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,
71 extendOccEnv, foldOccEnv )
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, isClassTyCon, 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 -- hsc_HPT is not mutable because we only demand-load
125 -- external packages; the home package is eagerly
126 -- loaded by the compilation manager.
128 -- The next two are side-effected by compiling
129 -- to reflect sucking in interface files
130 hsc_EPS :: IORef ExternalPackageState,
131 hsc_NC :: IORef NameCache }
133 hscEPS :: HscEnv -> IO ExternalPackageState
134 hscEPS hsc_env = readIORef (hsc_EPS hsc_env)
137 The GhciMode is self-explanatory:
140 data GhciMode = Batch -- ghc --make Main
141 | Interactive -- ghc --interactive
142 | OneShot -- ghc Foo.hs
143 | IDE -- Visual Studio etc
146 isOneShot :: GhciMode -> Bool
147 isOneShot OneShot = True
148 isOneShot _other = False
152 type HomePackageTable = ModuleEnv HomeModInfo -- Domain = modules in the home package
153 type PackageIfaceTable = ModuleEnv ModIface -- Domain = modules in the imported packages
155 emptyHomePackageTable = emptyModuleEnv
156 emptyPackageIfaceTable = emptyModuleEnv
159 = HomeModInfo { hm_iface :: ModIface,
160 hm_globals :: Maybe GlobalRdrEnv, -- Its top level environment
161 -- Nothing <-> compiled module
162 hm_details :: ModDetails,
163 hm_linkable :: Linkable }
166 Simple lookups in the symbol table.
169 lookupIface :: HomePackageTable -> PackageIfaceTable -> Module -> Maybe ModIface
170 -- We often have two IfaceTables, and want to do a lookup
171 lookupIface hpt pit mod
172 = case lookupModuleEnv hpt mod of
173 Just mod_info -> Just (hm_iface mod_info)
174 Nothing -> lookupModuleEnv pit mod
176 lookupIfaceByModName :: HomePackageTable -> PackageIfaceTable -> ModuleName -> Maybe ModIface
177 -- We often have two IfaceTables, and want to do a lookup
178 lookupIfaceByModName hpt pit mod
179 = case lookupModuleEnvByName hpt mod of
180 Just mod_info -> Just (hm_iface mod_info)
181 Nothing -> lookupModuleEnvByName pit mod
185 -- Use instead of Finder.findModule if possible: this way doesn't
186 -- require filesystem operations, and it is guaranteed not to fail
187 -- when the IfaceTables are properly populated (i.e. after the renamer).
188 moduleNameToModule :: HomePackageTable -> PackageIfaceTable -> ModuleName -> Module
189 moduleNameToModule hpt pit mod
190 = mi_module (fromJust (lookupIfaceByModName hpt pit mod))
194 %************************************************************************
196 \subsection{Symbol tables and Module details}
198 %************************************************************************
200 A @ModIface@ plus a @ModDetails@ summarises everything we know
201 about a compiled module. The @ModIface@ is the stuff *before* linking,
202 and can be written out to an interface file. (The @ModDetails@ is after
203 linking; it is the "linked" form of the mi_decls field.)
205 When we *read* an interface file, we also construct a @ModIface@ from it,
206 except that the mi_decls part is empty; when reading we consolidate
207 the declarations into a single indexed map in the @PersistentRenamerState@.
212 mi_package :: !PackageName, -- Which package the module comes from
213 mi_module :: !Module,
214 mi_mod_vers :: !Version, -- Module version: changes when anything changes
216 mi_orphan :: !WhetherHasOrphans, -- Whether this module has orphans
217 mi_boot :: !IsBootInterface, -- Read from an hi-boot file?
219 mi_deps :: Dependencies,
220 -- This is consulted for directly-imported modules,
221 -- but not for anything else (hence lazy)
223 -- Usages; kept sorted so that it's easy to decide
224 -- whether to write a new iface file (changing usages
225 -- doesn't affect the version of this module)
226 mi_usages :: [Usage],
227 -- NOT STRICT! we read this field lazily from the interface file
228 -- It is *only* consulted by the recompilation checker
231 -- Kept sorted by (mod,occ), to make version comparisons easier
232 mi_exports :: ![IfaceExport],
233 mi_exp_vers :: !Version, -- Version number of export list
236 mi_fixities :: [(OccName,Fixity)],
237 -- NOT STRICT! we read this field lazily from the interface file
240 mi_deprecs :: IfaceDeprecs,
241 -- NOT STRICT! we read this field lazily from the interface file
243 -- Type, class and variable declarations
244 -- The version of an Id changes if its fixity or deprecations change
245 -- (as well as its type of course)
246 -- Ditto data constructors, class operations, except that
247 -- the version of the parent class/tycon changes
248 mi_decls :: [(Version,IfaceDecl)], -- Sorted
250 -- Instance declarations and rules
251 mi_insts :: [IfaceInst], -- Sorted
252 mi_rules :: [IfaceRule], -- Sorted
253 mi_rule_vers :: !Version, -- Version number for rules and instances combined
255 -- Cached environments for easy lookup
256 -- These are computed (lazily) from other fields
257 -- and are not put into the interface file
258 mi_dep_fn :: Name -> Maybe DeprecTxt, -- Cached lookup for mi_deprecs
259 mi_fix_fn :: OccName -> Fixity, -- Cached lookup for mi_fixities
260 mi_ver_fn :: OccName -> Maybe Version -- Cached lookup for mi_decls
261 -- The Nothing in mi_ver_fn means that the thing
262 -- isn't in decls. It's useful to know that when
263 -- seeing if we are up to date wrt the old interface
266 -- Should be able to construct ModDetails from mi_decls in ModIface
269 -- The next three fields are created by the typechecker
270 md_types :: !TypeEnv,
271 md_insts :: ![DFunId], -- Dfun-ids for the instances in this module
272 md_rules :: ![IdCoreRule] -- Domain may include Ids from other modules
275 -- A ModGuts is carried through the compiler, accumulating stuff as it goes
276 -- There is only one ModGuts at any time, the one for the module
277 -- being compiled right now. Once it is compiled, a ModIface and
278 -- ModDetails are extracted and the ModGuts is dicarded.
282 mg_module :: !Module,
283 mg_exports :: !NameSet, -- What it exports
284 mg_deps :: !Dependencies, -- What is below it, directly or otherwise
285 mg_dir_imps :: ![Module], -- Directly-imported modules; used to
286 -- generate initialisation code
287 mg_usages :: ![Usage], -- Version info for what it needed
289 mg_rdr_env :: !GlobalRdrEnv, -- Top-level lexical environment
290 mg_fix_env :: !FixityEnv, -- Fixity env, for things declared in this module
291 mg_deprecs :: !Deprecations, -- Deprecations declared in the module
293 mg_types :: !TypeEnv,
294 mg_insts :: ![DFunId], -- Instances
295 mg_rules :: ![IdCoreRule], -- Rules from this module
296 mg_binds :: ![CoreBind], -- Bindings for this module
297 mg_foreign :: !ForeignStubs
300 -- The ModGuts takes on several slightly different forms:
302 -- After simplification, the following fields change slightly:
303 -- mg_rules Orphan rules only (local ones now attached to binds)
304 -- mg_binds With rules attached
306 -- After CoreTidy, the following fields change slightly:
307 -- mg_types Now contains Ids as well, replete with final IdInfo
308 -- The Ids are only the ones that are visible from
309 -- importing modules. Without -O that means only
310 -- exported Ids, but with -O importing modules may
311 -- see ids mentioned in unfoldings of exported Ids
313 -- mg_insts Same DFunIds as before, but with final IdInfo,
314 -- and the unique might have changed; remember that
315 -- CoreTidy links up the uniques of old and new versions
317 -- mg_rules All rules for exported things, substituted with final Ids
325 imp_direct :: ![(Module,Bool)], -- Explicitly-imported modules
326 -- Boolean is true if we imported the whole
327 -- module (apart, perhaps, from hiding some)
328 imp_pkg_mods :: !ModuleSet, -- Non-home-package modules on which we depend,
329 -- directly or indirectly
330 imp_home_names :: !NameSet -- Home package things on which we depend,
331 -- directly or indirectly
334 data ForeignStubs = NoStubs
336 SDoc -- Header file prototypes for
337 -- "foreign exported" functions
338 SDoc -- C stubs to use when calling
339 -- "foreign exported" functions
340 [FastString] -- Headers that need to be included
341 -- into C code generated for this module
342 [Id] -- Foreign-exported binders
343 -- we have to generate code to register these
348 emptyModIface :: PackageName -> ModuleName -> ModIface
349 emptyModIface pkg mod
350 = ModIface { mi_package = pkg,
351 mi_module = mkModule pkg mod,
352 mi_mod_vers = initialVersion,
355 mi_deps = noDependencies,
358 mi_exp_vers = initialVersion,
360 mi_deprecs = NoDeprecs,
364 mi_rule_vers = initialVersion,
365 mi_dep_fn = emptyIfaceDepCache,
366 mi_fix_fn = emptyIfaceFixCache,
367 mi_ver_fn = emptyIfaceVerCache
372 %************************************************************************
374 \subsection{The interactive context}
376 %************************************************************************
379 data InteractiveContext
380 = InteractiveContext {
381 ic_toplev_scope :: [String], -- Include the "top-level" scope of
384 ic_exports :: [String], -- Include just the exports of these
387 ic_rn_gbl_env :: GlobalRdrEnv, -- The cached GlobalRdrEnv, built from
388 -- ic_toplev_scope and ic_exports
390 ic_rn_local_env :: LocalRdrEnv, -- Lexical context for variables bound
391 -- during interaction
393 ic_type_env :: TypeEnv -- Ditto for types
396 emptyInteractiveContext
397 = InteractiveContext { ic_toplev_scope = [],
399 ic_rn_gbl_env = emptyGlobalRdrEnv,
400 ic_rn_local_env = emptyLocalRdrEnv,
401 ic_type_env = emptyTypeEnv }
403 icPrintUnqual :: InteractiveContext -> PrintUnqualified
404 icPrintUnqual ictxt = unQualInScope (ic_rn_gbl_env ictxt)
407 @unQualInScope@ returns a function that takes a @Name@ and tells whether
408 its unqualified name is in scope. This is put as a boolean flag in
409 the @Name@'s provenance to guide whether or not to print the name qualified
413 unQualInScope :: GlobalRdrEnv -> PrintUnqualified
414 -- True if 'f' is in scope, and has only one binding,
415 -- and the thing it is bound to is the name we are looking for
416 -- (i.e. false if A.f and B.f are both in scope as unqualified 'f')
418 -- [Out of date] Also checks for built-in syntax, which is always 'in scope'
419 unQualInScope env mod occ
420 = case lookupGRE_RdrName (mkRdrUnqual occ) env of
421 [gre] -> nameModuleName (gre_name gre) == mod
426 %************************************************************************
430 %************************************************************************
433 implicitTyThings :: TyThing -> [TyThing]
434 implicitTyThings (AnId id) = []
436 -- For type constructors, add the data cons (and their extras),
437 -- and the selectors and generic-programming Ids too
439 -- Newtypes don't have a worker Id, so don't generate that?
440 implicitTyThings (ATyCon tc) = map AnId (tyConSelIds tc) ++
441 concatMap (extras_plus . ADataCon) (tyConDataCons tc)
443 -- For classes, add the class TyCon too (and its extras)
444 -- and the class selector Ids
445 implicitTyThings (AClass cl) = map AnId (classSelIds cl) ++
446 extras_plus (ATyCon (classTyCon cl))
449 -- For data cons add the worker and wrapper (if any)
450 implicitTyThings (ADataCon dc) = map AnId (dataConImplicitIds dc)
452 extras_plus thing = thing : implicitTyThings thing
454 extendTypeEnvWithIds :: TypeEnv -> [Id] -> TypeEnv
455 extendTypeEnvWithIds env ids
456 = extendNameEnvList env [(getName id, AnId id) | id <- ids]
459 %************************************************************************
463 %************************************************************************
466 type TypeEnv = NameEnv TyThing
468 emptyTypeEnv :: TypeEnv
469 typeEnvElts :: TypeEnv -> [TyThing]
470 typeEnvClasses :: TypeEnv -> [Class]
471 typeEnvTyCons :: TypeEnv -> [TyCon]
472 typeEnvIds :: TypeEnv -> [Id]
473 lookupTypeEnv :: TypeEnv -> Name -> Maybe TyThing
475 emptyTypeEnv = emptyNameEnv
476 typeEnvElts env = nameEnvElts env
477 typeEnvClasses env = [cl | AClass cl <- typeEnvElts env]
478 typeEnvTyCons env = [tc | ATyCon tc <- typeEnvElts env]
479 typeEnvIds env = [id | AnId id <- typeEnvElts env]
481 mkTypeEnv :: [TyThing] -> TypeEnv
482 mkTypeEnv things = extendTypeEnvList emptyTypeEnv things
484 lookupTypeEnv = lookupNameEnv
486 -- Extend the type environment
487 extendTypeEnv :: TypeEnv -> TyThing -> TypeEnv
488 extendTypeEnv env thing = extendNameEnv env (getName thing) thing
490 extendTypeEnvList :: TypeEnv -> [TyThing] -> TypeEnv
491 extendTypeEnvList env things = foldl extendTypeEnv env things
495 lookupType :: HomePackageTable -> PackageTypeEnv -> Name -> Maybe TyThing
496 lookupType hpt pte name
497 = case lookupModuleEnv hpt (nameModule name) of
498 Just details -> lookupNameEnv (md_types (hm_details details)) name
499 Nothing -> lookupNameEnv pte name
504 tyThingTyCon (ATyCon tc) = tc
505 tyThingTyCon other = pprPanic "tyThingTyCon" (ppr other)
507 tyThingClass (AClass cls) = cls
508 tyThingClass other = pprPanic "tyThingClass" (ppr other)
510 tyThingDataCon (ADataCon dc) = dc
511 tyThingDataCon other = pprPanic "tyThingDataCon" (ppr other)
513 tyThingId (AnId id) = id
514 tyThingId other = pprPanic "tyThingId" (ppr other)
517 %************************************************************************
519 \subsection{Auxiliary types}
521 %************************************************************************
523 These types are defined here because they are mentioned in ModDetails,
524 but they are mostly elaborated elsewhere
527 mkIfaceVerCache :: [(Version,IfaceDecl)] -> OccName -> Maybe Version
528 mkIfaceVerCache pairs
529 = \occ -> lookupOccEnv env occ
531 env = foldl add emptyOccEnv pairs
532 add env (v,d) = extendOccEnv env (ifName d) v
534 emptyIfaceVerCache :: OccName -> Maybe Version
535 emptyIfaceVerCache occ = Nothing
537 ------------------ Deprecations -------------------------
540 | DeprecAll DeprecTxt -- Whole module deprecated
541 | DeprecSome a -- Some specific things deprecated
544 type IfaceDeprecs = Deprecs [(OccName,DeprecTxt)]
545 type Deprecations = Deprecs (NameEnv (OccName,DeprecTxt))
547 mkIfaceDepCache:: IfaceDeprecs -> Name -> Maybe DeprecTxt
548 mkIfaceDepCache NoDeprecs = \n -> Nothing
549 mkIfaceDepCache (DeprecAll t) = \n -> Just t
550 mkIfaceDepCache (DeprecSome pairs) = lookupOccEnv (mkOccEnv pairs) . nameOccName
552 emptyIfaceDepCache :: Name -> Maybe DeprecTxt
553 emptyIfaceDepCache n = Nothing
555 lookupDeprec :: Deprecations -> Name -> Maybe DeprecTxt
556 lookupDeprec NoDeprecs name = Nothing
557 lookupDeprec (DeprecAll txt) name = Just txt
558 lookupDeprec (DeprecSome env) name = case lookupNameEnv env name of
559 Just (_, txt) -> Just txt
562 plusDeprecs :: Deprecations -> Deprecations -> Deprecations
563 plusDeprecs d NoDeprecs = d
564 plusDeprecs NoDeprecs d = d
565 plusDeprecs d (DeprecAll t) = DeprecAll t
566 plusDeprecs (DeprecAll t) d = DeprecAll t
567 plusDeprecs (DeprecSome v1) (DeprecSome v2) = DeprecSome (v1 `plusNameEnv` v2)
572 type Avails = [AvailInfo]
573 type AvailInfo = GenAvailInfo Name
574 type RdrAvailInfo = GenAvailInfo OccName
576 data GenAvailInfo name = Avail name -- An ordinary identifier
577 | AvailTC name -- The name of the type or class
578 [name] -- The available pieces of type/class.
579 -- NB: If the type or class is itself
580 -- to be in scope, it must be in this list.
581 -- Thus, typically: AvailTC Eq [Eq, ==, /=]
583 -- Equality used when deciding if the interface has changed
585 type IfaceExport = (ModuleName, [GenAvailInfo OccName])
587 availsToNameSet :: [AvailInfo] -> NameSet
588 availsToNameSet avails = foldl add emptyNameSet avails
590 add set avail = addListToNameSet set (availNames avail)
592 availName :: GenAvailInfo name -> name
593 availName (Avail n) = n
594 availName (AvailTC n _) = n
596 availNames :: GenAvailInfo name -> [name]
597 availNames (Avail n) = [n]
598 availNames (AvailTC n ns) = ns
600 instance Outputable n => Outputable (GenAvailInfo n) where
603 pprAvail :: Outputable n => GenAvailInfo n -> SDoc
604 pprAvail (AvailTC n ns) = ppr n <> case {- filter (/= n) -} ns of
606 ns' -> braces (hsep (punctuate comma (map ppr ns')))
608 pprAvail (Avail n) = ppr n
612 mkIfaceFixCache :: [(OccName, Fixity)] -> OccName -> Fixity
613 mkIfaceFixCache pairs
614 = \n -> lookupOccEnv env n `orElse` defaultFixity
618 emptyIfaceFixCache :: OccName -> Fixity
619 emptyIfaceFixCache n = defaultFixity
621 -- This fixity environment is for source code only
622 type FixityEnv = NameEnv FixItem
624 -- We keep the OccName in the range so that we can generate an interface from it
625 data FixItem = FixItem OccName Fixity SrcSpan
627 instance Outputable FixItem where
628 ppr (FixItem occ fix loc) = ppr fix <+> ppr occ <+> parens (ppr loc)
630 emptyFixityEnv :: FixityEnv
631 emptyFixityEnv = emptyNameEnv
633 lookupFixity :: FixityEnv -> Name -> Fixity
634 lookupFixity env n = case lookupNameEnv env n of
635 Just (FixItem _ fix _) -> fix
636 Nothing -> defaultFixity
640 %************************************************************************
642 \subsection{WhatsImported}
644 %************************************************************************
647 type WhetherHasOrphans = Bool
649 -- * an instance decl in a module other than the defn module for
650 -- one of the tycons or classes in the instance head
651 -- * a transformation rule in a module other than the one defining
652 -- the function in the head of the rule.
654 type IsBootInterface = Bool
656 -- Dependency info about modules and packages below this one
657 -- in the import hierarchy. See TcRnTypes.ImportAvails for details.
659 -- Invariant: the dependencies of a module M never includes M
660 -- Invariant: the lists are unordered, with no duplicates
662 = Deps { dep_mods :: [(ModuleName,IsBootInterface)], -- Home-package module dependencies
663 dep_pkgs :: [PackageName], -- External package dependencies
664 dep_orphs :: [ModuleName] } -- Orphan modules (whether home or external pkg)
666 noDependencies :: Dependencies
667 noDependencies = Deps [] [] []
670 = Usage { usg_name :: ModuleName, -- Name of the module
671 usg_mod :: Version, -- Module version
672 usg_entities :: [(OccName,Version)], -- Sorted by occurrence name
673 usg_exports :: Maybe Version, -- Export-list version, if we depend on it
674 usg_rules :: Version -- Orphan-rules version (for non-orphan
675 -- modules this will always be initialVersion)
677 -- This type doesn't let you say "I imported f but none of the rules in
678 -- the module". If you use anything in the module you get its rule version
679 -- So if the rules change, you'll recompile, even if you don't use them.
680 -- This is easy to implement, and it's safer: you might not have used the rules last
681 -- time round, but if someone has added a new rule you might need it this time
683 -- The export list field is (Just v) if we depend on the export list:
684 -- i.e. we imported the module without saying exactly what we imported
685 -- We need to recompile if the module exports changes, because we might
686 -- now have a name clash in the importing module.
690 %************************************************************************
692 The External Package State
694 %************************************************************************
697 type PackageTypeEnv = TypeEnv
698 type PackageRuleBase = RuleBase
699 type PackageInstEnv = InstEnv
701 data ExternalPackageState
703 eps_is_boot :: !(ModuleEnv (ModuleName, IsBootInterface)),
704 -- In OneShot mode (only), home-package modules accumulate in the
705 -- external package state, and are sucked in lazily.
706 -- For these home-pkg modules (only) we need to record which are
707 -- boot modules. We set this field after loading all the
708 -- explicitly-imported interfaces, but before doing anything else
710 -- The ModuleName part is not necessary, but it's useful for
711 -- debug prints, and it's convenient because this field comes
712 -- direct from TcRnTypes.ImportAvails.imp_dep_mods
714 eps_PIT :: !PackageIfaceTable,
715 -- The ModuleIFaces for modules in external packages
716 -- whose interfaces we have opened
717 -- The declarations in these interface files are held in
718 -- eps_decls, eps_insts, eps_rules (below), not in the
719 -- mi_decls fields of the iPIT.
720 -- What _is_ in the iPIT is:
727 eps_PTE :: !PackageTypeEnv, -- Domain = external-package modules
729 eps_inst_env :: !PackageInstEnv, -- The total InstEnv accumulated from
730 -- all the external-package modules
731 eps_rule_base :: !PackageRuleBase, -- Ditto RuleEnv
734 -- Holding pens for stuff that has been read in from file,
735 -- but not yet slurped into the renamer
736 eps_insts :: !InstPool,
737 -- The as-yet un-slurped instance decls
738 -- Decls move from here to eps_inst_env
739 -- Each instance is 'gated' by the names that must be
740 -- available before this instance decl is needed.
742 eps_rules :: !RulePool,
743 -- The as-yet un-slurped rules
745 eps_stats :: !EpsStats
748 -- "In" means read from iface files
749 -- "Out" means actually sucked in and type-checked
750 data EpsStats = EpsStats { n_ifaces_in
751 , n_decls_in, n_decls_out
752 , n_rules_in, n_rules_out
753 , n_insts_in, n_insts_out :: !Int }
756 The NameCache makes sure that there is just one Unique assigned for
757 each original name; i.e. (module-name, occ-name) pair. The Name is
758 always stored as a Global, and has the SrcLoc of its binding location.
759 Actually that's not quite right. When we first encounter the original
760 name, we might not be at its binding site (e.g. we are reading an
761 interface file); so we give it 'noSrcLoc' then. Later, when we find
762 its binding site, we fix it up.
764 Exactly the same is true of the Module stored in the Name. When we first
765 encounter the occurrence, we may not know the details of the module, so
766 we just store junk. Then when we find the binding site, we fix it up.
770 = NameCache { nsUniqs :: UniqSupply,
772 nsNames :: OrigNameCache,
773 -- Ensures that one original name gets one unique
774 nsIPs :: OrigIParamCache
775 -- Ensures that one implicit parameter name gets one unique
778 type OrigNameCache = ModuleEnv (OccEnv Name)
779 type OrigIParamCache = FiniteMap (IPName OccName) (IPName Name)
783 type Gated d = ([Name], (ModuleName, d)) -- The [Name] 'gate' the declaration; always non-empty
784 -- ModuleName records which iface file this
787 type RulePool = [Gated IfaceRule]
789 addRulesToPool :: RulePool
792 addRulesToPool rules new_rules = new_rules ++ rules
794 -------------------------
795 addEpsInStats :: EpsStats -> Int -> Int -> Int -> EpsStats
796 -- Add stats for one newly-read interface
797 addEpsInStats stats n_decls n_insts n_rules
798 = stats { n_ifaces_in = n_ifaces_in stats + 1
799 , n_decls_in = n_decls_in stats + n_decls
800 , n_insts_in = n_insts_in stats + n_insts
801 , n_rules_in = n_rules_in stats + n_rules }
803 -------------------------
804 type InstPool = NameEnv [Gated IfaceInst]
805 -- The key of the Pool is the Class
806 -- The Names are the TyCons in the instance head
807 -- For example, suppose this is in an interface file
808 -- instance C T where ...
809 -- We want to slurp this decl if both C and T are "visible" in
810 -- the importing module. See "The gating story" in RnIfaces for details.
813 addInstsToPool :: InstPool -> [(Name, Gated IfaceInst)] -> InstPool
814 addInstsToPool insts new_insts
815 = foldr add insts new_insts
817 add :: (Name, Gated IfaceInst) -> NameEnv [Gated IfaceInst] -> NameEnv [Gated IfaceInst]
818 add (cls,new_inst) insts = extendNameEnv_C combine insts cls [new_inst]
820 combine old_insts _ = new_inst : old_insts
824 %************************************************************************
826 \subsection{Linkable stuff}
828 %************************************************************************
830 This stuff is in here, rather than (say) in Linker.lhs, because the Linker.lhs
831 stuff is the *dynamic* linker, and isn't present in a stage-1 compiler
835 linkableTime :: ClockTime, -- Time at which this linkable was built
836 -- (i.e. when the bytecodes were produced,
837 -- or the mod date on the files)
838 linkableModName :: ModuleName, -- Should be Module, but see below
839 linkableUnlinked :: [Unlinked]
842 isObjectLinkable :: Linkable -> Bool
843 isObjectLinkable l = all isObject (linkableUnlinked l)
845 instance Outputable Linkable where
846 ppr (LM when_made mod unlinkeds)
847 = (text "LinkableM" <+> parens (text (show when_made)) <+> ppr mod)
848 $$ nest 3 (ppr unlinkeds)
850 -------------------------------------------
855 | BCOs CompiledByteCode
858 data CompiledByteCode = NoByteCode
861 instance Outputable Unlinked where
862 ppr (DotO path) = text "DotO" <+> text path
863 ppr (DotA path) = text "DotA" <+> text path
864 ppr (DotDLL path) = text "DotDLL" <+> text path
866 ppr (BCOs bcos) = text "BCOs" <+> ppr bcos
868 ppr (BCOs bcos) = text "No byte code"
871 isObject (DotO _) = True
872 isObject (DotA _) = True
873 isObject (DotDLL _) = True
876 isInterpretable = not . isObject
878 nameOfObject (DotO fn) = fn
879 nameOfObject (DotA fn) = fn
880 nameOfObject (DotDLL fn) = fn
882 byteCodeOfObject (BCOs bc) = bc