2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 \section[RnIfaces]{Cacheing and Renaming of Interfaces}
9 getImportedInstDecls, getImportedRules,
10 lookupFixity, loadHomeInterface,
11 importDecl, recordSlurp,
12 getImportVersions, getSlurped,
16 getDeclBinders, getDeclSysBinders,
17 removeContext -- removeContext probably belongs somewhere else
20 #include "HsVersions.h"
22 import CmdLineOpts ( opt_NoPruneDecls, opt_IgnoreIfacePragmas )
23 import HsSyn ( HsDecl(..), TyClDecl(..), InstDecl(..), IfaceSig(..),
24 HsType(..), ConDecl(..), IE(..), ConDetails(..), Sig(..),
25 ForeignDecl(..), ForKind(..), isDynamic,
26 FixitySig(..), RuleDecl(..),
29 import BasicTypes ( Version, NewOrData(..), defaultFixity )
30 import RdrHsSyn ( RdrNameHsDecl, RdrNameInstDecl, RdrNameTyClDecl, RdrNameRuleDecl,
33 import RnEnv ( mkImportedGlobalName, newImportedBinder, mkImportedGlobalFromRdrName,
34 lookupOccRn, lookupImplicitOccRn,
36 availName, availNames, addAvailToNameSet,
40 import RnHsSyn ( RenamedHsDecl )
41 import ParseIface ( parseIface, IfaceStuff(..) )
43 import FiniteMap ( FiniteMap, sizeFM, emptyFM, delFromFM, listToFM,
44 lookupFM, addToFM, addToFM_C, addListToFM,
45 fmToList, elemFM, foldFM
47 import Name ( Name {-instance NamedThing-},
48 nameModule, isLocallyDefined,
49 isWiredInName, nameUnique, NamedThing(..)
51 import Module ( Module, moduleString, pprModule,
52 mkVanillaModule, pprModuleName,
53 moduleUserString, moduleName, isLibModule,
54 ModuleName, WhereFrom(..),
56 import RdrName ( RdrName, rdrNameOcc )
59 import SrcLoc ( mkSrcLoc, SrcLoc )
60 import PrelMods ( pREL_GHC )
61 import PrelInfo ( cCallishTyKeys, thinAirModules )
63 import Maybes ( MaybeErr(..), maybeToBool, orElse )
64 import ListSetOps ( unionLists )
66 import Unique ( Unique )
67 import StringBuffer ( StringBuffer, hGetStringBuffer )
68 import FastString ( mkFastString )
69 import ErrUtils ( Message )
73 import IO ( isDoesNotExistError )
78 %*********************************************************
80 \subsection{Loading a new interface file}
82 %*********************************************************
85 loadHomeInterface :: SDoc -> Name -> RnM d Ifaces
86 loadHomeInterface doc_str name
87 = loadInterface doc_str (moduleName (nameModule name)) ImportBySystem `thenRn` \ (_, ifaces) ->
90 loadOrphanModules :: [ModuleName] -> RnM d ()
91 loadOrphanModules mods
92 | null mods = returnRn ()
93 | otherwise = traceRn (text "Loading orphan modules:" <+> fsep (map pprModuleName mods)) `thenRn_`
94 mapRn_ load mods `thenRn_`
97 load mod = loadInterface (pprModuleName mod <+> ptext SLIT("is a orphan-instance module")) mod ImportBySystem
99 loadInterface :: SDoc -> ModuleName -> WhereFrom -> RnM d (Module, Ifaces)
100 loadInterface doc_str mod_name from
101 = getIfacesRn `thenRn` \ ifaces ->
103 mod_map = iImpModInfo ifaces
104 mod_info = lookupFM mod_map mod_name
105 in_map = maybeToBool mod_info
108 -- Issue a warning for a redundant {- SOURCE -} import
109 -- It's redundant if the moduld is in the iImpModInfo at all,
110 -- because we arrange to read all the ordinary imports before
111 -- any of the {- SOURCE -} imports
112 warnCheckRn (not (in_map && case from of {ImportByUserSource -> True; other -> False}))
113 (warnRedundantSourceImport mod_name) `thenRn_`
115 -- CHECK WHETHER WE HAVE IT ALREADY
117 Just (_, _, Just (load_mod, _, _))
118 -> -- We're read it already so don't re-read it
119 returnRn (load_mod, ifaces) ;
123 -- READ THE MODULE IN
124 findAndReadIface doc_str mod_name from in_map
125 `thenRn` \ (hi_boot_read, read_result) ->
126 case read_result of {
127 Nothing -> -- Not found, so add an empty export env to the Ifaces map
128 -- so that we don't look again
130 mod = mkVanillaModule mod_name
131 new_mod_map = addToFM mod_map mod_name (0, False, Just (mod, False, []))
132 new_ifaces = ifaces { iImpModInfo = new_mod_map }
134 setIfacesRn new_ifaces `thenRn_`
135 failWithRn (mod, new_ifaces) (noIfaceErr mod hi_boot_read) ;
140 -- LOAD IT INTO Ifaces
142 -- NB: *first* we do loadDecl, so that the provenance of all the locally-defined
143 --- names is done correctly (notably, whether this is an .hi file or .hi-boot file).
144 -- If we do loadExport first the wrong info gets into the cache (unless we
145 -- explicitly tag each export which seems a bit of a bore)
147 getModuleRn `thenRn` \ this_mod_nm ->
149 rd_decls = pi_decls iface
151 foldlRn (loadDecl mod) (iDecls ifaces) rd_decls `thenRn` \ new_decls ->
152 foldlRn (loadInstDecl mod) (iInsts ifaces) (pi_insts iface) `thenRn` \ new_insts ->
153 (if (opt_IgnoreIfacePragmas)
154 then returnRn emptyBag
155 else foldlRn (loadRule mod) (iRules ifaces) (pi_rules iface)) `thenRn` \ new_rules ->
156 foldlRn (loadFixDecl mod_name) (iFixes ifaces) rd_decls `thenRn` \ new_fixities ->
157 mapRn (loadExport this_mod_nm) (pi_exports iface) `thenRn` \ avails_s ->
159 -- For an explicit user import, add to mod_map info about
160 -- the things the imported module depends on, extracted
161 -- from its usage info.
162 mod_map1 = case from of
163 ImportByUser -> addModDeps mod mod_map (pi_usages iface)
166 -- Now add info about this module
167 mod_map2 = addToFM mod_map1 mod_name mod_details
168 mod_details = (pi_mod iface, pi_orphan iface, Just (mod, hi_boot_read, concat avails_s))
170 new_ifaces = ifaces { iImpModInfo = mod_map2,
172 iFixes = new_fixities,
176 setIfacesRn new_ifaces `thenRn_`
177 returnRn (mod, new_ifaces)
180 addModDeps :: Module -> ImportedModuleInfo
181 -> [ImportVersion a] -> ImportedModuleInfo
182 addModDeps mod mod_deps new_deps
183 = foldr add mod_deps new_deps
185 is_lib = isLibModule mod -- Don't record dependencies when importing a library module
186 add (imp_mod, version, has_orphans, _) deps
187 | is_lib && not has_orphans = deps
188 | otherwise = addToFM_C combine deps imp_mod (version, has_orphans, Nothing)
189 -- Record dependencies for modules that are
190 -- either are dependent via a non-library module
191 -- or contain orphan rules or instance decls
193 -- Don't ditch a module that's already loaded!!
194 combine old@(_, _, Just _) new = old
195 combine old@(_, _, Nothing) new = new
197 loadExport :: ModuleName -> ExportItem -> RnM d [AvailInfo]
198 loadExport this_mod (mod, entities)
199 | mod == this_mod = returnRn []
200 -- If the module exports anything defined in this module, just ignore it.
201 -- Reason: otherwise it looks as if there are two local definition sites
202 -- for the thing, and an error gets reported. Easiest thing is just to
203 -- filter them out up front. This situation only arises if a module
204 -- imports itself, or another module that imported it. (Necessarily,
205 -- this invoves a loop.) Consequence: if you say
210 -- module B( AType ) where
211 -- import {-# SOURCE #-} A( AType )
213 -- then you'll get a 'B does not export AType' message. A bit bogus
214 -- but it's a bogus thing to do!
217 = mapRn (load_entity mod) entities
219 new_name mod occ = mkImportedGlobalName mod occ
221 load_entity mod (Avail occ)
222 = new_name mod occ `thenRn` \ name ->
223 returnRn (Avail name)
224 load_entity mod (AvailTC occ occs)
225 = new_name mod occ `thenRn` \ name ->
226 mapRn (new_name mod) occs `thenRn` \ names ->
227 returnRn (AvailTC name names)
230 loadFixDecl :: ModuleName -> FixityEnv
231 -> (Version, RdrNameHsDecl)
233 loadFixDecl mod_name fixity_env (version, FixD sig@(FixitySig rdr_name fixity loc))
234 = -- Ignore the version; when the fixity changes the version of
235 -- its 'host' entity changes, so we don't need a separate version
236 -- number for fixities
237 mkImportedGlobalName mod_name (rdrNameOcc rdr_name) `thenRn` \ name ->
239 new_fixity_env = addToNameEnv fixity_env name (FixitySig name fixity loc)
241 returnRn new_fixity_env
243 -- Ignore the other sorts of decl
244 loadFixDecl mod_name fixity_env other_decl = returnRn fixity_env
248 -> (Version, RdrNameHsDecl)
251 loadDecl mod decls_map (version, decl)
252 = getDeclBinders new_name decl `thenRn` \ maybe_avail ->
253 case maybe_avail of {
254 Nothing -> returnRn decls_map; -- No bindings
257 getDeclSysBinders new_name decl `thenRn` \ sys_bndrs ->
259 main_name = availName avail
260 new_decls_map = foldl add_decl decls_map
261 [ (name, (version, avail, name==main_name, (mod, decl')))
262 | name <- sys_bndrs ++ availNames avail]
263 add_decl decls_map (name, stuff)
264 = WARN( name `elemNameEnv` decls_map, ppr name )
265 addToNameEnv decls_map name stuff
267 returnRn new_decls_map
270 -- newImportedBinder puts into the cache the binder with the
271 -- module information set correctly. When the decl is later renamed,
272 -- the binding site will thereby get the correct module.
273 new_name rdr_name loc = newImportedBinder mod rdr_name
276 If a signature decl is being loaded, and optIgnoreIfacePragmas is on,
277 we toss away unfolding information.
279 Also, if the signature is loaded from a module we're importing from source,
280 we do the same. This is to avoid situations when compiling a pair of mutually
281 recursive modules, peering at unfolding info in the interface file of the other,
282 e.g., you compile A, it looks at B's interface file and may as a result change
283 its interface file. Hence, B is recompiled, maybe changing its interface file,
284 which will the unfolding info used in A to become invalid. Simple way out is to
285 just ignore unfolding info.
287 [Jan 99: I junked the second test above. If we're importing from an hi-boot
288 file there isn't going to *be* any pragma info. Maybe the above comment
289 dates from a time where we picked up a .hi file first if it existed?]
292 SigD (IfaceSig name tp ls loc) | opt_IgnoreIfacePragmas
293 -> SigD (IfaceSig name tp [] loc)
296 loadInstDecl :: Module
299 -> RnM d (Bag GatedDecl)
300 loadInstDecl mod insts decl@(InstDecl inst_ty binds uprags dfun_name src_loc)
302 -- Find out what type constructors and classes are "gates" for the
303 -- instance declaration. If all these "gates" are slurped in then
304 -- we should slurp the instance decl too.
306 -- We *don't* want to count names in the context part as gates, though.
308 -- instance Foo a => Baz (T a) where ...
310 -- Here the gates are Baz and T, but *not* Foo.
312 munged_inst_ty = removeContext inst_ty
313 free_names = extractHsTyRdrNames munged_inst_ty
315 setModuleRn (moduleName mod) $
316 mapRn mkImportedGlobalFromRdrName free_names `thenRn` \ gate_names ->
317 returnRn ((mkNameSet gate_names, (mod, InstD decl)) `consBag` insts)
320 -- In interface files, the instance decls now look like
321 -- forall a. Foo a -> Baz (T a)
322 -- so we have to strip off function argument types as well
323 -- as the bit before the '=>' (which is always empty in interface files)
324 removeContext (HsForAllTy tvs cxt ty) = HsForAllTy tvs [] (removeFuns ty)
325 removeContext ty = removeFuns ty
327 removeFuns (MonoFunTy _ ty) = removeFuns ty
331 loadRule :: Module -> Bag GatedDecl
332 -> RdrNameRuleDecl -> RnM d (Bag GatedDecl)
333 -- "Gate" the rule simply by whether the rule variable is
334 -- needed. We can refine this later.
335 loadRule mod rules decl@(IfaceRuleDecl var body src_loc)
336 = setModuleRn (moduleName mod) $
337 mkImportedGlobalFromRdrName var `thenRn` \ var_name ->
338 returnRn ((unitNameSet var_name, (mod, RuleD decl)) `consBag` rules)
342 %********************************************************
344 \subsection{Loading usage information}
346 %********************************************************
349 checkUpToDate :: ModuleName -> RnMG Bool -- True <=> no need to recompile
350 checkUpToDate mod_name
351 = getIfacesRn `thenRn` \ ifaces ->
352 findAndReadIface doc_str mod_name
354 (error "checkUpToDate") `thenRn` \ (_, read_result) ->
356 -- CHECK WHETHER WE HAVE IT ALREADY
358 Nothing -> -- Old interface file not found, so we'd better bail out
359 traceRn (sep [ptext SLIT("Didnt find old iface"),
360 pprModuleName mod_name]) `thenRn_`
364 -> -- Found it, so now check it
365 checkModUsage (pi_usages iface)
367 -- Only look in current directory, with suffix .hi
368 doc_str = sep [ptext SLIT("need usage info from"), pprModuleName mod_name]
370 checkModUsage [] = returnRn True -- Yes! Everything is up to date!
372 checkModUsage ((mod_name, old_mod_vers, _, Specifically []) : rest)
373 -- If CurrentModule.hi contains
375 -- then that simply records that Foo lies below CurrentModule in the
376 -- hierarchy, but CurrentModule doesn't depend in any way on Foo.
377 -- In this case we don't even want to open Foo's interface.
378 = traceRn (ptext SLIT("Nothing used from:") <+> ppr mod_name) `thenRn_`
379 checkModUsage rest -- This one's ok, so check the rest
381 checkModUsage ((mod_name, old_mod_vers, _, whats_imported) : rest)
382 = loadInterface doc_str mod_name ImportBySystem `thenRn` \ (mod, ifaces) ->
384 maybe_mod_vers = case lookupFM (iImpModInfo ifaces) mod_name of
385 Just (version, _, Just (_, _, _)) -> Just version
388 case maybe_mod_vers of {
389 Nothing -> -- If we can't find a version number for the old module then
390 -- bail out saying things aren't up to date
391 traceRn (sep [ptext SLIT("Can't find version number for module"),
392 pprModuleName mod_name])
393 `thenRn_` returnRn False ;
397 -- If the module version hasn't changed, just move on
398 if new_mod_vers == old_mod_vers then
399 traceRn (sep [ptext SLIT("Module version unchanged:"), pprModuleName mod_name])
400 `thenRn_` checkModUsage rest
402 traceRn (sep [ptext SLIT("Module version has changed:"), pprModuleName mod_name])
404 -- Module version changed, so check entities inside
406 -- If the usage info wants to say "I imported everything from this module"
407 -- it does so by making whats_imported equal to Everything
408 -- In that case, we must recompile
409 case whats_imported of {
410 Everything -> traceRn (ptext SLIT("...and I needed the whole module")) `thenRn_`
411 returnRn False; -- Bale out
413 Specifically old_local_vers ->
415 -- Non-empty usage list, so check item by item
416 checkEntityUsage mod_name (iDecls ifaces) old_local_vers `thenRn` \ up_to_date ->
418 traceRn (ptext SLIT("...but the bits I use haven't.")) `thenRn_`
419 checkModUsage rest -- This one's ok, so check the rest
421 returnRn False -- This one failed, so just bail out now
424 doc_str = sep [ptext SLIT("need version info for"), pprModuleName mod_name]
427 checkEntityUsage mod decls []
428 = returnRn True -- Yes! All up to date!
430 checkEntityUsage mod decls ((occ_name,old_vers) : rest)
431 = mkImportedGlobalName mod occ_name `thenRn` \ name ->
432 case lookupNameEnv decls name of
434 Nothing -> -- We used it before, but it ain't there now
435 traceRn (sep [ptext SLIT("No longer exported:"), ppr name])
436 `thenRn_` returnRn False
438 Just (new_vers,_,_,_) -- It's there, but is it up to date?
439 | new_vers == old_vers
440 -- Up to date, so check the rest
441 -> checkEntityUsage mod decls rest
444 -- Out of date, so bale out
445 -> traceRn (sep [ptext SLIT("Out of date:"), ppr name]) `thenRn_`
450 %*********************************************************
452 \subsection{Getting in a declaration}
454 %*********************************************************
457 importDecl :: Name -> RnMG (Maybe (Module, RdrNameHsDecl))
458 -- Returns Nothing for
461 -- (c) already slurped
467 = getSlurped `thenRn` \ already_slurped ->
468 if name `elemNameSet` already_slurped then
469 returnRn Nothing -- Already dealt with
471 if isLocallyDefined name then -- Don't bring in decls from
472 -- the renamed module's own interface file
473 addWarnRn (importDeclWarn name) `thenRn_`
476 getNonWiredInDecl name
480 getNonWiredInDecl :: Name -> RnMG (Maybe (Module, RdrNameHsDecl))
481 getNonWiredInDecl needed_name
482 = traceRn doc_str `thenRn_`
483 loadHomeInterface doc_str needed_name `thenRn` \ ifaces ->
484 case lookupNameEnv (iDecls ifaces) needed_name of
486 Just (version,avail,_,decl)
487 -> recordSlurp (Just version) avail `thenRn_`
490 Nothing -- Can happen legitimately for "Optional" occurrences
491 -> addErrRn (getDeclErr needed_name) `thenRn_`
494 doc_str = ptext SLIT("need decl for") <+> ppr needed_name
497 @getWiredInDecl@ maps a wired-in @Name@ to what it makes available.
498 It behaves exactly as if the wired in decl were actually in an interface file.
501 \item if the wired-in name is a data type constructor or a data constructor,
502 it brings in the type constructor and all the data constructors; and
503 marks as ``occurrences'' any free vars of the data con.
505 \item similarly for synonum type constructor
507 \item if the wired-in name is another wired-in Id, it marks as ``occurrences''
508 the free vars of the Id's type.
510 \item it loads the interface file for the wired-in thing for the
511 sole purpose of making sure that its instance declarations are available
513 All this is necessary so that we know all types that are ``in play'', so
514 that we know just what instances to bring into scope.
519 %*********************************************************
521 \subsection{Getting what a module exports}
523 %*********************************************************
525 @getInterfaceExports@ is called only for directly-imported modules.
528 getInterfaceExports :: ModuleName -> WhereFrom -> RnMG (Module, Avails)
529 getInterfaceExports mod_name from
530 = loadInterface doc_str mod_name from `thenRn` \ (mod, ifaces) ->
531 case lookupFM (iImpModInfo ifaces) mod_name of
532 Nothing -> -- Not there; it must be that the interface file wasn't found;
533 -- the error will have been reported already.
534 -- (Actually loadInterface should put the empty export env in there
535 -- anyway, but this does no harm.)
538 Just (_, _, Just (mod, _, avails)) -> returnRn (mod, avails)
540 doc_str = sep [pprModuleName mod_name, ptext SLIT("is directly imported")]
544 %*********************************************************
546 \subsection{Instance declarations are handled specially}
548 %*********************************************************
551 getImportedInstDecls :: NameSet -> RnMG [(Module,RdrNameHsDecl)]
552 getImportedInstDecls gates
553 = -- First, load any orphan-instance modules that aren't aready loaded
554 -- Orphan-instance modules are recorded in the module dependecnies
555 getIfacesRn `thenRn` \ ifaces ->
558 [mod | (mod, (_, True, Nothing)) <- fmToList (iImpModInfo ifaces)]
560 loadOrphanModules orphan_mods `thenRn_`
562 -- Now we're ready to grab the instance declarations
563 -- Find the un-gated ones and return them,
564 -- removing them from the bag kept in Ifaces
565 getIfacesRn `thenRn` \ ifaces ->
567 (decls, new_insts) = selectGated gates (iInsts ifaces)
569 setIfacesRn (ifaces { iInsts = new_insts }) `thenRn_`
571 traceRn (sep [text "getImportedInstDecls:",
572 nest 4 (fsep (map ppr gate_list)),
573 text "Slurped" <+> int (length decls) <+> text "instance declarations",
574 nest 4 (vcat (map ppr_brief_inst_decl decls))]) `thenRn_`
577 gate_list = nameSetToList gates
579 load_home gate | isLocallyDefined gate
582 = loadHomeInterface (ppr gate <+> text "is an instance gate") gate `thenRn_`
585 ppr_brief_inst_decl (mod, InstD (InstDecl inst_ty _ _ _ _))
587 HsForAllTy _ _ tau -> ppr tau
590 getImportedRules :: RnMG [(Module,RdrNameHsDecl)]
592 | opt_IgnoreIfacePragmas = returnRn []
594 = getIfacesRn `thenRn` \ ifaces ->
596 gates = iSlurp ifaces -- Anything at all that's been slurped
597 (decls, new_rules) = selectGated gates (iRules ifaces)
599 setIfacesRn (ifaces { iRules = new_rules }) `thenRn_`
600 traceRn (sep [text "getImportedRules:",
601 text "Slurped" <+> int (length decls) <+> text "rules"]) `thenRn_`
604 selectGated gates decl_bag
605 -- Select only those decls whose gates are *all* in 'gates'
607 | opt_NoPruneDecls -- Just to try the effect of not gating at all
608 = (foldrBag (\ (_,d) ds -> d:ds) [] decl_bag, emptyBag) -- Grab them all
612 = foldrBag select ([], emptyBag) decl_bag
614 select (reqd, decl) (yes, no)
615 | isEmptyNameSet (reqd `minusNameSet` gates) = (decl:yes, no)
616 | otherwise = (yes, (reqd,decl) `consBag` no)
618 lookupFixity :: Name -> RnMS Fixity
620 | isLocallyDefined name
621 = getFixityEnv `thenRn` \ local_fix_env ->
622 case lookupNameEnv local_fix_env name of
623 Just (FixitySig _ fix _) -> returnRn fix
624 Nothing -> returnRn defaultFixity
626 | otherwise -- Imported
627 = loadHomeInterface doc name `thenRn` \ ifaces ->
628 case lookupNameEnv (iFixes ifaces) name of
629 Just (FixitySig _ fix _) -> returnRn fix
630 Nothing -> returnRn defaultFixity
632 doc = ptext SLIT("Checking fixity for") <+> ppr name
636 %*********************************************************
638 \subsection{Keeping track of what we've slurped, and version numbers}
640 %*********************************************************
642 getImportVersions figures out what the ``usage information'' for this
643 moudule is; that is, what it must record in its interface file as the
644 things it uses. It records:
647 \item anything reachable from its body code
648 \item any module exported with a @module Foo@.
651 Why the latter? Because if @Foo@ changes then this module's export list
652 will change, so we must recompile this module at least as far as
653 making a new interface file --- but in practice that means complete
658 module A( f, g ) where | module B( f ) where
659 import B( f ) | f = h 3
663 Should we record @B.f@ in @A@'s usages? In fact we don't. Certainly,
664 if anything about @B.f@ changes than anyone who imports @A@ should be
665 recompiled; they'll get an early exit if they don't use @B.f@.
666 However, even if @B.f@ doesn't change at all, @B.h@ may do so, and
667 this change may not be reflected in @f@'s version number. So there
668 are two things going on when compiling module @A@:
671 \item Are @A.o@ and @A.hi@ correct? Then we can bale out early.
672 \item Should modules that import @A@ be recompiled?
675 For (1) it is slightly harmful to record @B.f@ in @A@'s usages,
676 because a change in @B.f@'s version will provoke full recompilation of
677 @A@, producing an identical @A.o@, and @A.hi@ differing only in its
678 usage-version of @B.f@ (and this usage-version info isn't used by any
681 For (2), because of the tricky @B.h@ question above, we ensure that
682 @A.hi@ is touched (even if identical to its previous version) if A's
683 recompilation was triggered by an imported @.hi@ file date change.
684 Given that, there's no need to record @B.f@ in @A@'s usages.
686 On the other hand, if @A@ exports @module B@, then we {\em do} count
687 @module B@ among @A@'s usages, because we must recompile @A@ to ensure
688 that @A.hi@ changes appropriately.
690 HOWEVER, we *do* record the usage
692 in A.hi, to record the fact that A does import B. This is used to decide
693 to look to look for B.hi rather than B.hi-boot when compiling a module that
694 imports A. This line says that A imports B, but uses nothing in it.
695 So we'll get an early bale-out when compiling A if B's version changes.
698 getImportVersions :: ModuleName -- Name of this module
699 -> ExportEnv -- Info about exports
700 -> RnMG (VersionInfo Name) -- Version info for these names
702 getImportVersions this_mod (ExportEnv export_avails _ export_all_mods)
703 = getIfacesRn `thenRn` \ ifaces ->
705 mod_map = iImpModInfo ifaces
706 imp_names = iVSlurp ifaces
708 -- mv_map groups together all the things imported from a particular module.
709 mv_map :: FiniteMap ModuleName [(Name,Version)]
710 mv_map = foldr add_mv emptyFM imp_names
712 -- Build the result list by adding info for each module.
713 -- For (a) a library module, we don't record it at all unless it contains orphans
714 -- (We must never lose track of orphans.)
716 -- (b) a source-imported module, don't record the dependency at all
718 -- (b) may seem a bit strange. The idea is that the usages in a .hi file records
719 -- *all* the module's dependencies other than the loop-breakers. We use
720 -- this info in findAndReadInterface to decide whether to look for a .hi file or
723 -- This means we won't track version changes, or orphans, from .hi-boot files.
724 -- The former is potentially rather bad news. It could be fixed by recording
725 -- whether something is a boot file along with the usage info for it, but
726 -- I can't be bothered just now.
728 mk_version_info mod_name (version, has_orphans, contents) so_far
730 go_for_it exports = (mod_name, version, has_orphans, exports) : so_far
733 Nothing -> -- We didn't even open the interface
734 -- This happens when a module, Foo, that we explicitly imported has
735 -- 'import Baz' in its interface file, recording that Baz is below
736 -- Foo in the module dependency hierarchy. We want to propagate this
737 -- information. The Nothing says that we didn't even open the interface
738 -- file but we must still propagate the dependeny info.
739 go_for_it (Specifically [])
741 Just (mod, boot_import, _) -- We did open the interface
742 | boot_import -- Don't record any usage info for this module
743 || (is_lib_module && not has_orphans)
746 | is_lib_module -- Record the module but not detailed
747 || mod_name `elem` export_all_mods -- version information for the imports
748 -> go_for_it Everything
751 -> case lookupFM mv_map mod_name of
752 Just whats_imported -> go_for_it (Specifically whats_imported)
753 Nothing -> go_for_it (Specifically [])
754 -- This happens if you have
756 -- but don't actually *use* anything from Foo
757 -- In which case record an empty dependency list
759 is_lib_module = isLibModule mod
762 -- A module shouldn't load its own interface
763 -- This seems like a convenient place to check
764 WARN( maybeToBool (lookupFM mod_map this_mod),
765 ptext SLIT("Wierd:") <+> ppr this_mod <+> ptext SLIT("loads its own interface") )
767 returnRn (foldFM mk_version_info [] mod_map)
769 add_mv v@(name, version) mv_map
770 = addToFM_C add_item mv_map mod [v]
772 mod = moduleName (nameModule name)
773 add_item vs _ = (v:vs)
778 = getIfacesRn `thenRn` \ ifaces ->
779 returnRn (iSlurp ifaces)
781 recordSlurp maybe_version avail
782 = getIfacesRn `thenRn` \ ifaces@(Ifaces { iSlurp = slurped_names,
783 iVSlurp = imp_names }) ->
785 new_slurped_names = addAvailToNameSet slurped_names avail
787 new_imp_names = case maybe_version of
788 Just version -> (availName avail, version) : imp_names
791 setIfacesRn (ifaces { iSlurp = new_slurped_names,
792 iVSlurp = new_imp_names })
796 %*********************************************************
798 \subsection{Getting binders out of a declaration}
800 %*********************************************************
802 @getDeclBinders@ returns the names for a @RdrNameHsDecl@.
803 It's used for both source code (from @availsFromDecl@) and interface files
806 It doesn't deal with source-code specific things: @ValD@, @DefD@. They
807 are handled by the sourc-code specific stuff in @RnNames@.
810 getDeclBinders :: (RdrName -> SrcLoc -> RnM d Name) -- New-name function
812 -> RnM d (Maybe AvailInfo)
814 getDeclBinders new_name (TyClD (TyData _ _ tycon _ condecls _ _ src_loc))
815 = new_name tycon src_loc `thenRn` \ tycon_name ->
816 getConFieldNames new_name condecls `thenRn` \ sub_names ->
817 returnRn (Just (AvailTC tycon_name (tycon_name : nub sub_names)))
818 -- The "nub" is because getConFieldNames can legitimately return duplicates,
819 -- when a record declaration has the same field in multiple constructors
821 getDeclBinders new_name (TyClD (TySynonym tycon _ _ src_loc))
822 = new_name tycon src_loc `thenRn` \ tycon_name ->
823 returnRn (Just (AvailTC tycon_name [tycon_name]))
825 getDeclBinders new_name (TyClD (ClassDecl _ cname _ _ sigs _ _ _ _ _ src_loc))
826 = new_name cname src_loc `thenRn` \ class_name ->
828 -- Record the names for the class ops
830 -- just want class-op sigs
831 op_sigs = filter isClassOpSig sigs
833 mapRn (getClassOpNames new_name) op_sigs `thenRn` \ sub_names ->
835 returnRn (Just (AvailTC class_name (class_name : sub_names)))
837 getDeclBinders new_name (SigD (IfaceSig var ty prags src_loc))
838 = new_name var src_loc `thenRn` \ var_name ->
839 returnRn (Just (Avail var_name))
841 getDeclBinders new_name (FixD _) = returnRn Nothing
843 -- foreign declarations
844 getDeclBinders new_name (ForD (ForeignDecl nm kind _ dyn _ loc))
845 | binds_haskell_name kind dyn
846 = new_name nm loc `thenRn` \ name ->
847 returnRn (Just (Avail name))
849 | otherwise -- a foreign export
850 = lookupImplicitOccRn nm `thenRn_`
853 getDeclBinders new_name (DefD _) = returnRn Nothing
854 getDeclBinders new_name (InstD _) = returnRn Nothing
855 getDeclBinders new_name (RuleD _) = returnRn Nothing
857 binds_haskell_name (FoImport _) _ = True
858 binds_haskell_name FoLabel _ = True
859 binds_haskell_name FoExport ext_nm = isDynamic ext_nm
862 getConFieldNames new_name (ConDecl con _ _ (RecCon fielddecls) src_loc : rest)
863 = mapRn (\n -> new_name n src_loc) (con:fields) `thenRn` \ cfs ->
864 getConFieldNames new_name rest `thenRn` \ ns ->
867 fields = concat (map fst fielddecls)
869 getConFieldNames new_name (ConDecl con _ _ condecl src_loc : rest)
870 = new_name con src_loc `thenRn` \ n ->
873 new_name f src_loc `thenRn` \ new_f ->
875 _ -> returnRn [n]) `thenRn` \ nn ->
876 getConFieldNames new_name rest `thenRn` \ ns ->
879 getConFieldNames new_name [] = returnRn []
881 getClassOpNames new_name (ClassOpSig op _ _ _ src_loc) = new_name op src_loc
884 @getDeclSysBinders@ gets the implicit binders introduced by a decl.
885 A the moment that's just the tycon and datacon that come with a class decl.
886 They aren't returned by @getDeclBinders@ because they aren't in scope;
887 but they {\em should} be put into the @DeclsMap@ of this module.
889 Note that this excludes the default-method names of a class decl,
890 and the dict fun of an instance decl, because both of these have
891 bindings of their own elsewhere.
894 getDeclSysBinders new_name (TyClD (ClassDecl _ cname _ _ sigs _ _ tname dname snames src_loc))
895 = new_name dname src_loc `thenRn` \ datacon_name ->
896 new_name tname src_loc `thenRn` \ tycon_name ->
897 sequenceRn [new_name n src_loc | n <- snames] `thenRn` \ scsel_names ->
898 returnRn (tycon_name : datacon_name : scsel_names)
900 getDeclSysBinders new_name other_decl
904 %*********************************************************
906 \subsection{Reading an interface file}
908 %*********************************************************
911 findAndReadIface :: SDoc -> ModuleName -> WhereFrom
912 -> Bool -- Only relevant for SystemImport
913 -- True <=> Look for a .hi file
914 -- False <=> Look for .hi-boot file unless there's
915 -- a library .hi file
916 -> RnM d (Bool, Maybe (Module, ParsedIface))
917 -- Bool is True if the interface actually read was a .hi-boot one
918 -- Nothing <=> file not found, or unreadable, or illegible
919 -- Just x <=> successfully found and parsed
921 findAndReadIface doc_str mod_name from hi_file
922 = traceRn trace_msg `thenRn_`
923 -- we keep two maps for interface files,
924 -- one for 'normal' ones, the other for .hi-boot files,
925 -- hence the need to signal which kind we're interested.
927 getHiMaps `thenRn` \ hi_maps ->
929 case find_path from hi_maps of
931 (hi_boot, Just (fpath, mod)) -> traceRn (ptext SLIT("...reading from") <+> text fpath)
933 readIface mod fpath `thenRn` \ result ->
934 returnRn (hi_boot, result)
935 (hi_boot, Nothing) -> traceRn (ptext SLIT("...not found")) `thenRn_`
936 returnRn (hi_boot, Nothing)
938 find_path ImportByUser (hi_map, _) = (False, lookupFM hi_map mod_name)
939 find_path ImportByUserSource (_, hiboot_map) = (True, lookupFM hiboot_map mod_name)
941 find_path ImportBySystem (hi_map, hiboot_map)
943 = -- If the module we seek is in our dependent set,
944 -- Look for a .hi file
945 (False, lookupFM hi_map mod_name)
948 -- Check if there's a library module of that name
949 -- If not, look for an hi-boot file
950 = case lookupFM hi_map mod_name of
951 stuff@(Just (_, mod)) | isLibModule mod -> (False, stuff)
952 other -> (True, lookupFM hiboot_map mod_name)
954 trace_msg = sep [hsep [ptext SLIT("Reading"),
956 ptext SLIT("interface for"),
957 pprModuleName mod_name <> semi],
958 nest 4 (ptext SLIT("reason:") <+> doc_str)]
961 @readIface@ tries just the one file.
964 readIface :: Module -> String -> RnM d (Maybe (Module, ParsedIface))
965 -- Nothing <=> file not found, or unreadable, or illegible
966 -- Just x <=> successfully found and parsed
967 readIface the_mod file_path
968 = ioToRnM (hGetStringBuffer False file_path) `thenRn` \ read_result ->
971 case parseIface contents
972 PState{ bol = 0#, atbol = 1#,
975 loc = mkSrcLoc (mkFastString file_path) 1 } of
976 PFailed err -> failWithRn Nothing err
977 POk _ (PIface mod_nm iface) ->
978 warnCheckRn (mod_nm == moduleName the_mod)
979 (hiModuleNameMismatchWarn the_mod mod_nm) `thenRn_`
980 returnRn (Just (the_mod, iface))
983 | isDoesNotExistError err -> returnRn Nothing
984 | otherwise -> failWithRn Nothing (cannaeReadFile file_path err)
987 %*********************************************************
991 %*********************************************************
994 noIfaceErr filename boot_file
995 = hsep [ptext SLIT("Could not find valid"), boot,
996 ptext SLIT("interface file"), quotes (pprModule filename)]
998 boot | boot_file = ptext SLIT("[boot]")
1001 cannaeReadFile file err
1002 = hcat [ptext SLIT("Failed in reading file: "),
1004 ptext SLIT("; error="),
1008 = ptext SLIT("Failed to find interface decl for") <+> quotes (ppr name)
1010 getDeclWarn name loc
1011 = sep [ptext SLIT("Failed to find (optional) interface decl for") <+> quotes (ppr name),
1012 ptext SLIT("desired at") <+> ppr loc]
1016 "Compiler tried to import decl from interface file with same name as module."),
1018 "(possible cause: module name clashes with interface file already in scope.)")
1020 hsep [ptext SLIT("name:"), quotes (ppr name)]
1022 warnRedundantSourceImport mod_name
1023 = ptext SLIT("Unnecessary {- SOURCE -} in the import of module")
1024 <+> quotes (pprModuleName mod_name)
1026 hiModuleNameMismatchWarn :: Module -> ModuleName -> Message
1027 hiModuleNameMismatchWarn requested_mod mod_nm =
1028 hsep [ ptext SLIT("Something is amiss; requested module name")
1029 , pprModule requested_mod
1030 , ptext SLIT("differs from name found in the interface file ")
1031 , pprModuleName mod_nm