X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2Ftypecheck%2FTcRnTypes.lhs;h=ebf410169c8c29c8aaf0769d01fc768125bb9cd1;hp=b624a14a65340487d8efe04139b06df2b0f73a7e;hb=7539ed8cade66d09fae1e0ccc66c519cafa3b55b;hpb=ecd655aaaa4ae495933415ad1ff6f6132ff3967f diff --git a/compiler/typecheck/TcRnTypes.lhs b/compiler/typecheck/TcRnTypes.lhs index b624a14..ebf4101 100644 --- a/compiler/typecheck/TcRnTypes.lhs +++ b/compiler/typecheck/TcRnTypes.lhs @@ -1,4 +1,4 @@ -% + % (c) The University of Glasgow 2006 % (c) The GRASP Project, Glasgow University, 1992-2002 % @@ -13,12 +13,12 @@ module TcRnTypes( IfGblEnv(..), IfLclEnv(..), -- Ranamer types - ErrCtxt, + ErrCtxt, RecFieldEnv, ImportAvails(..), emptyImportAvails, plusImportAvails, WhereFrom(..), mkModDeps, -- Typechecker types - TcTyThing(..), pprTcTyThingCategory, + TcTyThing(..), pprTcTyThingCategory, RefinementVisibility(..), -- Template Haskell ThStage(..), topStage, topSpliceStage, @@ -34,17 +34,17 @@ module TcRnTypes( plusLIEs, mkLIE, isEmptyLIE, lieToList, listToLIE, -- Misc other types - TcId, TcIdSet, TcDictBinds + TcId, TcIdSet, TcDictBinds, + ) where #include "HsVersions.h" import HsSyn hiding (LIE) import HscTypes -import Packages import Type +import Coercion import TcType -import TcGadt import InstEnv import FamInstEnv import IOEnv @@ -55,7 +55,7 @@ import NameSet import Var import VarEnv import Module -import UniqFM +import LazyUniqFM import SrcLoc import VarSet import ErrUtils @@ -65,6 +65,7 @@ import Util import Bag import Outputable import ListSetOps +import FastString import Data.Maybe import Data.List @@ -115,8 +116,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 @@ -133,7 +133,8 @@ data TcGblEnv tcg_default :: Maybe [Type], -- Types used for defaulting -- Nothing => no 'default' decl - tcg_fix_env :: FixityEnv, -- Just for things in this module + tcg_fix_env :: FixityEnv, -- Just for things in this module + tcg_field_env :: RecFieldEnv, -- Just for things in this module tcg_type_env :: TypeEnv, -- Global type env for the module we are compiling now -- All TyCons and Classes (for this module) end up in here right away, @@ -142,7 +143,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 @@ -218,15 +219,24 @@ data TcGblEnv -- Nothing <=> Don't retain renamed decls tcg_binds :: LHsBinds Id, -- Value bindings in this module - tcg_deprecs :: Deprecations, -- ...Deprecations + tcg_warns :: Warnings, -- ...Warnings and deprecations tcg_insts :: [Instance], -- ...Instances tcg_fam_insts :: [FamInst], -- ...Family instances tcg_rules :: [LRuleDecl Id], -- ...Rules tcg_fords :: [LForeignDecl Id], -- ...Foreign import & exports tcg_doc :: Maybe (HsDoc Name), -- Maybe Haddock documentation - tcg_hmi :: HaddockModInfo Name -- Haddock module information + tcg_hmi :: HaddockModInfo Name, -- Haddock module information + tcg_hpc :: AnyHpcUsage -- True if any part of the prog uses hpc instrumentation. } + +type RecFieldEnv = NameEnv [Name] -- Maps a constructor name *in this module* + -- to the fields for that constructor + -- This is used when dealing with ".." notation in record + -- construction and pattern matching. + -- The FieldEnv deals *only* with constructors defined in *thie* + -- module. For imported modules, we get the same info from the + -- TypeEnv \end{code} %************************************************************************ @@ -299,8 +309,8 @@ data TcLclEnv -- Changes as we move inside an expression tcl_ctxt :: ErrCtxt, -- Error context tcl_errs :: TcRef Messages, -- Place to accumulate errors - tcl_th_ctxt :: ThStage, -- Template Haskell context - tcl_arrow_ctxt :: ArrowCtxt, -- Arrow-notation context + tcl_th_ctxt :: ThStage, -- Template Haskell context + tcl_arrow_ctxt :: ArrowCtxt, -- Arrow-notation context tcl_rdr :: LocalRdrEnv, -- Local name envt -- Maintained during renaming, of course, but also during @@ -350,7 +360,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 @@ -421,7 +431,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, @@ -436,8 +447,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))) @@ -446,9 +470,16 @@ instance Outputable TcTyThing where -- Debugging only pprTcTyThingCategory :: TcTyThing -> SDoc pprTcTyThingCategory (AGlobal thing) = pprTyThingCategory thing -pprTcTyThingCategory (ATyVar {}) = ptext SLIT("Type variable") -pprTcTyThingCategory (ATcId {}) = ptext SLIT("Local identifier") -pprTcTyThingCategory (AThing {}) = ptext SLIT("Kinded 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} @@ -477,14 +508,15 @@ It is used * when processing the export list \begin{code} data ImportAvails = ImportAvails { - imp_mods :: ModuleEnv (Module, Bool, SrcSpan), + imp_mods :: ModuleEnv [(ModuleName, Bool, SrcSpan)], -- Domain is all directly-imported modules + -- The ModuleName is what the module was imported as, e.g. in + -- import Foo as Bar + -- it is Bar. -- Bool means: -- True => import was "import Foo ()" -- False => import was some other form -- - -- We need the Module in the range because we can't get - -- the keys of a ModuleEnv -- Used -- (a) to help construct the usage information in -- the interface file; if we import somethign we @@ -541,7 +573,7 @@ plusImportAvails (ImportAvails { imp_mods = mods2, imp_dep_mods = dmods2, imp_dep_pkgs = dpkgs2, imp_orphs = orphs2, imp_finsts = finsts2 }) - = ImportAvails { imp_mods = mods1 `plusModuleEnv` mods2, + = ImportAvails { imp_mods = plusModuleEnv_C (++) mods1 mods2, imp_dep_mods = plusUFM_C plus_mod_dep dmods1 dmods2, imp_dep_pkgs = dpkgs1 `unionLists` dpkgs2, imp_orphs = orphs1 `unionLists` orphs2, @@ -567,9 +599,9 @@ data WhereFrom | ImportBySystem -- Non user import. instance Outputable WhereFrom where - ppr (ImportByUser is_boot) | is_boot = ptext SLIT("{- SOURCE -}") + ppr (ImportByUser is_boot) | is_boot = ptext (sLit "{- SOURCE -}") | otherwise = empty - ppr ImportBySystem = ptext SLIT("{- SYSTEM -}") + ppr ImportBySystem = ptext (sLit "{- SYSTEM -}") \end{code} @@ -587,6 +619,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. 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 { @@ -596,17 +643,17 @@ data Inst } | ImplicInst { -- An implication constraint - -- forall tvs. (reft, given) => wanted + -- forall tvs. given => wanted tci_name :: Name, - tci_tyvars :: [TcTyVar], -- Includes coercion variables - -- mentioned in tci_reft - tci_reft :: Refinement, - tci_given :: [Inst], -- Only Dicts + tci_tyvars :: [TcTyVar], -- Quantified type variables + 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 } + -- NB: the tci_given are not necessarily rigid | Method { tci_id :: TcId, -- The Id for the Inst @@ -648,6 +695,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 @@ -657,26 +730,28 @@ than with the Avails handling stuff in TcSimplify \begin{code} instance Ord Inst where - compare = cmpInst + compare = cmpInst + -- Used *only* for AvailEnv in TcSimplify instance Eq Inst where (==) i1 i2 = case i1 `cmpInst` i2 of - EQ -> True - other -> False + EQ -> True + _ -> False +cmpInst :: Inst -> Inst -> Ordering cmpInst d1@(Dict {}) d2@(Dict {}) = tci_pred d1 `tcCmpPred` tci_pred d2 -cmpInst (Dict {}) other = LT +cmpInst (Dict {}) _ = LT cmpInst (Method {}) (Dict {}) = GT cmpInst m1@(Method {}) m2@(Method {}) = (tci_oid m1 `compare` tci_oid m2) `thenCmp` (tci_tys m1 `tcCmpTypes` tci_tys m2) -cmpInst (Method {}) other = LT +cmpInst (Method {}) _ = LT cmpInst (LitInst {}) (Dict {}) = GT cmpInst (LitInst {}) (Method {}) = GT cmpInst l1@(LitInst {}) l2@(LitInst {}) = (tci_lit l1 `compare` tci_lit l2) `thenCmp` (tci_ty l1 `tcCmpType` tci_ty l2) -cmpInst (LitInst {}) other = LT +cmpInst (LitInst {}) _ = LT -- Implication constraints are compared by *name* -- not by type; that is, we make no attempt to do CSE on them @@ -684,6 +759,15 @@ 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 {}) _ = 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_left i1 `tcCmpType` tci_left i2) `thenCmp` + (tci_right i1 `tcCmpType` tci_right i2) \end{code} @@ -697,15 +781,31 @@ cmpInst i1@(ImplicInst {}) i2@(ImplicInst {}) = tci_name i1 `compare` tci_name i -- FIXME: Rename this. It clashes with (Located (IE ...)) type LIE = Bag Inst -isEmptyLIE = isEmptyBag -emptyLIE = emptyBag -unitLIE inst = unitBag inst -mkLIE insts = listToBag insts +isEmptyLIE :: LIE -> Bool +isEmptyLIE = isEmptyBag + +emptyLIE :: LIE +emptyLIE = emptyBag + +unitLIE :: Inst -> LIE +unitLIE inst = unitBag inst + +mkLIE :: [Inst] -> LIE +mkLIE insts = listToBag insts + +plusLIE :: LIE -> LIE -> LIE plusLIE lie1 lie2 = lie1 `unionBags` lie2 -plusLIEs lies = unionManyBags lies -lieToList = bagToList -listToLIE = listToBag +plusLIEs :: [LIE] -> LIE +plusLIEs lies = unionManyBags lies + +lieToList :: LIE -> [Inst] +lieToList = bagToList + +listToLIE :: [Inst] -> LIE +listToLIE = listToBag + +consLIE :: Inst -> LIE -> LIE consLIE inst lie = lie `snocBag` inst -- Putting the new Inst at the *end* of the bag is a half-hearted attempt -- to ensure that we tend to report the *leftmost* type-constraint error @@ -749,7 +849,7 @@ instLocOrigin :: InstLoc -> InstOrigin instLocOrigin (InstLoc o _ _) = o pprInstArising :: Inst -> SDoc -pprInstArising loc = ptext SLIT("arising from") <+> pprInstLoc (tci_loc loc) +pprInstArising loc = ptext (sLit "arising from") <+> pprInstLoc (tci_loc loc) pprInstLoc :: InstLoc -> SDoc pprInstLoc (InstLoc orig span _) = sep [ppr orig, text "at" <+> ppr span] @@ -766,18 +866,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 @@ -785,22 +890,29 @@ 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 (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 (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 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") - ppr DefaultOrigin = ptext SLIT("a 'default' declaration") - ppr DoOrigin = ptext SLIT("a do statement") - ppr ProcOrigin = ptext SLIT("a proc expression") + 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 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") + ppr DefaultOrigin = ptext (sLit "a 'default' declaration") + ppr DoOrigin = ptext (sLit "a do statement") + ppr ProcOrigin = ptext (sLit "a proc expression") ppr (ImplicOrigin doc) = doc ppr (SigOrigin info) = pprSkolInfo info + ppr EqOrigin = ptext (sLit "a type equality") + ppr InstSigOrigin = panic "ppr InstSigOrigin" \end{code}