import CmdLineOpts ( opt_NoPruneDecls, opt_IgnoreIfacePragmas )
import HsSyn ( HsDecl(..), TyClDecl(..), InstDecl(..), IfaceSig(..),
HsType(..), ConDecl(..), IE(..), ConDetails(..), Sig(..),
- ForeignDecl(..), ForKind(..), isDynamic,
+ ForeignDecl(..), ForKind(..), isDynamicExtName,
FixitySig(..), RuleDecl(..),
isClassOpSig, Deprecation(..)
)
import RnEnv ( mkImportedGlobalName, newImportedBinder, mkImportedGlobalFromRdrName,
lookupOccRn, lookupImplicitOccRn,
pprAvail,
- availName, availNames, addAvailToNameSet,
+ availName, availNames, addAvailToNameSet, addSysAvails,
FreeVars, emptyFVs
)
import RnMonad
)
import Module ( Module, moduleString, pprModule,
mkVanillaModule, pprModuleName,
- moduleUserString, moduleName, isLibModule,
+ moduleUserString, moduleName, isLocalModule,
ModuleName, WhereFrom(..),
)
import RdrName ( RdrName, rdrNameOcc )
\begin{code}
loadHomeInterface :: SDoc -> Name -> RnM d Ifaces
loadHomeInterface doc_str name
- = loadInterface doc_str (moduleName (nameModule name)) ImportBySystem `thenRn` \ (_, ifaces) ->
- returnRn ifaces
+ = loadInterface doc_str (moduleName (nameModule name)) ImportBySystem
loadOrphanModules :: [ModuleName] -> RnM d ()
loadOrphanModules mods
| null mods = returnRn ()
- | otherwise = traceRn (text "Loading orphan modules:" <+> fsep (map pprModuleName mods)) `thenRn_`
- mapRn_ load mods `thenRn_`
+ | otherwise = traceRn (text "Loading orphan modules:" <+>
+ fsep (map pprModuleName mods)) `thenRn_`
+ mapRn_ load mods `thenRn_`
returnRn ()
where
- load mod = loadInterface (pprModuleName mod <+> ptext SLIT("is a orphan-instance module")) mod ImportBySystem
+ load mod = loadInterface (mk_doc mod) mod ImportBySystem
+ mk_doc mod = pprModuleName mod <+> ptext SLIT("is a orphan-instance module")
+
-loadInterface :: SDoc -> ModuleName -> WhereFrom -> RnM d (Module, Ifaces)
-loadInterface doc_str mod_name from
+loadInterface :: SDoc -> ModuleName -> WhereFrom -> RnM d Ifaces
+loadInterface doc mod from
+ = tryLoadInterface doc mod from `thenRn` \ (ifaces, maybe_err) ->
+ case maybe_err of
+ Nothing -> returnRn ifaces
+ Just err -> failWithRn ifaces err
+
+tryLoadInterface :: SDoc -> ModuleName -> WhereFrom -> RnM d (Ifaces, Maybe Message)
+ -- Returns (Just err) if an error happened
+ -- Guarantees to return with iImpModInfo m --> (... Just cts)
+ -- (If the load fails, we plug in a vanilla placeholder
+tryLoadInterface doc_str mod_name from
= getIfacesRn `thenRn` \ ifaces ->
let
mod_map = iImpModInfo ifaces
mod_info = lookupFM mod_map mod_name
- below_me = case mod_info of
- Nothing -> False
- Just (_, _, is_boot, _) -> not is_boot
- in
-
- -- Issue a warning for a redundant {- SOURCE -} import
- -- It's redundant if the moduld is in the iImpModInfo at all,
- -- because we arrange to read all the ordinary imports before
- -- any of the {- SOURCE -} imports
- warnCheckRn (not (below_me && case from of {ImportByUserSource -> True; other -> False}))
- (warnRedundantSourceImport mod_name) `thenRn_`
+ hi_boot_file = case from of {
+ ImportByUser -> False ; -- Not hi-boot
+ ImportByUserSource -> True ; -- hi-boot
+ ImportBySystem ->
+ case mod_info of
+ Just (_, _, is_boot, _) -> is_boot
+
+ Nothing -> False
+ -- We're importing a module we know absolutely
+ -- nothing about, so we assume it's from
+ -- another package, where we aren't doing
+ -- dependency tracking. So it won't be a hi-boot file.
+ }
+ redundant_source_import
+ = case (from, mod_info) of
+ (ImportByUserSource, Just (_,_,False,_)) -> True
+ other -> False
+ in
-- CHECK WHETHER WE HAVE IT ALREADY
case mod_info of {
- Just (_, _, _, Just (load_mod, _))
+ Just (_, _, _, Just _)
-> -- We're read it already so don't re-read it
- returnRn (load_mod, ifaces) ;
+ returnRn (ifaces, Nothing) ;
+
+ _ ->
- mod_map_result ->
+ -- Issue a warning for a redundant {- SOURCE -} import
+ -- NB that we arrange to read all the ordinary imports before
+ -- any of the {- SOURCE -} imports
+ warnCheckRn (not redundant_source_import)
+ (warnRedundantSourceImport mod_name) `thenRn_`
-- READ THE MODULE IN
- findAndReadIface doc_str mod_name from below_me
- `thenRn` \ (hi_boot_read, read_result) ->
+ findAndReadIface doc_str mod_name hi_boot_file `thenRn` \ read_result ->
case read_result of {
- Nothing -> -- Not found, so add an empty export env to the Ifaces map
+ Left err -> -- Not found, so add an empty export env to the Ifaces map
-- so that we don't look again
let
mod = mkVanillaModule mod_name
- new_mod_map = addToFM mod_map mod_name (0, False, False, Just (mod, []))
+ new_mod_map = addToFM mod_map mod_name (0, False, False, Just (mod, from, []))
new_ifaces = ifaces { iImpModInfo = new_mod_map }
in
setIfacesRn new_ifaces `thenRn_`
- failWithRn (mod, new_ifaces) (noIfaceErr mod hi_boot_read) ;
+ returnRn (new_ifaces, Just err) ;
-- Found and parsed!
- Just (mod, iface) ->
+ Right iface ->
-- LOAD IT INTO Ifaces
getModuleRn `thenRn` \ this_mod_nm ->
let
rd_decls = pi_decls iface
+ mod = pi_mod iface
in
+ -- Sanity check. If we're system-importing a module we know nothing at all
+ -- about, it should be from a different package to this one
+ WARN( not (maybeToBool mod_info) &&
+ case from of { ImportBySystem -> True; other -> False } &&
+ isLocalModule mod,
+ ppr mod )
foldlRn (loadDecl mod) (iDecls ifaces) rd_decls `thenRn` \ new_decls ->
foldlRn (loadInstDecl mod) (iInsts ifaces) (pi_insts iface) `thenRn` \ new_insts ->
(if opt_IgnoreIfacePragmas
-- the things the imported module depends on, extracted
-- from its usage info.
mod_map1 = case from of
- ImportByUser -> addModDeps mod mod_map (pi_usages iface)
+ ImportByUser -> addModDeps mod (pi_usages iface) mod_map
other -> mod_map
-- Now add info about this module
mod_map2 = addToFM mod_map1 mod_name mod_details
- mod_details = (pi_mod iface, pi_orphan iface, hi_boot_read, Just (mod, concat avails_s))
+ cts = (pi_mod iface, from, concat avails_s)
+ mod_details = (pi_vers iface, pi_orphan iface, hi_boot_file, Just cts)
new_ifaces = ifaces { iImpModInfo = mod_map2,
iDecls = new_decls,
iDeprecs = new_deprecs }
in
setIfacesRn new_ifaces `thenRn_`
- returnRn (mod, new_ifaces)
+ returnRn (new_ifaces, Nothing)
}}
-addModDeps :: Module -> ImportedModuleInfo
- -> [ImportVersion a] -> ImportedModuleInfo
-addModDeps mod mod_deps new_deps
- = foldr add mod_deps new_deps
+addModDeps :: Module -> [ImportVersion a]
+ -> ImportedModuleInfo -> ImportedModuleInfo
+-- (addModDeps M ivs deps)
+-- We are importing module M, and M.hi contains 'import' decls given by ivs
+addModDeps mod new_deps mod_deps
+ = foldr add mod_deps filtered_new_deps
where
- is_lib = isLibModule mod -- Don't record dependencies when importing a library module
- add (imp_mod, version, has_orphans, is_boot, _) deps
- | is_lib && not has_orphans = deps
- | otherwise = addToFM_C combine deps imp_mod (version, has_orphans, is_boot, Nothing)
- -- Record dependencies for modules that are
- -- either are dependent via a non-library module
- -- or contain orphan rules or instance decls
-
- -- Don't ditch a module that's already loaded
- -- If it isn't loaded, and together the is_boot-ness
- combine old@(_, _, _, Just _) new = old
- combine old@(_, _, old_is_boot, Nothing)
- new@(version, has_orphans, new_is_boot, _)
- = (version, has_orphans, old_is_boot && new_is_boot, Nothing)
+ -- Don't record dependencies when importing a module from another package
+ -- Except for its descendents which contain orphans,
+ -- and in that case, forget about the boot indicator
+ filtered_new_deps
+ | isLocalModule mod = [ (imp_mod, (version, has_orphans, is_boot, Nothing))
+ | (imp_mod, version, has_orphans, is_boot, _) <- new_deps
+ ]
+ | otherwise = [ (imp_mod, (version, True, False, Nothing))
+ | (imp_mod, version, has_orphans, _, _) <- new_deps,
+ has_orphans
+ ]
+ add (imp_mod, dep) deps = addToFM_C combine deps imp_mod dep
+
+ combine old@(_, _, old_is_boot, cts) new
+ | maybeToBool cts || not old_is_boot = old -- Keep the old info if it's already loaded
+ -- or if it's a non-boot pending load
+ | otherwise = new -- Otherwise pick new info
loadExport :: ModuleName -> ExportItem -> RnM d [AvailInfo]
loadExport this_mod (mod, entities)
getDeclSysBinders new_name decl `thenRn` \ sys_bndrs ->
let
+ full_avail = addSysAvails avail sys_bndrs
+ -- Add the sys-binders to avail. When we import the decl,
+ -- it's full_avail that will get added to the 'already-slurped' set (iSlurp)
+ -- If we miss out sys-binders, we'll read the decl multiple times!
+
main_name = availName avail
new_decls_map = foldl add_decl decls_map
- [ (name, (version, avail, name==main_name, (mod, decl')))
- | name <- sys_bndrs ++ availNames avail]
+ [ (name, (version, full_avail, name==main_name, (mod, decl')))
+ | name <- availNames full_avail]
add_decl decls_map (name, stuff)
= WARN( name `elemNameEnv` decls_map, ppr name )
addToNameEnv decls_map name stuff
%********************************************************
\begin{code}
-checkUpToDate :: ModuleName -> RnMG Bool -- True <=> no need to recompile
+upToDate = True
+outOfDate = False
+
+checkUpToDate :: ModuleName -> RnMG Bool -- True <=> no need to recompile
+ -- When this guy is called, we already know that the
+ -- source code is unchanged from last time
checkUpToDate mod_name
= getIfacesRn `thenRn` \ ifaces ->
findAndReadIface doc_str mod_name
- ImportByUser
- (error "checkUpToDate") `thenRn` \ (_, read_result) ->
+ False {- Not hi-boot -} `thenRn` \ read_result ->
-- CHECK WHETHER WE HAVE IT ALREADY
case read_result of
- Nothing -> -- Old interface file not found, so we'd better bail out
- traceRn (sep [ptext SLIT("Didnt find old iface"),
- pprModuleName mod_name]) `thenRn_`
- returnRn False
+ Left err -> -- Old interface file not found, or garbled, so we'd better bail out
+ traceRn (vcat [ptext SLIT("No old iface") <+> pprModuleName mod_name,
+ err]) `thenRn_`
+ returnRn outOfDate
- Just (_, iface)
+ Right iface
-> -- Found it, so now check it
checkModUsage (pi_usages iface)
where
-- Only look in current directory, with suffix .hi
doc_str = sep [ptext SLIT("need usage info from"), pprModuleName mod_name]
-checkModUsage [] = returnRn True -- Yes! Everything is up to date!
+checkModUsage [] = returnRn upToDate -- Yes! Everything is up to date!
checkModUsage ((mod_name, old_mod_vers, _, _, Specifically []) : rest)
-- If CurrentModule.hi contains
= traceRn (ptext SLIT("Nothing used from:") <+> ppr mod_name) `thenRn_`
checkModUsage rest -- This one's ok, so check the rest
-checkModUsage ((mod_name, old_mod_vers, _, _, whats_imported) : rest)
- = loadInterface doc_str mod_name ImportBySystem `thenRn` \ (mod, ifaces) ->
+checkModUsage ((mod_name, old_mod_vers, _, _, whats_imported) : rest)
+ = tryLoadInterface doc_str mod_name ImportBySystem `thenRn` \ (ifaces, maybe_err) ->
+ case maybe_err of {
+ Just err -> traceRn (sep [ptext SLIT("Can't find version number for module"),
+ pprModuleName mod_name]) `thenRn_`
+ returnRn outOfDate ;
+ -- Couldn't find or parse a module mentioned in the
+ -- old interface file. Don't complain -- it might just be that
+ -- the current module doesn't need that import and it's been deleted
+ Nothing ->
let
- maybe_mod_vers = case lookupFM (iImpModInfo ifaces) mod_name of
- Just (version, _, _, Just (_, _)) -> Just version
- other -> Nothing
+ new_mod_vers = case lookupFM (iImpModInfo ifaces) mod_name of
+ Just (version, _, _, _) -> version
in
- case maybe_mod_vers of {
- Nothing -> -- If we can't find a version number for the old module then
- -- bail out saying things aren't up to date
- traceRn (sep [ptext SLIT("Can't find version number for module"),
- pprModuleName mod_name])
- `thenRn_` returnRn False ;
-
- Just new_mod_vers ->
-
-- If the module version hasn't changed, just move on
if new_mod_vers == old_mod_vers then
traceRn (sep [ptext SLIT("Module version unchanged:"), pprModuleName mod_name])
-- In that case, we must recompile
case whats_imported of {
Everything -> traceRn (ptext SLIT("...and I needed the whole module")) `thenRn_`
- returnRn False; -- Bale out
+ returnRn outOfDate; -- Bale out
Specifically old_local_vers ->
traceRn (ptext SLIT("...but the bits I use haven't.")) `thenRn_`
checkModUsage rest -- This one's ok, so check the rest
else
- returnRn False -- This one failed, so just bail out now
+ returnRn outOfDate -- This one failed, so just bail out now
}}
where
doc_str = sep [ptext SLIT("need version info for"), pprModuleName mod_name]
checkEntityUsage mod decls []
- = returnRn True -- Yes! All up to date!
+ = returnRn upToDate -- Yes! All up to date!
checkEntityUsage mod decls ((occ_name,old_vers) : rest)
= mkImportedGlobalName mod occ_name `thenRn` \ name ->
Nothing -> -- We used it before, but it ain't there now
traceRn (sep [ptext SLIT("No longer exported:"), ppr name])
- `thenRn_` returnRn False
+ `thenRn_` returnRn outOfDate
Just (new_vers,_,_,_) -- It's there, but is it up to date?
| new_vers == old_vers
| otherwise
-- Out of date, so bale out
-> traceRn (sep [ptext SLIT("Out of date:"), ppr name]) `thenRn_`
- returnRn False
+ returnRn outOfDate
\end{code}
\begin{code}
getInterfaceExports :: ModuleName -> WhereFrom -> RnMG (Module, Avails)
getInterfaceExports mod_name from
- = loadInterface doc_str mod_name from `thenRn` \ (mod, ifaces) ->
+ = loadInterface doc_str mod_name from `thenRn` \ ifaces ->
case lookupFM (iImpModInfo ifaces) mod_name of
- Nothing -> -- Not there; it must be that the interface file wasn't found;
- -- the error will have been reported already.
- -- (Actually loadInterface should put the empty export env in there
- -- anyway, but this does no harm.)
- returnRn (mod, [])
-
- Just (_, _, _, Just (mod, avails)) -> returnRn (mod, avails)
+ Just (_, _, _, Just (mod, _, avails)) -> returnRn (mod, avails)
+ -- loadInterface always puts something in the map
+ -- even if it's a fake
where
doc_str = sep [pprModuleName mod_name, ptext SLIT("is directly imported")]
\end{code}
where
gate_list = nameSetToList gates
- load_home gate | isLocallyDefined gate
- = returnRn ()
- | otherwise
- = loadHomeInterface (ppr gate <+> text "is an instance gate") gate `thenRn_`
- returnRn ()
-
ppr_brief_inst_decl (mod, InstD (InstDecl inst_ty _ _ _ _))
= case inst_ty of
HsForAllTy _ _ tau -> ppr tau
things it uses. It records:
\begin{itemize}
-\item anything reachable from its body code
-\item any module exported with a @module Foo@.
+\item (a) anything reachable from its body code
+\item (b) any module exported with a @module Foo@
+\item (c) anything reachable from an exported item
\end{itemize}
-%
-Why the latter? Because if @Foo@ changes then this module's export list
+
+Why (b)? Because if @Foo@ changes then this module's export list
will change, so we must recompile this module at least as far as
making a new interface file --- but in practice that means complete
recompilation.
-What about this?
+Why (c)? Consider this:
\begin{verbatim}
module A( f, g ) where | module B( f ) where
import B( f ) | f = h 3
g = ... | h = ...
\end{verbatim}
-Should we record @B.f@ in @A@'s usages? In fact we don't. Certainly,
-if anything about @B.f@ changes than anyone who imports @A@ should be
-recompiled; they'll get an early exit if they don't use @B.f@.
-However, even if @B.f@ doesn't change at all, @B.h@ may do so, and
-this change may not be reflected in @f@'s version number. So there
-are two things going on when compiling module @A@:
-
-\begin{enumerate}
-\item Are @A.o@ and @A.hi@ correct? Then we can bale out early.
-\item Should modules that import @A@ be recompiled?
-\end{enumerate}
-
-For (1) it is slightly harmful to record @B.f@ in @A@'s usages,
-because a change in @B.f@'s version will provoke full recompilation of
-@A@, producing an identical @A.o@, and @A.hi@ differing only in its
-usage-version of @B.f@ (and this usage-version info isn't used by any
-importer).
-
-For (2), because of the tricky @B.h@ question above, we ensure that
-@A.hi@ is touched (even if identical to its previous version) if A's
-recompilation was triggered by an imported @.hi@ file date change.
-Given that, there's no need to record @B.f@ in @A@'s usages.
-
-On the other hand, if @A@ exports @module B@, then we {\em do} count
-@module B@ among @A@'s usages, because we must recompile @A@ to ensure
-that @A.hi@ changes appropriately.
-
-HOWEVER, we *do* record the usage
- import B <n> :: ;
+Here, @B.f@ isn't used in A. Should we nevertheless record @B.f@ in
+@A@'s usages? Our idea is that we aren't going to touch A.hi if it is
+*identical* to what it was before. If anything about @B.f@ changes
+than anyone who imports @A@ should be recompiled in case they use
+@B.f@ (they'll get an early exit if they don't). So, if anything
+about @B.f@ changes we'd better make sure that something in A.hi
+changes, and the convenient way to do that is to record the version
+number @B.f@ in A.hi in the usage list. If B.f changes that'll force a
+complete recompiation of A, which is overkill but it's the only way to
+write a new, slightly different, A.hi.
+
+But the example is tricker. Even if @B.f@ doesn't change at all,
+@B.h@ may do so, and this change may not be reflected in @f@'s version
+number. But with -O, a module that imports A must be recompiled if
+@B.h@ changes! So A must record a dependency on @B.h@. So we treat
+the occurrence of @B.f@ in the export list *just as if* it were in the
+code of A, and thereby haul in all the stuff reachable from it.
+
+[NB: If B was compiled with -O, but A isn't, we should really *still*
+haul in all the unfoldings for B, in case the module that imports A *is*
+compiled with -O. I think this is the case.]
+
+Even if B is used at all we get a usage line for B
+ import B <n> :: ... ;
in A.hi, to record the fact that A does import B. This is used to decide
to look to look for B.hi rather than B.hi-boot when compiling a module that
imports A. This line says that A imports B, but uses nothing in it.
-> ExportEnv -- Info about exports
-> RnMG (VersionInfo Name) -- Version info for these names
-getImportVersions this_mod (ExportEnv export_avails _ export_all_mods)
+getImportVersions this_mod (ExportEnv _ _ export_all_mods)
= getIfacesRn `thenRn` \ ifaces ->
let
mod_map = iImpModInfo ifaces
-- I can't be bothered just now.
mk_version_info mod_name (version, has_orphans, is_boot, contents) so_far
+ | mod_name == this_mod -- Check if M appears in the set of modules 'below' M
+ -- This seems like a convenient place to check
+ = WARN( not is_boot, ptext SLIT("Wierd:") <+> ppr this_mod <+>
+ ptext SLIT("imports itself (perhaps indirectly)") )
+ so_far
+
+ | otherwise
= let
go_for_it exports = (mod_name, version, has_orphans, is_boot, exports)
: so_far
-- Foo in the module dependency hierarchy. We want to propagate this
-- information. The Nothing says that we didn't even open the interface
-- file but we must still propagate the dependeny info.
+ -- The module in question must be a local module (in the same package)
go_for_it (Specifically [])
- Just (mod, _) -- We did open the interface
- | is_lib_module && not has_orphans
+ Just (mod, how_imported, _)
+ | is_sys_import && is_lib_module && not has_orphans
-> so_far
| is_lib_module -- Record the module but not detailed
-- but don't actually *use* anything from Foo
-- In which case record an empty dependency list
where
- is_lib_module = isLibModule mod
+ is_lib_module = not (isLocalModule mod)
+ is_sys_import = case how_imported of
+ ImportBySystem -> True
+ other -> False
in
- -- A module shouldn't load its own interface
- -- This seems like a convenient place to check
- WARN( maybeToBool (lookupFM mod_map this_mod),
- ptext SLIT("Wierd:") <+> ppr this_mod <+> ptext SLIT("loads its own interface") )
returnRn (foldFM mk_version_info [] mod_map)
where
returnRn (iSlurp ifaces)
recordSlurp maybe_version avail
+-- Nothing for locally defined names
+-- Just version for imported names
= getIfacesRn `thenRn` \ ifaces@(Ifaces { iSlurp = slurped_names,
iVSlurp = imp_names }) ->
let
= new_name tycon src_loc `thenRn` \ tycon_name ->
returnRn (Just (AvailTC tycon_name [tycon_name]))
-getDeclBinders new_name (TyClD (ClassDecl _ cname _ _ sigs _ _ _ _ _ src_loc))
+getDeclBinders new_name (TyClD (ClassDecl _ cname _ _ sigs _ _ _ _ _ _ src_loc))
= new_name cname src_loc `thenRn` \ class_name ->
-- Record the names for the class ops
binds_haskell_name (FoImport _) _ = True
binds_haskell_name FoLabel _ = True
-binds_haskell_name FoExport ext_nm = isDynamic ext_nm
+binds_haskell_name FoExport ext_nm = isDynamicExtName ext_nm
----------------
-getConFieldNames new_name (ConDecl con _ _ (RecCon fielddecls) src_loc : rest)
+getConFieldNames new_name (ConDecl con _ _ _ (RecCon fielddecls) src_loc : rest)
= mapRn (\n -> new_name n src_loc) (con:fields) `thenRn` \ cfs ->
getConFieldNames new_name rest `thenRn` \ ns ->
returnRn (cfs ++ ns)
where
fields = concat (map fst fielddecls)
-getConFieldNames new_name (ConDecl con _ _ condecl src_loc : rest)
+getConFieldNames new_name (ConDecl con _ _ _ condecl src_loc : rest)
= new_name con src_loc `thenRn` \ n ->
(case condecl of
NewCon _ (Just f) ->
bindings of their own elsewhere.
\begin{code}
-getDeclSysBinders new_name (TyClD (ClassDecl _ cname _ _ sigs _ _ tname dname snames src_loc))
- = new_name dname src_loc `thenRn` \ datacon_name ->
- new_name tname src_loc `thenRn` \ tycon_name ->
- sequenceRn [new_name n src_loc | n <- snames] `thenRn` \ scsel_names ->
- returnRn (tycon_name : datacon_name : scsel_names)
+getDeclSysBinders new_name (TyClD (ClassDecl _ cname _ _ sigs _ _ tname dname dwname snames src_loc))
+ = sequenceRn [new_name n src_loc | n <- (tname : dname : dwname : snames)]
+
+getDeclSysBinders new_name (TyClD (TyData _ _ _ _ cons _ _ _))
+ = sequenceRn [new_name wkr_name src_loc | ConDecl _ wkr_name _ _ _ src_loc <- cons]
getDeclSysBinders new_name other_decl
= returnRn []
%*********************************************************
\begin{code}
-findAndReadIface :: SDoc -> ModuleName -> WhereFrom
- -> Bool -- Only relevant for SystemImport
- -- True <=> Look for a .hi file
- -- False <=> Look for .hi-boot file unless there's
- -- a library .hi file
- -> RnM d (Bool, Maybe (Module, ParsedIface))
- -- Bool is True if the interface actually read was a .hi-boot one
+findAndReadIface :: SDoc -> ModuleName
+ -> IsBootInterface -- True <=> Look for a .hi-boot file
+ -- False <=> Look for .hi file
+ -> RnM d (Either Message ParsedIface)
-- Nothing <=> file not found, or unreadable, or illegible
-- Just x <=> successfully found and parsed
-findAndReadIface doc_str mod_name from hi_file
+findAndReadIface doc_str mod_name hi_boot_file
= traceRn trace_msg `thenRn_`
-- we keep two maps for interface files,
-- one for 'normal' ones, the other for .hi-boot files,
-- hence the need to signal which kind we're interested.
- getHiMaps `thenRn` \ hi_maps ->
+ getHiMaps `thenRn` \ (search_path, hi_map, hiboot_map) ->
+ let
+ relevant_map | hi_boot_file = hiboot_map
+ | otherwise = hi_map
+ in
+ case lookupFM relevant_map mod_name of
+ -- Found the file
+ Just fpath -> traceRn (ptext SLIT("...reading from") <+> text fpath) `thenRn_`
+ readIface mod_name fpath
- case find_path from hi_maps of
- -- Found the file
- (hi_boot, Just (fpath, mod)) -> traceRn (ptext SLIT("...reading from") <+> text fpath)
- `thenRn_`
- readIface mod fpath `thenRn` \ result ->
- returnRn (hi_boot, result)
- (hi_boot, Nothing) -> traceRn (ptext SLIT("...not found")) `thenRn_`
- returnRn (hi_boot, Nothing)
- where
- find_path ImportByUser (hi_map, _) = (False, lookupFM hi_map mod_name)
- find_path ImportByUserSource (_, hiboot_map) = (True, lookupFM hiboot_map mod_name)
-
- find_path ImportBySystem (hi_map, hiboot_map)
- | hi_file
- = -- If the module we seek is in our dependent set,
- -- Look for a .hi file
- (False, lookupFM hi_map mod_name)
-
- | otherwise
- -- Check if there's a library module of that name
- -- If not, look for an hi-boot file
- = case lookupFM hi_map mod_name of
- stuff@(Just (_, mod)) | isLibModule mod -> (False, stuff)
- other -> (True, lookupFM hiboot_map mod_name)
+ -- Can't find it
+ Nothing -> traceRn (ptext SLIT("...not found")) `thenRn_`
+ returnRn (Left (noIfaceErr mod_name hi_boot_file search_path))
+ where
trace_msg = sep [hsep [ptext SLIT("Reading"),
- ppr from,
+ if hi_boot_file then ptext SLIT("[boot]") else empty,
ptext SLIT("interface for"),
pprModuleName mod_name <> semi],
nest 4 (ptext SLIT("reason:") <+> doc_str)]
@readIface@ tries just the one file.
\begin{code}
-readIface :: Module -> String -> RnM d (Maybe (Module, ParsedIface))
+readIface :: ModuleName -> String -> RnM d (Either Message ParsedIface)
-- Nothing <=> file not found, or unreadable, or illegible
-- Just x <=> successfully found and parsed
-readIface the_mod file_path
+readIface wanted_mod file_path
= ioToRnM (hGetStringBuffer False file_path) `thenRn` \ read_result ->
case read_result of
Right contents ->
context = [],
glasgow_exts = 1#,
loc = mkSrcLoc (mkFastString file_path) 1 } of
- POk _ (PIface mod_nm iface) ->
- warnCheckRn (mod_nm == moduleName the_mod)
- (hiModuleNameMismatchWarn the_mod mod_nm) `thenRn_`
- returnRn (Just (the_mod, iface))
-
- PFailed err -> failWithRn Nothing err
- other -> failWithRn Nothing (ptext SLIT("Unrecognisable interface file"))
- -- This last case can happen if the interface file is (say) empty
- -- in which case the parser thinks it looks like an IdInfo or
- -- something like that. Just an artefact of the fact that the
- -- parser is used for several purposes at once.
-
- Left err
- | isDoesNotExistError err -> returnRn Nothing
- | otherwise -> failWithRn Nothing (cannaeReadFile file_path err)
+ POk _ (PIface iface) ->
+ warnCheckRn (read_mod == wanted_mod)
+ (hiModuleNameMismatchWarn wanted_mod read_mod) `thenRn_`
+ returnRn (Right iface)
+ where
+ read_mod = moduleName (pi_mod iface)
+
+ PFailed err -> bale_out err
+ parse_result -> bale_out empty
+ -- This last case can happen if the interface file is (say) empty
+ -- in which case the parser thinks it looks like an IdInfo or
+ -- something like that. Just an artefact of the fact that the
+ -- parser is used for several purposes at once.
+
+ Left io_err -> bale_out (text (show io_err))
+ where
+ bale_out err = returnRn (Left (badIfaceFile file_path err))
\end{code}
%*********************************************************
%*********************************************************
\begin{code}
-noIfaceErr filename boot_file
- = hsep [ptext SLIT("Could not find valid"), boot,
- ptext SLIT("interface file"), quotes (pprModule filename)]
+noIfaceErr mod_name boot_file search_path
+ = vcat [ptext SLIT("Could not find interface file for") <+> quotes (pprModuleName mod_name),
+ ptext SLIT("in the directories") <+>
+ -- \& to avoid cpp interpreting this string as a
+ -- comment starter with a pre-4.06 mkdependHS --SDM
+ vcat [ text dir <> text "/\&*" <> pp_suffix suffix
+ | (dir,suffix) <- search_path]
+ ]
where
- boot | boot_file = ptext SLIT("[boot]")
- | otherwise = empty
+ pp_suffix suffix | boot_file = ptext SLIT(".hi-boot")
+ | otherwise = text suffix
-cannaeReadFile file err
- = hcat [ptext SLIT("Failed in reading file: "),
- text file,
- ptext SLIT("; error="),
- text (show err)]
+badIfaceFile file err
+ = vcat [ptext SLIT("Bad interface file:") <+> text file,
+ nest 4 err]
getDeclErr name
- = ptext SLIT("Failed to find interface decl for") <+> quotes (ppr name)
+ = vcat [ptext SLIT("Failed to find interface decl for") <+> quotes (ppr name),
+ ptext SLIT("from module") <+> quotes (ppr (nameModule name))
+ ]
getDeclWarn name loc
= sep [ptext SLIT("Failed to find (optional) interface decl for") <+> quotes (ppr name),
= ptext SLIT("Unnecessary {- SOURCE -} in the import of module")
<+> quotes (pprModuleName mod_name)
-hiModuleNameMismatchWarn :: Module -> ModuleName -> Message
-hiModuleNameMismatchWarn requested_mod mod_nm =
+hiModuleNameMismatchWarn :: ModuleName -> ModuleName -> Message
+hiModuleNameMismatchWarn requested_mod read_mod =
hsep [ ptext SLIT("Something is amiss; requested module name")
- , pprModule requested_mod
- , ptext SLIT("differs from name found in the interface file ")
- , pprModuleName mod_nm
+ , pprModuleName requested_mod
+ , ptext SLIT("differs from name found in the interface file")
+ , pprModuleName read_mod
]
\end{code}
projects / ghc-hetmet.git / blobdiff