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, lookupIfaceByModName, moduleNameToModule,
21 InteractiveContext(..), emptyInteractiveContext,
22 icPrintUnqual, unQualInScope,
24 ModIface(..), mkIfaceDepCache, mkIfaceVerCache, mkIfaceFixCache,
27 Deprecs(..), IfaceDeprecs,
29 FixityEnv, FixItem(..), lookupFixity, emptyFixityEnv,
33 TyThing(..), tyThingClass, tyThingTyCon, tyThingDataCon, tyThingId,
34 TypeEnv, lookupType, mkTypeEnv, emptyTypeEnv,
35 extendTypeEnv, extendTypeEnvList, extendTypeEnvWithIds, lookupTypeEnv,
36 typeEnvElts, typeEnvClasses, typeEnvTyCons, typeEnvIds,
38 WhetherHasOrphans, IsBootInterface, Usage(..),
39 Dependencies(..), noDependencies,
40 InstPool, Gated, addInstsToPool,
41 RulePool, addRulesToPool,
42 NameCache(..), OrigNameCache, OrigIParamCache,
43 Avails, availsToNameSet, availName, availNames,
44 GenAvailInfo(..), AvailInfo, RdrAvailInfo,
47 Deprecations, DeprecTxt, lookupDeprec, plusDeprecs,
50 PackageInstEnv, PackageRuleBase,
53 Linkable(..), isObjectLinkable,
54 Unlinked(..), CompiledByteCode,
55 isObject, nameOfObject, isInterpretable, byteCodeOfObject
58 #include "HsVersions.h"
61 import ByteCodeAsm ( CompiledByteCode )
64 import RdrName ( GlobalRdrEnv, emptyGlobalRdrEnv,
65 LocalRdrEnv, emptyLocalRdrEnv,
66 GlobalRdrElt(..), mkRdrUnqual, lookupGRE_RdrName )
67 import Name ( Name, NamedThing, getName, nameOccName, nameModule, nameModuleName )
70 import OccName ( OccName, OccEnv, lookupOccEnv, mkOccEnv, emptyOccEnv,
73 import InstEnv ( InstEnv, DFunId )
74 import Rules ( RuleBase )
75 import CoreSyn ( CoreBind )
77 import Type ( TyThing(..) )
79 import Class ( Class, classSelIds, classTyCon )
80 import TyCon ( TyCon, tyConSelIds, tyConDataCons )
81 import DataCon ( dataConImplicitIds )
82 import Packages ( PackageName )
83 import CmdLineOpts ( DynFlags )
85 import BasicTypes ( Version, initialVersion, IPName,
86 Fixity, defaultFixity, DeprecTxt )
88 import IfaceSyn ( IfaceInst, IfaceRule, IfaceDecl(ifName) )
90 import FiniteMap ( FiniteMap )
91 import CoreSyn ( IdCoreRule )
92 import Maybes ( orElse )
94 import SrcLoc ( SrcSpan )
95 import UniqSupply ( UniqSupply )
96 import Maybe ( fromJust )
97 import FastString ( FastString )
99 import DATA_IOREF ( IORef, readIORef )
100 import Time ( ClockTime )
104 %************************************************************************
106 \subsection{Compilation environment}
108 %************************************************************************
110 The HscEnv gives the environment in which to compile a chunk of code.
114 = HscEnv { hsc_mode :: GhciMode,
115 hsc_dflags :: DynFlags,
117 hsc_HPT :: HomePackageTable,
118 -- The home package table describes already-compiled
119 -- home-packge modules, *excluding* the module we
120 -- are compiling right now.
121 -- (In one-shot mode the current module is the only
122 -- home-package module, so hsc_HPT is empty. All other
123 -- modules count as "external-package" modules.
124 -- However, even in GHCi mode, hi-boot interfaces are
125 -- demand-loadeded into the external-package table.)
127 -- hsc_HPT is not mutable because we only demand-load
128 -- external packages; the home package is eagerly
129 -- loaded, module by module, by the compilation manager.
131 -- The next two are side-effected by compiling
132 -- to reflect sucking in interface files
133 hsc_EPS :: IORef ExternalPackageState,
134 hsc_NC :: IORef NameCache }
136 hscEPS :: HscEnv -> IO ExternalPackageState
137 hscEPS hsc_env = readIORef (hsc_EPS hsc_env)
140 The GhciMode is self-explanatory:
143 data GhciMode = Batch -- ghc --make Main
144 | Interactive -- ghc --interactive
145 | OneShot -- ghc Foo.hs
146 | IDE -- Visual Studio etc
149 isOneShot :: GhciMode -> Bool
150 isOneShot OneShot = True
151 isOneShot _other = False
155 type HomePackageTable = ModuleEnv HomeModInfo -- Domain = modules in the home package
156 type PackageIfaceTable = ModuleEnv ModIface -- Domain = modules in the imported packages
158 emptyHomePackageTable = emptyModuleEnv
159 emptyPackageIfaceTable = emptyModuleEnv
162 = HomeModInfo { hm_iface :: ModIface,
163 hm_globals :: Maybe GlobalRdrEnv, -- Its top level environment
164 -- Nothing <-> compiled module
165 hm_details :: ModDetails,
166 hm_linkable :: Linkable }
169 Simple lookups in the symbol table.
172 lookupIface :: HomePackageTable -> PackageIfaceTable -> Module -> Maybe ModIface
173 -- We often have two IfaceTables, and want to do a lookup
174 lookupIface hpt pit mod
175 = case lookupModuleEnv hpt mod of
176 Just mod_info -> Just (hm_iface mod_info)
177 Nothing -> lookupModuleEnv pit mod
179 lookupIfaceByModName :: HomePackageTable -> PackageIfaceTable -> ModuleName -> Maybe ModIface
180 -- We often have two IfaceTables, and want to do a lookup
181 lookupIfaceByModName hpt pit mod
182 = case lookupModuleEnvByName hpt mod of
183 Just mod_info -> Just (hm_iface mod_info)
184 Nothing -> lookupModuleEnvByName pit mod
188 -- Use instead of Finder.findModule if possible: this way doesn't
189 -- require filesystem operations, and it is guaranteed not to fail
190 -- when the IfaceTables are properly populated (i.e. after the renamer).
191 moduleNameToModule :: HomePackageTable -> PackageIfaceTable -> ModuleName -> Module
192 moduleNameToModule hpt pit mod
193 = mi_module (fromJust (lookupIfaceByModName hpt pit mod))
197 %************************************************************************
199 \subsection{Symbol tables and Module details}
201 %************************************************************************
203 A @ModIface@ plus a @ModDetails@ summarises everything we know
204 about a compiled module. The @ModIface@ is the stuff *before* linking,
205 and can be written out to an interface file. (The @ModDetails@ is after
206 linking; it is the "linked" form of the mi_decls field.)
208 When we *read* an interface file, we also construct a @ModIface@ from it,
209 except that the mi_decls part is empty; when reading we consolidate
210 the declarations into a single indexed map in the @PersistentRenamerState@.
215 mi_package :: !PackageName, -- Which package the module comes from
216 mi_module :: !Module,
217 mi_mod_vers :: !Version, -- Module version: changes when anything changes
219 mi_orphan :: !WhetherHasOrphans, -- Whether this module has orphans
220 mi_boot :: !IsBootInterface, -- Read from an hi-boot file?
222 mi_deps :: Dependencies,
223 -- This is consulted for directly-imported modules,
224 -- but not for anything else (hence lazy)
226 -- Usages; kept sorted so that it's easy to decide
227 -- whether to write a new iface file (changing usages
228 -- doesn't affect the version of this module)
229 mi_usages :: [Usage],
230 -- NOT STRICT! we read this field lazily from the interface file
231 -- It is *only* consulted by the recompilation checker
234 -- Kept sorted by (mod,occ), to make version comparisons easier
235 mi_exports :: ![IfaceExport],
236 mi_exp_vers :: !Version, -- Version number of export list
239 mi_fixities :: [(OccName,Fixity)],
240 -- NOT STRICT! we read this field lazily from the interface file
243 mi_deprecs :: IfaceDeprecs,
244 -- NOT STRICT! we read this field lazily from the interface file
246 -- Type, class and variable declarations
247 -- The version of an Id changes if its fixity or deprecations change
248 -- (as well as its type of course)
249 -- Ditto data constructors, class operations, except that
250 -- the version of the parent class/tycon changes
251 mi_decls :: [(Version,IfaceDecl)], -- Sorted
253 -- Instance declarations and rules
254 mi_insts :: [IfaceInst], -- Sorted
255 mi_rules :: [IfaceRule], -- Sorted
256 mi_rule_vers :: !Version, -- Version number for rules and instances combined
258 -- Cached environments for easy lookup
259 -- These are computed (lazily) from other fields
260 -- and are not put into the interface file
261 mi_dep_fn :: Name -> Maybe DeprecTxt, -- Cached lookup for mi_deprecs
262 mi_fix_fn :: OccName -> Fixity, -- Cached lookup for mi_fixities
263 mi_ver_fn :: OccName -> Maybe Version -- Cached lookup for mi_decls
264 -- The Nothing in mi_ver_fn means that the thing
265 -- isn't in decls. It's useful to know that when
266 -- seeing if we are up to date wrt the old interface
269 -- Should be able to construct ModDetails from mi_decls in ModIface
272 -- The next three fields are created by the typechecker
273 md_types :: !TypeEnv,
274 md_insts :: ![DFunId], -- Dfun-ids for the instances in this module
275 md_rules :: ![IdCoreRule] -- Domain may include Ids from other modules
278 -- A ModGuts is carried through the compiler, accumulating stuff as it goes
279 -- There is only one ModGuts at any time, the one for the module
280 -- being compiled right now. Once it is compiled, a ModIface and
281 -- ModDetails are extracted and the ModGuts is dicarded.
285 mg_module :: !Module,
286 mg_exports :: !NameSet, -- What it exports
287 mg_deps :: !Dependencies, -- What is below it, directly or otherwise
288 mg_dir_imps :: ![Module], -- Directly-imported modules; used to
289 -- generate initialisation code
290 mg_usages :: ![Usage], -- Version info for what it needed
292 mg_rdr_env :: !GlobalRdrEnv, -- Top-level lexical environment
293 mg_fix_env :: !FixityEnv, -- Fixity env, for things declared in this module
294 mg_deprecs :: !Deprecations, -- Deprecations declared in the module
296 mg_types :: !TypeEnv,
297 mg_insts :: ![DFunId], -- Instances
298 mg_rules :: ![IdCoreRule], -- Rules from this module
299 mg_binds :: ![CoreBind], -- Bindings for this module
300 mg_foreign :: !ForeignStubs
303 -- The ModGuts takes on several slightly different forms:
305 -- After simplification, the following fields change slightly:
306 -- mg_rules Orphan rules only (local ones now attached to binds)
307 -- mg_binds With rules attached
309 -- After CoreTidy, the following fields change slightly:
310 -- mg_types Now contains Ids as well, replete with final IdInfo
311 -- The Ids are only the ones that are visible from
312 -- importing modules. Without -O that means only
313 -- exported Ids, but with -O importing modules may
314 -- see ids mentioned in unfoldings of exported Ids
316 -- mg_insts Same DFunIds as before, but with final IdInfo,
317 -- and the unique might have changed; remember that
318 -- CoreTidy links up the uniques of old and new versions
320 -- mg_rules All rules for exported things, substituted with final Ids
328 imp_direct :: ![(Module,Bool)], -- Explicitly-imported modules
329 -- Boolean is true if we imported the whole
330 -- module (apart, perhaps, from hiding some)
331 imp_pkg_mods :: !ModuleSet, -- Non-home-package modules on which we depend,
332 -- directly or indirectly
333 imp_home_names :: !NameSet -- Home package things on which we depend,
334 -- directly or indirectly
337 data ForeignStubs = NoStubs
339 SDoc -- Header file prototypes for
340 -- "foreign exported" functions
341 SDoc -- C stubs to use when calling
342 -- "foreign exported" functions
343 [FastString] -- Headers that need to be included
344 -- into C code generated for this module
345 [Id] -- Foreign-exported binders
346 -- we have to generate code to register these
351 emptyModIface :: PackageName -> ModuleName -> ModIface
352 emptyModIface pkg mod
353 = ModIface { mi_package = pkg,
354 mi_module = mkModule pkg mod,
355 mi_mod_vers = initialVersion,
358 mi_deps = noDependencies,
361 mi_exp_vers = initialVersion,
363 mi_deprecs = NoDeprecs,
367 mi_rule_vers = initialVersion,
368 mi_dep_fn = emptyIfaceDepCache,
369 mi_fix_fn = emptyIfaceFixCache,
370 mi_ver_fn = emptyIfaceVerCache
375 %************************************************************************
377 \subsection{The interactive context}
379 %************************************************************************
382 data InteractiveContext
383 = InteractiveContext {
384 ic_toplev_scope :: [String], -- Include the "top-level" scope of
387 ic_exports :: [String], -- Include just the exports of these
390 ic_rn_gbl_env :: GlobalRdrEnv, -- The cached GlobalRdrEnv, built from
391 -- ic_toplev_scope and ic_exports
393 ic_rn_local_env :: LocalRdrEnv, -- Lexical context for variables bound
394 -- during interaction
396 ic_type_env :: TypeEnv -- Ditto for types
399 emptyInteractiveContext
400 = InteractiveContext { ic_toplev_scope = [],
402 ic_rn_gbl_env = emptyGlobalRdrEnv,
403 ic_rn_local_env = emptyLocalRdrEnv,
404 ic_type_env = emptyTypeEnv }
406 icPrintUnqual :: InteractiveContext -> PrintUnqualified
407 icPrintUnqual ictxt = unQualInScope (ic_rn_gbl_env ictxt)
410 @unQualInScope@ returns a function that takes a @Name@ and tells whether
411 its unqualified name is in scope. This is put as a boolean flag in
412 the @Name@'s provenance to guide whether or not to print the name qualified
416 unQualInScope :: GlobalRdrEnv -> PrintUnqualified
417 -- True if 'f' is in scope, and has only one binding,
418 -- and the thing it is bound to is the name we are looking for
419 -- (i.e. false if A.f and B.f are both in scope as unqualified 'f')
421 -- [Out of date] Also checks for built-in syntax, which is always 'in scope'
422 unQualInScope env mod occ
423 = case lookupGRE_RdrName (mkRdrUnqual occ) env of
424 [gre] -> nameModuleName (gre_name gre) == mod
429 %************************************************************************
433 %************************************************************************
436 implicitTyThings :: TyThing -> [TyThing]
437 implicitTyThings (AnId id) = []
439 -- For type constructors, add the data cons (and their extras),
440 -- and the selectors and generic-programming Ids too
442 -- Newtypes don't have a worker Id, so don't generate that?
443 implicitTyThings (ATyCon tc) = map AnId (tyConSelIds tc) ++
444 concatMap (extras_plus . ADataCon) (tyConDataCons tc)
446 -- For classes, add the class TyCon too (and its extras)
447 -- and the class selector Ids
448 implicitTyThings (AClass cl) = map AnId (classSelIds cl) ++
449 extras_plus (ATyCon (classTyCon cl))
452 -- For data cons add the worker and wrapper (if any)
453 implicitTyThings (ADataCon dc) = map AnId (dataConImplicitIds dc)
455 extras_plus thing = thing : implicitTyThings thing
457 extendTypeEnvWithIds :: TypeEnv -> [Id] -> TypeEnv
458 extendTypeEnvWithIds env ids
459 = extendNameEnvList env [(getName id, AnId id) | id <- ids]
462 %************************************************************************
466 %************************************************************************
469 type TypeEnv = NameEnv TyThing
471 emptyTypeEnv :: TypeEnv
472 typeEnvElts :: TypeEnv -> [TyThing]
473 typeEnvClasses :: TypeEnv -> [Class]
474 typeEnvTyCons :: TypeEnv -> [TyCon]
475 typeEnvIds :: TypeEnv -> [Id]
476 lookupTypeEnv :: TypeEnv -> Name -> Maybe TyThing
478 emptyTypeEnv = emptyNameEnv
479 typeEnvElts env = nameEnvElts env
480 typeEnvClasses env = [cl | AClass cl <- typeEnvElts env]
481 typeEnvTyCons env = [tc | ATyCon tc <- typeEnvElts env]
482 typeEnvIds env = [id | AnId id <- typeEnvElts env]
484 mkTypeEnv :: [TyThing] -> TypeEnv
485 mkTypeEnv things = extendTypeEnvList emptyTypeEnv things
487 lookupTypeEnv = lookupNameEnv
489 -- Extend the type environment
490 extendTypeEnv :: TypeEnv -> TyThing -> TypeEnv
491 extendTypeEnv env thing = extendNameEnv env (getName thing) thing
493 extendTypeEnvList :: TypeEnv -> [TyThing] -> TypeEnv
494 extendTypeEnvList env things = foldl extendTypeEnv env things
498 lookupType :: HomePackageTable -> PackageTypeEnv -> Name -> Maybe TyThing
499 lookupType hpt pte name
500 = case lookupModuleEnv hpt (nameModule name) of
501 Just details -> lookupNameEnv (md_types (hm_details details)) name
502 Nothing -> lookupNameEnv pte name
507 tyThingTyCon (ATyCon tc) = tc
508 tyThingTyCon other = pprPanic "tyThingTyCon" (ppr other)
510 tyThingClass (AClass cls) = cls
511 tyThingClass other = pprPanic "tyThingClass" (ppr other)
513 tyThingDataCon (ADataCon dc) = dc
514 tyThingDataCon other = pprPanic "tyThingDataCon" (ppr other)
516 tyThingId (AnId id) = id
517 tyThingId other = pprPanic "tyThingId" (ppr other)
520 %************************************************************************
522 \subsection{Auxiliary types}
524 %************************************************************************
526 These types are defined here because they are mentioned in ModDetails,
527 but they are mostly elaborated elsewhere
530 mkIfaceVerCache :: [(Version,IfaceDecl)] -> OccName -> Maybe Version
531 mkIfaceVerCache pairs
532 = \occ -> lookupOccEnv env occ
534 env = foldl add emptyOccEnv pairs
535 add env (v,d) = extendOccEnv env (ifName d) v
537 emptyIfaceVerCache :: OccName -> Maybe Version
538 emptyIfaceVerCache occ = Nothing
540 ------------------ Deprecations -------------------------
543 | DeprecAll DeprecTxt -- Whole module deprecated
544 | DeprecSome a -- Some specific things deprecated
547 type IfaceDeprecs = Deprecs [(OccName,DeprecTxt)]
548 type Deprecations = Deprecs (NameEnv (OccName,DeprecTxt))
550 mkIfaceDepCache:: IfaceDeprecs -> Name -> Maybe DeprecTxt
551 mkIfaceDepCache NoDeprecs = \n -> Nothing
552 mkIfaceDepCache (DeprecAll t) = \n -> Just t
553 mkIfaceDepCache (DeprecSome pairs) = lookupOccEnv (mkOccEnv pairs) . nameOccName
555 emptyIfaceDepCache :: Name -> Maybe DeprecTxt
556 emptyIfaceDepCache n = Nothing
558 lookupDeprec :: Deprecations -> Name -> Maybe DeprecTxt
559 lookupDeprec NoDeprecs name = Nothing
560 lookupDeprec (DeprecAll txt) name = Just txt
561 lookupDeprec (DeprecSome env) name = case lookupNameEnv env name of
562 Just (_, txt) -> Just txt
565 plusDeprecs :: Deprecations -> Deprecations -> Deprecations
566 plusDeprecs d NoDeprecs = d
567 plusDeprecs NoDeprecs d = d
568 plusDeprecs d (DeprecAll t) = DeprecAll t
569 plusDeprecs (DeprecAll t) d = DeprecAll t
570 plusDeprecs (DeprecSome v1) (DeprecSome v2) = DeprecSome (v1 `plusNameEnv` v2)
575 type Avails = [AvailInfo]
576 type AvailInfo = GenAvailInfo Name
577 type RdrAvailInfo = GenAvailInfo OccName
579 data GenAvailInfo name = Avail name -- An ordinary identifier
580 | AvailTC name -- The name of the type or class
581 [name] -- The available pieces of type/class.
582 -- NB: If the type or class is itself
583 -- to be in scope, it must be in this list.
584 -- Thus, typically: AvailTC Eq [Eq, ==, /=]
586 -- Equality used when deciding if the interface has changed
588 type IfaceExport = (ModuleName, [GenAvailInfo OccName])
590 availsToNameSet :: [AvailInfo] -> NameSet
591 availsToNameSet avails = foldl add emptyNameSet avails
593 add set avail = addListToNameSet set (availNames avail)
595 availName :: GenAvailInfo name -> name
596 availName (Avail n) = n
597 availName (AvailTC n _) = n
599 availNames :: GenAvailInfo name -> [name]
600 availNames (Avail n) = [n]
601 availNames (AvailTC n ns) = ns
603 instance Outputable n => Outputable (GenAvailInfo n) where
606 pprAvail :: Outputable n => GenAvailInfo n -> SDoc
607 pprAvail (AvailTC n ns) = ppr n <> case {- filter (/= n) -} ns of
609 ns' -> braces (hsep (punctuate comma (map ppr ns')))
611 pprAvail (Avail n) = ppr n
615 mkIfaceFixCache :: [(OccName, Fixity)] -> OccName -> Fixity
616 mkIfaceFixCache pairs
617 = \n -> lookupOccEnv env n `orElse` defaultFixity
621 emptyIfaceFixCache :: OccName -> Fixity
622 emptyIfaceFixCache n = defaultFixity
624 -- This fixity environment is for source code only
625 type FixityEnv = NameEnv FixItem
627 -- We keep the OccName in the range so that we can generate an interface from it
628 data FixItem = FixItem OccName Fixity SrcSpan
630 instance Outputable FixItem where
631 ppr (FixItem occ fix loc) = ppr fix <+> ppr occ <+> parens (ppr loc)
633 emptyFixityEnv :: FixityEnv
634 emptyFixityEnv = emptyNameEnv
636 lookupFixity :: FixityEnv -> Name -> Fixity
637 lookupFixity env n = case lookupNameEnv env n of
638 Just (FixItem _ fix _) -> fix
639 Nothing -> defaultFixity
643 %************************************************************************
645 \subsection{WhatsImported}
647 %************************************************************************
650 type WhetherHasOrphans = Bool
652 -- * an instance decl in a module other than the defn module for
653 -- one of the tycons or classes in the instance head
654 -- * a transformation rule in a module other than the one defining
655 -- the function in the head of the rule.
657 type IsBootInterface = Bool
659 -- Dependency info about modules and packages below this one
660 -- in the import hierarchy. See TcRnTypes.ImportAvails for details.
662 -- Invariant: the dependencies of a module M never includes M
663 -- Invariant: the lists are unordered, with no duplicates
665 = Deps { dep_mods :: [(ModuleName,IsBootInterface)], -- Home-package module dependencies
666 dep_pkgs :: [PackageName], -- External package dependencies
667 dep_orphs :: [ModuleName] } -- Orphan modules (whether home or external pkg)
669 noDependencies :: Dependencies
670 noDependencies = Deps [] [] []
673 = Usage { usg_name :: ModuleName, -- Name of the module
674 usg_mod :: Version, -- Module version
675 usg_entities :: [(OccName,Version)], -- Sorted by occurrence name
676 usg_exports :: Maybe Version, -- Export-list version, if we depend on it
677 usg_rules :: Version -- Orphan-rules version (for non-orphan
678 -- modules this will always be initialVersion)
680 -- This type doesn't let you say "I imported f but none of the rules in
681 -- the module". If you use anything in the module you get its rule version
682 -- So if the rules change, you'll recompile, even if you don't use them.
683 -- This is easy to implement, and it's safer: you might not have used the rules last
684 -- time round, but if someone has added a new rule you might need it this time
686 -- The export list field is (Just v) if we depend on the export list:
687 -- i.e. we imported the module without saying exactly what we imported
688 -- We need to recompile if the module exports changes, because we might
689 -- now have a name clash in the importing module.
693 %************************************************************************
695 The External Package State
697 %************************************************************************
700 type PackageTypeEnv = TypeEnv
701 type PackageRuleBase = RuleBase
702 type PackageInstEnv = InstEnv
704 data ExternalPackageState
706 eps_is_boot :: !(ModuleEnv (ModuleName, IsBootInterface)),
707 -- In OneShot mode (only), home-package modules accumulate in the
708 -- external package state, and are sucked in lazily.
709 -- For these home-pkg modules (only) we need to record which are
710 -- boot modules. We set this field after loading all the
711 -- explicitly-imported interfaces, but before doing anything else
713 -- The ModuleName part is not necessary, but it's useful for
714 -- debug prints, and it's convenient because this field comes
715 -- direct from TcRnTypes.ImportAvails.imp_dep_mods
717 eps_PIT :: !PackageIfaceTable,
718 -- The ModuleIFaces for modules in external packages
719 -- whose interfaces we have opened
720 -- The declarations in these interface files are held in
721 -- eps_decls, eps_insts, eps_rules (below), not in the
722 -- mi_decls fields of the iPIT.
723 -- What _is_ in the iPIT is:
730 eps_PTE :: !PackageTypeEnv, -- Domain = external-package modules
732 eps_inst_env :: !PackageInstEnv, -- The total InstEnv accumulated from
733 -- all the external-package modules
734 eps_rule_base :: !PackageRuleBase, -- Ditto RuleEnv
737 -- Holding pens for stuff that has been read in from file,
738 -- but not yet slurped into the renamer
739 eps_insts :: !InstPool,
740 -- The as-yet un-slurped instance decls
741 -- Decls move from here to eps_inst_env
742 -- Each instance is 'gated' by the names that must be
743 -- available before this instance decl is needed.
745 eps_rules :: !RulePool,
746 -- The as-yet un-slurped rules
748 eps_stats :: !EpsStats
751 -- "In" means read from iface files
752 -- "Out" means actually sucked in and type-checked
753 data EpsStats = EpsStats { n_ifaces_in
754 , n_decls_in, n_decls_out
755 , n_rules_in, n_rules_out
756 , n_insts_in, n_insts_out :: !Int }
759 The NameCache makes sure that there is just one Unique assigned for
760 each original name; i.e. (module-name, occ-name) pair. The Name is
761 always stored as a Global, and has the SrcLoc of its binding location.
762 Actually that's not quite right. When we first encounter the original
763 name, we might not be at its binding site (e.g. we are reading an
764 interface file); so we give it 'noSrcLoc' then. Later, when we find
765 its binding site, we fix it up.
767 Exactly the same is true of the Module stored in the Name. When we first
768 encounter the occurrence, we may not know the details of the module, so
769 we just store junk. Then when we find the binding site, we fix it up.
773 = NameCache { nsUniqs :: UniqSupply,
775 nsNames :: OrigNameCache,
776 -- Ensures that one original name gets one unique
777 nsIPs :: OrigIParamCache
778 -- Ensures that one implicit parameter name gets one unique
781 type OrigNameCache = ModuleEnv (OccEnv Name)
782 type OrigIParamCache = FiniteMap (IPName OccName) (IPName Name)
786 type Gated d = ([Name], (ModuleName, d)) -- The [Name] 'gate' the declaration; always non-empty
787 -- ModuleName records which iface file this
790 type RulePool = [Gated IfaceRule]
792 addRulesToPool :: RulePool
795 addRulesToPool rules new_rules = new_rules ++ rules
797 -------------------------
798 addEpsInStats :: EpsStats -> Int -> Int -> Int -> EpsStats
799 -- Add stats for one newly-read interface
800 addEpsInStats stats n_decls n_insts n_rules
801 = stats { n_ifaces_in = n_ifaces_in stats + 1
802 , n_decls_in = n_decls_in stats + n_decls
803 , n_insts_in = n_insts_in stats + n_insts
804 , n_rules_in = n_rules_in stats + n_rules }
806 -------------------------
807 type InstPool = NameEnv [Gated IfaceInst]
808 -- The key of the Pool is the Class
809 -- The Names are the TyCons in the instance head
810 -- For example, suppose this is in an interface file
811 -- instance C T where ...
812 -- We want to slurp this decl if both C and T are "visible" in
813 -- the importing module. See "The gating story" in RnIfaces for details.
816 addInstsToPool :: InstPool -> [(Name, Gated IfaceInst)] -> InstPool
817 addInstsToPool insts new_insts
818 = foldr add insts new_insts
820 add :: (Name, Gated IfaceInst) -> NameEnv [Gated IfaceInst] -> NameEnv [Gated IfaceInst]
821 add (cls,new_inst) insts = extendNameEnv_C combine insts cls [new_inst]
823 combine old_insts _ = new_inst : old_insts
827 %************************************************************************
829 \subsection{Linkable stuff}
831 %************************************************************************
833 This stuff is in here, rather than (say) in Linker.lhs, because the Linker.lhs
834 stuff is the *dynamic* linker, and isn't present in a stage-1 compiler
838 linkableTime :: ClockTime, -- Time at which this linkable was built
839 -- (i.e. when the bytecodes were produced,
840 -- or the mod date on the files)
841 linkableModName :: ModuleName, -- Should be Module, but see below
842 linkableUnlinked :: [Unlinked]
845 isObjectLinkable :: Linkable -> Bool
846 isObjectLinkable l = all isObject (linkableUnlinked l)
848 instance Outputable Linkable where
849 ppr (LM when_made mod unlinkeds)
850 = (text "LinkableM" <+> parens (text (show when_made)) <+> ppr mod)
851 $$ nest 3 (ppr unlinkeds)
853 -------------------------------------------
858 | BCOs CompiledByteCode
861 data CompiledByteCode = NoByteCode
864 instance Outputable Unlinked where
865 ppr (DotO path) = text "DotO" <+> text path
866 ppr (DotA path) = text "DotA" <+> text path
867 ppr (DotDLL path) = text "DotDLL" <+> text path
869 ppr (BCOs bcos) = text "BCOs" <+> ppr bcos
871 ppr (BCOs bcos) = text "No byte code"
874 isObject (DotO _) = True
875 isObject (DotA _) = True
876 isObject (DotDLL _) = True
879 isInterpretable = not . isObject
881 nameOfObject (DotO fn) = fn
882 nameOfObject (DotA fn) = fn
883 nameOfObject (DotDLL fn) = fn
885 byteCodeOfObject (BCOs bc) = bc