%
+% (c) The University of Glasgow 2006
% (c) The GRASP Project, Glasgow University, 1992-2002
%
\begin{code}
#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}
-- 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
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}
\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
-- 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
-- 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)]
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
\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
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}
| 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
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")
projects / ghc-hetmet.git / blobdiff