2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 \section[RnIfaces]{Cacheing and Renaming of Interfaces}
13 getInterfaceExports, getDeferredDecls,
14 getImportedInstDecls, getImportedRules,
15 lookupFixityRn, loadHomeInterface,
16 importDecl, ImportDeclResult(..), recordLocalSlurps, loadBuiltinRules,
17 mkImportExportInfo, getSlurped,
19 checkModUsage, outOfDate, upToDate,
21 getDeclBinders, getDeclSysBinders,
22 removeContext -- removeContext probably belongs somewhere else
26 #include "HsVersions.h"
28 import CmdLineOpts ( opt_NoPruneDecls, opt_NoPruneTyDecls, opt_IgnoreIfacePragmas )
29 import HsSyn ( HsDecl(..), TyClDecl(..), InstDecl(..), IfaceSig(..),
30 HsType(..), ConDecl(..), IE(..), ConDetails(..), Sig(..),
31 ForeignDecl(..), ForKind(..), isDynamicExtName,
32 FixitySig(..), RuleDecl(..),
33 isClassOpSig, DeprecDecl(..)
35 import HsImpExp ( ieNames )
36 import CoreSyn ( CoreRule )
37 import BasicTypes ( Version, NewOrData(..) )
38 import RdrHsSyn ( RdrNameHsDecl, RdrNameInstDecl, RdrNameRuleDecl,
39 RdrNameDeprecation, RdrNameIE,
44 import ParseIface ( parseIface, IfaceStuff(..) )
46 import Name ( Name {-instance NamedThing-}, nameOccName,
47 nameModule, isLocallyDefined,
48 {-isWiredInName, -} NamedThing(..),
49 elemNameEnv, extendNameEnv
51 import Module ( Module, mkVanillaModule,
52 moduleName, isModuleInThisPackage,
53 ModuleName, WhereFrom(..),
55 import RdrName ( RdrName, rdrNameOcc )
57 import SrcLoc ( mkSrcLoc, SrcLoc )
58 import PrelInfo ( cCallishTyKeys )
59 import Maybes ( maybeToBool )
60 import Unique ( Uniquable(..) )
61 import StringBuffer ( hGetStringBuffer )
62 import FastString ( mkFastString )
63 import ErrUtils ( Message )
64 import Util ( sortLt )
74 import Panic ( panic )
75 lookupFixityRn = panic "lookupFixityRn"
80 %*********************************************************
82 \subsection{Loading a new interface file}
84 %*********************************************************
87 loadHomeInterface :: SDoc -> Name -> RnM d Ifaces
88 loadHomeInterface doc_str name
89 = loadInterface doc_str (moduleName (nameModule name)) ImportBySystem
91 loadOrphanModules :: [ModuleName] -> RnM d ()
92 loadOrphanModules mods
93 | null mods = returnRn ()
94 | otherwise = traceRn (text "Loading orphan modules:" <+>
95 fsep (map mods)) `thenRn_`
96 mapRn_ load mods `thenRn_`
99 load mod = loadInterface (mk_doc mod) mod ImportBySystem
100 mk_doc mod = ppr mod <+> ptext SLIT("is a orphan-instance module")
103 loadInterface :: SDoc -> ModuleName -> WhereFrom -> RnM d Ifaces
104 loadInterface doc mod from
105 = tryLoadInterface doc mod from `thenRn` \ (ifaces, maybe_err) ->
107 Nothing -> returnRn ifaces
108 Just err -> failWithRn ifaces err
110 tryLoadInterface :: SDoc -> ModuleName -> WhereFrom -> RnM d (Ifaces, Maybe Message)
111 -- Returns (Just err) if an error happened
112 -- Guarantees to return with iImpModInfo m --> (... Just cts)
113 -- (If the load fails, we plug in a vanilla placeholder
114 tryLoadInterface doc_str mod_name from
115 = getIfacesRn `thenRn` \ ifaces ->
117 mod_map = iImpModInfo ifaces
118 mod_info = lookupFM mod_map mod_name
121 = case (from, mod_info) of
122 (ImportByUser, _) -> False -- Not hi-boot
123 (ImportByUserSource, _) -> True -- hi-boot
124 (ImportBySystem, Just (_, is_boot, _)) -> is_boot --
125 (ImportBySystem, Nothing) -> False
126 -- We're importing a module we know absolutely
127 -- nothing about, so we assume it's from
128 -- another package, where we aren't doing
129 -- dependency tracking. So it won't be a hi-boot file.
131 redundant_source_import
132 = case (from, mod_info) of
133 (ImportByUserSource, Just (_,False,_)) -> True
136 -- CHECK WHETHER WE HAVE IT ALREADY
139 -> -- We're read it already so don't re-read it
140 returnRn (ifaces, Nothing) ;
144 -- Issue a warning for a redundant {- SOURCE -} import
145 -- NB that we arrange to read all the ordinary imports before
146 -- any of the {- SOURCE -} imports
147 warnCheckRn (not redundant_source_import)
148 (warnRedundantSourceImport mod_name) `thenRn_`
150 -- READ THE MODULE IN
151 findAndReadIface doc_str mod_name hi_boot_file `thenRn` \ read_resultb ->
152 case read_result of {
153 Left err -> -- Not found, so add an empty export env to the Ifaces map
154 -- so that we don't look again
156 new_mod_map = addToFM mod_map mod_name (False, False, True)
157 new_ifaces = ifaces { iImpModInfo = new_mod_map }
159 setIfacesRn new_ifaces `thenRn_`
160 returnRn (new_ifaces, Just err) ;
163 Right (mod, iface) ->
165 -- LOAD IT INTO Ifaces
167 -- NB: *first* we do loadDecl, so that the provenance of all the locally-defined
168 --- names is done correctly (notably, whether this is an .hi file or .hi-boot file).
169 -- If we do loadExport first the wrong info gets into the cache (unless we
170 -- explicitly tag each export which seems a bit of a bore)
173 -- Sanity check. If we're system-importing a module we know nothing at all
174 -- about, it should be from a different package to this one
175 WARN( not (maybeToBool mod_info) &&
176 case from of { ImportBySystem -> True; other -> False } &&
177 isModuleInThisPackage mod,
180 loadDecls mod (iDecls ifaces) (pi_decls iface) `thenRn` \ (decls_vers, new_decls) ->
181 loadRules mod (iRules ifaces) (pi_rules iface) `thenRn` \ (rule_vers, new_rules) ->
182 loadFixDecls mod_name (pi_fixity iface) `thenRn` \ (fix_vers, fix_env) ->
183 foldlRn (loadDeprec mod) emptyDeprecEnv (pi_deprecs iface) `thenRn` \ deprec_env ->
184 foldlRn (loadInstDecl mod) (iInsts ifaces) (pi_insts iface) `thenRn` \ new_insts ->
185 loadExports (pi_exports iface) `thenRn` \ avails ->
187 version = VersionInfo { modVers = pi_vers iface,
189 ruleVers = rule_vers,
190 declVers = decl_vers }
192 -- For an explicit user import, add to mod_map info about
193 -- the things the imported module depends on, extracted
194 -- from its usage info.
195 mod_map1 = case from of
196 ImportByUser -> addModDeps mod (pi_usages iface) mod_map
198 mod_map2 = addToFM mod_map1 mod_name (pi_orphan iface, hi_boot_file, True)
200 -- Now add info about this module to the PST
201 new_pst = extendModuleEnv pst mod mod_detils
202 mod_details = ModDetails { mdModule = mod, mvVersion = version,
204 mdFixEnv = fix_env, mdDeprecEnv = deprec_env }
206 new_ifaces = ifaces { iPST = new_pst,
210 iImpModInfo = mod_map2 }
212 setIfacesRn new_ifaces `thenRn_`
213 returnRn (new_ifaces, Nothing)
216 -----------------------------------------------------
217 -- Adding module dependencies from the
218 -- import decls in the interface file
219 -----------------------------------------------------
221 addModDeps :: Module -> PackageSymbolTable -> [ImportVersion a]
222 -> ImportedModuleInfo -> ImportedModuleInfo
223 -- (addModDeps M ivs deps)
224 -- We are importing module M, and M.hi contains 'import' decls given by ivs
225 addModDeps mod new_deps mod_deps
226 = foldr add mod_deps filtered_new_deps
228 -- Don't record dependencies when importing a module from another package
229 -- Except for its descendents which contain orphans,
230 -- and in that case, forget about the boot indicator
231 filtered_new_deps :: (ModuleName, (WhetherHasOrphans, IsBootInterface))
233 | isModuleInThisPackage mod
234 = [ (imp_mod, (has_orphans, is_boot, False))
235 | (imp_mod, has_orphans, is_boot, _) <- new_deps
237 | otherwise = [ (imp_mod, (True, False, False))
238 | (imp_mod, has_orphans, _, _) <- new_deps,
241 add (imp_mod, dep) deps = addToFM_C combine deps imp_mod dep
243 combine old@(_, old_is_boot, old_is_loaded) new
244 | old_is_loaded || not old_is_boot = old -- Keep the old info if it's already loaded
245 -- or if it's a non-boot pending load
246 | otherwise = new -- Otherwise pick new info
249 -----------------------------------------------------
250 -- Loading the export list
251 -----------------------------------------------------
253 loadExports :: [ExportItem] -> RnM d Avails
255 = getModuleRn `thenRn` \ this_mod ->
256 mapRn (loadExport this_mod) items `thenRn` \ avails_s ->
257 returnRn (concat avails_s)
260 loadExport :: Module -> ExportItem -> RnM d [AvailInfo]
261 loadExport this_mod (mod, entities)
262 | mod == moduleName this_mod = returnRn []
263 -- If the module exports anything defined in this module, just ignore it.
264 -- Reason: otherwise it looks as if there are two local definition sites
265 -- for the thing, and an error gets reported. Easiest thing is just to
266 -- filter them out up front. This situation only arises if a module
267 -- imports itself, or another module that imported it. (Necessarily,
268 -- this invoves a loop.) Consequence: if you say
273 -- module B( AType ) where
274 -- import {-# SOURCE #-} A( AType )
276 -- then you'll get a 'B does not export AType' message. A bit bogus
277 -- but it's a bogus thing to do!
280 = mapRn (load_entity mod) entities
282 new_name mod occ = newGlobalName mod occ
284 load_entity mod (Avail occ)
285 = new_name mod occ `thenRn` \ name ->
286 returnRn (Avail name)
287 load_entity mod (AvailTC occ occs)
288 = new_name mod occ `thenRn` \ name ->
289 mapRn (new_name mod) occs `thenRn` \ names ->
290 returnRn (AvailTC name names)
293 -----------------------------------------------------
294 -- Loading type/class/value decls
295 -----------------------------------------------------
299 -> [(Version, RdrNameHsDecl)]
300 -> RnM d (NameEnv Version, DeclsMap)
301 loadDecls mod decls_map decls
302 = foldlRn (loadDecl mod) (emptyNameEnv, decls_map) decls
305 -> (NameEnv Version, DeclsMap)
306 -> (Version, RdrNameHsDecl)
307 -> RnM d (NameEnv Version, DeclsMap)
308 loadDecl mod (version_map, decls_map) (version, decl)
309 = getDeclBinders new_name decl `thenRn` \ maybe_avail ->
310 case maybe_avail of {
311 Nothing -> returnRn (version_map, decls_map); -- No bindings
314 getDeclSysBinders new_name decl `thenRn` \ sys_bndrs ->
316 full_avail = addSysAvails avail sys_bndrs
317 -- Add the sys-binders to avail. When we import the decl,
318 -- it's full_avail that will get added to the 'already-slurped' set (iSlurp)
319 -- If we miss out sys-binders, we'll read the decl multiple times!
321 main_name = availName avail
322 new_decls_map = foldl add_decl decls_map
323 [ (name, (full_avail, name==main_name, (mod, decl')))
324 | name <- availNames full_avail]
325 add_decl decls_map (name, stuff)
326 = WARN( name `elemNameEnv` decls_map, ppr name )
327 extendNameEnv decls_map name stuff
329 new_version_map = extendNameEnv version_map main_name version
331 returnRn (new_version_map, new_decls_map)
334 -- newTopBinder puts into the cache the binder with the
335 -- module information set correctly. When the decl is later renamed,
336 -- the binding site will thereby get the correct module.
337 -- There maybe occurrences that don't have the correct Module, but
338 -- by the typechecker will propagate the binding definition to all
339 -- the occurrences, so that doesn't matter
340 new_name rdr_name loc = newTopBinder mod rdr_name loc
343 If a signature decl is being loaded, and optIgnoreIfacePragmas is on,
344 we toss away unfolding information.
346 Also, if the signature is loaded from a module we're importing from source,
347 we do the same. This is to avoid situations when compiling a pair of mutually
348 recursive modules, peering at unfolding info in the interface file of the other,
349 e.g., you compile A, it looks at B's interface file and may as a result change
350 its interface file. Hence, B is recompiled, maybe changing its interface file,
351 which will the unfolding info used in A to become invalid. Simple way out is to
352 just ignore unfolding info.
354 [Jan 99: I junked the second test above. If we're importing from an hi-boot
355 file there isn't going to *be* any pragma info. Maybe the above comment
356 dates from a time where we picked up a .hi file first if it existed?]
359 SigD (IfaceSig name tp ls loc) | opt_IgnoreIfacePragmas
360 -> SigD (IfaceSig name tp [] loc)
363 -----------------------------------------------------
364 -- Loading fixity decls
365 -----------------------------------------------------
367 loadFixDecls mod_name (version, decls)
368 | null decls = returnRn (version, emptyNameEnv)
371 = mapRn (loadFixDecl mod_name) decls `thenRn` \ to_add ->
372 returnRn (version, mkNameEnv to_add)
374 loadFixDecl mod_name sig@(FixitySig rdr_name fixity loc)
375 = newGlobalName mod_name (rdrNameOcc rdr_name) `thenRn` \ name ->
376 returnRn (name, FixitySig name fixity loc)
379 -----------------------------------------------------
380 -- Loading instance decls
381 -----------------------------------------------------
383 loadInstDecl :: Module
387 loadInstDecl mod insts decl@(InstDecl inst_ty binds uprags dfun_name src_loc)
389 -- Find out what type constructors and classes are "gates" for the
390 -- instance declaration. If all these "gates" are slurped in then
391 -- we should slurp the instance decl too.
393 -- We *don't* want to count names in the context part as gates, though.
395 -- instance Foo a => Baz (T a) where ...
397 -- Here the gates are Baz and T, but *not* Foo.
399 munged_inst_ty = removeContext inst_ty
400 free_names = extractHsTyRdrNames munged_inst_ty
403 mapRn lookupOrigName free_names `thenRn` \ gate_names ->
404 returnRn ((mkNameSet gate_names, (mod, InstD decl)) `consBag` insts)
407 -- In interface files, the instance decls now look like
408 -- forall a. Foo a -> Baz (T a)
409 -- so we have to strip off function argument types as well
410 -- as the bit before the '=>' (which is always empty in interface files)
411 removeContext (HsForAllTy tvs cxt ty) = HsForAllTy tvs [] (removeFuns ty)
412 removeContext ty = removeFuns ty
414 removeFuns (HsFunTy _ ty) = removeFuns ty
418 -----------------------------------------------------
420 -----------------------------------------------------
422 loadRules :: Module -> IfaceRules
423 -> (Version, [RdrNameRuleDecl])
424 -> RnM d (Version, IfaceRules)
425 loadRules mod rule_bag (version, rules)
426 | null rules || opt_IgnoreIfacePragmas
427 = returnRn (version, rule_bag)
430 mapRn (loadRule mod) rules `thenRn` \ new_rules ->
431 returnRn (version, rule_bag `unionBags` listToBag new_rules)
433 loadRule :: Module -> RdrNameRuleDecl -> RnM d GatedDecl
434 -- "Gate" the rule simply by whether the rule variable is
435 -- needed. We can refine this later.
436 loadRule mod decl@(IfaceRule _ _ var _ _ src_loc)
437 = lookupOrigName var `thenRn` \ var_name ->
438 returnRn (unitNameSet var_name, (mod, RuleD decl))
440 loadBuiltinRules :: [(RdrName, CoreRule)] -> RnMG ()
441 loadBuiltinRules builtin_rules
442 = getIfacesRn `thenRn` \ ifaces ->
443 mapRn loadBuiltinRule builtin_rules `thenRn` \ rule_decls ->
444 setIfacesRn (ifaces { iRules = iRules ifaces `unionBags` listToBag rule_decls })
446 loadBuiltinRule (var, rule)
447 = lookupOrigName var `thenRn` \ var_name ->
448 returnRn (unitNameSet var_name, (nameModule var_name, RuleD (IfaceRuleOut var rule)))
451 -----------------------------------------------------
452 -- Loading Deprecations
453 -----------------------------------------------------
455 loadDeprec :: Module -> DeprecationEnv -> RdrNameDeprecation -> RnM d DeprecationEnv
456 loadDeprec mod deprec_env (Deprecation (IEModuleContents _) txt _)
457 = traceRn (text "module deprecation not yet implemented:" <+> ppr mod <> colon <+> ppr txt) `thenRn_`
458 -- SUP: TEMPORARY HACK, ignoring module deprecations for now
461 loadDeprec mod deprec_env (Deprecation ie txt _)
463 mapRn lookupOrigName (ieNames ie) `thenRn` \ names ->
464 traceRn (text "loaded deprecation(s) for" <+> hcat (punctuate comma (map ppr names)) <> colon <+> ppr txt) `thenRn_`
465 returnRn (extendNameEnvList deprec_env (zip names (repeat txt)))
469 %********************************************************
471 \subsection{Checking usage information}
473 %********************************************************
479 checkModUsage :: [ImportVersion OccName] -> RnMG Bool
480 -- Given the usage information extracted from the old
481 -- M.hi file for the module being compiled, figure out
482 -- whether M needs to be recompiled.
484 checkModUsage [] = returnRn upToDate -- Yes! Everything is up to date!
486 checkModUsage ((mod_name, _, _, NothingAtAll) : rest)
487 -- If CurrentModule.hi contains
489 -- then that simply records that Foo lies below CurrentModule in the
490 -- hierarchy, but CurrentModule doesn't depend in any way on Foo.
491 -- In this case we don't even want to open Foo's interface.
492 = traceRn (ptext SLIT("Nothing used from:") <+> ppr mod_name) `thenRn_`
493 checkModUsage rest -- This one's ok, so check the rest
495 checkModUsage ((mod_name, _, _, whats_imported) : rest)
496 = tryLoadInterface doc_str mod_name ImportBySystem `thenRn` \ (ifaces, maybe_err) ->
498 Just err -> out_of_date (sep [ptext SLIT("Can't find version number for module"),
500 -- Couldn't find or parse a module mentioned in the
501 -- old interface file. Don't complain -- it might just be that
502 -- the current module doesn't need that import and it's been deleted
506 (_, new_mod_vers, new_fix_vers, new_rule_vers, _, _)
507 = case lookupFM (iImpModInfo ifaces) mod_name of
508 Just (_, _, Just stuff) -> stuff
510 old_mod_vers = case whats_imported of
512 Specifically v _ _ _ -> v
513 -- NothingAtAll case dealt with by previous eqn for checkModUsage
515 -- If the module version hasn't changed, just move on
516 if new_mod_vers == old_mod_vers then
517 traceRn (sep [ptext SLIT("Module version unchanged:"), ppr mod_name])
518 `thenRn_` checkModUsage rest
520 traceRn (sep [ptext SLIT("Module version has changed:"), ppr mod_name])
522 -- Module version changed, so check entities inside
524 -- If the usage info wants to say "I imported everything from this module"
525 -- it does so by making whats_imported equal to Everything
526 -- In that case, we must recompile
527 case whats_imported of { -- NothingAtAll dealt with earlier
530 -> out_of_date (ptext SLIT("...and I needed the whole module")) ;
532 Specifically _ old_fix_vers old_rule_vers old_local_vers ->
534 if old_fix_vers /= new_fix_vers then
535 out_of_date (ptext SLIT("Fixities changed"))
536 else if old_rule_vers /= new_rule_vers then
537 out_of_date (ptext SLIT("Rules changed"))
539 -- Non-empty usage list, so check item by item
540 checkEntityUsage mod_name (iDecls ifaces) old_local_vers `thenRn` \ up_to_date ->
542 traceRn (ptext SLIT("...but the bits I use haven't.")) `thenRn_`
543 checkModUsage rest -- This one's ok, so check the rest
545 returnRn outOfDate -- This one failed, so just bail out now
548 doc_str = sep [ptext SLIT("need version info for"), ppr mod_name]
551 checkEntityUsage mod decls []
552 = returnRn upToDate -- Yes! All up to date!
554 checkEntityUsage mod decls ((occ_name,old_vers) : rest)
555 = newGlobalName mod occ_name `thenRn` \ name ->
556 case lookupNameEnv decls name of
558 Nothing -> -- We used it before, but it ain't there now
559 out_of_date (sep [ptext SLIT("No longer exported:"), ppr name])
561 Just (new_vers,_,_,_) -- It's there, but is it up to date?
562 | new_vers == old_vers
563 -- Up to date, so check the rest
564 -> checkEntityUsage mod decls rest
567 -- Out of date, so bale out
568 -> out_of_date (sep [ptext SLIT("Out of date:"), ppr name])
570 out_of_date msg = traceRn msg `thenRn_` returnRn outOfDate
574 %*********************************************************
576 \subsection{Getting in a declaration}
578 %*********************************************************
581 importDecl :: Name -> RnMG ImportDeclResult
583 data ImportDeclResult
587 | HereItIs (Module, RdrNameHsDecl)
590 = getIfacesRn `thenRn` \ ifaces ->
591 getHomeSymbolTableRn `thenRn` \ hst ->
592 if name `elemNameSet` iSlurp ifaces
593 || inTypeEnv (iPST ifaces) name
594 || inTypeEnv hst name
595 then -- Already dealt with
596 returnRn AlreadySlurped
598 else if isLocallyDefined name then -- Don't bring in decls from
599 -- the renamed module's own interface file
600 addWarnRn (importDeclWarn name) `thenRn_`
601 returnRn AlreadySlurped
603 else if isWiredInName name then
604 -- When we find a wired-in name we must load its
605 -- home module so that we find any instance decls therein
606 loadHomeInterface doc name `thenRn_`
609 else getNonWiredInDecl name
611 doc = ptext SLIT("need home module for wired in thing") <+> ppr name
613 getNonWiredInDecl :: Name -> RnMG ImportDeclResult
614 getNonWiredInDecl needed_name
615 = traceRn doc_str `thenRn_`
616 loadHomeInterface doc_str needed_name `thenRn` \ ifaces ->
617 case lookupNameEnv (iDecls ifaces) needed_name of
619 Just (version, avail, is_tycon_name, decl@(_, TyClD (TyData DataType _ _ _ _ ncons _ _ _ _ _)))
620 -- This case deals with deferred import of algebraic data types
622 | not opt_NoPruneTyDecls
624 && (opt_IgnoreIfacePragmas || ncons > 1)
625 -- We only defer if imported interface pragmas are ingored
626 -- or if it's not a product type.
627 -- Sole reason: The wrapper for a strict function may need to look
628 -- inside its arg, and hence need to see its arg type's constructors.
630 && not (getUnique tycon_name `elem` cCallishTyKeys)
631 -- Never defer ccall types; we have to unbox them,
632 -- and importing them does no harm
634 -> -- OK, so we're importing a deferrable data type
635 if needed_name == tycon_name then
636 -- The needed_name is the TyCon of a data type decl
637 -- Record that it's slurped, put it in the deferred set
638 -- and don't return a declaration at all
639 setIfacesRn (recordSlurp (ifaces {iDeferred = iDeferred ifaces
640 `addOneToNameSet` tycon_name})
641 version (AvailTC needed_name [needed_name])) `thenRn_`
644 -- The needed name is a constructor of a data type decl,
645 -- getting a constructor, so remove the TyCon from the deferred set
646 -- (if it's there) and return the full declaration
647 setIfacesRn (recordSlurp (ifaces {iDeferred = iDeferred ifaces
648 `delFromNameSet` tycon_name})
649 version avail) `thenRn_`
650 returnRn (HereItIs decl)
652 tycon_name = availName avail
654 Just (version,avail,_,decl)
655 -> setIfacesRn (recordSlurp ifaces version avail) `thenRn_`
656 returnRn (HereItIs decl)
659 -> addErrRn (getDeclErr needed_name) `thenRn_`
660 returnRn AlreadySlurped
662 doc_str = ptext SLIT("need decl for") <+> ppr needed_name
664 getDeferredDecls :: RnMG [(Module, RdrNameHsDecl)]
666 = getIfacesRn `thenRn` \ ifaces ->
668 decls_map = iDecls ifaces
669 deferred_names = nameSetToList (iDeferred ifaces)
670 get_abstract_decl n = case lookupNameEnv decls_map n of
671 Just (_, _, _, decl) -> decl
673 traceRn (sep [text "getDeferredDecls", nest 4 (fsep (map ppr deferred_names))]) `thenRn_`
674 returnRn (map get_abstract_decl deferred_names)
677 @getWiredInDecl@ maps a wired-in @Name@ to what it makes available.
678 It behaves exactly as if the wired in decl were actually in an interface file.
681 \item if the wired-in name is a data type constructor or a data constructor,
682 it brings in the type constructor and all the data constructors; and
683 marks as ``occurrences'' any free vars of the data con.
685 \item similarly for synonum type constructor
687 \item if the wired-in name is another wired-in Id, it marks as ``occurrences''
688 the free vars of the Id's type.
690 \item it loads the interface file for the wired-in thing for the
691 sole purpose of making sure that its instance declarations are available
693 All this is necessary so that we know all types that are ``in play'', so
694 that we know just what instances to bring into scope.
699 %*********************************************************
701 \subsection{Getting what a module exports}
703 %*********************************************************
705 @getInterfaceExports@ is called only for directly-imported modules.
708 getInterfaceExports :: ModuleName -> WhereFrom -> RnMG (Module, Avails)
709 getInterfaceExports mod_name from
710 = getHomeSymbolTableRn `thenRn` \ hst ->
711 case lookupModuleEnvByName hst mod_name of {
712 Just mds -> returnRn (mdModule mds, mdExports mds) ;
713 Nothing -> pprPanic "getInterfaceExports" (ppr mod_name)
715 -- I think this is what it _used_ to say. JRS, 001017
716 -- loadInterface doc_str mod_name from `thenRn` \ ifaces ->
717 -- case lookupModuleEnv (iPST ifaces) mod_name of
718 -- Just mds -> returnRn (mdModule mod, mdExports mds)
719 -- -- loadInterface always puts something in the map
720 -- -- even if it's a fake
724 doc_str = sep [ppr mod_name, ptext SLIT("is directly imported")]
728 %*********************************************************
730 \subsection{Instance declarations are handled specially}
732 %*********************************************************
735 getImportedInstDecls :: NameSet -> RnMG [(Module,RdrNameHsDecl)]
736 getImportedInstDecls gates
737 = -- First, load any orphan-instance modules that aren't aready loaded
738 -- Orphan-instance modules are recorded in the module dependecnies
739 getIfacesRn `thenRn` \ ifaces ->
742 [mod | (mod, (True, _, Nothing)) <- fmToList (iImpModInfo ifaces)]
744 loadOrphanModules orphan_mods `thenRn_`
746 -- Now we're ready to grab the instance declarations
747 -- Find the un-gated ones and return them,
748 -- removing them from the bag kept in Ifaces
749 getIfacesRn `thenRn` \ ifaces ->
751 (decls, new_insts) = selectGated gates (iInsts ifaces)
753 setIfacesRn (ifaces { iInsts = new_insts }) `thenRn_`
755 traceRn (sep [text "getImportedInstDecls:",
756 nest 4 (fsep (map ppr gate_list)),
757 text "Slurped" <+> int (length decls) <+> text "instance declarations",
758 nest 4 (vcat (map ppr_brief_inst_decl decls))]) `thenRn_`
761 gate_list = nameSetToList gates
763 ppr_brief_inst_decl (mod, InstD (InstDecl inst_ty _ _ _ _))
765 HsForAllTy _ _ tau -> ppr tau
768 getImportedRules :: RnMG [(Module,RdrNameHsDecl)]
770 | opt_IgnoreIfacePragmas = returnRn []
772 = getIfacesRn `thenRn` \ ifaces ->
774 gates = iSlurp ifaces -- Anything at all that's been slurped
775 rules = iRules ifaces
776 (decls, new_rules) = selectGated gates rules
781 setIfacesRn (ifaces { iRules = new_rules }) `thenRn_`
782 traceRn (sep [text "getImportedRules:",
783 text "Slurped" <+> int (length decls) <+> text "rules"]) `thenRn_`
786 selectGated gates decl_bag
787 -- Select only those decls whose gates are *all* in 'gates'
789 | opt_NoPruneDecls -- Just to try the effect of not gating at all
790 = (foldrBag (\ (_,d) ds -> d:ds) [] decl_bag, emptyBag) -- Grab them all
794 = foldrBag select ([], emptyBag) decl_bag
796 select (reqd, decl) (yes, no)
797 | isEmptyNameSet (reqd `minusNameSet` gates) = (decl:yes, no)
798 | otherwise = (yes, (reqd,decl) `consBag` no)
800 lookupFixityRn :: Name -> RnMS Fixity
802 | isLocallyDefined name
803 = getFixityEnv `thenRn` \ local_fix_env ->
804 returnRn (lookupLocalFixity local_fix_env name)
806 | otherwise -- Imported
807 -- For imported names, we have to get their fixities by doing a loadHomeInterface,
808 -- and consulting the Ifaces that comes back from that, because the interface
809 -- file for the Name might not have been loaded yet. Why not? Suppose you import module A,
810 -- which exports a function 'f', which is defined in module B. Then B isn't loaded
811 -- right away (after all, it's possible that nothing from B will be used).
812 -- When we come across a use of 'f', we need to know its fixity, and it's then,
813 -- and only then, that we load B.hi. That is what's happening here.
814 = getHomeSymbolTableRn `thenRn` \ hst ->
815 case lookupFixityEnv hst name of {
816 Just fixity -> returnRn fixity ;
819 loadHomeInterface doc name `thenRn` \ ifaces ->
820 returnRn (lookupFixityEnv (iPST ifaces) name `orElse` defaultFixity)
823 doc = ptext SLIT("Checking fixity for") <+> ppr name
827 %*********************************************************
829 \subsection{Keeping track of what we've slurped, and version numbers}
831 %*********************************************************
833 getImportVersions figures out what the ``usage information'' for this
834 moudule is; that is, what it must record in its interface file as the
835 things it uses. It records:
838 \item (a) anything reachable from its body code
839 \item (b) any module exported with a @module Foo@
840 \item (c) anything reachable from an exported item
843 Why (b)? Because if @Foo@ changes then this module's export list
844 will change, so we must recompile this module at least as far as
845 making a new interface file --- but in practice that means complete
848 Why (c)? Consider this:
850 module A( f, g ) where | module B( f ) where
851 import B( f ) | f = h 3
855 Here, @B.f@ isn't used in A. Should we nevertheless record @B.f@ in
856 @A@'s usages? Our idea is that we aren't going to touch A.hi if it is
857 *identical* to what it was before. If anything about @B.f@ changes
858 than anyone who imports @A@ should be recompiled in case they use
859 @B.f@ (they'll get an early exit if they don't). So, if anything
860 about @B.f@ changes we'd better make sure that something in A.hi
861 changes, and the convenient way to do that is to record the version
862 number @B.f@ in A.hi in the usage list. If B.f changes that'll force a
863 complete recompiation of A, which is overkill but it's the only way to
864 write a new, slightly different, A.hi.
866 But the example is tricker. Even if @B.f@ doesn't change at all,
867 @B.h@ may do so, and this change may not be reflected in @f@'s version
868 number. But with -O, a module that imports A must be recompiled if
869 @B.h@ changes! So A must record a dependency on @B.h@. So we treat
870 the occurrence of @B.f@ in the export list *just as if* it were in the
871 code of A, and thereby haul in all the stuff reachable from it.
873 [NB: If B was compiled with -O, but A isn't, we should really *still*
874 haul in all the unfoldings for B, in case the module that imports A *is*
875 compiled with -O. I think this is the case.]
877 Even if B is used at all we get a usage line for B
878 import B <n> :: ... ;
879 in A.hi, to record the fact that A does import B. This is used to decide
880 to look to look for B.hi rather than B.hi-boot when compiling a module that
881 imports A. This line says that A imports B, but uses nothing in it.
882 So we'll get an early bale-out when compiling A if B's version changes.
885 mkImportExportInfo :: ModuleName -- Name of this module
886 -> Avails -- Info about exports
887 -> Maybe [RdrNameIE] -- The export header
888 -> RnMG ([ExportItem], -- Export info for iface file; sorted
889 [ImportVersion OccName]) -- Import info for iface file; sorted
890 -- Both results are sorted into canonical order to
891 -- reduce needless wobbling of interface files
893 mkImportExportInfo this_mod export_avails exports
894 = getIfacesRn `thenRn` \ ifaces ->
896 export_all_mods = case exports of
898 Just es -> [mod | IEModuleContents mod <- es,
901 mod_map = iImpModInfo ifaces
902 imp_names = iVSlurp ifaces
904 -- mv_map groups together all the things imported from a particular module.
905 mv_map :: FiniteMap ModuleName [(OccName,Version)]
906 mv_map = foldr add_mv emptyFM imp_names
908 add_mv (name, version) mv_map = addItem mv_map (moduleName (nameModule name))
909 (nameOccName name, version)
911 -- Build the result list by adding info for each module.
912 -- For (a) a library module, we don't record it at all unless it contains orphans
913 -- (We must never lose track of orphans.)
915 -- (b) a source-imported module, don't record the dependency at all
917 -- (b) may seem a bit strange. The idea is that the usages in a .hi file records
918 -- *all* the module's dependencies other than the loop-breakers. We use
919 -- this info in findAndReadInterface to decide whether to look for a .hi file or
922 -- This means we won't track version changes, or orphans, from .hi-boot files.
923 -- The former is potentially rather bad news. It could be fixed by recording
924 -- whether something is a boot file along with the usage info for it, but
925 -- I can't be bothered just now.
927 mk_imp_info mod_name (has_orphans, is_boot, contents) so_far
928 | mod_name == this_mod -- Check if M appears in the set of modules 'below' M
929 -- This seems like a convenient place to check
930 = WARN( not is_boot, ptext SLIT("Wierd:") <+> ppr this_mod <+>
931 ptext SLIT("imports itself (perhaps indirectly)") )
936 go_for_it exports = (mod_name, has_orphans, is_boot, exports)
940 Nothing -> -- We didn't even open the interface
941 -- This happens when a module, Foo, that we explicitly imported has
942 -- 'import Baz' in its interface file, recording that Baz is below
943 -- Foo in the module dependency hierarchy. We want to propagate this
944 -- information. The Nothing says that we didn't even open the interface
945 -- file but we must still propagate the dependeny info.
946 -- The module in question must be a local module (in the same package)
947 go_for_it NothingAtAll
949 Just (mod, mod_vers, fix_vers, rule_vers, how_imported, _)
950 | is_sys_import && is_lib_module && not has_orphans
953 | is_lib_module -- Record the module but not detailed
954 || mod_name `elem` export_all_mods -- version information for the imports
955 -> go_for_it (Everything mod_vers)
958 -> case lookupFM mv_map mod_name of
959 Just whats_imported -> go_for_it (Specifically mod_vers fix_vers rule_vers
960 (sortImport whats_imported))
961 Nothing -> go_for_it NothingAtAll
962 -- This happens if you have
964 -- but don't actually *use* anything from Foo
965 -- In which case record an empty dependency list
967 is_lib_module = not (isModuleInThisPackage mod)
968 is_sys_import = case how_imported of
969 ImportBySystem -> True
973 import_info = foldFM mk_imp_info [] mod_map
975 -- Sort exports into groups by module
976 export_fm :: FiniteMap ModuleName [RdrAvailInfo]
977 export_fm = foldr insert emptyFM export_avails
979 insert avail efm = addItem efm (moduleName (nameModule (availName avail)))
982 export_info = [(m, sortExport as) | (m,as) <- fmToList export_fm]
984 traceRn (text "Modules in Ifaces: " <+> fsep (map ppr (keysFM mod_map))) `thenRn_`
985 returnRn (export_info, import_info)
988 addItem :: FiniteMap ModuleName [a] -> ModuleName -> a -> FiniteMap ModuleName [a]
989 addItem fm mod x = addToFM_C add_item fm mod [x]
993 sortImport :: [(OccName,Version)] -> [(OccName,Version)]
994 -- Make the usage lists appear in canonical order
995 sortImport vs = sortLt lt vs
997 lt (n1,v1) (n2,v2) = n1 < n2
999 sortExport :: [RdrAvailInfo] -> [RdrAvailInfo]
1000 sortExport as = sortLt lt as
1002 lt a1 a2 = availName a1 < availName a2
1007 = getIfacesRn `thenRn` \ ifaces ->
1008 returnRn (iSlurp ifaces)
1010 recordSlurp ifaces@(Ifaces { iSlurp = slurped_names, iVSlurp = imp_names })
1013 new_slurped_names = addAvailToNameSet slurped_names avail
1014 new_imp_names = (availName avail, version) : imp_names
1016 ifaces { iSlurp = new_slurped_names, iVSlurp = new_imp_names }
1018 recordLocalSlurps local_avails
1019 = getIfacesRn `thenRn` \ ifaces ->
1021 new_slurped_names = foldl addAvailToNameSet (iSlurp ifaces) local_avails
1023 setIfacesRn (ifaces { iSlurp = new_slurped_names })
1027 %*********************************************************
1029 \subsection{Getting binders out of a declaration}
1031 %*********************************************************
1033 @getDeclBinders@ returns the names for a @RdrNameHsDecl@.
1034 It's used for both source code (from @availsFromDecl@) and interface files
1037 It doesn't deal with source-code specific things: @ValD@, @DefD@. They
1038 are handled by the sourc-code specific stuff in @RnNames@.
1041 getDeclBinders :: (RdrName -> SrcLoc -> RnM d Name) -- New-name function
1043 -> RnM d (Maybe AvailInfo)
1045 getDeclBinders new_name (TyClD (TyData _ _ tycon _ condecls _ _ _ src_loc _ _))
1046 = new_name tycon src_loc `thenRn` \ tycon_name ->
1047 getConFieldNames new_name condecls `thenRn` \ sub_names ->
1048 returnRn (Just (AvailTC tycon_name (tycon_name : nub sub_names)))
1049 -- The "nub" is because getConFieldNames can legitimately return duplicates,
1050 -- when a record declaration has the same field in multiple constructors
1052 getDeclBinders new_name (TyClD (TySynonym tycon _ _ src_loc))
1053 = new_name tycon src_loc `thenRn` \ tycon_name ->
1054 returnRn (Just (AvailTC tycon_name [tycon_name]))
1056 getDeclBinders new_name (TyClD (ClassDecl _ cname _ _ sigs _ _ _ src_loc))
1057 = new_name cname src_loc `thenRn` \ class_name ->
1059 -- Record the names for the class ops
1061 -- just want class-op sigs
1062 op_sigs = filter isClassOpSig sigs
1064 mapRn (getClassOpNames new_name) op_sigs `thenRn` \ sub_names ->
1066 returnRn (Just (AvailTC class_name (class_name : sub_names)))
1068 getDeclBinders new_name (SigD (IfaceSig var ty prags src_loc))
1069 = new_name var src_loc `thenRn` \ var_name ->
1070 returnRn (Just (Avail var_name))
1072 getDeclBinders new_name (FixD _) = returnRn Nothing
1073 getDeclBinders new_name (DeprecD _) = returnRn Nothing
1075 -- foreign declarations
1076 getDeclBinders new_name (ForD (ForeignDecl nm kind _ dyn _ loc))
1077 | binds_haskell_name kind dyn
1078 = new_name nm loc `thenRn` \ name ->
1079 returnRn (Just (Avail name))
1081 | otherwise -- a foreign export
1082 = lookupOrigName nm `thenRn_`
1085 getDeclBinders new_name (DefD _) = returnRn Nothing
1086 getDeclBinders new_name (InstD _) = returnRn Nothing
1087 getDeclBinders new_name (RuleD _) = returnRn Nothing
1089 binds_haskell_name (FoImport _) _ = True
1090 binds_haskell_name FoLabel _ = True
1091 binds_haskell_name FoExport ext_nm = isDynamicExtName ext_nm
1094 getConFieldNames new_name (ConDecl con _ _ _ (RecCon fielddecls) src_loc : rest)
1095 = mapRn (\n -> new_name n src_loc) (con:fields) `thenRn` \ cfs ->
1096 getConFieldNames new_name rest `thenRn` \ ns ->
1097 returnRn (cfs ++ ns)
1099 fields = concat (map fst fielddecls)
1101 getConFieldNames new_name (ConDecl con _ _ _ condecl src_loc : rest)
1102 = new_name con src_loc `thenRn` \ n ->
1103 getConFieldNames new_name rest `thenRn` \ ns ->
1106 getConFieldNames new_name [] = returnRn []
1108 getClassOpNames new_name (ClassOpSig op _ _ src_loc) = new_name op src_loc
1111 @getDeclSysBinders@ gets the implicit binders introduced by a decl.
1112 A the moment that's just the tycon and datacon that come with a class decl.
1113 They aren't returned by @getDeclBinders@ because they aren't in scope;
1114 but they {\em should} be put into the @DeclsMap@ of this module.
1116 Note that this excludes the default-method names of a class decl,
1117 and the dict fun of an instance decl, because both of these have
1118 bindings of their own elsewhere.
1121 getDeclSysBinders new_name (TyClD (ClassDecl _ cname _ _ sigs _ _ names
1123 = sequenceRn [new_name n src_loc | n <- names]
1125 getDeclSysBinders new_name (TyClD (TyData _ _ _ _ cons _ _ _ _ _ _))
1126 = sequenceRn [new_name wkr_name src_loc | ConDecl _ wkr_name _ _ _ src_loc <- cons]
1128 getDeclSysBinders new_name other_decl
1132 %*********************************************************
1134 \subsection{Reading an interface file}
1136 %*********************************************************
1139 findAndReadIface :: SDoc -> ModuleName
1140 -> IsBootInterface -- True <=> Look for a .hi-boot file
1141 -- False <=> Look for .hi file
1142 -> RnM d (Either Message (Module, ParsedIface))
1143 -- Nothing <=> file not found, or unreadable, or illegible
1144 -- Just x <=> successfully found and parsed
1146 findAndReadIface doc_str mod_name hi_boot_file
1147 = traceRn trace_msg `thenRn_`
1148 -- we keep two maps for interface files,
1149 -- one for 'normal' ones, the other for .hi-boot files,
1150 -- hence the need to signal which kind we're interested.
1152 getFinderRn `thenRn` \ finder ->
1153 ioToRn (findModule finder mod_name) `thenRn` \ maybe_module ->
1155 case maybe_module of
1156 Just mod | hi_boot_file, Just fpath <- moduleHiBootFile mod
1157 -> readIface mod fpath
1158 | not hi_boot_file, Just fpath <- moduleHiFile mod
1159 -> readIface mod fpath
1162 other -> traceRn (ptext SLIT("...not found")) `thenRn_`
1163 returnRn (Left (noIfaceErr finder mod_name hi_boot_file))
1166 trace_msg = sep [hsep [ptext SLIT("Reading"),
1167 if hi_boot_file then ptext SLIT("[boot]") else empty,
1168 ptext SLIT("interface for"),
1169 ppr mod_name <> semi],
1170 nest 4 (ptext SLIT("reason:") <+> doc_str)]
1173 @readIface@ tries just the one file.
1176 readIface :: Module -> String -> RnM d (Either Message (Module, ParsedIface))
1177 -- Nothing <=> file not found, or unreadable, or illegible
1178 -- Just x <=> successfully found and parsed
1179 readIface wanted_mod file_path
1180 = traceRn (ptext SLIT("...reading from") <+> text file_path) `thenRn_`
1181 ioToRnM (hGetStringBuffer False file_path) `thenRn` \ read_result ->
1184 case parseIface contents
1185 PState{ bol = 0#, atbol = 1#,
1188 loc = mkSrcLoc (mkFastString file_path) 1 } of
1189 POk _ (PIface iface) ->
1190 warnCheckRn (moduleName wanted_mod == read_mod)
1191 (hiModuleNameMismatchWarn wanted_mod read_mod) `thenRn_`
1192 returnRn (Right (mod, iface))
1194 read_mod = moduleName (pi_mod iface)
1196 PFailed err -> bale_out err
1197 parse_result -> bale_out empty
1198 -- This last case can happen if the interface file is (say) empty
1199 -- in which case the parser thinks it looks like an IdInfo or
1200 -- something like that. Just an artefact of the fact that the
1201 -- parser is used for several purposes at once.
1203 Left io_err -> bale_out (text (show io_err))
1205 bale_out err = returnRn (Left (badIfaceFile file_path err))
1208 %*********************************************************
1212 %*********************************************************
1215 noIfaceErr mod_name boot_file search_path
1216 = vcat [ptext SLIT("Could not find interface file for") <+> quotes (ppr mod_name),
1217 ptext SLIT("in the directories") <+>
1218 -- \& to avoid cpp interpreting this string as a
1219 -- comment starter with a pre-4.06 mkdependHS --SDM
1220 vcat [ text dir <> text "/\&*" <> pp_suffix suffix
1221 | (dir,suffix) <- search_path]
1224 pp_suffix suffix | boot_file = ptext SLIT(".hi-boot")
1225 | otherwise = text suffix
1227 badIfaceFile file err
1228 = vcat [ptext SLIT("Bad interface file:") <+> text file,
1232 = vcat [ptext SLIT("Failed to find interface decl for") <+> quotes (ppr name),
1233 ptext SLIT("from module") <+> quotes (ppr (nameModule name))
1238 "Compiler tried to import decl from interface file with same name as module."),
1240 "(possible cause: module name clashes with interface file already in scope.)")
1242 hsep [ptext SLIT("name:"), quotes (ppr name)]
1244 warnRedundantSourceImport mod_name
1245 = ptext SLIT("Unnecessary {- SOURCE -} in the import of module")
1246 <+> quotes (ppr mod_name)
1248 hiModuleNameMismatchWarn :: Module -> ModuleName -> Message
1249 hiModuleNameMismatchWarn requested_mod read_mod =
1250 hsep [ ptext SLIT("Something is amiss; requested module name")
1251 , ppr (moduleName requested_mod)
1252 , ptext SLIT("differs from name found in the interface file")
1257 #endif /* TEMP DEBUG HACK! */