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,
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 )
72 import IO ( isDoesNotExistError )
77 %*********************************************************
79 \subsection{Loading a new interface file}
81 %*********************************************************
84 loadHomeInterface :: SDoc -> Name -> RnM d Ifaces
85 loadHomeInterface doc_str name
86 = loadInterface doc_str (moduleName (nameModule name)) ImportBySystem `thenRn` \ (_, ifaces) ->
89 loadOrphanModules :: [ModuleName] -> RnM d ()
90 loadOrphanModules mods
91 | null mods = returnRn ()
92 | otherwise = traceRn (text "Loading orphan modules:" <+> fsep (map pprModuleName mods)) `thenRn_`
93 mapRn_ load mods `thenRn_`
96 load mod = loadInterface (pprModuleName mod <+> ptext SLIT("is a orphan-instance module")) mod ImportBySystem
98 loadInterface :: SDoc -> ModuleName -> WhereFrom -> RnM d (Module, Ifaces)
99 loadInterface doc_str mod_name from
100 = getIfacesRn `thenRn` \ ifaces ->
102 mod_map = iImpModInfo ifaces
103 mod_info = lookupFM mod_map mod_name
104 in_map = maybeToBool mod_info
107 -- Issue a warning for a redundant {- SOURCE -} import
108 -- It's redundant if the moduld is in the iImpModInfo at all,
109 -- because we arrange to read all the ordinary imports before
110 -- any of the {- SOURCE -} imports
111 warnCheckRn (not (in_map && case from of {ImportByUserSource -> True; other -> False}))
112 (warnRedundantSourceImport mod_name) `thenRn_`
114 -- CHECK WHETHER WE HAVE IT ALREADY
116 Just (_, _, Just (load_mod, _, _))
117 -> -- We're read it already so don't re-read it
118 returnRn (load_mod, ifaces) ;
122 -- READ THE MODULE IN
123 findAndReadIface doc_str mod_name from in_map
124 `thenRn` \ (hi_boot_read, read_result) ->
125 case read_result of {
126 Nothing -> -- Not found, so add an empty export env to the Ifaces map
127 -- so that we don't look again
129 mod = mkVanillaModule mod_name
130 new_mod_map = addToFM mod_map mod_name (0, False, Just (mod, False, []))
131 new_ifaces = ifaces { iImpModInfo = new_mod_map }
133 setIfacesRn new_ifaces `thenRn_`
134 failWithRn (mod, new_ifaces) (noIfaceErr mod hi_boot_read) ;
139 -- LOAD IT INTO Ifaces
141 -- NB: *first* we do loadDecl, so that the provenance of all the locally-defined
142 --- names is done correctly (notably, whether this is an .hi file or .hi-boot file).
143 -- If we do loadExport first the wrong info gets into the cache (unless we
144 -- explicitly tag each export which seems a bit of a bore)
146 getModuleRn `thenRn` \ this_mod_nm ->
148 rd_decls = pi_decls iface
150 foldlRn (loadDecl mod) (iDecls ifaces) rd_decls `thenRn` \ new_decls ->
151 foldlRn (loadInstDecl mod) (iInsts ifaces) (pi_insts iface) `thenRn` \ new_insts ->
152 foldlRn (loadRule mod) (iRules ifaces) (pi_rules iface) `thenRn` \ new_rules ->
153 foldlRn (loadFixDecl mod_name) (iFixes ifaces) rd_decls `thenRn` \ new_fixities ->
154 mapRn (loadExport this_mod_nm) (pi_exports iface) `thenRn` \ avails_s ->
156 -- For an explicit user import, add to mod_map info about
157 -- the things the imported module depends on, extracted
158 -- from its usage info.
159 mod_map1 = case from of
160 ImportByUser -> addModDeps mod mod_map (pi_usages iface)
163 -- Now add info about this module
164 mod_map2 = addToFM mod_map1 mod_name mod_details
165 mod_details = (pi_mod iface, pi_orphan iface, Just (mod, hi_boot_read, concat avails_s))
167 new_ifaces = ifaces { iImpModInfo = mod_map2,
169 iFixes = new_fixities,
173 setIfacesRn new_ifaces `thenRn_`
174 returnRn (mod, new_ifaces)
177 addModDeps :: Module -> ImportedModuleInfo
178 -> [ImportVersion a] -> ImportedModuleInfo
179 addModDeps mod mod_deps new_deps
180 = foldr add mod_deps new_deps
182 is_lib = isLibModule mod -- Don't record dependencies when importing a library module
183 add (imp_mod, version, has_orphans, _) deps
184 | is_lib && not has_orphans = deps
185 | otherwise = addToFM_C combine deps imp_mod (version, has_orphans, Nothing)
186 -- Record dependencies for modules that are
187 -- either are dependent via a non-library module
188 -- or contain orphan rules or instance decls
190 -- Don't ditch a module that's already loaded!!
191 combine old@(_, _, Just _) new = old
192 combine old@(_, _, Nothing) new = new
194 loadExport :: ModuleName -> ExportItem -> RnM d [AvailInfo]
195 loadExport this_mod (mod, entities)
196 | mod == this_mod = returnRn []
197 -- If the module exports anything defined in this module, just ignore it.
198 -- Reason: otherwise it looks as if there are two local definition sites
199 -- for the thing, and an error gets reported. Easiest thing is just to
200 -- filter them out up front. This situation only arises if a module
201 -- imports itself, or another module that imported it. (Necessarily,
202 -- this invoves a loop.) Consequence: if you say
207 -- module B( AType ) where
208 -- import {-# SOURCE #-} A( AType )
210 -- then you'll get a 'B does not export AType' message. A bit bogus
211 -- but it's a bogus thing to do!
214 = mapRn (load_entity mod) entities
216 new_name mod occ = mkImportedGlobalName mod occ
218 load_entity mod (Avail occ)
219 = new_name mod occ `thenRn` \ name ->
220 returnRn (Avail name)
221 load_entity mod (AvailTC occ occs)
222 = new_name mod occ `thenRn` \ name ->
223 mapRn (new_name mod) occs `thenRn` \ names ->
224 returnRn (AvailTC name names)
227 loadFixDecl :: ModuleName -> FixityEnv
228 -> (Version, RdrNameHsDecl)
230 loadFixDecl mod_name fixity_env (version, FixD sig@(FixitySig rdr_name fixity loc))
231 = -- Ignore the version; when the fixity changes the version of
232 -- its 'host' entity changes, so we don't need a separate version
233 -- number for fixities
234 mkImportedGlobalName mod_name (rdrNameOcc rdr_name) `thenRn` \ name ->
236 new_fixity_env = addToNameEnv fixity_env name (FixitySig name fixity loc)
238 returnRn new_fixity_env
240 -- Ignore the other sorts of decl
241 loadFixDecl mod_name fixity_env other_decl = returnRn fixity_env
245 -> (Version, RdrNameHsDecl)
248 loadDecl mod decls_map (version, decl)
249 = getDeclBinders new_name decl `thenRn` \ maybe_avail ->
250 case maybe_avail of {
251 Nothing -> returnRn decls_map; -- No bindings
254 getDeclSysBinders new_name decl `thenRn` \ sys_bndrs ->
256 main_name = availName avail
257 new_decls_map = foldl add_decl decls_map
258 [ (name, (version, avail, name==main_name, (mod, decl')))
259 | name <- sys_bndrs ++ availNames avail]
260 add_decl decls_map (name, stuff)
261 = WARN( name `elemNameEnv` decls_map, ppr name )
262 addToNameEnv decls_map name stuff
264 returnRn new_decls_map
267 -- newImportedBinder puts into the cache the binder with the
268 -- module information set correctly. When the decl is later renamed,
269 -- the binding site will thereby get the correct module.
270 new_name rdr_name loc = newImportedBinder mod rdr_name
273 If a signature decl is being loaded, and optIgnoreIfacePragmas is on,
274 we toss away unfolding information.
276 Also, if the signature is loaded from a module we're importing from source,
277 we do the same. This is to avoid situations when compiling a pair of mutually
278 recursive modules, peering at unfolding info in the interface file of the other,
279 e.g., you compile A, it looks at B's interface file and may as a result change
280 its interface file. Hence, B is recompiled, maybe changing its interface file,
281 which will the unfolding info used in A to become invalid. Simple way out is to
282 just ignore unfolding info.
284 [Jan 99: I junked the second test above. If we're importing from an hi-boot
285 file there isn't going to *be* any pragma info. Maybe the above comment
286 dates from a time where we picked up a .hi file first if it existed?]
289 SigD (IfaceSig name tp ls loc) | opt_IgnoreIfacePragmas
290 -> SigD (IfaceSig name tp [] loc)
293 loadInstDecl :: Module
296 -> RnM d (Bag GatedDecl)
297 loadInstDecl mod insts decl@(InstDecl inst_ty binds uprags dfun_name src_loc)
299 -- Find out what type constructors and classes are "gates" for the
300 -- instance declaration. If all these "gates" are slurped in then
301 -- we should slurp the instance decl too.
303 -- We *don't* want to count names in the context part as gates, though.
305 -- instance Foo a => Baz (T a) where ...
307 -- Here the gates are Baz and T, but *not* Foo.
309 munged_inst_ty = removeContext inst_ty
310 free_names = extractHsTyRdrNames munged_inst_ty
312 setModuleRn (moduleName mod) $
313 mapRn mkImportedGlobalFromRdrName free_names `thenRn` \ gate_names ->
314 returnRn ((mkNameSet gate_names, (mod, InstD decl)) `consBag` insts)
317 -- In interface files, the instance decls now look like
318 -- forall a. Foo a -> Baz (T a)
319 -- so we have to strip off function argument types as well
320 -- as the bit before the '=>' (which is always empty in interface files)
321 removeContext (HsForAllTy tvs cxt ty) = HsForAllTy tvs [] (removeFuns ty)
322 removeContext ty = removeFuns ty
324 removeFuns (MonoFunTy _ ty) = removeFuns ty
328 loadRule :: Module -> Bag GatedDecl
329 -> RdrNameRuleDecl -> RnM d (Bag GatedDecl)
330 -- "Gate" the rule simply by whether the rule variable is
331 -- needed. We can refine this later.
332 loadRule mod rules decl@(IfaceRuleDecl var body src_loc)
333 = setModuleRn (moduleName mod) $
334 mkImportedGlobalFromRdrName var `thenRn` \ var_name ->
335 returnRn ((unitNameSet var_name, (mod, RuleD decl)) `consBag` rules)
339 %********************************************************
341 \subsection{Loading usage information}
343 %********************************************************
346 checkUpToDate :: ModuleName -> RnMG Bool -- True <=> no need to recompile
347 checkUpToDate mod_name
348 = getIfacesRn `thenRn` \ ifaces ->
349 findAndReadIface doc_str mod_name
351 (error "checkUpToDate") `thenRn` \ (_, read_result) ->
353 -- CHECK WHETHER WE HAVE IT ALREADY
355 Nothing -> -- Old interface file not found, so we'd better bail out
356 traceRn (sep [ptext SLIT("Didnt find old iface"),
357 pprModuleName mod_name]) `thenRn_`
361 -> -- Found it, so now check it
362 checkModUsage (pi_usages iface)
364 -- Only look in current directory, with suffix .hi
365 doc_str = sep [ptext SLIT("need usage info from"), pprModuleName mod_name]
367 checkModUsage [] = returnRn True -- Yes! Everything is up to date!
369 checkModUsage ((mod_name, old_mod_vers, _, whats_imported) : rest)
370 = loadInterface doc_str mod_name ImportBySystem `thenRn` \ (mod, ifaces) ->
372 maybe_mod_vers = case lookupFM (iImpModInfo ifaces) mod_name of
373 Just (version, _, Just (_, _, _)) -> Just version
376 case maybe_mod_vers of {
377 Nothing -> -- If we can't find a version number for the old module then
378 -- bail out saying things aren't up to date
379 traceRn (sep [ptext SLIT("Can't find version number for module"),
380 pprModuleName mod_name])
381 `thenRn_` returnRn False ;
385 -- If the module version hasn't changed, just move on
386 if new_mod_vers == old_mod_vers then
387 traceRn (sep [ptext SLIT("Module version unchanged:"), pprModuleName mod_name])
388 `thenRn_` checkModUsage rest
390 traceRn (sep [ptext SLIT("Module version has changed:"), pprModuleName mod_name])
392 -- Module version changed, so check entities inside
394 -- If the usage info wants to say "I imported everything from this module"
395 -- it does so by making whats_imported equal to Everything
396 -- In that case, we must recompile
397 case whats_imported of {
398 Everything -> traceRn (ptext SLIT("...and I needed the whole module")) `thenRn_`
399 returnRn False; -- Bale out
401 Specifically old_local_vers ->
403 -- Non-empty usage list, so check item by item
404 checkEntityUsage mod_name (iDecls ifaces) old_local_vers `thenRn` \ up_to_date ->
406 traceRn (ptext SLIT("...but the bits I use haven't.")) `thenRn_`
407 checkModUsage rest -- This one's ok, so check the rest
409 returnRn False -- This one failed, so just bail out now
412 doc_str = sep [ptext SLIT("need version info for"), pprModuleName mod_name]
415 checkEntityUsage mod decls []
416 = returnRn True -- Yes! All up to date!
418 checkEntityUsage mod decls ((occ_name,old_vers) : rest)
419 = mkImportedGlobalName mod occ_name `thenRn` \ name ->
420 case lookupNameEnv decls name of
422 Nothing -> -- We used it before, but it ain't there now
423 putDocRn (sep [ptext SLIT("No longer exported:"), ppr name])
424 `thenRn_` returnRn False
426 Just (new_vers,_,_,_) -- It's there, but is it up to date?
427 | new_vers == old_vers
428 -- Up to date, so check the rest
429 -> checkEntityUsage mod decls rest
432 -- Out of date, so bale out
433 -> putDocRn (sep [ptext SLIT("Out of date:"), ppr name]) `thenRn_`
438 %*********************************************************
440 \subsection{Getting in a declaration}
442 %*********************************************************
445 importDecl :: Name -> RnMG (Maybe (Module, RdrNameHsDecl))
446 -- Returns Nothing for
449 -- (c) already slurped
455 = getSlurped `thenRn` \ already_slurped ->
456 if name `elemNameSet` already_slurped then
457 returnRn Nothing -- Already dealt with
459 if isLocallyDefined name then -- Don't bring in decls from
460 -- the renamed module's own interface file
461 addWarnRn (importDeclWarn name) `thenRn_`
464 getNonWiredInDecl name
468 getNonWiredInDecl :: Name -> RnMG (Maybe (Module, RdrNameHsDecl))
469 getNonWiredInDecl needed_name
470 = traceRn doc_str `thenRn_`
471 loadHomeInterface doc_str needed_name `thenRn` \ ifaces ->
472 case lookupNameEnv (iDecls ifaces) needed_name of
474 Just (version,avail,_,decl)
475 -> recordSlurp (Just version) avail `thenRn_`
478 Nothing -- Can happen legitimately for "Optional" occurrences
479 -> addErrRn (getDeclErr needed_name) `thenRn_`
482 doc_str = ptext SLIT("need decl for") <+> ppr needed_name
485 @getWiredInDecl@ maps a wired-in @Name@ to what it makes available.
486 It behaves exactly as if the wired in decl were actually in an interface file.
489 \item if the wired-in name is a data type constructor or a data constructor,
490 it brings in the type constructor and all the data constructors; and
491 marks as ``occurrences'' any free vars of the data con.
493 \item similarly for synonum type constructor
495 \item if the wired-in name is another wired-in Id, it marks as ``occurrences''
496 the free vars of the Id's type.
498 \item it loads the interface file for the wired-in thing for the
499 sole purpose of making sure that its instance declarations are available
501 All this is necessary so that we know all types that are ``in play'', so
502 that we know just what instances to bring into scope.
507 %*********************************************************
509 \subsection{Getting what a module exports}
511 %*********************************************************
513 @getInterfaceExports@ is called only for directly-imported modules.
516 getInterfaceExports :: ModuleName -> WhereFrom -> RnMG (Module, Avails)
517 getInterfaceExports mod_name from
518 = loadInterface doc_str mod_name from `thenRn` \ (mod, ifaces) ->
519 case lookupFM (iImpModInfo ifaces) mod_name of
520 Nothing -> -- Not there; it must be that the interface file wasn't found;
521 -- the error will have been reported already.
522 -- (Actually loadInterface should put the empty export env in there
523 -- anyway, but this does no harm.)
526 Just (_, _, Just (mod, _, avails)) -> returnRn (mod, avails)
528 doc_str = sep [pprModuleName mod_name, ptext SLIT("is directly imported")]
532 %*********************************************************
534 \subsection{Instance declarations are handled specially}
536 %*********************************************************
539 getImportedInstDecls :: NameSet -> RnMG [(Module,RdrNameHsDecl)]
540 getImportedInstDecls gates
541 = -- First, load any orphan-instance modules that aren't aready loaded
542 -- Orphan-instance modules are recorded in the module dependecnies
543 getIfacesRn `thenRn` \ ifaces ->
546 [mod | (mod, (_, True, Nothing)) <- fmToList (iImpModInfo ifaces)]
548 loadOrphanModules orphan_mods `thenRn_`
550 -- Now we're ready to grab the instance declarations
551 -- Find the un-gated ones and return them,
552 -- removing them from the bag kept in Ifaces
553 getIfacesRn `thenRn` \ ifaces ->
555 (decls, new_insts) = selectGated gates (iInsts ifaces)
557 setIfacesRn (ifaces { iInsts = new_insts }) `thenRn_`
559 traceRn (sep [text "getImportedInstDecls:",
560 nest 4 (fsep (map ppr gate_list)),
561 text "Slurped" <+> int (length decls) <+> text "instance declarations",
562 nest 4 (vcat (map ppr_brief_inst_decl decls))]) `thenRn_`
565 gate_list = nameSetToList gates
567 load_home gate | isLocallyDefined gate
570 = loadHomeInterface (ppr gate <+> text "is an instance gate") gate `thenRn_`
573 ppr_brief_inst_decl (mod, InstD (InstDecl inst_ty _ _ _ _))
575 HsForAllTy _ _ tau -> ppr tau
578 getImportedRules :: RnMG [(Module,RdrNameHsDecl)]
580 = getIfacesRn `thenRn` \ ifaces ->
582 gates = iSlurp ifaces -- Anything at all that's been slurped
583 (decls, new_rules) = selectGated gates (iRules ifaces)
585 setIfacesRn (ifaces { iRules = new_rules }) `thenRn_`
586 traceRn (sep [text "getImportedRules:",
587 text "Slurped" <+> int (length decls) <+> text "rules"]) `thenRn_`
590 selectGated gates decl_bag
591 -- Select only those decls whose gates are *all* in 'gates'
593 | opt_NoPruneDecls -- Just to try the effect of not gating at all
594 = (foldrBag (\ (_,d) ds -> d:ds) [] decl_bag, emptyBag) -- Grab them all
598 = foldrBag select ([], emptyBag) decl_bag
600 select (reqd, decl) (yes, no)
601 | isEmptyNameSet (reqd `minusNameSet` gates) = (decl:yes, no)
602 | otherwise = (yes, (reqd,decl) `consBag` no)
604 lookupFixity :: Name -> RnMS Fixity
606 | isLocallyDefined name
607 = getFixityEnv `thenRn` \ local_fix_env ->
608 case lookupNameEnv local_fix_env name of
609 Just (FixitySig _ fix _) -> returnRn fix
610 Nothing -> returnRn defaultFixity
612 | otherwise -- Imported
613 = loadHomeInterface doc name `thenRn` \ ifaces ->
614 case lookupNameEnv (iFixes ifaces) name of
615 Just (FixitySig _ fix _) -> returnRn fix
616 Nothing -> returnRn defaultFixity
618 doc = ptext SLIT("Checking fixity for") <+> ppr name
622 %*********************************************************
624 \subsection{Keeping track of what we've slurped, and version numbers}
626 %*********************************************************
628 getImportVersions figures out
629 what the ``usage information'' for this moudule is;
630 that is, what it must record in its interface file as the things it uses.
633 \item anything reachable from its body code
634 \item any module exported with a @module Foo@.
637 Why the latter? Because if @Foo@ changes then this module's export list
638 will change, so we must recompile this module at least as far as
639 making a new interface file --- but in practice that means complete
644 module A( f, g ) where | module B( f ) where
645 import B( f ) | f = h 3
648 Should we record @B.f@ in @A@'s usages? In fact we don't. Certainly, if
649 anything about @B.f@ changes than anyone who imports @A@ should be recompiled;
650 they'll get an early exit if they don't use @B.f@. However, even if @B.f@
651 doesn't change at all, @B.h@ may do so, and this change may not be reflected
652 in @f@'s version number. So there are two things going on when compiling module @A@:
654 \item Are @A.o@ and @A.hi@ correct? Then we can bale out early.
655 \item Should modules that import @A@ be recompiled?
657 For (1) it is slightly harmful to record @B.f@ in @A@'s usages,
658 because a change in @B.f@'s version will provoke full recompilation of @A@,
659 producing an identical @A.o@,
660 and @A.hi@ differing only in its usage-version of @B.f@
661 (and this usage-version info isn't used by any importer).
663 For (2), because of the tricky @B.h@ question above,
664 we ensure that @A.hi@ is touched
665 (even if identical to its previous version)
666 if A's recompilation was triggered by an imported @.hi@ file date change.
667 Given that, there's no need to record @B.f@ in @A@'s usages.
669 On the other hand, if @A@ exports @module B@,
670 then we {\em do} count @module B@ among @A@'s usages,
671 because we must recompile @A@ to ensure that @A.hi@ changes appropriately.
674 getImportVersions :: ModuleName -- Name of this module
675 -> Maybe [IE any] -- Export list for this module
676 -> RnMG (VersionInfo Name) -- Version info for these names
678 getImportVersions this_mod exports
679 = getIfacesRn `thenRn` \ ifaces ->
681 mod_map = iImpModInfo ifaces
682 imp_names = iVSlurp ifaces
684 -- mv_map groups together all the things imported from a particular module.
685 mv_map1, mv_map2 :: FiniteMap ModuleName (WhatsImported Name)
687 -- mv_map1 records all the modules that have a "module M"
688 -- in this module's export list with an "Everything"
689 mv_map1 = foldr add_mod emptyFM export_mods
691 -- mv_map2 adds the version numbers of things exported individually
692 mv_map2 = foldr add_mv mv_map1 imp_names
694 -- Build the result list by adding info for each module.
695 -- For (a) library modules
696 -- (b) source-imported modules
697 -- we do something special. We don't want to record detailed usage information.
698 -- Indeed we don't want to record them at all unless they contain orphans,
699 -- which we must never lose track of.
700 mk_version_info mod_name (version, has_orphans, cts) so_far
701 | lib_or_source_imported && not has_orphans
702 = so_far -- Don't record any usage info for this module
704 | lib_or_source_imported -- Has orphans; record the module but not
705 -- detailed version information for the imports
706 = (mod_name, version, has_orphans, Specifically []) : so_far
709 = (mod_name, version, has_orphans, whats_imported) : so_far
711 whats_imported = case lookupFM mv_map2 mod_name of
713 Nothing -> Specifically []
715 lib_or_source_imported = case cts of
716 Just (mod, boot_import, _) -> isLibModule mod || boot_import
719 returnRn (foldFM mk_version_info [] mod_map)
721 export_mods = case exports of
723 Just es -> [mod | IEModuleContents mod <- es, mod /= this_mod]
725 add_mv v@(name, version) mv_map
726 = addToFM_C add_item mv_map mod (Specifically [v])
728 mod = moduleName (nameModule name)
730 add_item Everything _ = Everything
731 add_item (Specifically xs) _ = Specifically (v:xs)
733 add_mod mod mv_map = addToFM mv_map mod Everything
738 = getIfacesRn `thenRn` \ ifaces ->
739 returnRn (iSlurp ifaces)
741 recordSlurp maybe_version avail
742 = getIfacesRn `thenRn` \ ifaces@(Ifaces { iSlurp = slurped_names,
743 iVSlurp = imp_names }) ->
745 new_slurped_names = addAvailToNameSet slurped_names avail
747 new_imp_names = case maybe_version of
748 Just version -> (availName avail, version) : imp_names
751 setIfacesRn (ifaces { iSlurp = new_slurped_names,
752 iVSlurp = new_imp_names })
756 %*********************************************************
758 \subsection{Getting binders out of a declaration}
760 %*********************************************************
762 @getDeclBinders@ returns the names for a @RdrNameHsDecl@.
763 It's used for both source code (from @availsFromDecl@) and interface files
766 It doesn't deal with source-code specific things: @ValD@, @DefD@. They
767 are handled by the sourc-code specific stuff in @RnNames@.
770 getDeclBinders :: (RdrName -> SrcLoc -> RnM d Name) -- New-name function
772 -> RnM d (Maybe AvailInfo)
774 getDeclBinders new_name (TyClD (TyData _ _ tycon _ condecls _ _ src_loc))
775 = new_name tycon src_loc `thenRn` \ tycon_name ->
776 getConFieldNames new_name condecls `thenRn` \ sub_names ->
777 returnRn (Just (AvailTC tycon_name (tycon_name : nub sub_names)))
778 -- The "nub" is because getConFieldNames can legitimately return duplicates,
779 -- when a record declaration has the same field in multiple constructors
781 getDeclBinders new_name (TyClD (TySynonym tycon _ _ src_loc))
782 = new_name tycon src_loc `thenRn` \ tycon_name ->
783 returnRn (Just (AvailTC tycon_name [tycon_name]))
785 getDeclBinders new_name (TyClD (ClassDecl _ cname _ sigs _ _ _ _ _ src_loc))
786 = new_name cname src_loc `thenRn` \ class_name ->
788 -- Record the names for the class ops
790 -- just want class-op sigs
791 op_sigs = filter isClassOpSig sigs
793 mapRn (getClassOpNames new_name) op_sigs `thenRn` \ sub_names ->
795 returnRn (Just (AvailTC class_name (class_name : sub_names)))
797 getDeclBinders new_name (SigD (IfaceSig var ty prags src_loc))
798 = new_name var src_loc `thenRn` \ var_name ->
799 returnRn (Just (Avail var_name))
801 getDeclBinders new_name (FixD _) = returnRn Nothing
803 -- foreign declarations
804 getDeclBinders new_name (ForD (ForeignDecl nm kind _ dyn _ loc))
805 | binds_haskell_name kind dyn
806 = new_name nm loc `thenRn` \ name ->
807 returnRn (Just (Avail name))
809 | otherwise -- a foreign export
810 = lookupImplicitOccRn nm `thenRn_`
813 getDeclBinders new_name (DefD _) = returnRn Nothing
814 getDeclBinders new_name (InstD _) = returnRn Nothing
815 getDeclBinders new_name (RuleD _) = returnRn Nothing
817 binds_haskell_name (FoImport _) _ = True
818 binds_haskell_name FoLabel _ = True
819 binds_haskell_name FoExport ext_nm = isDynamic ext_nm
822 getConFieldNames new_name (ConDecl con _ _ (RecCon fielddecls) src_loc : rest)
823 = mapRn (\n -> new_name n src_loc) (con:fields) `thenRn` \ cfs ->
824 getConFieldNames new_name rest `thenRn` \ ns ->
827 fields = concat (map fst fielddecls)
829 getConFieldNames new_name (ConDecl con _ _ condecl src_loc : rest)
830 = new_name con src_loc `thenRn` \ n ->
833 new_name f src_loc `thenRn` \ new_f ->
835 _ -> returnRn [n]) `thenRn` \ nn ->
836 getConFieldNames new_name rest `thenRn` \ ns ->
839 getConFieldNames new_name [] = returnRn []
841 getClassOpNames new_name (ClassOpSig op _ _ src_loc) = new_name op src_loc
844 @getDeclSysBinders@ gets the implicit binders introduced by a decl.
845 A the moment that's just the tycon and datacon that come with a class decl.
846 They aren't returned by @getDeclBinders@ because they aren't in scope;
847 but they {\em should} be put into the @DeclsMap@ of this module.
849 Note that this excludes the default-method names of a class decl,
850 and the dict fun of an instance decl, because both of these have
851 bindings of their own elsewhere.
854 getDeclSysBinders new_name (TyClD (ClassDecl _ cname _ sigs _ _ tname dname snames src_loc))
855 = new_name dname src_loc `thenRn` \ datacon_name ->
856 new_name tname src_loc `thenRn` \ tycon_name ->
857 sequenceRn [new_name n src_loc | n <- snames] `thenRn` \ scsel_names ->
858 returnRn (tycon_name : datacon_name : scsel_names)
860 getDeclSysBinders new_name other_decl
864 %*********************************************************
866 \subsection{Reading an interface file}
868 %*********************************************************
871 findAndReadIface :: SDoc -> ModuleName -> WhereFrom
872 -> Bool -- Only relevant for SystemImport
873 -- True <=> Look for a .hi file
874 -- False <=> Look for .hi-boot file unless there's
875 -- a library .hi file
876 -> RnM d (Bool, Maybe (Module, ParsedIface))
877 -- Bool is True if the interface actually read was a .hi-boot one
878 -- Nothing <=> file not found, or unreadable, or illegible
879 -- Just x <=> successfully found and parsed
881 findAndReadIface doc_str mod_name from hi_file
882 = traceRn trace_msg `thenRn_`
883 -- we keep two maps for interface files,
884 -- one for 'normal' ones, the other for .hi-boot files,
885 -- hence the need to signal which kind we're interested.
887 getHiMaps `thenRn` \ hi_maps ->
889 case find_path from hi_maps of
891 (hi_boot, Just (fpath, mod)) -> traceRn (ptext SLIT("...reading from") <+> text fpath)
893 readIface mod fpath `thenRn` \ result ->
894 returnRn (hi_boot, result)
895 (hi_boot, Nothing) -> traceRn (ptext SLIT("...not found")) `thenRn_`
896 returnRn (hi_boot, Nothing)
898 find_path ImportByUser (hi_map, _) = (False, lookupFM hi_map mod_name)
899 find_path ImportByUserSource (_, hiboot_map) = (True, lookupFM hiboot_map mod_name)
901 find_path ImportBySystem (hi_map, hiboot_map)
903 = -- If the module we seek is in our dependent set,
904 -- Look for a .hi file
905 (False, lookupFM hi_map mod_name)
908 -- Check if there's a library module of that name
909 -- If not, look for an hi-boot file
910 = case lookupFM hi_map mod_name of
911 stuff@(Just (_, mod)) | isLibModule mod -> (False, stuff)
912 other -> (True, lookupFM hiboot_map mod_name)
914 trace_msg = sep [hsep [ptext SLIT("Reading"),
916 ptext SLIT("interface for"),
917 pprModuleName mod_name <> semi],
918 nest 4 (ptext SLIT("reason:") <+> doc_str)]
921 @readIface@ tries just the one file.
924 readIface :: Module -> String -> RnM d (Maybe (Module, ParsedIface))
925 -- Nothing <=> file not found, or unreadable, or illegible
926 -- Just x <=> successfully found and parsed
927 readIface the_mod file_path
928 = ioToRnM (hGetStringBuffer False file_path) `thenRn` \ read_result ->
931 case parseIface contents
932 PState{ bol = 0#, atbol = 1#,
935 loc = mkSrcLoc (mkFastString file_path) 1 } of
936 PFailed err -> failWithRn Nothing err
937 POk _ (PIface mod_nm iface) ->
938 warnCheckRn (mod_nm == moduleName the_mod)
939 (hsep [ ptext SLIT("Something is amiss; requested module name")
941 , ptext SLIT("differs from name found in the interface file ")
942 , pprModuleName mod_nm
944 `thenRn_` returnRn (Just (the_mod, iface))
947 | isDoesNotExistError err -> returnRn Nothing
948 | otherwise -> failWithRn Nothing (cannaeReadFile file_path err)
951 %*********************************************************
955 %*********************************************************
958 noIfaceErr filename boot_file
959 = hsep [ptext SLIT("Could not find valid"), boot,
960 ptext SLIT("interface file"), quotes (pprModule filename)]
962 boot | boot_file = ptext SLIT("[boot]")
965 cannaeReadFile file err
966 = hcat [ptext SLIT("Failed in reading file: "),
968 ptext SLIT("; error="),
972 = ptext SLIT("Failed to find interface decl for") <+> quotes (ppr name)
975 = sep [ptext SLIT("Failed to find (optional) interface decl for") <+> quotes (ppr name),
976 ptext SLIT("desired at") <+> ppr loc]
980 "Compiler tried to import decl from interface file with same name as module."),
982 "(possible cause: module name clashes with interface file already in scope.)")
984 hsep [ptext SLIT("name:"), quotes (ppr name)]
986 warnRedundantSourceImport mod_name
987 = ptext SLIT("Unnecessary {- SOURCE -} in the import of module")
988 <+> quotes (pprModuleName mod_name)