ghc/compiler/rename/RnIfaces.lhs

   1 %
   2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
   3 %
   4 \section[RnIfaces]{Cacheing and Renaming of Interfaces}
   5
   6 \begin{code}
   7 module RnIfaces
   8        (
   9         getInterfaceExports,
  10         getImportedInstDecls, getImportedRules,
  11         lookupFixityRn,
  12         importDecl, ImportDeclResult(..), recordLocalSlurps,
  13         mkImportInfo, getSlurped
  14        )
  15 where
  16
  17 #include "HsVersions.h"
  18
  19 import CmdLineOpts      ( opt_NoPruneDecls, opt_NoPruneTyDecls, opt_IgnoreIfacePragmas )
  20 import HscTypes
  21 import HsSyn            ( HsDecl(..), InstDecl(..),  HsType(..) )
  22 import HsImpExp         ( ImportDecl(..) )
  23 import BasicTypes       ( Version, defaultFixity )
  24 import RdrHsSyn         ( RdrNameHsDecl, RdrNameInstDecl )
  25 import RnHiFiles        ( tryLoadInterface, loadHomeInterface, loadInterface, loadOrphanModules )
  26 import RnEnv
  27 import RnMonad
  28 import Name             ( Name {-instance NamedThing-}, nameOccName,
  29                           nameModule, isLocallyDefined,
  30                           NamedThing(..),
  31                           elemNameEnv
  32                          )
  33 import Module           ( Module, ModuleEnv,
  34                           moduleName, isModuleInThisPackage,
  35                           ModuleName, WhereFrom(..),
  36                           emptyModuleEnv, lookupModuleEnvByName,
  37                           extendModuleEnv_C, lookupWithDefaultModuleEnv
  38                         )
  39 import NameSet
  40 import PrelInfo         ( wiredInThingEnv )
  41 import Maybes           ( orElse )
  42 import FiniteMap
  43 import Outputable
  44 import Bag
  45
  46 import List             ( nub )
  47 \end{code}
  48
  49
  50 %*********************************************************
  51 %*                                                      *
  52 \subsection{Getting what a module exports}
  53 %*                                                      *
  54 %*********************************************************
  55
  56 @getInterfaceExports@ is called only for directly-imported modules.
  57
  58 \begin{code}
  59 getInterfaceExports :: ModuleName -> WhereFrom -> RnMG (Module, Avails)
  60 getInterfaceExports mod_name from
  61   = getHomeIfaceTableRn                 `thenRn` \ hit ->
  62     case lookupModuleEnvByName hit mod_name of {
  63         Just mi -> returnRn (mi_module mi, mi_exports mi) ;
  64         Nothing  ->
  65
  66     loadInterface doc_str mod_name from `thenRn` \ ifaces ->
  67     case lookupModuleEnvByName (iPIT ifaces) mod_name of
  68         Just mi -> returnRn (mi_module mi, mi_exports mi) ;
  69                 -- loadInterface always puts something in the map
  70                 -- even if it's a fake
  71         Nothing -> pprPanic "getInterfaceExports" (ppr mod_name)
  72     }
  73     where
  74       doc_str = sep [ppr mod_name, ptext SLIT("is directly imported")]
  75 \end{code}
  76
  77
  78 %*********************************************************
  79 %*                                                      *
  80 \subsection{Instance declarations are handled specially}
  81 %*                                                      *
  82 %*********************************************************
  83
  84 \begin{code}
  85 getImportedInstDecls :: NameSet -> RnMG [(Module,RdrNameHsDecl)]
  86 getImportedInstDecls gates
  87   =     -- First, load any orphan-instance modules that aren't aready loaded
  88         -- Orphan-instance modules are recorded in the module dependecnies
  89     getIfacesRn                                         `thenRn` \ ifaces ->
  90     let
  91         orphan_mods =
  92           [mod | (mod, (True, _, False)) <- fmToList (iImpModInfo ifaces)]
  93     in
  94     loadOrphanModules orphan_mods                       `thenRn_`
  95
  96         -- Now we're ready to grab the instance declarations
  97         -- Find the un-gated ones and return them,
  98         -- removing them from the bag kept in Ifaces
  99     getIfacesRn                                         `thenRn` \ ifaces ->
 100     let
 101         (decls, new_insts) = selectGated gates (iInsts ifaces)
 102     in
 103     setIfacesRn (ifaces { iInsts = new_insts })         `thenRn_`
 104
 105     traceRn (sep [text "getImportedInstDecls:",
 106                   nest 4 (fsep (map ppr gate_list)),
 107                   text "Slurped" <+> int (length decls) <+> text "instance declarations",
 108                   nest 4 (vcat (map ppr_brief_inst_decl decls))])       `thenRn_`
 109     returnRn decls
 110   where
 111     gate_list      = nameSetToList gates
 112
 113 ppr_brief_inst_decl (mod, InstD (InstDecl inst_ty _ _ _ _))
 114   = case inst_ty of
 115         HsForAllTy _ _ tau -> ppr tau
 116         other              -> ppr inst_ty
 117
 118 getImportedRules :: RnMG [(Module,RdrNameHsDecl)]
 119 getImportedRules
 120   | opt_IgnoreIfacePragmas = returnRn []
 121   | otherwise
 122   = getIfacesRn         `thenRn` \ ifaces ->
 123     let
 124         gates              = iSlurp ifaces      -- Anything at all that's been slurped
 125         rules              = iRules ifaces
 126         (decls, new_rules) = selectGated gates rules
 127     in
 128     if null decls then
 129         returnRn []
 130     else
 131     setIfacesRn (ifaces { iRules = new_rules })              `thenRn_`
 132     traceRn (sep [text "getImportedRules:",
 133                   text "Slurped" <+> int (length decls) <+> text "rules"])   `thenRn_`
 134     returnRn decls
 135
 136 selectGated gates decl_bag
 137         -- Select only those decls whose gates are *all* in 'gates'
 138 #ifdef DEBUG
 139   | opt_NoPruneDecls    -- Just to try the effect of not gating at all
 140   = (foldrBag (\ (_,d) ds -> d:ds) [] decl_bag, emptyBag)       -- Grab them all
 141
 142   | otherwise
 143 #endif
 144   = foldrBag select ([], emptyBag) decl_bag
 145   where
 146     select (reqd, decl) (yes, no)
 147         | isEmptyNameSet (reqd `minusNameSet` gates) = (decl:yes, no)
 148         | otherwise                                  = (yes,      (reqd,decl) `consBag` no)
 149
 150 lookupFixityRn :: Name -> RnMS Fixity
 151 lookupFixityRn name
 152   | isLocallyDefined name
 153   = getFixityEnv                        `thenRn` \ local_fix_env ->
 154     returnRn (lookupLocalFixity local_fix_env name)
 155
 156   | otherwise   -- Imported
 157       -- For imported names, we have to get their fixities by doing a loadHomeInterface,
 158       -- and consulting the Ifaces that comes back from that, because the interface
 159       -- file for the Name might not have been loaded yet.  Why not?  Suppose you import module A,
 160       -- which exports a function 'f', which is defined in module B.  Then B isn't loaded
 161       -- right away (after all, it's possible that nothing from B will be used).
 162       -- When we come across a use of 'f', we need to know its fixity, and it's then,
 163       -- and only then, that we load B.hi.  That is what's happening here.
 164   = getHomeIfaceTableRn                 `thenRn` \ hit ->
 165     loadHomeInterface doc name          `thenRn` \ ifaces ->
 166     case lookupTable hit (iPIT ifaces) name of
 167         Just iface -> returnRn (lookupNameEnv (mi_fixities iface) name `orElse` defaultFixity)
 168         Nothing    -> returnRn defaultFixity
 169   where
 170     doc = ptext SLIT("Checking fixity for") <+> ppr name
 171 \end{code}
 172
 173
 174 %*********************************************************
 175 %*                                                      *
 176 \subsection{Keeping track of what we've slurped, and version numbers}
 177 %*                                                      *
 178 %*********************************************************
 179
 180 getImportVersions figures out what the ``usage information'' for this
 181 moudule is; that is, what it must record in its interface file as the
 182 things it uses.  It records:
 183
 184 \begin{itemize}
 185 \item   (a) anything reachable from its body code
 186 \item   (b) any module exported with a @module Foo@
 187 \item   (c) anything reachable from an exported item
 188 \end{itemize}
 189
 190 Why (b)?  Because if @Foo@ changes then this module's export list
 191 will change, so we must recompile this module at least as far as
 192 making a new interface file --- but in practice that means complete
 193 recompilation.
 194
 195 Why (c)?  Consider this:
 196 \begin{verbatim}
 197         module A( f, g ) where  |       module B( f ) where
 198           import B( f )         |         f = h 3
 199           g = ...               |         h = ...
 200 \end{verbatim}
 201
 202 Here, @B.f@ isn't used in A.  Should we nevertheless record @B.f@ in
 203 @A@'s usages?  Our idea is that we aren't going to touch A.hi if it is
 204 *identical* to what it was before.  If anything about @B.f@ changes
 205 than anyone who imports @A@ should be recompiled in case they use
 206 @B.f@ (they'll get an early exit if they don't).  So, if anything
 207 about @B.f@ changes we'd better make sure that something in A.hi
 208 changes, and the convenient way to do that is to record the version
 209 number @B.f@ in A.hi in the usage list.  If B.f changes that'll force a
 210 complete recompiation of A, which is overkill but it's the only way to
 211 write a new, slightly different, A.hi.
 212
 213 But the example is tricker.  Even if @B.f@ doesn't change at all,
 214 @B.h@ may do so, and this change may not be reflected in @f@'s version
 215 number.  But with -O, a module that imports A must be recompiled if
 216 @B.h@ changes!  So A must record a dependency on @B.h@.  So we treat
 217 the occurrence of @B.f@ in the export list *just as if* it were in the
 218 code of A, and thereby haul in all the stuff reachable from it.
 219
 220 [NB: If B was compiled with -O, but A isn't, we should really *still*
 221 haul in all the unfoldings for B, in case the module that imports A *is*
 222 compiled with -O.  I think this is the case.]
 223
 224 Even if B is used at all we get a usage line for B
 225         import B <n> :: ... ;
 226 in A.hi, to record the fact that A does import B.  This is used to decide
 227 to look to look for B.hi rather than B.hi-boot when compiling a module that
 228 imports A.  This line says that A imports B, but uses nothing in it.
 229 So we'll get an early bale-out when compiling A if B's version changes.
 230
 231 \begin{code}
 232 mkImportInfo :: ModuleName                      -- Name of this module
 233              -> [ImportDecl n]                  -- The import decls
 234              -> RnMG [ImportVersion Name]
 235
 236 mkImportInfo this_mod imports
 237   = getIfacesRn                                 `thenRn` \ ifaces ->
 238     getHomeIfaceTableRn                         `thenRn` \ hit ->
 239     let
 240         import_all_mods :: [ModuleName]
 241                 -- Modules where we imported all the names
 242                 -- (apart from hiding some, perhaps)
 243         import_all_mods = nub [ m | ImportDecl m _ _ _ imp_list _ <- imports,
 244                                     import_all imp_list ]
 245
 246         import_all (Just (False, _)) = False    -- Imports are specified explicitly
 247         import_all other             = True     -- Everything is imported
 248
 249         mod_map   = iImpModInfo ifaces
 250         imp_names = iVSlurp     ifaces
 251         pit       = iPIT        ifaces
 252
 253         -- mv_map groups together all the things imported from a particular module.
 254         mv_map :: ModuleEnv [Name]
 255         mv_map = foldr add_mv emptyModuleEnv imp_names
 256
 257         add_mv name mv_map = addItem mv_map (nameModule name) name
 258
 259         -- Build the result list by adding info for each module.
 260         -- For (a) a library module, we don't record it at all unless it contains orphans
 261         --         (We must never lose track of orphans.)
 262         --
 263         --     (b) a source-imported module, don't record the dependency at all
 264         --
 265         -- (b) may seem a bit strange.  The idea is that the usages in a .hi file records
 266         -- *all* the module's dependencies other than the loop-breakers.  We use
 267         -- this info in findAndReadInterface to decide whether to look for a .hi file or
 268         -- a .hi-boot file.
 269         --
 270         -- This means we won't track version changes, or orphans, from .hi-boot files.
 271         -- The former is potentially rather bad news.  It could be fixed by recording
 272         -- whether something is a boot file along with the usage info for it, but
 273         -- I can't be bothered just now.
 274
 275         mk_imp_info mod_name (has_orphans, is_boot, opened) so_far
 276            | mod_name == this_mod       -- Check if M appears in the set of modules 'below' M
 277                                         -- This seems like a convenient place to check
 278            = WARN( not is_boot, ptext SLIT("Wierd:") <+> ppr this_mod <+>
 279                                 ptext SLIT("imports itself (perhaps indirectly)") )
 280              so_far
 281
 282            | not opened                 -- We didn't even open the interface
 283            =            -- This happens when a module, Foo, that we explicitly imported has
 284                         -- 'import Baz' in its interface file, recording that Baz is below
 285                         -- Foo in the module dependency hierarchy.  We want to propagate this
 286                         -- information.  The Nothing says that we didn't even open the interface
 287                         -- file but we must still propagate the dependency info.
 288                         -- The module in question must be a local module (in the same package)
 289              go_for_it NothingAtAll
 290
 291
 292            | is_lib_module && not has_orphans
 293            = so_far
 294
 295            | is_lib_module                      -- Record the module version only
 296            = go_for_it (Everything module_vers)
 297
 298            | otherwise
 299            = go_for_it whats_imported
 300
 301              where
 302                 go_for_it exports = (mod_name, has_orphans, is_boot, exports) : so_far
 303                 mod_iface         = lookupIface hit pit mod_name
 304                 mod               = mi_module mod_iface
 305                 is_lib_module     = not (isModuleInThisPackage mod)
 306                 version_info      = mi_version mod_iface
 307                 version_env       = vers_decls version_info
 308                 module_vers       = vers_module version_info
 309
 310                 whats_imported = Specifically module_vers
 311                                               export_vers import_items
 312                                               (vers_rules version_info)
 313
 314                 import_items = [(n,v) | n <- lookupWithDefaultModuleEnv mv_map [] mod,
 315                                         let v = lookupNameEnv version_env n `orElse`
 316                                                 pprPanic "mk_whats_imported" (ppr n)
 317                                ]
 318                 export_vers | moduleName mod `elem` import_all_mods
 319                             = Just (vers_exports version_info)
 320                             | otherwise
 321                             = Nothing
 322
 323         import_info = foldFM mk_imp_info [] mod_map
 324     in
 325     traceRn (text "Modules in Ifaces: " <+> fsep (map ppr (keysFM mod_map)))    `thenRn_`
 326     returnRn import_info
 327
 328
 329 addItem :: ModuleEnv [a] -> Module -> a -> ModuleEnv [a]
 330 addItem fm mod x = extendModuleEnv_C add_item fm mod [x]
 331                  where
 332                    add_item xs _ = x:xs
 333 \end{code}
 334
 335 \begin{code}
 336 getSlurped
 337   = getIfacesRn         `thenRn` \ ifaces ->
 338     returnRn (iSlurp ifaces)
 339
 340 recordSlurp ifaces@(Ifaces { iSlurp = slurped_names, iVSlurp = imp_names })
 341             avail
 342   = let
 343         new_slurped_names = addAvailToNameSet slurped_names avail
 344         new_imp_names     = availName avail : imp_names
 345     in
 346     ifaces { iSlurp  = new_slurped_names, iVSlurp = new_imp_names }
 347
 348 recordLocalSlurps local_avails
 349   = getIfacesRn         `thenRn` \ ifaces ->
 350     let
 351         new_slurped_names = foldl addAvailToNameSet (iSlurp ifaces) local_avails
 352     in
 353     setIfacesRn (ifaces { iSlurp  = new_slurped_names })
 354 \end{code}
 355
 356
 357 %*********************************************************
 358 %*                                                      *
 359 \subsection{Getting in a declaration}
 360 %*                                                      *
 361 %*********************************************************
 362
 363 \begin{code}
 364 importDecl :: Name -> RnMG ImportDeclResult
 365
 366 data ImportDeclResult
 367   = AlreadySlurped
 368   | WiredIn
 369   | Deferred
 370   | HereItIs (Module, RdrNameHsDecl)
 371
 372 importDecl name
 373   =     -- Check if it was loaded before beginning this module
 374     checkAlreadyAvailable name          `thenRn` \ done ->
 375     if done then
 376         returnRn AlreadySlurped
 377     else
 378
 379         -- Check if we slurped it in while compiling this module
 380     getIfacesRn                         `thenRn` \ ifaces ->
 381     if name `elemNameSet` iSlurp ifaces then
 382         returnRn AlreadySlurped
 383     else
 384
 385         -- Don't slurp in decls from this module's own interface file
 386         -- (Indeed, this shouldn't happen.)
 387     if isLocallyDefined name then
 388         addWarnRn (importDeclWarn name) `thenRn_`
 389         returnRn AlreadySlurped
 390     else
 391
 392         -- When we find a wired-in name we must load its home
 393         -- module so that we find any instance decls lurking therein
 394     if name `elemNameEnv` wiredInThingEnv then
 395         loadHomeInterface doc name      `thenRn_`
 396         returnRn WiredIn
 397
 398     else getNonWiredInDecl name
 399   where
 400     doc = ptext SLIT("need home module for wired in thing") <+> ppr name
 401
 402 getNonWiredInDecl :: Name -> RnMG ImportDeclResult
 403 getNonWiredInDecl needed_name
 404   = traceRn doc_str                             `thenRn_`
 405     loadHomeInterface doc_str needed_name       `thenRn` \ ifaces ->
 406     case lookupNameEnv (iDecls ifaces) needed_name of
 407
 408 {-              OMIT DEFERRED STUFF FOR NOW, TILL GHCI WORKS
 409       Just (version, avail, is_tycon_name, decl@(_, TyClD (TyData DataType _ _ _ _ ncons _ _ _ _)))
 410         -- This case deals with deferred import of algebraic data types
 411
 412         |  not opt_NoPruneTyDecls
 413
 414         && (opt_IgnoreIfacePragmas || ncons > 1)
 415                 -- We only defer if imported interface pragmas are ingored
 416                 -- or if it's not a product type.
 417                 -- Sole reason: The wrapper for a strict function may need to look
 418                 -- inside its arg, and hence need to see its arg type's constructors.
 419
 420         && not (getUnique tycon_name `elem` cCallishTyKeys)
 421                 -- Never defer ccall types; we have to unbox them,
 422                 -- and importing them does no harm
 423
 424
 425         ->      -- OK, so we're importing a deferrable data type
 426             if needed_name == tycon_name
 427                 -- The needed_name is the TyCon of a data type decl
 428                 -- Record that it's slurped, put it in the deferred set
 429                 -- and don't return a declaration at all
 430                 setIfacesRn (recordSlurp (ifaces {iDeferred = iDeferred ifaces
 431                                                               `addOneToNameSet` tycon_name})
 432                                          version (AvailTC needed_name [needed_name]))   `thenRn_`
 433                 returnRn Deferred
 434
 435             else
 436                 -- The needed name is a constructor of a data type decl,
 437                 -- getting a constructor, so remove the TyCon from the deferred set
 438                 -- (if it's there) and return the full declaration
 439                 setIfacesRn (recordSlurp (ifaces {iDeferred = iDeferred ifaces
 440                                                                `delFromNameSet` tycon_name})
 441                                     version avail)      `thenRn_`
 442                 returnRn (HereItIs decl)
 443         where
 444            tycon_name = availName avail
 445 -}
 446
 447       Just (avail,_,decl)
 448         -> setIfacesRn (recordSlurp ifaces avail)       `thenRn_`
 449            returnRn (HereItIs decl)
 450
 451       Nothing
 452         -> addErrRn (getDeclErr needed_name)    `thenRn_`
 453            returnRn AlreadySlurped
 454   where
 455      doc_str = ptext SLIT("need decl for") <+> ppr needed_name
 456
 457 {-              OMIT FOR NOW
 458 getDeferredDecls :: RnMG [(Module, RdrNameHsDecl)]
 459 getDeferredDecls
 460   = getIfacesRn         `thenRn` \ ifaces ->
 461     let
 462         decls_map           = iDecls ifaces
 463         deferred_names      = nameSetToList (iDeferred ifaces)
 464         get_abstract_decl n = case lookupNameEnv decls_map n of
 465                                  Just (_, _, _, decl) -> decl
 466     in
 467     traceRn (sep [text "getDeferredDecls", nest 4 (fsep (map ppr deferred_names))])     `thenRn_`
 468     returnRn (map get_abstract_decl deferred_names)
 469 -}
 470 \end{code}
 471
 472 @getWiredInDecl@ maps a wired-in @Name@ to what it makes available.
 473 It behaves exactly as if the wired in decl were actually in an interface file.
 474 Specifically,
 475 \begin{itemize}
 476 \item   if the wired-in name is a data type constructor or a data constructor,
 477         it brings in the type constructor and all the data constructors; and
 478         marks as ``occurrences'' any free vars of the data con.
 479
 480 \item   similarly for synonum type constructor
 481
 482 \item   if the wired-in name is another wired-in Id, it marks as ``occurrences''
 483         the free vars of the Id's type.
 484
 485 \item   it loads the interface file for the wired-in thing for the
 486         sole purpose of making sure that its instance declarations are available
 487 \end{itemize}
 488 All this is necessary so that we know all types that are ``in play'', so
 489 that we know just what instances to bring into scope.
 490
 491
 492 %********************************************************
 493 %*                                                      *
 494 \subsection{Checking usage information}
 495 %*                                                      *
 496 %********************************************************
 497
 498 \begin{code}
 499 type RecompileRequired = Bool
 500 upToDate  = False       -- Recompile not required
 501 outOfDate = True        -- Recompile required
 502
 503 recompileRequired :: Module -> Bool -> Maybe ModIface -> RnMG RecompileRequired
 504 recompileRequired mod source_unchanged maybe_iface
 505   = traceRn (text "Considering whether compilation is required for" <+> ppr mod <> colon)       `thenRn_`
 506
 507         -- CHECK WHETHER THE SOURCE HAS CHANGED
 508     if not source_unchanged then
 509         traceRn (nest 4 (text "Source file changed or recompilation check turned off")) `thenRn_`
 510         returnRn outOfDate
 511     else
 512
 513         -- CHECK WHETHER WE HAVE AN OLD IFACE
 514     case maybe_iface of
 515         Nothing -> traceRn (nest 4 (ptext SLIT("No old interface file")))       `thenRn_`
 516                    returnRn outOfDate ;
 517
 518         Just iface  ->          -- Source code unchanged and no errors yet... carry on
 519                         getHomeIfaceTableRn                                     `thenRn` \ hit ->
 520                         checkList [checkModUsage hit u | u <- mi_usages iface]
 521
 522 checkList :: [RnMG RecompileRequired] -> RnMG RecompileRequired
 523 checkList []             = returnRn upToDate
 524 checkList (check:checks) = check        `thenRn` \ recompile ->
 525                            if recompile then
 526                                 returnRn outOfDate
 527                            else
 528                                 checkList checks
 529 \end{code}
 530
 531 \begin{code}
 532 checkModUsage :: HomeIfaceTable -> ImportVersion Name -> RnMG RecompileRequired
 533 -- Given the usage information extracted from the old
 534 -- M.hi file for the module being compiled, figure out
 535 -- whether M needs to be recompiled.
 536
 537 checkModUsage hit (mod_name, _, _, NothingAtAll)
 538         -- If CurrentModule.hi contains
 539         --      import Foo :: ;
 540         -- then that simply records that Foo lies below CurrentModule in the
 541         -- hierarchy, but CurrentModule doesn't depend in any way on Foo.
 542         -- In this case we don't even want to open Foo's interface.
 543   = up_to_date (ptext SLIT("Nothing used from:") <+> ppr mod_name)
 544
 545 checkModUsage hit (mod_name, _, _, whats_imported)
 546   = tryLoadInterface doc_str mod_name ImportBySystem    `thenRn` \ (ifaces, maybe_err) ->
 547     case maybe_err of {
 548         Just err -> out_of_date (sep [ptext SLIT("Can't find version number for module"),
 549                                       ppr mod_name]) ;
 550                 -- Couldn't find or parse a module mentioned in the
 551                 -- old interface file.  Don't complain -- it might just be that
 552                 -- the current module doesn't need that import and it's been deleted
 553
 554         Nothing ->
 555     let
 556         mod_details   = lookupTableByModName hit (iPIT ifaces) mod_name
 557                         `orElse` panic "checkModUsage"
 558         new_vers      = mi_version mod_details
 559         new_decl_vers = vers_decls new_vers
 560     in
 561     case whats_imported of {    -- NothingAtAll dealt with earlier
 562
 563       Everything old_mod_vers -> checkModuleVersion old_mod_vers new_vers       `thenRn` \ recompile ->
 564                                  if recompile then
 565                                         out_of_date (ptext SLIT("...and I needed the whole module"))
 566                                  else
 567                                         returnRn upToDate ;
 568
 569       Specifically old_mod_vers maybe_old_export_vers old_decl_vers old_rule_vers ->
 570
 571         -- CHECK MODULE
 572     checkModuleVersion old_mod_vers new_vers    `thenRn` \ recompile ->
 573     if not recompile then
 574         returnRn upToDate
 575     else
 576
 577         -- CHECK EXPORT LIST
 578     if checkExportList maybe_old_export_vers new_vers then
 579         out_of_date (ptext SLIT("Export list changed"))
 580     else
 581
 582         -- CHECK RULES
 583     if old_rule_vers /= vers_rules new_vers then
 584         out_of_date (ptext SLIT("Rules changed"))
 585     else
 586
 587         -- CHECK ITEMS ONE BY ONE
 588     checkList [checkEntityUsage new_decl_vers u | u <- old_decl_vers]   `thenRn` \ recompile ->
 589     if recompile then
 590         returnRn outOfDate      -- This one failed, so just bail out now
 591     else
 592         up_to_date (ptext SLIT("...but the bits I use haven't."))
 593
 594     }}
 595   where
 596     doc_str = sep [ptext SLIT("need version info for"), ppr mod_name]
 597
 598 ------------------------
 599 checkModuleVersion old_mod_vers new_vers
 600   | vers_module new_vers == old_mod_vers
 601   = up_to_date (ptext SLIT("Module version unchanged"))
 602
 603   | otherwise
 604   = out_of_date (ptext SLIT("Module version has changed"))
 605
 606 ------------------------
 607 checkExportList Nothing  new_vers = upToDate
 608 checkExportList (Just v) new_vers = v /= vers_exports new_vers
 609
 610 ------------------------
 611 checkEntityUsage new_vers (name,old_vers)
 612   = case lookupNameEnv new_vers name of
 613
 614         Nothing       ->        -- We used it before, but it ain't there now
 615                           out_of_date (sep [ptext SLIT("No longer exported:"), ppr name])
 616
 617         Just new_vers   -- It's there, but is it up to date?
 618           | new_vers == old_vers -> returnRn upToDate
 619           | otherwise            -> out_of_date (sep [ptext SLIT("Out of date:"), ppr name])
 620
 621 up_to_date  msg = traceRn msg `thenRn_` returnRn upToDate
 622 out_of_date msg = traceRn msg `thenRn_` returnRn outOfDate
 623 \end{code}
 624
 625
 626 %*********************************************************
 627 %*                                                       *
 628 \subsection{Errors}
 629 %*                                                       *
 630 %*********************************************************
 631
 632 \begin{code}
 633 getDeclErr name
 634   = vcat [ptext SLIT("Failed to find interface decl for") <+> quotes (ppr name),
 635           ptext SLIT("from module") <+> quotes (ppr (nameModule name))
 636          ]
 637
 638 importDeclWarn name
 639   = sep [ptext SLIT(
 640     "Compiler tried to import decl from interface file with same name as module."),
 641          ptext SLIT(
 642     "(possible cause: module name clashes with interface file already in scope.)")
 643         ] $$
 644     hsep [ptext SLIT("name:"), quotes (ppr name)]
 645 \end{code}