2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 \section[RnIfaces]{Cacheing and Renaming of Interfaces}
10 getInterfaceExports, getDeferredDecls,
11 getImportedInstDecls, getImportedRules,
12 lookupFixityRn, loadHomeInterface,
13 importDecl, ImportDeclResult(..), recordLocalSlurps, loadBuiltinRules,
14 mkImportExportInfo, getSlurped,
16 checkModUsage, outOfDate, upToDate,
18 getDeclBinders, getDeclSysBinders,
19 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, NewOrData(..) )
34 import RdrHsSyn ( RdrNameHsDecl, RdrNameInstDecl, RdrNameRuleDecl,
35 RdrNameDeprecation, RdrNameIE,
40 import ParseIface ( parseIface, IfaceStuff(..) )
42 import Name ( Name {-instance NamedThing-}, nameOccName,
43 nameModule, isLocallyDefined,
44 isWiredInName, NamedThing(..),
45 elemNameEnv, extendNameEnv
47 import Module ( Module, mkVanillaModule, pprModuleName,
48 moduleName, isLocalModule,
49 ModuleName, WhereFrom(..),
51 import RdrName ( RdrName, rdrNameOcc )
53 import SrcLoc ( mkSrcLoc, SrcLoc )
54 import PrelInfo ( cCallishTyKeys )
55 import Maybes ( maybeToBool )
56 import Unique ( Uniquable(..) )
57 import StringBuffer ( hGetStringBuffer )
58 import FastString ( mkFastString )
59 import ErrUtils ( Message )
60 import Util ( sortLt )
70 %*********************************************************
72 \subsection{Loading a new interface file}
74 %*********************************************************
77 loadHomeInterface :: SDoc -> Name -> RnM d Ifaces
78 loadHomeInterface doc_str name
79 = loadInterface doc_str (moduleName (nameModule name)) ImportBySystem
81 loadOrphanModules :: [ModuleName] -> RnM d ()
82 loadOrphanModules mods
83 | null mods = returnRn ()
84 | otherwise = traceRn (text "Loading orphan modules:" <+>
85 fsep (map pprModuleName mods)) `thenRn_`
86 mapRn_ load mods `thenRn_`
89 load mod = loadInterface (mk_doc mod) mod ImportBySystem
90 mk_doc mod = pprModuleName mod <+> ptext SLIT("is a orphan-instance module")
93 loadInterface :: SDoc -> ModuleName -> WhereFrom -> RnM d Ifaces
94 loadInterface doc mod from
95 = tryLoadInterface doc mod from `thenRn` \ (ifaces, maybe_err) ->
97 Nothing -> returnRn ifaces
98 Just err -> failWithRn ifaces err
100 tryLoadInterface :: SDoc -> ModuleName -> WhereFrom -> RnM d (Ifaces, Maybe Message)
101 -- Returns (Just err) if an error happened
102 -- Guarantees to return with iImpModInfo m --> (... Just cts)
103 -- (If the load fails, we plug in a vanilla placeholder
104 tryLoadInterface doc_str mod_name from
105 = getIfacesRn `thenRn` \ ifaces ->
107 mod_map = iImpModInfo ifaces
108 mod_info = lookupFM mod_map mod_name
111 = case (from, mod_info) of
112 (ImportByUser, _) -> False -- Not hi-boot
113 (ImportByUserSource, _) -> True -- hi-boot
114 (ImportBySystem, Just (_, is_boot, _)) -> is_boot --
115 (ImportBySystem, Nothing) -> False
116 -- We're importing a module we know absolutely
117 -- nothing about, so we assume it's from
118 -- another package, where we aren't doing
119 -- dependency tracking. So it won't be a hi-boot file.
121 redundant_source_import
122 = case (from, mod_info) of
123 (ImportByUserSource, Just (_,False,_)) -> True
126 -- CHECK WHETHER WE HAVE IT ALREADY
129 -> -- We're read it already so don't re-read it
130 returnRn (ifaces, Nothing) ;
134 -- Issue a warning for a redundant {- SOURCE -} import
135 -- NB that we arrange to read all the ordinary imports before
136 -- any of the {- SOURCE -} imports
137 warnCheckRn (not redundant_source_import)
138 (warnRedundantSourceImport mod_name) `thenRn_`
140 -- READ THE MODULE IN
141 findAndReadIface doc_str mod_name hi_boot_file `thenRn` \ read_resultb ->
142 case read_result of {
143 Left err -> -- Not found, so add an empty export env to the Ifaces map
144 -- so that we don't look again
146 new_mod_map = addToFM mod_map mod_name (False, False, True)
147 new_ifaces = ifaces { iImpModInfo = new_mod_map }
149 setIfacesRn new_ifaces `thenRn_`
150 returnRn (new_ifaces, Just err) ;
153 Right (mod, iface) ->
155 -- LOAD IT INTO Ifaces
157 -- NB: *first* we do loadDecl, so that the provenance of all the locally-defined
158 --- names is done correctly (notably, whether this is an .hi file or .hi-boot file).
159 -- If we do loadExport first the wrong info gets into the cache (unless we
160 -- explicitly tag each export which seems a bit of a bore)
163 -- Sanity check. If we're system-importing a module we know nothing at all
164 -- about, it should be from a different package to this one
165 WARN( not (maybeToBool mod_info) &&
166 case from of { ImportBySystem -> True; other -> False } &&
170 loadDecls mod (iDecls ifaces) (pi_decls iface) `thenRn` \ (decls_vers, new_decls) ->
171 loadRules mod (iRules ifaces) (pi_rules iface) `thenRn` \ (rule_vers, new_rules) ->
172 loadFixDecls mod_name (pi_fixity iface) `thenRn` \ (fix_vers, fix_env) ->
173 foldlRn (loadDeprec mod) emptyDeprecEnv (pi_deprecs iface) `thenRn` \ deprec_env ->
174 foldlRn (loadInstDecl mod) (iInsts ifaces) (pi_insts iface) `thenRn` \ new_insts ->
175 loadExports (pi_exports iface) `thenRn` \ avails ->
177 version = VersionInfo { modVers = pi_vers iface,
179 ruleVers = rule_vers,
180 declVers = decl_vers }
182 -- For an explicit user import, add to mod_map info about
183 -- the things the imported module depends on, extracted
184 -- from its usage info.
185 mod_map1 = case from of
186 ImportByUser -> addModDeps mod (pi_usages iface) mod_map
188 mod_map2 = addToFM mod_map1 mod_name (pi_orphan iface, hi_boot_file, True)
190 -- Now add info about this module to the PST
191 new_pst = extendModuleEnv pst mod mod_detils
192 mod_details = ModDetails { mdModule = mod, mvVersion = version,
194 mdFixEnv = fix_env, mdDeprecEnv = deprec_env }
196 new_ifaces = ifaces { iPST = new_pst,
200 iImpModInfo = mod_map2 }
202 setIfacesRn new_ifaces `thenRn_`
203 returnRn (new_ifaces, Nothing)
206 -----------------------------------------------------
207 -- Adding module dependencies from the
208 -- import decls in the interface file
209 -----------------------------------------------------
211 addModDeps :: Module -> PackageSymbolTable -> [ImportVersion a]
212 -> ImportedModuleInfo -> ImportedModuleInfo
213 -- (addModDeps M ivs deps)
214 -- We are importing module M, and M.hi contains 'import' decls given by ivs
215 addModDeps mod new_deps mod_deps
216 = foldr add mod_deps filtered_new_deps
218 -- Don't record dependencies when importing a module from another package
219 -- Except for its descendents which contain orphans,
220 -- and in that case, forget about the boot indicator
221 filtered_new_deps :: (ModuleName, (WhetherHasOrphans, IsBootInterface))
223 | isLocalModule mod = [ (imp_mod, (has_orphans, is_boot, False))
224 | (imp_mod, has_orphans, is_boot, _) <- new_deps
226 | otherwise = [ (imp_mod, (True, False, False))
227 | (imp_mod, has_orphans, _, _) <- new_deps,
230 add (imp_mod, dep) deps = addToFM_C combine deps imp_mod dep
232 combine old@(_, old_is_boot, old_is_loaded) new
233 | old_is_loaded || not old_is_boot = old -- Keep the old info if it's already loaded
234 -- or if it's a non-boot pending load
235 | otherwise = new -- Otherwise pick new info
238 -----------------------------------------------------
239 -- Loading the export list
240 -----------------------------------------------------
242 loadExports :: [ExportItem] -> RnM d Avails
244 = getModuleRn `thenRn` \ this_mod ->
245 mapRn (loadExport this_mod) items `thenRn` \ avails_s ->
246 returnRn (concat avails_s)
249 loadExport :: Module -> ExportItem -> RnM d [AvailInfo]
250 loadExport this_mod (mod, entities)
251 | mod == moduleName this_mod = returnRn []
252 -- If the module exports anything defined in this module, just ignore it.
253 -- Reason: otherwise it looks as if there are two local definition sites
254 -- for the thing, and an error gets reported. Easiest thing is just to
255 -- filter them out up front. This situation only arises if a module
256 -- imports itself, or another module that imported it. (Necessarily,
257 -- this invoves a loop.) Consequence: if you say
262 -- module B( AType ) where
263 -- import {-# SOURCE #-} A( AType )
265 -- then you'll get a 'B does not export AType' message. A bit bogus
266 -- but it's a bogus thing to do!
269 = mapRn (load_entity mod) entities
271 new_name mod occ = newGlobalName mod occ
273 load_entity mod (Avail occ)
274 = new_name mod occ `thenRn` \ name ->
275 returnRn (Avail name)
276 load_entity mod (AvailTC occ occs)
277 = new_name mod occ `thenRn` \ name ->
278 mapRn (new_name mod) occs `thenRn` \ names ->
279 returnRn (AvailTC name names)
282 -----------------------------------------------------
283 -- Loading type/class/value decls
284 -----------------------------------------------------
288 -> [(Version, RdrNameHsDecl)]
289 -> RnM d (NameEnv Version, DeclsMap)
290 loadDecls mod decls_map decls
291 = foldlRn (loadDecl mod) (emptyNameEnv, decls_map) decls
294 -> (NameEnv Version, DeclsMap)
295 -> (Version, RdrNameHsDecl)
296 -> RnM d (NameEnv Version, DeclsMap)
297 loadDecl mod (version_map, decls_map) (version, decl)
298 = getDeclBinders new_name decl `thenRn` \ maybe_avail ->
299 case maybe_avail of {
300 Nothing -> returnRn (version_map, decls_map); -- No bindings
303 getDeclSysBinders new_name decl `thenRn` \ sys_bndrs ->
305 full_avail = addSysAvails avail sys_bndrs
306 -- Add the sys-binders to avail. When we import the decl,
307 -- it's full_avail that will get added to the 'already-slurped' set (iSlurp)
308 -- If we miss out sys-binders, we'll read the decl multiple times!
310 main_name = availName avail
311 new_decls_map = foldl add_decl decls_map
312 [ (name, (full_avail, name==main_name, (mod, decl')))
313 | name <- availNames full_avail]
314 add_decl decls_map (name, stuff)
315 = WARN( name `elemNameEnv` decls_map, ppr name )
316 extendNameEnv decls_map name stuff
318 new_version_map = extendNameEnv version_map main_name version
320 returnRn (new_version_map, new_decls_map)
323 -- newTopBinder puts into the cache the binder with the
324 -- module information set correctly. When the decl is later renamed,
325 -- the binding site will thereby get the correct module.
326 -- There maybe occurrences that don't have the correct Module, but
327 -- by the typechecker will propagate the binding definition to all
328 -- the occurrences, so that doesn't matter
329 new_name rdr_name loc = newTopBinder mod rdr_name loc
332 If a signature decl is being loaded, and optIgnoreIfacePragmas is on,
333 we toss away unfolding information.
335 Also, if the signature is loaded from a module we're importing from source,
336 we do the same. This is to avoid situations when compiling a pair of mutually
337 recursive modules, peering at unfolding info in the interface file of the other,
338 e.g., you compile A, it looks at B's interface file and may as a result change
339 its interface file. Hence, B is recompiled, maybe changing its interface file,
340 which will the unfolding info used in A to become invalid. Simple way out is to
341 just ignore unfolding info.
343 [Jan 99: I junked the second test above. If we're importing from an hi-boot
344 file there isn't going to *be* any pragma info. Maybe the above comment
345 dates from a time where we picked up a .hi file first if it existed?]
348 SigD (IfaceSig name tp ls loc) | opt_IgnoreIfacePragmas
349 -> SigD (IfaceSig name tp [] loc)
352 -----------------------------------------------------
353 -- Loading fixity decls
354 -----------------------------------------------------
356 loadFixDecls mod_name (version, decls)
357 | null decls = returnRn (version, emptyNameEnv)
360 = mapRn (loadFixDecl mod_name) decls `thenRn` \ to_add ->
361 returnRn (version, mkNameEnv to_add)
363 loadFixDecl mod_name sig@(FixitySig rdr_name fixity loc)
364 = newGlobalName mod_name (rdrNameOcc rdr_name) `thenRn` \ name ->
365 returnRn (name, FixitySig name fixity loc)
368 -----------------------------------------------------
369 -- Loading instance decls
370 -----------------------------------------------------
372 loadInstDecl :: Module
376 loadInstDecl mod insts decl@(InstDecl inst_ty binds uprags dfun_name src_loc)
378 -- Find out what type constructors and classes are "gates" for the
379 -- instance declaration. If all these "gates" are slurped in then
380 -- we should slurp the instance decl too.
382 -- We *don't* want to count names in the context part as gates, though.
384 -- instance Foo a => Baz (T a) where ...
386 -- Here the gates are Baz and T, but *not* Foo.
388 munged_inst_ty = removeContext inst_ty
389 free_names = extractHsTyRdrNames munged_inst_ty
392 mapRn lookupOrigName free_names `thenRn` \ gate_names ->
393 returnRn ((mkNameSet gate_names, (mod, InstD decl)) `consBag` insts)
396 -- In interface files, the instance decls now look like
397 -- forall a. Foo a -> Baz (T a)
398 -- so we have to strip off function argument types as well
399 -- as the bit before the '=>' (which is always empty in interface files)
400 removeContext (HsForAllTy tvs cxt ty) = HsForAllTy tvs [] (removeFuns ty)
401 removeContext ty = removeFuns ty
403 removeFuns (HsFunTy _ ty) = removeFuns ty
407 -----------------------------------------------------
409 -----------------------------------------------------
411 loadRules :: Module -> IfaceRules
412 -> (Version, [RdrNameRuleDecl])
413 -> RnM d (Version, IfaceRules)
414 loadRules mod rule_bag (version, rules)
415 | null rules || opt_IgnoreIfacePragmas
416 = returnRn (version, rule_bag)
419 mapRn (loadRule mod) rules `thenRn` \ new_rules ->
420 returnRn (version, rule_bag `unionBags` listToBag new_rules)
422 loadRule :: Module -> RdrNameRuleDecl -> RnM d GatedDecl
423 -- "Gate" the rule simply by whether the rule variable is
424 -- needed. We can refine this later.
425 loadRule mod decl@(IfaceRule _ _ var _ _ src_loc)
426 = lookupOrigName var `thenRn` \ var_name ->
427 returnRn (unitNameSet var_name, (mod, RuleD decl))
429 loadBuiltinRules :: [(RdrName, CoreRule)] -> RnMG ()
430 loadBuiltinRules builtin_rules
431 = getIfacesRn `thenRn` \ ifaces ->
432 mapRn loadBuiltinRule builtin_rules `thenRn` \ rule_decls ->
433 setIfacesRn (ifaces { iRules = iRules ifaces `unionBags` listToBag rule_decls })
435 loadBuiltinRule (var, rule)
436 = lookupOrigName var `thenRn` \ var_name ->
437 returnRn (unitNameSet var_name, (nameModule var_name, RuleD (IfaceRuleOut var rule)))
440 -----------------------------------------------------
441 -- Loading Deprecations
442 -----------------------------------------------------
444 loadDeprec :: Module -> DeprecationEnv -> RdrNameDeprecation -> RnM d DeprecationEnv
445 loadDeprec mod deprec_env (Deprecation (IEModuleContents _) txt _)
446 = traceRn (text "module deprecation not yet implemented:" <+> ppr mod <> colon <+> ppr txt) `thenRn_`
447 -- SUP: TEMPORARY HACK, ignoring module deprecations for now
450 loadDeprec mod deprec_env (Deprecation ie txt _)
452 mapRn lookupOrigName (ieNames ie) `thenRn` \ names ->
453 traceRn (text "loaded deprecation(s) for" <+> hcat (punctuate comma (map ppr names)) <> colon <+> ppr txt) `thenRn_`
454 returnRn (extendNameEnvList deprec_env (zip names (repeat txt)))
458 %********************************************************
460 \subsection{Checking usage information}
462 %********************************************************
468 checkModUsage :: [ImportVersion OccName] -> RnMG Bool
469 -- Given the usage information extracted from the old
470 -- M.hi file for the module being compiled, figure out
471 -- whether M needs to be recompiled.
473 checkModUsage [] = returnRn upToDate -- Yes! Everything is up to date!
475 checkModUsage ((mod_name, _, _, NothingAtAll) : rest)
476 -- If CurrentModule.hi contains
478 -- then that simply records that Foo lies below CurrentModule in the
479 -- hierarchy, but CurrentModule doesn't depend in any way on Foo.
480 -- In this case we don't even want to open Foo's interface.
481 = traceRn (ptext SLIT("Nothing used from:") <+> ppr mod_name) `thenRn_`
482 checkModUsage rest -- This one's ok, so check the rest
484 checkModUsage ((mod_name, _, _, whats_imported) : rest)
485 = tryLoadInterface doc_str mod_name ImportBySystem `thenRn` \ (ifaces, maybe_err) ->
487 Just err -> out_of_date (sep [ptext SLIT("Can't find version number for module"),
488 pprModuleName mod_name]) ;
489 -- Couldn't find or parse a module mentioned in the
490 -- old interface file. Don't complain -- it might just be that
491 -- the current module doesn't need that import and it's been deleted
495 (_, new_mod_vers, new_fix_vers, new_rule_vers, _, _)
496 = case lookupFM (iImpModInfo ifaces) mod_name of
497 Just (_, _, Just stuff) -> stuff
499 old_mod_vers = case whats_imported of
501 Specifically v _ _ _ -> v
502 -- NothingAtAll case dealt with by previous eqn for checkModUsage
504 -- If the module version hasn't changed, just move on
505 if new_mod_vers == old_mod_vers then
506 traceRn (sep [ptext SLIT("Module version unchanged:"), pprModuleName mod_name])
507 `thenRn_` checkModUsage rest
509 traceRn (sep [ptext SLIT("Module version has changed:"), pprModuleName mod_name])
511 -- Module version changed, so check entities inside
513 -- If the usage info wants to say "I imported everything from this module"
514 -- it does so by making whats_imported equal to Everything
515 -- In that case, we must recompile
516 case whats_imported of { -- NothingAtAll dealt with earlier
519 -> out_of_date (ptext SLIT("...and I needed the whole module")) ;
521 Specifically _ old_fix_vers old_rule_vers old_local_vers ->
523 if old_fix_vers /= new_fix_vers then
524 out_of_date (ptext SLIT("Fixities changed"))
525 else if old_rule_vers /= new_rule_vers then
526 out_of_date (ptext SLIT("Rules changed"))
528 -- Non-empty usage list, so check item by item
529 checkEntityUsage mod_name (iDecls ifaces) old_local_vers `thenRn` \ up_to_date ->
531 traceRn (ptext SLIT("...but the bits I use haven't.")) `thenRn_`
532 checkModUsage rest -- This one's ok, so check the rest
534 returnRn outOfDate -- This one failed, so just bail out now
537 doc_str = sep [ptext SLIT("need version info for"), pprModuleName mod_name]
540 checkEntityUsage mod decls []
541 = returnRn upToDate -- Yes! All up to date!
543 checkEntityUsage mod decls ((occ_name,old_vers) : rest)
544 = newGlobalName mod occ_name `thenRn` \ name ->
545 case lookupNameEnv decls name of
547 Nothing -> -- We used it before, but it ain't there now
548 out_of_date (sep [ptext SLIT("No longer exported:"), ppr name])
550 Just (new_vers,_,_,_) -- It's there, but is it up to date?
551 | new_vers == old_vers
552 -- Up to date, so check the rest
553 -> checkEntityUsage mod decls rest
556 -- Out of date, so bale out
557 -> out_of_date (sep [ptext SLIT("Out of date:"), ppr name])
559 out_of_date msg = traceRn msg `thenRn_` returnRn outOfDate
563 %*********************************************************
565 \subsection{Getting in a declaration}
567 %*********************************************************
570 importDecl :: Name -> RnMG ImportDeclResult
572 data ImportDeclResult
576 | HereItIs (Module, RdrNameHsDecl)
579 = getIfacesRn `thenRn` \ ifaces ->
580 getHomeSymbolTableRn `thenRn` \ hst ->
581 if name `elemNameSet` iSlurp ifaces
582 || inTypeEnv (iPST ifaces) name
583 || inTypeEnv hst name
584 then -- Already dealt with
585 returnRn AlreadySlurped
587 else if isLocallyDefined name then -- Don't bring in decls from
588 -- the renamed module's own interface file
589 addWarnRn (importDeclWarn name) `thenRn_`
590 returnRn AlreadySlurped
592 else if isWiredInName name then
593 -- When we find a wired-in name we must load its
594 -- home module so that we find any instance decls therein
595 loadHomeInterface doc name `thenRn_`
598 else getNonWiredInDecl name
600 doc = ptext SLIT("need home module for wired in thing") <+> ppr name
602 getNonWiredInDecl :: Name -> RnMG ImportDeclResult
603 getNonWiredInDecl needed_name
604 = traceRn doc_str `thenRn_`
605 loadHomeInterface doc_str needed_name `thenRn` \ ifaces ->
606 case lookupNameEnv (iDecls ifaces) needed_name of
608 Just (version, avail, is_tycon_name, decl@(_, TyClD (TyData DataType _ _ _ _ ncons _ _ _ _ _)))
609 -- This case deals with deferred import of algebraic data types
611 | not opt_NoPruneTyDecls
613 && (opt_IgnoreIfacePragmas || ncons > 1)
614 -- We only defer if imported interface pragmas are ingored
615 -- or if it's not a product type.
616 -- Sole reason: The wrapper for a strict function may need to look
617 -- inside its arg, and hence need to see its arg type's constructors.
619 && not (getUnique tycon_name `elem` cCallishTyKeys)
620 -- Never defer ccall types; we have to unbox them,
621 -- and importing them does no harm
623 -> -- OK, so we're importing a deferrable data type
624 if needed_name == tycon_name then
625 -- The needed_name is the TyCon of a data type decl
626 -- Record that it's slurped, put it in the deferred set
627 -- and don't return a declaration at all
628 setIfacesRn (recordSlurp (ifaces {iDeferred = iDeferred ifaces
629 `addOneToNameSet` tycon_name})
630 version (AvailTC needed_name [needed_name])) `thenRn_`
633 -- The needed name is a constructor of a data type decl,
634 -- getting a constructor, so remove the TyCon from the deferred set
635 -- (if it's there) and return the full declaration
636 setIfacesRn (recordSlurp (ifaces {iDeferred = iDeferred ifaces
637 `delFromNameSet` tycon_name})
638 version avail) `thenRn_`
639 returnRn (HereItIs decl)
641 tycon_name = availName avail
643 Just (version,avail,_,decl)
644 -> setIfacesRn (recordSlurp ifaces version avail) `thenRn_`
645 returnRn (HereItIs decl)
648 -> addErrRn (getDeclErr needed_name) `thenRn_`
649 returnRn AlreadySlurped
651 doc_str = ptext SLIT("need decl for") <+> ppr needed_name
653 getDeferredDecls :: RnMG [(Module, RdrNameHsDecl)]
655 = getIfacesRn `thenRn` \ ifaces ->
657 decls_map = iDecls ifaces
658 deferred_names = nameSetToList (iDeferred ifaces)
659 get_abstract_decl n = case lookupNameEnv decls_map n of
660 Just (_, _, _, decl) -> decl
662 traceRn (sep [text "getDeferredDecls", nest 4 (fsep (map ppr deferred_names))]) `thenRn_`
663 returnRn (map get_abstract_decl deferred_names)
666 @getWiredInDecl@ maps a wired-in @Name@ to what it makes available.
667 It behaves exactly as if the wired in decl were actually in an interface file.
670 \item if the wired-in name is a data type constructor or a data constructor,
671 it brings in the type constructor and all the data constructors; and
672 marks as ``occurrences'' any free vars of the data con.
674 \item similarly for synonum type constructor
676 \item if the wired-in name is another wired-in Id, it marks as ``occurrences''
677 the free vars of the Id's type.
679 \item it loads the interface file for the wired-in thing for the
680 sole purpose of making sure that its instance declarations are available
682 All this is necessary so that we know all types that are ``in play'', so
683 that we know just what instances to bring into scope.
688 %*********************************************************
690 \subsection{Getting what a module exports}
692 %*********************************************************
694 @getInterfaceExports@ is called only for directly-imported modules.
697 getInterfaceExports :: ModuleName -> WhereFrom -> RnMG (Module, Avails)
698 getInterfaceExports mod_name from
699 = getHomeSymbolTableRn `thenRn` \ hst ->
700 case lookupModuleEnvByName hst mod_name of {
701 Just mds -> returnRn (mdModule mds, mdExports mds) ;
704 loadInterface doc_str mod_name from `thenRn` \ ifaces ->
705 case lookupModuleEnv (iPST ifaces) mod_name of
706 Just mds -> returnRn (mdModule mod, mdExports mds)
707 -- loadInterface always puts something in the map
708 -- even if it's a fake
710 doc_str = sep [pprModuleName mod_name, ptext SLIT("is directly imported")]
714 %*********************************************************
716 \subsection{Instance declarations are handled specially}
718 %*********************************************************
721 getImportedInstDecls :: NameSet -> RnMG [(Module,RdrNameHsDecl)]
722 getImportedInstDecls gates
723 = -- First, load any orphan-instance modules that aren't aready loaded
724 -- Orphan-instance modules are recorded in the module dependecnies
725 getIfacesRn `thenRn` \ ifaces ->
728 [mod | (mod, (True, _, Nothing)) <- fmToList (iImpModInfo ifaces)]
730 loadOrphanModules orphan_mods `thenRn_`
732 -- Now we're ready to grab the instance declarations
733 -- Find the un-gated ones and return them,
734 -- removing them from the bag kept in Ifaces
735 getIfacesRn `thenRn` \ ifaces ->
737 (decls, new_insts) = selectGated gates (iInsts ifaces)
739 setIfacesRn (ifaces { iInsts = new_insts }) `thenRn_`
741 traceRn (sep [text "getImportedInstDecls:",
742 nest 4 (fsep (map ppr gate_list)),
743 text "Slurped" <+> int (length decls) <+> text "instance declarations",
744 nest 4 (vcat (map ppr_brief_inst_decl decls))]) `thenRn_`
747 gate_list = nameSetToList gates
749 ppr_brief_inst_decl (mod, InstD (InstDecl inst_ty _ _ _ _))
751 HsForAllTy _ _ tau -> ppr tau
754 getImportedRules :: RnMG [(Module,RdrNameHsDecl)]
756 | opt_IgnoreIfacePragmas = returnRn []
758 = getIfacesRn `thenRn` \ ifaces ->
760 gates = iSlurp ifaces -- Anything at all that's been slurped
761 rules = iRules ifaces
762 (decls, new_rules) = selectGated gates rules
767 setIfacesRn (ifaces { iRules = new_rules }) `thenRn_`
768 traceRn (sep [text "getImportedRules:",
769 text "Slurped" <+> int (length decls) <+> text "rules"]) `thenRn_`
772 selectGated gates decl_bag
773 -- Select only those decls whose gates are *all* in 'gates'
775 | opt_NoPruneDecls -- Just to try the effect of not gating at all
776 = (foldrBag (\ (_,d) ds -> d:ds) [] decl_bag, emptyBag) -- Grab them all
780 = foldrBag select ([], emptyBag) decl_bag
782 select (reqd, decl) (yes, no)
783 | isEmptyNameSet (reqd `minusNameSet` gates) = (decl:yes, no)
784 | otherwise = (yes, (reqd,decl) `consBag` no)
786 lookupFixityRn :: Name -> RnMS Fixity
788 | isLocallyDefined name
789 = getFixityEnv `thenRn` \ local_fix_env ->
790 returnRn (lookupLocalFixity local_fix_env name)
792 | otherwise -- Imported
793 -- For imported names, we have to get their fixities by doing a loadHomeInterface,
794 -- and consulting the Ifaces that comes back from that, because the interface
795 -- file for the Name might not have been loaded yet. Why not? Suppose you import module A,
796 -- which exports a function 'f', which is defined in module B. Then B isn't loaded
797 -- right away (after all, it's possible that nothing from B will be used).
798 -- When we come across a use of 'f', we need to know its fixity, and it's then,
799 -- and only then, that we load B.hi. That is what's happening here.
800 = getHomeSymbolTableRn `thenRn` \ hst ->
801 case lookupFixityEnv hst name of {
802 Just fixity -> returnRn fixity ;
805 loadHomeInterface doc name `thenRn` \ ifaces ->
806 returnRn (lookupFixityEnv (iPST ifaces) name `orElse` defaultFixity)
809 doc = ptext SLIT("Checking fixity for") <+> ppr name
813 %*********************************************************
815 \subsection{Keeping track of what we've slurped, and version numbers}
817 %*********************************************************
819 getImportVersions figures out what the ``usage information'' for this
820 moudule is; that is, what it must record in its interface file as the
821 things it uses. It records:
824 \item (a) anything reachable from its body code
825 \item (b) any module exported with a @module Foo@
826 \item (c) anything reachable from an exported item
829 Why (b)? Because if @Foo@ changes then this module's export list
830 will change, so we must recompile this module at least as far as
831 making a new interface file --- but in practice that means complete
834 Why (c)? Consider this:
836 module A( f, g ) where | module B( f ) where
837 import B( f ) | f = h 3
841 Here, @B.f@ isn't used in A. Should we nevertheless record @B.f@ in
842 @A@'s usages? Our idea is that we aren't going to touch A.hi if it is
843 *identical* to what it was before. If anything about @B.f@ changes
844 than anyone who imports @A@ should be recompiled in case they use
845 @B.f@ (they'll get an early exit if they don't). So, if anything
846 about @B.f@ changes we'd better make sure that something in A.hi
847 changes, and the convenient way to do that is to record the version
848 number @B.f@ in A.hi in the usage list. If B.f changes that'll force a
849 complete recompiation of A, which is overkill but it's the only way to
850 write a new, slightly different, A.hi.
852 But the example is tricker. Even if @B.f@ doesn't change at all,
853 @B.h@ may do so, and this change may not be reflected in @f@'s version
854 number. But with -O, a module that imports A must be recompiled if
855 @B.h@ changes! So A must record a dependency on @B.h@. So we treat
856 the occurrence of @B.f@ in the export list *just as if* it were in the
857 code of A, and thereby haul in all the stuff reachable from it.
859 [NB: If B was compiled with -O, but A isn't, we should really *still*
860 haul in all the unfoldings for B, in case the module that imports A *is*
861 compiled with -O. I think this is the case.]
863 Even if B is used at all we get a usage line for B
864 import B <n> :: ... ;
865 in A.hi, to record the fact that A does import B. This is used to decide
866 to look to look for B.hi rather than B.hi-boot when compiling a module that
867 imports A. This line says that A imports B, but uses nothing in it.
868 So we'll get an early bale-out when compiling A if B's version changes.
871 mkImportExportInfo :: ModuleName -- Name of this module
872 -> Avails -- Info about exports
873 -> Maybe [RdrNameIE] -- The export header
874 -> RnMG ([ExportItem], -- Export info for iface file; sorted
875 [ImportVersion OccName]) -- Import info for iface file; sorted
876 -- Both results are sorted into canonical order to
877 -- reduce needless wobbling of interface files
879 mkImportExportInfo this_mod export_avails exports
880 = getIfacesRn `thenRn` \ ifaces ->
882 export_all_mods = case exports of
884 Just es -> [mod | IEModuleContents mod <- es,
887 mod_map = iImpModInfo ifaces
888 imp_names = iVSlurp ifaces
890 -- mv_map groups together all the things imported from a particular module.
891 mv_map :: FiniteMap ModuleName [(OccName,Version)]
892 mv_map = foldr add_mv emptyFM imp_names
894 add_mv (name, version) mv_map = addItem mv_map (moduleName (nameModule name))
895 (nameOccName name, version)
897 -- Build the result list by adding info for each module.
898 -- For (a) a library module, we don't record it at all unless it contains orphans
899 -- (We must never lose track of orphans.)
901 -- (b) a source-imported module, don't record the dependency at all
903 -- (b) may seem a bit strange. The idea is that the usages in a .hi file records
904 -- *all* the module's dependencies other than the loop-breakers. We use
905 -- this info in findAndReadInterface to decide whether to look for a .hi file or
908 -- This means we won't track version changes, or orphans, from .hi-boot files.
909 -- The former is potentially rather bad news. It could be fixed by recording
910 -- whether something is a boot file along with the usage info for it, but
911 -- I can't be bothered just now.
913 mk_imp_info mod_name (has_orphans, is_boot, contents) so_far
914 | mod_name == this_mod -- Check if M appears in the set of modules 'below' M
915 -- This seems like a convenient place to check
916 = WARN( not is_boot, ptext SLIT("Wierd:") <+> ppr this_mod <+>
917 ptext SLIT("imports itself (perhaps indirectly)") )
922 go_for_it exports = (mod_name, has_orphans, is_boot, exports)
926 Nothing -> -- We didn't even open the interface
927 -- This happens when a module, Foo, that we explicitly imported has
928 -- 'import Baz' in its interface file, recording that Baz is below
929 -- Foo in the module dependency hierarchy. We want to propagate this
930 -- information. The Nothing says that we didn't even open the interface
931 -- file but we must still propagate the dependeny info.
932 -- The module in question must be a local module (in the same package)
933 go_for_it NothingAtAll
935 Just (mod, mod_vers, fix_vers, rule_vers, how_imported, _)
936 | is_sys_import && is_lib_module && not has_orphans
939 | is_lib_module -- Record the module but not detailed
940 || mod_name `elem` export_all_mods -- version information for the imports
941 -> go_for_it (Everything mod_vers)
944 -> case lookupFM mv_map mod_name of
945 Just whats_imported -> go_for_it (Specifically mod_vers fix_vers rule_vers
946 (sortImport whats_imported))
947 Nothing -> go_for_it NothingAtAll
948 -- This happens if you have
950 -- but don't actually *use* anything from Foo
951 -- In which case record an empty dependency list
953 is_lib_module = not (isLocalModule mod)
954 is_sys_import = case how_imported of
955 ImportBySystem -> True
959 import_info = foldFM mk_imp_info [] mod_map
961 -- Sort exports into groups by module
962 export_fm :: FiniteMap ModuleName [RdrAvailInfo]
963 export_fm = foldr insert emptyFM export_avails
965 insert avail efm = addItem efm (moduleName (nameModule (availName avail)))
968 export_info = [(m, sortExport as) | (m,as) <- fmToList export_fm]
970 traceRn (text "Modules in Ifaces: " <+> fsep (map ppr (keysFM mod_map))) `thenRn_`
971 returnRn (export_info, import_info)
974 addItem :: FiniteMap ModuleName [a] -> ModuleName -> a -> FiniteMap ModuleName [a]
975 addItem fm mod x = addToFM_C add_item fm mod [x]
979 sortImport :: [(OccName,Version)] -> [(OccName,Version)]
980 -- Make the usage lists appear in canonical order
981 sortImport vs = sortLt lt vs
983 lt (n1,v1) (n2,v2) = n1 < n2
985 sortExport :: [RdrAvailInfo] -> [RdrAvailInfo]
986 sortExport as = sortLt lt as
988 lt a1 a2 = availName a1 < availName a2
993 = getIfacesRn `thenRn` \ ifaces ->
994 returnRn (iSlurp ifaces)
996 recordSlurp ifaces@(Ifaces { iSlurp = slurped_names, iVSlurp = imp_names })
999 new_slurped_names = addAvailToNameSet slurped_names avail
1000 new_imp_names = (availName avail, version) : imp_names
1002 ifaces { iSlurp = new_slurped_names, iVSlurp = new_imp_names }
1004 recordLocalSlurps local_avails
1005 = getIfacesRn `thenRn` \ ifaces ->
1007 new_slurped_names = foldl addAvailToNameSet (iSlurp ifaces) local_avails
1009 setIfacesRn (ifaces { iSlurp = new_slurped_names })
1013 %*********************************************************
1015 \subsection{Getting binders out of a declaration}
1017 %*********************************************************
1019 @getDeclBinders@ returns the names for a @RdrNameHsDecl@.
1020 It's used for both source code (from @availsFromDecl@) and interface files
1023 It doesn't deal with source-code specific things: @ValD@, @DefD@. They
1024 are handled by the sourc-code specific stuff in @RnNames@.
1027 getDeclBinders :: (RdrName -> SrcLoc -> RnM d Name) -- New-name function
1029 -> RnM d (Maybe AvailInfo)
1031 getDeclBinders new_name (TyClD (TyData _ _ tycon _ condecls _ _ _ src_loc _ _))
1032 = new_name tycon src_loc `thenRn` \ tycon_name ->
1033 getConFieldNames new_name condecls `thenRn` \ sub_names ->
1034 returnRn (Just (AvailTC tycon_name (tycon_name : nub sub_names)))
1035 -- The "nub" is because getConFieldNames can legitimately return duplicates,
1036 -- when a record declaration has the same field in multiple constructors
1038 getDeclBinders new_name (TyClD (TySynonym tycon _ _ src_loc))
1039 = new_name tycon src_loc `thenRn` \ tycon_name ->
1040 returnRn (Just (AvailTC tycon_name [tycon_name]))
1042 getDeclBinders new_name (TyClD (ClassDecl _ cname _ _ sigs _ _ _ src_loc))
1043 = new_name cname src_loc `thenRn` \ class_name ->
1045 -- Record the names for the class ops
1047 -- just want class-op sigs
1048 op_sigs = filter isClassOpSig sigs
1050 mapRn (getClassOpNames new_name) op_sigs `thenRn` \ sub_names ->
1052 returnRn (Just (AvailTC class_name (class_name : sub_names)))
1054 getDeclBinders new_name (SigD (IfaceSig var ty prags src_loc))
1055 = new_name var src_loc `thenRn` \ var_name ->
1056 returnRn (Just (Avail var_name))
1058 getDeclBinders new_name (FixD _) = returnRn Nothing
1059 getDeclBinders new_name (DeprecD _) = returnRn Nothing
1061 -- foreign declarations
1062 getDeclBinders new_name (ForD (ForeignDecl nm kind _ dyn _ loc))
1063 | binds_haskell_name kind dyn
1064 = new_name nm loc `thenRn` \ name ->
1065 returnRn (Just (Avail name))
1067 | otherwise -- a foreign export
1068 = lookupOrigName nm `thenRn_`
1071 getDeclBinders new_name (DefD _) = returnRn Nothing
1072 getDeclBinders new_name (InstD _) = returnRn Nothing
1073 getDeclBinders new_name (RuleD _) = returnRn Nothing
1075 binds_haskell_name (FoImport _) _ = True
1076 binds_haskell_name FoLabel _ = True
1077 binds_haskell_name FoExport ext_nm = isDynamicExtName ext_nm
1080 getConFieldNames new_name (ConDecl con _ _ _ (RecCon fielddecls) src_loc : rest)
1081 = mapRn (\n -> new_name n src_loc) (con:fields) `thenRn` \ cfs ->
1082 getConFieldNames new_name rest `thenRn` \ ns ->
1083 returnRn (cfs ++ ns)
1085 fields = concat (map fst fielddecls)
1087 getConFieldNames new_name (ConDecl con _ _ _ condecl src_loc : rest)
1088 = new_name con src_loc `thenRn` \ n ->
1089 getConFieldNames new_name rest `thenRn` \ ns ->
1092 getConFieldNames new_name [] = returnRn []
1094 getClassOpNames new_name (ClassOpSig op _ _ src_loc) = new_name op src_loc
1097 @getDeclSysBinders@ gets the implicit binders introduced by a decl.
1098 A the moment that's just the tycon and datacon that come with a class decl.
1099 They aren't returned by @getDeclBinders@ because they aren't in scope;
1100 but they {\em should} be put into the @DeclsMap@ of this module.
1102 Note that this excludes the default-method names of a class decl,
1103 and the dict fun of an instance decl, because both of these have
1104 bindings of their own elsewhere.
1107 getDeclSysBinders new_name (TyClD (ClassDecl _ cname _ _ sigs _ _ names
1109 = sequenceRn [new_name n src_loc | n <- names]
1111 getDeclSysBinders new_name (TyClD (TyData _ _ _ _ cons _ _ _ _ _ _))
1112 = sequenceRn [new_name wkr_name src_loc | ConDecl _ wkr_name _ _ _ src_loc <- cons]
1114 getDeclSysBinders new_name other_decl
1118 %*********************************************************
1120 \subsection{Reading an interface file}
1122 %*********************************************************
1125 findAndReadIface :: SDoc -> ModuleName
1126 -> IsBootInterface -- True <=> Look for a .hi-boot file
1127 -- False <=> Look for .hi file
1128 -> RnM d (Either Message (Module, ParsedIface))
1129 -- Nothing <=> file not found, or unreadable, or illegible
1130 -- Just x <=> successfully found and parsed
1132 findAndReadIface doc_str mod_name hi_boot_file
1133 = traceRn trace_msg `thenRn_`
1134 -- we keep two maps for interface files,
1135 -- one for 'normal' ones, the other for .hi-boot files,
1136 -- hence the need to signal which kind we're interested.
1138 getFinderRn `thenRn` \ finder ->
1139 ioToRn (findModule finder mod_name) `thenRn` \ maybe_module ->
1141 case maybe_module of
1142 Just mod | hi_boot_file, Just fpath <- moduleHiBootFile mod
1143 -> readIface mod fpath
1144 | not hi_boot_file, Just fpath <- moduleHiFile mod
1145 -> readIface mod fpath
1148 other -> traceRn (ptext SLIT("...not found")) `thenRn_`
1149 returnRn (Left (noIfaceErr finder mod_name hi_boot_file))
1152 trace_msg = sep [hsep [ptext SLIT("Reading"),
1153 if hi_boot_file then ptext SLIT("[boot]") else empty,
1154 ptext SLIT("interface for"),
1155 pprModuleName mod_name <> semi],
1156 nest 4 (ptext SLIT("reason:") <+> doc_str)]
1159 @readIface@ tries just the one file.
1162 readIface :: Module -> String -> RnM d (Either Message (Module, ParsedIface))
1163 -- Nothing <=> file not found, or unreadable, or illegible
1164 -- Just x <=> successfully found and parsed
1165 readIface wanted_mod file_path
1166 = traceRn (ptext SLIT("...reading from") <+> text file_path) `thenRn_`
1167 ioToRnM (hGetStringBuffer False file_path) `thenRn` \ read_result ->
1170 case parseIface contents
1171 PState{ bol = 0#, atbol = 1#,
1174 loc = mkSrcLoc (mkFastString file_path) 1 } of
1175 POk _ (PIface iface) ->
1176 warnCheckRn (moduleName wanted_mod == read_mod)
1177 (hiModuleNameMismatchWarn wanted_mod read_mod) `thenRn_`
1178 returnRn (Right (mod, iface))
1180 read_mod = moduleName (pi_mod iface)
1182 PFailed err -> bale_out err
1183 parse_result -> bale_out empty
1184 -- This last case can happen if the interface file is (say) empty
1185 -- in which case the parser thinks it looks like an IdInfo or
1186 -- something like that. Just an artefact of the fact that the
1187 -- parser is used for several purposes at once.
1189 Left io_err -> bale_out (text (show io_err))
1191 bale_out err = returnRn (Left (badIfaceFile file_path err))
1194 %*********************************************************
1198 %*********************************************************
1201 noIfaceErr mod_name boot_file search_path
1202 = vcat [ptext SLIT("Could not find interface file for") <+> quotes (pprModuleName mod_name),
1203 ptext SLIT("in the directories") <+>
1204 -- \& to avoid cpp interpreting this string as a
1205 -- comment starter with a pre-4.06 mkdependHS --SDM
1206 vcat [ text dir <> text "/\&*" <> pp_suffix suffix
1207 | (dir,suffix) <- search_path]
1210 pp_suffix suffix | boot_file = ptext SLIT(".hi-boot")
1211 | otherwise = text suffix
1213 badIfaceFile file err
1214 = vcat [ptext SLIT("Bad interface file:") <+> text file,
1218 = vcat [ptext SLIT("Failed to find interface decl for") <+> quotes (ppr name),
1219 ptext SLIT("from module") <+> quotes (ppr (nameModule name))
1224 "Compiler tried to import decl from interface file with same name as module."),
1226 "(possible cause: module name clashes with interface file already in scope.)")
1228 hsep [ptext SLIT("name:"), quotes (ppr name)]
1230 warnRedundantSourceImport mod_name
1231 = ptext SLIT("Unnecessary {- SOURCE -} in the import of module")
1232 <+> quotes (pprModuleName mod_name)
1234 hiModuleNameMismatchWarn :: Module -> ModuleName -> Message
1235 hiModuleNameMismatchWarn requested_mod read_mod =
1236 hsep [ ptext SLIT("Something is amiss; requested module name")
1238 , ptext SLIT("differs from name found in the interface file")
1239 , pprModuleName read_mod