2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 \section[RnIfaces]{Cacheing and Renaming of Interfaces}
12 getImportedInstDecls, getImportedRules,
13 lookupFixityRn, loadHomeInterface,
14 importDecl, ImportDeclResult(..), recordLocalSlurps, loadBuiltinRules,
15 mkImportExportInfo, getSlurped,
17 getDeclBinders, getDeclSysBinders,
18 removeContext -- removeContext probably belongs somewhere else
22 #include "HsVersions.h"
24 import CmdLineOpts ( opt_NoPruneDecls, opt_NoPruneTyDecls, opt_IgnoreIfacePragmas )
25 import HsSyn ( HsDecl(..), TyClDecl(..), InstDecl(..), IfaceSig(..),
26 HsType(..), ConDecl(..), IE(..), ConDetails(..), Sig(..),
27 ForeignDecl(..), ForKind(..), isDynamicExtName,
28 FixitySig(..), RuleDecl(..),
29 isClassOpSig, DeprecDecl(..)
31 import HsImpExp ( ieNames )
32 import CoreSyn ( CoreRule )
33 import BasicTypes ( Version, defaultFixity )
34 import RdrHsSyn ( RdrNameHsDecl, RdrNameInstDecl, RdrNameRuleDecl,
35 RdrNameDeprecation, RdrNameIE,
40 import ParseIface ( parseIface, IfaceStuff(..) )
42 import Name ( Name {-instance NamedThing-}, nameOccName,
43 nameModule, isLocallyDefined,
45 mkNameEnv, elemNameEnv, extendNameEnv
47 import Module ( Module,
48 moduleName, isModuleInThisPackage,
49 ModuleName, WhereFrom(..),
50 extendModuleEnv, lookupModuleEnv, lookupModuleEnvByName
52 import RdrName ( RdrName, rdrNameOcc )
54 import SrcLoc ( mkSrcLoc, SrcLoc )
55 import PrelInfo ( cCallishTyKeys, wiredInThingEnv )
56 import Maybes ( maybeToBool, orElse )
57 import StringBuffer ( hGetStringBuffer )
58 import FastString ( mkFastString )
59 import ErrUtils ( Message )
60 import Util ( sortLt )
71 %*********************************************************
73 \subsection{Loading a new interface file}
75 %*********************************************************
78 loadHomeInterface :: SDoc -> Name -> RnM d Ifaces
79 loadHomeInterface doc_str name
80 = loadInterface doc_str (moduleName (nameModule name)) ImportBySystem
82 loadOrphanModules :: [ModuleName] -> RnM d ()
83 loadOrphanModules mods
84 | null mods = returnRn ()
85 | otherwise = traceRn (text "Loading orphan modules:" <+>
86 fsep (map ppr mods)) `thenRn_`
87 mapRn_ load mods `thenRn_`
90 load mod = loadInterface (mk_doc mod) mod ImportBySystem
91 mk_doc mod = ppr mod <+> ptext SLIT("is a orphan-instance module")
94 loadInterface :: SDoc -> ModuleName -> WhereFrom -> RnM d Ifaces
95 loadInterface doc mod from
96 = tryLoadInterface doc mod from `thenRn` \ (ifaces, maybe_err) ->
98 Nothing -> returnRn ifaces
99 Just err -> failWithRn ifaces err
101 tryLoadInterface :: SDoc -> ModuleName -> WhereFrom -> RnM d (Ifaces, Maybe Message)
102 -- Returns (Just err) if an error happened
103 -- Guarantees to return with iImpModInfo m --> (... Just cts)
104 -- (If the load fails, we plug in a vanilla placeholder
105 tryLoadInterface doc_str mod_name from
106 = getIfacesRn `thenRn` \ ifaces ->
108 mod_map = iImpModInfo ifaces
109 mod_info = lookupFM mod_map mod_name
112 = case (from, mod_info) of
113 (ImportByUser, _) -> False -- Not hi-boot
114 (ImportByUserSource, _) -> True -- hi-boot
115 (ImportBySystem, Just (_, is_boot, _)) -> is_boot --
116 (ImportBySystem, Nothing) -> False
117 -- We're importing a module we know absolutely
118 -- nothing about, so we assume it's from
119 -- another package, where we aren't doing
120 -- dependency tracking. So it won't be a hi-boot file.
122 redundant_source_import
123 = case (from, mod_info) of
124 (ImportByUserSource, Just (_,False,_)) -> True
127 -- CHECK WHETHER WE HAVE IT ALREADY
130 -> -- We're read it already so don't re-read it
131 returnRn (ifaces, Nothing) ;
135 -- Issue a warning for a redundant {- SOURCE -} import
136 -- NB that we arrange to read all the ordinary imports before
137 -- any of the {- SOURCE -} imports
138 warnCheckRn (not redundant_source_import)
139 (warnRedundantSourceImport mod_name) `thenRn_`
141 -- READ THE MODULE IN
142 findAndReadIface doc_str mod_name hi_boot_file `thenRn` \ read_result ->
143 case read_result of {
144 Left err -> -- Not found, so add an empty export env to the Ifaces map
145 -- so that we don't look again
147 new_mod_map = addToFM mod_map mod_name (False, False, True)
148 new_ifaces = ifaces { iImpModInfo = new_mod_map }
150 setIfacesRn new_ifaces `thenRn_`
151 returnRn (new_ifaces, Just err) ;
154 Right (mod, iface) ->
156 -- LOAD IT INTO Ifaces
158 -- NB: *first* we do loadDecl, so that the provenance of all the locally-defined
159 --- names is done correctly (notably, whether this is an .hi file or .hi-boot file).
160 -- If we do loadExport first the wrong info gets into the cache (unless we
161 -- explicitly tag each export which seems a bit of a bore)
164 -- Sanity check. If we're system-importing a module we know nothing at all
165 -- about, it should be from a different package to this one
166 WARN( not (maybeToBool mod_info) &&
167 case from of { ImportBySystem -> True; other -> False } &&
168 isModuleInThisPackage mod,
171 loadDecls mod (iDecls ifaces) (pi_decls iface) `thenRn` \ (decls_vers, new_decls) ->
172 loadRules mod (iRules ifaces) (pi_rules iface) `thenRn` \ (rule_vers, new_rules) ->
173 loadFixDecls mod_name (pi_fixity iface) `thenRn` \ (fix_vers, fix_env) ->
174 foldlRn (loadDeprec mod) emptyNameEnv (pi_deprecs iface) `thenRn` \ deprec_env ->
175 foldlRn (loadInstDecl mod) (iInsts ifaces) (pi_insts iface) `thenRn` \ new_insts ->
176 loadExports (pi_exports iface) `thenRn` \ avails ->
178 version = VersionInfo { modVers = pi_vers iface,
180 ruleVers = rule_vers,
181 declVers = decls_vers }
183 -- For an explicit user import, add to mod_map info about
184 -- the things the imported module depends on, extracted
185 -- from its usage info.
186 mod_map1 = case from of
187 ImportByUser -> addModDeps mod (pi_usages iface) mod_map
189 mod_map2 = addToFM mod_map1 mod_name (has_orphans, hi_boot_file, True)
191 -- Now add info about this module to the PIT
192 has_orphans = pi_orphan iface
193 new_pit = extendModuleEnv (iPIT ifaces) mod mod_iface
194 mod_iface = ModIface { mi_module = mod, mi_version = version,
195 mi_exports = avails, mi_orphan = has_orphans,
196 mi_fixities = fix_env, mi_deprecs = deprec_env,
197 mi_usages = [], -- Will be filled in later
198 mi_decls = panic "No mi_decls in PIT",
199 mi_globals = panic "No mi_globals in PIT"
202 new_ifaces = ifaces { iPIT = new_pit,
206 iImpModInfo = mod_map2 }
208 setIfacesRn new_ifaces `thenRn_`
209 returnRn (new_ifaces, Nothing)
212 -----------------------------------------------------
213 -- Adding module dependencies from the
214 -- import decls in the interface file
215 -----------------------------------------------------
217 addModDeps :: Module -> [ImportVersion a]
218 -> ImportedModuleInfo -> ImportedModuleInfo
219 -- (addModDeps M ivs deps)
220 -- We are importing module M, and M.hi contains 'import' decls given by ivs
221 addModDeps mod new_deps mod_deps
222 = foldr add mod_deps filtered_new_deps
224 -- Don't record dependencies when importing a module from another package
225 -- Except for its descendents which contain orphans,
226 -- and in that case, forget about the boot indicator
227 filtered_new_deps :: [(ModuleName, (WhetherHasOrphans, IsBootInterface))]
229 | isModuleInThisPackage mod
230 = [ (imp_mod, (has_orphans, is_boot, False))
231 | (imp_mod, has_orphans, is_boot, _) <- new_deps
233 | otherwise = [ (imp_mod, (True, False, False))
234 | (imp_mod, has_orphans, _, _) <- new_deps,
237 add (imp_mod, dep) deps = addToFM_C combine deps imp_mod dep
239 combine old@(_, old_is_boot, old_is_loaded) new
240 | old_is_loaded || not old_is_boot = old -- Keep the old info if it's already loaded
241 -- or if it's a non-boot pending load
242 | otherwise = new -- Otherwise pick new info
245 -----------------------------------------------------
246 -- Loading the export list
247 -----------------------------------------------------
249 loadExports :: [ExportItem] -> RnM d Avails
251 = getModuleRn `thenRn` \ this_mod ->
252 mapRn (loadExport this_mod) items `thenRn` \ avails_s ->
253 returnRn (concat avails_s)
256 loadExport :: Module -> ExportItem -> RnM d [AvailInfo]
257 loadExport this_mod (mod, entities)
258 | mod == moduleName this_mod = returnRn []
259 -- If the module exports anything defined in this module, just ignore it.
260 -- Reason: otherwise it looks as if there are two local definition sites
261 -- for the thing, and an error gets reported. Easiest thing is just to
262 -- filter them out up front. This situation only arises if a module
263 -- imports itself, or another module that imported it. (Necessarily,
264 -- this invoves a loop.) Consequence: if you say
269 -- module B( AType ) where
270 -- import {-# SOURCE #-} A( AType )
272 -- then you'll get a 'B does not export AType' message. A bit bogus
273 -- but it's a bogus thing to do!
276 = mapRn (load_entity mod) entities
278 new_name mod occ = newGlobalName mod occ
280 load_entity mod (Avail occ)
281 = new_name mod occ `thenRn` \ name ->
282 returnRn (Avail name)
283 load_entity mod (AvailTC occ occs)
284 = new_name mod occ `thenRn` \ name ->
285 mapRn (new_name mod) occs `thenRn` \ names ->
286 returnRn (AvailTC name names)
289 -----------------------------------------------------
290 -- Loading type/class/value decls
291 -----------------------------------------------------
295 -> [(Version, RdrNameHsDecl)]
296 -> RnM d (NameEnv Version, DeclsMap)
297 loadDecls mod decls_map decls
298 = foldlRn (loadDecl mod) (emptyNameEnv, decls_map) decls
301 -> (NameEnv Version, DeclsMap)
302 -> (Version, RdrNameHsDecl)
303 -> RnM d (NameEnv Version, DeclsMap)
304 loadDecl mod (version_map, decls_map) (version, decl)
305 = getDeclBinders new_name decl `thenRn` \ maybe_avail ->
306 case maybe_avail of {
307 Nothing -> returnRn (version_map, decls_map); -- No bindings
310 getDeclSysBinders new_name decl `thenRn` \ sys_bndrs ->
312 full_avail = addSysAvails avail sys_bndrs
313 -- Add the sys-binders to avail. When we import the decl,
314 -- it's full_avail that will get added to the 'already-slurped' set (iSlurp)
315 -- If we miss out sys-binders, we'll read the decl multiple times!
317 main_name = availName avail
318 new_decls_map = foldl add_decl decls_map
319 [ (name, (full_avail, name==main_name, (mod, decl')))
320 | name <- availNames full_avail]
321 add_decl decls_map (name, stuff)
322 = WARN( name `elemNameEnv` decls_map, ppr name )
323 extendNameEnv decls_map name stuff
325 new_version_map = extendNameEnv version_map main_name version
327 returnRn (new_version_map, new_decls_map)
330 -- newTopBinder puts into the cache the binder with the
331 -- module information set correctly. When the decl is later renamed,
332 -- the binding site will thereby get the correct module.
333 -- There maybe occurrences that don't have the correct Module, but
334 -- by the typechecker will propagate the binding definition to all
335 -- the occurrences, so that doesn't matter
336 new_name rdr_name loc = newTopBinder mod rdr_name loc
339 If a signature decl is being loaded, and optIgnoreIfacePragmas is on,
340 we toss away unfolding information.
342 Also, if the signature is loaded from a module we're importing from source,
343 we do the same. This is to avoid situations when compiling a pair of mutually
344 recursive modules, peering at unfolding info in the interface file of the other,
345 e.g., you compile A, it looks at B's interface file and may as a result change
346 its interface file. Hence, B is recompiled, maybe changing its interface file,
347 which will the unfolding info used in A to become invalid. Simple way out is to
348 just ignore unfolding info.
350 [Jan 99: I junked the second test above. If we're importing from an hi-boot
351 file there isn't going to *be* any pragma info. Maybe the above comment
352 dates from a time where we picked up a .hi file first if it existed?]
355 SigD (IfaceSig name tp ls loc) | opt_IgnoreIfacePragmas
356 -> SigD (IfaceSig name tp [] loc)
359 -----------------------------------------------------
360 -- Loading fixity decls
361 -----------------------------------------------------
363 loadFixDecls mod_name (version, decls)
364 = mapRn (loadFixDecl mod_name) decls `thenRn` \ to_add ->
365 returnRn (version, mkNameEnv to_add)
367 loadFixDecl mod_name sig@(FixitySig rdr_name fixity loc)
368 = newGlobalName mod_name (rdrNameOcc rdr_name) `thenRn` \ name ->
369 returnRn (name, fixity)
372 -----------------------------------------------------
373 -- Loading instance decls
374 -----------------------------------------------------
376 loadInstDecl :: Module
380 loadInstDecl mod insts decl@(InstDecl inst_ty binds uprags dfun_name src_loc)
382 -- Find out what type constructors and classes are "gates" for the
383 -- instance declaration. If all these "gates" are slurped in then
384 -- we should slurp the instance decl too.
386 -- We *don't* want to count names in the context part as gates, though.
388 -- instance Foo a => Baz (T a) where ...
390 -- Here the gates are Baz and T, but *not* Foo.
392 munged_inst_ty = removeContext inst_ty
393 free_names = extractHsTyRdrNames munged_inst_ty
396 mapRn lookupOrigName free_names `thenRn` \ gate_names ->
397 returnRn ((mkNameSet gate_names, (mod, InstD decl)) `consBag` insts)
400 -- In interface files, the instance decls now look like
401 -- forall a. Foo a -> Baz (T a)
402 -- so we have to strip off function argument types as well
403 -- as the bit before the '=>' (which is always empty in interface files)
404 removeContext (HsForAllTy tvs cxt ty) = HsForAllTy tvs [] (removeFuns ty)
405 removeContext ty = removeFuns ty
407 removeFuns (HsFunTy _ ty) = removeFuns ty
411 -----------------------------------------------------
413 -----------------------------------------------------
415 loadRules :: Module -> IfaceRules
416 -> (Version, [RdrNameRuleDecl])
417 -> RnM d (Version, IfaceRules)
418 loadRules mod rule_bag (version, rules)
419 | null rules || opt_IgnoreIfacePragmas
420 = returnRn (version, rule_bag)
423 mapRn (loadRule mod) rules `thenRn` \ new_rules ->
424 returnRn (version, rule_bag `unionBags` listToBag new_rules)
426 loadRule :: Module -> RdrNameRuleDecl -> RnM d GatedDecl
427 -- "Gate" the rule simply by whether the rule variable is
428 -- needed. We can refine this later.
429 loadRule mod decl@(IfaceRule _ _ var _ _ src_loc)
430 = lookupOrigName var `thenRn` \ var_name ->
431 returnRn (unitNameSet var_name, (mod, RuleD decl))
433 loadBuiltinRules :: [(RdrName, CoreRule)] -> RnMG ()
434 loadBuiltinRules builtin_rules
435 = getIfacesRn `thenRn` \ ifaces ->
436 mapRn loadBuiltinRule builtin_rules `thenRn` \ rule_decls ->
437 setIfacesRn (ifaces { iRules = iRules ifaces `unionBags` listToBag rule_decls })
439 loadBuiltinRule (var, rule)
440 = lookupOrigName var `thenRn` \ var_name ->
441 returnRn (unitNameSet var_name, (nameModule var_name, RuleD (IfaceRuleOut var rule)))
444 -----------------------------------------------------
445 -- Loading Deprecations
446 -----------------------------------------------------
448 loadDeprec :: Module -> DeprecationEnv -> RdrNameDeprecation -> RnM d DeprecationEnv
449 loadDeprec mod deprec_env (Deprecation (IEModuleContents _) txt _)
450 = traceRn (text "module deprecation not yet implemented:" <+> ppr mod <> colon <+> ppr txt) `thenRn_`
451 -- SUP: TEMPORARY HACK, ignoring module deprecations for now
454 loadDeprec mod deprec_env (Deprecation ie txt _)
456 mapRn lookupOrigName (ieNames ie) `thenRn` \ names ->
457 traceRn (text "loaded deprecation(s) for" <+> hcat (punctuate comma (map ppr names)) <> colon <+> ppr txt) `thenRn_`
458 returnRn (extendNameEnvList deprec_env (zip names (repeat txt)))
462 %*********************************************************
464 \subsection{Getting in a declaration}
466 %*********************************************************
469 importDecl :: Name -> RnMG ImportDeclResult
471 data ImportDeclResult
475 | HereItIs (Module, RdrNameHsDecl)
478 = -- Check if it was loaded before beginning this module
479 checkAlreadyAvailable name `thenRn` \ done ->
481 returnRn AlreadySlurped
484 -- Check if we slurped it in while compiling this module
485 getIfacesRn `thenRn` \ ifaces ->
486 if name `elemNameSet` iSlurp ifaces then
487 returnRn AlreadySlurped
490 -- Don't slurp in decls from this module's own interface file
491 -- (Indeed, this shouldn't happen.)
492 if isLocallyDefined name then
493 addWarnRn (importDeclWarn name) `thenRn_`
494 returnRn AlreadySlurped
497 -- When we find a wired-in name we must load its home
498 -- module so that we find any instance decls lurking therein
499 if name `elemNameEnv` wiredInThingEnv then
500 loadHomeInterface doc name `thenRn_`
503 else getNonWiredInDecl name
505 doc = ptext SLIT("need home module for wired in thing") <+> ppr name
507 getNonWiredInDecl :: Name -> RnMG ImportDeclResult
508 getNonWiredInDecl needed_name
509 = traceRn doc_str `thenRn_`
510 loadHomeInterface doc_str needed_name `thenRn` \ ifaces ->
511 case lookupNameEnv (iDecls ifaces) needed_name of
513 {- OMIT DEFERRED STUFF FOR NOW, TILL GHCI WORKS
514 Just (version, avail, is_tycon_name, decl@(_, TyClD (TyData DataType _ _ _ _ ncons _ _ _ _ _)))
515 -- This case deals with deferred import of algebraic data types
517 | not opt_NoPruneTyDecls
519 && (opt_IgnoreIfacePragmas || ncons > 1)
520 -- We only defer if imported interface pragmas are ingored
521 -- or if it's not a product type.
522 -- Sole reason: The wrapper for a strict function may need to look
523 -- inside its arg, and hence need to see its arg type's constructors.
525 && not (getUnique tycon_name `elem` cCallishTyKeys)
526 -- Never defer ccall types; we have to unbox them,
527 -- and importing them does no harm
530 -> -- OK, so we're importing a deferrable data type
531 if needed_name == tycon_name
532 -- The needed_name is the TyCon of a data type decl
533 -- Record that it's slurped, put it in the deferred set
534 -- and don't return a declaration at all
535 setIfacesRn (recordSlurp (ifaces {iDeferred = iDeferred ifaces
536 `addOneToNameSet` tycon_name})
537 version (AvailTC needed_name [needed_name])) `thenRn_`
541 -- The needed name is a constructor of a data type decl,
542 -- getting a constructor, so remove the TyCon from the deferred set
543 -- (if it's there) and return the full declaration
544 setIfacesRn (recordSlurp (ifaces {iDeferred = iDeferred ifaces
545 `delFromNameSet` tycon_name})
546 version avail) `thenRn_`
547 returnRn (HereItIs decl)
549 tycon_name = availName avail
553 -> setIfacesRn (recordSlurp ifaces avail) `thenRn_`
554 returnRn (HereItIs decl)
557 -> addErrRn (getDeclErr needed_name) `thenRn_`
558 returnRn AlreadySlurped
560 doc_str = ptext SLIT("need decl for") <+> ppr needed_name
563 getDeferredDecls :: RnMG [(Module, RdrNameHsDecl)]
565 = getIfacesRn `thenRn` \ ifaces ->
567 decls_map = iDecls ifaces
568 deferred_names = nameSetToList (iDeferred ifaces)
569 get_abstract_decl n = case lookupNameEnv decls_map n of
570 Just (_, _, _, decl) -> decl
572 traceRn (sep [text "getDeferredDecls", nest 4 (fsep (map ppr deferred_names))]) `thenRn_`
573 returnRn (map get_abstract_decl deferred_names)
577 @getWiredInDecl@ maps a wired-in @Name@ to what it makes available.
578 It behaves exactly as if the wired in decl were actually in an interface file.
581 \item if the wired-in name is a data type constructor or a data constructor,
582 it brings in the type constructor and all the data constructors; and
583 marks as ``occurrences'' any free vars of the data con.
585 \item similarly for synonum type constructor
587 \item if the wired-in name is another wired-in Id, it marks as ``occurrences''
588 the free vars of the Id's type.
590 \item it loads the interface file for the wired-in thing for the
591 sole purpose of making sure that its instance declarations are available
593 All this is necessary so that we know all types that are ``in play'', so
594 that we know just what instances to bring into scope.
599 %*********************************************************
601 \subsection{Getting what a module exports}
603 %*********************************************************
605 @getInterfaceExports@ is called only for directly-imported modules.
608 getInterfaceExports :: ModuleName -> WhereFrom -> RnMG (Module, Avails)
609 getInterfaceExports mod_name from
610 = getHomeIfaceTableRn `thenRn` \ hit ->
611 case lookupModuleEnvByName hit mod_name of {
612 Just mi -> returnRn (mi_module mi, mi_exports mi) ;
615 loadInterface doc_str mod_name from `thenRn` \ ifaces ->
616 case lookupModuleEnvByName (iPIT ifaces) mod_name of
617 Just mi -> returnRn (mi_module mi, mi_exports mi) ;
618 -- loadInterface always puts something in the map
619 -- even if it's a fake
620 Nothing -> pprPanic "getInterfaceExports" (ppr mod_name)
623 doc_str = sep [ppr mod_name, ptext SLIT("is directly imported")]
627 %*********************************************************
629 \subsection{Instance declarations are handled specially}
631 %*********************************************************
634 getImportedInstDecls :: NameSet -> RnMG [(Module,RdrNameHsDecl)]
635 getImportedInstDecls gates
636 = -- First, load any orphan-instance modules that aren't aready loaded
637 -- Orphan-instance modules are recorded in the module dependecnies
638 getIfacesRn `thenRn` \ ifaces ->
641 [mod | (mod, (True, _, False)) <- fmToList (iImpModInfo ifaces)]
643 loadOrphanModules orphan_mods `thenRn_`
645 -- Now we're ready to grab the instance declarations
646 -- Find the un-gated ones and return them,
647 -- removing them from the bag kept in Ifaces
648 getIfacesRn `thenRn` \ ifaces ->
650 (decls, new_insts) = selectGated gates (iInsts ifaces)
652 setIfacesRn (ifaces { iInsts = new_insts }) `thenRn_`
654 traceRn (sep [text "getImportedInstDecls:",
655 nest 4 (fsep (map ppr gate_list)),
656 text "Slurped" <+> int (length decls) <+> text "instance declarations",
657 nest 4 (vcat (map ppr_brief_inst_decl decls))]) `thenRn_`
660 gate_list = nameSetToList gates
662 ppr_brief_inst_decl (mod, InstD (InstDecl inst_ty _ _ _ _))
664 HsForAllTy _ _ tau -> ppr tau
667 getImportedRules :: RnMG [(Module,RdrNameHsDecl)]
669 | opt_IgnoreIfacePragmas = returnRn []
671 = getIfacesRn `thenRn` \ ifaces ->
673 gates = iSlurp ifaces -- Anything at all that's been slurped
674 rules = iRules ifaces
675 (decls, new_rules) = selectGated gates rules
680 setIfacesRn (ifaces { iRules = new_rules }) `thenRn_`
681 traceRn (sep [text "getImportedRules:",
682 text "Slurped" <+> int (length decls) <+> text "rules"]) `thenRn_`
685 selectGated gates decl_bag
686 -- Select only those decls whose gates are *all* in 'gates'
688 | opt_NoPruneDecls -- Just to try the effect of not gating at all
689 = (foldrBag (\ (_,d) ds -> d:ds) [] decl_bag, emptyBag) -- Grab them all
693 = foldrBag select ([], emptyBag) decl_bag
695 select (reqd, decl) (yes, no)
696 | isEmptyNameSet (reqd `minusNameSet` gates) = (decl:yes, no)
697 | otherwise = (yes, (reqd,decl) `consBag` no)
699 lookupFixityRn :: Name -> RnMS Fixity
701 | isLocallyDefined name
702 = getFixityEnv `thenRn` \ local_fix_env ->
703 returnRn (lookupLocalFixity local_fix_env name)
705 | otherwise -- Imported
706 -- For imported names, we have to get their fixities by doing a loadHomeInterface,
707 -- and consulting the Ifaces that comes back from that, because the interface
708 -- file for the Name might not have been loaded yet. Why not? Suppose you import module A,
709 -- which exports a function 'f', which is defined in module B. Then B isn't loaded
710 -- right away (after all, it's possible that nothing from B will be used).
711 -- When we come across a use of 'f', we need to know its fixity, and it's then,
712 -- and only then, that we load B.hi. That is what's happening here.
713 = getHomeIfaceTableRn `thenRn` \ hst ->
714 case lookupFixityEnv hst name of {
715 Just fixity -> returnRn fixity ;
718 loadHomeInterface doc name `thenRn` \ ifaces ->
719 returnRn (lookupFixityEnv (iPIT ifaces) name `orElse` defaultFixity)
722 doc = ptext SLIT("Checking fixity for") <+> ppr name
726 %*********************************************************
728 \subsection{Keeping track of what we've slurped, and version numbers}
730 %*********************************************************
732 getImportVersions figures out what the ``usage information'' for this
733 moudule is; that is, what it must record in its interface file as the
734 things it uses. It records:
737 \item (a) anything reachable from its body code
738 \item (b) any module exported with a @module Foo@
739 \item (c) anything reachable from an exported item
742 Why (b)? Because if @Foo@ changes then this module's export list
743 will change, so we must recompile this module at least as far as
744 making a new interface file --- but in practice that means complete
747 Why (c)? Consider this:
749 module A( f, g ) where | module B( f ) where
750 import B( f ) | f = h 3
754 Here, @B.f@ isn't used in A. Should we nevertheless record @B.f@ in
755 @A@'s usages? Our idea is that we aren't going to touch A.hi if it is
756 *identical* to what it was before. If anything about @B.f@ changes
757 than anyone who imports @A@ should be recompiled in case they use
758 @B.f@ (they'll get an early exit if they don't). So, if anything
759 about @B.f@ changes we'd better make sure that something in A.hi
760 changes, and the convenient way to do that is to record the version
761 number @B.f@ in A.hi in the usage list. If B.f changes that'll force a
762 complete recompiation of A, which is overkill but it's the only way to
763 write a new, slightly different, A.hi.
765 But the example is tricker. Even if @B.f@ doesn't change at all,
766 @B.h@ may do so, and this change may not be reflected in @f@'s version
767 number. But with -O, a module that imports A must be recompiled if
768 @B.h@ changes! So A must record a dependency on @B.h@. So we treat
769 the occurrence of @B.f@ in the export list *just as if* it were in the
770 code of A, and thereby haul in all the stuff reachable from it.
772 [NB: If B was compiled with -O, but A isn't, we should really *still*
773 haul in all the unfoldings for B, in case the module that imports A *is*
774 compiled with -O. I think this is the case.]
776 Even if B is used at all we get a usage line for B
777 import B <n> :: ... ;
778 in A.hi, to record the fact that A does import B. This is used to decide
779 to look to look for B.hi rather than B.hi-boot when compiling a module that
780 imports A. This line says that A imports B, but uses nothing in it.
781 So we'll get an early bale-out when compiling A if B's version changes.
784 mkImportExportInfo :: ModuleName -- Name of this module
785 -> Avails -- Info about exports
786 -> [ImportDecl n] -- The import decls
787 -> RnMG ([ExportItem], -- Export info for iface file; sorted
788 [ImportVersion Name]) -- Import info for iface file; sorted
789 -- Both results are sorted into canonical order to
790 -- reduce needless wobbling of interface files
792 mkImportExportInfo this_mod export_avails exports
793 = getIfacesRn `thenRn` \ ifaces ->
795 import_all_mods :: [ModuleName]
796 -- Modules where we imported all the names
797 -- (apart from hiding some, perhaps)
798 import_all_mods = nub [ m | ImportDecl m _ _ _ imp_list _ <- imports ]
800 import_all (Just (False, _)) = False -- Imports are specified explicitly
801 import_all other = True -- Everything is imported
803 mod_map = iImpModInfo ifaces
804 imp_names = iVSlurp ifaces
806 -- mv_map groups together all the things imported from a particular module.
807 mv_map :: ModuleEnv [Name]
808 mv_map = foldr add_mv emptyFM imp_names
810 add_mv (name, version) mv_map = addItem mv_map (nameModule name) name
812 -- Build the result list by adding info for each module.
813 -- For (a) a library module, we don't record it at all unless it contains orphans
814 -- (We must never lose track of orphans.)
816 -- (b) a source-imported module, don't record the dependency at all
818 -- (b) may seem a bit strange. The idea is that the usages in a .hi file records
819 -- *all* the module's dependencies other than the loop-breakers. We use
820 -- this info in findAndReadInterface to decide whether to look for a .hi file or
823 -- This means we won't track version changes, or orphans, from .hi-boot files.
824 -- The former is potentially rather bad news. It could be fixed by recording
825 -- whether something is a boot file along with the usage info for it, but
826 -- I can't be bothered just now.
828 mk_imp_info mod_name (has_orphans, is_boot, opened) so_far
829 | mod_name == this_mod -- Check if M appears in the set of modules 'below' M
830 -- This seems like a convenient place to check
831 = WARN( not is_boot, ptext SLIT("Wierd:") <+> ppr this_mod <+>
832 ptext SLIT("imports itself (perhaps indirectly)") )
835 | not opened -- We didn't even open the interface
836 -> -- This happens when a module, Foo, that we explicitly imported has
837 -- 'import Baz' in its interface file, recording that Baz is below
838 -- Foo in the module dependency hierarchy. We want to propagate this
839 -- information. The Nothing says that we didn't even open the interface
840 -- file but we must still propagate the dependeny info.
841 -- The module in question must be a local module (in the same package)
842 go_for_it NothingAtAll
845 | is_lib_module && not has_orphans
848 | is_lib_module -- Record the module version only
849 -> go_for_it (Everything mod_vers)
852 -> go_for_it (mk_whats_imported mod mod_vers)
857 go_for_it exports = (mod_name, has_orphans, is_boot, exports) : so_far
858 mod_iface = lookupIface hit pit mod_name
859 mod = mi_module mod_iface
860 is_lib_module = not (isModuleInThisPackage mod)
861 version_info = mi_version mod_iface
862 version_env = vers_decls version_info
864 whats_imported = Specifically mod_vers export_vers import_items
865 (vers_rules version_info)
867 import_items = [(n,v) | n <- lookupWithDefaultModuleEnv mv_map [] mod,
868 let v = lookupNameEnv version_env `orElse`
869 pprPanic "mk_whats_imported" (ppr n)
871 export_vers | moduleName mod `elem` import_all_mods = Just (vers_exports version_info)
872 | otherwise = Nothing
874 import_info = foldFM mk_imp_info [] mod_map
876 -- Sort exports into groups by module
877 export_fm :: FiniteMap Module [RdrAvailInfo]
878 export_fm = foldr insert emptyFM export_avails
880 insert avail efm = addItem efm (nameModule (availName avail))
883 export_info = fmToList export_fm
885 traceRn (text "Modules in Ifaces: " <+> fsep (map ppr (keysFM mod_map))) `thenRn_`
886 returnRn (export_info, import_info)
889 addItem :: ModuleEnv [a] -> Module -> a -> ModuleEnv [a]
890 addItem fm mod x = plusModuleEnv_C add_item fm mod [x]
897 = getIfacesRn `thenRn` \ ifaces ->
898 returnRn (iSlurp ifaces)
900 recordSlurp ifaces@(Ifaces { iSlurp = slurped_names, iVSlurp = imp_names })
903 new_slurped_names = addAvailToNameSet slurped_names avail
904 new_imp_names = availName avail : imp_names
906 ifaces { iSlurp = new_slurped_names, iVSlurp = new_imp_names }
908 recordLocalSlurps local_avails
909 = getIfacesRn `thenRn` \ ifaces ->
911 new_slurped_names = foldl addAvailToNameSet (iSlurp ifaces) local_avails
913 setIfacesRn (ifaces { iSlurp = new_slurped_names })
917 %*********************************************************
919 \subsection{Getting binders out of a declaration}
921 %*********************************************************
923 @getDeclBinders@ returns the names for a @RdrNameHsDecl@.
924 It's used for both source code (from @availsFromDecl@) and interface files
927 It doesn't deal with source-code specific things: @ValD@, @DefD@. They
928 are handled by the sourc-code specific stuff in @RnNames@.
931 getDeclBinders :: (RdrName -> SrcLoc -> RnM d Name) -- New-name function
933 -> RnM d (Maybe AvailInfo)
935 getDeclBinders new_name (TyClD (TyData _ _ tycon _ condecls _ _ _ src_loc _ _))
936 = new_name tycon src_loc `thenRn` \ tycon_name ->
937 getConFieldNames new_name condecls `thenRn` \ sub_names ->
938 returnRn (Just (AvailTC tycon_name (tycon_name : nub sub_names)))
939 -- The "nub" is because getConFieldNames can legitimately return duplicates,
940 -- when a record declaration has the same field in multiple constructors
942 getDeclBinders new_name (TyClD (TySynonym tycon _ _ src_loc))
943 = new_name tycon src_loc `thenRn` \ tycon_name ->
944 returnRn (Just (AvailTC tycon_name [tycon_name]))
946 getDeclBinders new_name (TyClD (ClassDecl _ cname _ _ sigs _ _ _ src_loc))
947 = new_name cname src_loc `thenRn` \ class_name ->
949 -- Record the names for the class ops
951 -- just want class-op sigs
952 op_sigs = filter isClassOpSig sigs
954 mapRn (getClassOpNames new_name) op_sigs `thenRn` \ sub_names ->
956 returnRn (Just (AvailTC class_name (class_name : sub_names)))
958 getDeclBinders new_name (SigD (IfaceSig var ty prags src_loc))
959 = new_name var src_loc `thenRn` \ var_name ->
960 returnRn (Just (Avail var_name))
962 getDeclBinders new_name (FixD _) = returnRn Nothing
963 getDeclBinders new_name (DeprecD _) = returnRn Nothing
965 -- foreign declarations
966 getDeclBinders new_name (ForD (ForeignDecl nm kind _ dyn _ loc))
967 | binds_haskell_name kind dyn
968 = new_name nm loc `thenRn` \ name ->
969 returnRn (Just (Avail name))
971 | otherwise -- a foreign export
972 = lookupOrigName nm `thenRn_`
975 getDeclBinders new_name (DefD _) = returnRn Nothing
976 getDeclBinders new_name (InstD _) = returnRn Nothing
977 getDeclBinders new_name (RuleD _) = returnRn Nothing
979 binds_haskell_name (FoImport _) _ = True
980 binds_haskell_name FoLabel _ = True
981 binds_haskell_name FoExport ext_nm = isDynamicExtName ext_nm
984 getConFieldNames new_name (ConDecl con _ _ _ (RecCon fielddecls) src_loc : rest)
985 = mapRn (\n -> new_name n src_loc) (con:fields) `thenRn` \ cfs ->
986 getConFieldNames new_name rest `thenRn` \ ns ->
989 fields = concat (map fst fielddecls)
991 getConFieldNames new_name (ConDecl con _ _ _ condecl src_loc : rest)
992 = new_name con src_loc `thenRn` \ n ->
993 getConFieldNames new_name rest `thenRn` \ ns ->
996 getConFieldNames new_name [] = returnRn []
998 getClassOpNames new_name (ClassOpSig op _ _ src_loc) = new_name op src_loc
1001 @getDeclSysBinders@ gets the implicit binders introduced by a decl.
1002 A the moment that's just the tycon and datacon that come with a class decl.
1003 They aren't returned by @getDeclBinders@ because they aren't in scope;
1004 but they {\em should} be put into the @DeclsMap@ of this module.
1006 Note that this excludes the default-method names of a class decl,
1007 and the dict fun of an instance decl, because both of these have
1008 bindings of their own elsewhere.
1011 getDeclSysBinders new_name (TyClD (ClassDecl _ cname _ _ sigs _ _ names
1013 = sequenceRn [new_name n src_loc | n <- names]
1015 getDeclSysBinders new_name (TyClD (TyData _ _ _ _ cons _ _ _ _ _ _))
1016 = sequenceRn [new_name wkr_name src_loc | ConDecl _ wkr_name _ _ _ src_loc <- cons]
1018 getDeclSysBinders new_name other_decl
1022 %*********************************************************
1024 \subsection{Reading an interface file}
1026 %*********************************************************
1029 findAndReadIface :: SDoc -> ModuleName
1030 -> IsBootInterface -- True <=> Look for a .hi-boot file
1031 -- False <=> Look for .hi file
1032 -> RnM d (Either Message (Module, ParsedIface))
1033 -- Nothing <=> file not found, or unreadable, or illegible
1034 -- Just x <=> successfully found and parsed
1036 findAndReadIface doc_str mod_name hi_boot_file
1037 = traceRn trace_msg `thenRn_`
1038 -- we keep two maps for interface files,
1039 -- one for 'normal' ones, the other for .hi-boot files,
1040 -- hence the need to signal which kind we're interested.
1042 getFinderRn `thenRn` \ finder ->
1043 ioToRnM (finder mod_name) `thenRn` \ maybe_found ->
1047 | hi_boot_file -> readIface mod (hi_file locn ++ "-hi-boot")
1048 | otherwise -> readIface mod (hi_file locn)
1051 other -> traceRn (ptext SLIT("...not found")) `thenRn_`
1052 returnRn (Left (noIfaceErr mod_name hi_boot_file))
1055 trace_msg = sep [hsep [ptext SLIT("Reading"),
1056 if hi_boot_file then ptext SLIT("[boot]") else empty,
1057 ptext SLIT("interface for"),
1058 ppr mod_name <> semi],
1059 nest 4 (ptext SLIT("reason:") <+> doc_str)]
1062 @readIface@ tries just the one file.
1065 readIface :: Module -> String -> RnM d (Either Message (Module, ParsedIface))
1066 -- Nothing <=> file not found, or unreadable, or illegible
1067 -- Just x <=> successfully found and parsed
1068 readIface wanted_mod file_path
1069 = traceRn (ptext SLIT("...reading from") <+> text file_path) `thenRn_`
1070 ioToRnM (hGetStringBuffer False file_path) `thenRn` \ read_result ->
1073 case parseIface contents
1074 PState{ bol = 0#, atbol = 1#,
1077 loc = mkSrcLoc (mkFastString file_path) 1 } of
1078 POk _ (PIface iface) ->
1079 warnCheckRn (wanted_mod == read_mod)
1080 (hiModuleNameMismatchWarn wanted_mod read_mod) `thenRn_`
1081 returnRn (Right (wanted_mod, iface))
1083 read_mod = pi_mod iface
1085 PFailed err -> bale_out err
1086 parse_result -> bale_out empty
1087 -- This last case can happen if the interface file is (say) empty
1088 -- in which case the parser thinks it looks like an IdInfo or
1089 -- something like that. Just an artefact of the fact that the
1090 -- parser is used for several purposes at once.
1092 Left io_err -> bale_out (text (show io_err))
1094 bale_out err = returnRn (Left (badIfaceFile file_path err))
1097 %*********************************************************
1101 %*********************************************************
1104 noIfaceErr mod_name boot_file
1105 = ptext SLIT("Could not find interface file for") <+> quotes (ppr mod_name)
1106 -- We used to print the search path, but we can't do that
1107 -- now, becuase it's hidden inside the finder.
1108 -- Maybe the finder should expose more functions.
1110 badIfaceFile file err
1111 = vcat [ptext SLIT("Bad interface file:") <+> text file,
1115 = vcat [ptext SLIT("Failed to find interface decl for") <+> quotes (ppr name),
1116 ptext SLIT("from module") <+> quotes (ppr (nameModule name))
1121 "Compiler tried to import decl from interface file with same name as module."),
1123 "(possible cause: module name clashes with interface file already in scope.)")
1125 hsep [ptext SLIT("name:"), quotes (ppr name)]
1127 warnRedundantSourceImport mod_name
1128 = ptext SLIT("Unnecessary {- SOURCE -} in the import of module")
1129 <+> quotes (ppr mod_name)
1131 hiModuleNameMismatchWarn :: Module -> ModuleName -> Message
1132 hiModuleNameMismatchWarn requested_mod read_mod =
1133 hsep [ ptext SLIT("Something is amiss; requested module name")
1134 , ppr (moduleName requested_mod)
1135 , ptext SLIT("differs from name found in the interface file")