\section[RnIfaces]{Cacheing and Renaming of Interfaces}
\begin{code}
-module RnIfaces (
- findAndReadIface,
+module RnIfaces
+ (
+ findAndReadIface,
- getInterfaceExports, getDeferredDecls,
+ getInterfaceExports,
getImportedInstDecls, getImportedRules,
lookupFixityRn, loadHomeInterface,
- importDecl, ImportDeclResult(..), recordLocalSlurps, loadBuiltinRules,
- mkImportExportInfo, getSlurped,
-
- checkModUsage, outOfDate, upToDate,
+ importDecl, ImportDeclResult(..), recordLocalSlurps,
+ mkImportInfo, getSlurped,
getDeclBinders, getDeclSysBinders,
removeContext -- removeContext probably belongs somewhere else
- ) where
+ )
+where
#include "HsVersions.h"
import CmdLineOpts ( opt_NoPruneDecls, opt_NoPruneTyDecls, opt_IgnoreIfacePragmas )
+import HscTypes
import HsSyn ( HsDecl(..), TyClDecl(..), InstDecl(..), IfaceSig(..),
- HsType(..), ConDecl(..), IE(..), ConDetails(..), Sig(..),
+ HsType(..), ConDecl(..),
ForeignDecl(..), ForKind(..), isDynamicExtName,
FixitySig(..), RuleDecl(..),
- isClassOpSig, DeprecDecl(..)
+ tyClDeclNames
)
-import HsImpExp ( ieNames )
-import CoreSyn ( CoreRule )
-import BasicTypes ( Version, NewOrData(..) )
+import HsImpExp ( ImportDecl(..) )
+import BasicTypes ( Version, defaultFixity )
import RdrHsSyn ( RdrNameHsDecl, RdrNameInstDecl, RdrNameRuleDecl,
- RdrNameDeprecation, RdrNameIE,
extractHsTyRdrNames
)
import RnEnv
import Name ( Name {-instance NamedThing-}, nameOccName,
nameModule, isLocallyDefined,
- isWiredInName, nameUnique, NamedThing(..),
- elemNameEnv, extendNameEnv
+ NamedThing(..),
+ mkNameEnv, elemNameEnv, extendNameEnv
)
-import Module ( Module, moduleString, pprModule,
- mkVanillaModule, pprModuleName,
- moduleUserString, moduleName, isLocalModule,
+import Module ( Module, ModuleEnv,
+ moduleName, isModuleInThisPackage,
ModuleName, WhereFrom(..),
+ emptyModuleEnv, extendModuleEnv, lookupModuleEnvByName,
+ extendModuleEnv_C, lookupWithDefaultModuleEnv
)
import RdrName ( RdrName, rdrNameOcc )
import NameSet
import SrcLoc ( mkSrcLoc, SrcLoc )
-import PrelInfo ( cCallishTyKeys )
-import Maybes ( MaybeErr(..), maybeToBool, orElse )
-import Unique ( Uniquable(..) )
+import PrelInfo ( wiredInThingEnv )
+import Maybes ( maybeToBool, orElse )
import StringBuffer ( hGetStringBuffer )
import FastString ( mkFastString )
import ErrUtils ( Message )
-import Util ( sortLt )
import Lex
import FiniteMap
import Outputable
import Bag
-import List ( nub )
+import List ( nub )
\end{code}
loadOrphanModules mods
| null mods = returnRn ()
| otherwise = traceRn (text "Loading orphan modules:" <+>
- fsep (map pprModuleName mods)) `thenRn_`
+ fsep (map ppr mods)) `thenRn_`
mapRn_ load mods `thenRn_`
returnRn ()
where
load mod = loadInterface (mk_doc mod) mod ImportBySystem
- mk_doc mod = pprModuleName mod <+> ptext SLIT("is a orphan-instance module")
+ mk_doc mod = ppr mod <+> ptext SLIT("is a orphan-instance module")
loadInterface :: SDoc -> ModuleName -> WhereFrom -> RnM d Ifaces
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
+ -- Guarantees to return with iImpModInfo m --> (..., True)
+ -- (If the load fails, we plug in a vanilla placeholder)
tryLoadInterface doc_str mod_name from
- = getIfacesRn `thenRn` \ ifaces ->
+ = getHomeIfaceTableRn `thenRn` \ hit ->
+ getIfacesRn `thenRn` \ ifaces ->
+
+ -- Check whether we have it already in the home package
+ case lookupModuleEnvByName hit mod_name of {
+ Just _ -> returnRn (ifaces, Nothing) ; -- In the home package
+ Nothing ->
+
let
mod_map = iImpModInfo ifaces
mod_info = lookupFM mod_map mod_name
- 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.
- }
+ hi_boot_file
+ = case (from, mod_info) of
+ (ImportByUser, _) -> False -- Not hi-boot
+ (ImportByUserSource, _) -> True -- hi-boot
+ (ImportBySystem, Just (_, is_boot, _)) -> is_boot --
+ (ImportBySystem, 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
+ other -> False
in
-- CHECK WHETHER WE HAVE IT ALREADY
case mod_info of {
- Just (_, _, Just _)
+ Just (_, _, True)
-> -- We're read it already so don't re-read it
returnRn (ifaces, Nothing) ;
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 (False, False, Just (mod, 0, 0, 0, from, []))
+ new_mod_map = addToFM mod_map mod_name (False, False, True)
new_ifaces = ifaces { iImpModInfo = new_mod_map }
in
setIfacesRn new_ifaces `thenRn_`
returnRn (new_ifaces, Just err) ;
-- Found and parsed!
- Right iface ->
+ Right (mod, iface) ->
-- LOAD IT INTO Ifaces
-- If we do loadExport first the wrong info gets into the cache (unless we
-- explicitly tag each export which seems a bit of a bore)
- getModuleRn `thenRn` \ this_mod ->
- let
- 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,
+ isModuleInThisPackage mod,
ppr mod )
- foldlRn (loadDecl mod) (iDecls ifaces) (pi_decls iface) `thenRn` \ new_decls ->
+
+ loadDecls mod (iDecls ifaces) (pi_decls iface) `thenRn` \ (decls_vers, new_decls) ->
+ loadRules mod (iRules ifaces) (pi_rules iface) `thenRn` \ (rule_vers, new_rules) ->
+ loadFixDecls mod_name (pi_fixity iface) `thenRn` \ fix_env ->
+ loadDeprecs mod (pi_deprecs iface) `thenRn` \ deprec_env ->
foldlRn (loadInstDecl mod) (iInsts ifaces) (pi_insts iface) `thenRn` \ new_insts ->
- loadRules mod (iRules ifaces) (pi_rules iface) `thenRn` \ new_rules ->
- loadFixDecls mod_name (iFixes ifaces) (pi_fixity iface) `thenRn` \ new_fixities ->
- foldlRn (loadDeprec mod) (iDeprecs ifaces) (pi_deprecs iface) `thenRn` \ new_deprecs ->
- mapRn (loadExport this_mod) (pi_exports iface) `thenRn` \ avails_s ->
+ loadExports (pi_exports iface) `thenRn` \ (export_vers, avails) ->
let
+ version = VersionInfo { vers_module = pi_vers iface,
+ vers_exports = export_vers,
+ vers_rules = rule_vers,
+ vers_decls = decls_vers }
+
-- For an explicit user import, add to mod_map info about
-- the things the imported module depends on, extracted
-- from its usage info.
mod_map1 = case from of
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
- cts = (pi_mod iface, pi_vers iface,
- fst (pi_fixity iface), fst (pi_rules iface),
- from, concat avails_s)
- mod_details = (pi_orphan iface, hi_boot_file, Just cts)
-
- new_ifaces = ifaces { iImpModInfo = mod_map2,
+ mod_map2 = addToFM mod_map1 mod_name (has_orphans, hi_boot_file, True)
+
+ -- Now add info about this module to the PIT
+ has_orphans = pi_orphan iface
+ new_pit = extendModuleEnv (iPIT ifaces) mod mod_iface
+ mod_iface = ModIface { mi_module = mod, mi_version = version,
+ mi_exports = avails, mi_orphan = has_orphans,
+ mi_fixities = fix_env, mi_deprecs = deprec_env,
+ mi_usages = [], -- Will be filled in later
+ mi_decls = panic "No mi_decls in PIT",
+ mi_globals = panic "No mi_globals in PIT"
+ }
+
+ new_ifaces = ifaces { iPIT = new_pit,
iDecls = new_decls,
- iFixes = new_fixities,
iInsts = new_insts,
iRules = new_rules,
- iDeprecs = new_deprecs }
+ iImpModInfo = mod_map2 }
in
setIfacesRn new_ifaces `thenRn_`
returnRn (new_ifaces, Nothing)
- }}
+ }}}
-----------------------------------------------------
-- Adding module dependencies from the
-- 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 :: [(ModuleName, (WhetherHasOrphans, IsBootInterface, IsLoaded))]
filtered_new_deps
- | isLocalModule mod = [ (imp_mod, (has_orphans, is_boot, Nothing))
+ | isModuleInThisPackage mod
+ = [ (imp_mod, (has_orphans, is_boot, False))
| (imp_mod, has_orphans, is_boot, _) <- new_deps
]
- | otherwise = [ (imp_mod, (True, False, Nothing))
+ | otherwise = [ (imp_mod, (True, False, False))
| (imp_mod, 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
+ combine old@(_, old_is_boot, old_is_loaded) new
+ | old_is_loaded || 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
+ | otherwise = new -- Otherwise pick new info
-----------------------------------------------------
-- Loading the export list
-----------------------------------------------------
+loadExports :: (Version, [ExportItem]) -> RnM d (Version, Avails)
+loadExports (vers, items)
+ = getModuleRn `thenRn` \ this_mod ->
+ mapRn (loadExport this_mod) items `thenRn` \ avails_s ->
+ returnRn (vers, concat avails_s)
+
+
loadExport :: Module -> ExportItem -> RnM d [AvailInfo]
loadExport this_mod (mod, entities)
| mod == moduleName this_mod = returnRn []
-- Loading type/class/value decls
-----------------------------------------------------
+loadDecls :: Module
+ -> DeclsMap
+ -> [(Version, RdrNameHsDecl)]
+ -> RnM d (NameEnv Version, DeclsMap)
+loadDecls mod decls_map decls
+ = foldlRn (loadDecl mod) (emptyNameEnv, decls_map) decls
+
loadDecl :: Module
- -> DeclsMap
+ -> (NameEnv Version, DeclsMap)
-> (Version, RdrNameHsDecl)
- -> RnM d DeclsMap
-
-loadDecl mod decls_map (version, decl)
+ -> RnM d (NameEnv Version, DeclsMap)
+loadDecl mod (version_map, decls_map) (version, decl)
= getDeclBinders new_name decl `thenRn` \ maybe_avail ->
case maybe_avail of {
- Nothing -> returnRn decls_map; -- No bindings
- Just avail ->
+ Nothing -> returnRn (version_map, decls_map); -- No bindings
+ Just avail ->
getDeclSysBinders new_name decl `thenRn` \ sys_bndrs ->
let
main_name = availName avail
new_decls_map = foldl add_decl decls_map
- [ (name, (version, full_avail, name==main_name, (mod, decl')))
+ [ (name, (full_avail, name==main_name, (mod, decl')))
| name <- availNames full_avail]
add_decl decls_map (name, stuff)
= WARN( name `elemNameEnv` decls_map, ppr name )
extendNameEnv decls_map name stuff
+
+ new_version_map = extendNameEnv version_map main_name version
in
- returnRn new_decls_map
+ returnRn (new_version_map, new_decls_map)
}
where
-- newTopBinder puts into the cache the binder with the
-- There maybe occurrences that don't have the correct Module, but
-- by the typechecker will propagate the binding definition to all
-- the occurrences, so that doesn't matter
- new_name rdr_name loc = newTopBinder mod (rdrNameOcc rdr_name)
+ new_name rdr_name loc = newTopBinder mod rdr_name loc
{-
If a signature decl is being loaded, and optIgnoreIfacePragmas is on,
-- Loading fixity decls
-----------------------------------------------------
-loadFixDecls mod_name fixity_env (version, decls)
- | null decls = returnRn fixity_env
-
- | otherwise
+loadFixDecls mod_name decls
= mapRn (loadFixDecl mod_name) decls `thenRn` \ to_add ->
- returnRn (extendNameEnvList fixity_env to_add)
+ returnRn (mkNameEnv to_add)
loadFixDecl mod_name sig@(FixitySig rdr_name fixity loc)
= newGlobalName mod_name (rdrNameOcc rdr_name) `thenRn` \ name ->
- returnRn (name, FixitySig name fixity loc)
+ returnRn (name, fixity)
-----------------------------------------------------
loadRules :: Module -> IfaceRules
-> (Version, [RdrNameRuleDecl])
- -> RnM d IfaceRules
+ -> RnM d (Version, IfaceRules)
loadRules mod rule_bag (version, rules)
| null rules || opt_IgnoreIfacePragmas
- = returnRn rule_bag
+ = returnRn (version, rule_bag)
| otherwise
= setModuleRn mod $
mapRn (loadRule mod) rules `thenRn` \ new_rules ->
- returnRn (rule_bag `unionBags` listToBag new_rules)
+ returnRn (version, rule_bag `unionBags` listToBag new_rules)
loadRule :: Module -> RdrNameRuleDecl -> RnM d GatedDecl
-- "Gate" the rule simply by whether the rule variable is
= lookupOrigName var `thenRn` \ var_name ->
returnRn (unitNameSet var_name, (mod, RuleD decl))
-loadBuiltinRules :: [(RdrName, CoreRule)] -> RnMG ()
-loadBuiltinRules builtin_rules
- = getIfacesRn `thenRn` \ ifaces ->
- mapRn loadBuiltinRule builtin_rules `thenRn` \ rule_decls ->
- setIfacesRn (ifaces { iRules = iRules ifaces `unionBags` listToBag rule_decls })
-
-loadBuiltinRule (var, rule)
- = lookupOrigName var `thenRn` \ var_name ->
- returnRn (unitNameSet var_name, (nameModule var_name, RuleD (IfaceRuleOut var rule)))
-
-----------------------------------------------------
-- Loading Deprecations
-----------------------------------------------------
-loadDeprec :: Module -> DeprecationEnv -> RdrNameDeprecation -> RnM d DeprecationEnv
-loadDeprec mod deprec_env (Deprecation (IEModuleContents _) txt _)
- = traceRn (text "module deprecation not yet implemented:" <+> ppr mod <> colon <+> ppr txt) `thenRn_`
- -- SUP: TEMPORARY HACK, ignoring module deprecations for now
- returnRn deprec_env
-
-loadDeprec mod deprec_env (Deprecation ie txt _)
- = setModuleRn mod $
- mapRn lookupOrigName (ieNames ie) `thenRn` \ names ->
- traceRn (text "loaded deprecation(s) for" <+> hcat (punctuate comma (map ppr names)) <> colon <+> ppr txt) `thenRn_`
- returnRn (extendNameEnvList deprec_env (zip names (repeat txt)))
-\end{code}
-
-
-%********************************************************
-%* *
-\subsection{Checking usage information}
-%* *
-%********************************************************
-
-\begin{code}
-upToDate = True
-outOfDate = False
-
-checkModUsage :: [ImportVersion OccName] -> RnMG Bool
--- Given the usage information extracted from the old
--- M.hi file for the module being compiled, figure out
--- whether M needs to be recompiled.
-
-checkModUsage [] = returnRn upToDate -- Yes! Everything is up to date!
-
-checkModUsage ((mod_name, _, _, NothingAtAll) : rest)
- -- If CurrentModule.hi contains
- -- import Foo :: ;
- -- then that simply records that Foo lies below CurrentModule in the
- -- hierarchy, but CurrentModule doesn't depend in any way on Foo.
- -- In this case we don't even want to open Foo's interface.
- = traceRn (ptext SLIT("Nothing used from:") <+> ppr mod_name) `thenRn_`
- checkModUsage rest -- This one's ok, so check the rest
-
-checkModUsage ((mod_name, _, _, whats_imported) : rest)
- = tryLoadInterface doc_str mod_name ImportBySystem `thenRn` \ (ifaces, maybe_err) ->
- case maybe_err of {
- Just err -> out_of_date (sep [ptext SLIT("Can't find version number for module"),
- pprModuleName mod_name]) ;
- -- 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
- (_, new_mod_vers, new_fix_vers, new_rule_vers, _, _)
- = case lookupFM (iImpModInfo ifaces) mod_name of
- Just (_, _, Just stuff) -> stuff
-
- old_mod_vers = case whats_imported of
- Everything v -> v
- Specifically v _ _ _ -> v
- -- NothingAtAll case dealt with by previous eqn for checkModUsage
- in
- -- 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
- else
- 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"
- -- it does so by making whats_imported equal to Everything
- -- In that case, we must recompile
- case whats_imported of { -- NothingAtAll dealt with earlier
-
- Everything _
- -> out_of_date (ptext SLIT("...and I needed the whole module")) ;
-
- Specifically _ old_fix_vers old_rule_vers old_local_vers ->
-
- if old_fix_vers /= new_fix_vers then
- out_of_date (ptext SLIT("Fixities changed"))
- else if old_rule_vers /= new_rule_vers then
- out_of_date (ptext SLIT("Rules changed"))
- else
- -- Non-empty usage list, so check item by item
- checkEntityUsage mod_name (iDecls ifaces) old_local_vers `thenRn` \ up_to_date ->
- if up_to_date then
- traceRn (ptext SLIT("...but the bits I use haven't.")) `thenRn_`
- checkModUsage rest -- This one's ok, so check the rest
- else
- 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 upToDate -- Yes! All up to date!
-
-checkEntityUsage mod decls ((occ_name,old_vers) : rest)
- = newGlobalName mod occ_name `thenRn` \ name ->
- case lookupNameEnv decls name of
-
- Nothing -> -- We used it before, but it ain't there now
- out_of_date (sep [ptext SLIT("No longer exported:"), ppr name])
-
- Just (new_vers,_,_,_) -- It's there, but is it up to date?
- | new_vers == old_vers
- -- Up to date, so check the rest
- -> checkEntityUsage mod decls rest
-
- | otherwise
- -- Out of date, so bale out
- -> out_of_date (sep [ptext SLIT("Out of date:"), ppr name])
-
-out_of_date msg = traceRn msg `thenRn_` returnRn outOfDate
+loadDeprecs :: Module -> IfaceDeprecs -> RnM d Deprecations
+loadDeprecs m Nothing = returnRn NoDeprecs
+loadDeprecs m (Just (Left txt)) = returnRn (DeprecAll txt)
+loadDeprecs m (Just (Right prs)) = setModuleRn m $
+ foldlRn loadDeprec emptyNameEnv prs `thenRn` \ env ->
+ returnRn (DeprecSome env)
+loadDeprec deprec_env (n, txt)
+ = lookupOrigName n `thenRn` \ name ->
+ traceRn (text "Loaded deprecation(s) for" <+> ppr name <> colon <+> ppr txt) `thenRn_`
+ returnRn (extendNameEnv deprec_env name txt)
\end{code}
| HereItIs (Module, RdrNameHsDecl)
importDecl name
- = getSlurped `thenRn` \ already_slurped ->
- if name `elemNameSet` already_slurped then
- returnRn AlreadySlurped -- Already dealt with
+ = -- Check if it was loaded before beginning this module
+ checkAlreadyAvailable name `thenRn` \ done ->
+ if done then
+ returnRn AlreadySlurped
+ else
+
+ -- Check if we slurped it in while compiling this module
+ getIfacesRn `thenRn` \ ifaces ->
+ if name `elemNameSet` iSlurp ifaces then
+ returnRn AlreadySlurped
+ else
- else if isLocallyDefined name then -- Don't bring in decls from
- -- the renamed module's own interface file
+ -- Don't slurp in decls from this module's own interface file
+ -- (Indeed, this shouldn't happen.)
+ if isLocallyDefined name then
addWarnRn (importDeclWarn name) `thenRn_`
returnRn AlreadySlurped
+ else
- else if isWiredInName name then
- -- When we find a wired-in name we must load its
- -- home module so that we find any instance decls therein
+ -- When we find a wired-in name we must load its home
+ -- module so that we find any instance decls lurking therein
+ if name `elemNameEnv` wiredInThingEnv then
loadHomeInterface doc name `thenRn_`
returnRn WiredIn
where
doc = ptext SLIT("need home module for wired in thing") <+> ppr name
-
-{- I don't think this is necessary any more; SLPJ May 00
- load_home name
- | name `elemNameSet` source_binders = returnRn ()
- -- When compiling the prelude, a wired-in thing may
- -- be defined in this module, in which case we don't
- -- want to load its home module!
- -- Using 'isLocallyDefined' doesn't work because some of
- -- the free variables returned are simply 'listTyCon_Name',
- -- with a system provenance. We could look them up every time
- -- but that seems a waste.
- | otherwise = loadHomeInterface doc name `thenRn_`
- returnRn ()
--}
-
getNonWiredInDecl :: Name -> RnMG ImportDeclResult
getNonWiredInDecl needed_name
= traceRn doc_str `thenRn_`
loadHomeInterface doc_str needed_name `thenRn` \ ifaces ->
case lookupNameEnv (iDecls ifaces) needed_name of
- Just (version, avail, is_tycon_name, decl@(_, TyClD (TyData DataType _ _ _ _ ncons _ _ _)))
+{- OMIT DEFERRED STUFF FOR NOW, TILL GHCI WORKS
+ Just (version, avail, is_tycon_name, decl@(_, TyClD (TyData DataType _ _ _ _ ncons _ _ _ _)))
-- This case deals with deferred import of algebraic data types
| not opt_NoPruneTyDecls
-- Never defer ccall types; we have to unbox them,
-- and importing them does no harm
- -> -- OK, so we're importing a deferrable data type
- if needed_name == tycon_name then
- -- The needed_name is the TyCon of a data type decl
+
+ -> -- OK, so we're importing a deferrable data type
+ if needed_name == tycon_name
+ -- The needed_name is the TyCon of a data type decl
-- Record that it's slurped, put it in the deferred set
-- and don't return a declaration at all
setIfacesRn (recordSlurp (ifaces {iDeferred = iDeferred ifaces
`addOneToNameSet` tycon_name})
version (AvailTC needed_name [needed_name])) `thenRn_`
returnRn Deferred
+
else
- -- The needed name is a constructor of a data type decl,
+ -- The needed name is a constructor of a data type decl,
-- getting a constructor, so remove the TyCon from the deferred set
-- (if it's there) and return the full declaration
- setIfacesRn (recordSlurp (ifaces {iDeferred = iDeferred ifaces
+ setIfacesRn (recordSlurp (ifaces {iDeferred = iDeferred ifaces
`delFromNameSet` tycon_name})
version avail) `thenRn_`
- returnRn (HereItIs decl)
+ returnRn (HereItIs decl)
where
tycon_name = availName avail
+-}
- Just (version,avail,_,decl)
- -> setIfacesRn (recordSlurp ifaces version avail) `thenRn_`
+ Just (avail,_,decl)
+ -> setIfacesRn (recordSlurp ifaces avail) `thenRn_`
returnRn (HereItIs decl)
Nothing
where
doc_str = ptext SLIT("need decl for") <+> ppr needed_name
+{- OMIT FOR NOW
getDeferredDecls :: RnMG [(Module, RdrNameHsDecl)]
getDeferredDecls
= getIfacesRn `thenRn` \ ifaces ->
in
traceRn (sep [text "getDeferredDecls", nest 4 (fsep (map ppr deferred_names))]) `thenRn_`
returnRn (map get_abstract_decl deferred_names)
+-}
\end{code}
@getWiredInDecl@ maps a wired-in @Name@ to what it makes available.
\begin{code}
getInterfaceExports :: ModuleName -> WhereFrom -> RnMG (Module, Avails)
getInterfaceExports mod_name from
- = loadInterface doc_str mod_name from `thenRn` \ ifaces ->
- case lookupFM (iImpModInfo ifaces) mod_name of
- 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")]
+ = getHomeIfaceTableRn `thenRn` \ hit ->
+ case lookupModuleEnvByName hit mod_name of {
+ Just mi -> returnRn (mi_module mi, mi_exports mi) ;
+ Nothing ->
+
+ loadInterface doc_str mod_name from `thenRn` \ ifaces ->
+ case lookupModuleEnvByName (iPIT ifaces) mod_name of
+ Just mi -> returnRn (mi_module mi, mi_exports mi) ;
+ -- loadInterface always puts something in the map
+ -- even if it's a fake
+ Nothing -> pprPanic "getInterfaceExports" (ppr mod_name)
+ }
+ where
+ doc_str = sep [ppr mod_name, ptext SLIT("is directly imported")]
\end{code}
getIfacesRn `thenRn` \ ifaces ->
let
orphan_mods =
- [mod | (mod, (True, _, Nothing)) <- fmToList (iImpModInfo ifaces)]
+ [mod | (mod, (True, _, False)) <- fmToList (iImpModInfo ifaces)]
in
loadOrphanModules orphan_mods `thenRn_`
lookupFixityRn name
| isLocallyDefined name
= getFixityEnv `thenRn` \ local_fix_env ->
- returnRn (lookupFixity local_fix_env name)
+ returnRn (lookupLocalFixity local_fix_env name)
| otherwise -- Imported
-- For imported names, we have to get their fixities by doing a loadHomeInterface,
-- right away (after all, it's possible that nothing from B will be used).
-- When we come across a use of 'f', we need to know its fixity, and it's then,
-- and only then, that we load B.hi. That is what's happening here.
- = loadHomeInterface doc name `thenRn` \ ifaces ->
- returnRn (lookupFixity (iFixes ifaces) name)
+ = getHomeIfaceTableRn `thenRn` \ hit ->
+ loadHomeInterface doc name `thenRn` \ ifaces ->
+ case lookupTable hit (iPIT ifaces) name of
+ Just iface -> returnRn (lookupNameEnv (mi_fixities iface) name `orElse` defaultFixity)
+ Nothing -> returnRn defaultFixity
where
doc = ptext SLIT("Checking fixity for") <+> ppr name
\end{code}
So we'll get an early bale-out when compiling A if B's version changes.
\begin{code}
-mkImportExportInfo :: ModuleName -- Name of this module
- -> Avails -- Info about exports
- -> Maybe [RdrNameIE] -- The export header
- -> RnMG ([ExportItem], -- Export info for iface file; sorted
- [ImportVersion OccName]) -- Import info for iface file; sorted
- -- Both results are sorted into canonical order to
- -- reduce needless wobbling of interface files
-
-mkImportExportInfo this_mod export_avails exports
+mkImportInfo :: ModuleName -- Name of this module
+ -> [ImportDecl n] -- The import decls
+ -> RnMG [ImportVersion Name]
+
+mkImportInfo this_mod imports
= getIfacesRn `thenRn` \ ifaces ->
+ getHomeIfaceTableRn `thenRn` \ hit ->
let
- export_all_mods = case exports of
- Nothing -> []
- Just es -> [mod | IEModuleContents mod <- es,
- mod /= this_mod]
+ import_all_mods :: [ModuleName]
+ -- Modules where we imported all the names
+ -- (apart from hiding some, perhaps)
+ import_all_mods = nub [ m | ImportDecl m _ _ _ imp_list _ <- imports,
+ import_all imp_list ]
+
+ import_all (Just (False, _)) = False -- Imports are specified explicitly
+ import_all other = True -- Everything is imported
mod_map = iImpModInfo ifaces
imp_names = iVSlurp ifaces
+ pit = iPIT ifaces
-- mv_map groups together all the things imported from a particular module.
- mv_map :: FiniteMap ModuleName [(OccName,Version)]
- mv_map = foldr add_mv emptyFM imp_names
+ mv_map :: ModuleEnv [Name]
+ mv_map = foldr add_mv emptyModuleEnv imp_names
- add_mv (name, version) mv_map = addItem mv_map (moduleName (nameModule name))
- (nameOccName name, version)
+ add_mv name mv_map = addItem mv_map (nameModule name) name
-- 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
-- whether something is a boot file along with the usage info for it, but
-- I can't be bothered just now.
- mk_imp_info mod_name (has_orphans, is_boot, contents) so_far
+ mk_imp_info mod_name (has_orphans, is_boot, opened) 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, has_orphans, is_boot, exports)
- : so_far
- in
- case contents of
- Nothing -> -- We didn't even open the interface
- -- This happens when a module, Foo, that we explicitly imported has
+ | not opened -- We didn't even open the interface
+ = -- This happens when a module, Foo, that we explicitly imported has
-- 'import Baz' in its interface file, recording that Baz is below
-- 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.
+ -- file but we must still propagate the dependency info.
-- The module in question must be a local module (in the same package)
- go_for_it NothingAtAll
+ go_for_it NothingAtAll
+
- Just (mod, mod_vers, fix_vers, rule_vers, how_imported, _)
- | is_sys_import && is_lib_module && not has_orphans
- -> so_far
+ | is_lib_module && not has_orphans
+ = so_far
- | is_lib_module -- Record the module but not detailed
- || mod_name `elem` export_all_mods -- version information for the imports
- -> go_for_it (Everything mod_vers)
-
- | otherwise
- -> case lookupFM mv_map mod_name of
- Just whats_imported -> go_for_it (Specifically mod_vers fix_vers rule_vers
- (sortImport whats_imported))
- Nothing -> go_for_it NothingAtAll
- -- This happens if you have
- -- import Foo
- -- but don't actually *use* anything from Foo
- -- In which case record an empty dependency list
- where
- is_lib_module = not (isLocalModule mod)
- is_sys_import = case how_imported of
- ImportBySystem -> True
- other -> False
-
+ | is_lib_module -- Record the module version only
+ = go_for_it (Everything module_vers)
+ | otherwise
+ = go_for_it whats_imported
+
+ where
+ go_for_it exports = (mod_name, has_orphans, is_boot, exports) : so_far
+ mod_iface = lookupIface hit pit mod_name
+ mod = mi_module mod_iface
+ is_lib_module = not (isModuleInThisPackage mod)
+ version_info = mi_version mod_iface
+ version_env = vers_decls version_info
+ module_vers = vers_module version_info
+
+ whats_imported = Specifically module_vers
+ export_vers import_items
+ (vers_rules version_info)
+
+ import_items = [(n,v) | n <- lookupWithDefaultModuleEnv mv_map [] mod,
+ let v = lookupNameEnv version_env n `orElse`
+ pprPanic "mk_whats_imported" (ppr n)
+ ]
+ export_vers | moduleName mod `elem` import_all_mods
+ = Just (vers_exports version_info)
+ | otherwise
+ = Nothing
+
import_info = foldFM mk_imp_info [] mod_map
-
- -- Sort exports into groups by module
- export_fm :: FiniteMap ModuleName [RdrAvailInfo]
- export_fm = foldr insert emptyFM export_avails
-
- insert avail efm = addItem efm (moduleName (nameModule (availName avail)))
- (rdrAvailInfo avail)
-
- export_info = [(m, sortExport as) | (m,as) <- fmToList export_fm]
in
- returnRn (export_info, import_info)
+ traceRn (text "Modules in Ifaces: " <+> fsep (map ppr (keysFM mod_map))) `thenRn_`
+ returnRn import_info
-addItem :: FiniteMap ModuleName [a] -> ModuleName -> a -> FiniteMap ModuleName [a]
-addItem fm mod x = addToFM_C add_item fm mod [x]
+addItem :: ModuleEnv [a] -> Module -> a -> ModuleEnv [a]
+addItem fm mod x = extendModuleEnv_C add_item fm mod [x]
where
add_item xs _ = x:xs
-
-sortImport :: [(OccName,Version)] -> [(OccName,Version)]
- -- Make the usage lists appear in canonical order
-sortImport vs = sortLt lt vs
- where
- lt (n1,v1) (n2,v2) = n1 < n2
-
-sortExport :: [RdrAvailInfo] -> [RdrAvailInfo]
-sortExport as = sortLt lt as
- where
- lt a1 a2 = availName a1 < availName a2
\end{code}
\begin{code}
returnRn (iSlurp ifaces)
recordSlurp ifaces@(Ifaces { iSlurp = slurped_names, iVSlurp = imp_names })
- version avail
+ avail
= let
new_slurped_names = addAvailToNameSet slurped_names avail
- new_imp_names = (availName avail, version) : imp_names
+ new_imp_names = availName avail : imp_names
in
ifaces { iSlurp = new_slurped_names, iVSlurp = new_imp_names }
-> RdrNameHsDecl
-> RnM d (Maybe AvailInfo)
-getDeclBinders new_name (TyClD (TyData _ _ tycon _ condecls _ _ _ src_loc))
- = new_name tycon src_loc `thenRn` \ tycon_name ->
- getConFieldNames new_name condecls `thenRn` \ sub_names ->
- returnRn (Just (AvailTC tycon_name (tycon_name : nub sub_names)))
- -- The "nub" is because getConFieldNames can legitimately return duplicates,
- -- when a record declaration has the same field in multiple constructors
-
-getDeclBinders new_name (TyClD (TySynonym tycon _ _ src_loc))
- = new_name tycon src_loc `thenRn` \ tycon_name ->
- returnRn (Just (AvailTC tycon_name [tycon_name]))
-
-getDeclBinders new_name (TyClD (ClassDecl _ cname _ _ sigs _ _ _ _ _ _ src_loc))
- = new_name cname src_loc `thenRn` \ class_name ->
-
- -- Record the names for the class ops
- let
- -- just want class-op sigs
- op_sigs = filter isClassOpSig sigs
- in
- mapRn (getClassOpNames new_name) op_sigs `thenRn` \ sub_names ->
-
- returnRn (Just (AvailTC class_name (class_name : sub_names)))
+getDeclBinders new_name (TyClD tycl_decl)
+ = mapRn do_one (tyClDeclNames tycl_decl) `thenRn` \ (main_name:sub_names) ->
+ returnRn (Just (AvailTC main_name (main_name : sub_names)))
+ where
+ do_one (name,loc) = new_name name loc
getDeclBinders new_name (SigD (IfaceSig var ty prags src_loc))
= new_name var src_loc `thenRn` \ var_name ->
returnRn (Just (Avail var_name))
-getDeclBinders new_name (FixD _) = returnRn Nothing
-getDeclBinders new_name (DeprecD _) = returnRn Nothing
-
-- foreign declarations
getDeclBinders new_name (ForD (ForeignDecl nm kind _ dyn _ loc))
| binds_haskell_name kind dyn
= lookupOrigName nm `thenRn_`
returnRn Nothing
-getDeclBinders new_name (DefD _) = returnRn Nothing
-getDeclBinders new_name (InstD _) = returnRn Nothing
-getDeclBinders new_name (RuleD _) = returnRn Nothing
+getDeclBinders new_name (FixD _) = returnRn Nothing
+getDeclBinders new_name (DeprecD _) = 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 = isDynamicExtName 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 rest `thenRn` \ ns ->
- returnRn (cfs ++ ns)
- where
- fields = concat (map fst fielddecls)
-
-getConFieldNames new_name (ConDecl con _ _ _ condecl src_loc : rest)
- = new_name con src_loc `thenRn` \ n ->
- (case condecl of
- NewCon _ (Just f) ->
- new_name f src_loc `thenRn` \ new_f ->
- returnRn [n,new_f]
- _ -> returnRn [n]) `thenRn` \ nn ->
- getConFieldNames new_name rest `thenRn` \ ns ->
- returnRn (nn ++ ns)
-
-getConFieldNames new_name [] = returnRn []
-
-getClassOpNames new_name (ClassOpSig op _ _ src_loc) = new_name op src_loc
\end{code}
@getDeclSysBinders@ gets the implicit binders introduced by a decl.
bindings of their own elsewhere.
\begin{code}
-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 (ClassDecl _ cname _ _ sigs _ names src_loc))
+ = sequenceRn [new_name n src_loc | n <- names]
-getDeclSysBinders new_name (TyClD (TyData _ _ _ _ cons _ _ _ _))
+getDeclSysBinders new_name (TyClD (TyData _ _ _ _ cons _ _ _ _ _))
= sequenceRn [new_name wkr_name src_loc | ConDecl _ wkr_name _ _ _ src_loc <- cons]
getDeclSysBinders new_name other_decl
findAndReadIface :: SDoc -> ModuleName
-> IsBootInterface -- True <=> Look for a .hi-boot file
-- False <=> Look for .hi file
- -> RnM d (Either Message ParsedIface)
+ -> RnM d (Either Message (Module, ParsedIface))
-- Nothing <=> file not found, or unreadable, or illegible
-- Just x <=> successfully found and parsed
-- one for 'normal' ones, the other for .hi-boot files,
-- hence the need to signal which kind we're interested.
- 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
+ getFinderRn `thenRn` \ finder ->
+ ioToRnM (finder mod_name) `thenRn` \ maybe_found ->
+
+ case maybe_found of
+ Right (Just (mod,locn))
+ | hi_boot_file -> readIface mod (hi_file locn ++ "-hi-boot")
+ | otherwise -> readIface mod (hi_file locn)
-- Can't find it
- Nothing -> traceRn (ptext SLIT("...not found")) `thenRn_`
- returnRn (Left (noIfaceErr mod_name hi_boot_file search_path))
+ other -> traceRn (ptext SLIT("...not found")) `thenRn_`
+ returnRn (Left (noIfaceErr mod_name hi_boot_file))
where
trace_msg = sep [hsep [ptext SLIT("Reading"),
if hi_boot_file then ptext SLIT("[boot]") else empty,
ptext SLIT("interface for"),
- pprModuleName mod_name <> semi],
+ ppr mod_name <> semi],
nest 4 (ptext SLIT("reason:") <+> doc_str)]
\end{code}
@readIface@ tries just the one file.
\begin{code}
-readIface :: ModuleName -> String -> RnM d (Either Message ParsedIface)
+readIface :: Module -> String -> RnM d (Either Message (Module, ParsedIface))
-- Nothing <=> file not found, or unreadable, or illegible
-- Just x <=> successfully found and parsed
readIface wanted_mod file_path
- = ioToRnM (hGetStringBuffer False file_path) `thenRn` \ read_result ->
+ = traceRn (ptext SLIT("...reading from") <+> text file_path) `thenRn_`
+ ioToRnM (hGetStringBuffer False file_path) `thenRn` \ read_result ->
case read_result of
Right contents ->
case parseIface contents
glasgow_exts = 1#,
loc = mkSrcLoc (mkFastString file_path) 1 } of
POk _ (PIface iface) ->
- warnCheckRn (read_mod == wanted_mod)
+ warnCheckRn (wanted_mod == read_mod)
(hiModuleNameMismatchWarn wanted_mod read_mod) `thenRn_`
- returnRn (Right iface)
+ returnRn (Right (wanted_mod, iface))
where
- read_mod = moduleName (pi_mod iface)
+ read_mod = pi_mod iface
PFailed err -> bale_out err
parse_result -> bale_out empty
%*********************************************************
\begin{code}
-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
- pp_suffix suffix | boot_file = ptext SLIT(".hi-boot")
- | otherwise = text suffix
+noIfaceErr mod_name boot_file
+ = ptext SLIT("Could not find interface file for") <+> quotes (ppr mod_name)
+ -- We used to print the search path, but we can't do that
+ -- now, becuase it's hidden inside the finder.
+ -- Maybe the finder should expose more functions.
badIfaceFile file err
= vcat [ptext SLIT("Bad interface file:") <+> text file,
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("desired at") <+> ppr loc]
-
importDeclWarn name
= sep [ptext SLIT(
"Compiler tried to import decl from interface file with same name as module."),
warnRedundantSourceImport mod_name
= ptext SLIT("Unnecessary {- SOURCE -} in the import of module")
- <+> quotes (pprModuleName mod_name)
+ <+> quotes (ppr mod_name)
-hiModuleNameMismatchWarn :: ModuleName -> ModuleName -> Message
+hiModuleNameMismatchWarn :: Module -> Module -> Message
hiModuleNameMismatchWarn requested_mod read_mod =
hsep [ ptext SLIT("Something is amiss; requested module name")
- , pprModuleName requested_mod
+ , ppr (moduleName requested_mod)
, ptext SLIT("differs from name found in the interface file")
- , pprModuleName read_mod
+ , ppr read_mod
]
\end{code}
projects / ghc-hetmet.git / blobdiff