2 % (c) The University of Glasgow, 2000
4 \section[HscTypes]{Types for the per-module compiler}
9 GhciMode(..), isOneShot,
12 ModGuts(..), ModImports(..), ForeignStubs(..),
14 HomePackageTable, HomeModInfo(..), emptyHomePackageTable,
16 ExternalPackageState(..), EpsStats(..), addEpsInStats,
17 PackageTypeEnv, PackageIfaceTable, emptyPackageIfaceTable,
18 lookupIface, lookupIfaceByModule, emptyModIface,
20 InteractiveContext(..), emptyInteractiveContext,
21 icPrintUnqual, unQualInScope,
23 ModIface(..), mkIfaceDepCache, mkIfaceVerCache, mkIfaceFixCache,
24 IfacePackage(..), emptyIfaceDepCache,
26 Deprecs(..), IfaceDeprecs,
28 FixityEnv, FixItem(..), lookupFixity, emptyFixityEnv,
32 TyThing(..), tyThingClass, tyThingTyCon, tyThingDataCon, tyThingId,
33 TypeEnv, lookupType, mkTypeEnv, emptyTypeEnv,
34 extendTypeEnv, extendTypeEnvList, extendTypeEnvWithIds, lookupTypeEnv,
35 typeEnvElts, typeEnvClasses, typeEnvTyCons, typeEnvIds,
37 WhetherHasOrphans, IsBootInterface, Usage(..),
38 Dependencies(..), noDependencies,
39 InstPool, Gated, addInstsToPool,
40 RulePool, addRulesToPool,
41 NameCache(..), OrigNameCache, OrigIParamCache,
42 Avails, availsToNameSet, availName, availNames,
43 GenAvailInfo(..), AvailInfo, RdrAvailInfo,
46 Deprecations, DeprecTxt, lookupDeprec, plusDeprecs,
49 PackageInstEnv, PackageRuleBase,
52 Linkable(..), isObjectLinkable,
53 Unlinked(..), CompiledByteCode,
54 isObject, nameOfObject, isInterpretable, byteCodeOfObject
57 #include "HsVersions.h"
60 import ByteCodeAsm ( CompiledByteCode )
63 import RdrName ( GlobalRdrEnv, emptyGlobalRdrEnv,
64 LocalRdrEnv, emptyLocalRdrEnv,
65 GlobalRdrElt(..), mkRdrUnqual, lookupGRE_RdrName )
66 import Name ( Name, NamedThing, getName, nameOccName, nameModule )
69 import OccName ( OccName, OccEnv, lookupOccEnv, mkOccEnv, emptyOccEnv,
72 import InstEnv ( InstEnv, DFunId )
73 import Rules ( RuleBase )
74 import CoreSyn ( CoreBind )
76 import Type ( TyThing(..) )
78 import Class ( Class, classSelIds, classTyCon )
79 import TyCon ( TyCon, tyConSelIds, tyConDataCons )
80 import DataCon ( dataConImplicitIds )
81 import Packages ( PackageId )
82 import CmdLineOpts ( DynFlags )
84 import BasicTypes ( Version, initialVersion, IPName,
85 Fixity, defaultFixity, DeprecTxt )
87 import IfaceSyn ( IfaceInst, IfaceRule, IfaceDecl(ifName) )
89 import FiniteMap ( FiniteMap )
90 import CoreSyn ( IdCoreRule )
91 import Maybes ( orElse )
93 import SrcLoc ( SrcSpan )
94 import UniqSupply ( UniqSupply )
95 import FastString ( FastString )
97 import DATA_IOREF ( IORef, readIORef )
98 import Time ( ClockTime )
102 %************************************************************************
104 \subsection{Compilation environment}
106 %************************************************************************
108 The HscEnv gives the environment in which to compile a chunk of code.
112 = HscEnv { hsc_mode :: GhciMode,
113 hsc_dflags :: DynFlags,
115 hsc_HPT :: HomePackageTable,
116 -- The home package table describes already-compiled
117 -- home-packge modules, *excluding* the module we
118 -- are compiling right now.
119 -- (In one-shot mode the current module is the only
120 -- home-package module, so hsc_HPT is empty. All other
121 -- modules count as "external-package" modules.
122 -- However, even in GHCi mode, hi-boot interfaces are
123 -- demand-loadeded into the external-package table.)
125 -- hsc_HPT is not mutable because we only demand-load
126 -- external packages; the home package is eagerly
127 -- loaded, module by module, by the compilation manager.
129 -- The next two are side-effected by compiling
130 -- to reflect sucking in interface files
131 hsc_EPS :: IORef ExternalPackageState,
132 hsc_NC :: IORef NameCache }
134 hscEPS :: HscEnv -> IO ExternalPackageState
135 hscEPS hsc_env = readIORef (hsc_EPS hsc_env)
138 The GhciMode is self-explanatory:
141 data GhciMode = Batch -- ghc --make Main
142 | Interactive -- ghc --interactive
143 | OneShot -- ghc Foo.hs
144 | IDE -- Visual Studio etc
147 isOneShot :: GhciMode -> Bool
148 isOneShot OneShot = True
149 isOneShot _other = False
153 type HomePackageTable = ModuleEnv HomeModInfo -- Domain = modules in the home package
154 type PackageIfaceTable = ModuleEnv ModIface -- Domain = modules in the imported packages
156 emptyHomePackageTable = emptyModuleEnv
157 emptyPackageIfaceTable = emptyModuleEnv
160 = HomeModInfo { hm_iface :: ModIface,
161 hm_globals :: Maybe GlobalRdrEnv, -- Its top level environment
162 -- Nothing <-> compiled module
163 hm_details :: ModDetails,
164 hm_linkable :: Linkable }
167 Simple lookups in the symbol table.
170 lookupIface :: HomePackageTable -> PackageIfaceTable -> Module -> Maybe ModIface
171 -- We often have two IfaceTables, and want to do a lookup
172 lookupIface hpt pit mod
173 = case lookupModuleEnv hpt mod of
174 Just mod_info -> Just (hm_iface mod_info)
175 Nothing -> lookupModuleEnv pit mod
177 lookupIfaceByModule :: HomePackageTable -> PackageIfaceTable -> Module -> Maybe ModIface
178 -- We often have two IfaceTables, and want to do a lookup
179 lookupIfaceByModule hpt pit mod
180 = case lookupModuleEnv hpt mod of
181 Just mod_info -> Just (hm_iface mod_info)
182 Nothing -> lookupModuleEnv pit mod
185 %************************************************************************
187 \subsection{Symbol tables and Module details}
189 %************************************************************************
191 A @ModIface@ plus a @ModDetails@ summarises everything we know
192 about a compiled module. The @ModIface@ is the stuff *before* linking,
193 and can be written out to an interface file. (The @ModDetails@ is after
194 linking; it is the "linked" form of the mi_decls field.)
196 When we *read* an interface file, we also construct a @ModIface@ from it,
197 except that the mi_decls part is empty; when reading we consolidate
198 the declarations into a single indexed map in the @PersistentRenamerState@.
203 mi_package :: !IfacePackage, -- Which package the module comes from
204 mi_module :: !Module,
205 mi_mod_vers :: !Version, -- Module version: changes when anything changes
207 mi_orphan :: !WhetherHasOrphans, -- Whether this module has orphans
208 mi_boot :: !IsBootInterface, -- Read from an hi-boot file?
210 mi_deps :: Dependencies,
211 -- This is consulted for directly-imported modules,
212 -- but not for anything else (hence lazy)
214 -- Usages; kept sorted so that it's easy to decide
215 -- whether to write a new iface file (changing usages
216 -- doesn't affect the version of this module)
217 mi_usages :: [Usage],
218 -- NOT STRICT! we read this field lazily from the interface file
219 -- It is *only* consulted by the recompilation checker
222 -- Kept sorted by (mod,occ), to make version comparisons easier
223 mi_exports :: ![IfaceExport],
224 mi_exp_vers :: !Version, -- Version number of export list
227 mi_fixities :: [(OccName,Fixity)],
228 -- NOT STRICT! we read this field lazily from the interface file
231 mi_deprecs :: IfaceDeprecs,
232 -- NOT STRICT! we read this field lazily from the interface file
234 -- Type, class and variable declarations
235 -- The version of an Id changes if its fixity or deprecations change
236 -- (as well as its type of course)
237 -- Ditto data constructors, class operations, except that
238 -- the version of the parent class/tycon changes
239 mi_decls :: [(Version,IfaceDecl)], -- Sorted
241 -- Instance declarations and rules
242 mi_insts :: [IfaceInst], -- Sorted
243 mi_rules :: [IfaceRule], -- Sorted
244 mi_rule_vers :: !Version, -- Version number for rules and instances combined
246 -- Cached environments for easy lookup
247 -- These are computed (lazily) from other fields
248 -- and are not put into the interface file
249 mi_dep_fn :: Name -> Maybe DeprecTxt, -- Cached lookup for mi_deprecs
250 mi_fix_fn :: OccName -> Fixity, -- Cached lookup for mi_fixities
251 mi_ver_fn :: OccName -> Maybe Version -- Cached lookup for mi_decls
252 -- The Nothing in mi_ver_fn means that the thing
253 -- isn't in decls. It's useful to know that when
254 -- seeing if we are up to date wrt the old interface
257 data IfacePackage = ThisPackage | ExternalPackage PackageId
259 -- Should be able to construct ModDetails from mi_decls in ModIface
262 -- The next three fields are created by the typechecker
263 md_types :: !TypeEnv,
264 md_insts :: ![DFunId], -- Dfun-ids for the instances in this module
265 md_rules :: ![IdCoreRule] -- Domain may include Ids from other modules
268 -- A ModGuts is carried through the compiler, accumulating stuff as it goes
269 -- There is only one ModGuts at any time, the one for the module
270 -- being compiled right now. Once it is compiled, a ModIface and
271 -- ModDetails are extracted and the ModGuts is dicarded.
275 mg_module :: !Module,
276 mg_exports :: !NameSet, -- What it exports
277 mg_deps :: !Dependencies, -- What is below it, directly or otherwise
278 mg_dir_imps :: ![Module], -- Directly-imported modules; used to
279 -- generate initialisation code
280 mg_usages :: ![Usage], -- Version info for what it needed
282 mg_rdr_env :: !GlobalRdrEnv, -- Top-level lexical environment
283 mg_fix_env :: !FixityEnv, -- Fixity env, for things declared in this module
284 mg_deprecs :: !Deprecations, -- Deprecations declared in the module
286 mg_types :: !TypeEnv,
287 mg_insts :: ![DFunId], -- Instances
288 mg_rules :: ![IdCoreRule], -- Rules from this module
289 mg_binds :: ![CoreBind], -- Bindings for this module
290 mg_foreign :: !ForeignStubs
293 -- The ModGuts takes on several slightly different forms:
295 -- After simplification, the following fields change slightly:
296 -- mg_rules Orphan rules only (local ones now attached to binds)
297 -- mg_binds With rules attached
299 -- After CoreTidy, the following fields change slightly:
300 -- mg_types Now contains Ids as well, replete with final IdInfo
301 -- The Ids are only the ones that are visible from
302 -- importing modules. Without -O that means only
303 -- exported Ids, but with -O importing modules may
304 -- see ids mentioned in unfoldings of exported Ids
306 -- mg_insts Same DFunIds as before, but with final IdInfo,
307 -- and the unique might have changed; remember that
308 -- CoreTidy links up the uniques of old and new versions
310 -- mg_rules All rules for exported things, substituted with final Ids
318 imp_direct :: ![(Module,Bool)], -- Explicitly-imported modules
319 -- Boolean is true if we imported the whole
320 -- module (apart, perhaps, from hiding some)
321 imp_pkg_mods :: !ModuleSet, -- Non-home-package modules on which we depend,
322 -- directly or indirectly
323 imp_home_names :: !NameSet -- Home package things on which we depend,
324 -- directly or indirectly
327 data ForeignStubs = NoStubs
329 SDoc -- Header file prototypes for
330 -- "foreign exported" functions
331 SDoc -- C stubs to use when calling
332 -- "foreign exported" functions
333 [FastString] -- Headers that need to be included
334 -- into C code generated for this module
335 [Id] -- Foreign-exported binders
336 -- we have to generate code to register these
341 emptyModIface :: IfacePackage -> Module -> ModIface
342 emptyModIface pkg mod
343 = ModIface { mi_package = pkg,
345 mi_mod_vers = initialVersion,
348 mi_deps = noDependencies,
351 mi_exp_vers = initialVersion,
353 mi_deprecs = NoDeprecs,
357 mi_rule_vers = initialVersion,
358 mi_dep_fn = emptyIfaceDepCache,
359 mi_fix_fn = emptyIfaceFixCache,
360 mi_ver_fn = emptyIfaceVerCache
365 %************************************************************************
367 \subsection{The interactive context}
369 %************************************************************************
372 data InteractiveContext
373 = InteractiveContext {
374 ic_toplev_scope :: [String], -- Include the "top-level" scope of
377 ic_exports :: [String], -- Include just the exports of these
380 ic_rn_gbl_env :: GlobalRdrEnv, -- The cached GlobalRdrEnv, built from
381 -- ic_toplev_scope and ic_exports
383 ic_rn_local_env :: LocalRdrEnv, -- Lexical context for variables bound
384 -- during interaction
386 ic_type_env :: TypeEnv -- Ditto for types
389 emptyInteractiveContext
390 = InteractiveContext { ic_toplev_scope = [],
392 ic_rn_gbl_env = emptyGlobalRdrEnv,
393 ic_rn_local_env = emptyLocalRdrEnv,
394 ic_type_env = emptyTypeEnv }
396 icPrintUnqual :: InteractiveContext -> PrintUnqualified
397 icPrintUnqual ictxt = unQualInScope (ic_rn_gbl_env ictxt)
400 @unQualInScope@ returns a function that takes a @Name@ and tells whether
401 its unqualified name is in scope. This is put as a boolean flag in
402 the @Name@'s provenance to guide whether or not to print the name qualified
406 unQualInScope :: GlobalRdrEnv -> PrintUnqualified
407 -- True if 'f' is in scope, and has only one binding,
408 -- and the thing it is bound to is the name we are looking for
409 -- (i.e. false if A.f and B.f are both in scope as unqualified 'f')
411 -- [Out of date] Also checks for built-in syntax, which is always 'in scope'
412 unQualInScope env mod occ
413 = case lookupGRE_RdrName (mkRdrUnqual occ) env of
414 [gre] -> nameModule (gre_name gre) == mod
419 %************************************************************************
423 %************************************************************************
426 implicitTyThings :: TyThing -> [TyThing]
427 implicitTyThings (AnId id) = []
429 -- For type constructors, add the data cons (and their extras),
430 -- and the selectors and generic-programming Ids too
432 -- Newtypes don't have a worker Id, so don't generate that?
433 implicitTyThings (ATyCon tc) = map AnId (tyConSelIds tc) ++
434 concatMap (extras_plus . ADataCon) (tyConDataCons tc)
436 -- For classes, add the class TyCon too (and its extras)
437 -- and the class selector Ids
438 implicitTyThings (AClass cl) = map AnId (classSelIds cl) ++
439 extras_plus (ATyCon (classTyCon cl))
442 -- For data cons add the worker and wrapper (if any)
443 implicitTyThings (ADataCon dc) = map AnId (dataConImplicitIds dc)
445 extras_plus thing = thing : implicitTyThings thing
447 extendTypeEnvWithIds :: TypeEnv -> [Id] -> TypeEnv
448 extendTypeEnvWithIds env ids
449 = extendNameEnvList env [(getName id, AnId id) | id <- ids]
452 %************************************************************************
456 %************************************************************************
459 type TypeEnv = NameEnv TyThing
461 emptyTypeEnv :: TypeEnv
462 typeEnvElts :: TypeEnv -> [TyThing]
463 typeEnvClasses :: TypeEnv -> [Class]
464 typeEnvTyCons :: TypeEnv -> [TyCon]
465 typeEnvIds :: TypeEnv -> [Id]
466 lookupTypeEnv :: TypeEnv -> Name -> Maybe TyThing
468 emptyTypeEnv = emptyNameEnv
469 typeEnvElts env = nameEnvElts env
470 typeEnvClasses env = [cl | AClass cl <- typeEnvElts env]
471 typeEnvTyCons env = [tc | ATyCon tc <- typeEnvElts env]
472 typeEnvIds env = [id | AnId id <- typeEnvElts env]
474 mkTypeEnv :: [TyThing] -> TypeEnv
475 mkTypeEnv things = extendTypeEnvList emptyTypeEnv things
477 lookupTypeEnv = lookupNameEnv
479 -- Extend the type environment
480 extendTypeEnv :: TypeEnv -> TyThing -> TypeEnv
481 extendTypeEnv env thing = extendNameEnv env (getName thing) thing
483 extendTypeEnvList :: TypeEnv -> [TyThing] -> TypeEnv
484 extendTypeEnvList env things = foldl extendTypeEnv env things
488 lookupType :: HomePackageTable -> PackageTypeEnv -> Name -> Maybe TyThing
489 lookupType hpt pte name
490 = case lookupModuleEnv hpt (nameModule name) of
491 Just details -> lookupNameEnv (md_types (hm_details details)) name
492 Nothing -> lookupNameEnv pte name
497 tyThingTyCon (ATyCon tc) = tc
498 tyThingTyCon other = pprPanic "tyThingTyCon" (ppr other)
500 tyThingClass (AClass cls) = cls
501 tyThingClass other = pprPanic "tyThingClass" (ppr other)
503 tyThingDataCon (ADataCon dc) = dc
504 tyThingDataCon other = pprPanic "tyThingDataCon" (ppr other)
506 tyThingId (AnId id) = id
507 tyThingId other = pprPanic "tyThingId" (ppr other)
510 %************************************************************************
512 \subsection{Auxiliary types}
514 %************************************************************************
516 These types are defined here because they are mentioned in ModDetails,
517 but they are mostly elaborated elsewhere
520 mkIfaceVerCache :: [(Version,IfaceDecl)] -> OccName -> Maybe Version
521 mkIfaceVerCache pairs
522 = \occ -> lookupOccEnv env occ
524 env = foldl add emptyOccEnv pairs
525 add env (v,d) = extendOccEnv env (ifName d) v
527 emptyIfaceVerCache :: OccName -> Maybe Version
528 emptyIfaceVerCache occ = Nothing
530 ------------------ Deprecations -------------------------
533 | DeprecAll DeprecTxt -- Whole module deprecated
534 | DeprecSome a -- Some specific things deprecated
537 type IfaceDeprecs = Deprecs [(OccName,DeprecTxt)]
538 type Deprecations = Deprecs (NameEnv (OccName,DeprecTxt))
540 mkIfaceDepCache:: IfaceDeprecs -> Name -> Maybe DeprecTxt
541 mkIfaceDepCache NoDeprecs = \n -> Nothing
542 mkIfaceDepCache (DeprecAll t) = \n -> Just t
543 mkIfaceDepCache (DeprecSome pairs) = lookupOccEnv (mkOccEnv pairs) . nameOccName
545 emptyIfaceDepCache :: Name -> Maybe DeprecTxt
546 emptyIfaceDepCache n = Nothing
548 lookupDeprec :: Deprecations -> Name -> Maybe DeprecTxt
549 lookupDeprec NoDeprecs name = Nothing
550 lookupDeprec (DeprecAll txt) name = Just txt
551 lookupDeprec (DeprecSome env) name = case lookupNameEnv env name of
552 Just (_, txt) -> Just txt
555 plusDeprecs :: Deprecations -> Deprecations -> Deprecations
556 plusDeprecs d NoDeprecs = d
557 plusDeprecs NoDeprecs d = d
558 plusDeprecs d (DeprecAll t) = DeprecAll t
559 plusDeprecs (DeprecAll t) d = DeprecAll t
560 plusDeprecs (DeprecSome v1) (DeprecSome v2) = DeprecSome (v1 `plusNameEnv` v2)
565 type Avails = [AvailInfo]
566 type AvailInfo = GenAvailInfo Name
567 type RdrAvailInfo = GenAvailInfo OccName
569 data GenAvailInfo name = Avail name -- An ordinary identifier
570 | AvailTC name -- The name of the type or class
571 [name] -- The available pieces of type/class.
572 -- NB: If the type or class is itself
573 -- to be in scope, it must be in this list.
574 -- Thus, typically: AvailTC Eq [Eq, ==, /=]
576 -- Equality used when deciding if the interface has changed
578 type IfaceExport = (Module, [GenAvailInfo OccName])
580 availsToNameSet :: [AvailInfo] -> NameSet
581 availsToNameSet avails = foldl add emptyNameSet avails
583 add set avail = addListToNameSet set (availNames avail)
585 availName :: GenAvailInfo name -> name
586 availName (Avail n) = n
587 availName (AvailTC n _) = n
589 availNames :: GenAvailInfo name -> [name]
590 availNames (Avail n) = [n]
591 availNames (AvailTC n ns) = ns
593 instance Outputable n => Outputable (GenAvailInfo n) where
596 pprAvail :: Outputable n => GenAvailInfo n -> SDoc
597 pprAvail (AvailTC n ns) = ppr n <> case {- filter (/= n) -} ns of
599 ns' -> braces (hsep (punctuate comma (map ppr ns')))
601 pprAvail (Avail n) = ppr n
605 mkIfaceFixCache :: [(OccName, Fixity)] -> OccName -> Fixity
606 mkIfaceFixCache pairs
607 = \n -> lookupOccEnv env n `orElse` defaultFixity
611 emptyIfaceFixCache :: OccName -> Fixity
612 emptyIfaceFixCache n = defaultFixity
614 -- This fixity environment is for source code only
615 type FixityEnv = NameEnv FixItem
617 -- We keep the OccName in the range so that we can generate an interface from it
618 data FixItem = FixItem OccName Fixity SrcSpan
620 instance Outputable FixItem where
621 ppr (FixItem occ fix loc) = ppr fix <+> ppr occ <+> parens (ppr loc)
623 emptyFixityEnv :: FixityEnv
624 emptyFixityEnv = emptyNameEnv
626 lookupFixity :: FixityEnv -> Name -> Fixity
627 lookupFixity env n = case lookupNameEnv env n of
628 Just (FixItem _ fix _) -> fix
629 Nothing -> defaultFixity
633 %************************************************************************
635 \subsection{WhatsImported}
637 %************************************************************************
640 type WhetherHasOrphans = Bool
642 -- * an instance decl in a module other than the defn module for
643 -- one of the tycons or classes in the instance head
644 -- * a transformation rule in a module other than the one defining
645 -- the function in the head of the rule.
647 type IsBootInterface = Bool
649 -- Dependency info about modules and packages below this one
650 -- in the import hierarchy. See TcRnTypes.ImportAvails for details.
652 -- Invariant: the dependencies of a module M never includes M
653 -- Invariant: the lists are unordered, with no duplicates
655 = Deps { dep_mods :: [(Module,IsBootInterface)], -- Home-package module dependencies
656 dep_pkgs :: [PackageId], -- External package dependencies
657 dep_orphs :: [Module] } -- Orphan modules (whether home or external pkg)
659 -- Equality used only for old/new comparison in MkIface.addVersionInfo
661 noDependencies :: Dependencies
662 noDependencies = Deps [] [] []
665 = Usage { usg_name :: Module, -- Name of the module
666 usg_mod :: Version, -- Module version
667 usg_entities :: [(OccName,Version)], -- Sorted by occurrence name
668 usg_exports :: Maybe Version, -- Export-list version, if we depend on it
669 usg_rules :: Version -- Orphan-rules version (for non-orphan
670 -- modules this will always be initialVersion)
672 -- This type doesn't let you say "I imported f but none of the rules in
673 -- the module". If you use anything in the module you get its rule version
674 -- So if the rules change, you'll recompile, even if you don't use them.
675 -- This is easy to implement, and it's safer: you might not have used the rules last
676 -- time round, but if someone has added a new rule you might need it this time
678 -- The export list field is (Just v) if we depend on the export list:
679 -- i.e. we imported the module without saying exactly what we imported
680 -- We need to recompile if the module exports changes, because we might
681 -- now have a name clash in the importing module.
685 %************************************************************************
687 The External Package State
689 %************************************************************************
692 type PackageTypeEnv = TypeEnv
693 type PackageRuleBase = RuleBase
694 type PackageInstEnv = InstEnv
696 data ExternalPackageState
698 eps_is_boot :: !(ModuleEnv (Module, IsBootInterface)),
699 -- In OneShot mode (only), home-package modules accumulate in the
700 -- external package state, and are sucked in lazily.
701 -- For these home-pkg modules (only) we need to record which are
702 -- boot modules. We set this field after loading all the
703 -- explicitly-imported interfaces, but before doing anything else
705 -- The Module part is not necessary, but it's useful for
706 -- debug prints, and it's convenient because this field comes
707 -- direct from TcRnTypes.ImportAvails.imp_dep_mods
709 eps_PIT :: !PackageIfaceTable,
710 -- The ModuleIFaces for modules in external packages
711 -- whose interfaces we have opened
712 -- The declarations in these interface files are held in
713 -- eps_decls, eps_insts, eps_rules (below), not in the
714 -- mi_decls fields of the iPIT.
715 -- What _is_ in the iPIT is:
722 eps_PTE :: !PackageTypeEnv, -- Domain = external-package modules
724 eps_inst_env :: !PackageInstEnv, -- The total InstEnv accumulated from
725 -- all the external-package modules
726 eps_rule_base :: !PackageRuleBase, -- Ditto RuleEnv
729 -- Holding pens for stuff that has been read in from file,
730 -- but not yet slurped into the renamer
731 eps_insts :: !InstPool,
732 -- The as-yet un-slurped instance decls
733 -- Decls move from here to eps_inst_env
734 -- Each instance is 'gated' by the names that must be
735 -- available before this instance decl is needed.
737 eps_rules :: !RulePool,
738 -- The as-yet un-slurped rules
740 eps_stats :: !EpsStats
743 -- "In" means read from iface files
744 -- "Out" means actually sucked in and type-checked
745 data EpsStats = EpsStats { n_ifaces_in
746 , n_decls_in, n_decls_out
747 , n_rules_in, n_rules_out
748 , n_insts_in, n_insts_out :: !Int }
751 The NameCache makes sure that there is just one Unique assigned for
752 each original name; i.e. (module-name, occ-name) pair. The Name is
753 always stored as a Global, and has the SrcLoc of its binding location.
754 Actually that's not quite right. When we first encounter the original
755 name, we might not be at its binding site (e.g. we are reading an
756 interface file); so we give it 'noSrcLoc' then. Later, when we find
757 its binding site, we fix it up.
759 Exactly the same is true of the Module stored in the Name. When we first
760 encounter the occurrence, we may not know the details of the module, so
761 we just store junk. Then when we find the binding site, we fix it up.
765 = NameCache { nsUniqs :: UniqSupply,
767 nsNames :: OrigNameCache,
768 -- Ensures that one original name gets one unique
769 nsIPs :: OrigIParamCache
770 -- Ensures that one implicit parameter name gets one unique
773 type OrigNameCache = ModuleEnv (OccEnv Name)
774 type OrigIParamCache = FiniteMap (IPName OccName) (IPName Name)
778 type Gated d = ([Name], (Module, d)) -- The [Name] 'gate' the declaration; always non-empty
779 -- Module records which iface file this
782 type RulePool = [Gated IfaceRule]
784 addRulesToPool :: RulePool
787 addRulesToPool rules new_rules = new_rules ++ rules
789 -------------------------
790 addEpsInStats :: EpsStats -> Int -> Int -> Int -> EpsStats
791 -- Add stats for one newly-read interface
792 addEpsInStats stats n_decls n_insts n_rules
793 = stats { n_ifaces_in = n_ifaces_in stats + 1
794 , n_decls_in = n_decls_in stats + n_decls
795 , n_insts_in = n_insts_in stats + n_insts
796 , n_rules_in = n_rules_in stats + n_rules }
798 -------------------------
799 type InstPool = NameEnv [Gated IfaceInst]
800 -- The key of the Pool is the Class
801 -- The Names are the TyCons in the instance head
802 -- For example, suppose this is in an interface file
803 -- instance C T where ...
804 -- We want to slurp this decl if both C and T are "visible" in
805 -- the importing module. See "The gating story" in RnIfaces for details.
808 addInstsToPool :: InstPool -> [(Name, Gated IfaceInst)] -> InstPool
809 addInstsToPool insts new_insts
810 = foldr add insts new_insts
812 add :: (Name, Gated IfaceInst) -> NameEnv [Gated IfaceInst] -> NameEnv [Gated IfaceInst]
813 add (cls,new_inst) insts = extendNameEnv_C combine insts cls [new_inst]
815 combine old_insts _ = new_inst : old_insts
819 %************************************************************************
821 \subsection{Linkable stuff}
823 %************************************************************************
825 This stuff is in here, rather than (say) in Linker.lhs, because the Linker.lhs
826 stuff is the *dynamic* linker, and isn't present in a stage-1 compiler
830 linkableTime :: ClockTime, -- Time at which this linkable was built
831 -- (i.e. when the bytecodes were produced,
832 -- or the mod date on the files)
833 linkableModule :: Module, -- Should be Module, but see below
834 linkableUnlinked :: [Unlinked]
837 isObjectLinkable :: Linkable -> Bool
838 isObjectLinkable l = all isObject (linkableUnlinked l)
840 instance Outputable Linkable where
841 ppr (LM when_made mod unlinkeds)
842 = (text "LinkableM" <+> parens (text (show when_made)) <+> ppr mod)
843 $$ nest 3 (ppr unlinkeds)
845 -------------------------------------------
850 | BCOs CompiledByteCode
853 data CompiledByteCode = NoByteCode
856 instance Outputable Unlinked where
857 ppr (DotO path) = text "DotO" <+> text path
858 ppr (DotA path) = text "DotA" <+> text path
859 ppr (DotDLL path) = text "DotDLL" <+> text path
861 ppr (BCOs bcos) = text "BCOs" <+> ppr bcos
863 ppr (BCOs bcos) = text "No byte code"
866 isObject (DotO _) = True
867 isObject (DotA _) = True
868 isObject (DotDLL _) = True
871 isInterpretable = not . isObject
873 nameOfObject (DotO fn) = fn
874 nameOfObject (DotA fn) = fn
875 nameOfObject (DotDLL fn) = fn
877 byteCodeOfObject (BCOs bc) = bc