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(..), defaultFixity )
34 import RdrHsSyn ( RdrNameHsDecl, RdrNameInstDecl, RdrNameTyClDecl, RdrNameRuleDecl,
35 RdrNameFixitySig, RdrNameDeprecation, RdrNameIE,
38 import RnEnv ( mkImportedGlobalName, newTopBinder, mkImportedGlobalFromRdrName,
39 lookupOccRn, lookupImplicitOccRn,
40 pprAvail, rdrAvailInfo,
41 availName, availNames, addAvailToNameSet, addSysAvails,
45 import RnHsSyn ( RenamedHsDecl, RenamedDeprecation )
46 import ParseIface ( parseIface, IfaceStuff(..) )
48 import Name ( Name {-instance NamedThing-}, nameOccName,
49 nameModule, isLocallyDefined,
50 isWiredInName, nameUnique, NamedThing(..)
52 import Module ( Module, moduleString, pprModule,
53 mkVanillaModule, pprModuleName,
54 moduleUserString, moduleName, isLocalModule,
55 ModuleName, WhereFrom(..),
57 import RdrName ( RdrName, rdrNameOcc )
60 import SrcLoc ( mkSrcLoc, SrcLoc )
61 import PrelInfo ( pREL_GHC, cCallishTyKeys )
62 import Maybes ( MaybeErr(..), maybeToBool, orElse )
63 import ListSetOps ( unionLists )
64 import Unique ( Unique, Uniquable(..) )
65 import StringBuffer ( StringBuffer, hGetStringBuffer )
66 import FastString ( mkFastString )
67 import ErrUtils ( Message )
68 import Util ( sortLt, lengthExceeds )
74 import IO ( isDoesNotExistError )
79 %*********************************************************
81 \subsection{Loading a new interface file}
83 %*********************************************************
86 loadHomeInterface :: SDoc -> Name -> RnM d Ifaces
87 loadHomeInterface doc_str name
88 = loadInterface doc_str (moduleName (nameModule name)) ImportBySystem
90 loadOrphanModules :: [ModuleName] -> RnM d ()
91 loadOrphanModules mods
92 | null mods = returnRn ()
93 | otherwise = traceRn (text "Loading orphan modules:" <+>
94 fsep (map pprModuleName mods)) `thenRn_`
95 mapRn_ load mods `thenRn_`
98 load mod = loadInterface (mk_doc mod) mod ImportBySystem
99 mk_doc mod = pprModuleName mod <+> ptext SLIT("is a orphan-instance module")
102 loadInterface :: SDoc -> ModuleName -> WhereFrom -> RnM d Ifaces
103 loadInterface doc mod from
104 = tryLoadInterface doc mod from `thenRn` \ (ifaces, maybe_err) ->
106 Nothing -> returnRn ifaces
107 Just err -> failWithRn ifaces err
109 tryLoadInterface :: SDoc -> ModuleName -> WhereFrom -> RnM d (Ifaces, Maybe Message)
110 -- Returns (Just err) if an error happened
111 -- Guarantees to return with iImpModInfo m --> (... Just cts)
112 -- (If the load fails, we plug in a vanilla placeholder
113 tryLoadInterface doc_str mod_name from
114 = getIfacesRn `thenRn` \ ifaces ->
116 mod_map = iImpModInfo ifaces
117 mod_info = lookupFM mod_map mod_name
119 hi_boot_file = case from of {
120 ImportByUser -> False ; -- Not hi-boot
121 ImportByUserSource -> True ; -- hi-boot
124 Just (_, is_boot, _) -> is_boot
127 -- We're importing a module we know absolutely
128 -- nothing about, so we assume it's from
129 -- another package, where we aren't doing
130 -- dependency tracking. So it won't be a hi-boot file.
132 redundant_source_import
133 = case (from, mod_info) of
134 (ImportByUserSource, Just (_,False,_)) -> True
137 -- CHECK WHETHER WE HAVE IT ALREADY
140 -> -- We're read it already so don't re-read it
141 returnRn (ifaces, Nothing) ;
145 -- Issue a warning for a redundant {- SOURCE -} import
146 -- NB that we arrange to read all the ordinary imports before
147 -- any of the {- SOURCE -} imports
148 warnCheckRn (not redundant_source_import)
149 (warnRedundantSourceImport mod_name) `thenRn_`
151 -- READ THE MODULE IN
152 findAndReadIface doc_str mod_name hi_boot_file `thenRn` \ read_result ->
153 case read_result of {
154 Left err -> -- Not found, so add an empty export env to the Ifaces map
155 -- so that we don't look again
157 mod = mkVanillaModule mod_name
158 new_mod_map = addToFM mod_map mod_name (False, False, Just (mod, 0, 0, 0, from, []))
159 new_ifaces = ifaces { iImpModInfo = new_mod_map }
161 setIfacesRn new_ifaces `thenRn_`
162 returnRn (new_ifaces, Just err) ;
167 -- LOAD IT INTO Ifaces
169 -- NB: *first* we do loadDecl, so that the provenance of all the locally-defined
170 --- names is done correctly (notably, whether this is an .hi file or .hi-boot file).
171 -- If we do loadExport first the wrong info gets into the cache (unless we
172 -- explicitly tag each export which seems a bit of a bore)
174 getModuleRn `thenRn` \ this_mod_nm ->
178 -- Sanity check. If we're system-importing a module we know nothing at all
179 -- about, it should be from a different package to this one
180 WARN( not (maybeToBool mod_info) &&
181 case from of { ImportBySystem -> True; other -> False } &&
184 foldlRn (loadDecl mod) (iDecls ifaces) (pi_decls iface) `thenRn` \ new_decls ->
185 foldlRn (loadInstDecl mod) (iInsts ifaces) (pi_insts iface) `thenRn` \ new_insts ->
186 loadRules mod (iRules ifaces) (pi_rules iface) `thenRn` \ new_rules ->
187 loadFixDecls mod_name (iFixes ifaces) (pi_fixity iface) `thenRn` \ new_fixities ->
188 foldlRn (loadDeprec mod) (iDeprecs ifaces) (pi_deprecs iface) `thenRn` \ new_deprecs ->
189 mapRn (loadExport this_mod_nm) (pi_exports iface) `thenRn` \ avails_s ->
191 -- For an explicit user import, add to mod_map info about
192 -- the things the imported module depends on, extracted
193 -- from its usage info.
194 mod_map1 = case from of
195 ImportByUser -> addModDeps mod (pi_usages iface) mod_map
198 -- Now add info about this module
199 mod_map2 = addToFM mod_map1 mod_name mod_details
200 cts = (pi_mod iface, pi_vers iface,
201 fst (pi_fixity iface), fst (pi_rules iface),
202 from, concat avails_s)
203 mod_details = (pi_orphan iface, hi_boot_file, Just cts)
205 new_ifaces = ifaces { iImpModInfo = mod_map2,
207 iFixes = new_fixities,
210 iDeprecs = new_deprecs }
212 setIfacesRn new_ifaces `thenRn_`
213 returnRn (new_ifaces, Nothing)
216 -----------------------------------------------------
217 -- Adding module dependencies from the
218 -- import decls in the interface file
219 -----------------------------------------------------
221 addModDeps :: Module -> [ImportVersion a]
222 -> ImportedModuleInfo -> ImportedModuleInfo
223 -- (addModDeps M ivs deps)
224 -- We are importing module M, and M.hi contains 'import' decls given by ivs
225 addModDeps mod new_deps mod_deps
226 = foldr add mod_deps filtered_new_deps
228 -- Don't record dependencies when importing a module from another package
229 -- Except for its descendents which contain orphans,
230 -- and in that case, forget about the boot indicator
232 | isLocalModule mod = [ (imp_mod, (has_orphans, is_boot, Nothing))
233 | (imp_mod, has_orphans, is_boot, _) <- new_deps
235 | otherwise = [ (imp_mod, (True, False, Nothing))
236 | (imp_mod, has_orphans, _, _) <- new_deps,
239 add (imp_mod, dep) deps = addToFM_C combine deps imp_mod dep
241 combine old@(_, old_is_boot, cts) new
242 | maybeToBool cts || not old_is_boot = old -- Keep the old info if it's already loaded
243 -- or if it's a non-boot pending load
244 | otherwise = new -- Otherwise pick new info
247 -----------------------------------------------------
248 -- Loading the export list
249 -----------------------------------------------------
251 loadExport :: ModuleName -> ExportItem -> RnM d [AvailInfo]
252 loadExport this_mod (mod, entities)
253 | mod == this_mod = returnRn []
254 -- If the module exports anything defined in this module, just ignore it.
255 -- Reason: otherwise it looks as if there are two local definition sites
256 -- for the thing, and an error gets reported. Easiest thing is just to
257 -- filter them out up front. This situation only arises if a module
258 -- imports itself, or another module that imported it. (Necessarily,
259 -- this invoves a loop.) Consequence: if you say
264 -- module B( AType ) where
265 -- import {-# SOURCE #-} A( AType )
267 -- then you'll get a 'B does not export AType' message. A bit bogus
268 -- but it's a bogus thing to do!
271 = mapRn (load_entity mod) entities
273 new_name mod occ = mkImportedGlobalName mod occ
275 load_entity mod (Avail occ)
276 = new_name mod occ `thenRn` \ name ->
277 returnRn (Avail name)
278 load_entity mod (AvailTC occ occs)
279 = new_name mod occ `thenRn` \ name ->
280 mapRn (new_name mod) occs `thenRn` \ names ->
281 returnRn (AvailTC name names)
284 -----------------------------------------------------
285 -- Loading type/class/value decls
286 -----------------------------------------------------
290 -> (Version, RdrNameHsDecl)
293 loadDecl mod decls_map (version, decl)
294 = getDeclBinders new_name decl `thenRn` \ maybe_avail ->
295 case maybe_avail of {
296 Nothing -> returnRn decls_map; -- No bindings
299 getDeclSysBinders new_name decl `thenRn` \ sys_bndrs ->
301 full_avail = addSysAvails avail sys_bndrs
302 -- Add the sys-binders to avail. When we import the decl,
303 -- it's full_avail that will get added to the 'already-slurped' set (iSlurp)
304 -- If we miss out sys-binders, we'll read the decl multiple times!
306 main_name = availName avail
307 new_decls_map = foldl add_decl decls_map
308 [ (name, (version, full_avail, name==main_name, (mod, decl')))
309 | name <- availNames full_avail]
310 add_decl decls_map (name, stuff)
311 = WARN( name `elemNameEnv` decls_map, ppr name )
312 addToNameEnv decls_map name stuff
314 returnRn new_decls_map
317 -- newTopBinder puts into the cache the binder with the
318 -- module information set correctly. When the decl is later renamed,
319 -- the binding site will thereby get the correct module.
320 -- There maybe occurrences that don't have the correct Module, but
321 -- by the typechecker will propagate the binding definition to all
322 -- the occurrences, so that doesn't matter
323 new_name rdr_name loc = newTopBinder mod (rdrNameOcc rdr_name)
326 If a signature decl is being loaded, and optIgnoreIfacePragmas is on,
327 we toss away unfolding information.
329 Also, if the signature is loaded from a module we're importing from source,
330 we do the same. This is to avoid situations when compiling a pair of mutually
331 recursive modules, peering at unfolding info in the interface file of the other,
332 e.g., you compile A, it looks at B's interface file and may as a result change
333 its interface file. Hence, B is recompiled, maybe changing its interface file,
334 which will the unfolding info used in A to become invalid. Simple way out is to
335 just ignore unfolding info.
337 [Jan 99: I junked the second test above. If we're importing from an hi-boot
338 file there isn't going to *be* any pragma info. Maybe the above comment
339 dates from a time where we picked up a .hi file first if it existed?]
342 SigD (IfaceSig name tp ls loc) | opt_IgnoreIfacePragmas
343 -> SigD (IfaceSig name tp [] loc)
346 -----------------------------------------------------
347 -- Loading fixity decls
348 -----------------------------------------------------
350 loadFixDecls mod_name fixity_env (version, decls)
351 | null decls = returnRn fixity_env
354 = mapRn (loadFixDecl mod_name) decls `thenRn` \ to_add ->
355 returnRn (addListToNameEnv fixity_env to_add)
357 loadFixDecl mod_name sig@(FixitySig rdr_name fixity loc)
358 = mkImportedGlobalName mod_name (rdrNameOcc rdr_name) `thenRn` \ name ->
359 returnRn (name, FixitySig name fixity loc)
362 -----------------------------------------------------
363 -- Loading instance decls
364 -----------------------------------------------------
366 loadInstDecl :: Module
370 loadInstDecl mod insts decl@(InstDecl inst_ty binds uprags dfun_name src_loc)
372 -- Find out what type constructors and classes are "gates" for the
373 -- instance declaration. If all these "gates" are slurped in then
374 -- we should slurp the instance decl too.
376 -- We *don't* want to count names in the context part as gates, though.
378 -- instance Foo a => Baz (T a) where ...
380 -- Here the gates are Baz and T, but *not* Foo.
382 munged_inst_ty = removeContext inst_ty
383 free_names = extractHsTyRdrNames munged_inst_ty
385 setModuleRn (moduleName mod) $
386 mapRn mkImportedGlobalFromRdrName free_names `thenRn` \ gate_names ->
387 returnRn ((mkNameSet gate_names, (mod, InstD decl)) `consBag` insts)
390 -- In interface files, the instance decls now look like
391 -- forall a. Foo a -> Baz (T a)
392 -- so we have to strip off function argument types as well
393 -- as the bit before the '=>' (which is always empty in interface files)
394 removeContext (HsForAllTy tvs cxt ty) = HsForAllTy tvs [] (removeFuns ty)
395 removeContext ty = removeFuns ty
397 removeFuns (HsFunTy _ ty) = removeFuns ty
401 -----------------------------------------------------
403 -----------------------------------------------------
405 loadRules :: Module -> IfaceRules
406 -> (Version, [RdrNameRuleDecl])
408 loadRules mod rule_bag (version, rules)
409 | null rules || opt_IgnoreIfacePragmas
412 = setModuleRn mod_name $
413 mapRn (loadRule mod) rules `thenRn` \ new_rules ->
414 returnRn (rule_bag `unionBags` listToBag new_rules)
416 mod_name = moduleName mod
418 loadRule :: Module -> RdrNameRuleDecl -> RnM d GatedDecl
419 -- "Gate" the rule simply by whether the rule variable is
420 -- needed. We can refine this later.
421 loadRule mod decl@(IfaceRule _ _ var _ _ src_loc)
422 = mkImportedGlobalFromRdrName var `thenRn` \ var_name ->
423 returnRn (unitNameSet var_name, (mod, RuleD decl))
425 loadBuiltinRules :: [(RdrName, CoreRule)] -> RnMG ()
426 loadBuiltinRules builtin_rules
427 = getIfacesRn `thenRn` \ ifaces ->
428 mapRn loadBuiltinRule builtin_rules `thenRn` \ rule_decls ->
429 setIfacesRn (ifaces { iRules = iRules ifaces `unionBags` listToBag rule_decls })
431 loadBuiltinRule (var, rule)
432 = mkImportedGlobalFromRdrName var `thenRn` \ var_name ->
433 returnRn (unitNameSet var_name, (nameModule var_name, RuleD (IfaceRuleOut var rule)))
436 -----------------------------------------------------
437 -- Loading Deprecations
438 -----------------------------------------------------
440 loadDeprec :: Module -> DeprecationEnv -> RdrNameDeprecation -> RnM d DeprecationEnv
441 loadDeprec mod deprec_env (Deprecation (IEModuleContents _) txt _)
442 = traceRn (text "module deprecation not yet implemented:" <+> ppr mod <> colon <+> ppr txt) `thenRn_`
443 -- SUP: TEMPORARY HACK, ignoring module deprecations for now
446 loadDeprec mod deprec_env (Deprecation ie txt _)
447 = setModuleRn (moduleName mod) $
448 mapRn mkImportedGlobalFromRdrName (ieNames ie) `thenRn` \ names ->
449 traceRn (text "loaded deprecation(s) for" <+> hcat (punctuate comma (map ppr names)) <> colon <+> ppr txt) `thenRn_`
450 returnRn (extendNameEnv deprec_env (zip names (repeat txt)))
454 %********************************************************
456 \subsection{Checking usage information}
458 %********************************************************
464 checkModUsage :: [ImportVersion OccName] -> RnMG Bool
465 -- Given the usage information extracted from the old
466 -- M.hi file for the module being compiled, figure out
467 -- whether M needs to be recompiled.
469 checkModUsage [] = returnRn upToDate -- Yes! Everything is up to date!
471 checkModUsage ((mod_name, _, _, NothingAtAll) : rest)
472 -- If CurrentModule.hi contains
474 -- then that simply records that Foo lies below CurrentModule in the
475 -- hierarchy, but CurrentModule doesn't depend in any way on Foo.
476 -- In this case we don't even want to open Foo's interface.
477 = traceRn (ptext SLIT("Nothing used from:") <+> ppr mod_name) `thenRn_`
478 checkModUsage rest -- This one's ok, so check the rest
480 checkModUsage ((mod_name, _, _, whats_imported) : rest)
481 = tryLoadInterface doc_str mod_name ImportBySystem `thenRn` \ (ifaces, maybe_err) ->
483 Just err -> out_of_date (sep [ptext SLIT("Can't find version number for module"),
484 pprModuleName mod_name]) ;
485 -- Couldn't find or parse a module mentioned in the
486 -- old interface file. Don't complain -- it might just be that
487 -- the current module doesn't need that import and it's been deleted
491 (_, new_mod_vers, new_fix_vers, new_rule_vers, _, _)
492 = case lookupFM (iImpModInfo ifaces) mod_name of
493 Just (_, _, Just stuff) -> stuff
495 old_mod_vers = case whats_imported of
497 Specifically v _ _ _ -> v
498 -- NothingAtAll case dealt with by previous eqn for checkModUsage
500 -- If the module version hasn't changed, just move on
501 if new_mod_vers == old_mod_vers then
502 traceRn (sep [ptext SLIT("Module version unchanged:"), pprModuleName mod_name])
503 `thenRn_` checkModUsage rest
505 traceRn (sep [ptext SLIT("Module version has changed:"), pprModuleName mod_name])
507 -- Module version changed, so check entities inside
509 -- If the usage info wants to say "I imported everything from this module"
510 -- it does so by making whats_imported equal to Everything
511 -- In that case, we must recompile
512 case whats_imported of { -- NothingAtAll dealt with earlier
515 -> out_of_date (ptext SLIT("...and I needed the whole module")) ;
517 Specifically _ old_fix_vers old_rule_vers old_local_vers ->
519 if old_fix_vers /= new_fix_vers then
520 out_of_date (ptext SLIT("Fixities changed"))
521 else if old_rule_vers /= new_rule_vers then
522 out_of_date (ptext SLIT("Rules changed"))
524 -- Non-empty usage list, so check item by item
525 checkEntityUsage mod_name (iDecls ifaces) old_local_vers `thenRn` \ up_to_date ->
527 traceRn (ptext SLIT("...but the bits I use haven't.")) `thenRn_`
528 checkModUsage rest -- This one's ok, so check the rest
530 returnRn outOfDate -- This one failed, so just bail out now
533 doc_str = sep [ptext SLIT("need version info for"), pprModuleName mod_name]
536 checkEntityUsage mod decls []
537 = returnRn upToDate -- Yes! All up to date!
539 checkEntityUsage mod decls ((occ_name,old_vers) : rest)
540 = mkImportedGlobalName mod occ_name `thenRn` \ name ->
541 case lookupNameEnv decls name of
543 Nothing -> -- We used it before, but it ain't there now
544 out_of_date (sep [ptext SLIT("No longer exported:"), ppr name])
546 Just (new_vers,_,_,_) -- It's there, but is it up to date?
547 | new_vers == old_vers
548 -- Up to date, so check the rest
549 -> checkEntityUsage mod decls rest
552 -- Out of date, so bale out
553 -> out_of_date (sep [ptext SLIT("Out of date:"), ppr name])
555 out_of_date msg = traceRn msg `thenRn_` returnRn outOfDate
559 %*********************************************************
561 \subsection{Getting in a declaration}
563 %*********************************************************
566 importDecl :: Name -> RnMG ImportDeclResult
568 data ImportDeclResult
572 | HereItIs (Module, RdrNameHsDecl)
575 = getSlurped `thenRn` \ already_slurped ->
576 if name `elemNameSet` already_slurped then
577 returnRn AlreadySlurped -- Already dealt with
579 else if isLocallyDefined name then -- Don't bring in decls from
580 -- the renamed module's own interface file
581 addWarnRn (importDeclWarn name) `thenRn_`
582 returnRn AlreadySlurped
584 else if isWiredInName name then
585 -- When we find a wired-in name we must load its
586 -- home module so that we find any instance decls therein
587 loadHomeInterface doc name `thenRn_`
590 else getNonWiredInDecl name
592 doc = ptext SLIT("need home module for wired in thing") <+> ppr name
595 {- I don't think this is necessary any more; SLPJ May 00
597 | name `elemNameSet` source_binders = returnRn ()
598 -- When compiling the prelude, a wired-in thing may
599 -- be defined in this module, in which case we don't
600 -- want to load its home module!
601 -- Using 'isLocallyDefined' doesn't work because some of
602 -- the free variables returned are simply 'listTyCon_Name',
603 -- with a system provenance. We could look them up every time
604 -- but that seems a waste.
605 | otherwise = loadHomeInterface doc name `thenRn_`
609 getNonWiredInDecl :: Name -> RnMG ImportDeclResult
610 getNonWiredInDecl needed_name
611 = traceRn doc_str `thenRn_`
612 loadHomeInterface doc_str needed_name `thenRn` \ ifaces ->
613 case lookupNameEnv (iDecls ifaces) needed_name of
615 Just (version, avail, is_tycon_name, decl@(_, TyClD (TyData DataType _ _ _ _ ncons _ _ _)))
616 -- This case deals with deferred import of algebraic data types
618 | not opt_NoPruneTyDecls
620 && (opt_IgnoreIfacePragmas || ncons > 1)
621 -- We only defer if imported interface pragmas are ingored
622 -- or if it's not a product type.
623 -- Sole reason: The wrapper for a strict function may need to look
624 -- inside its arg, and hence need to see its arg type's constructors.
626 && not (getUnique tycon_name `elem` cCallishTyKeys)
627 -- Never defer ccall types; we have to unbox them,
628 -- and importing them does no harm
630 -> -- OK, so we're importing a deferrable data type
631 if needed_name == tycon_name then
632 -- The needed_name is the TyCon of a data type decl
633 -- Record that it's slurped, put it in the deferred set
634 -- and don't return a declaration at all
635 setIfacesRn (recordSlurp (ifaces {iDeferred = iDeferred ifaces
636 `addOneToNameSet` tycon_name})
637 version (AvailTC needed_name [needed_name])) `thenRn_`
640 -- The needed name is a constructor of a data type decl,
641 -- getting a constructor, so remove the TyCon from the deferred set
642 -- (if it's there) and return the full declaration
643 setIfacesRn (recordSlurp (ifaces {iDeferred = iDeferred ifaces
644 `delFromNameSet` tycon_name})
645 version avail) `thenRn_`
646 returnRn (HereItIs decl)
648 tycon_name = availName avail
650 Just (version,avail,_,decl)
651 -> setIfacesRn (recordSlurp ifaces version avail) `thenRn_`
652 returnRn (HereItIs decl)
655 -> addErrRn (getDeclErr needed_name) `thenRn_`
656 returnRn AlreadySlurped
658 doc_str = ptext SLIT("need decl for") <+> ppr needed_name
660 getDeferredDecls :: RnMG [(Module, RdrNameHsDecl)]
662 = getIfacesRn `thenRn` \ ifaces ->
664 decls_map = iDecls ifaces
665 deferred_names = nameSetToList (iDeferred ifaces)
666 get_abstract_decl n = case lookupNameEnv decls_map n of
667 Just (_, _, _, decl) -> decl
669 traceRn (sep [text "getDeferredDecls", nest 4 (fsep (map ppr deferred_names))]) `thenRn_`
670 returnRn (map get_abstract_decl deferred_names)
673 @getWiredInDecl@ maps a wired-in @Name@ to what it makes available.
674 It behaves exactly as if the wired in decl were actually in an interface file.
677 \item if the wired-in name is a data type constructor or a data constructor,
678 it brings in the type constructor and all the data constructors; and
679 marks as ``occurrences'' any free vars of the data con.
681 \item similarly for synonum type constructor
683 \item if the wired-in name is another wired-in Id, it marks as ``occurrences''
684 the free vars of the Id's type.
686 \item it loads the interface file for the wired-in thing for the
687 sole purpose of making sure that its instance declarations are available
689 All this is necessary so that we know all types that are ``in play'', so
690 that we know just what instances to bring into scope.
695 %*********************************************************
697 \subsection{Getting what a module exports}
699 %*********************************************************
701 @getInterfaceExports@ is called only for directly-imported modules.
704 getInterfaceExports :: ModuleName -> WhereFrom -> RnMG (Module, Avails)
705 getInterfaceExports mod_name from
706 = loadInterface doc_str mod_name from `thenRn` \ ifaces ->
707 case lookupFM (iImpModInfo ifaces) mod_name of
708 Just (_, _, Just (mod, _, _, _, _, avails)) -> returnRn (mod, avails)
709 -- loadInterface always puts something in the map
710 -- even if it's a fake
712 doc_str = sep [pprModuleName mod_name, ptext SLIT("is directly imported")]
716 %*********************************************************
718 \subsection{Instance declarations are handled specially}
720 %*********************************************************
723 getImportedInstDecls :: NameSet -> RnMG [(Module,RdrNameHsDecl)]
724 getImportedInstDecls gates
725 = -- First, load any orphan-instance modules that aren't aready loaded
726 -- Orphan-instance modules are recorded in the module dependecnies
727 getIfacesRn `thenRn` \ ifaces ->
730 [mod | (mod, (True, _, Nothing)) <- fmToList (iImpModInfo ifaces)]
732 loadOrphanModules orphan_mods `thenRn_`
734 -- Now we're ready to grab the instance declarations
735 -- Find the un-gated ones and return them,
736 -- removing them from the bag kept in Ifaces
737 getIfacesRn `thenRn` \ ifaces ->
739 (decls, new_insts) = selectGated gates (iInsts ifaces)
741 setIfacesRn (ifaces { iInsts = new_insts }) `thenRn_`
743 traceRn (sep [text "getImportedInstDecls:",
744 nest 4 (fsep (map ppr gate_list)),
745 text "Slurped" <+> int (length decls) <+> text "instance declarations",
746 nest 4 (vcat (map ppr_brief_inst_decl decls))]) `thenRn_`
749 gate_list = nameSetToList gates
751 ppr_brief_inst_decl (mod, InstD (InstDecl inst_ty _ _ _ _))
753 HsForAllTy _ _ tau -> ppr tau
756 getImportedRules :: RnMG [(Module,RdrNameHsDecl)]
758 | opt_IgnoreIfacePragmas = returnRn []
760 = getIfacesRn `thenRn` \ ifaces ->
762 gates = iSlurp ifaces -- Anything at all that's been slurped
763 rules = iRules ifaces
764 (decls, new_rules) = selectGated gates rules
769 setIfacesRn (ifaces { iRules = new_rules }) `thenRn_`
770 traceRn (sep [text "getImportedRules:",
771 text "Slurped" <+> int (length decls) <+> text "rules"]) `thenRn_`
774 selectGated gates decl_bag
775 -- Select only those decls whose gates are *all* in 'gates'
777 | opt_NoPruneDecls -- Just to try the effect of not gating at all
778 = (foldrBag (\ (_,d) ds -> d:ds) [] decl_bag, emptyBag) -- Grab them all
782 = foldrBag select ([], emptyBag) decl_bag
784 select (reqd, decl) (yes, no)
785 | isEmptyNameSet (reqd `minusNameSet` gates) = (decl:yes, no)
786 | otherwise = (yes, (reqd,decl) `consBag` no)
788 lookupFixityRn :: Name -> RnMS Fixity
790 | isLocallyDefined name
791 = getFixityEnv `thenRn` \ local_fix_env ->
792 returnRn (lookupFixity local_fix_env name)
794 | otherwise -- Imported
795 -- For imported names, we have to get their fixities by doing a loadHomeInterface,
796 -- and consulting the Ifaces that comes back from that, because the interface
797 -- file for the Name might not have been loaded yet. Why not? Suppose you import module A,
798 -- which exports a function 'f', which is defined in module B. Then B isn't loaded
799 -- right away (after all, it's possible that nothing from B will be used).
800 -- When we come across a use of 'f', we need to know its fixity, and it's then,
801 -- and only then, that we load B.hi. That is what's happening here.
802 = loadHomeInterface doc name `thenRn` \ ifaces ->
803 returnRn (lookupFixity (iFixes ifaces) name)
805 doc = ptext SLIT("Checking fixity for") <+> ppr name
809 %*********************************************************
811 \subsection{Keeping track of what we've slurped, and version numbers}
813 %*********************************************************
815 getImportVersions figures out what the ``usage information'' for this
816 moudule is; that is, what it must record in its interface file as the
817 things it uses. It records:
820 \item (a) anything reachable from its body code
821 \item (b) any module exported with a @module Foo@
822 \item (c) anything reachable from an exported item
825 Why (b)? Because if @Foo@ changes then this module's export list
826 will change, so we must recompile this module at least as far as
827 making a new interface file --- but in practice that means complete
830 Why (c)? Consider this:
832 module A( f, g ) where | module B( f ) where
833 import B( f ) | f = h 3
837 Here, @B.f@ isn't used in A. Should we nevertheless record @B.f@ in
838 @A@'s usages? Our idea is that we aren't going to touch A.hi if it is
839 *identical* to what it was before. If anything about @B.f@ changes
840 than anyone who imports @A@ should be recompiled in case they use
841 @B.f@ (they'll get an early exit if they don't). So, if anything
842 about @B.f@ changes we'd better make sure that something in A.hi
843 changes, and the convenient way to do that is to record the version
844 number @B.f@ in A.hi in the usage list. If B.f changes that'll force a
845 complete recompiation of A, which is overkill but it's the only way to
846 write a new, slightly different, A.hi.
848 But the example is tricker. Even if @B.f@ doesn't change at all,
849 @B.h@ may do so, and this change may not be reflected in @f@'s version
850 number. But with -O, a module that imports A must be recompiled if
851 @B.h@ changes! So A must record a dependency on @B.h@. So we treat
852 the occurrence of @B.f@ in the export list *just as if* it were in the
853 code of A, and thereby haul in all the stuff reachable from it.
855 [NB: If B was compiled with -O, but A isn't, we should really *still*
856 haul in all the unfoldings for B, in case the module that imports A *is*
857 compiled with -O. I think this is the case.]
859 Even if B is used at all we get a usage line for B
860 import B <n> :: ... ;
861 in A.hi, to record the fact that A does import B. This is used to decide
862 to look to look for B.hi rather than B.hi-boot when compiling a module that
863 imports A. This line says that A imports B, but uses nothing in it.
864 So we'll get an early bale-out when compiling A if B's version changes.
867 mkImportExportInfo :: ModuleName -- Name of this module
868 -> Avails -- Info about exports
869 -> Maybe [RdrNameIE] -- The export header
870 -> RnMG ([ExportItem], -- Export info for iface file; sorted
871 [ImportVersion OccName]) -- Import info for iface file; sorted
872 -- Both results are sorted into canonical order to
873 -- reduce needless wobbling of interface files
875 mkImportExportInfo this_mod export_avails exports
876 = getIfacesRn `thenRn` \ ifaces ->
878 export_all_mods = case exports of
880 Just es -> [mod | IEModuleContents mod <- es,
883 mod_map = iImpModInfo ifaces
884 imp_names = iVSlurp ifaces
886 -- mv_map groups together all the things imported from a particular module.
887 mv_map :: FiniteMap ModuleName [(OccName,Version)]
888 mv_map = foldr add_mv emptyFM imp_names
890 add_mv (name, version) mv_map = addItem mv_map (moduleName (nameModule name))
891 (nameOccName name, version)
893 -- Build the result list by adding info for each module.
894 -- For (a) a library module, we don't record it at all unless it contains orphans
895 -- (We must never lose track of orphans.)
897 -- (b) a source-imported module, don't record the dependency at all
899 -- (b) may seem a bit strange. The idea is that the usages in a .hi file records
900 -- *all* the module's dependencies other than the loop-breakers. We use
901 -- this info in findAndReadInterface to decide whether to look for a .hi file or
904 -- This means we won't track version changes, or orphans, from .hi-boot files.
905 -- The former is potentially rather bad news. It could be fixed by recording
906 -- whether something is a boot file along with the usage info for it, but
907 -- I can't be bothered just now.
909 mk_imp_info mod_name (has_orphans, is_boot, contents) so_far
910 | mod_name == this_mod -- Check if M appears in the set of modules 'below' M
911 -- This seems like a convenient place to check
912 = WARN( not is_boot, ptext SLIT("Wierd:") <+> ppr this_mod <+>
913 ptext SLIT("imports itself (perhaps indirectly)") )
918 go_for_it exports = (mod_name, has_orphans, is_boot, exports)
922 Nothing -> -- We didn't even open the interface
923 -- This happens when a module, Foo, that we explicitly imported has
924 -- 'import Baz' in its interface file, recording that Baz is below
925 -- Foo in the module dependency hierarchy. We want to propagate this
926 -- information. The Nothing says that we didn't even open the interface
927 -- file but we must still propagate the dependeny info.
928 -- The module in question must be a local module (in the same package)
929 go_for_it NothingAtAll
931 Just (mod, mod_vers, fix_vers, rule_vers, how_imported, _)
932 | is_sys_import && is_lib_module && not has_orphans
935 | is_lib_module -- Record the module but not detailed
936 || mod_name `elem` export_all_mods -- version information for the imports
937 -> go_for_it (Everything mod_vers)
940 -> case lookupFM mv_map mod_name of
941 Just whats_imported -> go_for_it (Specifically mod_vers fix_vers rule_vers
942 (sortImport whats_imported))
943 Nothing -> go_for_it NothingAtAll
944 -- This happens if you have
946 -- but don't actually *use* anything from Foo
947 -- In which case record an empty dependency list
949 is_lib_module = not (isLocalModule mod)
950 is_sys_import = case how_imported of
951 ImportBySystem -> True
955 import_info = foldFM mk_imp_info [] mod_map
957 -- Sort exports into groups by module
958 export_fm :: FiniteMap ModuleName [RdrAvailInfo]
959 export_fm = foldr insert emptyFM export_avails
961 insert avail efm = addItem efm (moduleName (nameModule (availName avail)))
964 export_info = [(m, sortExport as) | (m,as) <- fmToList export_fm]
966 returnRn (export_info, import_info)
969 addItem :: FiniteMap ModuleName [a] -> ModuleName -> a -> FiniteMap ModuleName [a]
970 addItem fm mod x = addToFM_C add_item fm mod [x]
974 sortImport :: [(OccName,Version)] -> [(OccName,Version)]
975 -- Make the usage lists appear in canonical order
976 sortImport vs = sortLt lt vs
978 lt (n1,v1) (n2,v2) = n1 < n2
980 sortExport :: [RdrAvailInfo] -> [RdrAvailInfo]
981 sortExport as = sortLt lt as
983 lt a1 a2 = availName a1 < availName a2
988 = getIfacesRn `thenRn` \ ifaces ->
989 returnRn (iSlurp ifaces)
991 recordSlurp ifaces@(Ifaces { iSlurp = slurped_names, iVSlurp = imp_names })
994 new_slurped_names = addAvailToNameSet slurped_names avail
995 new_imp_names = (availName avail, version) : imp_names
997 ifaces { iSlurp = new_slurped_names, iVSlurp = new_imp_names }
999 recordLocalSlurps local_avails
1000 = getIfacesRn `thenRn` \ ifaces ->
1002 new_slurped_names = foldl addAvailToNameSet (iSlurp ifaces) local_avails
1004 setIfacesRn (ifaces { iSlurp = new_slurped_names })
1008 %*********************************************************
1010 \subsection{Getting binders out of a declaration}
1012 %*********************************************************
1014 @getDeclBinders@ returns the names for a @RdrNameHsDecl@.
1015 It's used for both source code (from @availsFromDecl@) and interface files
1018 It doesn't deal with source-code specific things: @ValD@, @DefD@. They
1019 are handled by the sourc-code specific stuff in @RnNames@.
1022 getDeclBinders :: (RdrName -> SrcLoc -> RnM d Name) -- New-name function
1024 -> RnM d (Maybe AvailInfo)
1026 getDeclBinders new_name (TyClD (TyData _ _ tycon _ condecls _ _ _ src_loc))
1027 = new_name tycon src_loc `thenRn` \ tycon_name ->
1028 getConFieldNames new_name condecls `thenRn` \ sub_names ->
1029 returnRn (Just (AvailTC tycon_name (tycon_name : nub sub_names)))
1030 -- The "nub" is because getConFieldNames can legitimately return duplicates,
1031 -- when a record declaration has the same field in multiple constructors
1033 getDeclBinders new_name (TyClD (TySynonym tycon _ _ src_loc))
1034 = new_name tycon src_loc `thenRn` \ tycon_name ->
1035 returnRn (Just (AvailTC tycon_name [tycon_name]))
1037 getDeclBinders new_name (TyClD (ClassDecl _ cname _ _ sigs _ _ _ _ _ _ src_loc))
1038 = new_name cname src_loc `thenRn` \ class_name ->
1040 -- Record the names for the class ops
1042 -- just want class-op sigs
1043 op_sigs = filter isClassOpSig sigs
1045 mapRn (getClassOpNames new_name) op_sigs `thenRn` \ sub_names ->
1047 returnRn (Just (AvailTC class_name (class_name : sub_names)))
1049 getDeclBinders new_name (SigD (IfaceSig var ty prags src_loc))
1050 = new_name var src_loc `thenRn` \ var_name ->
1051 returnRn (Just (Avail var_name))
1053 getDeclBinders new_name (FixD _) = returnRn Nothing
1054 getDeclBinders new_name (DeprecD _) = returnRn Nothing
1056 -- foreign declarations
1057 getDeclBinders new_name (ForD (ForeignDecl nm kind _ dyn _ loc))
1058 | binds_haskell_name kind dyn
1059 = new_name nm loc `thenRn` \ name ->
1060 returnRn (Just (Avail name))
1062 | otherwise -- a foreign export
1063 = lookupImplicitOccRn nm `thenRn_`
1066 getDeclBinders new_name (DefD _) = returnRn Nothing
1067 getDeclBinders new_name (InstD _) = returnRn Nothing
1068 getDeclBinders new_name (RuleD _) = returnRn Nothing
1070 binds_haskell_name (FoImport _) _ = True
1071 binds_haskell_name FoLabel _ = True
1072 binds_haskell_name FoExport ext_nm = isDynamicExtName ext_nm
1075 getConFieldNames new_name (ConDecl con _ _ _ (RecCon fielddecls) src_loc : rest)
1076 = mapRn (\n -> new_name n src_loc) (con:fields) `thenRn` \ cfs ->
1077 getConFieldNames new_name rest `thenRn` \ ns ->
1078 returnRn (cfs ++ ns)
1080 fields = concat (map fst fielddecls)
1082 getConFieldNames new_name (ConDecl con _ _ _ condecl src_loc : rest)
1083 = new_name con src_loc `thenRn` \ n ->
1085 NewCon _ (Just f) ->
1086 new_name f src_loc `thenRn` \ new_f ->
1088 _ -> returnRn [n]) `thenRn` \ nn ->
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 _ _ tname dname dwname snames src_loc))
1108 = sequenceRn [new_name n src_loc | n <- (tname : dname : dwname : snames)]
1110 getDeclSysBinders new_name (TyClD (TyData _ _ _ _ cons _ _ _ _))
1111 = sequenceRn [new_name wkr_name src_loc | ConDecl _ wkr_name _ _ _ src_loc <- cons]
1113 getDeclSysBinders new_name other_decl
1117 %*********************************************************
1119 \subsection{Reading an interface file}
1121 %*********************************************************
1124 findAndReadIface :: SDoc -> ModuleName
1125 -> IsBootInterface -- True <=> Look for a .hi-boot file
1126 -- False <=> Look for .hi file
1127 -> RnM d (Either Message ParsedIface)
1128 -- Nothing <=> file not found, or unreadable, or illegible
1129 -- Just x <=> successfully found and parsed
1131 findAndReadIface doc_str mod_name hi_boot_file
1132 = traceRn trace_msg `thenRn_`
1133 -- we keep two maps for interface files,
1134 -- one for 'normal' ones, the other for .hi-boot files,
1135 -- hence the need to signal which kind we're interested.
1137 getHiMaps `thenRn` \ (search_path, hi_map, hiboot_map) ->
1139 relevant_map | hi_boot_file = hiboot_map
1140 | otherwise = hi_map
1142 case lookupFM relevant_map mod_name of
1144 Just fpath -> traceRn (ptext SLIT("...reading from") <+> text fpath) `thenRn_`
1145 readIface mod_name fpath
1148 Nothing -> traceRn (ptext SLIT("...not found")) `thenRn_`
1149 returnRn (Left (noIfaceErr mod_name hi_boot_file search_path))
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 :: ModuleName -> String -> RnM d (Either Message ParsedIface)
1163 -- Nothing <=> file not found, or unreadable, or illegible
1164 -- Just x <=> successfully found and parsed
1165 readIface wanted_mod file_path
1166 = ioToRnM (hGetStringBuffer False file_path) `thenRn` \ read_result ->
1169 case parseIface contents
1170 PState{ bol = 0#, atbol = 1#,
1173 loc = mkSrcLoc (mkFastString file_path) 1 } of
1174 POk _ (PIface iface) ->
1175 warnCheckRn (read_mod == wanted_mod)
1176 (hiModuleNameMismatchWarn wanted_mod read_mod) `thenRn_`
1177 returnRn (Right iface)
1179 read_mod = moduleName (pi_mod iface)
1181 PFailed err -> bale_out err
1182 parse_result -> bale_out empty
1183 -- This last case can happen if the interface file is (say) empty
1184 -- in which case the parser thinks it looks like an IdInfo or
1185 -- something like that. Just an artefact of the fact that the
1186 -- parser is used for several purposes at once.
1188 Left io_err -> bale_out (text (show io_err))
1190 bale_out err = returnRn (Left (badIfaceFile file_path err))
1193 %*********************************************************
1197 %*********************************************************
1200 noIfaceErr mod_name boot_file search_path
1201 = vcat [ptext SLIT("Could not find interface file for") <+> quotes (pprModuleName mod_name),
1202 ptext SLIT("in the directories") <+>
1203 -- \& to avoid cpp interpreting this string as a
1204 -- comment starter with a pre-4.06 mkdependHS --SDM
1205 vcat [ text dir <> text "/\&*" <> pp_suffix suffix
1206 | (dir,suffix) <- search_path]
1209 pp_suffix suffix | boot_file = ptext SLIT(".hi-boot")
1210 | otherwise = text suffix
1212 badIfaceFile file err
1213 = vcat [ptext SLIT("Bad interface file:") <+> text file,
1217 = vcat [ptext SLIT("Failed to find interface decl for") <+> quotes (ppr name),
1218 ptext SLIT("from module") <+> quotes (ppr (nameModule name))
1221 getDeclWarn name loc
1222 = sep [ptext SLIT("Failed to find (optional) interface decl for") <+> quotes (ppr name),
1223 ptext SLIT("desired at") <+> ppr loc]
1227 "Compiler tried to import decl from interface file with same name as module."),
1229 "(possible cause: module name clashes with interface file already in scope.)")
1231 hsep [ptext SLIT("name:"), quotes (ppr name)]
1233 warnRedundantSourceImport mod_name
1234 = ptext SLIT("Unnecessary {- SOURCE -} in the import of module")
1235 <+> quotes (pprModuleName mod_name)
1237 hiModuleNameMismatchWarn :: ModuleName -> ModuleName -> Message
1238 hiModuleNameMismatchWarn requested_mod read_mod =
1239 hsep [ ptext SLIT("Something is amiss; requested module name")
1240 , pprModuleName requested_mod
1241 , ptext SLIT("differs from name found in the interface file")
1242 , pprModuleName read_mod