2 % (c) The University of Glasgow, 2000
4 \section[HscTypes]{Types for the per-module compiler}
11 ModDetails(..), ModIface(..),
12 ModGuts(..), ModImports(..), ForeignStubs(..),
13 ParsedIface(..), IfaceDeprecs,
15 HomePackageTable, HomeModInfo(..), emptyHomePackageTable,
17 ExternalPackageState(..),
18 PackageTypeEnv, PackageIfaceTable, emptyPackageIfaceTable,
19 lookupIface, lookupIfaceByModName, moduleNameToModule,
22 InteractiveContext(..), emptyInteractiveContext, icPrintUnqual,
24 IfaceDecls, mkIfaceDecls, dcl_tycl, dcl_rules, dcl_insts,
26 VersionInfo(..), initialVersionInfo, lookupVersion,
27 FixityEnv, lookupFixity, collectFixities, emptyFixityEnv,
29 TyThing(..), isTyClThing, implicitTyThingIds,
31 TypeEnv, lookupType, mkTypeEnv, emptyTypeEnv,
32 extendTypeEnvList, extendTypeEnvWithIds,
33 typeEnvElts, typeEnvClasses, typeEnvTyCons, typeEnvIds,
35 WhetherHasOrphans, IsBootInterface, DeclsMap, Usage(..), Dependencies,
36 IfaceInsts, IfaceRules, GatedDecl, GatedDecls, GateFn,
37 NameCache(..), OrigNameCache, OrigIParamCache,
38 Avails, availsToNameSet, availName, availNames,
39 GenAvailInfo(..), AvailInfo, RdrAvailInfo,
40 ExportItem, RdrExportItem,
42 PersistentCompilerState(..),
44 Deprecations(..), lookupDeprec, plusDeprecs,
46 InstEnv, ClsInstEnv, DFunId,
47 PackageInstEnv, PackageRuleBase,
49 GlobalRdrEnv, GlobalRdrElt(..), emptyGlobalRdrEnv, pprGlobalRdrEnv,
50 LocalRdrEnv, extendLocalRdrEnv, isLocalGRE, unQualInScope,
53 Linkable(..), isObjectLinkable,
54 Unlinked(..), CompiledByteCode,
55 isObject, nameOfObject, isInterpretable, byteCodeOfObject,
58 Provenance(..), ImportReason(..),
59 pprNameProvenance, hasBetterProv
63 #include "HsVersions.h"
66 import ByteCodeAsm ( CompiledByteCode )
69 import RdrName ( RdrName, mkRdrUnqual,
70 RdrNameEnv, addListToRdrEnv, foldRdrEnv, isUnqual,
71 rdrEnvToList, emptyRdrEnv )
72 import Name ( Name, NamedThing, getName, nameOccName, nameModule, nameSrcLoc )
75 import OccName ( OccName )
77 import InstEnv ( InstEnv, ClsInstEnv, DFunId )
78 import Rules ( RuleBase )
79 import CoreSyn ( CoreBind )
81 import Class ( Class, classSelIds )
82 import TyCon ( TyCon, isNewTyCon, tyConGenIds, tyConSelIds, tyConDataCons_maybe )
83 import Type ( TyThing(..), isTyClThing )
84 import DataCon ( dataConWorkId, dataConWrapId )
85 import Packages ( PackageName, basePackage )
86 import CmdLineOpts ( DynFlags )
88 import BasicTypes ( Version, initialVersion, IPName,
89 Fixity, FixitySig(..), defaultFixity )
91 import HsSyn ( DeprecTxt, TyClDecl, InstDecl, RuleDecl,
92 tyClDeclName, ifaceRuleDeclName, tyClDeclNames,
94 import RnHsSyn ( RenamedTyClDecl, RenamedRuleDecl, RenamedInstDecl )
96 import CoreSyn ( IdCoreRule )
97 import PrelNames ( isBuiltInSyntaxName )
101 import Maybes ( orElse )
103 import SrcLoc ( SrcLoc, isGoodSrcLoc )
104 import Util ( thenCmp, sortLt )
105 import UniqSupply ( UniqSupply )
106 import Maybe ( fromJust )
107 import FastString ( FastString )
109 import Time ( ClockTime )
113 %************************************************************************
115 \subsection{Compilation environment}
117 %************************************************************************
119 The HscEnv gives the environment in which to compile a chunk of code.
122 data HscEnv = HscEnv { hsc_mode :: GhciMode,
123 hsc_dflags :: DynFlags,
124 hsc_HPT :: HomePackageTable }
127 The GhciMode is self-explanatory:
130 data GhciMode = Batch | Interactive | OneShot
135 type HomePackageTable = ModuleEnv HomeModInfo -- Domain = modules in the home package
136 type PackageIfaceTable = ModuleEnv ModIface -- Domain = modules in the imported packages
138 emptyHomePackageTable = emptyModuleEnv
139 emptyPackageIfaceTable = emptyModuleEnv
141 data HomeModInfo = HomeModInfo { hm_iface :: ModIface,
142 hm_details :: ModDetails,
143 hm_linkable :: Linkable }
146 Simple lookups in the symbol table.
149 lookupIface :: HomePackageTable -> PackageIfaceTable -> Name -> Maybe ModIface
150 -- We often have two IfaceTables, and want to do a lookup
151 lookupIface hpt pit name
152 = case lookupModuleEnv hpt mod of
153 Just mod_info -> Just (hm_iface mod_info)
154 Nothing -> lookupModuleEnv pit mod
156 mod = nameModule name
158 lookupIfaceByModName :: HomePackageTable -> PackageIfaceTable -> ModuleName -> Maybe ModIface
159 -- We often have two IfaceTables, and want to do a lookup
160 lookupIfaceByModName hpt pit mod
161 = case lookupModuleEnvByName hpt mod of
162 Just mod_info -> Just (hm_iface mod_info)
163 Nothing -> lookupModuleEnvByName pit mod
167 -- Use instead of Finder.findModule if possible: this way doesn't
168 -- require filesystem operations, and it is guaranteed not to fail
169 -- when the IfaceTables are properly populated (i.e. after the renamer).
170 moduleNameToModule :: HomePackageTable -> PackageIfaceTable -> ModuleName -> Module
171 moduleNameToModule hpt pit mod
172 = mi_module (fromJust (lookupIfaceByModName hpt pit mod))
176 %************************************************************************
178 \subsection{Symbol tables and Module details}
180 %************************************************************************
182 A @ModIface@ plus a @ModDetails@ summarises everything we know
183 about a compiled module. The @ModIface@ is the stuff *before* linking,
184 and can be written out to an interface file. (The @ModDetails@ is after
185 linking; it is the "linked" form of the mi_decls field.)
187 When we *read* an interface file, we also construct a @ModIface@ from it,
188 except that the mi_decls part is empty; when reading we consolidate
189 the declarations into a single indexed map in the @PersistentRenamerState@.
194 mi_module :: !Module,
195 mi_package :: !PackageName, -- Which package the module comes from
196 mi_version :: !VersionInfo, -- Version info for everything in this module
197 mi_orphan :: !WhetherHasOrphans, -- Whether this module has orphans
198 mi_boot :: !IsBootInterface, -- Read from an hi-boot file?
200 mi_deps :: Dependencies,
201 -- This is consulted for directly-imported modules, but
202 -- not for anything else
204 mi_usages :: [Usage Name],
205 -- Usages; kept sorted so that it's easy to decide
206 -- whether to write a new iface file (changing usages
207 -- doesn't affect the version of this module)
208 -- NOT STRICT! we read this field lazily from the interface file
209 -- It is *only* consulted by the recompilation checker
211 mi_exports :: ![ExportItem],
212 -- What it exports Kept sorted by (mod,occ), to make
213 -- version comparisons easier
215 mi_globals :: !(Maybe GlobalRdrEnv),
216 -- Its top level environment or Nothing if we read this
217 -- interface from an interface file. (We need the source
218 -- file to figure out the top-level environment.)
220 mi_fixities :: !FixityEnv, -- Fixities
221 mi_deprecs :: Deprecations, -- Deprecations
222 -- NOT STRICT! we read this field lazilly from the interface file
224 mi_decls :: IfaceDecls -- The RnDecls form of ModDetails
225 -- NOT STRICT! we fill this field with _|_ sometimes
228 -- Should be able to construct ModDetails from mi_decls in ModIface
231 -- The next three fields are created by the typechecker
232 md_types :: !TypeEnv,
233 md_insts :: ![DFunId], -- Dfun-ids for the instances in this module
234 md_rules :: ![IdCoreRule] -- Domain may include Ids from other modules
237 -- A ModGuts is carried through the compiler, accumulating stuff as it goes
238 -- There is only one ModGuts at any time, the one for the module
239 -- being compiled right now. Once it is compiled, a ModIface and
240 -- ModDetails are extracted and the ModGuts is dicarded.
244 mg_module :: !Module,
245 mg_exports :: !Avails, -- What it exports
246 mg_deps :: !Dependencies, -- What is below it, directly or otherwise
247 mg_dir_imps :: ![Module], -- Directly-imported modules; used to
248 -- generate initialisation code
249 mg_usages :: ![Usage Name], -- Version info for what it needed
251 mg_rdr_env :: !GlobalRdrEnv, -- Top-level lexical environment
252 mg_fix_env :: !FixityEnv, -- Fixity env, for things declared in this module
253 mg_deprecs :: !Deprecations, -- Deprecations declared in the module
255 mg_types :: !TypeEnv,
256 mg_insts :: ![DFunId], -- Instances
257 mg_rules :: ![IdCoreRule], -- Rules from this module
258 mg_binds :: ![CoreBind], -- Bindings for this module
259 mg_foreign :: !ForeignStubs
262 -- The ModGuts takes on several slightly different forms:
264 -- After simplification, the following fields change slightly:
265 -- mg_rules Orphan rules only (local ones now attached to binds)
266 -- mg_binds With rules attached
268 -- After CoreTidy, the following fields change slightly:
269 -- mg_types Now contains Ids as well, replete with final IdInfo
270 -- The Ids are only the ones that are visible from
271 -- importing modules. Without -O that means only
272 -- exported Ids, but with -O importing modules may
273 -- see ids mentioned in unfoldings of exported Ids
275 -- mg_insts Same DFunIds as before, but with final IdInfo,
276 -- and the unique might have changed; remember that
277 -- CoreTidy links up the uniques of old and new versions
279 -- mg_rules All rules for exported things, substituted with final Ids
287 imp_direct :: ![(Module,Bool)], -- Explicitly-imported modules
288 -- Boolean is true if we imported the whole
289 -- module (apart, perhaps, from hiding some)
290 imp_pkg_mods :: !ModuleSet, -- Non-home-package modules on which we depend,
291 -- directly or indirectly
292 imp_home_names :: !NameSet -- Home package things on which we depend,
293 -- directly or indirectly
296 data ForeignStubs = NoStubs
298 SDoc -- Header file prototypes for
299 -- "foreign exported" functions
300 SDoc -- C stubs to use when calling
301 -- "foreign exported" functions
302 [FastString] -- Headers that need to be included
303 -- into C code generated for this module
304 [Id] -- Foreign-exported binders
305 -- we have to generate code to register these
308 data IfaceDecls = IfaceDecls { dcl_tycl :: [RenamedTyClDecl], -- Sorted
309 dcl_rules :: [RenamedRuleDecl], -- Sorted
310 dcl_insts :: [RenamedInstDecl] } -- Unsorted
312 mkIfaceDecls :: [RenamedTyClDecl] -> [RenamedRuleDecl] -> [RenamedInstDecl] -> IfaceDecls
313 -- Sort to put them in canonical order for version comparison
314 mkIfaceDecls tycls rules insts
315 = IfaceDecls { dcl_tycl = sortLt lt_tycl tycls,
316 dcl_rules = sortLt lt_rule rules,
317 dcl_insts = sortLt lt_inst insts }
319 d1 `lt_tycl` d2 = tyClDeclName d1 < tyClDeclName d2
320 r1 `lt_rule` r2 = ifaceRuleDeclName r1 < ifaceRuleDeclName r2
321 i1 `lt_inst` i2 = instDeclDFun i1 < instDeclDFun i2
325 emptyModIface :: Module -> ModIface
327 = ModIface { mi_module = mod,
328 mi_package = basePackage, -- XXX fully bogus
329 mi_version = initialVersionInfo,
335 mi_fixities = emptyNameEnv,
336 mi_globals = Nothing,
337 mi_deprecs = NoDeprecs,
338 mi_decls = panic "emptyModIface: decls"
343 %************************************************************************
345 Parsed interface files
347 %************************************************************************
349 A ParsedIface is exactly as read from an interface file.
352 type IfaceDeprecs = Maybe (Either DeprecTxt [(RdrName,DeprecTxt)])
353 -- Nothing => NoDeprecs
354 -- Just (Left t) => DeprecAll
355 -- Just (Right p) => DeprecSome
359 pi_mod :: ModuleName,
360 pi_pkg :: PackageName,
361 pi_vers :: Version, -- Module version number
362 pi_orphan :: WhetherHasOrphans, -- Whether this module has orphans
363 pi_deps :: Dependencies, -- What it depends on
364 pi_usages :: [Usage OccName], -- Usages
365 pi_exports :: (Version, [RdrExportItem]), -- Exports
366 pi_decls :: [(Version, TyClDecl RdrName)], -- Local definitions
367 pi_fixity :: [FixitySig RdrName], -- Local fixity declarations,
368 pi_insts :: [InstDecl RdrName], -- Local instance declarations
369 pi_rules :: (Version, [RuleDecl RdrName]), -- Rules, with their version
370 pi_deprecs :: IfaceDeprecs -- Deprecations
375 %************************************************************************
377 \subsection{The interactive context}
379 %************************************************************************
382 data InteractiveContext
383 = InteractiveContext {
384 ic_toplev_scope :: [Module], -- Include the "top-level" scope of
387 ic_exports :: [Module], -- 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 = emptyRdrEnv,
403 ic_rn_local_env = emptyRdrEnv,
404 ic_type_env = emptyTypeEnv }
406 icPrintUnqual :: InteractiveContext -> PrintUnqualified
407 icPrintUnqual ictxt = unQualInScope (ic_rn_gbl_env ictxt)
411 %************************************************************************
413 \subsection{Type environment stuff}
415 %************************************************************************
418 typeEnvElts :: TypeEnv -> [TyThing]
419 typeEnvClasses :: TypeEnv -> [Class]
420 typeEnvTyCons :: TypeEnv -> [TyCon]
421 typeEnvIds :: TypeEnv -> [Id]
423 typeEnvElts env = nameEnvElts env
424 typeEnvClasses env = [cl | AClass cl <- typeEnvElts env]
425 typeEnvTyCons env = [tc | ATyCon tc <- typeEnvElts env]
426 typeEnvIds env = [id | AnId id <- typeEnvElts env]
428 implicitTyThingIds :: [TyThing] -> [Id]
429 -- Add the implicit data cons and selectors etc
430 implicitTyThingIds things
431 = concat (map go things)
434 go (AClass cl) = classSelIds cl
435 go (ATyCon tc) = tyConGenIds tc ++
437 [ n | dc <- tyConDataCons_maybe tc `orElse` [],
438 n <- implicitConIds tc dc]
439 -- Synonyms return empty list of constructors and selectors
441 implicitConIds tc dc -- Newtypes have a constructor wrapper,
443 | isNewTyCon tc = [dataConWrapId dc]
444 | otherwise = [dataConWorkId dc, dataConWrapId dc]
449 type TypeEnv = NameEnv TyThing
451 emptyTypeEnv = emptyNameEnv
453 mkTypeEnv :: [TyThing] -> TypeEnv
454 mkTypeEnv things = extendTypeEnvList emptyTypeEnv things
456 extendTypeEnvList :: TypeEnv -> [TyThing] -> TypeEnv
457 extendTypeEnvList env things
458 = extendNameEnvList env [(getName thing, thing) | thing <- things]
460 extendTypeEnvWithIds :: TypeEnv -> [Id] -> TypeEnv
461 extendTypeEnvWithIds env ids
462 = extendNameEnvList env [(getName id, AnId id) | id <- ids]
466 lookupType :: HomePackageTable -> PackageTypeEnv -> Name -> Maybe TyThing
467 lookupType hpt pte name
468 = case lookupModuleEnv hpt (nameModule name) of
469 Just details -> lookupNameEnv (md_types (hm_details details)) name
470 Nothing -> lookupNameEnv pte name
473 %************************************************************************
475 \subsection{Auxiliary types}
477 %************************************************************************
479 These types are defined here because they are mentioned in ModDetails,
480 but they are mostly elaborated elsewhere
485 vers_module :: Version, -- Changes when anything changes
486 vers_exports :: Version, -- Changes when export list changes
487 vers_rules :: Version, -- Changes when any rule changes
488 vers_decls :: NameEnv Version
489 -- Versions for "big" names only (not data constructors, class ops)
490 -- The version of an Id changes if its fixity changes
491 -- Ditto data constructors, class operations, except that the version of
492 -- the parent class/tycon changes
494 -- If a name isn't in the map, it means 'initialVersion'
497 initialVersionInfo :: VersionInfo
498 initialVersionInfo = VersionInfo { vers_module = initialVersion,
499 vers_exports = initialVersion,
500 vers_rules = initialVersion,
501 vers_decls = emptyNameEnv
504 lookupVersion :: NameEnv Version -> Name -> Version
505 lookupVersion env name = lookupNameEnv env name `orElse` initialVersion
507 data Deprecations = NoDeprecs
508 | DeprecAll DeprecTxt -- Whole module deprecated
509 | DeprecSome (NameEnv (Name,DeprecTxt)) -- Some things deprecated
511 -- We keep the Name in the range, so we can print them out
513 lookupDeprec :: Deprecations -> Name -> Maybe DeprecTxt
514 lookupDeprec NoDeprecs name = Nothing
515 lookupDeprec (DeprecAll txt) name = Just txt
516 lookupDeprec (DeprecSome env) name = case lookupNameEnv env name of
517 Just (_, txt) -> Just txt
520 plusDeprecs :: Deprecations -> Deprecations -> Deprecations
521 plusDeprecs d NoDeprecs = d
522 plusDeprecs NoDeprecs d = d
523 plusDeprecs d (DeprecAll t) = DeprecAll t
524 plusDeprecs (DeprecAll t) d = DeprecAll t
525 plusDeprecs (DeprecSome v1) (DeprecSome v2) = DeprecSome (v1 `plusNameEnv` v2)
527 instance Eq Deprecations where
528 -- Used when checking whether we need write a new interface
529 NoDeprecs == NoDeprecs = True
530 (DeprecAll t1) == (DeprecAll t2) = t1 == t2
531 (DeprecSome e1) == (DeprecSome e2) = nameEnvElts e1 == nameEnvElts e2
537 type Avails = [AvailInfo]
538 type AvailInfo = GenAvailInfo Name
539 type RdrAvailInfo = GenAvailInfo OccName
541 data GenAvailInfo name = Avail name -- An ordinary identifier
542 | AvailTC name -- The name of the type or class
543 [name] -- The available pieces of type/class.
544 -- NB: If the type or class is itself
545 -- to be in scope, it must be in this list.
546 -- Thus, typically: AvailTC Eq [Eq, ==, /=]
548 -- Equality used when deciding if the interface has changed
550 type RdrExportItem = (ModuleName, [RdrAvailInfo])
551 type ExportItem = (ModuleName, [AvailInfo])
553 availsToNameSet :: [AvailInfo] -> NameSet
554 availsToNameSet avails = foldl add emptyNameSet avails
556 add set avail = addListToNameSet set (availNames avail)
558 availName :: GenAvailInfo name -> name
559 availName (Avail n) = n
560 availName (AvailTC n _) = n
562 availNames :: GenAvailInfo name -> [name]
563 availNames (Avail n) = [n]
564 availNames (AvailTC n ns) = ns
566 instance Outputable n => Outputable (GenAvailInfo n) where
569 pprAvail :: Outputable n => GenAvailInfo n -> SDoc
570 pprAvail (AvailTC n ns) = ppr n <> case {- filter (/= n) -} ns of
572 ns' -> braces (hsep (punctuate comma (map ppr ns')))
574 pprAvail (Avail n) = ppr n
578 type FixityEnv = NameEnv (FixitySig Name)
579 -- We keep the whole fixity sig so that we
580 -- can report line-number info when there is a duplicate
581 -- fixity declaration
583 emptyFixityEnv :: FixityEnv
584 emptyFixityEnv = emptyNameEnv
586 lookupFixity :: FixityEnv -> Name -> Fixity
587 lookupFixity env n = case lookupNameEnv env n of
588 Just (FixitySig _ fix _) -> fix
589 Nothing -> defaultFixity
591 collectFixities :: FixityEnv -> [TyClDecl Name] -> [FixitySig Name]
592 -- Collect fixities for the specified declarations
593 collectFixities env decls
595 | d <- decls, (n,_) <- tyClDeclNames d,
596 Just fix <- [lookupNameEnv env n]
601 %************************************************************************
603 \subsection{WhatsImported}
605 %************************************************************************
608 type WhetherHasOrphans = Bool
610 -- * an instance decl in a module other than the defn module for
611 -- one of the tycons or classes in the instance head
612 -- * a transformation rule in a module other than the one defining
613 -- the function in the head of the rule.
615 type IsBootInterface = Bool
617 -- Dependency info about modules and packages below this one
618 -- in the import hierarchy. See TcRnTypes.ImportAvails for details.
620 -- Invariant: the dependencies of a module M never includes M
622 = ([(ModuleName, WhetherHasOrphans, IsBootInterface)], [PackageName])
625 = Usage { usg_name :: ModuleName, -- Name of the module
626 usg_mod :: Version, -- Module version
627 usg_exports :: Maybe Version, -- Export-list version, if we depend on it
628 usg_entities :: [(name,Version)], -- Sorted by occurrence name
629 usg_rules :: Version -- Rules version
631 -- This type doesn't let you say "I imported f but none of the rules in
632 -- the module". If you use anything in the module you get its rule version
633 -- So if the rules change, you'll recompile, even if you don't use them.
634 -- This is easy to implement, and it's safer: you might not have used the rules last
635 -- time round, but if someone has added a new rule you might need it this time
637 -- The export list field is (Just v) if we depend on the export list:
638 -- i.e. we imported the module without saying exactly what we imported
639 -- We need to recompile if the module exports changes, because we might
640 -- now have a name clash in the importing module.
644 %************************************************************************
646 \subsection{The persistent compiler state}
648 %************************************************************************
650 The @PersistentCompilerState@ persists across successive calls to the
654 data PersistentCompilerState
656 pcs_nc :: !NameCache,
657 pcs_EPS :: !ExternalPackageState
663 type PackageTypeEnv = TypeEnv
664 type PackageRuleBase = RuleBase
665 type PackageInstEnv = InstEnv
667 data ExternalPackageState
669 eps_PIT :: !PackageIfaceTable,
670 -- The ModuleIFaces for modules in external packages
671 -- whose interfaces we have opened
672 -- The declarations in these interface files are held in
673 -- eps_decls, eps_insts, eps_rules (below), not in the
674 -- mi_decls fields of the iPIT.
675 -- What _is_ in the iPIT is:
682 eps_PTE :: !PackageTypeEnv, -- Domain = external-package modules
684 eps_inst_env :: !PackageInstEnv, -- The total InstEnv accumulated from
685 -- all the external-package modules
686 eps_rule_base :: !PackageRuleBase, -- Ditto RuleEnv
689 -- Holding pens for stuff that has been read in from file,
690 -- but not yet slurped into the renamer
691 eps_decls :: !DeclsMap,
692 -- A single, global map of Names to unslurped decls
693 eps_insts :: !IfaceInsts,
694 -- The as-yet un-slurped instance decls; this bag is depleted when we
695 -- slurp an instance decl so that we don't slurp the same one twice.
696 -- Each is 'gated' by the names that must be available before
697 -- this instance decl is needed.
698 eps_rules :: !IfaceRules,
699 -- Similar to instance decls, only for rules
701 eps_inst_gates :: !NameSet -- Gates for instance decls
702 -- The instance gates must accumulate across
703 -- all invocations of the renamer;
704 -- see "the gating story" in RnIfaces.lhs
705 -- These names should all be from other packages;
706 -- for the home package we have all the instance
707 -- declarations anyhow
711 The NameCache makes sure that there is just one Unique assigned for
712 each original name; i.e. (module-name, occ-name) pair. The Name is
713 always stored as a Global, and has the SrcLoc of its binding location.
714 Actually that's not quite right. When we first encounter the original
715 name, we might not be at its binding site (e.g. we are reading an
716 interface file); so we give it 'noSrcLoc' then. Later, when we find
717 its binding site, we fix it up.
719 Exactly the same is true of the Module stored in the Name. When we first
720 encounter the occurrence, we may not know the details of the module, so
721 we just store junk. Then when we find the binding site, we fix it up.
725 = NameCache { nsUniqs :: UniqSupply,
727 nsNames :: OrigNameCache,
728 -- Ensures that one original name gets one unique
729 nsIPs :: OrigIParamCache
730 -- Ensures that one implicit parameter name gets one unique
733 type OrigNameCache = ModuleEnv (Module, OccNameCache)
734 -- Maps a module *name* to a Module,
735 -- plus the OccNameEnv fot that module
736 type OccNameCache = FiniteMap OccName Name
737 -- Maps the OccName to a Name
738 -- A FiniteMap because OccNames have a Namespace/Faststring pair
740 type OrigIParamCache = FiniteMap (IPName RdrName) (IPName Name)
743 A DeclsMap contains a binding for each Name in the declaration
744 including the constructors of a type decl etc. The Bool is True just
748 type DeclsMap = (NameEnv (AvailInfo, Bool, (Module, TyClDecl RdrName)), Int)
749 -- The Int says how many have been sucked in
751 type IfaceInsts = GatedDecls (InstDecl RdrName)
752 type IfaceRules = GatedDecls (RuleDecl RdrName)
754 type GatedDecls d = (Bag (GatedDecl d), Int) -- The Int says how many have been sucked in
755 type GatedDecl d = (GateFn, (Module, d))
756 type GateFn = (Name -> Bool) -> Bool -- Returns True <=> gate is open
757 -- The (Name -> Bool) fn returns True for visible Names
758 -- For example, suppose this is in an interface file
759 -- instance C T where ...
760 -- We want to slurp this decl if both C and T are "visible" in
761 -- the importing module. See "The gating story" in RnIfaces for details.
765 %************************************************************************
767 \subsection{Linkable stuff}
769 %************************************************************************
771 This stuff is in here, rather than (say) in Linker.lhs, because the Linker.lhs
772 stuff is the *dynamic* linker, and isn't present in a stage-1 compiler
776 linkableTime :: ClockTime, -- Time at which this linkable was built
777 -- (i.e. when the bytecodes were produced,
778 -- or the mod date on the files)
779 linkableModName :: ModuleName, -- Should be Module, but see below
780 linkableUnlinked :: [Unlinked]
783 isObjectLinkable :: Linkable -> Bool
784 isObjectLinkable l = all isObject (linkableUnlinked l)
786 instance Outputable Linkable where
787 ppr (LM when_made mod unlinkeds)
788 = (text "LinkableM" <+> parens (text (show when_made)) <+> ppr mod)
789 $$ nest 3 (ppr unlinkeds)
791 -------------------------------------------
796 | BCOs CompiledByteCode
799 data CompiledByteCode = NoByteCode
802 instance Outputable Unlinked where
803 ppr (DotO path) = text "DotO" <+> text path
804 ppr (DotA path) = text "DotA" <+> text path
805 ppr (DotDLL path) = text "DotDLL" <+> text path
807 ppr (BCOs bcos) = text "BCOs" <+> ppr bcos
809 ppr (BCOs bcos) = text "No byte code"
812 isObject (DotO _) = True
813 isObject (DotA _) = True
814 isObject (DotDLL _) = True
817 isInterpretable = not . isObject
819 nameOfObject (DotO fn) = fn
820 nameOfObject (DotA fn) = fn
821 nameOfObject (DotDLL fn) = fn
823 byteCodeOfObject (BCOs bc) = bc
827 %************************************************************************
829 \subsection{Provenance and export info}
831 %************************************************************************
833 A LocalRdrEnv is used for local bindings (let, where, lambda, case)
837 type LocalRdrEnv = RdrNameEnv Name
839 extendLocalRdrEnv :: LocalRdrEnv -> [Name] -> LocalRdrEnv
840 extendLocalRdrEnv env names
841 = addListToRdrEnv env [(mkRdrUnqual (nameOccName n), n) | n <- names]
844 The GlobalRdrEnv gives maps RdrNames to Names. There is a separate
845 one for each module, corresponding to that module's top-level scope.
848 type GlobalRdrEnv = RdrNameEnv [GlobalRdrElt]
849 -- The list is because there may be name clashes
850 -- These only get reported on lookup, not on construction
852 emptyGlobalRdrEnv = emptyRdrEnv
855 = GRE { gre_name :: Name,
856 gre_parent :: Name, -- Name of the "parent" structure
857 -- * the tycon of a data con
858 -- * the class of a class op
859 -- For others it's just the same as gre_name
860 gre_prov :: Provenance, -- Why it's in scope
861 gre_deprec :: Maybe DeprecTxt -- Whether this name is deprecated
864 instance Outputable GlobalRdrElt where
865 ppr gre = ppr (gre_name gre) <+>
866 parens (hsep [text "parent:" <+> ppr (gre_parent gre) <> comma,
867 pprNameProvenance gre])
869 = vcat (map pp (rdrEnvToList env))
871 pp (rn, gres) = ppr rn <> colon <+>
872 vcat [ ppr (gre_name gre) <+> pprNameProvenance gre
875 isLocalGRE :: GlobalRdrElt -> Bool
876 isLocalGRE (GRE {gre_prov = LocalDef}) = True
877 isLocalGRE other = False
880 @unQualInScope@ returns a function that takes a @Name@ and tells whether
881 its unqualified name is in scope. This is put as a boolean flag in
882 the @Name@'s provenance to guide whether or not to print the name qualified
886 unQualInScope :: GlobalRdrEnv -> Name -> Bool
887 -- True if 'f' is in scope, and has only one binding,
888 -- and the thing it is bound to is the name we are looking for
889 -- (i.e. false if A.f and B.f are both in scope as unqualified 'f')
891 -- Also checks for built-in syntax, which is always 'in scope'
893 -- This fn is only efficient if the shared
894 -- partial application is used a lot.
896 = \n -> n `elemNameSet` unqual_names || isBuiltInSyntaxName n
898 unqual_names :: NameSet
899 unqual_names = foldRdrEnv add emptyNameSet env
900 add rdr_name [gre] unquals | isUnqual rdr_name = addOneToNameSet unquals (gre_name gre)
901 add _ _ unquals = unquals
904 The "provenance" of something says how it came to be in scope.
908 = LocalDef -- Defined locally
910 | NonLocalDef -- Defined non-locally
913 -- Just used for grouping error messages (in RnEnv.warnUnusedBinds)
914 instance Eq Provenance where
915 p1 == p2 = case p1 `compare` p2 of EQ -> True; _ -> False
917 instance Eq ImportReason where
918 p1 == p2 = case p1 `compare` p2 of EQ -> True; _ -> False
920 instance Ord Provenance where
921 compare LocalDef LocalDef = EQ
922 compare LocalDef (NonLocalDef _) = LT
923 compare (NonLocalDef _) LocalDef = GT
925 compare (NonLocalDef reason1) (NonLocalDef reason2)
926 = compare reason1 reason2
928 instance Ord ImportReason where
929 compare ImplicitImport ImplicitImport = EQ
930 compare ImplicitImport (UserImport _ _ _) = LT
931 compare (UserImport _ _ _) ImplicitImport = GT
932 compare (UserImport m1 loc1 _) (UserImport m2 loc2 _)
933 = (m1 `compare` m2) `thenCmp` (loc1 `compare` loc2)
937 = UserImport Module SrcLoc Bool -- Imported from module M on line L
938 -- Note the M may well not be the defining module
940 -- The Bool is true iff the thing was named *explicitly* in the import spec,
941 -- rather than being imported as part of a group; e.g.
944 -- Here, everything imported by B, and the constructors of T
945 -- are not named explicitly; only T is named explicitly.
946 -- This info is used when warning of unused names.
948 | ImplicitImport -- Imported implicitly for some other reason
952 hasBetterProv :: Provenance -> Provenance -> Bool
954 -- a local thing over an imported thing
955 -- a user-imported thing over a non-user-imported thing
956 -- an explicitly-imported thing over an implicitly imported thing
957 hasBetterProv LocalDef _ = True
958 hasBetterProv (NonLocalDef (UserImport _ _ _ )) (NonLocalDef ImplicitImport) = True
959 hasBetterProv _ _ = False
961 pprNameProvenance :: GlobalRdrElt -> SDoc
962 pprNameProvenance (GRE {gre_name = name, gre_prov = prov})
964 LocalDef -> ptext SLIT("defined at") <+> ppr (nameSrcLoc name)
965 NonLocalDef why -> sep [ppr_reason why,
966 nest 2 (ppr_defn (nameSrcLoc name))]
968 ppr_reason ImplicitImport = ptext SLIT("implicitly imported")
969 ppr_reason (UserImport mod loc _) = ptext SLIT("imported from") <+> ppr mod <+> ptext SLIT("at") <+> ppr loc
971 ppr_defn loc | isGoodSrcLoc loc = parens (ptext SLIT("at") <+> ppr loc)