2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 \%[RnIfaces]{Cacheing and Renaming of Interfaces}
8 ( slurpImpDecls, importSupportingDecls,
9 RecompileRequired, outOfDate, upToDate, checkVersions
13 #include "HsVersions.h"
15 import CmdLineOpts ( opt_IgnoreIfacePragmas, opt_NoPruneDecls )
17 import HsSyn ( HsDecl(..), Sig(..), TyClDecl(..), ConDecl(..), HsConDetails(..),
18 InstDecl(..), HsType(..), hsTyVarNames, getBangType
20 import RdrHsSyn ( RdrNameTyClDecl, RdrNameInstDecl, RdrNameRuleDecl )
21 import RnHsSyn ( RenamedHsDecl, RenamedTyClDecl,
22 extractHsTyNames, extractHsCtxtTyNames,
23 tyClDeclFVs, ruleDeclFVs, impDeclFVs
25 import RnHiFiles ( loadInterface, loadHomeInterface, loadOrphanModules )
26 import RnNames ( mkModDeps )
27 import RnSource ( rnTyClDecl, rnInstDecl, rnIfaceRuleDecl )
28 import TcEnv ( getInGlobalScope, tcLookupGlobal_maybe )
30 import Id ( idType, idName, globalIdDetails )
31 import IdInfo ( GlobalIdDetails(..) )
32 import TcType ( tyClsNamesOfType, classNamesOfTheta )
33 import FieldLabel ( fieldLabelTyCon )
34 import DataCon ( dataConTyCon, dataConWrapId )
35 import TyCon ( visibleDataCons, isSynTyCon, getSynTyConDefn, tyConClass_maybe, tyConName )
36 import Class ( className, classSCTheta )
37 import Name ( Name {-instance NamedThing-}, isWiredInName, nameIsLocalOrFrom,
38 nameModule, NamedThing(..) )
39 import NameEnv ( delFromNameEnv, lookupNameEnv )
41 import Module ( Module, isHomeModule )
42 import PrelNames ( hasKey, fractionalClassKey, numClassKey,
43 integerTyConName, doubleTyConName )
47 import Maybe( fromJust )
51 %*********************************************************
53 \subsection{Slurping declarations}
55 %*********************************************************
58 -------------------------------------------------------
59 slurpImpDecls :: FreeVars -> TcRn m [RenamedHsDecl]
60 slurpImpDecls source_fvs
61 = traceRn (text "slurpImp" <+> fsep (map ppr (nameSetToList source_fvs))) `thenM_`
63 -- Slurp in things which might be 'gates' for instance
64 -- declarations, plus the instance declarations themselves
65 slurpSourceRefs source_fvs `thenM` \ (gate_decls, bndrs) ->
67 -- Then get everything else
69 needed = foldr (plusFV . impDeclFVs) emptyFVs gate_decls
71 import_supporting_decls (gate_decls, bndrs) needed
74 -------------------------------------------------------
75 slurpSourceRefs :: FreeVars -- Variables referenced in source
76 -> TcRn m ([RenamedHsDecl], -- Needed declarations
77 NameSet) -- Names bound by those declarations
78 -- Slurp imported declarations needed directly by the source code;
79 -- and some of the ones they need. The goal is to find all the 'gates'
80 -- for instance declarations.
82 slurpSourceRefs source_fvs
83 = go_outer [] emptyFVs -- Accumulating decls
84 (nameSetToList source_fvs) -- Things whose defn hasn't been loaded yet
86 -- The outer loop repeatedly slurps the decls for the current gates
87 -- and the instance decls
89 -- The outer loop is needed because consider
90 -- instance Foo a => Baz (Maybe a) where ...
91 -- It may be that Baz and Maybe are used in the source module,
92 -- but not Foo; so we need to chase Foo too.
94 -- We also need to follow superclass refs. In particular, 'chasing Foo' must
95 -- include actually getting in Foo's class decl
96 -- class Wib a => Foo a where ..
97 -- so that its superclasses are discovered. The point is that Wib is a gate too.
98 -- We do this for tycons too, so that we look through type synonyms.
100 go_outer decls bndrs [] = returnM (decls, bndrs)
102 go_outer decls bndrs refs -- 'refs' are not necessarily slurped yet
103 = traceRn (text "go_outer" <+> ppr refs) `thenM_`
104 foldlM go_inner (decls, bndrs, emptyFVs) refs `thenM` \ (decls1, bndrs1, gates1) ->
105 getImportedInstDecls gates1 `thenM` \ (inst_decls, new_gates) ->
106 rnIfaceDecls rnInstDecl inst_decls `thenM` \ inst_decls' ->
107 go_outer (map InstD inst_decls' ++ decls1)
109 (nameSetToList (new_gates `plusFV` plusFVs (map getInstDeclGates inst_decls')))
110 -- NB: we go round again to fetch the decls for any gates of any decls
111 -- we have loaded. For example, if we mention
112 -- print :: Show a => a -> String
113 -- then we must load the decl for Show before stopping, to ensure
114 -- that instances from its home module are available
116 go_inner (decls, bndrs, gates) wanted_name
117 = importDecl bndrs wanted_name `thenM` \ import_result ->
118 case import_result of
119 AlreadySlurped -> returnM (decls, bndrs, gates)
123 bndrs `addOneFV` wanted_name, -- Avoid repeated calls to getWiredInGates
124 gates `plusFV` getWiredInGates ty_thing)
126 HereItIs decl new_bndrs
127 -> rnIfaceDecl rnTyClDecl decl `thenM` \ new_decl ->
128 returnM (TyClD new_decl : decls,
129 bndrs `plusFV` new_bndrs,
130 gates `plusFV` getGates source_fvs new_decl)
134 -------------------------------------------------------
135 -- import_supporting_decls keeps going until the free-var set is empty
136 importSupportingDecls needed
137 = import_supporting_decls ([], emptyNameSet) needed
139 import_supporting_decls
140 :: ([RenamedHsDecl], NameSet) -- Some imported decls, with their binders
141 -> FreeVars -- Remaining un-slurped names
142 -> TcRn m [RenamedHsDecl]
143 import_supporting_decls decls needed
144 = slurpIfaceDecls decls needed `thenM` \ (decls1, bndrs1) ->
145 getImportedRules bndrs1 `thenM` \ rule_decls ->
147 [] -> returnM decls1 -- No new rules, so we are done
148 other -> rnIfaceDecls rnIfaceRuleDecl rule_decls `thenM` \ rule_decls' ->
150 rule_fvs = plusFVs (map ruleDeclFVs rule_decls')
151 decls2 = decls1 ++ map RuleD rule_decls'
153 traceRn (text "closeRules" <+> ppr rule_decls' $$
154 fsep (map ppr (nameSetToList rule_fvs))) `thenM_`
155 import_supporting_decls (decls2, bndrs1) rule_fvs
158 -------------------------------------------------------
159 -- Augment decls with any decls needed by needed,
160 -- and so on transitively
161 slurpIfaceDecls :: ([RenamedHsDecl], NameSet) -- Already slurped
162 -> FreeVars -- Still needed
163 -> TcRn m ([RenamedHsDecl], NameSet)
164 slurpIfaceDecls (decls, bndrs) needed
165 = slurp decls bndrs (nameSetToList needed)
167 slurp decls bndrs [] = returnM (decls, bndrs)
168 slurp decls bndrs (n:ns)
169 = importDecl bndrs n `thenM` \ import_result ->
170 case import_result of
171 HereItIs decl new_bndrs -- Found a declaration... rename it
172 -> rnIfaceDecl rnTyClDecl decl `thenM` \ new_decl ->
173 slurp (TyClD new_decl : decls)
174 (bndrs `plusFV` new_bndrs)
175 (nameSetToList (tyClDeclFVs new_decl) ++ ns)
178 other -> -- No declaration... (wired in thing, or deferred,
179 -- or already slurped)
180 slurp decls (bndrs `addOneFV` n) ns
182 -------------------------------------------------------
183 rnIfaceDecls rn decls = mappM (rnIfaceDecl rn) decls
184 rnIfaceDecl rn (mod, decl) = initRn (InterfaceMode mod) (rn decl)
189 -- Tiresomely, we must get the "main" name for the
190 -- thing, because that's what VSlurp contains, and what
191 -- is recorded in the usage information
192 get_main_name (AClass cl) = className cl
193 get_main_name (ADataCon dc) = tyConName (dataConTyCon dc)
194 get_main_name (ATyCon tc)
195 | Just clas <- tyConClass_maybe tc = get_main_name (AClass clas)
196 | otherwise = tyConName tc
197 get_main_name (AnId id)
198 = case globalIdDetails id of
199 DataConWorkId dc -> get_main_name (ATyCon (dataConTyCon dc))
200 DataConWrapId dc -> get_main_name (ATyCon (dataConTyCon dc))
201 RecordSelId lbl -> get_main_name (ATyCon (fieldLabelTyCon lbl))
202 GenericOpId tc -> get_main_name (ATyCon tc)
203 ClassOpId cl -> className cl
207 recordUsage :: Name -> TcRn m ()
208 -- Record that the Name has been used, for
209 -- later generation of usage info in the interface file
210 recordUsage name = updUsages (upd_usg name)
213 | isHomeModule mod = addOneToNameSet usages name
216 mod = nameModule name
220 %*********************************************************
222 \subsection{Getting in a declaration}
224 %*********************************************************
227 importDecl :: NameSet -> Name -> TcRn m ImportDeclResult
229 data ImportDeclResult
232 | HereItIs (Module, RdrNameTyClDecl) NameSet
233 -- The NameSet is the bunch of names bound by this decl
235 importDecl already_slurped name
236 = -- STEP 0: Check if it's from this module
237 -- Doing this catches a common case quickly
238 getModule `thenM` \ this_mod ->
239 if nameIsLocalOrFrom this_mod name then
240 -- Variables defined on the GHCi command line (e.g. let x = 3)
241 -- are Internal names (which don't have a Module)
242 returnM AlreadySlurped
245 -- STEP 1: Check if we've slurped it in while compiling this module
246 if name `elemNameSet` already_slurped then
247 returnM AlreadySlurped
250 -- STEP 2: Check if it's already in the type environment
251 tcLookupGlobal_maybe name `thenM` \ maybe_thing ->
252 case maybe_thing of {
256 -> -- When we find a wired-in name we must load its home
257 -- module so that we find any instance decls lurking therein
258 loadHomeInterface wi_doc name `thenM_`
259 returnM (InTypeEnv ty_thing)
262 -> -- We have slurp something that's already in the type environment,
263 -- that was not slurped in an earlier compilation.
264 -- Must still record it in the Usages info, because that's used to
265 -- generate usage information
267 traceRn (text "not wired in" <+> ppr name) `thenM_`
268 recordUsage (get_main_name ty_thing) `thenM_`
269 returnM (InTypeEnv ty_thing) ;
273 -- STEP 4: OK, we have to slurp it in from an interface file
274 -- First load the interface file
275 traceRn nd_doc `thenM_`
276 loadHomeInterface nd_doc name `thenM_`
278 -- STEP 4: Get the declaration out
279 getEps `thenM` \ eps ->
281 (decls_map, n_slurped) = eps_decls eps
283 case lookupNameEnv decls_map name of
284 Just (avail,_,decl) -> setEps eps' `thenM_`
285 recordUsage (availName avail) `thenM_`
286 returnM (HereItIs decl (mkFVs avail_names))
288 avail_names = availNames avail
289 new_decls_map = foldl delFromNameEnv decls_map avail_names
290 eps' = eps { eps_decls = (new_decls_map, n_slurped+1) }
292 Nothing -> addErr (getDeclErr name) `thenM_`
293 returnM AlreadySlurped
296 wi_doc = ptext SLIT("need home module for wired in thing") <+> ppr name
297 nd_doc = ptext SLIT("need decl for") <+> ppr name
302 %*********************************************************
304 \subsection{Extracting the `gates'}
306 %*********************************************************
310 We want to avoid sucking in too many instance declarations.
311 An instance decl is only useful if the types and classes mentioned in
312 its 'head' are all available in the program being compiled. E.g.
314 instance (..) => C (T1 a) (T2 b) where ...
316 is only useful if C, T1 and T2 are all "available". So we keep
317 instance decls that have been parsed from .hi files, but not yet
318 slurped in, in a pool called the 'gated instance pool'.
319 Each has its set of 'gates': {C, T1, T2} in the above example.
321 More precisely, the gates of a module are the types and classes
322 that are mentioned in:
324 a) the source code [Note: in fact these don't seem
325 to be treated as gates, perhaps
326 because no imported instance decl
327 can mention them; mutter mutter
329 b) the type of an Id that's mentioned in the source code
330 [includes constructors and selectors]
331 c) the RHS of a type synonym that is a gate
332 d) the superclasses of a class that is a gate
333 e) the context of an instance decl that is slurped in
335 We slurp in an instance decl from the gated instance pool iff
337 all its gates are either in the gates of the module,
338 or the gates of a previously-loaded module
340 The latter constraint is because there might have been an instance
341 decl slurped in during an earlier compilation, like this:
343 instance Foo a => Baz (Maybe a) where ...
345 In the module being compiled we might need (Baz (Maybe T)), where T is
346 defined in this module, and hence we need the instance for (Foo T).
347 So @Foo@ becomes a gate. But there's no way to 'see' that. More
348 generally, types might be involved as well:
350 instance Foo2 S a => Baz2 a where ...
352 Now we must treat S as a gate too, as well as Foo2. So the solution
355 we simply treat the gates of all previously-loaded
356 modules as gates of this one
358 So the gates are remembered across invocations of the renamer in the
359 PersistentRenamerState. This gloss mainly affects ghc --make and ghc
362 (We used to use the persistent type environment for this purpose,
363 but it has too much. For a start, it contains all tuple types,
364 because they are in the wired-in type env!)
367 Consructors and class operations
368 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
369 When we import a declaration like
371 data T = T1 Wibble | T2 Wobble
373 we don't want to treat @Wibble@ and @Wobble@ as gates {\em unless}
374 @T1@, @T2@ respectively are mentioned by the user program. If only
375 @T@ is mentioned we want only @T@ to be a gate; that way we don't suck
376 in useless instance decls for (say) @Eq Wibble@, when they can't
379 And that's just what (b) says: we only treat T1's type as a gate if
380 T1 is mentioned. getGates, which deals with decls we are slurping in,
381 has to be a bit careful, because a mention of T1 will slurp in T's whole
384 -----------------------------
385 @getGates@ takes a newly imported (and renamed) decl, and the free
386 vars of the source program, and extracts from the decl the gate names.
389 getGates :: FreeVars -- Things mentioned in the source program
390 -- Used for the cunning "constructors and
391 -- class ops" story described 10 lines above.
395 getGates source_fvs decl
396 = get_gates (\n -> n `elemNameSet` source_fvs) decl
398 get_gates is_used (ForeignType {tcdName = tycon}) = unitNameSet tycon
399 get_gates is_used (IfaceSig {tcdType = ty}) = extractHsTyNames ty
401 get_gates is_used (ClassDecl { tcdCtxt = ctxt, tcdName = cls, tcdTyVars = tvs, tcdSigs = sigs})
402 = (super_cls_and_sigs `addOneToNameSet` cls) `unionNameSets`
403 implicitClassGates cls
405 super_cls_and_sigs = delListFromNameSet (foldr (plusFV . get) (extractHsCtxtTyNames ctxt) sigs)
407 get (ClassOpSig n _ ty _)
408 | is_used n = extractHsTyNames ty
409 | otherwise = emptyFVs
411 get_gates is_used (TySynonym {tcdTyVars = tvs, tcdSynRhs = ty})
412 = delListFromNameSet (extractHsTyNames ty) (hsTyVarNames tvs)
413 -- A type synonym type constructor isn't a "gate" for instance decls
415 get_gates is_used (TyData {tcdCtxt = ctxt, tcdName = tycon, tcdTyVars = tvs, tcdCons = cons})
416 = delListFromNameSet (foldr (plusFV . get) (extractHsCtxtTyNames ctxt)
417 (visibleDataCons cons))
419 `addOneToNameSet` tycon
421 get (ConDecl n tvs ctxt details _)
423 -- If the constructor is method, get fvs from all its fields
424 = delListFromNameSet (get_details details `plusFV`
425 extractHsCtxtTyNames ctxt)
427 get (ConDecl n tvs ctxt (RecCon fields) _)
428 -- Even if the constructor isn't mentioned, the fields
429 -- might be, as selectors. They can't mention existentially
430 -- bound tyvars (typechecker checks for that) so no need for
431 -- the deleteListFromNameSet part
432 = foldr (plusFV . get_field) emptyFVs fields
434 get other_con = emptyFVs
436 get_details (PrefixCon tys) = plusFVs (map get_bang tys)
437 get_details (InfixCon t1 t2) = get_bang t1 `plusFV` get_bang t2
438 get_details (RecCon fields) = plusFVs [get_bang t | (_, t) <- fields]
440 get_field (f,t) | is_used f = get_bang t
441 | otherwise = emptyFVs
443 get_bang bty = extractHsTyNames (getBangType bty)
445 implicitClassGates :: Name -> FreeVars
446 implicitClassGates cls
447 -- If we load class Num, add Integer to the free gates
448 -- This takes account of the fact that Integer might be needed for
449 -- defaulting, but we don't want to load Integer (and all its baggage)
450 -- if there's no numeric stuff needed.
451 -- Similarly for class Fractional and Double
453 -- NB: adding T to the gates will force T to be loaded
455 -- NB: If we load (say) Floating, we'll end up loading Fractional too,
456 -- since Fractional is a superclass of Floating
457 | cls `hasKey` numClassKey = unitFV integerTyConName
458 | cls `hasKey` fractionalClassKey = unitFV doubleTyConName
459 | otherwise = emptyFVs
462 @getWiredInGates@ is just like @getGates@, but it sees a previously-loaded
463 thing rather than a declaration.
466 getWiredInGates :: TyThing -> FreeVars
467 -- The TyThing is one that we already have in our type environment, either
468 -- a) because the TyCon or Id is wired in, or
469 -- b) from a previous compile
471 -- Either way, we might have instance decls in the (persistent) collection
472 -- of parsed-but-not-slurped instance decls that should be slurped in.
473 -- This might be the first module that mentions both the type and the class
474 -- for that instance decl, even though both the type and the class were
475 -- mentioned in other modules, and hence are in the type environment
477 getWiredInGates (AClass cl)
478 = unitFV (getName cl) `plusFV` mkFVs super_classes
480 super_classes = classNamesOfTheta (classSCTheta cl)
482 getWiredInGates (AnId the_id) = tyClsNamesOfType (idType the_id)
483 getWiredInGates (ADataCon dc) = tyClsNamesOfType (idType (dataConWrapId dc))
484 getWiredInGates (ATyCon tc)
485 | isSynTyCon tc = tyClsNamesOfType ty
486 | otherwise = unitFV (getName tc)
488 (_,ty) = getSynTyConDefn tc
490 getInstDeclGates (InstDecl inst_ty _ _ _ _) = extractHsTyNames inst_ty
494 getImportedInstDecls :: NameSet -> TcRn m ([(Module,RdrNameInstDecl)], NameSet)
495 -- Returns the gates that are new since last time
496 getImportedInstDecls gates
497 = -- First, load any orphan-instance modules that aren't aready loaded
498 -- Orphan-instance modules are recorded in the module dependecnies
499 getImports `thenM` \ imports ->
500 getEps `thenM` \ eps ->
502 old_gates = eps_inst_gates eps
503 new_gates = gates `minusNameSet` old_gates
504 all_gates = new_gates `unionNameSets` old_gates
505 orphan_mods = imp_orphs imports
507 loadOrphanModules orphan_mods `thenM_`
509 -- Now we're ready to grab the instance declarations
510 -- Find the un-gated ones and return them,
511 -- removing them from the bag kept in EPS
512 -- Don't foget to get the EPS a second time...
513 -- loadOrphanModules may have side-effected it!
514 getEps `thenM` \ eps ->
516 available n = n `elemNameSet` all_gates
517 (decls, new_insts) = selectGated available (eps_insts eps)
519 setEps (eps { eps_insts = new_insts,
520 eps_inst_gates = all_gates }) `thenM_`
522 traceRn (sep [text "getImportedInstDecls:",
523 nest 4 (fsep (map ppr (nameSetToList gates))),
524 nest 4 (fsep (map ppr (nameSetToList all_gates))),
525 nest 4 (fsep (map ppr (nameSetToList new_gates))),
526 text "Slurped" <+> int (length decls) <+> text "instance declarations",
527 nest 4 (vcat (map ppr_brief_inst_decl decls))]) `thenM_`
528 returnM (decls, new_gates)
530 ppr_brief_inst_decl (mod, InstDecl inst_ty _ _ _ _)
532 HsForAllTy _ _ tau -> ppr tau
535 getImportedRules :: NameSet -- Slurped already
536 -> TcRn m [(Module,RdrNameRuleDecl)]
537 getImportedRules slurped
538 | opt_IgnoreIfacePragmas = returnM []
540 = getEps `thenM` \ eps ->
541 getInGlobalScope `thenM` \ in_type_env ->
542 let -- Slurp rules for anything that is slurped,
543 -- either now, or previously
544 available n = n `elemNameSet` slurped || in_type_env n
545 (decls, new_rules) = selectGated available (eps_rules eps)
550 setEps (eps { eps_rules = new_rules }) `thenM_`
551 traceRn (sep [text "getImportedRules:",
552 text "Slurped" <+> int (length decls) <+> text "rules"]) `thenM_`
555 selectGated :: (Name->Bool) -> GatedDecls d
556 -> ([(Module,d)], GatedDecls d)
557 selectGated available (decl_bag, n_slurped)
558 -- Select only those decls whose gates are *all* available
560 | opt_NoPruneDecls -- Just to try the effect of not gating at all
562 decls = foldrBag (\ (_,d) ds -> d:ds) [] decl_bag -- Grab them all
564 (decls, (emptyBag, n_slurped + length decls))
568 = case foldrBag select ([], emptyBag) decl_bag of
569 (decls, new_bag) -> (decls, (new_bag, n_slurped + length decls))
571 select (gate_fn, decl) (yes, no)
572 | gate_fn available = (decl:yes, no)
573 | otherwise = (yes, (gate_fn,decl) `consBag` no)
577 %********************************************************
579 \subsection{Checking usage information}
581 %********************************************************
583 @recompileRequired@ is called from the HscMain. It checks whether
584 a recompilation is required. It needs access to the persistent state,
585 finder, etc, because it may have to load lots of interface files to
586 check their versions.
589 type RecompileRequired = Bool
590 upToDate = False -- Recompile not required
591 outOfDate = True -- Recompile required
593 checkVersions :: Bool -- True <=> source unchanged
594 -> ModIface -- Old interface
595 -> TcRn m RecompileRequired
596 checkVersions source_unchanged iface
597 | not source_unchanged
600 = traceHiDiffs (text "Considering whether compilation is required for" <+>
601 ppr (mi_module iface) <> colon) `thenM_`
603 -- Source code unchanged and no errors yet... carry on
604 -- First put the dependent-module info in the envt, just temporarily,
605 -- so that when we look for interfaces we look for the right one (.hi or .hi-boot)
606 -- It's just temporary because either the usage check will succeed
607 -- (in which case we are done with this module) or it'll fail (in which
608 -- case we'll compile the module from scratch anyhow).
609 updGblEnv (\ gbl -> gbl { tcg_imports = mod_deps }) (
610 checkList [checkModUsage u | u <- mi_usages iface]
614 -- This is a bit of a hack really
615 mod_deps = emptyImportAvails { imp_dep_mods = mkModDeps (dep_mods (mi_deps iface)) }
617 checkList :: [TcRn m RecompileRequired] -> TcRn m RecompileRequired
618 checkList [] = returnM upToDate
619 checkList (check:checks) = check `thenM` \ recompile ->
627 checkModUsage :: Usage Name -> TcRn m RecompileRequired
628 -- Given the usage information extracted from the old
629 -- M.hi file for the module being compiled, figure out
630 -- whether M needs to be recompiled.
632 checkModUsage (Usage { usg_name = mod_name, usg_mod = old_mod_vers,
633 usg_rules = old_rule_vers,
634 usg_exports = maybe_old_export_vers,
635 usg_entities = old_decl_vers })
636 = -- Load the imported interface is possible
638 doc_str = sep [ptext SLIT("need version info for"), ppr mod_name]
640 traceHiDiffs (text "Checking usages for module" <+> ppr mod_name) `thenM_`
642 tryM (loadInterface doc_str mod_name ImportBySystem) `thenM` \ mb_iface ->
645 Left exn -> (out_of_date (sep [ptext SLIT("Can't find version number for module"),
647 -- Couldn't find or parse a module mentioned in the
648 -- old interface file. Don't complain -- it might just be that
649 -- the current module doesn't need that import and it's been deleted
653 new_vers = mi_version iface
654 new_mod_vers = vers_module new_vers
655 new_decl_vers = vers_decls new_vers
656 new_export_vers = vers_exports new_vers
657 new_rule_vers = vers_rules new_vers
660 checkModuleVersion old_mod_vers new_mod_vers `thenM` \ recompile ->
661 if not recompile then
666 if checkExportList maybe_old_export_vers new_export_vers then
667 out_of_date_vers (ptext SLIT(" Export list changed"))
668 (fromJust maybe_old_export_vers)
673 if old_rule_vers /= new_rule_vers then
674 out_of_date_vers (ptext SLIT(" Rules changed"))
675 old_rule_vers new_rule_vers
678 -- CHECK ITEMS ONE BY ONE
679 checkList [checkEntityUsage new_decl_vers u | u <- old_decl_vers] `thenM` \ recompile ->
681 returnM outOfDate -- This one failed, so just bail out now
683 up_to_date (ptext SLIT(" Great! The bits I use are up to date"))
687 ------------------------
688 checkModuleVersion old_mod_vers new_mod_vers
689 | new_mod_vers == old_mod_vers
690 = up_to_date (ptext SLIT("Module version unchanged"))
693 = out_of_date_vers (ptext SLIT(" Module version has changed"))
694 old_mod_vers new_mod_vers
696 ------------------------
697 checkExportList Nothing new_vers = upToDate
698 checkExportList (Just v) new_vers = v /= new_vers
700 ------------------------
701 checkEntityUsage new_vers (name,old_vers)
702 = case lookupNameEnv new_vers name of
704 Nothing -> -- We used it before, but it ain't there now
705 out_of_date (sep [ptext SLIT("No longer exported:"), ppr name])
707 Just new_vers -- It's there, but is it up to date?
708 | new_vers == old_vers -> traceHiDiffs (text " Up to date" <+> ppr name <+> parens (ppr new_vers)) `thenM_`
710 | otherwise -> out_of_date_vers (ptext SLIT(" Out of date:") <+> ppr name)
713 up_to_date msg = traceHiDiffs msg `thenM_` returnM upToDate
714 out_of_date msg = traceHiDiffs msg `thenM_` returnM outOfDate
715 out_of_date_vers msg old_vers new_vers
716 = out_of_date (hsep [msg, ppr old_vers, ptext SLIT("->"), ppr new_vers])
720 %*********************************************************
724 %*********************************************************
728 = vcat [ptext SLIT("Failed to find interface decl for") <+> quotes (ppr name),
729 ptext SLIT("from module") <+> quotes (ppr (nameModule name))