X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2Ftypecheck%2FTcRnTypes.lhs;h=2bb80bcad1063cb586427991bd457c948c9926be;hp=ba1888dd97d7bf99e45831ce5096c43775c70ded;hb=311b1cdfc9b1c311cc53482c461c18cba8885b2a;hpb=bf40e268d916947786c56ec38db86190854a2d2c diff --git a/compiler/typecheck/TcRnTypes.lhs b/compiler/typecheck/TcRnTypes.lhs index ba1888d..2bb80bc 100644 --- a/compiler/typecheck/TcRnTypes.lhs +++ b/compiler/typecheck/TcRnTypes.lhs @@ -1,4 +1,5 @@ % +% (c) The University of Glasgow 2006 % (c) The GRASP Project, Glasgow University, 1992-2002 % \begin{code} @@ -41,39 +42,34 @@ module TcRnTypes( #include "HsVersions.h" -import HsSyn ( PendingSplice, HsOverLit, LRuleDecl, LForeignDecl, - ArithSeqInfo, DictBinds, LHsBinds, LImportDecl, HsGroup, - HsWrapper, IE ) -import HscTypes ( FixityEnv, - HscEnv, TypeEnv, TyThing, - GenAvailInfo(..), AvailInfo, HscSource(..), - availName, IsBootInterface, Deprecations ) -import Packages ( PackageId ) -import Type ( Type, pprTyThingCategory ) -import TcType ( TcTyVarSet, TcType, TcThetaType, SkolemInfo, - TcPredType, TcKind, tcCmpPred, tcCmpType, - tcCmpTypes, pprSkolInfo ) -import InstEnv ( Instance, InstEnv ) -import FamInstEnv ( FamInstEnv ) +import HsSyn hiding (LIE) +import HscTypes +import Packages +import Type +import TcType +import InstEnv +import FamInstEnv import IOEnv -import RdrName ( GlobalRdrEnv, LocalRdrEnv ) -import Name ( Name ) +import RdrName +import Name import NameEnv -import NameSet ( NameSet, unionNameSets, DefUses ) -import Var ( Id, TyVar ) -import VarEnv ( TidyEnv ) +import NameSet +import Var +import VarEnv import Module import UniqFM -import SrcLoc ( SrcSpan, SrcLoc, Located, srcSpanStart ) -import VarSet ( IdSet ) -import ErrUtils ( Messages, Message ) -import UniqSupply ( UniqSupply ) -import BasicTypes ( IPName ) -import Util ( thenCmp ) +import SrcLoc +import VarSet +import ErrUtils +import UniqSupply +import BasicTypes +import Util import Bag import Outputable -import Maybe ( mapMaybe ) -import ListSetOps ( unionLists ) +import ListSetOps + +import Data.Maybe +import Data.List \end{code} @@ -163,7 +159,7 @@ data TcGblEnv -- 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 :: NameSet, -- What is exported + tcg_exports :: [AvailInfo], -- What is exported tcg_imports :: ImportAvails, -- Information about what was imported -- from where, including things bound -- in this module @@ -223,11 +219,15 @@ data TcGblEnv tcg_rn_decls :: Maybe (HsGroup Name), -- renamed decls, maybe -- Nothing <=> Don't retain renamed decls - tcg_binds :: LHsBinds Id, -- Value bindings in this module - tcg_deprecs :: Deprecations, -- ...Deprecations - tcg_insts :: [Instance], -- ...Instances - tcg_rules :: [LRuleDecl Id], -- ...Rules - tcg_fords :: [LForeignDecl Id] -- ...Foreign import & exports + tcg_binds :: LHsBinds Id, -- Value bindings in this module + tcg_deprecs :: Deprecations, -- ...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 } \end{code} @@ -478,20 +478,21 @@ It is used * when processing the export list \begin{code} data ImportAvails = ImportAvails { - imp_env :: ModuleNameEnv NameSet, - -- All the things imported, classified by + imp_env :: ModuleNameEnv [AvailInfo], + -- All the things imported *unqualified*, classified by -- the *module qualifier* for its import -- e.g. import List as Foo -- would add a binding Foo |-> ...stuff from List... -- to imp_env. -- - -- We need to classify them like this so that we can figure out - -- "module M" export specifiers in an export list - -- (see 1.4 Report Section 5.1.1). Ultimately, we want to find - -- everything that is unambiguously in scope as 'M.x' - -- and where plain 'x' is (perhaps ambiguously) in scope. - -- So the starting point is all things that are in scope as 'M.x', - -- which is what this field tells us. + -- This is exactly the list of things that will be exported + -- by a 'module M' specifier in the export list. + -- (see Haskell 98 Report Section 5.2). + -- + -- Warning: there may be duplciates in this list, + -- duplicates are removed at the use site (rnExports). + -- We might consider turning this into a NameEnv at + -- some point. imp_mods :: ModuleEnv (Module, Bool, SrcSpan), -- Domain is all directly-imported modules @@ -506,6 +507,11 @@ data ImportAvails -- the interface file; if we import somethign we -- need to recompile if the export version changes -- (b) to specify what child modules to initialise + -- + -- We need a full ModuleEnv rather than a ModuleNameEnv + -- here, because we might be importing modules of the + -- same name from different packages. (currently not the case, + -- but might be in the future). imp_dep_mods :: ModuleNameEnv (ModuleName, IsBootInterface), -- Home-package modules needed by the module being compiled @@ -522,8 +528,19 @@ data ImportAvails -- directly, or via other modules in this package, or via -- modules imported from other packages. - imp_orphs :: [Module] - -- Orphan modules below us in the import tree + imp_orphs :: [Module], + -- Orphan modules below us in the import tree (and maybe + -- including us for imported modules) + + imp_finsts :: [Module], + -- Family instance modules below us in the import tree (and + -- maybe including us for imported modules) + + imp_parent :: NameEnv AvailInfo + -- for the names in scope in this module, tells us + -- the relationship between parents and children + -- (eg. a TyCon is the parent of its DataCons, a + -- class is the parent of its methods, etc.). } mkModDeps :: [(ModuleName, IsBootInterface)] @@ -537,20 +554,32 @@ emptyImportAvails = ImportAvails { imp_env = emptyUFM, imp_mods = emptyModuleEnv, imp_dep_mods = emptyUFM, imp_dep_pkgs = [], - imp_orphs = [] } + imp_orphs = [], + imp_finsts = [], + imp_parent = emptyNameEnv } plusImportAvails :: ImportAvails -> ImportAvails -> ImportAvails plusImportAvails (ImportAvails { imp_env = env1, imp_mods = mods1, - imp_dep_mods = dmods1, imp_dep_pkgs = dpkgs1, imp_orphs = orphs1 }) + imp_dep_mods = dmods1, imp_dep_pkgs = dpkgs1, + imp_orphs = orphs1, imp_finsts = finsts1, + imp_parent = parent1 }) (ImportAvails { imp_env = env2, imp_mods = mods2, - imp_dep_mods = dmods2, imp_dep_pkgs = dpkgs2, imp_orphs = orphs2 }) - = ImportAvails { imp_env = plusUFM_C unionNameSets env1 env2, + imp_dep_mods = dmods2, imp_dep_pkgs = dpkgs2, + imp_orphs = orphs2, imp_finsts = finsts2, + imp_parent = parent2 }) + = ImportAvails { imp_env = plusUFM_C (++) env1 env2, imp_mods = mods1 `plusModuleEnv` mods2, imp_dep_mods = plusUFM_C plus_mod_dep dmods1 dmods2, imp_dep_pkgs = dpkgs1 `unionLists` dpkgs2, - imp_orphs = orphs1 `unionLists` orphs2 } + imp_orphs = orphs1 `unionLists` orphs2, + imp_finsts = finsts1 `unionLists` finsts2, + imp_parent = plusNameEnv_C plus_avails parent1 parent2 } where + plus_avails (AvailTC tc subs1) (AvailTC _ subs2) + = AvailTC tc (nub (subs1 ++ subs2)) + plus_avails avail _ = avail + plus_mod_dep (m1, boot1) (m2, boot2) = WARN( not (m1 == m2), (ppr m1 <+> ppr m2) $$ (ppr boot1 <+> ppr boot2) ) -- Check mod-names match @@ -660,48 +689,52 @@ type Int, represented by \begin{code} data Inst - = Dict - Name - TcPredType - InstLoc - - | Method - Id - - TcId -- The overloaded function - -- This function will be a global, local, or ClassOpId; - -- inside instance decls (only) it can also be an InstId! - -- The id needn't be completely polymorphic. - -- You'll probably find its name (for documentation purposes) - -- inside the InstOrigin - - [TcType] -- The types to which its polymorphic tyvars - -- should be instantiated. - -- These types must saturate the Id's foralls. - - TcThetaType -- The (types of the) dictionaries to which the function - -- must be applied to get the method + = Dict { + tci_name :: Name, + tci_pred :: TcPredType, + tci_loc :: InstLoc + } - InstLoc + | Method { + tci_id :: TcId, -- The Id for the Inst - -- INVARIANT 1: in (Method u f tys theta tau loc) - -- type of (f tys dicts(from theta)) = tau + tci_oid :: TcId, -- The overloaded function + -- This function will be a global, local, or ClassOpId; + -- inside instance decls (only) it can also be an InstId! + -- The id needn't be completely polymorphic. + -- You'll probably find its name (for documentation purposes) + -- inside the InstOrigin - -- INVARIANT 2: tau must not be of form (Pred -> Tau) + tci_tys :: [TcType], -- The types to which its polymorphic tyvars + -- should be instantiated. + -- These types must saturate the Id's foralls. + + tci_theta :: TcThetaType, + -- The (types of the) dictionaries to which the function + -- must be applied to get the method + + tci_loc :: InstLoc + } + -- INVARIANT 1: in (Method m f tys theta tau loc) + -- type of m = type of (f tys dicts(from theta)) + + -- INVARIANT 2: type of m must not be of form (Pred -> Tau) -- 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 - Name - (HsOverLit Name) -- The literal from the occurrence site - -- INVARIANT: never a rebindable-syntax literal - -- Reason: tcSyntaxName does unification, and we - -- don't want to deal with that during tcSimplify, - -- when resolving LitInsts - TcType -- The type at which the literal is used - InstLoc + | LitInst { + tci_name :: Name, + tci_lit :: HsOverLit Name, -- The literal from the occurrence site + -- INVARIANT: never a rebindable-syntax literal + -- Reason: tcSyntaxName does unification, and we + -- don't want to deal with that during tcSimplify, + -- when resolving LitInsts + + tci_ty :: TcType, -- The type at which the literal is used + tci_loc :: InstLoc + } \end{code} @Insts@ are ordered by their class/type info, rather than by their @@ -717,16 +750,18 @@ instance Eq Inst where EQ -> True other -> False -cmpInst (Dict _ pred1 _) (Dict _ pred2 _) = pred1 `tcCmpPred` pred2 -cmpInst (Dict _ _ _) other = LT +cmpInst d1@(Dict {}) d2@(Dict {}) = tci_pred d1 `tcCmpPred` tci_pred d2 +cmpInst (Dict {}) other = LT -cmpInst (Method _ _ _ _ _) (Dict _ _ _) = GT -cmpInst (Method _ id1 tys1 _ _) (Method _ id2 tys2 _ _) = (id1 `compare` id2) `thenCmp` (tys1 `tcCmpTypes` tys2) -cmpInst (Method _ _ _ _ _) other = 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 (LitInst _ _ _ _) (Dict _ _ _) = GT -cmpInst (LitInst _ _ _ _) (Method _ _ _ _ _) = GT -cmpInst (LitInst _ lit1 ty1 _) (LitInst _ lit2 ty2 _) = (lit1 `compare` lit2) `thenCmp` (ty1 `tcCmpType` ty2) +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) \end{code} @@ -799,6 +834,7 @@ data InstOrigin | RecordUpdOrigin | InstScOrigin -- Typechecking superclasses of an instance declaration | DerivOrigin -- Typechecking deriving + | StandAloneDerivOrigin -- Typechecking stand-alone deriving | DefaultOrigin -- Typechecking a default decl | DoOrigin -- Arising from a do expression | ProcOrigin -- Arising from a proc expression @@ -820,6 +856,7 @@ pprInstLoc (InstLoc orig locn _) 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 StandAloneDerivOrigin = ptext SLIT("a 'deriving' 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")