#include "HsVersions.h"
+import DriverState ( GhcMode(..), v_GhcMode )
+import DriverUtil ( splitFilename )
import CmdLineOpts ( opt_IgnoreIfacePragmas )
import HscTypes ( ModuleLocation(..),
ModIface(..), emptyModIface,
- VersionInfo(..),
+ VersionInfo(..), ImportedModuleInfo,
lookupIfaceByModName,
ImportVersion, WhetherHasOrphans, IsBootInterface,
DeclsMap, GatedDecl, IfaceInsts, IfaceRules,
import BasicTypes ( Version, defaultFixity )
import RnEnv
import RnMonad
-import ParseIface ( parseIface, IfaceStuff(..) )
+import ParseIface ( parseIface )
-import Name ( Name {-instance NamedThing-}, nameOccName,
- nameModule, isLocalName, nameIsLocalOrFrom,
- NamedThing(..),
+import Name ( Name {-instance NamedThing-},
+ nameModule, isLocalName, nameIsLocalOrFrom
)
-import Name ( mkNameEnv, extendNameEnv )
-import Module ( Module,
- moduleName, isHomeModule,
- ModuleName, WhereFrom(..),
- extendModuleEnv, mkVanillaModule
- )
-import RdrName ( RdrName, rdrNameOcc )
+import NameEnv
+import Module
+import RdrName ( rdrNameOcc )
import SrcLoc ( mkSrcLoc )
import Maybes ( maybeToBool, orElse )
import StringBuffer ( hGetStringBuffer )
import FastString ( mkFastString )
import ErrUtils ( Message )
-import Finder ( findModule )
+import Finder ( findModule, findPackageModule )
import Lex
import FiniteMap
import Outputable
import Bag
import Config
+import IOExts
import Directory
\end{code}
= tryLoadInterface doc mod from `thenRn` \ (ifaces, maybe_err) ->
case maybe_err of
Nothing -> returnRn ifaces
- Just err -> failWithRn ifaces err
+ Just err -> failWithRn ifaces (elaborate err)
+ where
+ elaborate err = hang (ptext SLIT("failed to load interface for") <+> quotes (ppr mod) <> colon)
+ 4 err
tryLoadInterface :: SDoc -> ModuleName -> WhereFrom -> RnM d (ModIface, Maybe Message)
-- Returns (Just err) if an error happened
-- (If the load fails, we plug in a vanilla placeholder)
tryLoadInterface doc_str mod_name from
= getHomeIfaceTableRn `thenRn` \ hit ->
+ getModuleRn `thenRn` \ this_mod ->
getIfacesRn `thenRn` \ ifaces@(Ifaces { iPIT = pit }) ->
-- CHECK WHETHER WE HAVE IT ALREADY
warnCheckRn (not redundant_source_import)
(warnRedundantSourceImport mod_name) `thenRn_`
+ -- Check that we aren't importing ourselves.
+ -- That only happens in Rename.checkOldIface,
+ -- which doesn't call tryLoadInterface
+ warnCheckRn
+ (not (isHomeModule this_mod) || moduleName this_mod /= mod_name)
+ (warnSelfImport this_mod) `thenRn_`
+
-- READ THE MODULE IN
- findAndReadIface doc_str mod_name hi_boot_file `thenRn` \ read_result ->
+ findAndReadIface doc_str mod_name hi_boot_file
+ `thenRn` \ read_result ->
case read_result of {
Left err -> -- Not found, so add an empty export env to the Ifaces map
-- so that we don't look again
ImportByUser -> addModDeps mod is_loaded (pi_usages iface) mod_map
other -> mod_map
mod_map2 = delFromFM mod_map1 mod_name
- is_loaded m = maybeToBool (lookupIfaceByModName hit pit m)
+
+ this_mod_name = moduleName this_mod
+ is_loaded m = m == this_mod_name
+ || maybeToBool (lookupIfaceByModName hit pit m)
+ -- We treat the currently-being-compiled module as 'loaded' because
+ -- even though it isn't yet in the HIT or PIT; otherwise it gets
+ -- put into iImpModInfo, and then spat out into its own interface
+ -- file as a dependency
-- Now add info about this module to the PIT
has_orphans = pi_orphan iface
-----------------------------------------------------
addModDeps :: Module
- -> (ModuleName -> Bool) -- True for module interfaces
+ -> (ModuleName -> Bool) -- True for modules that are already loaded
-> [ImportVersion a]
-> ImportedModuleInfo -> ImportedModuleInfo
-- (addModDeps M ivs deps)
-- and in that case, forget about the boot indicator
filtered_new_deps :: [(ModuleName, (WhetherHasOrphans, IsBootInterface))]
filtered_new_deps
- | isHomeModule mod
- = [ (imp_mod, (has_orphans, is_boot))
+ | isHomeModule mod = [ (imp_mod, (has_orphans, is_boot))
| (imp_mod, has_orphans, is_boot, _) <- new_deps,
not (is_loaded imp_mod)
]
loadExports :: (Version, [ExportItem]) -> RnM d (Version, [(ModuleName,Avails)])
loadExports (vers, items)
- = getModuleRn `thenRn` \ this_mod ->
- mapRn (loadExport this_mod) items `thenRn` \ avails_s ->
+ = mapRn loadExport items `thenRn` \ avails_s ->
returnRn (vers, avails_s)
-loadExport :: Module -> ExportItem -> RnM d (ModuleName, Avails)
-loadExport this_mod (mod, entities)
+loadExport :: ExportItem -> RnM d (ModuleName, Avails)
+loadExport (mod, entities)
= mapRn (load_entity mod) entities `thenRn` \ avails ->
returnRn (mod, avails)
where
It doesn't deal with source-code specific things: @ValD@, @DefD@. They
are handled by the sourc-code specific stuff in @RnNames@.
+ *** See "THE NAMING STORY" in HsDecls ****
+
+
\begin{code}
getTyClDeclBinders
:: Module
findAndReadIface doc_str mod_name hi_boot_file
= traceRn trace_msg `thenRn_`
- ioToRnM (findModule mod_name) `thenRn` \ maybe_found ->
+ -- In interactive or --make mode, we are *not allowed* to demand-load
+ -- a home package .hi file. So don't even look for them.
+ -- This helps in the case where you are sitting in eg. ghc/lib/std
+ -- and start up GHCi - it won't complain that all the modules it tries
+ -- to load are found in the home location.
+ ioToRnM_no_fail (readIORef v_GhcMode) `thenRn` \ mode ->
+ let home_allowed = mode `notElem` [ DoInteractive, DoLink ]
+ in
+
+ ioToRnM (if home_allowed
+ then findModule mod_name
+ else findPackageModule mod_name) `thenRn` \ maybe_found ->
+
case maybe_found of
Right (Just (wanted_mod,locn))
Left bad -> returnRn (Left bad)
Right iface
-> let read_mod = pi_mod iface
- in warnCheckRn (wanted_mod == read_mod)
- (hiModuleNameMismatchWarn wanted_mod
- read_mod) `thenRn_`
+ in -- check that the module names agree
+ checkRn
+ (wanted_mod == read_mod)
+ (hiModuleNameMismatchWarn wanted_mod read_mod)
+ `thenRn_`
+ -- check that the package names agree
+ checkRn
+ (modulePackage wanted_mod == modulePackage read_mod)
+ (packageNameMismatchWarn wanted_mod read_mod)
+ `thenRn_`
returnRn (Right (wanted_mod, iface))
-- Can't find it
other -> traceRn (ptext SLIT("...not found")) `thenRn_`
if b then returnRn hi_boot_ver_path
else returnRn hi_boot_path
| otherwise = returnRn hi_path
- where (Just hi_path) = ml_hi_file locn
- hi_boot_path = hi_path ++ "-boot"
- hi_boot_ver_path = hi_path ++ "-boot-" ++ cHscIfaceFileVersion
+ where hi_path = ml_hi_file locn
+ (hi_base, _hi_suf) = splitFilename hi_path
+ hi_boot_path = hi_base ++ ".hi-boot"
+ hi_boot_ver_path = hi_base ++ ".hi-boot-" ++ cHscIfaceFileVersion
\end{code}
@readIface@ tries just the one file.
Right contents ->
case parseIface contents init_parser_state of
- POk _ (PIface iface) -> returnRn (Right iface)
+ POk _ iface -> returnRn (Right 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.
}
where
init_parser_state = PState{ bol = 0#, atbol = 1#,
, ppr read_mod
]
+packageNameMismatchWarn :: Module -> Module -> Message
+packageNameMismatchWarn requested_mod read_mod =
+ sep [ ptext SLIT("Module"), quotes (ppr requested_mod),
+ ptext SLIT("is located in package"),
+ quotes (ptext (modulePackage requested_mod)),
+ ptext SLIT("but its interface file claims it is part of package"),
+ quotes (ptext (modulePackage read_mod))
+ ]
+
warnRedundantSourceImport mod_name
= ptext SLIT("Unnecessary {- SOURCE -} in the import of module")
<+> quotes (ppr mod_name)
+
+notLoaded mod
+ = ptext SLIT("Module") <+> quotes (ppr mod) <+> ptext SLIT("is not loaded")
+
+warnSelfImport mod
+ = ptext SLIT("Importing my own interface: module") <+> ppr mod
\end{code}
projects / ghc-hetmet.git / blobdiff