X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftypecheck%2FTcRnTypes.lhs;h=055a2dd185f642ddbcff1b0069ba389537f8cf5d;hb=ef5b4b146aa172d8ac10f39b5eb3d7a0f948d8f1;hp=9237f8b624e7b9212aaa200b0b0315de10e13b3c;hpb=f714e6b642fd614a9971717045ae47c3d871275e;p=ghc-hetmet.git diff --git a/ghc/compiler/typecheck/TcRnTypes.lhs b/ghc/compiler/typecheck/TcRnTypes.lhs index 9237f8b..055a2dd 100644 --- a/ghc/compiler/typecheck/TcRnTypes.lhs +++ b/ghc/compiler/typecheck/TcRnTypes.lhs @@ -20,7 +20,7 @@ module TcRnTypes( WhereFrom(..), mkModDeps, -- Typechecker types - TcTyThing(..), + TcTyThing(..), GadtRefinement, -- Template Haskell ThStage(..), topStage, topSpliceStage, @@ -36,19 +36,20 @@ module TcRnTypes( plusLIEs, mkLIE, isEmptyLIE, lieToList, listToLIE, -- Misc other types - TcId, TcIdSet + TcId, TcIdSet, TcDictBinds ) where #include "HsVersions.h" -import HsSyn ( PendingSplice, HsOverLit, LHsBind, LRuleDecl, LForeignDecl, - Pat, ArithSeqInfo ) +import HsSyn ( PendingSplice, HsOverLit, LRuleDecl, LForeignDecl, + ArithSeqInfo, DictBinds, LHsBinds ) import HscTypes ( FixityEnv, HscEnv, TypeEnv, TyThing, - Avails, GenAvailInfo(..), AvailInfo, + GenAvailInfo(..), AvailInfo, availName, IsBootInterface, Deprecations ) -import Packages ( PackageName ) -import TcType ( TcTyVarSet, TcType, TcTauType, TcThetaType, +import Packages ( PackageId ) +import Type ( Type, TvSubstEnv ) +import TcType ( TcTyVarSet, TcType, TcTauType, TcThetaType, SkolemInfo, TcPredType, TcKind, tcCmpPred, tcCmpType, tcCmpTypes ) import InstEnv ( DFunId, InstEnv ) import IOEnv @@ -57,8 +58,6 @@ import Name ( Name ) import NameEnv import NameSet ( NameSet, emptyNameSet, DefUses ) import OccName ( OccEnv ) -import Type ( Type ) -import Class ( Class ) import Var ( Id, TyVar ) import VarEnv ( TidyEnv ) import Module @@ -85,9 +84,12 @@ import ListSetOps ( unionLists ) The monad itself has to be defined here, because it is mentioned by ErrCtxt \begin{code} -type TcRef a = IORef a -type TcId = Id -- Type may be a TcType -type TcIdSet = IdSet +type TcRef a = IORef a +type TcId = Id -- Type may be a TcType +type TcIdSet = IdSet +type TcDictBinds = DictBinds TcId -- Bag of dictionary bindings + + type TcRnIf a b c = IOEnv (Env a b) c type IfM lcl a = TcRnIf IfGblEnv lcl a -- Iface stuff @@ -109,14 +111,14 @@ type TcM a = TcRn a -- Historical data Env gbl lcl -- Changes as we move into an expression = Env { env_top :: HscEnv, -- Top-level stuff that never changes - -- Includes all info about imported things + -- Includes all info about imported things env_us :: TcRef UniqSupply, -- Unique supply for local varibles env_gbl :: gbl, -- Info about things defined at the top level - -- of the module being compiled + -- of the module being compiled - env_lcl :: lcl -- Nested stuff -- changes as we go into + env_lcl :: lcl -- Nested stuff; changes as we go into -- an expression } @@ -148,22 +150,14 @@ data TcGblEnv tcg_inst_env :: InstEnv, -- Instance envt for *home-package* modules -- Includes the dfuns in tcg_insts - tcg_inst_uses :: TcRef NameSet, -- Home-package Dfuns actually used - -- Used to generate version dependencies - -- This records usages, rather like tcg_dus, but it has to - -- be a mutable variable so it can be augmented - -- when we look up an instance. These uses of dfuns are - -- rather like the free variables of the program, but - -- are implicit instead of explicit. - -- Now a bunch of things about this module that are simply -- accumulated, but never consulted until the end. -- Nevertheless, it's convenient to accumulate them along -- with the rest of the info from this module. - tcg_exports :: Avails, -- What is exported - tcg_imports :: ImportAvails, -- Information about what was imported - -- from where, including things bound - -- in this module + tcg_exports :: NameSet, -- What is exported + tcg_imports :: ImportAvails, -- Information about what was imported + -- from where, including things bound + -- in this module tcg_dus :: DefUses, -- What is defined in this module and what is used. -- The latter is used to generate @@ -171,16 +165,38 @@ data TcGblEnv -- things have not changed version stamp -- (b) unused-import info - tcg_keep :: NameSet, -- Set of names to keep alive, and to expose in the - -- interface file (but not to export to the user). - -- These are typically extra definitions generated from - -- data type declarations which would otherwise be - -- dropped as dead code. + tcg_keep :: TcRef NameSet, -- Locally-defined top-level names to keep alive + -- "Keep alive" means give them an Exported flag, so + -- that the simplifier does not discard them as dead + -- code, and so that they are exposed in the interface file + -- (but not to export to the user). + -- + -- Some things, like dict-fun Ids and default-method Ids are + -- "born" with the Exported flag on, for exactly the above reason, + -- but some we only discover as we go. Specifically: + -- * The to/from functions for generic data types + -- * Top-level variables appearing free in the RHS of an orphan rule + -- * Top-level variables appearing free in a TH bracket + + tcg_inst_uses :: TcRef NameSet, -- Home-package Dfuns actually used + -- Used to generate version dependencies + -- This records usages, rather like tcg_dus, but it has to + -- be a mutable variable so it can be augmented + -- when we look up an instance. These uses of dfuns are + -- rather like the free variables of the program, but + -- are implicit instead of explicit. + + tcg_th_used :: TcRef Bool, -- True <=> Template Haskell syntax used + -- We need this so that we can generate a dependency on the + -- Template Haskell package, becuase the desugarer is going to + -- emit loads of references to TH symbols. It's rather like + -- tcg_inst_uses; the reference is implicit rather than explicit, + -- so we have to zap a mutable variable. -- The next fields accumulate the payload of the module -- The binds, rules and foreign-decl fiels are collected -- initially in un-zonked form and are finally zonked in tcRnSrcDecls - tcg_binds :: Bag (LHsBind Id), -- Value bindings in this module + tcg_binds :: LHsBinds Id, -- Value bindings in this module tcg_deprecs :: Deprecations, -- ...Deprecations tcg_insts :: [DFunId], -- ...Instances tcg_rules :: [LRuleDecl Id], -- ...Rules @@ -203,17 +219,10 @@ data IfGblEnv -- was originally a hi-boot file. -- We need the module name so we can test when it's appropriate -- to look in this env. - if_rec_types :: Maybe (Module, IfG TypeEnv), + if_rec_types :: Maybe (Module, IfG TypeEnv) -- Allows a read effect, so it can be in a mutable -- variable; c.f. handling the external package type env -- Nothing => interactive stuff, no loops possible - - if_is_boot :: ModuleEnv (ModuleName, IsBootInterface) - -- Tells what we know about boot interface files - -- When we're importing a module we know absolutely - -- nothing about, so we assume it's from - -- another package, where we aren't doing - -- dependency tracking. So it won't be a hi-boot file. } data IfLclEnv @@ -221,7 +230,7 @@ data IfLclEnv -- The module for the current IfaceDecl -- So if we see f = \x -> x -- it means M.f = \x -> x, where M is the if_mod - if_mod :: ModuleName, + if_mod :: Module, if_tv_env :: OccEnv TyVar, -- Nested tyvar bindings if_id_env :: OccEnv Id -- Nested id binding @@ -273,22 +282,58 @@ data TcLclEnv -- Changes as we move inside an expression -- We still need the unsullied global name env so that -- we can look up record field names - tcl_env :: NameEnv TcTyThing, -- The local type environment: Ids and TyVars - -- defined in this module + tcl_env :: NameEnv TcTyThing, -- The local type environment: Ids and TyVars + -- defined in this module tcl_tyvars :: TcRef TcTyVarSet, -- The "global tyvars" - -- Namely, the in-scope TyVars bound in tcl_lenv, + -- Namely, the in-scope TyVars bound in tcl_env, -- plus the tyvars mentioned in the types of Ids bound in tcl_lenv -- Why mutable? see notes with tcGetGlobalTyVars - tcl_lie :: TcRef LIE -- Place to accumulate type constraints + tcl_lie :: TcRef LIE, -- Place to accumulate type constraints + tcl_gadt :: GadtRefinement -- The current type refinement for GADTs + +----------------------------------------------------------- +-- Not yet; it's a new complication and I want to see whether it bites +-- tcl_given :: [Inst] -- Insts available in the current context (see Note [Given Insts]) +----------------------------------------------------------- } +type GadtRefinement = TvSubstEnv -- Binds rigid type variables to their refinements + +{- Note [Given Insts] + ~~~~~~~~~~~~~~~~~~ +Because of GADTs, we have to pass inwards the Insts provided by type signatures +and existential contexts. Consider + data T a where { T1 :: b -> b -> T [b] } + f :: Eq a => T a -> Bool + f (T1 x y) = [x]==[y] + +The constructor T1 binds an existential variable 'b', and we need Eq [b]. +Well, we have it, because Eq a refines to Eq [b], but we can only spot that if we +pass it inwards. + +-} + --------------------------- -- Template Haskell levels --------------------------- -type ThLevel = Int -- Always >= 0 +type ThLevel = Int + -- Indicates how many levels of brackets we are inside + -- (always >= 0) + -- Incremented when going inside a bracket, + -- decremented when going inside a splice + +impLevel, topLevel :: ThLevel +topLevel = 1 -- Things defined at top level of this module +impLevel = 0 -- Imported things; they can be used inside a top level splice +-- +-- For example: +-- f = ... +-- g1 = $(map ...) is OK +-- g2 = $(f ...) is not OK; because we havn't compiled f yet + data ThStage = Comp -- Ordinary compiling, at level topLevel @@ -301,16 +346,6 @@ topStage = Comp topSpliceStage = Splice (topLevel - 1) -- Stage for the body of a top-level splice -impLevel, topLevel :: ThLevel -topLevel = 1 -- Things defined at top level of this module -impLevel = 0 -- Imported things; they can be used inside a top level splice --- --- For example: --- f = ... --- g1 = $(map ...) is OK --- g2 = $(f ...) is not OK; because we havn't compiled f yet - - --------------------------- -- Arrow-notation stages --------------------------- @@ -436,7 +471,7 @@ data ImportAvails -- combine stuff coming from different (unqualified) -- imports of the same module - imp_mods :: ModuleEnv (Module, Maybe Bool), + imp_mods :: ModuleEnv (Module, Maybe Bool, SrcSpan), -- Domain is all directly-imported modules -- Maybe value answers the question "is the import restricted?" -- Nothing => unrestricted import (e.g., "import Foo") @@ -454,29 +489,30 @@ data ImportAvails -- need to recompile if the module version changes -- (b) to specify what child modules to initialise - imp_dep_mods :: ModuleEnv (ModuleName, IsBootInterface), + imp_dep_mods :: ModuleEnv (Module, IsBootInterface), -- Home-package modules needed by the module being compiled -- - -- It doesn't matter whether any of these dependencies are actually - -- *used* when compiling the module; they are listed if they are below - -- it at all. For example, suppose M imports A which imports X. Then - -- compiling M might not need to consult X.hi, but X is still listed - -- in M's dependencies. - - imp_dep_pkgs :: [PackageName], + -- It doesn't matter whether any of these dependencies + -- are actually *used* when compiling the module; they + -- are listed if they are below it at all. For + -- example, suppose M imports A which imports X. Then + -- compiling M might not need to consult X.hi, but X + -- is still listed in M's dependencies. + + imp_dep_pkgs :: [PackageId], -- Packages needed by the module being compiled, whether -- directly, or via other modules in this package, or via -- modules imported from other packages. - imp_orphs :: [ModuleName] + imp_orphs :: [Module] -- Orphan modules below us in the import tree } -mkModDeps :: [(ModuleName, IsBootInterface)] - -> ModuleEnv (ModuleName, IsBootInterface) +mkModDeps :: [(Module, IsBootInterface)] + -> ModuleEnv (Module, IsBootInterface) mkModDeps deps = foldl add emptyModuleEnv deps where - add env elt@(m,_) = extendModuleEnvByName env m elt + add env elt@(m,_) = extendModuleEnv env m elt emptyImportAvails :: ImportAvails emptyImportAvails = ImportAvails { imp_env = emptyAvailEnv, @@ -609,7 +645,7 @@ type Int, represented by \begin{code} data Inst = Dict - Id + Name TcPredType InstLoc @@ -638,13 +674,13 @@ data Inst -- type of (f tys dicts(from theta)) = tau -- INVARIANT 2: tau must not be of form (Pred -> Tau) - -- Reason: two methods are considerd equal if the + -- Reason: two methods are considered equal if the -- base Id matches, and the instantiating types -- match. The TcThetaType should then match too. -- This only bites in the call to tcInstClassOp in TcClassDcl.mkMethodBind | LitInst - Id + Name HsOverLit -- The literal from the occurrence site -- INVARIANT: never a rebindable-syntax literal -- Reason: tcSyntaxName does unification, and we @@ -723,91 +759,54 @@ instLocSrcSpan :: InstLoc -> SrcSpan instLocSrcSpan (InstLoc _ src_span _) = src_span data InstOrigin - = OccurrenceOf Name -- Occurrence of an overloaded identifier + = SigOrigin SkolemInfo -- Pattern, class decl, inst decl etc; + -- Places that bind type variables and introduce + -- available constraints - | IPOccOrigin (IPName Name) -- Occurrence of an implicit parameter | IPBindOrigin (IPName Name) -- Binding site of an implicit parameter - | RecordUpdOrigin - - | DataDeclOrigin -- Typechecking a data declaration + ------------------------------------------------------- + -- The rest are all occurrences: Insts that are 'wanted' + ------------------------------------------------------- + | OccurrenceOf Name -- Occurrence of an overloaded identifier - | InstanceDeclOrigin -- Typechecking an instance decl + | IPOccOrigin (IPName Name) -- Occurrence of an implicit parameter | LiteralOrigin HsOverLit -- Occurrence of a literal - | PatOrigin (Pat Name) - | ArithSeqOrigin (ArithSeqInfo Name) -- [x..], [x..y] etc | PArrSeqOrigin (ArithSeqInfo Name) -- [:x..y:] and [:x,y..z:] - | SignatureOrigin -- A dict created from a type signature - | Rank2Origin -- A dict created when typechecking the argument - -- of a rank-2 typed function + | InstSigOrigin -- A dict occurrence arising from instantiating + -- a polymorphic type during a subsumption check - | DoOrigin -- The monad for a do expression - | ProcOrigin -- A proc expression - - | ClassDeclOrigin -- Manufactured during a class decl - - | InstanceSpecOrigin Class -- in a SPECIALIZE instance pragma - Type - - -- When specialising instances the instance info attached to - -- each class is not yet ready, so we record it inside the - -- origin information. This is a bit of a hack, but it works - -- fine. (Patrick is to blame [WDP].) - - | ValSpecOrigin Name -- in a SPECIALIZE pragma for a value - - -- Argument or result of a ccall - -- Dictionaries with this origin aren't actually mentioned in the - -- translated term, and so need not be bound. Nor should they - -- be abstracted over. - - | UnknownOrigin -- Help! I give up... + | RecordUpdOrigin + | InstScOrigin -- Typechecking superclasses of an instance declaration + | DerivOrigin -- Typechecking deriving + | DefaultOrigin -- Typechecking a default decl + | DoOrigin -- Arising from a do expression + | ProcOrigin -- Arising from a proc expression \end{code} \begin{code} pprInstLoc :: InstLoc -> SDoc -pprInstLoc (InstLoc orig locn ctxt) +pprInstLoc (InstLoc (SigOrigin info) locn _) + = text "arising from" <+> ppr info -- I don't think this happens much, if at all +pprInstLoc (InstLoc orig locn _) = hsep [text "arising from", pp_orig orig, text "at", ppr locn] where - pp_orig (OccurrenceOf name) - = hsep [ptext SLIT("use of"), quotes (ppr name)] - pp_orig (IPOccOrigin name) - = hsep [ptext SLIT("use of implicit parameter"), quotes (ppr name)] - pp_orig (IPBindOrigin name) - = hsep [ptext SLIT("binding for implicit parameter"), quotes (ppr name)] - pp_orig RecordUpdOrigin - = ptext SLIT("a record update") - pp_orig DataDeclOrigin - = ptext SLIT("the data type declaration") - pp_orig InstanceDeclOrigin - = ptext SLIT("the instance declaration") - pp_orig (LiteralOrigin lit) - = hsep [ptext SLIT("the literal"), quotes (ppr lit)] - pp_orig (PatOrigin pat) - = hsep [ptext SLIT("the pattern"), quotes (ppr pat)] - pp_orig (ArithSeqOrigin seq) - = hsep [ptext SLIT("the arithmetic sequence"), quotes (ppr seq)] - pp_orig (PArrSeqOrigin seq) - = hsep [ptext SLIT("the parallel array sequence"), quotes (ppr seq)] - pp_orig (SignatureOrigin) - = ptext SLIT("a type signature") - pp_orig (Rank2Origin) - = ptext SLIT("a function with an overloaded argument type") - pp_orig (DoOrigin) - = ptext SLIT("a do statement") - pp_orig (ProcOrigin) - = ptext SLIT("a proc expression") - pp_orig (ClassDeclOrigin) - = ptext SLIT("a class declaration") - pp_orig (InstanceSpecOrigin clas ty) - = hsep [text "a SPECIALIZE instance pragma; class", - quotes (ppr clas), text "type:", ppr ty] - pp_orig (ValSpecOrigin name) - = hsep [ptext SLIT("a SPECIALIZE user-pragma for"), quotes (ppr name)] - pp_orig (UnknownOrigin) - = ptext SLIT("...oops -- I don't know where the overloading came from!") + pp_orig (OccurrenceOf name) = hsep [ptext SLIT("use of"), quotes (ppr name)] + pp_orig (IPOccOrigin name) = hsep [ptext SLIT("use of implicit parameter"), quotes (ppr name)] + pp_orig (IPBindOrigin name) = hsep [ptext SLIT("binding for implicit parameter"), quotes (ppr name)] + pp_orig RecordUpdOrigin = ptext SLIT("a record update") + pp_orig (LiteralOrigin lit) = hsep [ptext SLIT("the literal"), quotes (ppr lit)] + pp_orig (ArithSeqOrigin seq) = hsep [ptext SLIT("the arithmetic sequence"), quotes (ppr seq)] + pp_orig (PArrSeqOrigin seq) = hsep [ptext SLIT("the parallel array sequence"), quotes (ppr seq)] + pp_orig InstSigOrigin = ptext SLIT("instantiating a type signature") + pp_orig InstScOrigin = ptext SLIT("the superclasses of an instance declaration") + pp_orig DerivOrigin = ptext SLIT("the 'deriving' clause of a data type declaration") + pp_orig DefaultOrigin = ptext SLIT("a 'default' declaration") + pp_orig DoOrigin = ptext SLIT("a do statement") + pp_orig ProcOrigin = ptext SLIT("a proc expression") + pp_orig (SigOrigin info) = ppr info \end{code}