checkUpToDate,
- getDeclBinders
+ getDeclBinders, getDeclSysBinders,
+ removeContext -- removeContext probably belongs somewhere else
) where
#include "HsVersions.h"
import CmdLineOpts ( opt_NoPruneDecls, opt_IgnoreIfacePragmas )
import HsSyn ( HsDecl(..), TyClDecl(..), InstDecl(..), IfaceSig(..),
HsType(..), ConDecl(..), IE(..), ConDetails(..), Sig(..),
+ ForeignDecl(..), ForKind(..), isDynamic,
FixitySig(..), RuleDecl(..),
isClassOpSig
)
extractHsTyRdrNames
)
import RnEnv ( mkImportedGlobalName, newImportedBinder, mkImportedGlobalFromRdrName,
- lookupOccRn,
+ lookupOccRn, lookupImplicitOccRn,
pprAvail,
availName, availNames, addAvailToNameSet,
FreeVars, emptyFVs
import RnHsSyn ( RenamedHsDecl )
import ParseIface ( parseIface, IfaceStuff(..) )
-import FiniteMap ( FiniteMap, sizeFM, emptyFM, delFromFM,
+import FiniteMap ( FiniteMap, sizeFM, emptyFM, delFromFM, listToFM,
lookupFM, addToFM, addToFM_C, addListToFM,
fmToList, elemFM, foldFM
)
import Unique ( Unique )
import StringBuffer ( StringBuffer, hGetStringBuffer )
import FastString ( mkFastString )
+import ErrUtils ( Message )
+import Lex
import Outputable
import IO ( isDoesNotExistError )
%*********************************************************
\begin{code}
-loadHomeInterface :: SDoc -> Name -> RnM d (Module, Ifaces)
+loadHomeInterface :: SDoc -> Name -> RnM d Ifaces
loadHomeInterface doc_str name
- = loadInterface doc_str (moduleName (nameModule name)) ImportBySystem
+ = loadInterface doc_str (moduleName (nameModule name)) ImportBySystem `thenRn` \ (_, ifaces) ->
+ returnRn ifaces
+
+loadOrphanModules :: [ModuleName] -> RnM d ()
+loadOrphanModules mods
+ | null mods = returnRn ()
+ | 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
loadInterface :: SDoc -> ModuleName -> WhereFrom -> RnM d (Module, Ifaces)
loadInterface doc_str mod_name from
mod_map_result ->
-- READ THE MODULE IN
- findAndReadIface doc_str mod_name from in_map `thenRn` \ (hi_boot_read, read_result) ->
+ findAndReadIface doc_str mod_name from in_map
+ `thenRn` \ (hi_boot_read, read_result) ->
case read_result of {
Nothing -> -- 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, Just (mod, False, []))
- new_ifaces = ifaces { iImpModInfo = new_mod_map }
- in
- setIfacesRn new_ifaces `thenRn_`
- failWithRn (mod, new_ifaces) (noIfaceErr mod hi_boot_read) ;
+ let
+ mod = mkVanillaModule mod_name
+ new_mod_map = addToFM mod_map mod_name (0, False, Just (mod, False, []))
+ new_ifaces = ifaces { iImpModInfo = new_mod_map }
+ in
+ setIfacesRn new_ifaces `thenRn_`
+ failWithRn (mod, new_ifaces) (noIfaceErr mod hi_boot_read) ;
-- Found and parsed!
Just (mod, iface) ->
in
foldlRn (loadDecl mod) (iDecls ifaces) rd_decls `thenRn` \ new_decls ->
foldlRn (loadInstDecl mod) (iInsts ifaces) (pi_insts iface) `thenRn` \ new_insts ->
- foldlRn (loadRule mod) (iRules ifaces) (pi_rules iface) `thenRn` \ new_rules ->
+ (if (opt_IgnoreIfacePragmas)
+ then returnRn emptyBag
+ else foldlRn (loadRule mod) (iRules ifaces) (pi_rules iface)) `thenRn` \ new_rules ->
foldlRn (loadFixDecl mod_name) (iFixes ifaces) rd_decls `thenRn` \ new_fixities ->
mapRn (loadExport this_mod_nm) (pi_exports iface) `thenRn` \ avails_s ->
let
is_lib = isLibModule mod -- Don't record dependencies when importing a library module
add (imp_mod, version, has_orphans, _) deps
| is_lib && not has_orphans = deps
- | otherwise = addToFM_C combine deps imp_mod (version, has_orphans, Nothing)
+ | otherwise = addToFM_C combine deps imp_mod (version, has_orphans, Nothing)
-- Record dependencies for modules that are
-- either are dependent via a non-library module
-- or contain orphan rules or instance decls
let
main_name = availName avail
new_decls_map = foldl add_decl decls_map
- [ (name, (version, avail, name==main_name, (mod, decl)))
+ [ (name, (version, avail, name==main_name, (mod, decl')))
| name <- sys_bndrs ++ availNames avail]
add_decl decls_map (name, stuff)
= WARN( name `elemNameEnv` decls_map, ppr name )
dates from a time where we picked up a .hi file first if it existed?]
-}
decl' = case decl of
- SigD (IfaceSig name tp ls loc) | opt_IgnoreIfacePragmas -> SigD (IfaceSig name tp [] loc)
- other -> decl
+ SigD (IfaceSig name tp ls loc) | opt_IgnoreIfacePragmas
+ -> SigD (IfaceSig name tp [] loc)
+ other -> decl
loadInstDecl :: Module
-> Bag GatedDecl
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 ;
+ 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]) `thenRn_`
- checkModUsage rest
+ traceRn (sep [ptext SLIT("Module version unchanged:"), pprModuleName mod_name])
+ `thenRn_` checkModUsage rest
else
- traceRn (sep [ptext SLIT("Module version has changed:"), pprModuleName mod_name]) `thenRn_`
-
+ traceRn (sep [ptext SLIT("Module version has changed:"), pprModuleName mod_name])
+ `thenRn_`
-- Module version changed, so check entities inside
-- If the usage info wants to say "I imported everything from this module"
case lookupNameEnv decls name of
Nothing -> -- We used it before, but it ain't there now
- putDocRn (sep [ptext SLIT("No longer exported:"), ppr name]) `thenRn_`
- returnRn False
+ traceRn (sep [ptext SLIT("No longer exported:"), ppr name])
+ `thenRn_` returnRn False
Just (new_vers,_,_,_) -- It's there, but is it up to date?
| new_vers == old_vers
| otherwise
-- Out of date, so bale out
- -> putDocRn (sep [ptext SLIT("Out of date:"), ppr name]) `thenRn_`
+ -> traceRn (sep [ptext SLIT("Out of date:"), ppr name]) `thenRn_`
returnRn False
\end{code}
if name `elemNameSet` already_slurped then
returnRn Nothing -- Already dealt with
else
- getModuleRn `thenRn` \ this_mod ->
- let
- mod = moduleName (nameModule name)
- in
- if mod == this_mod then -- Don't bring in decls from
+ if isLocallyDefined name then -- Don't bring in decls from
-- the renamed module's own interface file
- addWarnRn (importDeclWarn mod name) `thenRn_`
+ addWarnRn (importDeclWarn name) `thenRn_`
returnRn Nothing
else
getNonWiredInDecl name
getNonWiredInDecl :: Name -> RnMG (Maybe (Module, RdrNameHsDecl))
getNonWiredInDecl needed_name
= traceRn doc_str `thenRn_`
- loadHomeInterface doc_str needed_name `thenRn` \ (_, ifaces) ->
+ loadHomeInterface doc_str needed_name `thenRn` \ ifaces ->
case lookupNameEnv (iDecls ifaces) needed_name of
Just (version,avail,_,decl)
@getWiredInDecl@ maps a wired-in @Name@ to what it makes available.
It behaves exactly as if the wired in decl were actually in an interface file.
Specifically,
-
- * if the wired-in name is a data type constructor or a data constructor,
+\begin{itemize}
+\item if the wired-in name is a data type constructor or a data constructor,
it brings in the type constructor and all the data constructors; and
- marks as "occurrences" any free vars of the data con.
+ marks as ``occurrences'' any free vars of the data con.
- * similarly for synonum type constructor
+\item similarly for synonum type constructor
- * if the wired-in name is another wired-in Id, it marks as "occurrences"
+\item if the wired-in name is another wired-in Id, it marks as ``occurrences''
the free vars of the Id's type.
- * it loads the interface file for the wired-in thing for the
+\item it loads the interface file for the wired-in thing for the
sole purpose of making sure that its instance declarations are available
-
-All this is necessary so that we know all types that are "in play", so
+\end{itemize}
+All this is necessary so that we know all types that are ``in play'', so
that we know just what instances to bring into scope.
%* *
%*********************************************************
-@getInterfaceExports@ is called only for directly-imported modules
+@getInterfaceExports@ is called only for directly-imported modules.
\begin{code}
getInterfaceExports :: ModuleName -> WhereFrom -> RnMG (Module, Avails)
getInterfaceExports mod_name from
= loadInterface doc_str mod_name from `thenRn` \ (mod, 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, [])
+ 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)
where
\begin{code}
getImportedInstDecls :: NameSet -> RnMG [(Module,RdrNameHsDecl)]
getImportedInstDecls gates
- = -- First load any orphan-instance modules that aren't aready loaded
+ = -- First, load any orphan-instance modules that aren't aready loaded
-- Orphan-instance modules are recorded in the module dependecnies
- getIfacesRn `thenRn` \ ifaces ->
+ getIfacesRn `thenRn` \ ifaces ->
let
- orphan_mods = [mod | (mod, (_, True, Nothing)) <- fmToList (iImpModInfo ifaces)]
+ orphan_mods =
+ [mod | (mod, (_, True, Nothing)) <- fmToList (iImpModInfo ifaces)]
in
- traceRn (text "Loading orphan modules" <+> fsep (map pprModuleName orphan_mods)) `thenRn_`
- mapRn_ load_it orphan_mods `thenRn_`
+ loadOrphanModules orphan_mods `thenRn_`
-- Now we're ready to grab the instance declarations
-- Find the un-gated ones and return them,
-- removing them from the bag kept in Ifaces
- getIfacesRn `thenRn` \ ifaces ->
+ getIfacesRn `thenRn` \ ifaces ->
let
(decls, new_insts) = selectGated gates (iInsts ifaces)
in
setIfacesRn (ifaces { iInsts = new_insts }) `thenRn_`
traceRn (sep [text "getImportedInstDecls:",
- nest 4 (fsep (map ppr (nameSetToList gates))),
- text "Slurped" <+> int (length decls) <+> text "instance declarations"]) `thenRn_`
+ nest 4 (fsep (map ppr gate_list)),
+ text "Slurped" <+> int (length decls) <+> text "instance declarations",
+ nest 4 (vcat (map ppr_brief_inst_decl decls))]) `thenRn_`
returnRn decls
where
- load_it mod = loadInterface (doc_str mod) mod ImportBySystem
- doc_str mod = sep [pprModuleName mod, ptext SLIT("is a orphan-instance module")]
+ 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
+ other -> ppr inst_ty
getImportedRules :: RnMG [(Module,RdrNameHsDecl)]
-getImportedRules
+getImportedRules
+ | opt_IgnoreIfacePragmas = returnRn []
+ | otherwise
= getIfacesRn `thenRn` \ ifaces ->
let
gates = iSlurp ifaces -- Anything at all that's been slurped
returnRn decls
selectGated gates decl_bag
+ -- Select only those decls whose gates are *all* in 'gates'
#ifdef DEBUG
| opt_NoPruneDecls -- Just to try the effect of not gating at all
= (foldrBag (\ (_,d) ds -> d:ds) [] decl_bag, emptyBag) -- Grab them all
Nothing -> returnRn defaultFixity
| otherwise -- Imported
- = loadHomeInterface doc name `thenRn` \ (_, ifaces) ->
+ = loadHomeInterface doc name `thenRn` \ ifaces ->
case lookupNameEnv (iFixes ifaces) name of
Just (FixitySig _ fix _) -> returnRn fix
Nothing -> returnRn defaultFixity
%* *
%*********************************************************
-getImportVersions figures out what the "usage information" for this moudule is;
-that is, what it must record in its interface file as the things it uses.
-It records:
- - anything reachable from its body code
- - any module exported with a "module Foo".
+getImportVersions figures out what the ``usage information'' for this
+moudule is; that is, what it must record in its interface file as the
+things it uses. It records:
-Why the latter? Because if Foo changes then this module's export list
+\begin{itemize}
+\item anything reachable from its body code
+\item any module exported with a @module Foo@.
+\end{itemize}
+%
+Why the latter? 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?
- module A( f, g ) where module B( f ) where
- import B( f ) f = h 3
- g = ... h = ...
-
-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:
-
-1. Are A.o and A.hi correct? Then we can bale out early.
-2. Should modules that import A be recompiled?
-
-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 (which 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 *do* count module B among
-A's usages, because we must recompile A to ensure that A.hi changes appropriately.
+\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> :: ;
+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.
+So we'll get an early bale-out when compiling A if B's version changes.
\begin{code}
getImportVersions :: ModuleName -- Name of this module
- -> Maybe [IE any] -- Export list for this module
+ -> ExportEnv -- Info about exports
-> RnMG (VersionInfo Name) -- Version info for these names
-getImportVersions this_mod exports
+getImportVersions this_mod (ExportEnv export_avails _ export_all_mods)
= getIfacesRn `thenRn` \ ifaces ->
let
mod_map = iImpModInfo ifaces
imp_names = iVSlurp ifaces
+ export_mods :: FiniteMap ModuleName () -- Set of home modules for
+ -- things in the export list
+ export_mods = listToFM [(moduleName (nameModule (availName a)), ()) | a <- export_avails]
+
-- mv_map groups together all the things imported from a particular module.
- mv_map1, mv_map2 :: FiniteMap ModuleName (WhatsImported Name)
+ mv_map :: FiniteMap ModuleName [(Name,Version)]
+ mv_map = foldr add_mv emptyFM imp_names
- -- mv_map1 records all the modules that have a "module M"
- -- in this module's export list with an "Everything"
- mv_map1 = foldr add_mod emptyFM export_mods
-
- -- mv_map2 adds the version numbers of things exported individually
- mv_map2 = foldr add_mv mv_map1 imp_names
-
- -- Build the result list by adding info for each module,
- -- *omitting* (a) library modules
- -- (b) source-imported modules
- mk_version_info mod_name (version, has_orphans, cts) so_far
- | omit cts = so_far -- Don't record usage info for this module
- | otherwise = (mod_name, version, has_orphans, whats_imported) : so_far
+ -- Build the result list by adding info for each module.
+ -- For (a) a library module, we don't record it at all unless it contains orphans
+ -- (We must never lose track of orphans.)
+ --
+ -- (b) a source-imported module, don't record the dependency at all
+ --
+ -- (b) may seem a bit strange. The idea is that the usages in a .hi file records
+ -- *all* the module's dependencies other than the loop-breakers. We use
+ -- this info in findAndReadInterface to decide whether to look for a .hi file or
+ -- a .hi-boot file.
+ --
+ -- This means we won't track version changes, or orphans, from .hi-boot files.
+ -- The former is potentially rather bad news. It could be fixed by recording
+ -- whether something is a boot file along with the usage info for it, but
+ -- I can't be bothered just now.
+
+ mk_version_info mod_name (version, has_orphans, Nothing) so_far
+ = ASSERT( not has_orphans ) -- If has_orphans is true we will have opened it
+ so_far -- We didn't even read this module's interface
+ -- so don't record dependency on it.
+
+ mk_version_info mod_name (version, has_orphans, Just (mod, boot_import, _)) so_far
+ | boot_import -- Don't record any usage info for this module
+ || (is_lib_module && not has_orphans)
+ = so_far
+
+ | is_lib_module -- Record the module but not
+ || mod_name `elem` export_all_mods -- detailed version information for the imports
+ = go_for_it Everything
+
+ | otherwise
+ = case lookupFM mv_map mod_name of
+ Just whats_imported
+ -> go_for_it (Specifically whats_imported)
+
+ Nothing -- This happens if you have
+ -- import Foo
+ -- but don't actually *use* anything from Foo
+ | has_orphans -- Check for (a) orphans (we must never forget them)
+ || mod_name `elemFM` export_mods -- or (b) something from the module is exported
+ -> -- ...in which case record an empty dependency list
+ go_for_it (Specifically [])
+
+ | otherwise -> so_far -- No point in recording any dependency
where
- whats_imported = case lookupFM mv_map2 mod_name of
- Just wi -> wi
- Nothing -> Specifically []
+ is_lib_module = isLibModule mod
+ go_for_it exports = (mod_name, version, has_orphans, exports) : so_far
- omit (Just (mod, boot_import, _)) = isLibModule mod || boot_import
- omit Nothing = 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
- export_mods = case exports of
- Nothing -> []
- Just es -> [mod | IEModuleContents mod <- es, mod /= this_mod]
-
add_mv v@(name, version) mv_map
- = addToFM_C add_item mv_map mod (Specifically [v])
- where
+ = addToFM_C add_item mv_map mod [v]
+ where
mod = moduleName (nameModule name)
-
- add_item Everything _ = Everything
- add_item (Specifically xs) _ = Specifically (v:xs)
-
- add_mod mod mv_map = addToFM mv_map mod Everything
+ add_item vs _ = (v:vs)
\end{code}
\begin{code}
It's used for both source code (from @availsFromDecl@) and interface files
(from @loadDecl@).
-It doesn't deal with source-code specific things: ValD, DefD. They
-are handled by the sourc-code specific stuff in RnNames.
+It doesn't deal with source-code specific things: @ValD@, @DefD@. They
+are handled by the sourc-code specific stuff in @RnNames@.
\begin{code}
getDeclBinders :: (RdrName -> SrcLoc -> RnM d Name) -- New-name function
= 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
returnRn (Just (Avail var_name))
getDeclBinders new_name (FixD _) = returnRn Nothing
-getDeclBinders new_name (ForD _) = returnRn Nothing
+
+ -- foreign declarations
+getDeclBinders new_name (ForD (ForeignDecl nm kind _ dyn _ loc))
+ | binds_haskell_name kind dyn
+ = new_name nm loc `thenRn` \ name ->
+ returnRn (Just (Avail name))
+
+ | otherwise -- a foreign export
+ = lookupImplicitOccRn nm `thenRn_`
+ returnRn Nothing
+
getDeclBinders new_name (DefD _) = returnRn Nothing
getDeclBinders new_name (InstD _) = returnRn Nothing
getDeclBinders new_name (RuleD _) = returnRn Nothing
+binds_haskell_name (FoImport _) _ = True
+binds_haskell_name FoLabel _ = True
+binds_haskell_name FoExport ext_nm = isDynamic ext_nm
+
----------------
getConFieldNames new_name (ConDecl con _ _ (RecCon fielddecls) src_loc : rest)
= mapRn (\n -> new_name n src_loc) (con:fields) `thenRn` \ cfs ->
getConFieldNames new_name [] = returnRn []
-getClassOpNames new_name (ClassOpSig op _ _ src_loc) = new_name op src_loc
+getClassOpNames new_name (ClassOpSig op _ _ _ src_loc) = new_name op src_loc
\end{code}
@getDeclSysBinders@ gets the implicit binders introduced by a decl.
A the moment that's just the tycon and datacon that come with a class decl.
-They aren'te returned by getDeclBinders because they aren't in scope;
-but they *should* be put into the DeclsMap of this module.
+They aren't returned by @getDeclBinders@ because they aren't in scope;
+but they {\em should} be put into the @DeclsMap@ of this module.
Note that this excludes the default-method names of a class decl,
and the dict fun of an instance decl, because both of these have
bindings of their own elsewhere.
\begin{code}
-getDeclSysBinders new_name (TyClD (ClassDecl _ cname _ sigs _ _ tname dname snames src_loc))
+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 ->
case find_path from hi_maps of
-- Found the file
- (hi_boot, Just (fpath, mod)) -> traceRn (ptext SLIT("...reading from") <+> text fpath) `thenRn_`
+ (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_`
-- Nothing <=> file not found, or unreadable, or illegible
-- Just x <=> successfully found and parsed
readIface the_mod file_path
- = ioToRnM (hGetStringBuffer file_path) `thenRn` \ read_result ->
+ = ioToRnM (hGetStringBuffer False file_path) `thenRn` \ read_result ->
case read_result of
Right contents ->
- case parseIface contents (mkSrcLoc (mkFastString file_path) 1) of
- Failed err -> failWithRn Nothing err
- Succeeded (PIface mod_nm iface) ->
- warnCheckRn (mod_nm == moduleName the_mod)
- (hsep [ ptext SLIT("Something is amiss; requested module name")
- , pprModule the_mod
- , ptext SLIT("differs from name found in the interface file ")
- , pprModuleName mod_nm
- ]) `thenRn_`
- returnRn (Just (the_mod, iface))
+ case parseIface contents
+ PState{ bol = 0#, atbol = 1#,
+ context = [],
+ glasgow_exts = 1#,
+ loc = mkSrcLoc (mkFastString file_path) 1 } of
+ PFailed err -> failWithRn Nothing err
+ POk _ (PIface mod_nm iface) ->
+ warnCheckRn (mod_nm == moduleName the_mod)
+ (hiModuleNameMismatchWarn the_mod mod_nm) `thenRn_`
+ returnRn (Just (the_mod, iface))
Left err
| isDoesNotExistError err -> returnRn Nothing
= sep [ptext SLIT("Failed to find (optional) interface decl for") <+> quotes (ppr name),
ptext SLIT("desired at") <+> ppr loc]
-importDeclWarn mod name
- = sep [ptext SLIT("Compiler tried to import decl from interface file with same name as module."),
- ptext SLIT("(possible cause: module name clashes with interface file already in scope.)")
+importDeclWarn name
+ = sep [ptext SLIT(
+ "Compiler tried to import decl from interface file with same name as module."),
+ ptext SLIT(
+ "(possible cause: module name clashes with interface file already in scope.)")
] $$
- hsep [ptext SLIT("Interface:"), quotes (pprModuleName mod),
- comma, ptext SLIT("name:"), quotes (ppr name)]
+ hsep [ptext SLIT("name:"), quotes (ppr name)]
warnRedundantSourceImport mod_name
- = ptext SLIT("Unnecessary {- SOURCE -} in the import of module") <+> quotes (pprModuleName mod_name)
+ = ptext SLIT("Unnecessary {- SOURCE -} in the import of module")
+ <+> quotes (pprModuleName mod_name)
+
+hiModuleNameMismatchWarn :: Module -> ModuleName -> Message
+hiModuleNameMismatchWarn requested_mod mod_nm =
+ 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
+ ]
+
\end{code}