X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2Ftypecheck%2FTcRnTypes.lhs;h=feaf9f949200cfc9799bb5cfb764e5354bf70632;hp=d11ee27d57b6773b8b52afd305b51a204bbce51a;hb=aafdba3bce91afb003f5f50e001e141744837bae;hpb=e12bd07bcadb0efb1da0b49801a4a43689ee508a diff --git a/compiler/typecheck/TcRnTypes.lhs b/compiler/typecheck/TcRnTypes.lhs index d11ee27..feaf9f9 100644 --- a/compiler/typecheck/TcRnTypes.lhs +++ b/compiler/typecheck/TcRnTypes.lhs @@ -1,8 +1,15 @@ -% + % (c) The University of Glasgow 2006 % (c) The GRASP Project, Glasgow University, 1992-2002 % \begin{code} +{-# OPTIONS -w #-} +-- The above warning supression flag is a temporary kludge. +-- While working on this module you are encouraged to remove it and fix +-- any warnings in the module. See +-- http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings +-- for details + module TcRnTypes( TcRnIf, TcRn, TcM, RnM, IfM, IfL, IfG, -- The monad is opaque outside this module TcRef, @@ -18,7 +25,7 @@ module TcRnTypes( WhereFrom(..), mkModDeps, -- Typechecker types - TcTyThing(..), pprTcTyThingCategory, + TcTyThing(..), pprTcTyThingCategory, RefinementVisibility(..), -- Template Haskell ThStage(..), topStage, topSpliceStage, @@ -34,7 +41,8 @@ module TcRnTypes( plusLIEs, mkLIE, isEmptyLIE, lieToList, listToLIE, -- Misc other types - TcId, TcIdSet, TcDictBinds + TcId, TcIdSet, TcDictBinds, + ) where #include "HsVersions.h" @@ -43,6 +51,7 @@ import HsSyn hiding (LIE) import HscTypes import Packages import Type +import Coercion import TcType import TcGadt import InstEnv @@ -65,6 +74,7 @@ import Util import Bag import Outputable import ListSetOps +import FiniteMap import Data.Maybe import Data.List @@ -115,8 +125,7 @@ data Env gbl lcl -- Changes as we move into an expression env_gbl :: gbl, -- Info about things defined at the top level -- of the module being compiled - env_lcl :: lcl -- Nested stuff; changes as we go into - -- an expression + env_lcl :: lcl -- Nested stuff; changes as we go into } -- TcGblEnv describes the top-level of the module at the @@ -143,7 +152,7 @@ data TcGblEnv -- (Ids defined in this module start in the local envt, -- though they move to the global envt during zonking) - tcg_type_env_var :: TcRef TypeEnv, + tcg_type_env_var :: TcRef TypeEnv, -- Used only to initialise the interface-file -- typechecker in initIfaceTcRn, so that it can see stuff -- bound in this module when dealing with hi-boot recursions @@ -316,15 +325,11 @@ data TcLclEnv -- Changes as we move inside an expression -- Maintained during renaming, of course, but also during -- type checking, solely so that when renaming a Template-Haskell -- splice we have the right environment for the renamer. - -- - -- Used only for names bound within a value binding (bound by - -- lambda, case, where, let etc), but *not* for top-level names. - -- - -- Does *not* include global name envt; may shadow it - -- Includes both ordinary variables and type variables; - -- they are kept distinct because tyvar have a different - -- occurrence contructor (Name.TvOcc) -- + -- Does *not* include global name envt; may shadow it + -- Includes both ordinary variables and type variables; + -- they are kept distinct because tyvar have a different + -- occurrence contructor (Name.TvOcc) -- We still need the unsullied global name env so that -- we can look up record field names @@ -364,7 +369,7 @@ type ThLevel = Int -- Incremented when going inside a bracket, -- decremented when going inside a splice -- NB: ThLevel is one greater than the 'n' in Fig 2 of the - -- original "Template meta-programmign for Haskell" paper + -- original "Template meta-programming for Haskell" paper impLevel, topLevel :: ThLevel topLevel = 1 -- Things defined at top level of this module @@ -435,7 +440,8 @@ data TcTyThing | ATcId { -- Ids defined in this module; may not be fully zonked tct_id :: TcId, - tct_co :: Maybe HsWrapper, -- Nothing <=> Do not apply a GADT type refinement + tct_co :: RefinementVisibility, -- Previously: Maybe HsWrapper + -- Nothing <=> Do not apply a GADT type refinement -- I am wobbly, or have no free -- type variables -- Just co <=> Apply any type refinement to me, @@ -450,8 +456,21 @@ data TcTyThing | AThing TcKind -- Used temporarily, during kind checking, for the -- tycons and clases in this recursive group +data RefinementVisibility + = Unrefineable -- Do not apply a GADT refinement + -- I have no free variables + + | Rigid HsWrapper -- Apply any refinement to me + -- and record it in the coercion + + | Wobbly -- Do not apply a GADT refinement + -- I am wobbly + + | WobblyInvisible -- Wobbly type, not available inside current + -- GADT refinement + instance Outputable TcTyThing where -- Debugging only - ppr (AGlobal g) = ppr g + ppr (AGlobal g) = pprTyThing g ppr elt@(ATcId {}) = text "Identifier" <> ifPprDebug (brackets (ppr (tct_id elt) <> dcolon <> ppr (tct_type elt) <> comma <+> ppr (tct_level elt) <+> ppr (tct_co elt))) @@ -463,6 +482,13 @@ pprTcTyThingCategory (AGlobal thing) = pprTyThingCategory thing pprTcTyThingCategory (ATyVar {}) = ptext SLIT("Type variable") pprTcTyThingCategory (ATcId {}) = ptext SLIT("Local identifier") pprTcTyThingCategory (AThing {}) = ptext SLIT("Kinded thing") + +instance Outputable RefinementVisibility where + ppr Unrefineable = ptext SLIT("unrefineable") + ppr (Rigid co) = ptext SLIT("rigid") <+> ppr co + ppr Wobbly = ptext SLIT("wobbly") + ppr WobblyInvisible = ptext SLIT("wobbly-invisible") + \end{code} \begin{code} @@ -605,6 +631,21 @@ type Int, represented by Method 34 doubleId [Int] origin +In addition to the basic Haskell variants of 'Inst's, they can now also +represent implication constraints 'forall tvs. (reft, given) => wanted' +and equality constraints 'co :: ty1 ~ ty2'. + +NB: Equalities occur in two flavours: + + (1) Dict {tci_pred = EqPred ty1 ty2} + (2) EqInst {tci_left = ty1, tci_right = ty2, tci_co = coe} + +The former arises from equalities in contexts, whereas the latter is used +whenever the type checker introduces an equality (e.g., during deferring +unification). + +I am not convinced that this duplication is necessary or useful! -=chak + \begin{code} data Inst = Dict { @@ -620,9 +661,9 @@ data Inst -- Includes coercion variables -- mentioned in tci_reft tci_reft :: Refinement, - tci_given :: [Inst], -- Only Dicts + tci_given :: [Inst], -- Only Dicts and EqInsts -- (no Methods, LitInsts, ImplicInsts) - tci_wanted :: [Inst], -- Only Dicts and ImplicInsts + tci_wanted :: [Inst], -- Only Dicts, EqInst, and ImplicInsts -- (no Methods or LitInsts) tci_loc :: InstLoc @@ -671,6 +712,32 @@ data Inst tci_ty :: TcType, -- The type at which the literal is used tci_loc :: InstLoc } + + | EqInst { -- delayed unification of the form + -- co :: ty1 ~ ty2 + tci_left :: TcType, -- ty1 -- both types are... + tci_right :: TcType, -- ty2 -- ...free of boxes + tci_co :: Either -- co + TcTyVar -- - a wanted equation, with a hole, to be + -- filled with a witness for the equality; + -- for equation arising from deferring + -- unification, 'ty1' is the actual and + -- 'ty2' the expected type + Coercion, -- - a given equation, with a coercion + -- witnessing the equality; + -- a coercion that originates from a + -- signature or a GADT is a CoVar, but + -- after normalisation of coercions, they + -- can be arbitrary Coercions involving + -- constructors and pseudo-constructors + -- like sym and trans. + tci_loc :: InstLoc, + + tci_name :: Name -- Debugging help only: this makes it easier to + -- follow where a constraint is used in a morass + -- of trace messages! Unlike other Insts, it has + -- no semantic significance whatsoever. + } \end{code} @Insts@ are ordered by their class/type info, rather than by their @@ -707,6 +774,14 @@ cmpInst (ImplicInst {}) (Dict {}) = GT cmpInst (ImplicInst {}) (Method {}) = GT cmpInst (ImplicInst {}) (LitInst {}) = GT cmpInst i1@(ImplicInst {}) i2@(ImplicInst {}) = tci_name i1 `compare` tci_name i2 +cmpInst (ImplicInst {}) other = LT + + -- same for Equality constraints +cmpInst (EqInst {}) (Dict {}) = GT +cmpInst (EqInst {}) (Method {}) = GT +cmpInst (EqInst {}) (LitInst {}) = GT +cmpInst (EqInst {}) (ImplicInst {}) = GT +cmpInst i1@(EqInst {}) i2@(EqInst {}) = tci_name i1 `compare` tci_name i2 \end{code} @@ -789,18 +864,23 @@ data InstOrigin -- The rest are all occurrences: Insts that are 'wanted' ------------------------------------------------------- | OccurrenceOf Name -- Occurrence of an overloaded identifier + | SpecPragOrigin Name -- Specialisation pragma for identifier | IPOccOrigin (IPName Name) -- Occurrence of an implicit parameter | LiteralOrigin (HsOverLit Name) -- Occurrence of a literal + | NegateOrigin -- Occurrence of syntactic negation | ArithSeqOrigin (ArithSeqInfo Name) -- [x..], [x..y] etc | PArrSeqOrigin (ArithSeqInfo Name) -- [:x..y:] and [:x,y..z:] + | TupleOrigin -- (..,..) | InstSigOrigin -- A dict occurrence arising from instantiating -- a polymorphic type during a subsumption check + | ExprSigOrigin -- e :: ty | RecordUpdOrigin + | ViewPatOrigin | InstScOrigin -- Typechecking superclasses of an instance declaration | DerivOrigin -- Typechecking deriving | StandAloneDerivOrigin -- Typechecking stand-alone deriving @@ -808,16 +888,21 @@ data InstOrigin | DoOrigin -- Arising from a do expression | ProcOrigin -- Arising from a proc expression | ImplicOrigin SDoc -- An implication constraint + | EqOrigin -- A type equality instance Outputable InstOrigin where ppr (OccurrenceOf name) = hsep [ptext SLIT("a use of"), quotes (ppr name)] + ppr (SpecPragOrigin name) = hsep [ptext SLIT("a specialisation pragma for"), quotes (ppr name)] ppr (IPOccOrigin name) = hsep [ptext SLIT("a use of implicit parameter"), quotes (ppr name)] ppr (IPBindOrigin name) = hsep [ptext SLIT("a binding for implicit parameter"), quotes (ppr name)] ppr RecordUpdOrigin = ptext SLIT("a record update") + ppr ExprSigOrigin = ptext SLIT("an expression type signature") + ppr ViewPatOrigin = ptext SLIT("a view pattern") ppr (LiteralOrigin lit) = hsep [ptext SLIT("the literal"), quotes (ppr lit)] ppr (ArithSeqOrigin seq) = hsep [ptext SLIT("the arithmetic sequence"), quotes (ppr seq)] ppr (PArrSeqOrigin seq) = hsep [ptext SLIT("the parallel array sequence"), quotes (ppr seq)] - ppr InstSigOrigin = ptext SLIT("instantiating a type signature") + ppr TupleOrigin = ptext SLIT("a tuple") + ppr NegateOrigin = ptext SLIT("a use of syntactic negation") ppr InstScOrigin = ptext SLIT("the superclasses of an instance declaration") ppr DerivOrigin = ptext SLIT("the 'deriving' clause of a data type declaration") ppr StandAloneDerivOrigin = ptext SLIT("a 'deriving' declaration") @@ -826,4 +911,5 @@ instance Outputable InstOrigin where ppr ProcOrigin = ptext SLIT("a proc expression") ppr (ImplicOrigin doc) = doc ppr (SigOrigin info) = pprSkolInfo info + ppr EqOrigin = ptext SLIT("a type equality") \end{code}