2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 \section[RnIfaces]{Cacheing and Renaming of Interfaces}
12 getInterfaceExports, getDeferredDecls,
13 getImportedInstDecls, getImportedRules,
14 lookupFixityRn, loadHomeInterface,
15 importDecl, ImportDeclResult(..), recordLocalSlurps, loadBuiltinRules,
16 mkImportExportInfo, getSlurped,
18 checkModUsage, outOfDate, upToDate,
20 getDeclBinders, getDeclSysBinders,
21 removeContext -- removeContext probably belongs somewhere else
26 #include "HsVersions.h"
28 import CmdLineOpts ( opt_NoPruneDecls, opt_NoPruneTyDecls, opt_IgnoreIfacePragmas )
29 import HsSyn ( HsDecl(..), TyClDecl(..), InstDecl(..), IfaceSig(..),
30 HsType(..), ConDecl(..), IE(..), ConDetails(..), Sig(..),
31 ForeignDecl(..), ForKind(..), isDynamicExtName,
32 FixitySig(..), RuleDecl(..),
33 isClassOpSig, DeprecDecl(..)
35 import HsImpExp ( ieNames )
36 import CoreSyn ( CoreRule )
37 import BasicTypes ( Version, NewOrData(..) )
38 import RdrHsSyn ( RdrNameHsDecl, RdrNameInstDecl, RdrNameRuleDecl,
39 RdrNameDeprecation, RdrNameIE,
44 import ParseIface ( parseIface, IfaceStuff(..) )
46 import Name ( Name {-instance NamedThing-}, nameOccName,
47 nameModule, isLocallyDefined,
48 {-isWiredInName, -} NamedThing(..),
49 elemNameEnv, extendNameEnv
51 import Module ( Module, mkVanillaModule,
52 moduleName, isModuleInThisPackage,
53 ModuleName, WhereFrom(..),
55 import RdrName ( RdrName, rdrNameOcc )
57 import SrcLoc ( mkSrcLoc, SrcLoc )
58 import PrelInfo ( cCallishTyKeys )
59 import Maybes ( maybeToBool )
60 import Unique ( Uniquable(..) )
61 import StringBuffer ( hGetStringBuffer )
62 import FastString ( mkFastString )
63 import ErrUtils ( Message )
64 import Util ( sortLt )
74 import Panic ( panic )
75 lookupFixityRn = panic "lookupFixityRn"
76 findAndReadIface = panic "findAndReadIface"
77 getInterfaceExports = panic "getInterfaceExports"
78 getDeclBinders = panic "getDeclBinders"
79 recordLocalSlurps = panic "recordLocalSlurps"
80 checkModUsage = panic "checkModUsage"
81 outOfDate = panic "outOfDate"
82 getSlurped = panic "getSlurped"
83 removeContext = panic "removeContext"
84 loadBuiltinRules = panic "loadBuiltinRules"
85 getDeferredDecls = panic "getDeferredDecls"
90 | HereItIs (Module, RdrNameHsDecl)
91 getImportedInstDecls = panic "getImportedInstDecls"
92 importDecl = panic "importDecl"
93 mkImportExportInfo = panic "mkImportExportInfo"
94 getImportedRules = panic "getImportedRules"
99 %*********************************************************
101 \subsection{Loading a new interface file}
103 %*********************************************************
106 loadHomeInterface :: SDoc -> Name -> RnM d Ifaces
107 loadHomeInterface doc_str name
108 = loadInterface doc_str (moduleName (nameModule name)) ImportBySystem
110 loadOrphanModules :: [ModuleName] -> RnM d ()
111 loadOrphanModules mods
112 | null mods = returnRn ()
113 | otherwise = traceRn (text "Loading orphan modules:" <+>
114 fsep (map mods)) `thenRn_`
115 mapRn_ load mods `thenRn_`
118 load mod = loadInterface (mk_doc mod) mod ImportBySystem
119 mk_doc mod = ppr mod <+> ptext SLIT("is a orphan-instance module")
122 loadInterface :: SDoc -> ModuleName -> WhereFrom -> RnM d Ifaces
123 loadInterface doc mod from
124 = tryLoadInterface doc mod from `thenRn` \ (ifaces, maybe_err) ->
126 Nothing -> returnRn ifaces
127 Just err -> failWithRn ifaces err
129 tryLoadInterface :: SDoc -> ModuleName -> WhereFrom -> RnM d (Ifaces, Maybe Message)
130 -- Returns (Just err) if an error happened
131 -- Guarantees to return with iImpModInfo m --> (... Just cts)
132 -- (If the load fails, we plug in a vanilla placeholder
133 tryLoadInterface doc_str mod_name from
134 = getIfacesRn `thenRn` \ ifaces ->
136 mod_map = iImpModInfo ifaces
137 mod_info = lookupFM mod_map mod_name
140 = case (from, mod_info) of
141 (ImportByUser, _) -> False -- Not hi-boot
142 (ImportByUserSource, _) -> True -- hi-boot
143 (ImportBySystem, Just (_, is_boot, _)) -> is_boot --
144 (ImportBySystem, Nothing) -> False
145 -- We're importing a module we know absolutely
146 -- nothing about, so we assume it's from
147 -- another package, where we aren't doing
148 -- dependency tracking. So it won't be a hi-boot file.
150 redundant_source_import
151 = case (from, mod_info) of
152 (ImportByUserSource, Just (_,False,_)) -> True
155 -- CHECK WHETHER WE HAVE IT ALREADY
158 -> -- We're read it already so don't re-read it
159 returnRn (ifaces, Nothing) ;
163 -- Issue a warning for a redundant {- SOURCE -} import
164 -- NB that we arrange to read all the ordinary imports before
165 -- any of the {- SOURCE -} imports
166 warnCheckRn (not redundant_source_import)
167 (warnRedundantSourceImport mod_name) `thenRn_`
169 -- READ THE MODULE IN
170 findAndReadIface doc_str mod_name hi_boot_file `thenRn` \ read_resultb ->
171 case read_result of {
172 Left err -> -- Not found, so add an empty export env to the Ifaces map
173 -- so that we don't look again
175 new_mod_map = addToFM mod_map mod_name (False, False, True)
176 new_ifaces = ifaces { iImpModInfo = new_mod_map }
178 setIfacesRn new_ifaces `thenRn_`
179 returnRn (new_ifaces, Just err) ;
182 Right (mod, iface) ->
184 -- LOAD IT INTO Ifaces
186 -- NB: *first* we do loadDecl, so that the provenance of all the locally-defined
187 --- names is done correctly (notably, whether this is an .hi file or .hi-boot file).
188 -- If we do loadExport first the wrong info gets into the cache (unless we
189 -- explicitly tag each export which seems a bit of a bore)
192 -- Sanity check. If we're system-importing a module we know nothing at all
193 -- about, it should be from a different package to this one
194 WARN( not (maybeToBool mod_info) &&
195 case from of { ImportBySystem -> True; other -> False } &&
196 isModuleInThisPackage mod,
199 loadDecls mod (iDecls ifaces) (pi_decls iface) `thenRn` \ (decls_vers, new_decls) ->
200 loadRules mod (iRules ifaces) (pi_rules iface) `thenRn` \ (rule_vers, new_rules) ->
201 loadFixDecls mod_name (pi_fixity iface) `thenRn` \ (fix_vers, fix_env) ->
202 foldlRn (loadDeprec mod) emptyDeprecEnv (pi_deprecs iface) `thenRn` \ deprec_env ->
203 foldlRn (loadInstDecl mod) (iInsts ifaces) (pi_insts iface) `thenRn` \ new_insts ->
204 loadExports (pi_exports iface) `thenRn` \ avails ->
206 version = VersionInfo { modVers = pi_vers iface,
208 ruleVers = rule_vers,
209 declVers = decl_vers }
211 -- For an explicit user import, add to mod_map info about
212 -- the things the imported module depends on, extracted
213 -- from its usage info.
214 mod_map1 = case from of
215 ImportByUser -> addModDeps mod (pi_usages iface) mod_map
217 mod_map2 = addToFM mod_map1 mod_name (pi_orphan iface, hi_boot_file, True)
219 -- Now add info about this module to the PST
220 new_pst = extendModuleEnv pst mod mod_detils
221 mod_details = ModDetails { mdModule = mod, mvVersion = version,
223 mdFixEnv = fix_env, mdDeprecEnv = deprec_env }
225 new_ifaces = ifaces { iPST = new_pst,
229 iImpModInfo = mod_map2 }
231 setIfacesRn new_ifaces `thenRn_`
232 returnRn (new_ifaces, Nothing)
235 -----------------------------------------------------
236 -- Adding module dependencies from the
237 -- import decls in the interface file
238 -----------------------------------------------------
240 addModDeps :: Module -> PackageSymbolTable -> [ImportVersion a]
241 -> ImportedModuleInfo -> ImportedModuleInfo
242 -- (addModDeps M ivs deps)
243 -- We are importing module M, and M.hi contains 'import' decls given by ivs
244 addModDeps mod new_deps mod_deps
245 = foldr add mod_deps filtered_new_deps
247 -- Don't record dependencies when importing a module from another package
248 -- Except for its descendents which contain orphans,
249 -- and in that case, forget about the boot indicator
250 filtered_new_deps :: (ModuleName, (WhetherHasOrphans, IsBootInterface))
252 | isModuleInThisPackage mod
253 = [ (imp_mod, (has_orphans, is_boot, False))
254 | (imp_mod, has_orphans, is_boot, _) <- new_deps
256 | otherwise = [ (imp_mod, (True, False, False))
257 | (imp_mod, has_orphans, _, _) <- new_deps,
260 add (imp_mod, dep) deps = addToFM_C combine deps imp_mod dep
262 combine old@(_, old_is_boot, old_is_loaded) new
263 | old_is_loaded || not old_is_boot = old -- Keep the old info if it's already loaded
264 -- or if it's a non-boot pending load
265 | otherwise = new -- Otherwise pick new info
268 -----------------------------------------------------
269 -- Loading the export list
270 -----------------------------------------------------
272 loadExports :: [ExportItem] -> RnM d Avails
274 = getModuleRn `thenRn` \ this_mod ->
275 mapRn (loadExport this_mod) items `thenRn` \ avails_s ->
276 returnRn (concat avails_s)
279 loadExport :: Module -> ExportItem -> RnM d [AvailInfo]
280 loadExport this_mod (mod, entities)
281 | mod == moduleName this_mod = returnRn []
282 -- If the module exports anything defined in this module, just ignore it.
283 -- Reason: otherwise it looks as if there are two local definition sites
284 -- for the thing, and an error gets reported. Easiest thing is just to
285 -- filter them out up front. This situation only arises if a module
286 -- imports itself, or another module that imported it. (Necessarily,
287 -- this invoves a loop.) Consequence: if you say
292 -- module B( AType ) where
293 -- import {-# SOURCE #-} A( AType )
295 -- then you'll get a 'B does not export AType' message. A bit bogus
296 -- but it's a bogus thing to do!
299 = mapRn (load_entity mod) entities
301 new_name mod occ = newGlobalName mod occ
303 load_entity mod (Avail occ)
304 = new_name mod occ `thenRn` \ name ->
305 returnRn (Avail name)
306 load_entity mod (AvailTC occ occs)
307 = new_name mod occ `thenRn` \ name ->
308 mapRn (new_name mod) occs `thenRn` \ names ->
309 returnRn (AvailTC name names)
312 -----------------------------------------------------
313 -- Loading type/class/value decls
314 -----------------------------------------------------
318 -> [(Version, RdrNameHsDecl)]
319 -> RnM d (NameEnv Version, DeclsMap)
320 loadDecls mod decls_map decls
321 = foldlRn (loadDecl mod) (emptyNameEnv, decls_map) decls
324 -> (NameEnv Version, DeclsMap)
325 -> (Version, RdrNameHsDecl)
326 -> RnM d (NameEnv Version, DeclsMap)
327 loadDecl mod (version_map, decls_map) (version, decl)
328 = getDeclBinders new_name decl `thenRn` \ maybe_avail ->
329 case maybe_avail of {
330 Nothing -> returnRn (version_map, decls_map); -- No bindings
333 getDeclSysBinders new_name decl `thenRn` \ sys_bndrs ->
335 full_avail = addSysAvails avail sys_bndrs
336 -- Add the sys-binders to avail. When we import the decl,
337 -- it's full_avail that will get added to the 'already-slurped' set (iSlurp)
338 -- If we miss out sys-binders, we'll read the decl multiple times!
340 main_name = availName avail
341 new_decls_map = foldl add_decl decls_map
342 [ (name, (full_avail, name==main_name, (mod, decl')))
343 | name <- availNames full_avail]
344 add_decl decls_map (name, stuff)
345 = WARN( name `elemNameEnv` decls_map, ppr name )
346 extendNameEnv decls_map name stuff
348 new_version_map = extendNameEnv version_map main_name version
350 returnRn (new_version_map, new_decls_map)
353 -- newTopBinder puts into the cache the binder with the
354 -- module information set correctly. When the decl is later renamed,
355 -- the binding site will thereby get the correct module.
356 -- There maybe occurrences that don't have the correct Module, but
357 -- by the typechecker will propagate the binding definition to all
358 -- the occurrences, so that doesn't matter
359 new_name rdr_name loc = newTopBinder mod rdr_name loc
362 If a signature decl is being loaded, and optIgnoreIfacePragmas is on,
363 we toss away unfolding information.
365 Also, if the signature is loaded from a module we're importing from source,
366 we do the same. This is to avoid situations when compiling a pair of mutually
367 recursive modules, peering at unfolding info in the interface file of the other,
368 e.g., you compile A, it looks at B's interface file and may as a result change
369 its interface file. Hence, B is recompiled, maybe changing its interface file,
370 which will the unfolding info used in A to become invalid. Simple way out is to
371 just ignore unfolding info.
373 [Jan 99: I junked the second test above. If we're importing from an hi-boot
374 file there isn't going to *be* any pragma info. Maybe the above comment
375 dates from a time where we picked up a .hi file first if it existed?]
378 SigD (IfaceSig name tp ls loc) | opt_IgnoreIfacePragmas
379 -> SigD (IfaceSig name tp [] loc)
382 -----------------------------------------------------
383 -- Loading fixity decls
384 -----------------------------------------------------
386 loadFixDecls mod_name (version, decls)
387 | null decls = returnRn (version, emptyNameEnv)
390 = mapRn (loadFixDecl mod_name) decls `thenRn` \ to_add ->
391 returnRn (version, mkNameEnv to_add)
393 loadFixDecl mod_name sig@(FixitySig rdr_name fixity loc)
394 = newGlobalName mod_name (rdrNameOcc rdr_name) `thenRn` \ name ->
395 returnRn (name, FixitySig name fixity loc)
398 -----------------------------------------------------
399 -- Loading instance decls
400 -----------------------------------------------------
402 loadInstDecl :: Module
406 loadInstDecl mod insts decl@(InstDecl inst_ty binds uprags dfun_name src_loc)
408 -- Find out what type constructors and classes are "gates" for the
409 -- instance declaration. If all these "gates" are slurped in then
410 -- we should slurp the instance decl too.
412 -- We *don't* want to count names in the context part as gates, though.
414 -- instance Foo a => Baz (T a) where ...
416 -- Here the gates are Baz and T, but *not* Foo.
418 munged_inst_ty = removeContext inst_ty
419 free_names = extractHsTyRdrNames munged_inst_ty
422 mapRn lookupOrigName free_names `thenRn` \ gate_names ->
423 returnRn ((mkNameSet gate_names, (mod, InstD decl)) `consBag` insts)
426 -- In interface files, the instance decls now look like
427 -- forall a. Foo a -> Baz (T a)
428 -- so we have to strip off function argument types as well
429 -- as the bit before the '=>' (which is always empty in interface files)
430 removeContext (HsForAllTy tvs cxt ty) = HsForAllTy tvs [] (removeFuns ty)
431 removeContext ty = removeFuns ty
433 removeFuns (HsFunTy _ ty) = removeFuns ty
437 -----------------------------------------------------
439 -----------------------------------------------------
441 loadRules :: Module -> IfaceRules
442 -> (Version, [RdrNameRuleDecl])
443 -> RnM d (Version, IfaceRules)
444 loadRules mod rule_bag (version, rules)
445 | null rules || opt_IgnoreIfacePragmas
446 = returnRn (version, rule_bag)
449 mapRn (loadRule mod) rules `thenRn` \ new_rules ->
450 returnRn (version, rule_bag `unionBags` listToBag new_rules)
452 loadRule :: Module -> RdrNameRuleDecl -> RnM d GatedDecl
453 -- "Gate" the rule simply by whether the rule variable is
454 -- needed. We can refine this later.
455 loadRule mod decl@(IfaceRule _ _ var _ _ src_loc)
456 = lookupOrigName var `thenRn` \ var_name ->
457 returnRn (unitNameSet var_name, (mod, RuleD decl))
459 loadBuiltinRules :: [(RdrName, CoreRule)] -> RnMG ()
460 loadBuiltinRules builtin_rules
461 = getIfacesRn `thenRn` \ ifaces ->
462 mapRn loadBuiltinRule builtin_rules `thenRn` \ rule_decls ->
463 setIfacesRn (ifaces { iRules = iRules ifaces `unionBags` listToBag rule_decls })
465 loadBuiltinRule (var, rule)
466 = lookupOrigName var `thenRn` \ var_name ->
467 returnRn (unitNameSet var_name, (nameModule var_name, RuleD (IfaceRuleOut var rule)))
470 -----------------------------------------------------
471 -- Loading Deprecations
472 -----------------------------------------------------
474 loadDeprec :: Module -> DeprecationEnv -> RdrNameDeprecation -> RnM d DeprecationEnv
475 loadDeprec mod deprec_env (Deprecation (IEModuleContents _) txt _)
476 = traceRn (text "module deprecation not yet implemented:" <+> ppr mod <> colon <+> ppr txt) `thenRn_`
477 -- SUP: TEMPORARY HACK, ignoring module deprecations for now
480 loadDeprec mod deprec_env (Deprecation ie txt _)
482 mapRn lookupOrigName (ieNames ie) `thenRn` \ names ->
483 traceRn (text "loaded deprecation(s) for" <+> hcat (punctuate comma (map ppr names)) <> colon <+> ppr txt) `thenRn_`
484 returnRn (extendNameEnvList deprec_env (zip names (repeat txt)))
488 %********************************************************
490 \subsection{Checking usage information}
492 %********************************************************
498 checkModUsage :: [ImportVersion OccName] -> RnMG Bool
499 -- Given the usage information extracted from the old
500 -- M.hi file for the module being compiled, figure out
501 -- whether M needs to be recompiled.
503 checkModUsage [] = returnRn upToDate -- Yes! Everything is up to date!
505 checkModUsage ((mod_name, _, _, NothingAtAll) : rest)
506 -- If CurrentModule.hi contains
508 -- then that simply records that Foo lies below CurrentModule in the
509 -- hierarchy, but CurrentModule doesn't depend in any way on Foo.
510 -- In this case we don't even want to open Foo's interface.
511 = traceRn (ptext SLIT("Nothing used from:") <+> ppr mod_name) `thenRn_`
512 checkModUsage rest -- This one's ok, so check the rest
514 checkModUsage ((mod_name, _, _, whats_imported) : rest)
515 = tryLoadInterface doc_str mod_name ImportBySystem `thenRn` \ (ifaces, maybe_err) ->
517 Just err -> out_of_date (sep [ptext SLIT("Can't find version number for module"),
519 -- Couldn't find or parse a module mentioned in the
520 -- old interface file. Don't complain -- it might just be that
521 -- the current module doesn't need that import and it's been deleted
525 (_, new_mod_vers, new_fix_vers, new_rule_vers, _, _)
526 = case lookupFM (iImpModInfo ifaces) mod_name of
527 Just (_, _, Just stuff) -> stuff
529 old_mod_vers = case whats_imported of
531 Specifically v _ _ _ -> v
532 -- NothingAtAll case dealt with by previous eqn for checkModUsage
534 -- If the module version hasn't changed, just move on
535 if new_mod_vers == old_mod_vers then
536 traceRn (sep [ptext SLIT("Module version unchanged:"), ppr mod_name])
537 `thenRn_` checkModUsage rest
539 traceRn (sep [ptext SLIT("Module version has changed:"), ppr mod_name])
541 -- Module version changed, so check entities inside
543 -- If the usage info wants to say "I imported everything from this module"
544 -- it does so by making whats_imported equal to Everything
545 -- In that case, we must recompile
546 case whats_imported of { -- NothingAtAll dealt with earlier
549 -> out_of_date (ptext SLIT("...and I needed the whole module")) ;
551 Specifically _ old_fix_vers old_rule_vers old_local_vers ->
553 if old_fix_vers /= new_fix_vers then
554 out_of_date (ptext SLIT("Fixities changed"))
555 else if old_rule_vers /= new_rule_vers then
556 out_of_date (ptext SLIT("Rules changed"))
558 -- Non-empty usage list, so check item by item
559 checkEntityUsage mod_name (iDecls ifaces) old_local_vers `thenRn` \ up_to_date ->
561 traceRn (ptext SLIT("...but the bits I use haven't.")) `thenRn_`
562 checkModUsage rest -- This one's ok, so check the rest
564 returnRn outOfDate -- This one failed, so just bail out now
567 doc_str = sep [ptext SLIT("need version info for"), ppr mod_name]
570 checkEntityUsage mod decls []
571 = returnRn upToDate -- Yes! All up to date!
573 checkEntityUsage mod decls ((occ_name,old_vers) : rest)
574 = newGlobalName mod occ_name `thenRn` \ name ->
575 case lookupNameEnv decls name of
577 Nothing -> -- We used it before, but it ain't there now
578 out_of_date (sep [ptext SLIT("No longer exported:"), ppr name])
580 Just (new_vers,_,_,_) -- It's there, but is it up to date?
581 | new_vers == old_vers
582 -- Up to date, so check the rest
583 -> checkEntityUsage mod decls rest
586 -- Out of date, so bale out
587 -> out_of_date (sep [ptext SLIT("Out of date:"), ppr name])
589 out_of_date msg = traceRn msg `thenRn_` returnRn outOfDate
593 %*********************************************************
595 \subsection{Getting in a declaration}
597 %*********************************************************
600 importDecl :: Name -> RnMG ImportDeclResult
602 data ImportDeclResult
606 | HereItIs (Module, RdrNameHsDecl)
609 = getIfacesRn `thenRn` \ ifaces ->
610 getHomeSymbolTableRn `thenRn` \ hst ->
611 if name `elemNameSet` iSlurp ifaces
612 || inTypeEnv (iPST ifaces) name
613 || inTypeEnv hst name
614 then -- Already dealt with
615 returnRn AlreadySlurped
617 else if isLocallyDefined name then -- Don't bring in decls from
618 -- the renamed module's own interface file
619 addWarnRn (importDeclWarn name) `thenRn_`
620 returnRn AlreadySlurped
622 else if isWiredInName name then
623 -- When we find a wired-in name we must load its
624 -- home module so that we find any instance decls therein
625 loadHomeInterface doc name `thenRn_`
628 else getNonWiredInDecl name
630 doc = ptext SLIT("need home module for wired in thing") <+> ppr name
632 getNonWiredInDecl :: Name -> RnMG ImportDeclResult
633 getNonWiredInDecl needed_name
634 = traceRn doc_str `thenRn_`
635 loadHomeInterface doc_str needed_name `thenRn` \ ifaces ->
636 case lookupNameEnv (iDecls ifaces) needed_name of
638 Just (version, avail, is_tycon_name, decl@(_, TyClD (TyData DataType _ _ _ _ ncons _ _ _ _ _)))
639 -- This case deals with deferred import of algebraic data types
641 | not opt_NoPruneTyDecls
643 && (opt_IgnoreIfacePragmas || ncons > 1)
644 -- We only defer if imported interface pragmas are ingored
645 -- or if it's not a product type.
646 -- Sole reason: The wrapper for a strict function may need to look
647 -- inside its arg, and hence need to see its arg type's constructors.
649 && not (getUnique tycon_name `elem` cCallishTyKeys)
650 -- Never defer ccall types; we have to unbox them,
651 -- and importing them does no harm
653 -> -- OK, so we're importing a deferrable data type
654 if needed_name == tycon_name then
655 -- The needed_name is the TyCon of a data type decl
656 -- Record that it's slurped, put it in the deferred set
657 -- and don't return a declaration at all
658 setIfacesRn (recordSlurp (ifaces {iDeferred = iDeferred ifaces
659 `addOneToNameSet` tycon_name})
660 version (AvailTC needed_name [needed_name])) `thenRn_`
663 -- The needed name is a constructor of a data type decl,
664 -- getting a constructor, so remove the TyCon from the deferred set
665 -- (if it's there) and return the full declaration
666 setIfacesRn (recordSlurp (ifaces {iDeferred = iDeferred ifaces
667 `delFromNameSet` tycon_name})
668 version avail) `thenRn_`
669 returnRn (HereItIs decl)
671 tycon_name = availName avail
673 Just (version,avail,_,decl)
674 -> setIfacesRn (recordSlurp ifaces version avail) `thenRn_`
675 returnRn (HereItIs decl)
678 -> addErrRn (getDeclErr needed_name) `thenRn_`
679 returnRn AlreadySlurped
681 doc_str = ptext SLIT("need decl for") <+> ppr needed_name
683 getDeferredDecls :: RnMG [(Module, RdrNameHsDecl)]
685 = getIfacesRn `thenRn` \ ifaces ->
687 decls_map = iDecls ifaces
688 deferred_names = nameSetToList (iDeferred ifaces)
689 get_abstract_decl n = case lookupNameEnv decls_map n of
690 Just (_, _, _, decl) -> decl
692 traceRn (sep [text "getDeferredDecls", nest 4 (fsep (map ppr deferred_names))]) `thenRn_`
693 returnRn (map get_abstract_decl deferred_names)
696 @getWiredInDecl@ maps a wired-in @Name@ to what it makes available.
697 It behaves exactly as if the wired in decl were actually in an interface file.
700 \item if the wired-in name is a data type constructor or a data constructor,
701 it brings in the type constructor and all the data constructors; and
702 marks as ``occurrences'' any free vars of the data con.
704 \item similarly for synonum type constructor
706 \item if the wired-in name is another wired-in Id, it marks as ``occurrences''
707 the free vars of the Id's type.
709 \item it loads the interface file for the wired-in thing for the
710 sole purpose of making sure that its instance declarations are available
712 All this is necessary so that we know all types that are ``in play'', so
713 that we know just what instances to bring into scope.
718 %*********************************************************
720 \subsection{Getting what a module exports}
722 %*********************************************************
724 @getInterfaceExports@ is called only for directly-imported modules.
727 getInterfaceExports :: ModuleName -> WhereFrom -> RnMG (Module, Avails)
728 getInterfaceExports mod_name from
729 = getHomeSymbolTableRn `thenRn` \ hst ->
730 case lookupModuleEnvByName hst mod_name of {
731 Just mds -> returnRn (mdModule mds, mdExports mds) ;
732 Nothing -> pprPanic "getInterfaceExports" (ppr mod_name)
734 -- I think this is what it _used_ to say. JRS, 001017
735 -- loadInterface doc_str mod_name from `thenRn` \ ifaces ->
736 -- case lookupModuleEnv (iPST ifaces) mod_name of
737 -- Just mds -> returnRn (mdModule mod, mdExports mds)
738 -- -- loadInterface always puts something in the map
739 -- -- even if it's a fake
743 doc_str = sep [ppr mod_name, ptext SLIT("is directly imported")]
747 %*********************************************************
749 \subsection{Instance declarations are handled specially}
751 %*********************************************************
754 getImportedInstDecls :: NameSet -> RnMG [(Module,RdrNameHsDecl)]
755 getImportedInstDecls gates
756 = -- First, load any orphan-instance modules that aren't aready loaded
757 -- Orphan-instance modules are recorded in the module dependecnies
758 getIfacesRn `thenRn` \ ifaces ->
761 [mod | (mod, (True, _, Nothing)) <- fmToList (iImpModInfo ifaces)]
763 loadOrphanModules orphan_mods `thenRn_`
765 -- Now we're ready to grab the instance declarations
766 -- Find the un-gated ones and return them,
767 -- removing them from the bag kept in Ifaces
768 getIfacesRn `thenRn` \ ifaces ->
770 (decls, new_insts) = selectGated gates (iInsts ifaces)
772 setIfacesRn (ifaces { iInsts = new_insts }) `thenRn_`
774 traceRn (sep [text "getImportedInstDecls:",
775 nest 4 (fsep (map ppr gate_list)),
776 text "Slurped" <+> int (length decls) <+> text "instance declarations",
777 nest 4 (vcat (map ppr_brief_inst_decl decls))]) `thenRn_`
780 gate_list = nameSetToList gates
782 ppr_brief_inst_decl (mod, InstD (InstDecl inst_ty _ _ _ _))
784 HsForAllTy _ _ tau -> ppr tau
787 getImportedRules :: RnMG [(Module,RdrNameHsDecl)]
789 | opt_IgnoreIfacePragmas = returnRn []
791 = getIfacesRn `thenRn` \ ifaces ->
793 gates = iSlurp ifaces -- Anything at all that's been slurped
794 rules = iRules ifaces
795 (decls, new_rules) = selectGated gates rules
800 setIfacesRn (ifaces { iRules = new_rules }) `thenRn_`
801 traceRn (sep [text "getImportedRules:",
802 text "Slurped" <+> int (length decls) <+> text "rules"]) `thenRn_`
805 selectGated gates decl_bag
806 -- Select only those decls whose gates are *all* in 'gates'
808 | opt_NoPruneDecls -- Just to try the effect of not gating at all
809 = (foldrBag (\ (_,d) ds -> d:ds) [] decl_bag, emptyBag) -- Grab them all
813 = foldrBag select ([], emptyBag) decl_bag
815 select (reqd, decl) (yes, no)
816 | isEmptyNameSet (reqd `minusNameSet` gates) = (decl:yes, no)
817 | otherwise = (yes, (reqd,decl) `consBag` no)
819 lookupFixityRn :: Name -> RnMS Fixity
821 | isLocallyDefined name
822 = getFixityEnv `thenRn` \ local_fix_env ->
823 returnRn (lookupLocalFixity local_fix_env name)
825 | otherwise -- Imported
826 -- For imported names, we have to get their fixities by doing a loadHomeInterface,
827 -- and consulting the Ifaces that comes back from that, because the interface
828 -- file for the Name might not have been loaded yet. Why not? Suppose you import module A,
829 -- which exports a function 'f', which is defined in module B. Then B isn't loaded
830 -- right away (after all, it's possible that nothing from B will be used).
831 -- When we come across a use of 'f', we need to know its fixity, and it's then,
832 -- and only then, that we load B.hi. That is what's happening here.
833 = getHomeSymbolTableRn `thenRn` \ hst ->
834 case lookupFixityEnv hst name of {
835 Just fixity -> returnRn fixity ;
838 loadHomeInterface doc name `thenRn` \ ifaces ->
839 returnRn (lookupFixityEnv (iPST ifaces) name `orElse` defaultFixity)
842 doc = ptext SLIT("Checking fixity for") <+> ppr name
846 %*********************************************************
848 \subsection{Keeping track of what we've slurped, and version numbers}
850 %*********************************************************
852 getImportVersions figures out what the ``usage information'' for this
853 moudule is; that is, what it must record in its interface file as the
854 things it uses. It records:
857 \item (a) anything reachable from its body code
858 \item (b) any module exported with a @module Foo@
859 \item (c) anything reachable from an exported item
862 Why (b)? Because if @Foo@ changes then this module's export list
863 will change, so we must recompile this module at least as far as
864 making a new interface file --- but in practice that means complete
867 Why (c)? Consider this:
869 module A( f, g ) where | module B( f ) where
870 import B( f ) | f = h 3
874 Here, @B.f@ isn't used in A. Should we nevertheless record @B.f@ in
875 @A@'s usages? Our idea is that we aren't going to touch A.hi if it is
876 *identical* to what it was before. If anything about @B.f@ changes
877 than anyone who imports @A@ should be recompiled in case they use
878 @B.f@ (they'll get an early exit if they don't). So, if anything
879 about @B.f@ changes we'd better make sure that something in A.hi
880 changes, and the convenient way to do that is to record the version
881 number @B.f@ in A.hi in the usage list. If B.f changes that'll force a
882 complete recompiation of A, which is overkill but it's the only way to
883 write a new, slightly different, A.hi.
885 But the example is tricker. Even if @B.f@ doesn't change at all,
886 @B.h@ may do so, and this change may not be reflected in @f@'s version
887 number. But with -O, a module that imports A must be recompiled if
888 @B.h@ changes! So A must record a dependency on @B.h@. So we treat
889 the occurrence of @B.f@ in the export list *just as if* it were in the
890 code of A, and thereby haul in all the stuff reachable from it.
892 [NB: If B was compiled with -O, but A isn't, we should really *still*
893 haul in all the unfoldings for B, in case the module that imports A *is*
894 compiled with -O. I think this is the case.]
896 Even if B is used at all we get a usage line for B
897 import B <n> :: ... ;
898 in A.hi, to record the fact that A does import B. This is used to decide
899 to look to look for B.hi rather than B.hi-boot when compiling a module that
900 imports A. This line says that A imports B, but uses nothing in it.
901 So we'll get an early bale-out when compiling A if B's version changes.
904 mkImportExportInfo :: ModuleName -- Name of this module
905 -> Avails -- Info about exports
906 -> Maybe [RdrNameIE] -- The export header
907 -> RnMG ([ExportItem], -- Export info for iface file; sorted
908 [ImportVersion OccName]) -- Import info for iface file; sorted
909 -- Both results are sorted into canonical order to
910 -- reduce needless wobbling of interface files
912 mkImportExportInfo this_mod export_avails exports
913 = getIfacesRn `thenRn` \ ifaces ->
915 export_all_mods = case exports of
917 Just es -> [mod | IEModuleContents mod <- es,
920 mod_map = iImpModInfo ifaces
921 imp_names = iVSlurp ifaces
923 -- mv_map groups together all the things imported from a particular module.
924 mv_map :: FiniteMap ModuleName [(OccName,Version)]
925 mv_map = foldr add_mv emptyFM imp_names
927 add_mv (name, version) mv_map = addItem mv_map (moduleName (nameModule name))
928 (nameOccName name, version)
930 -- Build the result list by adding info for each module.
931 -- For (a) a library module, we don't record it at all unless it contains orphans
932 -- (We must never lose track of orphans.)
934 -- (b) a source-imported module, don't record the dependency at all
936 -- (b) may seem a bit strange. The idea is that the usages in a .hi file records
937 -- *all* the module's dependencies other than the loop-breakers. We use
938 -- this info in findAndReadInterface to decide whether to look for a .hi file or
941 -- This means we won't track version changes, or orphans, from .hi-boot files.
942 -- The former is potentially rather bad news. It could be fixed by recording
943 -- whether something is a boot file along with the usage info for it, but
944 -- I can't be bothered just now.
946 mk_imp_info mod_name (has_orphans, is_boot, contents) so_far
947 | mod_name == this_mod -- Check if M appears in the set of modules 'below' M
948 -- This seems like a convenient place to check
949 = WARN( not is_boot, ptext SLIT("Wierd:") <+> ppr this_mod <+>
950 ptext SLIT("imports itself (perhaps indirectly)") )
955 go_for_it exports = (mod_name, has_orphans, is_boot, exports)
959 Nothing -> -- We didn't even open the interface
960 -- This happens when a module, Foo, that we explicitly imported has
961 -- 'import Baz' in its interface file, recording that Baz is below
962 -- Foo in the module dependency hierarchy. We want to propagate this
963 -- information. The Nothing says that we didn't even open the interface
964 -- file but we must still propagate the dependeny info.
965 -- The module in question must be a local module (in the same package)
966 go_for_it NothingAtAll
968 Just (mod, mod_vers, fix_vers, rule_vers, how_imported, _)
969 | is_sys_import && is_lib_module && not has_orphans
972 | is_lib_module -- Record the module but not detailed
973 || mod_name `elem` export_all_mods -- version information for the imports
974 -> go_for_it (Everything mod_vers)
977 -> case lookupFM mv_map mod_name of
978 Just whats_imported -> go_for_it (Specifically mod_vers fix_vers rule_vers
979 (sortImport whats_imported))
980 Nothing -> go_for_it NothingAtAll
981 -- This happens if you have
983 -- but don't actually *use* anything from Foo
984 -- In which case record an empty dependency list
986 is_lib_module = not (isModuleInThisPackage mod)
987 is_sys_import = case how_imported of
988 ImportBySystem -> True
992 import_info = foldFM mk_imp_info [] mod_map
994 -- Sort exports into groups by module
995 export_fm :: FiniteMap ModuleName [RdrAvailInfo]
996 export_fm = foldr insert emptyFM export_avails
998 insert avail efm = addItem efm (moduleName (nameModule (availName avail)))
1001 export_info = [(m, sortExport as) | (m,as) <- fmToList export_fm]
1003 traceRn (text "Modules in Ifaces: " <+> fsep (map ppr (keysFM mod_map))) `thenRn_`
1004 returnRn (export_info, import_info)
1007 addItem :: FiniteMap ModuleName [a] -> ModuleName -> a -> FiniteMap ModuleName [a]
1008 addItem fm mod x = addToFM_C add_item fm mod [x]
1010 add_item xs _ = x:xs
1012 sortImport :: [(OccName,Version)] -> [(OccName,Version)]
1013 -- Make the usage lists appear in canonical order
1014 sortImport vs = sortLt lt vs
1016 lt (n1,v1) (n2,v2) = n1 < n2
1018 sortExport :: [RdrAvailInfo] -> [RdrAvailInfo]
1019 sortExport as = sortLt lt as
1021 lt a1 a2 = availName a1 < availName a2
1026 = getIfacesRn `thenRn` \ ifaces ->
1027 returnRn (iSlurp ifaces)
1029 recordSlurp ifaces@(Ifaces { iSlurp = slurped_names, iVSlurp = imp_names })
1032 new_slurped_names = addAvailToNameSet slurped_names avail
1033 new_imp_names = (availName avail, version) : imp_names
1035 ifaces { iSlurp = new_slurped_names, iVSlurp = new_imp_names }
1037 recordLocalSlurps local_avails
1038 = getIfacesRn `thenRn` \ ifaces ->
1040 new_slurped_names = foldl addAvailToNameSet (iSlurp ifaces) local_avails
1042 setIfacesRn (ifaces { iSlurp = new_slurped_names })
1046 %*********************************************************
1048 \subsection{Getting binders out of a declaration}
1050 %*********************************************************
1052 @getDeclBinders@ returns the names for a @RdrNameHsDecl@.
1053 It's used for both source code (from @availsFromDecl@) and interface files
1056 It doesn't deal with source-code specific things: @ValD@, @DefD@. They
1057 are handled by the sourc-code specific stuff in @RnNames@.
1060 getDeclBinders :: (RdrName -> SrcLoc -> RnM d Name) -- New-name function
1062 -> RnM d (Maybe AvailInfo)
1064 getDeclBinders new_name (TyClD (TyData _ _ tycon _ condecls _ _ _ src_loc _ _))
1065 = new_name tycon src_loc `thenRn` \ tycon_name ->
1066 getConFieldNames new_name condecls `thenRn` \ sub_names ->
1067 returnRn (Just (AvailTC tycon_name (tycon_name : nub sub_names)))
1068 -- The "nub" is because getConFieldNames can legitimately return duplicates,
1069 -- when a record declaration has the same field in multiple constructors
1071 getDeclBinders new_name (TyClD (TySynonym tycon _ _ src_loc))
1072 = new_name tycon src_loc `thenRn` \ tycon_name ->
1073 returnRn (Just (AvailTC tycon_name [tycon_name]))
1075 getDeclBinders new_name (TyClD (ClassDecl _ cname _ _ sigs _ _ _ src_loc))
1076 = new_name cname src_loc `thenRn` \ class_name ->
1078 -- Record the names for the class ops
1080 -- just want class-op sigs
1081 op_sigs = filter isClassOpSig sigs
1083 mapRn (getClassOpNames new_name) op_sigs `thenRn` \ sub_names ->
1085 returnRn (Just (AvailTC class_name (class_name : sub_names)))
1087 getDeclBinders new_name (SigD (IfaceSig var ty prags src_loc))
1088 = new_name var src_loc `thenRn` \ var_name ->
1089 returnRn (Just (Avail var_name))
1091 getDeclBinders new_name (FixD _) = returnRn Nothing
1092 getDeclBinders new_name (DeprecD _) = returnRn Nothing
1094 -- foreign declarations
1095 getDeclBinders new_name (ForD (ForeignDecl nm kind _ dyn _ loc))
1096 | binds_haskell_name kind dyn
1097 = new_name nm loc `thenRn` \ name ->
1098 returnRn (Just (Avail name))
1100 | otherwise -- a foreign export
1101 = lookupOrigName nm `thenRn_`
1104 getDeclBinders new_name (DefD _) = returnRn Nothing
1105 getDeclBinders new_name (InstD _) = returnRn Nothing
1106 getDeclBinders new_name (RuleD _) = returnRn Nothing
1108 binds_haskell_name (FoImport _) _ = True
1109 binds_haskell_name FoLabel _ = True
1110 binds_haskell_name FoExport ext_nm = isDynamicExtName ext_nm
1113 getConFieldNames new_name (ConDecl con _ _ _ (RecCon fielddecls) src_loc : rest)
1114 = mapRn (\n -> new_name n src_loc) (con:fields) `thenRn` \ cfs ->
1115 getConFieldNames new_name rest `thenRn` \ ns ->
1116 returnRn (cfs ++ ns)
1118 fields = concat (map fst fielddecls)
1120 getConFieldNames new_name (ConDecl con _ _ _ condecl src_loc : rest)
1121 = new_name con src_loc `thenRn` \ n ->
1122 getConFieldNames new_name rest `thenRn` \ ns ->
1125 getConFieldNames new_name [] = returnRn []
1127 getClassOpNames new_name (ClassOpSig op _ _ src_loc) = new_name op src_loc
1130 @getDeclSysBinders@ gets the implicit binders introduced by a decl.
1131 A the moment that's just the tycon and datacon that come with a class decl.
1132 They aren't returned by @getDeclBinders@ because they aren't in scope;
1133 but they {\em should} be put into the @DeclsMap@ of this module.
1135 Note that this excludes the default-method names of a class decl,
1136 and the dict fun of an instance decl, because both of these have
1137 bindings of their own elsewhere.
1140 getDeclSysBinders new_name (TyClD (ClassDecl _ cname _ _ sigs _ _ names
1142 = sequenceRn [new_name n src_loc | n <- names]
1144 getDeclSysBinders new_name (TyClD (TyData _ _ _ _ cons _ _ _ _ _ _))
1145 = sequenceRn [new_name wkr_name src_loc | ConDecl _ wkr_name _ _ _ src_loc <- cons]
1147 getDeclSysBinders new_name other_decl
1151 %*********************************************************
1153 \subsection{Reading an interface file}
1155 %*********************************************************
1158 findAndReadIface :: SDoc -> ModuleName
1159 -> IsBootInterface -- True <=> Look for a .hi-boot file
1160 -- False <=> Look for .hi file
1161 -> RnM d (Either Message (Module, ParsedIface))
1162 -- Nothing <=> file not found, or unreadable, or illegible
1163 -- Just x <=> successfully found and parsed
1165 findAndReadIface doc_str mod_name hi_boot_file
1166 = traceRn trace_msg `thenRn_`
1167 -- we keep two maps for interface files,
1168 -- one for 'normal' ones, the other for .hi-boot files,
1169 -- hence the need to signal which kind we're interested.
1171 getFinderRn `thenRn` \ finder ->
1172 ioToRn (findModule finder mod_name) `thenRn` \ maybe_module ->
1174 case maybe_module of
1175 Just mod | hi_boot_file, Just fpath <- moduleHiBootFile mod
1176 -> readIface mod fpath
1177 | not hi_boot_file, Just fpath <- moduleHiFile mod
1178 -> readIface mod fpath
1181 other -> traceRn (ptext SLIT("...not found")) `thenRn_`
1182 returnRn (Left (noIfaceErr finder mod_name hi_boot_file))
1185 trace_msg = sep [hsep [ptext SLIT("Reading"),
1186 if hi_boot_file then ptext SLIT("[boot]") else empty,
1187 ptext SLIT("interface for"),
1188 ppr mod_name <> semi],
1189 nest 4 (ptext SLIT("reason:") <+> doc_str)]
1192 @readIface@ tries just the one file.
1195 readIface :: Module -> String -> RnM d (Either Message (Module, ParsedIface))
1196 -- Nothing <=> file not found, or unreadable, or illegible
1197 -- Just x <=> successfully found and parsed
1198 readIface wanted_mod file_path
1199 = traceRn (ptext SLIT("...reading from") <+> text file_path) `thenRn_`
1200 ioToRnM (hGetStringBuffer False file_path) `thenRn` \ read_result ->
1203 case parseIface contents
1204 PState{ bol = 0#, atbol = 1#,
1207 loc = mkSrcLoc (mkFastString file_path) 1 } of
1208 POk _ (PIface iface) ->
1209 warnCheckRn (moduleName wanted_mod == read_mod)
1210 (hiModuleNameMismatchWarn wanted_mod read_mod) `thenRn_`
1211 returnRn (Right (mod, iface))
1213 read_mod = moduleName (pi_mod iface)
1215 PFailed err -> bale_out err
1216 parse_result -> bale_out empty
1217 -- This last case can happen if the interface file is (say) empty
1218 -- in which case the parser thinks it looks like an IdInfo or
1219 -- something like that. Just an artefact of the fact that the
1220 -- parser is used for several purposes at once.
1222 Left io_err -> bale_out (text (show io_err))
1224 bale_out err = returnRn (Left (badIfaceFile file_path err))
1227 %*********************************************************
1231 %*********************************************************
1234 noIfaceErr mod_name boot_file search_path
1235 = vcat [ptext SLIT("Could not find interface file for") <+> quotes (ppr mod_name),
1236 ptext SLIT("in the directories") <+>
1237 -- \& to avoid cpp interpreting this string as a
1238 -- comment starter with a pre-4.06 mkdependHS --SDM
1239 vcat [ text dir <> text "/\&*" <> pp_suffix suffix
1240 | (dir,suffix) <- search_path]
1243 pp_suffix suffix | boot_file = ptext SLIT(".hi-boot")
1244 | otherwise = text suffix
1246 badIfaceFile file err
1247 = vcat [ptext SLIT("Bad interface file:") <+> text file,
1251 = vcat [ptext SLIT("Failed to find interface decl for") <+> quotes (ppr name),
1252 ptext SLIT("from module") <+> quotes (ppr (nameModule name))
1257 "Compiler tried to import decl from interface file with same name as module."),
1259 "(possible cause: module name clashes with interface file already in scope.)")
1261 hsep [ptext SLIT("name:"), quotes (ppr name)]
1263 warnRedundantSourceImport mod_name
1264 = ptext SLIT("Unnecessary {- SOURCE -} in the import of module")
1265 <+> quotes (ppr mod_name)
1267 hiModuleNameMismatchWarn :: Module -> ModuleName -> Message
1268 hiModuleNameMismatchWarn requested_mod read_mod =
1269 hsep [ ptext SLIT("Something is amiss; requested module name")
1270 , ppr (moduleName requested_mod)
1271 , ptext SLIT("differs from name found in the interface file")
1276 #endif /* TEMP DEBUG HACK! */