2 % (c) The University of Glasgow, 2000
4 \section[HscTypes]{Types for the per-module compiler}
11 ModGuts(..), ModImports(..), ForeignStubs(..),
13 ModSummary(..), showModMsg, isBootSummary,
14 msHsFilePath, msHiFilePath, msObjFilePath,
16 HscSource(..), isHsBoot, hscSourceString, -- Re-exported from DriverPhases
18 HomePackageTable, HomeModInfo(..), emptyHomePackageTable,
19 hptInstances, hptRules,
21 ExternalPackageState(..), EpsStats(..), addEpsInStats,
22 PackageTypeEnv, PackageIfaceTable, emptyPackageIfaceTable,
23 lookupIface, lookupIfaceByModule, emptyModIface,
25 InteractiveContext(..), emptyInteractiveContext,
26 icPrintUnqual, unQualInScope,
28 ModIface(..), mkIfaceDepCache, mkIfaceVerCache, mkIfaceFixCache,
31 Deprecs(..), IfaceDeprecs,
33 FixityEnv, FixItem(..), lookupFixity, emptyFixityEnv,
37 TyThing(..), tyThingClass, tyThingTyCon, tyThingDataCon, tyThingId,
38 TypeEnv, lookupType, mkTypeEnv, emptyTypeEnv,
39 extendTypeEnv, extendTypeEnvList, extendTypeEnvWithIds, lookupTypeEnv,
40 typeEnvElts, typeEnvClasses, typeEnvTyCons, typeEnvIds,
42 WhetherHasOrphans, IsBootInterface, Usage(..),
43 Dependencies(..), noDependencies,
44 InstPool, Gated, addInstsToPool,
45 RulePool, addRulesToPool,
46 NameCache(..), OrigNameCache, OrigIParamCache,
47 Avails, availsToNameSet, availName, availNames,
48 GenAvailInfo(..), AvailInfo, RdrAvailInfo,
51 Deprecations, DeprecTxt, lookupDeprec, plusDeprecs,
54 PackageInstEnv, PackageRuleBase,
57 Linkable(..), isObjectLinkable,
58 Unlinked(..), CompiledByteCode,
59 isObject, nameOfObject, isInterpretable, byteCodeOfObject
62 #include "HsVersions.h"
65 import ByteCodeAsm ( CompiledByteCode )
68 import RdrName ( GlobalRdrEnv, emptyGlobalRdrEnv,
69 LocalRdrEnv, emptyLocalRdrEnv,
70 GlobalRdrElt(..), mkRdrUnqual, lookupGRE_RdrName )
71 import Name ( Name, NamedThing, getName, nameOccName, nameModule )
74 import OccName ( OccName, OccEnv, lookupOccEnv, mkOccEnv, emptyOccEnv,
77 import InstEnv ( InstEnv, DFunId )
78 import Rules ( RuleBase )
79 import CoreSyn ( CoreBind )
81 import Type ( TyThing(..) )
83 import Class ( Class, classSelIds, classTyCon )
84 import TyCon ( TyCon, tyConSelIds, tyConDataCons )
85 import DataCon ( dataConImplicitIds )
86 import Packages ( PackageIdH, PackageId )
87 import DynFlags ( DynFlags(..), isOneShot )
88 import DriverPhases ( HscSource(..), isHsBoot, hscSourceString )
89 import BasicTypes ( Version, initialVersion, IPName,
90 Fixity, defaultFixity, DeprecTxt )
92 import IfaceSyn ( IfaceInst, IfaceRule, IfaceDecl(ifName) )
94 import FiniteMap ( FiniteMap )
95 import CoreSyn ( IdCoreRule )
96 import Maybes ( orElse, fromJust, expectJust )
98 import SrcLoc ( SrcSpan )
99 import UniqSupply ( UniqSupply )
100 import FastString ( FastString )
102 import DATA_IOREF ( IORef, readIORef )
103 import StringBuffer ( StringBuffer )
104 import Time ( ClockTime )
108 %************************************************************************
110 \subsection{Compilation environment}
112 %************************************************************************
114 The HscEnv gives the environment in which to compile a chunk of code.
118 = HscEnv { hsc_dflags :: DynFlags,
120 hsc_HPT :: HomePackageTable,
121 -- The home package table describes already-compiled
122 -- home-packge modules, *excluding* the module we
123 -- are compiling right now.
124 -- (In one-shot mode the current module is the only
125 -- home-package module, so hsc_HPT is empty. All other
126 -- modules count as "external-package" modules.
127 -- However, even in GHCi mode, hi-boot interfaces are
128 -- demand-loadeded into the external-package table.)
130 -- hsc_HPT is not mutable because we only demand-load
131 -- external packages; the home package is eagerly
132 -- loaded, module by module, by the compilation manager.
134 -- The HPT may contain modules compiled earlier by --make
135 -- but not actually below the current module in the dependency
136 -- graph. (This changes a previous invariant: changed Jan 05.)
138 -- The next two are side-effected by compiling
139 -- to reflect sucking in interface files
140 hsc_EPS :: IORef ExternalPackageState,
141 hsc_NC :: IORef NameCache }
143 hscEPS :: HscEnv -> IO ExternalPackageState
144 hscEPS hsc_env = readIORef (hsc_EPS hsc_env)
148 type HomePackageTable = ModuleEnv HomeModInfo -- Domain = modules in the home package
149 type PackageIfaceTable = ModuleEnv ModIface -- Domain = modules in the imported packages
151 emptyHomePackageTable = emptyModuleEnv
152 emptyPackageIfaceTable = emptyModuleEnv
155 = HomeModInfo { hm_iface :: ModIface,
156 hm_details :: ModDetails,
157 hm_linkable :: Linkable }
160 Simple lookups in the symbol table.
163 lookupIface :: HomePackageTable -> PackageIfaceTable -> Module -> Maybe ModIface
164 -- We often have two IfaceTables, and want to do a lookup
165 lookupIface hpt pit mod
166 = case lookupModuleEnv hpt mod of
167 Just mod_info -> Just (hm_iface mod_info)
168 Nothing -> lookupModuleEnv pit mod
170 lookupIfaceByModule :: HomePackageTable -> PackageIfaceTable -> Module -> Maybe ModIface
171 -- We often have two IfaceTables, and want to do a lookup
172 lookupIfaceByModule hpt pit mod
173 = case lookupModuleEnv hpt mod of
174 Just mod_info -> Just (hm_iface mod_info)
175 Nothing -> lookupModuleEnv pit mod
180 hptInstances :: HscEnv -> (Module -> Bool) -> [DFunId]
181 -- Find all the instance declarations that are in modules imported
182 -- by this one, directly or indirectly, and are in the Home Package Table
183 -- This ensures that we don't see instances from modules --make compiled
184 -- before this one, but which are not below this one
185 hptInstances hsc_env want_this_module
187 | mod_info <- moduleEnvElts (hsc_HPT hsc_env)
188 , want_this_module (mi_module (hm_iface mod_info))
189 , dfun <- md_insts (hm_details mod_info) ]
191 hptRules :: HscEnv -> [(Module, IsBootInterface)] -> [IdCoreRule]
192 -- Get rules from modules "below" this one (in the dependency sense)
193 -- C.f Inst.hptInstances
194 hptRules hsc_env deps
195 | isOneShot (ghcMode (hsc_dflags hsc_env)) = []
198 hpt = hsc_HPT hsc_env
201 | -- Find each non-hi-boot module below me
204 -- Look it up in the HPT
205 , let mod_info = ASSERT( mod `elemModuleEnv` hpt )
206 fromJust (lookupModuleEnv hpt mod)
209 , rule <- md_rules (hm_details mod_info) ]
213 %************************************************************************
215 \subsection{Symbol tables and Module details}
217 %************************************************************************
219 A @ModIface@ plus a @ModDetails@ summarises everything we know
220 about a compiled module. The @ModIface@ is the stuff *before* linking,
221 and can be written out to an interface file. (The @ModDetails@ is after
222 linking; it is the "linked" form of the mi_decls field.)
224 When we *read* an interface file, we also construct a @ModIface@ from it,
225 except that the mi_decls part is empty; when reading we consolidate
226 the declarations into a single indexed map in the @PersistentRenamerState@.
231 mi_package :: !PackageIdH, -- Which package the module comes from
232 mi_module :: !Module,
233 mi_mod_vers :: !Version, -- Module version: changes when anything changes
235 mi_orphan :: !WhetherHasOrphans, -- Whether this module has orphans
236 mi_boot :: !IsBootInterface, -- Read from an hi-boot file?
238 mi_deps :: Dependencies,
239 -- This is consulted for directly-imported modules,
240 -- but not for anything else (hence lazy)
242 -- Usages; kept sorted so that it's easy to decide
243 -- whether to write a new iface file (changing usages
244 -- doesn't affect the version of this module)
245 mi_usages :: [Usage],
246 -- NOT STRICT! we read this field lazily from the interface file
247 -- It is *only* consulted by the recompilation checker
250 -- Kept sorted by (mod,occ), to make version comparisons easier
251 mi_exports :: ![IfaceExport],
252 mi_exp_vers :: !Version, -- Version number of export list
255 mi_fixities :: [(OccName,Fixity)],
256 -- NOT STRICT! we read this field lazily from the interface file
259 mi_deprecs :: IfaceDeprecs,
260 -- NOT STRICT! we read this field lazily from the interface file
262 -- Type, class and variable declarations
263 -- The version of an Id changes if its fixity or deprecations change
264 -- (as well as its type of course)
265 -- Ditto data constructors, class operations, except that
266 -- the version of the parent class/tycon changes
267 mi_decls :: [(Version,IfaceDecl)], -- Sorted
269 mi_globals :: !(Maybe GlobalRdrEnv),
270 -- Its top level environment or Nothing if we read this
271 -- interface from an interface file. (We need the source
272 -- file to figure out the top-level environment.)
274 -- Instance declarations and rules
275 mi_insts :: [IfaceInst], -- Sorted
276 mi_rules :: [IfaceRule], -- Sorted
277 mi_rule_vers :: !Version, -- Version number for rules and instances combined
279 -- Cached environments for easy lookup
280 -- These are computed (lazily) from other fields
281 -- and are not put into the interface file
282 mi_dep_fn :: Name -> Maybe DeprecTxt, -- Cached lookup for mi_deprecs
283 mi_fix_fn :: OccName -> Fixity, -- Cached lookup for mi_fixities
284 mi_ver_fn :: OccName -> Maybe Version -- Cached lookup for mi_decls
285 -- The Nothing in mi_ver_fn means that the thing
286 -- isn't in decls. It's useful to know that when
287 -- seeing if we are up to date wrt the old interface
290 -- Should be able to construct ModDetails from mi_decls in ModIface
293 -- The next three fields are created by the typechecker
294 md_types :: !TypeEnv,
295 md_insts :: ![DFunId], -- Dfun-ids for the instances in this module
296 md_rules :: ![IdCoreRule] -- Domain may include Ids from other modules
299 -- A ModGuts is carried through the compiler, accumulating stuff as it goes
300 -- There is only one ModGuts at any time, the one for the module
301 -- being compiled right now. Once it is compiled, a ModIface and
302 -- ModDetails are extracted and the ModGuts is dicarded.
306 mg_module :: !Module,
307 mg_boot :: IsBootInterface, -- Whether it's an hs-boot module
308 mg_exports :: !NameSet, -- What it exports
309 mg_deps :: !Dependencies, -- What is below it, directly or otherwise
310 mg_dir_imps :: ![Module], -- Directly-imported modules; used to
311 -- generate initialisation code
312 mg_usages :: ![Usage], -- Version info for what it needed
314 mg_rdr_env :: !GlobalRdrEnv, -- Top-level lexical environment
315 mg_fix_env :: !FixityEnv, -- Fixity env, for things declared in this module
316 mg_deprecs :: !Deprecations, -- Deprecations declared in the module
318 mg_types :: !TypeEnv,
319 mg_insts :: ![DFunId], -- Instances
320 mg_rules :: ![IdCoreRule], -- Rules from this module
321 mg_binds :: ![CoreBind], -- Bindings for this module
322 mg_foreign :: !ForeignStubs
325 -- The ModGuts takes on several slightly different forms:
327 -- After simplification, the following fields change slightly:
328 -- mg_rules Orphan rules only (local ones now attached to binds)
329 -- mg_binds With rules attached
331 -- After CoreTidy, the following fields change slightly:
332 -- mg_types Now contains Ids as well, replete with final IdInfo
333 -- The Ids are only the ones that are visible from
334 -- importing modules. Without -O that means only
335 -- exported Ids, but with -O importing modules may
336 -- see ids mentioned in unfoldings of exported Ids
338 -- mg_insts Same DFunIds as before, but with final IdInfo,
339 -- and the unique might have changed; remember that
340 -- CoreTidy links up the uniques of old and new versions
342 -- mg_rules All rules for exported things, substituted with final Ids
350 imp_direct :: ![(Module,Bool)], -- Explicitly-imported modules
351 -- Boolean is true if we imported the whole
352 -- module (apart, perhaps, from hiding some)
353 imp_pkg_mods :: !ModuleSet, -- Non-home-package modules on which we depend,
354 -- directly or indirectly
355 imp_home_names :: !NameSet -- Home package things on which we depend,
356 -- directly or indirectly
359 data ForeignStubs = NoStubs
361 SDoc -- Header file prototypes for
362 -- "foreign exported" functions
363 SDoc -- C stubs to use when calling
364 -- "foreign exported" functions
365 [FastString] -- Headers that need to be included
366 -- into C code generated for this module
367 [Id] -- Foreign-exported binders
368 -- we have to generate code to register these
373 emptyModIface :: PackageIdH -> Module -> ModIface
374 emptyModIface pkg mod
375 = ModIface { mi_package = pkg,
377 mi_mod_vers = initialVersion,
380 mi_deps = noDependencies,
383 mi_exp_vers = initialVersion,
385 mi_deprecs = NoDeprecs,
389 mi_globals = Nothing,
390 mi_rule_vers = initialVersion,
391 mi_dep_fn = emptyIfaceDepCache,
392 mi_fix_fn = emptyIfaceFixCache,
393 mi_ver_fn = emptyIfaceVerCache
398 %************************************************************************
400 \subsection{The interactive context}
402 %************************************************************************
405 data InteractiveContext
406 = InteractiveContext {
407 ic_toplev_scope :: [String], -- Include the "top-level" scope of
410 ic_exports :: [String], -- Include just the exports of these
413 ic_rn_gbl_env :: GlobalRdrEnv, -- The cached GlobalRdrEnv, built from
414 -- ic_toplev_scope and ic_exports
416 ic_rn_local_env :: LocalRdrEnv, -- Lexical context for variables bound
417 -- during interaction
419 ic_type_env :: TypeEnv -- Ditto for types
422 emptyInteractiveContext
423 = InteractiveContext { ic_toplev_scope = [],
425 ic_rn_gbl_env = emptyGlobalRdrEnv,
426 ic_rn_local_env = emptyLocalRdrEnv,
427 ic_type_env = emptyTypeEnv }
429 icPrintUnqual :: InteractiveContext -> PrintUnqualified
430 icPrintUnqual ictxt = unQualInScope (ic_rn_gbl_env ictxt)
433 @unQualInScope@ returns a function that takes a @Name@ and tells whether
434 its unqualified name is in scope. This is put as a boolean flag in
435 the @Name@'s provenance to guide whether or not to print the name qualified
439 unQualInScope :: GlobalRdrEnv -> PrintUnqualified
440 -- True if 'f' is in scope, and has only one binding,
441 -- and the thing it is bound to is the name we are looking for
442 -- (i.e. false if A.f and B.f are both in scope as unqualified 'f')
444 -- [Out of date] Also checks for built-in syntax, which is always 'in scope'
445 unQualInScope env mod occ
446 = case lookupGRE_RdrName (mkRdrUnqual occ) env of
447 [gre] -> nameModule (gre_name gre) == mod
452 %************************************************************************
456 %************************************************************************
459 implicitTyThings :: TyThing -> [TyThing]
460 implicitTyThings (AnId id) = []
462 -- For type constructors, add the data cons (and their extras),
463 -- and the selectors and generic-programming Ids too
465 -- Newtypes don't have a worker Id, so don't generate that?
466 implicitTyThings (ATyCon tc) = map AnId (tyConSelIds tc) ++
467 concatMap (extras_plus . ADataCon) (tyConDataCons tc)
469 -- For classes, add the class TyCon too (and its extras)
470 -- and the class selector Ids
471 implicitTyThings (AClass cl) = map AnId (classSelIds cl) ++
472 extras_plus (ATyCon (classTyCon cl))
475 -- For data cons add the worker and wrapper (if any)
476 implicitTyThings (ADataCon dc) = map AnId (dataConImplicitIds dc)
478 extras_plus thing = thing : implicitTyThings thing
480 extendTypeEnvWithIds :: TypeEnv -> [Id] -> TypeEnv
481 extendTypeEnvWithIds env ids
482 = extendNameEnvList env [(getName id, AnId id) | id <- ids]
485 %************************************************************************
489 %************************************************************************
492 type TypeEnv = NameEnv TyThing
494 emptyTypeEnv :: TypeEnv
495 typeEnvElts :: TypeEnv -> [TyThing]
496 typeEnvClasses :: TypeEnv -> [Class]
497 typeEnvTyCons :: TypeEnv -> [TyCon]
498 typeEnvIds :: TypeEnv -> [Id]
499 lookupTypeEnv :: TypeEnv -> Name -> Maybe TyThing
501 emptyTypeEnv = emptyNameEnv
502 typeEnvElts env = nameEnvElts env
503 typeEnvClasses env = [cl | AClass cl <- typeEnvElts env]
504 typeEnvTyCons env = [tc | ATyCon tc <- typeEnvElts env]
505 typeEnvIds env = [id | AnId id <- typeEnvElts env]
507 mkTypeEnv :: [TyThing] -> TypeEnv
508 mkTypeEnv things = extendTypeEnvList emptyTypeEnv things
510 lookupTypeEnv = lookupNameEnv
512 -- Extend the type environment
513 extendTypeEnv :: TypeEnv -> TyThing -> TypeEnv
514 extendTypeEnv env thing = extendNameEnv env (getName thing) thing
516 extendTypeEnvList :: TypeEnv -> [TyThing] -> TypeEnv
517 extendTypeEnvList env things = foldl extendTypeEnv env things
521 lookupType :: HomePackageTable -> PackageTypeEnv -> Name -> Maybe TyThing
522 lookupType hpt pte name
523 = case lookupModuleEnv hpt (nameModule name) of
524 Just details -> lookupNameEnv (md_types (hm_details details)) name
525 Nothing -> lookupNameEnv pte name
530 tyThingTyCon (ATyCon tc) = tc
531 tyThingTyCon other = pprPanic "tyThingTyCon" (ppr other)
533 tyThingClass (AClass cls) = cls
534 tyThingClass other = pprPanic "tyThingClass" (ppr other)
536 tyThingDataCon (ADataCon dc) = dc
537 tyThingDataCon other = pprPanic "tyThingDataCon" (ppr other)
539 tyThingId (AnId id) = id
540 tyThingId other = pprPanic "tyThingId" (ppr other)
543 %************************************************************************
545 \subsection{Auxiliary types}
547 %************************************************************************
549 These types are defined here because they are mentioned in ModDetails,
550 but they are mostly elaborated elsewhere
553 mkIfaceVerCache :: [(Version,IfaceDecl)] -> OccName -> Maybe Version
554 mkIfaceVerCache pairs
555 = \occ -> lookupOccEnv env occ
557 env = foldl add emptyOccEnv pairs
558 add env (v,d) = extendOccEnv env (ifName d) v
560 emptyIfaceVerCache :: OccName -> Maybe Version
561 emptyIfaceVerCache occ = Nothing
563 ------------------ Deprecations -------------------------
566 | DeprecAll DeprecTxt -- Whole module deprecated
567 | DeprecSome a -- Some specific things deprecated
570 type IfaceDeprecs = Deprecs [(OccName,DeprecTxt)]
571 type Deprecations = Deprecs (NameEnv (OccName,DeprecTxt))
573 mkIfaceDepCache:: IfaceDeprecs -> Name -> Maybe DeprecTxt
574 mkIfaceDepCache NoDeprecs = \n -> Nothing
575 mkIfaceDepCache (DeprecAll t) = \n -> Just t
576 mkIfaceDepCache (DeprecSome pairs) = lookupOccEnv (mkOccEnv pairs) . nameOccName
578 emptyIfaceDepCache :: Name -> Maybe DeprecTxt
579 emptyIfaceDepCache n = Nothing
581 lookupDeprec :: Deprecations -> Name -> Maybe DeprecTxt
582 lookupDeprec NoDeprecs name = Nothing
583 lookupDeprec (DeprecAll txt) name = Just txt
584 lookupDeprec (DeprecSome env) name = case lookupNameEnv env name of
585 Just (_, txt) -> Just txt
588 plusDeprecs :: Deprecations -> Deprecations -> Deprecations
589 plusDeprecs d NoDeprecs = d
590 plusDeprecs NoDeprecs d = d
591 plusDeprecs d (DeprecAll t) = DeprecAll t
592 plusDeprecs (DeprecAll t) d = DeprecAll t
593 plusDeprecs (DeprecSome v1) (DeprecSome v2) = DeprecSome (v1 `plusNameEnv` v2)
598 type Avails = [AvailInfo]
599 type AvailInfo = GenAvailInfo Name
600 type RdrAvailInfo = GenAvailInfo OccName
602 data GenAvailInfo name = Avail name -- An ordinary identifier
603 | AvailTC name -- The name of the type or class
604 [name] -- The available pieces of type/class.
605 -- NB: If the type or class is itself
606 -- to be in scope, it must be in this list.
607 -- Thus, typically: AvailTC Eq [Eq, ==, /=]
609 -- Equality used when deciding if the interface has changed
611 type IfaceExport = (Module, [GenAvailInfo OccName])
613 availsToNameSet :: [AvailInfo] -> NameSet
614 availsToNameSet avails = foldl add emptyNameSet avails
616 add set avail = addListToNameSet set (availNames avail)
618 availName :: GenAvailInfo name -> name
619 availName (Avail n) = n
620 availName (AvailTC n _) = n
622 availNames :: GenAvailInfo name -> [name]
623 availNames (Avail n) = [n]
624 availNames (AvailTC n ns) = ns
626 instance Outputable n => Outputable (GenAvailInfo n) where
629 pprAvail :: Outputable n => GenAvailInfo n -> SDoc
630 pprAvail (AvailTC n ns) = ppr n <> case {- filter (/= n) -} ns of
632 ns' -> braces (hsep (punctuate comma (map ppr ns')))
634 pprAvail (Avail n) = ppr n
638 mkIfaceFixCache :: [(OccName, Fixity)] -> OccName -> Fixity
639 mkIfaceFixCache pairs
640 = \n -> lookupOccEnv env n `orElse` defaultFixity
644 emptyIfaceFixCache :: OccName -> Fixity
645 emptyIfaceFixCache n = defaultFixity
647 -- This fixity environment is for source code only
648 type FixityEnv = NameEnv FixItem
650 -- We keep the OccName in the range so that we can generate an interface from it
651 data FixItem = FixItem OccName Fixity SrcSpan
653 instance Outputable FixItem where
654 ppr (FixItem occ fix loc) = ppr fix <+> ppr occ <+> parens (ppr loc)
656 emptyFixityEnv :: FixityEnv
657 emptyFixityEnv = emptyNameEnv
659 lookupFixity :: FixityEnv -> Name -> Fixity
660 lookupFixity env n = case lookupNameEnv env n of
661 Just (FixItem _ fix _) -> fix
662 Nothing -> defaultFixity
666 %************************************************************************
668 \subsection{WhatsImported}
670 %************************************************************************
673 type WhetherHasOrphans = Bool
675 -- * an instance decl in a module other than the defn module for
676 -- one of the tycons or classes in the instance head
677 -- * a transformation rule in a module other than the one defining
678 -- the function in the head of the rule.
680 type IsBootInterface = Bool
682 -- Dependency info about modules and packages below this one
683 -- in the import hierarchy. See TcRnTypes.ImportAvails for details.
685 -- Invariant: the dependencies of a module M never includes M
686 -- Invariant: the lists are unordered, with no duplicates
688 = Deps { dep_mods :: [(Module,IsBootInterface)], -- Home-package module dependencies
689 dep_pkgs :: [PackageId], -- External package dependencies
690 dep_orphs :: [Module] } -- Orphan modules (whether home or external pkg)
692 -- Equality used only for old/new comparison in MkIface.addVersionInfo
694 noDependencies :: Dependencies
695 noDependencies = Deps [] [] []
698 = Usage { usg_name :: Module, -- Name of the module
699 usg_mod :: Version, -- Module version
700 usg_entities :: [(OccName,Version)], -- Sorted by occurrence name
701 usg_exports :: Maybe Version, -- Export-list version, if we depend on it
702 usg_rules :: Version -- Orphan-rules version (for non-orphan
703 -- modules this will always be initialVersion)
705 -- This type doesn't let you say "I imported f but none of the rules in
706 -- the module". If you use anything in the module you get its rule version
707 -- So if the rules change, you'll recompile, even if you don't use them.
708 -- This is easy to implement, and it's safer: you might not have used the rules last
709 -- time round, but if someone has added a new rule you might need it this time
711 -- The export list field is (Just v) if we depend on the export list:
712 -- i.e. we imported the module without saying exactly what we imported
713 -- We need to recompile if the module exports changes, because we might
714 -- now have a name clash in the importing module.
718 %************************************************************************
720 The External Package State
722 %************************************************************************
725 type PackageTypeEnv = TypeEnv
726 type PackageRuleBase = RuleBase
727 type PackageInstEnv = InstEnv
729 data ExternalPackageState
731 eps_is_boot :: !(ModuleEnv (Module, IsBootInterface)),
732 -- In OneShot mode (only), home-package modules accumulate in the
733 -- external package state, and are sucked in lazily.
734 -- For these home-pkg modules (only) we need to record which are
735 -- boot modules. We set this field after loading all the
736 -- explicitly-imported interfaces, but before doing anything else
738 -- The Module part is not necessary, but it's useful for
739 -- debug prints, and it's convenient because this field comes
740 -- direct from TcRnTypes.ImportAvails.imp_dep_mods
742 eps_PIT :: !PackageIfaceTable,
743 -- The ModuleIFaces for modules in external packages
744 -- whose interfaces we have opened
745 -- The declarations in these interface files are held in
746 -- eps_decls, eps_insts, eps_rules (below), not in the
747 -- mi_decls fields of the iPIT.
748 -- What _is_ in the iPIT is:
755 eps_PTE :: !PackageTypeEnv, -- Domain = external-package modules
757 eps_inst_env :: !PackageInstEnv, -- The total InstEnv accumulated from
758 -- all the external-package modules
759 eps_rule_base :: !PackageRuleBase, -- Ditto RuleEnv
762 -- Holding pens for stuff that has been read in from file,
763 -- but not yet slurped into the renamer
764 eps_insts :: !InstPool,
765 -- The as-yet un-slurped instance decls
766 -- Decls move from here to eps_inst_env
767 -- Each instance is 'gated' by the names that must be
768 -- available before this instance decl is needed.
770 eps_rules :: !RulePool,
771 -- The as-yet un-slurped rules
773 eps_stats :: !EpsStats
776 -- "In" means read from iface files
777 -- "Out" means actually sucked in and type-checked
778 data EpsStats = EpsStats { n_ifaces_in
779 , n_decls_in, n_decls_out
780 , n_rules_in, n_rules_out
781 , n_insts_in, n_insts_out :: !Int }
784 The NameCache makes sure that there is just one Unique assigned for
785 each original name; i.e. (module-name, occ-name) pair. The Name is
786 always stored as a Global, and has the SrcLoc of its binding location.
787 Actually that's not quite right. When we first encounter the original
788 name, we might not be at its binding site (e.g. we are reading an
789 interface file); so we give it 'noSrcLoc' then. Later, when we find
790 its binding site, we fix it up.
792 Exactly the same is true of the Module stored in the Name. When we first
793 encounter the occurrence, we may not know the details of the module, so
794 we just store junk. Then when we find the binding site, we fix it up.
798 = NameCache { nsUniqs :: UniqSupply,
800 nsNames :: OrigNameCache,
801 -- Ensures that one original name gets one unique
802 nsIPs :: OrigIParamCache
803 -- Ensures that one implicit parameter name gets one unique
806 type OrigNameCache = ModuleEnv (OccEnv Name)
807 type OrigIParamCache = FiniteMap (IPName OccName) (IPName Name)
811 type Gated d = ([Name], (Module, SDoc, d))
812 -- The [Name] 'gate' the declaration; always non-empty
813 -- Module records which module this decl belongs to
814 -- SDoc records the pathname of the file, or similar err-ctxt info
816 type RulePool = [Gated IfaceRule]
818 addRulesToPool :: RulePool
821 addRulesToPool rules new_rules = new_rules ++ rules
823 -------------------------
824 addEpsInStats :: EpsStats -> Int -> Int -> Int -> EpsStats
825 -- Add stats for one newly-read interface
826 addEpsInStats stats n_decls n_insts n_rules
827 = stats { n_ifaces_in = n_ifaces_in stats + 1
828 , n_decls_in = n_decls_in stats + n_decls
829 , n_insts_in = n_insts_in stats + n_insts
830 , n_rules_in = n_rules_in stats + n_rules }
832 -------------------------
833 type InstPool = NameEnv [Gated IfaceInst]
834 -- The key of the Pool is the Class
835 -- The Names are the TyCons in the instance head
836 -- For example, suppose this is in an interface file
837 -- instance C T where ...
838 -- We want to slurp this decl if both C and T are "visible" in
839 -- the importing module. See "The gating story" in RnIfaces for details.
842 addInstsToPool :: InstPool -> [(Name, Gated IfaceInst)] -> InstPool
843 addInstsToPool insts new_insts
844 = foldr add insts new_insts
846 add :: (Name, Gated IfaceInst) -> NameEnv [Gated IfaceInst] -> NameEnv [Gated IfaceInst]
847 add (cls,new_inst) insts = extendNameEnv_C combine insts cls [new_inst]
849 combine old_insts _ = new_inst : old_insts
853 %************************************************************************
856 A ModSummary is a node in the compilation manager's
857 dependency graph, and it's also passed to hscMain
859 %************************************************************************
861 The nodes of the module graph are
862 EITHER a regular Haskell source module
863 OR a hi-boot source module
868 ms_mod :: Module, -- Name of the module
869 ms_hsc_src :: HscSource, -- Source is Haskell, hs-boot, external core
870 ms_location :: ModLocation, -- Location
871 ms_hs_date :: ClockTime, -- Timestamp of summarised file
872 ms_srcimps :: [Module], -- Source imports
873 ms_imps :: [Module], -- Non-source imports
874 ms_hspp_file :: Maybe FilePath, -- Filename of preprocessed source,
875 -- once we have preprocessed it.
876 ms_hspp_buf :: Maybe StringBuffer -- The actual preprocessed source, maybe.
879 -- The ModLocation contains both the original source filename and the
880 -- filename of the cleaned-up source file after all preprocessing has been
881 -- done. The point is that the summariser will have to cpp/unlit/whatever
882 -- all files anyway, and there's no point in doing this twice -- just
883 -- park the result in a temp file, put the name of it in the location,
884 -- and let @compile@ read from that file on the way back up.
886 -- The ModLocation is stable over successive up-sweeps in GHCi, wheres
887 -- the ms_hs_date and imports can, of course, change
889 msHsFilePath, msHiFilePath, msObjFilePath :: ModSummary -> FilePath
890 msHsFilePath ms = expectJust "msHsFilePath" (ml_hs_file (ms_location ms))
891 msHiFilePath ms = ml_hi_file (ms_location ms)
892 msObjFilePath ms = ml_obj_file (ms_location ms)
894 isBootSummary :: ModSummary -> Bool
895 isBootSummary ms = isHsBoot (ms_hsc_src ms)
897 instance Outputable ModSummary where
899 = sep [text "ModSummary {",
900 nest 3 (sep [text "ms_hs_date = " <> text (show (ms_hs_date ms)),
901 text "ms_mod =" <+> ppr (ms_mod ms)
902 <> text (hscSourceString (ms_hsc_src ms)) <> comma,
903 text "ms_imps =" <+> ppr (ms_imps ms),
904 text "ms_srcimps =" <+> ppr (ms_srcimps ms)]),
908 showModMsg :: Bool -> ModSummary -> String
909 showModMsg use_object mod_summary
910 = showSDoc (hsep [text (mod_str ++ replicate (max 0 (16 - length mod_str)) ' '),
911 char '(', text (msHsFilePath mod_summary) <> comma,
912 if use_object then text (msObjFilePath mod_summary)
913 else text "interpreted",
916 mod = ms_mod mod_summary
917 mod_str = moduleUserString mod ++ hscSourceString (ms_hsc_src mod_summary)
921 %************************************************************************
923 \subsection{Linkable stuff}
925 %************************************************************************
927 This stuff is in here, rather than (say) in Linker.lhs, because the Linker.lhs
928 stuff is the *dynamic* linker, and isn't present in a stage-1 compiler
932 linkableTime :: ClockTime, -- Time at which this linkable was built
933 -- (i.e. when the bytecodes were produced,
934 -- or the mod date on the files)
935 linkableModule :: Module, -- Should be Module, but see below
936 linkableUnlinked :: [Unlinked]
939 isObjectLinkable :: Linkable -> Bool
940 isObjectLinkable l = all isObject (linkableUnlinked l)
942 instance Outputable Linkable where
943 ppr (LM when_made mod unlinkeds)
944 = (text "LinkableM" <+> parens (text (show when_made)) <+> ppr mod)
945 $$ nest 3 (ppr unlinkeds)
947 -------------------------------------------
952 | BCOs CompiledByteCode
955 data CompiledByteCode = NoByteCode
958 instance Outputable Unlinked where
959 ppr (DotO path) = text "DotO" <+> text path
960 ppr (DotA path) = text "DotA" <+> text path
961 ppr (DotDLL path) = text "DotDLL" <+> text path
963 ppr (BCOs bcos) = text "BCOs" <+> ppr bcos
965 ppr (BCOs bcos) = text "No byte code"
968 isObject (DotO _) = True
969 isObject (DotA _) = True
970 isObject (DotDLL _) = True
973 isInterpretable = not . isObject
975 nameOfObject (DotO fn) = fn
976 nameOfObject (DotA fn) = fn
977 nameOfObject (DotDLL fn) = fn
979 byteCodeOfObject (BCOs bc) = bc