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,
15 hptInstances, hptRules,
17 ExternalPackageState(..), EpsStats(..), addEpsInStats,
18 PackageTypeEnv, PackageIfaceTable, emptyPackageIfaceTable,
19 lookupIface, lookupIfaceByModule, emptyModIface,
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 )
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 ( PackageIdH, PackageId )
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, fromJust )
94 import SrcLoc ( SrcSpan )
95 import UniqSupply ( UniqSupply )
96 import FastString ( FastString )
98 import DATA_IOREF ( IORef, readIORef )
99 import Time ( ClockTime )
103 %************************************************************************
105 \subsection{Compilation environment}
107 %************************************************************************
109 The HscEnv gives the environment in which to compile a chunk of code.
113 = HscEnv { hsc_mode :: GhciMode,
114 hsc_dflags :: DynFlags,
116 hsc_HPT :: HomePackageTable,
117 -- The home package table describes already-compiled
118 -- home-packge modules, *excluding* the module we
119 -- are compiling right now.
120 -- (In one-shot mode the current module is the only
121 -- home-package module, so hsc_HPT is empty. All other
122 -- modules count as "external-package" modules.
123 -- However, even in GHCi mode, hi-boot interfaces are
124 -- demand-loadeded into the external-package table.)
126 -- hsc_HPT is not mutable because we only demand-load
127 -- external packages; the home package is eagerly
128 -- loaded, module by module, by the compilation manager.
130 -- The HPT may contain modules compiled earlier by --make
131 -- but not actually below the current module in the dependency
132 -- graph. (This changes a previous invariant: changed Jan 05.)
134 -- The next two are side-effected by compiling
135 -- to reflect sucking in interface files
136 hsc_EPS :: IORef ExternalPackageState,
137 hsc_NC :: IORef NameCache }
139 hscEPS :: HscEnv -> IO ExternalPackageState
140 hscEPS hsc_env = readIORef (hsc_EPS hsc_env)
143 The GhciMode is self-explanatory:
146 data GhciMode = Batch -- ghc --make Main
147 | Interactive -- ghc --interactive
148 | OneShot -- ghc Foo.hs
149 | IDE -- Visual Studio etc
152 isOneShot :: GhciMode -> Bool
153 isOneShot OneShot = True
154 isOneShot _other = False
158 type HomePackageTable = ModuleEnv HomeModInfo -- Domain = modules in the home package
159 type PackageIfaceTable = ModuleEnv ModIface -- Domain = modules in the imported packages
161 emptyHomePackageTable = emptyModuleEnv
162 emptyPackageIfaceTable = emptyModuleEnv
165 = HomeModInfo { hm_iface :: ModIface,
166 hm_globals :: Maybe GlobalRdrEnv, -- Its top level environment
167 -- Nothing <-> compiled module
168 hm_details :: ModDetails,
169 hm_linkable :: Linkable }
172 Simple lookups in the symbol table.
175 lookupIface :: HomePackageTable -> PackageIfaceTable -> Module -> Maybe ModIface
176 -- We often have two IfaceTables, and want to do a lookup
177 lookupIface hpt pit mod
178 = case lookupModuleEnv hpt mod of
179 Just mod_info -> Just (hm_iface mod_info)
180 Nothing -> lookupModuleEnv pit mod
182 lookupIfaceByModule :: HomePackageTable -> PackageIfaceTable -> Module -> Maybe ModIface
183 -- We often have two IfaceTables, and want to do a lookup
184 lookupIfaceByModule hpt pit mod
185 = case lookupModuleEnv hpt mod of
186 Just mod_info -> Just (hm_iface mod_info)
187 Nothing -> lookupModuleEnv pit mod
192 hptInstances :: HscEnv -> [(Module, IsBootInterface)] -> [DFunId]
193 -- Find all the instance declarations that are in modules imported
194 -- by this one, directly or indirectly, and are in the Home Package Table
195 -- This ensures that we don't see instances from modules --make compiled
196 -- before this one, but which are not below this one
197 hptInstances hsc_env deps
198 | isOneShot (hsc_mode hsc_env) = [] -- In one-shot mode, the HPT is empty
201 hpt = hsc_HPT hsc_env
204 | -- Find each non-hi-boot module below me
207 -- Look it up in the HPT
208 , let mod_info = ASSERT2( mod `elemModuleEnv` hpt, ppr mod $$ vcat (map ppr_hm (moduleEnvElts hpt)))
209 fromJust (lookupModuleEnv hpt mod)
212 , dfun <- md_insts (hm_details mod_info) ]
214 ppr_hm hm = ppr (mi_module (hm_iface hm))
216 hptRules :: HscEnv -> [(Module, IsBootInterface)] -> [IdCoreRule]
217 -- Get rules from modules "below" this one (in the dependency sense)
218 -- C.f Inst.hptInstances
219 hptRules hsc_env deps
220 | isOneShot (hsc_mode hsc_env) = []
223 hpt = hsc_HPT hsc_env
226 | -- Find each non-hi-boot module below me
229 -- Look it up in the HPT
230 , let mod_info = ASSERT( mod `elemModuleEnv` hpt )
231 fromJust (lookupModuleEnv hpt mod)
234 , rule <- md_rules (hm_details mod_info) ]
238 %************************************************************************
240 \subsection{Symbol tables and Module details}
242 %************************************************************************
244 A @ModIface@ plus a @ModDetails@ summarises everything we know
245 about a compiled module. The @ModIface@ is the stuff *before* linking,
246 and can be written out to an interface file. (The @ModDetails@ is after
247 linking; it is the "linked" form of the mi_decls field.)
249 When we *read* an interface file, we also construct a @ModIface@ from it,
250 except that the mi_decls part is empty; when reading we consolidate
251 the declarations into a single indexed map in the @PersistentRenamerState@.
256 mi_package :: !PackageIdH, -- Which package the module comes from
257 mi_module :: !Module,
258 mi_mod_vers :: !Version, -- Module version: changes when anything changes
260 mi_orphan :: !WhetherHasOrphans, -- Whether this module has orphans
261 mi_boot :: !IsBootInterface, -- Read from an hi-boot file?
263 mi_deps :: Dependencies,
264 -- This is consulted for directly-imported modules,
265 -- but not for anything else (hence lazy)
267 -- Usages; kept sorted so that it's easy to decide
268 -- whether to write a new iface file (changing usages
269 -- doesn't affect the version of this module)
270 mi_usages :: [Usage],
271 -- NOT STRICT! we read this field lazily from the interface file
272 -- It is *only* consulted by the recompilation checker
275 -- Kept sorted by (mod,occ), to make version comparisons easier
276 mi_exports :: ![IfaceExport],
277 mi_exp_vers :: !Version, -- Version number of export list
280 mi_fixities :: [(OccName,Fixity)],
281 -- NOT STRICT! we read this field lazily from the interface file
284 mi_deprecs :: IfaceDeprecs,
285 -- NOT STRICT! we read this field lazily from the interface file
287 -- Type, class and variable declarations
288 -- The version of an Id changes if its fixity or deprecations change
289 -- (as well as its type of course)
290 -- Ditto data constructors, class operations, except that
291 -- the version of the parent class/tycon changes
292 mi_decls :: [(Version,IfaceDecl)], -- Sorted
294 -- Instance declarations and rules
295 mi_insts :: [IfaceInst], -- Sorted
296 mi_rules :: [IfaceRule], -- Sorted
297 mi_rule_vers :: !Version, -- Version number for rules and instances combined
299 -- Cached environments for easy lookup
300 -- These are computed (lazily) from other fields
301 -- and are not put into the interface file
302 mi_dep_fn :: Name -> Maybe DeprecTxt, -- Cached lookup for mi_deprecs
303 mi_fix_fn :: OccName -> Fixity, -- Cached lookup for mi_fixities
304 mi_ver_fn :: OccName -> Maybe Version -- Cached lookup for mi_decls
305 -- The Nothing in mi_ver_fn means that the thing
306 -- isn't in decls. It's useful to know that when
307 -- seeing if we are up to date wrt the old interface
310 -- Should be able to construct ModDetails from mi_decls in ModIface
313 -- The next three fields are created by the typechecker
314 md_types :: !TypeEnv,
315 md_insts :: ![DFunId], -- Dfun-ids for the instances in this module
316 md_rules :: ![IdCoreRule] -- Domain may include Ids from other modules
319 -- A ModGuts is carried through the compiler, accumulating stuff as it goes
320 -- There is only one ModGuts at any time, the one for the module
321 -- being compiled right now. Once it is compiled, a ModIface and
322 -- ModDetails are extracted and the ModGuts is dicarded.
326 mg_module :: !Module,
327 mg_exports :: !NameSet, -- What it exports
328 mg_deps :: !Dependencies, -- What is below it, directly or otherwise
329 mg_dir_imps :: ![Module], -- Directly-imported modules; used to
330 -- generate initialisation code
331 mg_usages :: ![Usage], -- Version info for what it needed
333 mg_rdr_env :: !GlobalRdrEnv, -- Top-level lexical environment
334 mg_fix_env :: !FixityEnv, -- Fixity env, for things declared in this module
335 mg_deprecs :: !Deprecations, -- Deprecations declared in the module
337 mg_types :: !TypeEnv,
338 mg_insts :: ![DFunId], -- Instances
339 mg_rules :: ![IdCoreRule], -- Rules from this module
340 mg_binds :: ![CoreBind], -- Bindings for this module
341 mg_foreign :: !ForeignStubs
344 -- The ModGuts takes on several slightly different forms:
346 -- After simplification, the following fields change slightly:
347 -- mg_rules Orphan rules only (local ones now attached to binds)
348 -- mg_binds With rules attached
350 -- After CoreTidy, the following fields change slightly:
351 -- mg_types Now contains Ids as well, replete with final IdInfo
352 -- The Ids are only the ones that are visible from
353 -- importing modules. Without -O that means only
354 -- exported Ids, but with -O importing modules may
355 -- see ids mentioned in unfoldings of exported Ids
357 -- mg_insts Same DFunIds as before, but with final IdInfo,
358 -- and the unique might have changed; remember that
359 -- CoreTidy links up the uniques of old and new versions
361 -- mg_rules All rules for exported things, substituted with final Ids
369 imp_direct :: ![(Module,Bool)], -- Explicitly-imported modules
370 -- Boolean is true if we imported the whole
371 -- module (apart, perhaps, from hiding some)
372 imp_pkg_mods :: !ModuleSet, -- Non-home-package modules on which we depend,
373 -- directly or indirectly
374 imp_home_names :: !NameSet -- Home package things on which we depend,
375 -- directly or indirectly
378 data ForeignStubs = NoStubs
380 SDoc -- Header file prototypes for
381 -- "foreign exported" functions
382 SDoc -- C stubs to use when calling
383 -- "foreign exported" functions
384 [FastString] -- Headers that need to be included
385 -- into C code generated for this module
386 [Id] -- Foreign-exported binders
387 -- we have to generate code to register these
392 emptyModIface :: PackageIdH -> Module -> ModIface
393 emptyModIface pkg mod
394 = ModIface { mi_package = pkg,
396 mi_mod_vers = initialVersion,
399 mi_deps = noDependencies,
402 mi_exp_vers = initialVersion,
404 mi_deprecs = NoDeprecs,
408 mi_rule_vers = initialVersion,
409 mi_dep_fn = emptyIfaceDepCache,
410 mi_fix_fn = emptyIfaceFixCache,
411 mi_ver_fn = emptyIfaceVerCache
416 %************************************************************************
418 \subsection{The interactive context}
420 %************************************************************************
423 data InteractiveContext
424 = InteractiveContext {
425 ic_toplev_scope :: [String], -- Include the "top-level" scope of
428 ic_exports :: [String], -- Include just the exports of these
431 ic_rn_gbl_env :: GlobalRdrEnv, -- The cached GlobalRdrEnv, built from
432 -- ic_toplev_scope and ic_exports
434 ic_rn_local_env :: LocalRdrEnv, -- Lexical context for variables bound
435 -- during interaction
437 ic_type_env :: TypeEnv -- Ditto for types
440 emptyInteractiveContext
441 = InteractiveContext { ic_toplev_scope = [],
443 ic_rn_gbl_env = emptyGlobalRdrEnv,
444 ic_rn_local_env = emptyLocalRdrEnv,
445 ic_type_env = emptyTypeEnv }
447 icPrintUnqual :: InteractiveContext -> PrintUnqualified
448 icPrintUnqual ictxt = unQualInScope (ic_rn_gbl_env ictxt)
451 @unQualInScope@ returns a function that takes a @Name@ and tells whether
452 its unqualified name is in scope. This is put as a boolean flag in
453 the @Name@'s provenance to guide whether or not to print the name qualified
457 unQualInScope :: GlobalRdrEnv -> PrintUnqualified
458 -- True if 'f' is in scope, and has only one binding,
459 -- and the thing it is bound to is the name we are looking for
460 -- (i.e. false if A.f and B.f are both in scope as unqualified 'f')
462 -- [Out of date] Also checks for built-in syntax, which is always 'in scope'
463 unQualInScope env mod occ
464 = case lookupGRE_RdrName (mkRdrUnqual occ) env of
465 [gre] -> nameModule (gre_name gre) == mod
470 %************************************************************************
474 %************************************************************************
477 implicitTyThings :: TyThing -> [TyThing]
478 implicitTyThings (AnId id) = []
480 -- For type constructors, add the data cons (and their extras),
481 -- and the selectors and generic-programming Ids too
483 -- Newtypes don't have a worker Id, so don't generate that?
484 implicitTyThings (ATyCon tc) = map AnId (tyConSelIds tc) ++
485 concatMap (extras_plus . ADataCon) (tyConDataCons tc)
487 -- For classes, add the class TyCon too (and its extras)
488 -- and the class selector Ids
489 implicitTyThings (AClass cl) = map AnId (classSelIds cl) ++
490 extras_plus (ATyCon (classTyCon cl))
493 -- For data cons add the worker and wrapper (if any)
494 implicitTyThings (ADataCon dc) = map AnId (dataConImplicitIds dc)
496 extras_plus thing = thing : implicitTyThings thing
498 extendTypeEnvWithIds :: TypeEnv -> [Id] -> TypeEnv
499 extendTypeEnvWithIds env ids
500 = extendNameEnvList env [(getName id, AnId id) | id <- ids]
503 %************************************************************************
507 %************************************************************************
510 type TypeEnv = NameEnv TyThing
512 emptyTypeEnv :: TypeEnv
513 typeEnvElts :: TypeEnv -> [TyThing]
514 typeEnvClasses :: TypeEnv -> [Class]
515 typeEnvTyCons :: TypeEnv -> [TyCon]
516 typeEnvIds :: TypeEnv -> [Id]
517 lookupTypeEnv :: TypeEnv -> Name -> Maybe TyThing
519 emptyTypeEnv = emptyNameEnv
520 typeEnvElts env = nameEnvElts env
521 typeEnvClasses env = [cl | AClass cl <- typeEnvElts env]
522 typeEnvTyCons env = [tc | ATyCon tc <- typeEnvElts env]
523 typeEnvIds env = [id | AnId id <- typeEnvElts env]
525 mkTypeEnv :: [TyThing] -> TypeEnv
526 mkTypeEnv things = extendTypeEnvList emptyTypeEnv things
528 lookupTypeEnv = lookupNameEnv
530 -- Extend the type environment
531 extendTypeEnv :: TypeEnv -> TyThing -> TypeEnv
532 extendTypeEnv env thing = extendNameEnv env (getName thing) thing
534 extendTypeEnvList :: TypeEnv -> [TyThing] -> TypeEnv
535 extendTypeEnvList env things = foldl extendTypeEnv env things
539 lookupType :: HomePackageTable -> PackageTypeEnv -> Name -> Maybe TyThing
540 lookupType hpt pte name
541 = case lookupModuleEnv hpt (nameModule name) of
542 Just details -> lookupNameEnv (md_types (hm_details details)) name
543 Nothing -> lookupNameEnv pte name
548 tyThingTyCon (ATyCon tc) = tc
549 tyThingTyCon other = pprPanic "tyThingTyCon" (ppr other)
551 tyThingClass (AClass cls) = cls
552 tyThingClass other = pprPanic "tyThingClass" (ppr other)
554 tyThingDataCon (ADataCon dc) = dc
555 tyThingDataCon other = pprPanic "tyThingDataCon" (ppr other)
557 tyThingId (AnId id) = id
558 tyThingId other = pprPanic "tyThingId" (ppr other)
561 %************************************************************************
563 \subsection{Auxiliary types}
565 %************************************************************************
567 These types are defined here because they are mentioned in ModDetails,
568 but they are mostly elaborated elsewhere
571 mkIfaceVerCache :: [(Version,IfaceDecl)] -> OccName -> Maybe Version
572 mkIfaceVerCache pairs
573 = \occ -> lookupOccEnv env occ
575 env = foldl add emptyOccEnv pairs
576 add env (v,d) = extendOccEnv env (ifName d) v
578 emptyIfaceVerCache :: OccName -> Maybe Version
579 emptyIfaceVerCache occ = Nothing
581 ------------------ Deprecations -------------------------
584 | DeprecAll DeprecTxt -- Whole module deprecated
585 | DeprecSome a -- Some specific things deprecated
588 type IfaceDeprecs = Deprecs [(OccName,DeprecTxt)]
589 type Deprecations = Deprecs (NameEnv (OccName,DeprecTxt))
591 mkIfaceDepCache:: IfaceDeprecs -> Name -> Maybe DeprecTxt
592 mkIfaceDepCache NoDeprecs = \n -> Nothing
593 mkIfaceDepCache (DeprecAll t) = \n -> Just t
594 mkIfaceDepCache (DeprecSome pairs) = lookupOccEnv (mkOccEnv pairs) . nameOccName
596 emptyIfaceDepCache :: Name -> Maybe DeprecTxt
597 emptyIfaceDepCache n = Nothing
599 lookupDeprec :: Deprecations -> Name -> Maybe DeprecTxt
600 lookupDeprec NoDeprecs name = Nothing
601 lookupDeprec (DeprecAll txt) name = Just txt
602 lookupDeprec (DeprecSome env) name = case lookupNameEnv env name of
603 Just (_, txt) -> Just txt
606 plusDeprecs :: Deprecations -> Deprecations -> Deprecations
607 plusDeprecs d NoDeprecs = d
608 plusDeprecs NoDeprecs d = d
609 plusDeprecs d (DeprecAll t) = DeprecAll t
610 plusDeprecs (DeprecAll t) d = DeprecAll t
611 plusDeprecs (DeprecSome v1) (DeprecSome v2) = DeprecSome (v1 `plusNameEnv` v2)
616 type Avails = [AvailInfo]
617 type AvailInfo = GenAvailInfo Name
618 type RdrAvailInfo = GenAvailInfo OccName
620 data GenAvailInfo name = Avail name -- An ordinary identifier
621 | AvailTC name -- The name of the type or class
622 [name] -- The available pieces of type/class.
623 -- NB: If the type or class is itself
624 -- to be in scope, it must be in this list.
625 -- Thus, typically: AvailTC Eq [Eq, ==, /=]
627 -- Equality used when deciding if the interface has changed
629 type IfaceExport = (Module, [GenAvailInfo OccName])
631 availsToNameSet :: [AvailInfo] -> NameSet
632 availsToNameSet avails = foldl add emptyNameSet avails
634 add set avail = addListToNameSet set (availNames avail)
636 availName :: GenAvailInfo name -> name
637 availName (Avail n) = n
638 availName (AvailTC n _) = n
640 availNames :: GenAvailInfo name -> [name]
641 availNames (Avail n) = [n]
642 availNames (AvailTC n ns) = ns
644 instance Outputable n => Outputable (GenAvailInfo n) where
647 pprAvail :: Outputable n => GenAvailInfo n -> SDoc
648 pprAvail (AvailTC n ns) = ppr n <> case {- filter (/= n) -} ns of
650 ns' -> braces (hsep (punctuate comma (map ppr ns')))
652 pprAvail (Avail n) = ppr n
656 mkIfaceFixCache :: [(OccName, Fixity)] -> OccName -> Fixity
657 mkIfaceFixCache pairs
658 = \n -> lookupOccEnv env n `orElse` defaultFixity
662 emptyIfaceFixCache :: OccName -> Fixity
663 emptyIfaceFixCache n = defaultFixity
665 -- This fixity environment is for source code only
666 type FixityEnv = NameEnv FixItem
668 -- We keep the OccName in the range so that we can generate an interface from it
669 data FixItem = FixItem OccName Fixity SrcSpan
671 instance Outputable FixItem where
672 ppr (FixItem occ fix loc) = ppr fix <+> ppr occ <+> parens (ppr loc)
674 emptyFixityEnv :: FixityEnv
675 emptyFixityEnv = emptyNameEnv
677 lookupFixity :: FixityEnv -> Name -> Fixity
678 lookupFixity env n = case lookupNameEnv env n of
679 Just (FixItem _ fix _) -> fix
680 Nothing -> defaultFixity
684 %************************************************************************
686 \subsection{WhatsImported}
688 %************************************************************************
691 type WhetherHasOrphans = Bool
693 -- * an instance decl in a module other than the defn module for
694 -- one of the tycons or classes in the instance head
695 -- * a transformation rule in a module other than the one defining
696 -- the function in the head of the rule.
698 type IsBootInterface = Bool
700 -- Dependency info about modules and packages below this one
701 -- in the import hierarchy. See TcRnTypes.ImportAvails for details.
703 -- Invariant: the dependencies of a module M never includes M
704 -- Invariant: the lists are unordered, with no duplicates
706 = Deps { dep_mods :: [(Module,IsBootInterface)], -- Home-package module dependencies
707 dep_pkgs :: [PackageId], -- External package dependencies
708 dep_orphs :: [Module] } -- Orphan modules (whether home or external pkg)
710 -- Equality used only for old/new comparison in MkIface.addVersionInfo
712 noDependencies :: Dependencies
713 noDependencies = Deps [] [] []
716 = Usage { usg_name :: Module, -- Name of the module
717 usg_mod :: Version, -- Module version
718 usg_entities :: [(OccName,Version)], -- Sorted by occurrence name
719 usg_exports :: Maybe Version, -- Export-list version, if we depend on it
720 usg_rules :: Version -- Orphan-rules version (for non-orphan
721 -- modules this will always be initialVersion)
723 -- This type doesn't let you say "I imported f but none of the rules in
724 -- the module". If you use anything in the module you get its rule version
725 -- So if the rules change, you'll recompile, even if you don't use them.
726 -- This is easy to implement, and it's safer: you might not have used the rules last
727 -- time round, but if someone has added a new rule you might need it this time
729 -- The export list field is (Just v) if we depend on the export list:
730 -- i.e. we imported the module without saying exactly what we imported
731 -- We need to recompile if the module exports changes, because we might
732 -- now have a name clash in the importing module.
736 %************************************************************************
738 The External Package State
740 %************************************************************************
743 type PackageTypeEnv = TypeEnv
744 type PackageRuleBase = RuleBase
745 type PackageInstEnv = InstEnv
747 data ExternalPackageState
749 eps_is_boot :: !(ModuleEnv (Module, IsBootInterface)),
750 -- In OneShot mode (only), home-package modules accumulate in the
751 -- external package state, and are sucked in lazily.
752 -- For these home-pkg modules (only) we need to record which are
753 -- boot modules. We set this field after loading all the
754 -- explicitly-imported interfaces, but before doing anything else
756 -- The Module part is not necessary, but it's useful for
757 -- debug prints, and it's convenient because this field comes
758 -- direct from TcRnTypes.ImportAvails.imp_dep_mods
760 eps_PIT :: !PackageIfaceTable,
761 -- The ModuleIFaces for modules in external packages
762 -- whose interfaces we have opened
763 -- The declarations in these interface files are held in
764 -- eps_decls, eps_insts, eps_rules (below), not in the
765 -- mi_decls fields of the iPIT.
766 -- What _is_ in the iPIT is:
773 eps_PTE :: !PackageTypeEnv, -- Domain = external-package modules
775 eps_inst_env :: !PackageInstEnv, -- The total InstEnv accumulated from
776 -- all the external-package modules
777 eps_rule_base :: !PackageRuleBase, -- Ditto RuleEnv
780 -- Holding pens for stuff that has been read in from file,
781 -- but not yet slurped into the renamer
782 eps_insts :: !InstPool,
783 -- The as-yet un-slurped instance decls
784 -- Decls move from here to eps_inst_env
785 -- Each instance is 'gated' by the names that must be
786 -- available before this instance decl is needed.
788 eps_rules :: !RulePool,
789 -- The as-yet un-slurped rules
791 eps_stats :: !EpsStats
794 -- "In" means read from iface files
795 -- "Out" means actually sucked in and type-checked
796 data EpsStats = EpsStats { n_ifaces_in
797 , n_decls_in, n_decls_out
798 , n_rules_in, n_rules_out
799 , n_insts_in, n_insts_out :: !Int }
802 The NameCache makes sure that there is just one Unique assigned for
803 each original name; i.e. (module-name, occ-name) pair. The Name is
804 always stored as a Global, and has the SrcLoc of its binding location.
805 Actually that's not quite right. When we first encounter the original
806 name, we might not be at its binding site (e.g. we are reading an
807 interface file); so we give it 'noSrcLoc' then. Later, when we find
808 its binding site, we fix it up.
810 Exactly the same is true of the Module stored in the Name. When we first
811 encounter the occurrence, we may not know the details of the module, so
812 we just store junk. Then when we find the binding site, we fix it up.
816 = NameCache { nsUniqs :: UniqSupply,
818 nsNames :: OrigNameCache,
819 -- Ensures that one original name gets one unique
820 nsIPs :: OrigIParamCache
821 -- Ensures that one implicit parameter name gets one unique
824 type OrigNameCache = ModuleEnv (OccEnv Name)
825 type OrigIParamCache = FiniteMap (IPName OccName) (IPName Name)
829 type Gated d = ([Name], (Module, SDoc, d))
830 -- The [Name] 'gate' the declaration; always non-empty
831 -- Module records which module this decl belongs to
832 -- SDoc records the pathname of the file, or similar err-ctxt info
834 type RulePool = [Gated IfaceRule]
836 addRulesToPool :: RulePool
839 addRulesToPool rules new_rules = new_rules ++ rules
841 -------------------------
842 addEpsInStats :: EpsStats -> Int -> Int -> Int -> EpsStats
843 -- Add stats for one newly-read interface
844 addEpsInStats stats n_decls n_insts n_rules
845 = stats { n_ifaces_in = n_ifaces_in stats + 1
846 , n_decls_in = n_decls_in stats + n_decls
847 , n_insts_in = n_insts_in stats + n_insts
848 , n_rules_in = n_rules_in stats + n_rules }
850 -------------------------
851 type InstPool = NameEnv [Gated IfaceInst]
852 -- The key of the Pool is the Class
853 -- The Names are the TyCons in the instance head
854 -- For example, suppose this is in an interface file
855 -- instance C T where ...
856 -- We want to slurp this decl if both C and T are "visible" in
857 -- the importing module. See "The gating story" in RnIfaces for details.
860 addInstsToPool :: InstPool -> [(Name, Gated IfaceInst)] -> InstPool
861 addInstsToPool insts new_insts
862 = foldr add insts new_insts
864 add :: (Name, Gated IfaceInst) -> NameEnv [Gated IfaceInst] -> NameEnv [Gated IfaceInst]
865 add (cls,new_inst) insts = extendNameEnv_C combine insts cls [new_inst]
867 combine old_insts _ = new_inst : old_insts
871 %************************************************************************
873 \subsection{Linkable stuff}
875 %************************************************************************
877 This stuff is in here, rather than (say) in Linker.lhs, because the Linker.lhs
878 stuff is the *dynamic* linker, and isn't present in a stage-1 compiler
882 linkableTime :: ClockTime, -- Time at which this linkable was built
883 -- (i.e. when the bytecodes were produced,
884 -- or the mod date on the files)
885 linkableModule :: Module, -- Should be Module, but see below
886 linkableUnlinked :: [Unlinked]
889 isObjectLinkable :: Linkable -> Bool
890 isObjectLinkable l = all isObject (linkableUnlinked l)
892 instance Outputable Linkable where
893 ppr (LM when_made mod unlinkeds)
894 = (text "LinkableM" <+> parens (text (show when_made)) <+> ppr mod)
895 $$ nest 3 (ppr unlinkeds)
897 -------------------------------------------
902 | BCOs CompiledByteCode
905 data CompiledByteCode = NoByteCode
908 instance Outputable Unlinked where
909 ppr (DotO path) = text "DotO" <+> text path
910 ppr (DotA path) = text "DotA" <+> text path
911 ppr (DotDLL path) = text "DotDLL" <+> text path
913 ppr (BCOs bcos) = text "BCOs" <+> ppr bcos
915 ppr (BCOs bcos) = text "No byte code"
918 isObject (DotO _) = True
919 isObject (DotA _) = True
920 isObject (DotDLL _) = True
923 isInterpretable = not . isObject
925 nameOfObject (DotO fn) = fn
926 nameOfObject (DotA fn) = fn
927 nameOfObject (DotDLL fn) = fn
929 byteCodeOfObject (BCOs bc) = bc