%
-% (c) The GRASP/AQUA Project, Glasgow University, 1992-1996
+% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
%
\section[RnIfaces]{Cacheing and Renaming of Interfaces}
\begin{code}
-#include "HsVersions.h"
+module RnIfaces
+ (
+ findAndReadIface,
-module RnIfaces (
- cachedIface,
- cachedDecl, CachingResult(..),
- rnIfaces,
- IfaceCache, initIfaceCache
- ) where
-
-IMP_Ubiq()
-
-import PreludeGlaST ( thenPrimIO, newVar, readVar, writeVar, SYN_IE(MutableVar) )
-#if __GLASGOW_HASKELL__ >= 200
-# define ST_THEN `stThen`
-# define TRY_IO tryIO
-IMPORT_1_3(GHCio(stThen,tryIO))
-#else
-# define ST_THEN `thenPrimIO`
-# define TRY_IO try
-#endif
+ getInterfaceExports,
+ getImportedInstDecls, getImportedRules,
+ lookupFixityRn, loadHomeInterface,
+ importDecl, ImportDeclResult(..), recordLocalSlurps,
+ mkImportInfo, getSlurped,
-import HsSyn
-import HsPragmas ( noGenPragmas )
-import RdrHsSyn
-import RnHsSyn
+ getDeclBinders, getDeclSysBinders,
+ removeContext -- removeContext probably belongs somewhere else
+ )
+where
-import RnMonad
-import RnSource ( rnTyDecl, rnClassDecl, rnInstDecl, rnPolyType )
-import RnUtils ( SYN_IE(RnEnv), emptyRnEnv, lookupRnEnv, lookupTcRnEnv, extendGlobalRnEnv )
-import ParseIface ( parseIface )
-import ParseUtils ( ParsedIface(..), RdrIfaceDecl(..), RdrIfaceInst(..),
- VersionsMap(..), UsagesMap(..)
- )
+#include "HsVersions.h"
-import Bag ( emptyBag, unitBag, consBag, snocBag,
- unionBags, unionManyBags, isEmptyBag, bagToList )
-import ErrUtils ( SYN_IE(Error), SYN_IE(Warning) )
-import FiniteMap ( emptyFM, lookupFM, addToFM, addToFM_C, plusFM, eltsFM,
- fmToList, delListFromFM, sizeFM, foldFM, unitFM,
- plusFM_C, addListToFM, keysFM{-ToDo:rm-}, FiniteMap
+import CmdLineOpts ( opt_NoPruneDecls, opt_NoPruneTyDecls, opt_IgnoreIfacePragmas )
+import HscTypes
+import HsSyn ( HsDecl(..), TyClDecl(..), InstDecl(..), IfaceSig(..),
+ HsType(..), ConDecl(..),
+ ForeignDecl(..), ForKind(..), isDynamicExtName,
+ FixitySig(..), RuleDecl(..),
+ tyClDeclNames
)
-import Maybes ( maybeToBool, MaybeErr(..) )
-import Name ( origName, moduleOf, nameOf, qualToOrigName, OrigName(..),
- isLexCon, RdrName(..), Name{-instance NamedThing-} )
-import PprStyle -- ToDo:rm
-import Outputable -- ToDo:rm
-import PrelInfo ( builtinNameInfo, SYN_IE(BuiltinNames) )
-import Pretty
-import UniqFM ( emptyUFM )
-import UniqSupply ( splitUniqSupply )
-import Util ( sortLt, removeDups, cmpPString, startsWith,
- panic, pprPanic, assertPanic, pprTrace{-ToDo:rm-} )
-\end{code}
-
-\begin{code}
-type ModuleToIfaceContents = FiniteMap Module ParsedIface
-type ModuleToIfaceFilePath = FiniteMap Module FilePath
-
-#if __GLASGOW_HASKELL__ >= 200
-# define REAL_WORLD RealWorld
-#else
-# define REAL_WORLD _RealWorld
-#endif
-
-data IfaceCache
- = IfaceCache
- Module -- the name of the module being compiled
- BuiltinNames -- so we can avoid going after things
- -- the compiler already knows about
- (MutableVar REAL_WORLD
- (ModuleToIfaceContents, -- interfaces for individual interface files
- ModuleToIfaceContents, -- merged interfaces based on module name
- -- used for extracting info about original names
- ModuleToIfaceFilePath))
-
-initIfaceCache mod hi_files
- = newVar (emptyFM,emptyFM,hi_files) ST_THEN \ iface_var ->
- return (IfaceCache mod b_names iface_var)
- where
- b_names = case builtinNameInfo of (b_names,_,_) -> b_names
+import HsImpExp ( ImportDecl(..) )
+import BasicTypes ( Version, defaultFixity )
+import RdrHsSyn ( RdrNameHsDecl, RdrNameInstDecl, RdrNameRuleDecl,
+ extractHsTyRdrNames
+ )
+import RnEnv
+import RnMonad
+import ParseIface ( parseIface, IfaceStuff(..) )
+
+import Name ( Name {-instance NamedThing-}, nameOccName,
+ nameModule, isLocallyDefined,
+ NamedThing(..),
+ mkNameEnv, elemNameEnv, extendNameEnv
+ )
+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 ( wiredInThingEnv )
+import Maybes ( maybeToBool, orElse )
+import StringBuffer ( hGetStringBuffer )
+import FastString ( mkFastString )
+import ErrUtils ( Message )
+import Lex
+import FiniteMap
+import Outputable
+import Bag
+
+import List ( nub )
\end{code}
-*********************************************************
-* *
-\subsection{Reading interface files}
-* *
-*********************************************************
-
-Return cached info about a Module's interface; otherwise,
-read the interface (using our @ModuleToIfaceFilePath@ map
-to decide where to look).
-
-Note: we have two notions of interface
- * the interface for a particular file name
- * the (combined) interface for a particular module name
-
-The idea is that two source files may declare a module
-with the same name with the declarations being merged.
-
-This allows us to have file PreludeList.hs producing
-PreludeList.hi but defining part of module Prelude.
-When PreludeList is imported its contents will be
-added to Prelude. In this way all the original names
-for a particular module will be available the imported
-decls are renamed.
-
-ToDo: Check duplicate definitons are the same.
-ToDo: Check/Merge duplicate pragmas.
+%*********************************************************
+%* *
+\subsection{Loading a new interface file}
+%* *
+%*********************************************************
\begin{code}
-cachedIface :: IfaceCache
- -> Bool -- True => want merged interface for original name
- -- False => want file interface only
- -> FAST_STRING -- item that prompted search (debugging only!)
- -> Module
- -> IO (MaybeErr ParsedIface Error)
-
-cachedIface (IfaceCache _ _ iface_var) want_orig_iface item modname
- = readVar iface_var ST_THEN \ (iface_fm, orig_fm, file_fm) ->
-
- case (lookupFM iface_fm modname) of
- Just iface -> return (want_iface iface orig_fm)
- Nothing ->
- case (lookupFM file_fm modname) of
- Nothing -> return (Failed (noIfaceErr modname))
- Just file ->
- readIface file modname item >>= \ read_iface ->
- case read_iface of
- Failed err -> -- pprTrace "module-file map:\n" (ppAboves [ppCat [ppPStr m, ppStr f] | (m,f) <- fmToList file_fm]) $
- return (Failed err)
- Succeeded iface ->
- let
- iface_fm' = addToFM iface_fm modname iface
- orig_fm' = addToFM_C mergeIfaces orig_fm (iface_mod iface) iface
- in
- writeVar iface_var (iface_fm', orig_fm', file_fm) ST_THEN \ _ ->
- return (want_iface iface orig_fm')
- where
- want_iface iface orig_fm
- | want_orig_iface
- = case lookupFM orig_fm modname of
- Nothing -> Failed (noOrigIfaceErr modname)
- Just orig_iface -> Succeeded orig_iface
- | otherwise
- = Succeeded iface
-
- iface_mod (ParsedIface mod _ _ _ _ _ _ _ _ _ _ _ _) = mod
-
-----------
-mergeIfaces (ParsedIface mod1 (_, files1) _ _ _ _ _ _ fixes1 tdefs1 vdefs1 idefs1 prags1)
- (ParsedIface mod2 (_, files2) _ _ _ _ _ _ fixes2 tdefs2 vdefs2 idefs2 prags2)
- = pprTrace "mergeIfaces:" (ppCat [ppStr "import", ppCat (map ppPStr (bagToList files2)),
- ppStr "merged with", ppPStr mod1]) $
- ASSERT(mod1 == mod2)
- ParsedIface mod1
- (True, unionBags files2 files1)
- (panic "mergeIface: module version numbers")
- (panic "mergeIface: source version numbers") -- Version numbers etc must be extracted from
- (panic "mergeIface: usage version numbers") -- the merged file interfaces named above
- (panic "mergeIface: decl version numbers")
- (panic "mergeIface: exports")
- (panic "mergeIface: instance modules")
- (plusFM_C (dup_merge "fixity" (ppr PprDebug . fixDeclName)) fixes1 fixes2)
- (plusFM_C (dup_merge "tycon/class" (ppr PprDebug . idecl_nm)) tdefs1 tdefs2)
- (plusFM_C (dup_merge "value" (ppr PprDebug . idecl_nm)) vdefs1 vdefs2)
- (unionBags idefs1 idefs2)
- (plusFM_C (dup_merge "pragma" ppStr) prags1 prags2)
+loadHomeInterface :: SDoc -> Name -> RnM d Ifaces
+loadHomeInterface doc_str name
+ = loadInterface doc_str (moduleName (nameModule name)) ImportBySystem
+
+loadOrphanModules :: [ModuleName] -> RnM d ()
+loadOrphanModules mods
+ | null mods = returnRn ()
+ | otherwise = traceRn (text "Loading orphan modules:" <+>
+ fsep (map ppr mods)) `thenRn_`
+ mapRn_ load mods `thenRn_`
+ returnRn ()
where
- dup_merge str ppr_dup dup1 dup2
- = pprTrace "mergeIfaces:"
- (ppCat [ppPStr mod1, ppPStr mod2, ppStr ": dup", ppStr str, ppStr "decl",
- ppr_dup dup1, ppr_dup dup2]) $
- dup2
-
- idecl_nm (TypeSig n _ _) = n
- idecl_nm (NewTypeSig n _ _ _) = n
- idecl_nm (DataSig n _ _ _ _) = n
- idecl_nm (ClassSig n _ _ _) = n
- idecl_nm (ValSig n _ _) = n
-
-----------
-data CachingResult
- = CachingFail Error -- tried to find a decl, something went wrong
- | CachingHit RdrIfaceDecl -- got it
- | CachingAvoided (Maybe (Either RnName RnName))
- -- didn't look in the interface
- -- file(s); Nothing => the thing
- -- *should* be in the source module;
- -- Just (Left ...) => builtin val name;
- -- Just (Right ..) => builtin tc name
-
-cachedDecl :: IfaceCache
- -> Bool -- True <=> tycon or class name
- -> OrigName
- -> IO CachingResult
-
-cachedDecl iface_cache@(IfaceCache this_mod (b_val_names,b_tc_names) _)
- class_or_tycon name@(OrigName mod str)
-
- = -- pprTrace "cachedDecl:" (ppr PprDebug name) $
- if mod == this_mod then -- some i/face has made a reference
- return (CachingAvoided Nothing) -- to something from this module
- else
+ load mod = loadInterface (mk_doc mod) mod ImportBySystem
+ mk_doc mod = ppr mod <+> ptext SLIT("is a orphan-instance module")
+
+
+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 --> (..., True)
+ -- (If the load fails, we plug in a vanilla placeholder)
+tryLoadInterface doc_str mod_name from
+ = 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, 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
+ in
+ -- CHECK WHETHER WE HAVE IT ALREADY
+ case mod_info of {
+ Just (_, _, True)
+ -> -- We're read it already so don't re-read it
+ returnRn (ifaces, Nothing) ;
+
+ _ ->
+
+ -- 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 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
+ let
+ 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 (mod, iface) ->
+
+ -- LOAD IT INTO Ifaces
+
+ -- NB: *first* we do loadDecl, so that the provenance of all the locally-defined
+ --- names is done correctly (notably, whether this is an .hi file or .hi-boot file).
+ -- 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)
+
+
+ -- 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 } &&
+ isModuleInThisPackage mod,
+ ppr mod )
+
+ 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 ->
+ loadExports (pi_exports iface) `thenRn` \ (export_vers, avails) ->
let
- b_env = if class_or_tycon then b_tc_names else b_val_names
+ 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
+ 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,
+ iInsts = new_insts,
+ iRules = new_rules,
+ iImpModInfo = mod_map2 }
in
- case (lookupFM b_env name) of
- Just rn -> -- in builtins!
- return (CachingAvoided (Just ((if class_or_tycon then Right else Left) rn)))
-
- Nothing ->
- cachedIface iface_cache True str mod >>= \ maybe_iface ->
- case maybe_iface of
- Failed err -> --pprTrace "cachedDecl:fail:" (ppr PprDebug orig) $
- return (CachingFail err)
- Succeeded (ParsedIface _ _ _ _ _ _ exps _ _ tdefs vdefs _ _) ->
- case (lookupFM (if class_or_tycon then tdefs else vdefs) str) of
- Just decl -> return (CachingHit decl)
- Nothing -> return (CachingFail (noDeclInIfaceErr mod str))
-
-----------
-cachedDeclByType :: IfaceCache
- -> RnName{-NB: diff type than cachedDecl -}
- -> IO CachingResult
-
-cachedDeclByType iface_cache rn
- -- the idea is: check that, e.g., if we're given an
- -- RnClass, then we really get back a ClassDecl from
- -- the cache (not an RnData, or something silly)
- = cachedDecl iface_cache (isRnTyConOrClass rn) (origName "cachedDeclByType" rn) >>= \ maybe_decl ->
+ setIfacesRn new_ifaces `thenRn_`
+ returnRn (new_ifaces, Nothing)
+ }}}
+
+-----------------------------------------------------
+-- Adding module dependencies from the
+-- import decls in the interface file
+-----------------------------------------------------
+
+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
+ -- 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
+ | isModuleInThisPackage mod
+ = [ (imp_mod, (has_orphans, is_boot, False))
+ | (imp_mod, has_orphans, is_boot, _) <- new_deps
+ ]
+ | 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, 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
+
+
+-----------------------------------------------------
+-- 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 []
+ -- If the module exports anything defined in this module, just ignore it.
+ -- Reason: otherwise it looks as if there are two local definition sites
+ -- for the thing, and an error gets reported. Easiest thing is just to
+ -- filter them out up front. This situation only arises if a module
+ -- imports itself, or another module that imported it. (Necessarily,
+ -- this invoves a loop.) Consequence: if you say
+ -- module A where
+ -- import B( AType )
+ -- type AType = ...
+ --
+ -- module B( AType ) where
+ -- import {-# SOURCE #-} A( AType )
+ --
+ -- then you'll get a 'B does not export AType' message. A bit bogus
+ -- but it's a bogus thing to do!
+
+ | otherwise
+ = mapRn (load_entity mod) entities
+ where
+ new_name mod occ = newGlobalName mod occ
+
+ load_entity mod (Avail occ)
+ = new_name mod occ `thenRn` \ name ->
+ returnRn (Avail name)
+ load_entity mod (AvailTC occ occs)
+ = new_name mod occ `thenRn` \ name ->
+ mapRn (new_name mod) occs `thenRn` \ names ->
+ returnRn (AvailTC name names)
+
+
+-----------------------------------------------------
+-- 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
+ -> (NameEnv Version, DeclsMap)
+ -> (Version, RdrNameHsDecl)
+ -> 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 (version_map, decls_map); -- No bindings
+ Just avail ->
+
+ getDeclSysBinders new_name decl `thenRn` \ sys_bndrs ->
let
- return_maybe_decl = return maybe_decl
- return_failed msg = return (CachingFail msg)
+ 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, (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
- case maybe_decl of
- CachingAvoided _ -> return_maybe_decl
- CachingFail io_msg -> return_failed (ifaceIoErr io_msg rn)
- CachingHit if_decl ->
- case rn of
- WiredInId _ -> return_failed (ifaceLookupWiredErr "value" rn)
- WiredInTyCon _ -> return_failed (ifaceLookupWiredErr "type constructor" rn)
- RnUnbound _ -> pprPanic "cachedDeclByType:" (ppr PprDebug rn)
-
- RnSyn _ -> return_maybe_decl
- RnData _ _ _ -> return_maybe_decl
- RnImplicitTyCon _ -> if is_tycon_decl if_decl
- then return_maybe_decl
- else return_failed (badIfaceLookupErr "type constructor" rn if_decl)
-
- RnClass _ _ -> return_maybe_decl
- RnImplicitClass _ -> if is_class_decl if_decl
- then return_maybe_decl
- else return_failed (badIfaceLookupErr "class" rn if_decl)
-
- RnName _ -> return_maybe_decl
- RnConstr _ _ -> return_maybe_decl
- RnField _ _ -> return_maybe_decl
- RnClassOp _ _ -> return_maybe_decl
- RnImplicit _ -> if is_val_decl if_decl
- then return_maybe_decl
- else return_failed (badIfaceLookupErr "value" rn if_decl)
+ returnRn (new_version_map, new_decls_map)
+ }
where
- is_tycon_decl (TypeSig _ _ _) = True
- is_tycon_decl (NewTypeSig _ _ _ _) = True
- is_tycon_decl (DataSig _ _ _ _ _) = True
- is_tycon_decl _ = False
-
- is_class_decl (ClassSig _ _ _ _) = True
- is_class_decl _ = False
-
- is_val_decl (ValSig _ _ _) = True
- is_val_decl (DataSig _ _ _ _ _) = True -- may be a constr or field
- is_val_decl (NewTypeSig _ _ _ _) = True -- may be a constr
- is_val_decl (ClassSig _ _ _ _) = True -- may be a method
- is_val_decl _ = False
+ -- newTopBinder puts into the cache the binder with the
+ -- module information set correctly. When the decl is later renamed,
+ -- the binding site will thereby get the correct module.
+ -- 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 rdr_name loc
+
+ {-
+ If a signature decl is being loaded, and optIgnoreIfacePragmas is on,
+ we toss away unfolding information.
+
+ Also, if the signature is loaded from a module we're importing from source,
+ we do the same. This is to avoid situations when compiling a pair of mutually
+ recursive modules, peering at unfolding info in the interface file of the other,
+ e.g., you compile A, it looks at B's interface file and may as a result change
+ its interface file. Hence, B is recompiled, maybe changing its interface file,
+ which will the unfolding info used in A to become invalid. Simple way out is to
+ just ignore unfolding info.
+
+ [Jan 99: I junked the second test above. If we're importing from an hi-boot
+ file there isn't going to *be* any pragma info. Maybe the above comment
+ 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
+
+-----------------------------------------------------
+-- Loading fixity decls
+-----------------------------------------------------
+
+loadFixDecls mod_name decls
+ = mapRn (loadFixDecl mod_name) decls `thenRn` \ 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, fixity)
+
+
+-----------------------------------------------------
+-- Loading instance decls
+-----------------------------------------------------
+
+loadInstDecl :: Module
+ -> IfaceInsts
+ -> RdrNameInstDecl
+ -> RnM d IfaceInsts
+loadInstDecl mod insts decl@(InstDecl inst_ty binds uprags dfun_name src_loc)
+ =
+ -- Find out what type constructors and classes are "gates" for the
+ -- instance declaration. If all these "gates" are slurped in then
+ -- we should slurp the instance decl too.
+ --
+ -- We *don't* want to count names in the context part as gates, though.
+ -- For example:
+ -- instance Foo a => Baz (T a) where ...
+ --
+ -- Here the gates are Baz and T, but *not* Foo.
+ let
+ munged_inst_ty = removeContext inst_ty
+ free_names = extractHsTyRdrNames munged_inst_ty
+ in
+ setModuleRn mod $
+ mapRn lookupOrigName free_names `thenRn` \ gate_names ->
+ returnRn ((mkNameSet gate_names, (mod, InstD decl)) `consBag` insts)
+
+
+-- In interface files, the instance decls now look like
+-- forall a. Foo a -> Baz (T a)
+-- so we have to strip off function argument types as well
+-- as the bit before the '=>' (which is always empty in interface files)
+removeContext (HsForAllTy tvs cxt ty) = HsForAllTy tvs [] (removeFuns ty)
+removeContext ty = removeFuns ty
+
+removeFuns (HsFunTy _ ty) = removeFuns ty
+removeFuns ty = ty
+
+
+-----------------------------------------------------
+-- Loading Rules
+-----------------------------------------------------
+
+loadRules :: Module -> IfaceRules
+ -> (Version, [RdrNameRuleDecl])
+ -> RnM d (Version, IfaceRules)
+loadRules mod rule_bag (version, rules)
+ | null rules || opt_IgnoreIfacePragmas
+ = returnRn (version, rule_bag)
+ | otherwise
+ = setModuleRn mod $
+ mapRn (loadRule mod) rules `thenRn` \ 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
+-- needed. We can refine this later.
+loadRule mod decl@(IfaceRule _ _ var _ _ src_loc)
+ = lookupOrigName var `thenRn` \ var_name ->
+ returnRn (unitNameSet var_name, (mod, RuleD decl))
+
+
+-----------------------------------------------------
+-- Loading Deprecations
+-----------------------------------------------------
+
+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}
+
+%*********************************************************
+%* *
+\subsection{Getting in a declaration}
+%* *
+%*********************************************************
+
\begin{code}
-readIface :: FilePath -> Module -> FAST_STRING -> IO (MaybeErr ParsedIface Error)
+importDecl :: Name -> RnMG ImportDeclResult
+
+data ImportDeclResult
+ = AlreadySlurped
+ | WiredIn
+ | Deferred
+ | HereItIs (Module, RdrNameHsDecl)
+
+importDecl name
+ = -- Check if it was loaded before beginning this module
+ checkAlreadyAvailable name `thenRn` \ done ->
+ if done then
+ returnRn AlreadySlurped
+ else
-readIface file modname item
- = --hPutStr stderr (" reading "++file++" ("++ _UNPK_ item ++")") >>
- TRY_IO (readFile file) >>= \ read_result ->
- case read_result of
- Left err -> return (Failed (cannaeReadErr file err))
- Right contents -> --hPutStr stderr ".." >>
- let parsed = parseIface contents in
- --hPutStr stderr "..\n" >>
- return (
- case parsed of
- Failed _ -> parsed
- Succeeded p -> Succeeded (init_merge modname p)
- )
- where
- init_merge this (ParsedIface mod _ v sv us vs exps insts fixes tdefs vdefs idefs prags)
- = ParsedIface mod (False, unitBag this) v sv us vs exps insts fixes tdefs vdefs idefs prags
-\end{code}
+ -- Check if we slurped it in while compiling this module
+ getIfacesRn `thenRn` \ ifaces ->
+ if name `elemNameSet` iSlurp ifaces then
+ returnRn AlreadySlurped
+ else
+
+ -- 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
+ -- 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
-\begin{code}
-rnIfaces :: IfaceCache -- iface cache (mutvar)
- -> [Module] -- directly imported modules
- -> UniqSupply
- -> RnEnv -- defined (in the source) name env
- -> RnEnv -- mentioned (in the source) name env
- -> RenamedHsModule -- module to extend with iface decls
- -> [RnName] -- imported names required (really the
- -- same info as in mentioned name env)
- -- Also, all the things we may look up
- -- later by key (Unique).
- -> IO (RenamedHsModule, -- extended module
- RnEnv, -- final env (for renaming derivings)
- ImplicitEnv, -- implicit names used (for usage info)
- (UsagesMap,VersionsMap,[Module]), -- usage info
- (Bag Error, Bag Warning))
-
-rnIfaces iface_cache imp_mods us
- def_env@((dqual, dunqual, dtc_qual, dtc_unqual), dstack)
- occ_env@((qual, unqual, tc_qual, tc_unqual), stack)
- rn_module@(HsModule modname iface_version exports imports fixities
- typedecls typesigs classdecls instdecls instsigs
- defdecls binds sigs src_loc)
- todo
- = {-
- pprTrace "rnIfaces:going after:" (ppCat (map (ppr PprDebug) todo)) $
- pprTrace "rnIfaces:qual:" (ppCat [ppBesides[ppPStr m,ppChar '.',ppPStr n] | (n,m) <- keysFM qual]) $
- pprTrace "rnIfaces:unqual:" (ppCat (map ppPStr (keysFM unqual))) $
- pprTrace "rnIfaces:tc_qual:" (ppCat [ppBesides[ppPStr m,ppChar '.',ppPStr n] | (n,m) <- keysFM tc_qual]) $
- pprTrace "rnIfaces:tc_unqual:" (ppCat (map ppPStr (keysFM tc_unqual))) $
-
- pprTrace "rnIfaces:dqual:" (ppCat [ppBesides[ppPStr m,ppChar '.',ppPStr n] | (n,m) <- keysFM dqual]) $
- pprTrace "rnIfaces:dunqual:" (ppCat (map ppPStr (keysFM dunqual))) $
- pprTrace "rnIfaces:dtc_qual:" (ppCat [ppBesides[ppPStr m,ppChar '.',ppPStr n] | (n,m) <- keysFM dtc_qual]) $
- pprTrace "rnIfaces:dtc_unqual:"(ppCat (map ppPStr (keysFM dtc_unqual))) $
- -}
+ else getNonWiredInDecl name
+ where
+ doc = ptext SLIT("need home module for wired in thing") <+> ppr name
+
+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
+
+{- 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
+
+ && (opt_IgnoreIfacePragmas || ncons > 1)
+ -- We only defer if imported interface pragmas are ingored
+ -- or if it's not a product type.
+ -- Sole reason: The wrapper for a strict function may need to look
+ -- inside its arg, and hence need to see its arg type's constructors.
+
+ && not (getUnique tycon_name `elem` cCallishTyKeys)
+ -- 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
+ -- 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,
+ -- 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
+ `delFromNameSet` tycon_name})
+ version avail) `thenRn_`
+ returnRn (HereItIs decl)
+ where
+ tycon_name = availName avail
+-}
- -- do transitive closure to bring in all needed names/defns and insts:
-
- decls_and_insts todo def_env occ_env empty_return us
- >>= \ (((if_typedecls, if_classdecls, if_instdecls, if_sigs),
- if_implicits,
- if_errs_warns),
- if_final_env) ->
-
- -- finalize what we want to say we learned about the
- -- things we used
- finalIfaceInfo iface_cache modname if_final_env if_instdecls {-all_imports_used imp_mods-} >>=
- \ usage_stuff@(usage_info, version_info, instance_mods) ->
-
- return (HsModule modname iface_version exports imports fixities
- (typedecls ++ if_typedecls)
- typesigs
- (classdecls ++ if_classdecls)
- (instdecls ++ if_instdecls)
- instsigs defdecls binds
- (sigs ++ if_sigs)
- src_loc,
- if_final_env,
- if_implicits,
- usage_stuff,
- if_errs_warns)
+ Just (avail,_,decl)
+ -> setIfacesRn (recordSlurp ifaces avail) `thenRn_`
+ returnRn (HereItIs decl)
+
+ Nothing
+ -> addErrRn (getDeclErr needed_name) `thenRn_`
+ returnRn AlreadySlurped
where
- decls_and_insts todo def_env occ_env to_return us
- = let
- (us1,us2) = splitUniqSupply us
- in
- do_decls todo -- initial batch of names to process
- (def_env, occ_env, us1) -- init stuff down
- to_return -- acc results
- >>= \ (decls_return,
- decls_def_env,
- decls_occ_env) ->
-
- cacheInstModules iface_cache imp_mods >>= \ errs ->
-
- do_insts decls_def_env decls_occ_env emptyRnEnv emptyFM
- (add_errs errs decls_return) us2
-
- --------
- do_insts def_env occ_env prev_env done_insts to_return us
- | size_tc_env occ_env == size_tc_env prev_env
- = return (to_return, occ_env)
-
- | otherwise
- = rnIfaceInstStuff iface_cache modname us1 occ_env done_insts to_return
- >>= \ (insts_return,
- new_insts,
- insts_occ_env,
- new_unknowns) ->
-
- do_decls new_unknowns -- new batch of names to process
- (def_env, insts_occ_env, us2) -- init stuff down
- insts_return -- acc results
- >>= \ (decls_return,
- decls_def_env,
- decls_occ_env) ->
-
- do_insts decls_def_env decls_occ_env occ_env new_insts decls_return us3
- where
- (us1,us') = splitUniqSupply us
- (us2,us3) = splitUniqSupply us'
-
- size_tc_env ((_, _, qual, unqual), _)
- = sizeFM qual + sizeFM unqual
-
-
- do_decls :: [RnName] -- Names we're looking for; we keep adding/deleting
- -- from this list; we're done when empty (nothing
- -- more needs to be looked for)
- -> Go_Down -- see defn below
- -> To_Return -- accumulated result
- -> IO (To_Return,
- RnEnv, -- extended decl env
- RnEnv) -- extended occ env
-
- do_decls to_find@[] down to_return
- = return (to_return, defenv down, occenv down)
-
- do_decls to_find@(n:ns) down to_return
- = case (lookup_defd down n) of
- Just _ -> -- previous processing must've found the stuff for this name;
- -- continue with the rest:
- -- pprTrace "do_decls:done:" (ppr PprDebug n) $
- do_decls ns down to_return
-
- Nothing
- | moduleOf (origName "do_decls" n) == modname ->
- -- avoid looking in interface for the module being compiled
- --pprTrace "do_decls:this module error:" (ppr PprDebug n) $
- do_decls ns down (add_warn (thisModImplicitWarn modname n) to_return)
-
- | otherwise ->
- -- OK, see what the cache has for us...
-
- cachedDeclByType iface_cache n >>= \ maybe_ans ->
- case maybe_ans of
- CachingAvoided _ ->
- pprTrace "do_decls:caching avoided:" (ppr PprDebug n) $
- do_decls ns down to_return
-
- CachingFail err -> -- add the error, but keep going:
- --pprTrace "do_decls:cache error:" (ppr PprDebug n) $
- do_decls ns down (add_err err to_return)
-
- CachingHit iface_decl -> -- something needing renaming!
- let
- (us1, us2) = splitUniqSupply (uniqsupply down)
- in
- case (initRn False{-iface-} modname (occenv down) us1 (
- setExtraRn emptyUFM{-no fixities-} $
- rnIfaceDecl iface_decl)) of {
- ((if_decl, if_defd, if_implicits), if_errs, if_warns) ->
- let
- new_unknowns = eltsFM (fst if_implicits) ++ eltsFM (snd if_implicits)
- in
- {-
- pprTrace "do_decls:renamed:" (ppAboves [ppr PprDebug n
- , ppCat [ppStr "new unknowns:", interpp'SP PprDebug new_unknowns]
- , ppCat [ppStr "defd vals:", interpp'SP PprDebug [n | (_,n) <- fst if_defd] ]
- , ppCat [ppStr "defd tcs:", interpp'SP PprDebug [n | (_,n) <- snd if_defd] ]
- ]) $
- -}
- do_decls (new_unknowns ++ ns)
- (add_occs if_defd if_implicits $
- new_uniqsupply us2 down)
- (add_decl if_decl $
- add_implicits if_implicits $
- add_errs if_errs $
- add_warns if_warns to_return)
- }
-
------------
-type Go_Down = (RnEnv, -- stuff we already have defns for;
- -- to check quickly if we've already
- -- found something for the name under consideration,
- -- due to previous processing.
- -- It starts off just w/ the defns for
- -- the things in this module.
- RnEnv, -- occurrence env; this gets added to as
- -- we process new iface decls. It includes
- -- entries for *all* occurrences, including those
- -- for which we have definitions.
- UniqSupply -- the obvious
- )
-
-lookup_defd (def_env, _, _) n
- = (if isRnTyConOrClass n then lookupTcRnEnv else lookupRnEnv) def_env
- (case (origName "lookup_defd" n) of { OrigName m s -> Qual m s })
- -- this is hack because we are reusing the RnEnv technology
-
-defenv (def_env, _, _) = def_env
-occenv (_, occ_env, _) = occ_env
-uniqsupply (_, _, us) = us
-
-new_uniqsupply us (def_env, occ_env, _) = (def_env, occ_env, us)
-
-add_occs (val_defds, tc_defds) (val_imps, tc_imps) (def_env, occ_env, us)
- = case (extendGlobalRnEnv def_env val_defds tc_defds) of { (new_def_env, def_dups) ->
- (if isEmptyBag def_dups then \x->x else pprTrace "add_occs:" (ppCat [ppr PprDebug n | (n,_,_) <- bagToList def_dups])) $
--- ASSERT(isEmptyBag def_dups)
- let
- de_orig imps = [ (Qual m n, v) | (OrigName m n, v) <- fmToList imps ]
- -- again, this hackery because we are reusing the RnEnv technology
+ doc_str = ptext SLIT("need decl for") <+> ppr needed_name
- val_occs = val_defds ++ de_orig val_imps
- tc_occs = tc_defds ++ de_orig tc_imps
+{- OMIT FOR NOW
+getDeferredDecls :: RnMG [(Module, RdrNameHsDecl)]
+getDeferredDecls
+ = getIfacesRn `thenRn` \ ifaces ->
+ let
+ decls_map = iDecls ifaces
+ deferred_names = nameSetToList (iDeferred ifaces)
+ get_abstract_decl n = case lookupNameEnv decls_map n of
+ Just (_, _, _, decl) -> decl
in
- case (extendGlobalRnEnv occ_env val_occs tc_occs) of { (new_occ_env, occ_dups) ->
+ traceRn (sep [text "getDeferredDecls", nest 4 (fsep (map ppr deferred_names))]) `thenRn_`
+ returnRn (map get_abstract_decl deferred_names)
+-}
+\end{code}
--- ASSERT(isEmptyBag occ_dups)
--- False because we may get a dup on the name we just shoved in
+@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,
+\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.
- (new_def_env, new_occ_env, us) }}
+\item similarly for synonum type constructor
-----------------
-type To_Return = (([RenamedTyDecl], [RenamedClassDecl], [RenamedInstDecl], [RenamedSig]),
- ImplicitEnv, -- new names used implicitly
- (Bag Error, Bag Warning)
- )
+\item if the wired-in name is another wired-in Id, it marks as ``occurrences''
+ the free vars of the Id's type.
-empty_return :: To_Return
-empty_return = (([],[],[],[]), emptyImplicitEnv, (emptyBag,emptyBag))
+\item it loads the interface file for the wired-in thing for the
+ sole purpose of making sure that its instance declarations are available
+\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.
+
-add_decl decl ((tydecls, classdecls, instdecls, sigs), implicit, msgs)
- = case decl of
- AddedTy t -> ((t:tydecls, classdecls, instdecls, sigs), implicit, msgs)
- AddedClass c -> ((tydecls, c:classdecls, instdecls, sigs), implicit, msgs)
- AddedSig s -> ((tydecls, classdecls, instdecls, s:sigs), implicit, msgs)
-add_insts is ((tydecls, classdecls, instdecls, sigs), implicit, msgs)
- = ((tydecls, classdecls, is ++ instdecls, sigs), implicit, msgs)
+
+%*********************************************************
+%* *
+\subsection{Getting what a module exports}
+%* *
+%*********************************************************
-add_implicits (val_imps, tc_imps) (decls, (val_fm, tc_fm), msgs)
- = (decls, (val_fm `plusFM` val_imps, tc_fm `plusFM` tc_imps), msgs)
+@getInterfaceExports@ is called only for directly-imported modules.
-add_err err (decls,implicit,(errs,warns)) = (decls,implicit,(errs `snocBag` err,warns))
-add_errs ers (decls,implicit,(errs,warns)) = (decls,implicit,(errs `unionBags` ers,warns))
-add_warn wrn (decls,implicit,(errs,warns)) = (decls,implicit,(errs, warns `snocBag` wrn))
-add_warns ws (decls,implicit,(errs,warns)) = (decls,implicit,(errs, warns `unionBags` ws))
+\begin{code}
+getInterfaceExports :: ModuleName -> WhereFrom -> RnMG (Module, Avails)
+getInterfaceExports mod_name from
+ = 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}
+
+%*********************************************************
+%* *
+\subsection{Instance declarations are handled specially}
+%* *
+%*********************************************************
+
\begin{code}
-data AddedDecl -- purely local
- = AddedTy RenamedTyDecl
- | AddedClass RenamedClassDecl
- | AddedSig RenamedSig
-
-rnIfaceDecl :: RdrIfaceDecl
- -> RnM_Fixes REAL_WORLD
- (AddedDecl, -- the resulting decl to add to the pot
- ([(RdrName,RnName)], [(RdrName,RnName)]),
- -- new val/tycon-class names that have
- -- *been defined* while processing this decl
- ImplicitEnv -- new implicit val/tycon-class names that we
- -- stumbled into
- )
-
-rnIfaceDecl (TypeSig tc _ decl)
- = rnTyDecl decl `thenRn` \ rn_decl ->
- lookupTyCon tc `thenRn` \ rn_tc ->
- getImplicitUpRn `thenRn` \ mentioned ->
+getImportedInstDecls :: NameSet -> RnMG [(Module,RdrNameHsDecl)]
+getImportedInstDecls gates
+ = -- First, load any orphan-instance modules that aren't aready loaded
+ -- Orphan-instance modules are recorded in the module dependecnies
+ getIfacesRn `thenRn` \ ifaces ->
let
- defds = ([], [(tc, rn_tc)])
- implicits = mentioned `sub` defds
+ orphan_mods =
+ [mod | (mod, (True, _, False)) <- fmToList (iImpModInfo ifaces)]
in
- returnRn (AddedTy rn_decl, defds, implicits)
+ loadOrphanModules orphan_mods `thenRn_`
-rnIfaceDecl (NewTypeSig tc dc _ decl)
- = rnTyDecl decl `thenRn` \ rn_decl ->
- lookupTyCon tc `thenRn` \ rn_tc ->
- lookupValue dc `thenRn` \ rn_dc ->
- getImplicitUpRn `thenRn` \ mentioned ->
- let
- defds = ([(dc, rn_dc)], [(tc, rn_tc)])
- implicits = mentioned `sub` defds
- in
- returnRn (AddedTy rn_decl, defds, implicits)
-
-rnIfaceDecl (DataSig tc dcs fcs _ decl)
- = rnTyDecl decl `thenRn` \ rn_decl ->
- lookupTyCon tc `thenRn` \ rn_tc ->
- mapRn lookupValue dcs `thenRn` \ rn_dcs ->
- mapRn lookupValue fcs `thenRn` \ rn_fcs ->
- getImplicitUpRn `thenRn` \ mentioned ->
+ -- 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 ->
let
- defds = (zip dcs rn_dcs ++ zip fcs rn_fcs , [(tc, rn_tc)])
- implicits = mentioned `sub` defds
+ (decls, new_insts) = selectGated gates (iInsts ifaces)
in
- returnRn (AddedTy rn_decl, defds, implicits)
+ setIfacesRn (ifaces { iInsts = new_insts }) `thenRn_`
-rnIfaceDecl (ClassSig clas ops _ decl)
- = rnClassDecl decl `thenRn` \ rn_decl ->
- lookupClass clas `thenRn` \ rn_clas ->
- mapRn (lookupClassOp rn_clas) ops `thenRn` \ rn_ops ->
- getImplicitUpRn `thenRn` \ mentioned ->
- let
- defds = (ops `zip` rn_ops, [(clas, rn_clas)])
- implicits = mentioned `sub` defds
- in
- returnRn (AddedClass rn_decl, defds, implicits)
-
-rnIfaceDecl (ValSig f src_loc ty)
- -- should rename_sig in RnBinds be used here? ToDo
- = lookupValue f `thenRn` \ rn_f ->
- -- pprTrace "rnIfaceDecl:ValSig:" (ppr PprDebug ty) $
- rnPolyType nullTyVarNamesEnv ty `thenRn` \ rn_ty ->
- getImplicitUpRn `thenRn` \ mentioned ->
+ traceRn (sep [text "getImportedInstDecls:",
+ 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
+ gate_list = nameSetToList gates
+
+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
+ | opt_IgnoreIfacePragmas = returnRn []
+ | otherwise
+ = getIfacesRn `thenRn` \ ifaces ->
let
- defds = ([(f, rn_f)], [])
- implicits = mentioned `sub` defds
+ gates = iSlurp ifaces -- Anything at all that's been slurped
+ rules = iRules ifaces
+ (decls, new_rules) = selectGated gates rules
in
- returnRn (AddedSig (Sig rn_f rn_ty noGenPragmas src_loc), defds, implicits)
-
-----
-sub :: ImplicitEnv -> ([(RdrName,RnName)], [(RdrName,RnName)]) -> ImplicitEnv
-
-sub (val_ment, tc_ment) (val_defds, tc_defds)
- = (delListFromFM val_ment (map (qualToOrigName . fst) val_defds),
- delListFromFM tc_ment (map (qualToOrigName . fst) tc_defds))
+ if null decls then
+ returnRn []
+ else
+ setIfacesRn (ifaces { iRules = new_rules }) `thenRn_`
+ traceRn (sep [text "getImportedRules:",
+ text "Slurped" <+> int (length decls) <+> text "rules"]) `thenRn_`
+ 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
+
+ | otherwise
+#endif
+ = foldrBag select ([], emptyBag) decl_bag
+ where
+ select (reqd, decl) (yes, no)
+ | isEmptyNameSet (reqd `minusNameSet` gates) = (decl:yes, no)
+ | otherwise = (yes, (reqd,decl) `consBag` no)
+
+lookupFixityRn :: Name -> RnMS Fixity
+lookupFixityRn name
+ | isLocallyDefined name
+ = getFixityEnv `thenRn` \ local_fix_env ->
+ returnRn (lookupLocalFixity local_fix_env name)
+
+ | otherwise -- Imported
+ -- For imported names, we have to get their fixities by doing a loadHomeInterface,
+ -- and consulting the Ifaces that comes back from that, because the interface
+ -- file for the Name might not have been loaded yet. Why not? Suppose you import module A,
+ -- which exports a function 'f', which is defined in module B. Then B isn't loaded
+ -- 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.
+ = 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}
-% ------------------------------
-@cacheInstModules@: cache instance modules specified in imports
+%*********************************************************
+%* *
+\subsection{Keeping track of what we've slurped, and version numbers}
+%* *
+%*********************************************************
+
+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:
+
+\begin{itemize}
+\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 (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.
+
+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}
+
+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.
+So we'll get an early bale-out when compiling A if B's version changes.
\begin{code}
-cacheInstModules :: IfaceCache -> [Module] -> IO (Bag Error)
+mkImportInfo :: ModuleName -- Name of this module
+ -> [ImportDecl n] -- The import decls
+ -> RnMG [ImportVersion Name]
-cacheInstModules iface_cache@(IfaceCache _ _ iface_var) imp_mods
- = readVar iface_var ST_THEN \ (iface_fm, _, _) ->
+mkImportInfo this_mod imports
+ = getIfacesRn `thenRn` \ ifaces ->
+ getHomeIfaceTableRn `thenRn` \ hit ->
let
- imp_ifaces = [ iface | Just iface <- map (lookupFM iface_fm) imp_mods ]
- (imp_imods, _) = removeDups cmpPString (bagToList (unionManyBags (map get_ims imp_ifaces)))
- get_ims (ParsedIface _ _ _ _ _ _ _ ims _ _ _ _ _) = ims
+ 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 :: ModuleEnv [Name]
+ mv_map = foldr add_mv emptyModuleEnv imp_names
+
+ 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
+ -- (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_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
+
+ | 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 dependency info.
+ -- The module in question must be a local module (in the same package)
+ go_for_it NothingAtAll
+
+
+ | is_lib_module && not has_orphans
+ = so_far
+
+ | 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
in
- --pprTrace "cacheInstModules:" (ppCat (map ppPStr imp_imods)) $
- accumulate (map (cachedIface iface_cache False SLIT("instance_modules")) imp_imods) >>= \ err_or_ifaces ->
+ traceRn (text "Modules in Ifaces: " <+> fsep (map ppr (keysFM mod_map))) `thenRn_`
+ returnRn import_info
- -- Sanity Check:
- -- Assert that instance modules given by direct imports contains
- -- instance modules extracted from all visited modules
- readVar iface_var ST_THEN \ (all_iface_fm, _, _) ->
- let
- all_ifaces = eltsFM all_iface_fm
- (all_imods, _) = removeDups cmpPString (bagToList (unionManyBags (map get_ims (all_ifaces))))
+addItem :: ModuleEnv [a] -> Module -> a -> ModuleEnv [a]
+addItem fm mod x = extendModuleEnv_C add_item fm mod [x]
+ where
+ add_item xs _ = x:xs
+\end{code}
+
+\begin{code}
+getSlurped
+ = getIfacesRn `thenRn` \ ifaces ->
+ returnRn (iSlurp ifaces)
+
+recordSlurp ifaces@(Ifaces { iSlurp = slurped_names, iVSlurp = imp_names })
+ avail
+ = let
+ new_slurped_names = addAvailToNameSet slurped_names avail
+ new_imp_names = availName avail : imp_names
in
- ASSERT(sortLt (<) imp_imods == sortLt (<) all_imods)
+ ifaces { iSlurp = new_slurped_names, iVSlurp = new_imp_names }
- return (bag_errs err_or_ifaces)
- where
- bag_errs [] = emptyBag
- bag_errs (Failed err :rest) = err `consBag` bag_errs rest
- bag_errs (Succeeded _:rest) = bag_errs rest
+recordLocalSlurps local_avails
+ = getIfacesRn `thenRn` \ ifaces ->
+ let
+ new_slurped_names = foldl addAvailToNameSet (iSlurp ifaces) local_avails
+ in
+ setIfacesRn (ifaces { iSlurp = new_slurped_names })
\end{code}
-@rnIfaceInstStuff@: Deal with instance declarations from interface files.
+%*********************************************************
+%* *
+\subsection{Getting binders out of a declaration}
+%* *
+%*********************************************************
-\begin{code}
-type InstanceEnv = FiniteMap (OrigName, OrigName) Int
-
-rnIfaceInstStuff
- :: IfaceCache -- all about ifaces we've read
- -> Module
- -> UniqSupply
- -> RnEnv -- current occ env
- -> InstanceEnv -- instances for these tycon/class pairs done
- -> To_Return
- -> IO (To_Return,
- InstanceEnv, -- extended instance env
- RnEnv, -- final occ env
- [RnName]) -- new unknown names
-
-rnIfaceInstStuff iface_cache@(IfaceCache _ _ iface_var) modname us occ_env done_inst_env to_return
- = -- all the instance decls we might even want to consider
- -- are in the ParsedIfaces that are in our cache
-
- readVar iface_var ST_THEN \ (_, orig_iface_fm, _) ->
- let
- all_ifaces = eltsFM orig_iface_fm
- all_insts = concat (map get_insts all_ifaces)
- interesting_insts = filter want_inst all_insts
+@getDeclBinders@ returns the names for a @RdrNameHsDecl@.
+It's used for both source code (from @availsFromDecl@) and interface files
+(from @loadDecl@).
- -- Sanity Check:
- -- Assert that there are no more instances for the done instances
+It doesn't deal with source-code specific things: @ValD@, @DefD@. They
+are handled by the sourc-code specific stuff in @RnNames@.
- claim_done = filter is_done_inst all_insts
- claim_done_env = foldr add_done_inst emptyFM claim_done
+\begin{code}
+getDeclBinders :: (RdrName -> SrcLoc -> RnM d Name) -- New-name function
+ -> RdrNameHsDecl
+ -> RnM d (Maybe AvailInfo)
- has_val fm (k,i) = case lookupFM fm k of { Nothing -> False; Just v -> i == v }
- in
- {-
- pprTrace "all_insts:\n" (ppr_insts (bagToList all_insts)) $
- pprTrace "interesting_insts:\n" (ppr_insts interesting_insts) $
- -}
- ASSERT(sizeFM done_inst_env == sizeFM claim_done_env)
- ASSERT(all (has_val claim_done_env) (fmToList done_inst_env))
-
- case (initRn False{-iface-} modname occ_env us (
- setExtraRn emptyUFM{-no fixities-} $
- mapRn rnIfaceInst interesting_insts `thenRn` \ insts ->
- getImplicitUpRn `thenRn` \ implicits ->
- returnRn (insts, implicits))) of {
- ((if_insts, if_implicits), if_errs, if_warns) ->
-
- return (add_insts if_insts $
- add_implicits if_implicits $
- add_errs if_errs $
- add_warns if_warns to_return,
- foldr add_done_inst done_inst_env interesting_insts,
- add_imp_occs if_implicits occ_env,
- eltsFM (fst if_implicits) ++ eltsFM (snd if_implicits))
- }
+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
- get_insts (ParsedIface imod _ _ _ _ _ _ _ _ _ _ insts _) = [(imod, inst) | inst <- bagToList insts]
-
- tycon_class clas tycon = (qualToOrigName clas, qualToOrigName tycon)
-
- add_done_inst (_, InstSig clas tycon _ _) inst_env
- = addToFM_C (+) inst_env (tycon_class clas tycon) 1
-
- is_done_inst (_, InstSig clas tycon _ _)
- = maybeToBool (lookupFM done_inst_env (tycon_class clas tycon))
-
- add_imp_occs (val_imps, tc_imps) occ_env
- = case (extendGlobalRnEnv occ_env (de_orig val_imps) (de_orig tc_imps)) of
- (ext_occ_env, occ_dups) -> ASSERT(isEmptyBag occ_dups)
- ext_occ_env
- where
- de_orig imps = [ (Qual m n, v) | (OrigName m n, v) <- fmToList imps ]
- -- again, this hackery because we are reusing the RnEnv technology
-
- want_inst i@(imod, InstSig clas tycon _ _)
- = -- it's a "good instance" (one to hang onto) if we have a
- -- chance of referring to *both* the class and tycon later on ...
- --pprTrace "want_inst:" (ppCat [ppr PprDebug clas, ppr PprDebug tycon, ppr PprDebug (mentionable tycon), ppr PprDebug (mentionable clas), ppr PprDebug(is_done_inst i)]) $
- mentionable tycon && mentionable clas && not (is_done_inst i)
- where
- mentionable nm
- = case lookupTcRnEnv occ_env nm of
- Just _ -> True
- Nothing -> -- maybe it's builtin
- let orig = qualToOrigName nm in
- case (lookupFM b_tc_names orig) of
- Just _ -> True
- Nothing -> maybeToBool (lookupFM b_keys orig)
-
- (b_tc_names, b_keys) -- pretty UGLY ...
- = case builtinNameInfo of ((_,builtin_tcs),b_keys,_) -> (builtin_tcs,b_keys)
-{-
- ppr_insts insts
- = ppAboves (map ppr_inst insts)
- where
- ppr_inst (InstSig c t _ inst_decl)
- = ppCat [ppr PprDebug c, ppr PprDebug t, ppr PprDebug inst_decl]
--}
+ 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))
+
+ -- 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
+ = lookupOrigName nm `thenRn_`
+ 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
\end{code}
-\begin{code}
-rnIfaceInst :: (Module, RdrIfaceInst) -> RnM_Fixes REAL_WORLD RenamedInstDecl
+@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't returned by @getDeclBinders@ because they aren't in scope;
+but they {\em should} be put into the @DeclsMap@ of this module.
-rnIfaceInst (imod, InstSig _ _ _ inst_decl) = rnInstDecl (inst_decl imod)
-\end{code}
+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}
-type BigMaps = (FiniteMap Module Version, -- module-version map
- FiniteMap (FAST_STRING,Module) Version) -- ordinary version map
-
-finalIfaceInfo ::
- IfaceCache -- iface cache
- -> Module -- this module's name
- -> RnEnv
- -> [RenamedInstDecl]
--- -> [RnName] -- all imported names required
--- -> [Module] -- directly imported modules
- -> IO (UsagesMap,
- VersionsMap, -- info about version numbers
- [Module]) -- special instance modules
-
-finalIfaceInfo iface_cache@(IfaceCache _ _ iface_var) modname if_final_env@((qual, unqual, tc_qual, tc_unqual), stack) if_instdecls
- =
--- pprTrace "usageIf:qual:" (ppCat [ppBesides[ppPStr m,ppChar '.',ppPStr n] | (n,m) <- keysFM qual]) $
--- pprTrace "usageIf:unqual:" (ppCat (map ppPStr (keysFM unqual))) $
--- pprTrace "usageIf:tc_qual:" (ppCat [ppBesides[ppPStr m,ppChar '.',ppPStr n] | (n,m) <- keysFM tc_qual]) $
--- pprTrace "usageIf:tc_unqual:" (ppCat (map ppPStr (keysFM tc_unqual))) $
- readVar iface_var ST_THEN \ (_, orig_iface_fm, _) ->
- let
- all_ifaces = eltsFM orig_iface_fm
- -- all the interfaces we have looked at
-
- big_maps
- -- combine all the version maps we have seen into maps to
- -- (a) lookup a module-version number, lookup an entity's
- -- individual version number
- = foldr mk_map (emptyFM,emptyFM) all_ifaces
+getDeclSysBinders new_name (TyClD (ClassDecl _ cname _ _ sigs _ names src_loc))
+ = sequenceRn [new_name n src_loc | n <- names]
- val_stuff@(val_usages, val_versions)
- = foldFM (process_item big_maps) (emptyFM, emptyFM){-init-} qual
-
- (all_usages, all_versions)
- = foldFM (process_item big_maps) val_stuff{-keep going-} tc_qual
- in
- return (all_usages, all_versions, [])
- where
- mk_map (ParsedIface m _ mv _ _ vers _ _ _ _ _ _ _) (mv_map, ver_map)
- = (addToFM mv_map m mv, -- add this module
- addListToFM ver_map [ ((n,m), v) | (n,v) <- fmToList vers ])
-
- -----------------------
- process_item :: BigMaps
- -> (FAST_STRING,Module) -> RnName -- RnEnv (QualNames) components
- -> (UsagesMap, VersionsMap) -- input
- -> (UsagesMap, VersionsMap) -- output
-
- process_item (big_mv_map, big_version_map) key@(n,m) rn as_before@(usages, versions)
- | irrelevant rn
- = as_before
- | m == modname -- this module => add to "versions"
- = (usages, addToFM versions n 1{-stub-})
- | otherwise -- from another module => add to "usages"
- = case (add_to_usages usages key) of
- Nothing -> as_before
- Just new_usages -> (new_usages, versions)
- where
- add_to_usages usages key@(n,m)
- = case (lookupFM big_mv_map m) of
- Nothing -> Nothing
- Just mv ->
- case (lookupFM big_version_map key) of
- Nothing -> Nothing
- Just kv ->
- Just $ addToFM usages m (
- case (lookupFM usages m) of
- Nothing -> -- nothing for this module yet...
- (mv, unitFM n kv)
-
- Just (mversion, mstuff) -> -- the "new" stuff will shadow the old
- ASSERT(mversion == mv)
- (mversion, addToFM mstuff n kv)
- )
-
- irrelevant (RnConstr _ _) = True -- We don't report these in their
- irrelevant (RnField _ _) = True -- own right in usages/etc.
- irrelevant (RnClassOp _ _) = True
- irrelevant (RnImplicit n) = isLexCon (nameOf (origName "irrelevant" n)) -- really a RnConstr
- irrelevant _ = False
+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 []
\end{code}
+%*********************************************************
+%* *
+\subsection{Reading an interface file}
+%* *
+%*********************************************************
\begin{code}
-thisModImplicitWarn mod n sty
- = ppBesides [ppPStr SLIT("An interface has an implicit need of "), ppr sty n, ppPStr SLIT("; assuming this module will provide it.")]
+findAndReadIface :: SDoc -> ModuleName
+ -> IsBootInterface -- True <=> Look for a .hi-boot file
+ -- False <=> Look for .hi file
+ -> RnM d (Either Message (Module, ParsedIface))
+ -- Nothing <=> file not found, or unreadable, or illegible
+ -- Just x <=> successfully found and parsed
+
+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.
+
+ 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
+ other -> traceRn (ptext SLIT("...not found")) `thenRn_`
+ returnRn (Left (noIfaceErr mod_name hi_boot_file))
-noIfaceErr mod sty
- = ppCat [ppPStr SLIT("Could not find interface for:"), ppPStr mod]
-
-noOrigIfaceErr mod sty
- = ppCat [ppPStr SLIT("Could not find original interface for:"), ppPStr mod]
+ where
+ trace_msg = sep [hsep [ptext SLIT("Reading"),
+ if hi_boot_file then ptext SLIT("[boot]") else empty,
+ ptext SLIT("interface for"),
+ ppr mod_name <> semi],
+ nest 4 (ptext SLIT("reason:") <+> doc_str)]
+\end{code}
-noDeclInIfaceErr mod str sty
- = ppBesides [ppPStr SLIT("Could not find interface declaration of: "),
- ppPStr mod, ppStr ".", ppPStr str]
+@readIface@ tries just the one file.
-cannaeReadErr file err sty
- = ppBesides [ppPStr SLIT("Failed in reading file: "), ppStr file, ppStr "; error=", ppStr (show err)]
+\begin{code}
+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
+ = 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
+ PState{ bol = 0#, atbol = 1#,
+ context = [],
+ glasgow_exts = 1#,
+ loc = mkSrcLoc (mkFastString file_path) 1 } of
+ POk _ (PIface iface) ->
+ warnCheckRn (wanted_mod == read_mod)
+ (hiModuleNameMismatchWarn wanted_mod read_mod) `thenRn_`
+ returnRn (Right (wanted_mod, iface))
+ where
+ read_mod = 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}
-ifaceLookupWiredErr msg n sty
- = ppBesides [ppPStr SLIT("Why am I looking up a wired-in "), ppStr msg, ppChar ':', ppr sty n]
+%*********************************************************
+%* *
+\subsection{Errors}
+%* *
+%*********************************************************
-badIfaceLookupErr msg name decl sty
- = ppBesides [ppPStr SLIT("Expected a "), ppStr msg, ppPStr SLIT(" declaration, but got this: ???")]
+\begin{code}
+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,
+ nest 4 err]
+
+getDeclErr name
+ = vcat [ptext SLIT("Failed to find interface decl for") <+> quotes (ppr name),
+ ptext SLIT("from module") <+> quotes (ppr (nameModule name))
+ ]
+
+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("name:"), quotes (ppr name)]
+
+warnRedundantSourceImport mod_name
+ = ptext SLIT("Unnecessary {- SOURCE -} in the import of module")
+ <+> quotes (ppr mod_name)
+
+hiModuleNameMismatchWarn :: Module -> Module -> Message
+hiModuleNameMismatchWarn requested_mod read_mod =
+ hsep [ ptext SLIT("Something is amiss; requested module name")
+ , ppr (moduleName requested_mod)
+ , ptext SLIT("differs from name found in the interface file")
+ , ppr read_mod
+ ]
-ifaceIoErr io_msg rn sty
- = ppBesides [io_msg sty, ppStr "; looking for: ", ppr sty rn]
\end{code}
projects / ghc-hetmet.git / blobdiff