\begin{code}
module RnIfaces
(
- getInterfaceExports,
recordLocalSlurps,
mkImportInfo,
extractHsTyNames, extractHsCtxtTyNames,
tyClDeclFVs, ruleDeclFVs, instDeclFVs
)
-import RnHiFiles ( tryLoadInterface, loadHomeInterface, loadInterface,
+import RnHiFiles ( tryLoadInterface, loadHomeInterface,
loadOrphanModules
)
import RnSource ( rnTyClDecl, rnInstDecl, rnIfaceRuleDecl )
import RnEnv
import RnMonad
-import Id ( idType )
+import Id ( idType, idName, globalIdDetails )
+import IdInfo ( GlobalIdDetails(..) )
import Type ( namesOfType )
-import TyCon ( isSynTyCon, getSynTyConDefn )
+import FieldLabel ( fieldLabelTyCon )
+import DataCon ( dataConTyCon )
+import TyCon ( isSynTyCon, getSynTyConDefn, tyConClass_maybe, tyConName )
+import Class ( className )
import Name ( Name {-instance NamedThing-}, nameOccName,
- nameModule, isLocalName, nameUnique,
- NamedThing(..)
+ nameModule, isLocalName, NamedThing(..)
)
-import Name ( elemNameEnv, delFromNameEnv )
+import NameEnv ( elemNameEnv, delFromNameEnv, lookupNameEnv )
+import NameSet
import Module ( Module, ModuleEnv,
- moduleName, isModuleInThisPackage,
+ moduleName, isHomeModule,
ModuleName, WhereFrom(..),
emptyModuleEnv,
extendModuleEnv_C, foldModuleEnv, lookupModuleEnv,
elemModuleSet, extendModuleSet
)
-import NameSet
-import PrelInfo ( wiredInThingEnv, fractionalClassKeys )
-import TysWiredIn ( doubleTyCon )
-import Maybes ( orElse )
+import PrelInfo ( wiredInThingEnv, hasKey, fractionalClassKey, numClassKey,
+ integerTyConName, doubleTyConName )
+import Maybes ( maybeToBool )
import FiniteMap
import Outputable
import Bag
%*********************************************************
%* *
-\subsection{Getting what a module exports}
-%* *
-%*********************************************************
-
-@getInterfaceExports@ is called only for directly-imported modules.
-
-\begin{code}
-getInterfaceExports :: ModuleName -> WhereFrom -> RnMG (Module, [(ModuleName,Avails)])
-getInterfaceExports mod_name from
- = loadInterface doc_str mod_name from `thenRn` \ iface ->
- returnRn (mi_module iface, mi_exports iface)
- where
- doc_str = sep [ppr mod_name, ptext SLIT("is directly imported")]
-\end{code}
-
-
-%*********************************************************
-%* *
\subsection{Keeping track of what we've slurped, and version numbers}
%* *
%*********************************************************
-getImportVersions figures out what the ``usage information'' for this
+mkImportInfo 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:
+things it uses.
+
+We produce a line for every module B below the module, A, currently being
+compiled:
+ import B <n> ;
+to record the fact that A does import B indirectly. 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.
+
+The usage information records:
\begin{itemize}
\item (a) anything reachable from its body code
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.
+ *** Conclusion: if A mentions B.f in its export list,
+ behave just as if A mentioned B.f in its source code,
+ and slurp in B.f and all its transitive closure ***
+
[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}
mkImportInfo :: ModuleName -- Name of this module
-> [ImportDecl n] -- The import decls
import_info0 = foldModuleEnv mk_imp_info [] pit
import_info1 = foldModuleEnv mk_imp_info import_info0 hit
- import_info = [ (mod_name, orphans, is_boot, NothingAtAll)
- | (mod_name, (orphans, is_boot)) <- fmToList (iImpModInfo ifaces) ] ++
- import_info1
+ import_info = not_even_opened_imports ++ import_info1
+
+ -- Recall that iImpModInfo describes modules that have been mentioned
+ -- in the import lists of interfaces we have opened, but which we have
+ -- not even opened when compiling this module
+ not_even_opened_imports = [ (mod_name, orphans, is_boot, NothingAtAll)
+ | (mod_name, (orphans, is_boot)) <- fmToList (iImpModInfo ifaces) ]
+
mk_imp_info :: ModIface -> [ImportVersion Name] -> [ImportVersion Name]
mk_imp_info iface so_far
| import_all_mod -- Case (a) and (b); the import-all part
= if is_home_pkg_mod then
go_for_it (Specifically mod_vers (Just export_vers) [] rules_vers)
+ -- Since the module isn't in the mv_map, presumably we
+ -- didn't actually import anything at all from it
else
go_for_it (Everything mod_vers)
mod = mi_module iface
mod_name = moduleName mod
- is_home_pkg_mod = isModuleInThisPackage mod
+ is_home_pkg_mod = isHomeModule mod
version_info = mi_version iface
version_env = vers_decls version_info
mod_vers = vers_module version_info
-- The sort is to put them into canonical order
mk_import_items ns = [(n,v) | n <- sortLt lt_occ ns,
- let v = lookupNameEnv version_env n `orElse`
- pprPanic "mk_whats_imported" (ppr n)
+ let v = lookupVersion version_env n
]
where
lt_occ n1 n2 = nameOccName n1 < nameOccName n2
= traceRn (text "slurpImp" <+> fsep (map ppr (nameSetToList source_fvs))) `thenRn_`
-- The current slurped-set records all local things
- getSlurped `thenRn` \ source_binders ->
- slurpSourceRefs source_binders source_fvs `thenRn` \ (decls, needed) ->
+ slurpSourceRefs source_fvs `thenRn` \ (decls, needed) ->
-- Then get everything else
closeDecls decls needed
-------------------------------------------------------
-slurpSourceRefs :: NameSet -- Variables defined in source
- -> FreeVars -- Variables referenced in source
+slurpSourceRefs :: FreeVars -- Variables referenced in source
-> RnMG ([RenamedHsDecl],
FreeVars) -- Un-satisfied needs
-- The declaration (and hence home module) of each gate has
-- already been loaded
-slurpSourceRefs source_binders source_fvs
+slurpSourceRefs source_fvs
= go_outer [] -- Accumulating decls
emptyFVs -- Unsatisfied needs
emptyFVs -- Accumulating gates
-- and the instance decls
-- The outer loop is needed because consider
+ -- instance Foo a => Baz (Maybe a) where ...
+ -- It may be that Baz and Maybe are used in the source module,
+ -- but not Foo; so we need to chase Foo too.
+ --
+ -- We also need to follow superclass refs. In particular, 'chasing Foo' must
+ -- include actually getting in Foo's class decl
+ -- class Wib a => Foo a where ..
+ -- so that its superclasses are discovered. The point is that Wib is a gate too.
+ -- We do this for tycons too, so that we look through type synonyms.
go_outer decls fvs all_gates []
= returnRn (decls, fvs)
go_outer decls fvs all_gates refs -- refs are not necessarily slurped yet
= traceRn (text "go_outer" <+> ppr refs) `thenRn_`
- getImportedInstDecls all_gates `thenRn` \ inst_decls ->
foldlRn go_inner (decls, fvs, emptyFVs) refs `thenRn` \ (decls1, fvs1, gates1) ->
+ getImportedInstDecls (all_gates `plusFV` gates1) `thenRn` \ inst_decls ->
rnIfaceInstDecls decls1 fvs1 gates1 inst_decls `thenRn` \ (decls2, fvs2, gates2) ->
go_outer decls2 fvs2 (all_gates `plusFV` gates2)
(nameSetToList (gates2 `minusNameSet` all_gates))
-- Knock out the all_gates because even if we don't slurp any new
-- decls we can get some apparently-new gates from wired-in names
+ -- and we get an infinite loop
go_inner (decls, fvs, gates) wanted_name
= importDecl wanted_name `thenRn` \ import_result ->
case rule_decls of
[] -> returnRn decls -- No new rules, so we are done
other -> rnIfaceDecls rnIfaceRuleDecl rule_decls `thenRn` \ rule_decls' ->
- closeDecls (map RuleD rule_decls' ++ decls)
- (plusFVs (map ruleDeclFVs rule_decls'))
+ let
+ rule_fvs = plusFVs (map ruleDeclFVs rule_decls')
+ in
+ traceRn (text "closeRules" <+> ppr rule_decls' $$ fsep (map ppr (nameSetToList rule_fvs))) `thenRn_`
+ closeDecls (map RuleD rule_decls' ++ decls) rule_fvs
+
-------------------------------------------------------
\begin{code}
-getSlurped
- = getIfacesRn `thenRn` \ ifaces ->
- returnRn (iSlurp ifaces)
-
-recordSlurp ifaces@(Ifaces { iDecls = (decls_map, n_slurped),
- iSlurp = slurped_names,
- iVSlurp = (imp_mods, imp_names) })
+recordDeclSlurp ifaces@(Ifaces { iDecls = (decls_map, n_slurped),
+ iSlurp = slurped_names,
+ iVSlurp = vslurp })
avail
= ASSERT2( not (isLocalName (availName avail)), ppr avail )
- ifaces { iDecls = (decls_map', n_slurped+1),
+ ifaces { iDecls = (new_decls_map, n_slurped+1),
iSlurp = new_slurped_names,
- iVSlurp = new_vslurp }
+ iVSlurp = updateVSlurp vslurp (availName avail) }
where
- decls_map' = foldl delFromNameEnv decls_map (availNames avail)
- main_name = availName avail
- mod = nameModule main_name
+ new_decls_map = foldl delFromNameEnv decls_map (availNames avail)
new_slurped_names = addAvailToNameSet slurped_names avail
- new_vslurp | isModuleInThisPackage mod = (imp_mods, addOneToNameSet imp_names main_name)
- | otherwise = (extendModuleSet imp_mods mod, imp_names)
-recordLocalSlurps local_avails
+
+-- recordTypeEnvSlurp is used when we slurp something that's
+-- already in the type environment, that was not slurped in an earlier compilation.
+-- We record it in the iVSlurp set, because that's used to
+-- generate usage information
+
+recordTypeEnvSlurp ifaces ty_thing
+ = ifaces { iVSlurp = updateVSlurp (iVSlurp ifaces) (get_main_name ty_thing) }
+ where
+ -- Tiresomely, we must get the "main" name for the
+ -- thing, because that's what VSlurp contains, and what
+ -- is recorded in the usage information
+ get_main_name (AClass cl) = className cl
+ get_main_name (ATyCon tc)
+ | Just clas <- tyConClass_maybe tc = get_main_name (AClass clas)
+ | otherwise = tyConName tc
+ get_main_name (AnId id)
+ = case globalIdDetails id of
+ DataConId dc -> get_main_name (ATyCon (dataConTyCon dc))
+ DataConWrapId dc -> get_main_name (ATyCon (dataConTyCon dc))
+ RecordSelId lbl -> get_main_name (ATyCon (fieldLabelTyCon lbl))
+ other -> idName id
+
+updateVSlurp (imp_mods, imp_names) main_name
+ | isHomeModule mod = (imp_mods, addOneToNameSet imp_names main_name)
+ | otherwise = (extendModuleSet imp_mods mod, imp_names)
+ where
+ mod = nameModule main_name
+
+recordLocalSlurps new_names
= getIfacesRn `thenRn` \ ifaces ->
- let
- new_slurped_names = foldl addAvailToNameSet (iSlurp ifaces) local_avails
- in
- setIfacesRn (ifaces { iSlurp = new_slurped_names })
+ setIfacesRn (ifaces { iSlurp = iSlurp ifaces `unionNameSets` new_names })
\end{code}
getGates source_fvs decl
= get_gates (\n -> n `elemNameSet` source_fvs) decl
-get_gates is_used (IfaceSig _ ty _ _)
- = extractHsTyNames ty
+get_gates is_used (IfaceSig {tcdType = ty}) = extractHsTyNames ty
-get_gates is_used (ClassDecl ctxt cls tvs _ sigs _ _ _ )
- = (delListFromNameSet (foldr (plusFV . get) (extractHsCtxtTyNames ctxt) sigs)
- (hsTyVarNames tvs)
- `addOneToNameSet` cls)
- `plusFV` maybe_double
+get_gates is_used (ClassDecl { tcdCtxt = ctxt, tcdName = cls, tcdTyVars = tvs, tcdSigs = sigs})
+ = (super_cls_and_sigs `addOneToNameSet` cls) `unionNameSets`
+ implicitClassGates cls
where
+ super_cls_and_sigs = delListFromNameSet (foldr (plusFV . get) (extractHsCtxtTyNames ctxt) sigs)
+ (hsTyVarNames tvs)
get (ClassOpSig n _ ty _)
| is_used n = extractHsTyNames ty
| otherwise = emptyFVs
- -- If we load any numeric class that doesn't have
- -- Int as an instance, add Double to the gates.
- -- This takes account of the fact that Double might be needed for
- -- defaulting, but we don't want to load Double (and all its baggage)
- -- if the more exotic classes aren't used at all.
- maybe_double | nameUnique cls `elem` fractionalClassKeys
- = unitFV (getName doubleTyCon)
- | otherwise
- = emptyFVs
-
-get_gates is_used (TySynonym tycon tvs ty _)
+get_gates is_used (TySynonym {tcdTyVars = tvs, tcdSynRhs = ty})
= delListFromNameSet (extractHsTyNames ty) (hsTyVarNames tvs)
-- A type synonym type constructor isn't a "gate" for instance decls
-get_gates is_used (TyData _ ctxt tycon tvs cons _ _ _ _ _)
+get_gates is_used (TyData {tcdCtxt = ctxt, tcdName = tycon, tcdTyVars = tvs, tcdCons = cons})
= delListFromNameSet (foldr (plusFV . get) (extractHsCtxtTyNames ctxt) cons)
(hsTyVarNames tvs)
`addOneToNameSet` tycon
| otherwise = emptyFVs
get_bang bty = extractHsTyNames (getBangType bty)
+
+implicitClassGates :: Name -> FreeVars
+implicitClassGates cls
+ -- If we load class Num, add Integer to the free gates
+ -- This takes account of the fact that Integer might be needed for
+ -- defaulting, but we don't want to load Integer (and all its baggage)
+ -- if there's no numeric stuff needed.
+ -- Similarly for class Fractional and Double
+ --
+ -- NB: adding T to the gates will force T to be loaded
+ --
+ -- NB: If we load (say) Floating, we'll end up loading Fractional too,
+ -- since Fractional is a superclass of Floating
+ | cls `hasKey` numClassKey = unitFV integerTyConName
+ | cls `hasKey` fractionalClassKey = unitFV doubleTyConName
+ | otherwise = emptyFVs
\end{code}
@getWiredInGates@ is just like @getGates@, but it sees a previously-loaded
-- mentioned in other modules, and hence are in the type environment
getWiredInGates (AnId the_id) = namesOfType (idType the_id)
-getWiredInGates (AClass cl) = emptyFVs -- The superclasses must also be previously
- -- loaded, and hence are automatically gates
+getWiredInGates (AClass cl) = implicitClassGates (getName cl)
+ -- The superclasses must also be previously
+ -- loaded, and hence are automatically gates
+ -- All previously-loaded classes are automatically gates
+ -- See "The gating story" above
getWiredInGates (ATyCon tc)
| isSynTyCon tc = delListFromNameSet (namesOfType ty) (map getName tyvars)
| otherwise = unitFV (getName tc)
getIfacesRn `thenRn` \ ifaces ->
getTypeEnvRn `thenRn` \ lookup ->
let
- (decls, new_insts) = selectGated gates lookup (iInsts ifaces)
+ available n
+ | n `elemNameSet` gates = True
+ | otherwise = case lookup n of { Just (AClass c) -> True; other -> False }
+ -- See "The gating story" above for the AClass thing
+
+ (decls, new_insts) = selectGated available (iInsts ifaces)
in
setIfacesRn (ifaces { iInsts = new_insts }) `thenRn_`
= getIfacesRn `thenRn` \ ifaces ->
getTypeEnvRn `thenRn` \ lookup ->
let
- gates = iSlurp ifaces -- Anything at all that's been slurped
- rules = iRules ifaces
- (decls, new_rules) = selectGated gates lookup rules
+ -- Slurp rules for anything that is slurped,
+ -- either now or previously
+ gates = iSlurp ifaces
+ available n = n `elemNameSet` gates || maybeToBool (lookup n)
+ (decls, new_rules) = selectGated available (iRules ifaces)
in
if null decls then
returnRn []
text "Slurped" <+> int (length decls) <+> text "rules"]) `thenRn_`
returnRn decls
-selectGated gates lookup (decl_bag, n_slurped)
- -- Select only those decls whose gates are *all* in 'gates'
- -- or are a class in 'lookup'
+selectGated :: (Name->Bool) -> GatedDecls d
+ -> ([(Module,d)], GatedDecls d)
+selectGated available (decl_bag, n_slurped)
+ -- Select only those decls whose gates are *all* available
#ifdef DEBUG
| opt_NoPruneDecls -- Just to try the effect of not gating at all
= let
= case foldrBag select ([], emptyBag) decl_bag of
(decls, new_bag) -> (decls, (new_bag, n_slurped + length decls))
where
- available n = n `elemNameSet` gates
- || case lookup n of { Just (AClass c) -> True; other -> False }
-
select (reqd, decl) (yes, no)
| all available reqd = (decl:yes, no)
| otherwise = (yes, (reqd,decl) `consBag` no)
| HereItIs (Module, RdrNameTyClDecl)
importDecl name
- = -- STEP 1: Check if it was loaded before beginning this module
- if isLocalName name then
- traceRn (text "Already (local)" <+> ppr name) `thenRn_`
- returnRn AlreadySlurped
+ = -- STEP 1: Check if we've slurped it in while compiling this module
+ getIfacesRn `thenRn` \ ifaces ->
+ if name `elemNameSet` iSlurp ifaces then
+ returnRn AlreadySlurped
else
+
-- STEP 2: Check if it's already in the type environment
getTypeEnvRn `thenRn` \ lookup ->
case lookup name of {
- Just ty_thing | name `elemNameEnv` wiredInThingEnv
- -> -- When we find a wired-in name we must load its home
- -- module so that we find any instance decls lurking therein
- loadHomeInterface wi_doc name `thenRn_`
- returnRn (InTypeEnv ty_thing)
-
- | otherwise
- -> returnRn (InTypeEnv ty_thing) ;
+ Just ty_thing
+ | name `elemNameEnv` wiredInThingEnv
+ -> -- When we find a wired-in name we must load its home
+ -- module so that we find any instance decls lurking therein
+ loadHomeInterface wi_doc name `thenRn_`
+ returnRn (InTypeEnv ty_thing)
+
+ | otherwise
+ -> -- Very important: record that we've seen it
+ -- See comments with recordTypeEnvSlurp
+ setIfacesRn (recordTypeEnvSlurp ifaces ty_thing) `thenRn_`
+ returnRn (InTypeEnv ty_thing) ;
Nothing ->
- -- STEP 3: Check if we've slurped it in while compiling this module
- getIfacesRn `thenRn` \ ifaces ->
- if name `elemNameSet` iSlurp ifaces then
- returnRn AlreadySlurped
- else
-
- -- STEP 4: OK, we have to slurp it in from an interface file
+ -- STEP 3: OK, we have to slurp it in from an interface file
-- First load the interface file
traceRn nd_doc `thenRn_`
loadHomeInterface nd_doc name `thenRn_`
getIfacesRn `thenRn` \ ifaces ->
- -- STEP 5: Get the declaration out
+ -- STEP 4: Get the declaration out
let
(decls_map, _) = iDecls ifaces
in
case lookupNameEnv decls_map name of
- Just (avail,_,decl)
- -> setIfacesRn (recordSlurp ifaces avail) `thenRn_`
- returnRn (HereItIs decl)
+ Just (avail,_,decl) -> setIfacesRn (recordDeclSlurp ifaces avail) `thenRn_`
+ returnRn (HereItIs decl)
- Nothing
- -> addErrRn (getDeclErr name) `thenRn_`
- returnRn AlreadySlurped
+ Nothing -> addErrRn (getDeclErr name) `thenRn_`
+ returnRn AlreadySlurped
}
where
wi_doc = ptext SLIT("need home module for wired in thing") <+> ppr name
outOfDate = True -- Recompile required
recompileRequired :: FilePath -- Only needed for debug msgs
- -> Bool -- Source unchanged
-> ModIface -- Old interface
-> RnMG RecompileRequired
-recompileRequired iface_path source_unchanged iface
- = traceRn (text "Considering whether compilation is required for" <+> text iface_path <> colon) `thenRn_`
-
- -- CHECK WHETHER THE SOURCE HAS CHANGED
- if not source_unchanged then
- traceRn (nest 4 (text "Source file changed or recompilation check turned off")) `thenRn_`
- returnRn outOfDate
- else
+recompileRequired iface_path iface
+ = traceHiDiffsRn (text "Considering whether compilation is required for" <+> text iface_path <> colon) `thenRn_`
-- Source code unchanged and no errors yet... carry on
checkList [checkModUsage u | u <- mi_usages iface]
-- In this case we don't even want to open Foo's interface.
= up_to_date (ptext SLIT("Nothing used from:") <+> ppr mod_name)
-checkModUsage (mod_name, _, _, whats_imported)
- = tryLoadInterface doc_str mod_name ImportBySystem `thenRn` \ (iface, maybe_err) ->
+checkModUsage (mod_name, _, is_boot, whats_imported)
+ = -- Load the imported interface is possible
+ -- We use tryLoadInterface, because failure is not an error
+ -- (might just be that the old .hi file for this module is out of date)
+ -- We use ImportByUser/ImportByUserSource as the 'from' flag,
+ -- a) because we need to know whether to load the .hi-boot file
+ -- b) because loadInterface things matters are amiss if we
+ -- ImportBySystem an interface it knows nothing about
+ let
+ doc_str = sep [ptext SLIT("need version info for"), ppr mod_name]
+ from | is_boot = ImportByUserSource
+ | otherwise = ImportByUser
+ in
+ traceHiDiffsRn (text "Checking usages for module" <+> ppr mod_name) `thenRn_`
+ tryLoadInterface doc_str mod_name from `thenRn` \ (iface, maybe_err) ->
+
case maybe_err of {
Just err -> out_of_date (sep [ptext SLIT("Can't find version number for module"),
ppr mod_name]) ;
up_to_date (ptext SLIT("...but the bits I use haven't."))
}}
- where
- doc_str = sep [ptext SLIT("need version info for"), ppr mod_name]
------------------------
checkModuleVersion old_mod_vers new_vers
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 -> returnRn upToDate
+ | new_vers == old_vers -> traceHiDiffsRn (text "Up to date" <+> ppr name <+> parens (ppr new_vers)) `thenRn_` returnRn upToDate
| otherwise -> out_of_date (sep [ptext SLIT("Out of date:"), ppr name])
-up_to_date msg = traceRn msg `thenRn_` returnRn upToDate
-out_of_date msg = traceRn msg `thenRn_` returnRn outOfDate
+up_to_date msg = traceHiDiffsRn msg `thenRn_` returnRn upToDate
+out_of_date msg = traceHiDiffsRn msg `thenRn_` returnRn outOfDate
\end{code}
projects / ghc-hetmet.git / blobdiff