[project @ 2000-10-25 15:57:33 by simonpj]
[ghc-hetmet.git] / ghc / compiler / rename / Rename.lhs
index cf67969..eb18d9d 100644 (file)
 \section[Rename]{Renaming and dependency analysis passes}
 
 \begin{code}
-module Rename ( renameModule ) where
+module Rename ( renameModule, closeIfaceDecls ) where
 
 #include "HsVersions.h"
 
 import HsSyn
-import HsPragmas       ( DataPragmas(..) )
-import RdrHsSyn                ( RdrNameHsModule, RdrNameHsDecl, RdrNameDeprecation )
-import RnHsSyn         ( RenamedHsModule, RenamedHsDecl, 
-                         extractHsTyNames, extractHsCtxtTyNames
+import RdrHsSyn                ( RdrNameHsModule, RdrNameHsDecl, RdrNameDeprecation, 
+                         RdrNameTyClDecl, RdrNameRuleDecl, RdrNameInstDecl
+                       )
+import RnHsSyn         ( RenamedHsDecl, RenamedTyClDecl, RenamedRuleDecl, RenamedInstDecl,
+                         extractHsTyNames, 
+                         instDeclFVs, tyClDeclFVs, ruleDeclFVs
                        )
 
-import CmdLineOpts     ( dopt_D_dump_rn_trace, dopt_D_dump_minimal_imports,
-                         opt_D_dump_rn, opt_D_dump_rn_stats, opt_WarnDeprecations,
-                         opt_WarnUnusedBinds
-                       )
+import CmdLineOpts     ( DynFlags, DynFlag(..) )
 import RnMonad
 import RnNames         ( getGlobalNames )
-import RnSource                ( rnSourceDecls, rnDecl )
-import RnIfaces                ( getImportedInstDecls, importDecl, mkImportExportInfo, getInterfaceExports,
-                         getImportedRules, getSlurped, removeContext,
-                         loadBuiltinRules, getDeferredDecls, ImportDeclResult(..)
+import RnSource                ( rnSourceDecls, rnTyClDecl, rnIfaceRuleDecl, rnInstDecl )
+import RnIfaces                ( slurpImpDecls, mkImportInfo, 
+                         getInterfaceExports, closeDecls,
+                         RecompileRequired, recompileRequired
                        )
+import RnHiFiles       ( findAndReadIface, removeContext, loadExports, loadFixDecls, loadDeprecs )
 import RnEnv           ( availName, availsToNameSet, 
-                         emptyAvailEnv, unitAvailEnv, availEnvElts, plusAvailEnv, 
+                         emptyAvailEnv, unitAvailEnv, availEnvElts, plusAvailEnv, groupAvails,
                          warnUnusedImports, warnUnusedLocalBinds, warnUnusedModules,
-                         lookupOrigNames, unknownNameErr,
-                         FreeVars, plusFVs, plusFV, unitFV, emptyFVs, isEmptyFVs, addOneFV
+                         lookupOrigNames, lookupGlobalRn, newGlobalName
                        )
 import Module           ( Module, ModuleName, WhereFrom(..),
-                         moduleNameUserString, mkSearchPath, moduleName, mkThisModule
+                         moduleNameUserString, moduleName, 
+                         lookupModuleEnv
                        )
 import Name            ( Name, isLocallyDefined, NamedThing(..), getSrcLoc,
-                         nameOccName, nameUnique, nameModule, maybeUserImportedFrom,
-                         isUserImportedExplicitlyName, isUserImportedName,
-                         maybeWiredInTyConName, maybeWiredInIdName,
-                         isUserExportedName, toRdrName,
-                         nameEnvElts, extendNameEnv
+                         nameOccName, nameModule,
+                         mkNameEnv, nameEnvElts, extendNameEnv
                        )
-import OccName         ( occNameFlavour, isValOcc )
-import Id              ( idType )
-import TyCon           ( isSynTyCon, getSynTyConDefn )
+import OccName         ( occNameFlavour )
 import NameSet
-import TysWiredIn      ( unitTyCon, intTyCon, doubleTyCon, boolTyCon )
-import PrelRules       ( builtinRules )
+import TysWiredIn      ( unitTyCon, intTyCon, boolTyCon )
 import PrelNames       ( mAIN_Name, pREL_MAIN_Name, pRELUDE_Name,
                          ioTyCon_RDR,
                          unpackCString_RDR, unpackCStringFoldr_RDR, unpackCStringUtf8_RDR,
                          eqString_RDR
                        )
-import PrelInfo                ( fractionalClassKeys, derivingOccurrences )
-import Type            ( namesOfType, funTyCon )
-import ErrUtils                ( printErrorsAndWarnings, dumpIfSet, ghcExit )
-import BasicTypes      ( Version, initialVersion )
-import Bag             ( isEmptyBag, bagToList )
+import PrelInfo                ( derivingOccurrences )
+import Type            ( funTyCon )
+import ErrUtils                ( dumpIfSet )
+import Bag             ( bagToList )
 import FiniteMap       ( FiniteMap, eltsFM, fmToList, emptyFM, lookupFM, 
                          addToFM_C, elemFM, addToFM
                        )
-import UniqSupply      ( UniqSupply )
 import UniqFM          ( lookupUFM )
-import SrcLoc          ( noSrcLoc )
-import Maybes          ( maybeToBool, expectJust )
+import Maybes          ( maybeToBool, catMaybes )
 import Outputable
 import IO              ( openFile, IOMode(..) )
+import HscTypes                ( Finder, PersistentCompilerState, HomeIfaceTable, HomeSymbolTable, 
+                         ModIface(..), WhatsImported(..), 
+                         VersionInfo(..), ImportVersion, IfaceDecls(..),
+                         GlobalRdrEnv, AvailEnv, Avails, GenAvailInfo(..), AvailInfo, 
+                         Provenance(..), ImportReason(..), initialVersionInfo,
+                         Deprecations(..), lookupDeprec
+                        )
+import List            ( partition, nub )
 \end{code}
 
 
 
+%*********************************************************
+%*                                                      *
+\subsection{The main function: rename}
+%*                                                      *
+%*********************************************************
+
 \begin{code}
-type RenameResult = ( PersistentCompilerState,
-                   , Module            -- This module
-                   , RenamedHsModule   -- Renamed module
-                   , Maybe ParsedIface -- The existing interface file, if any
-                   , ParsedIface       -- The new interface
-                   , [Module])         -- Imported modules
-                  
-renameModule :: PersistentCompilerState -> HomeSymbolTable
-            -> RdrNameHsModule -> IO (Maybe RenameResult)
-renameModule old_pcs hst this_mod@(HsModule mod_name vers exports imports local_decls _ loc)
+renameModule :: DynFlags -> Finder 
+            -> HomeIfaceTable -> HomeSymbolTable
+            -> PersistentCompilerState 
+            -> Module -> RdrNameHsModule 
+            -> IO (PersistentCompilerState, Maybe (ModIface, [RenamedHsDecl]))
+       -- Nothing => some error occurred in the renamer
+
+renameModule dflags finder hit hst old_pcs this_module rdr_module
   =    -- Initialise the renamer monad
     do {
-       ((maybe_rn_stuff, dump_action), msgs, new_pcs) 
-          <- initRn dflags finder old_pcs hst loc (rename this_mod) ;
-
-       -- Check for warnings
-       printErrorsAndWarnings msgs ;
-
-       -- Dump any debugging output
-       dump_action ;
+       (new_pcs, errors_found, maybe_rn_stuff) 
+          <- initRn dflags finder hit hst old_pcs this_module (rename this_module rdr_module) ;
 
-       -- Return results
-       if not (isEmptyBag rn_errs_bag) then
-           return (old_pcs, Nothing)
+       -- Return results.  No harm in updating the PCS
+       if errors_found then
+           return (new_pcs, Nothing)
         else
            return (new_pcs, maybe_rn_stuff)
     }
 \end{code}
 
 \begin{code}
-rename :: RdrNameHsModule -> RnMG (Maybe RenameResult, IO ())
-rename this_mod@(HsModule mod_name vers exports imports local_decls mod_deprec loc)
+rename :: Module -> RdrNameHsModule -> RnMG (Maybe (ModIface, [RenamedHsDecl]))
+rename this_module this_mod@(HsModule mod_name vers exports imports local_decls mod_deprec loc)
   =    -- FIND THE GLOBAL NAME ENVIRONMENT
     getGlobalNames this_mod                    `thenRn` \ maybe_stuff ->
 
        -- CHECK FOR EARLY EXIT
     case maybe_stuff of {
        Nothing ->      -- Everything is up to date; no need to recompile further
-               rnDump [] []            `thenRn` \ dump_action ->
-               returnRn (Nothing, dump_action) ;
+               rnDump [] []            `thenRn_`
+               returnRn Nothing ;
 
-       Just (gbl_env, local_gbl_env, export_avails, global_avail_env, old_iface) ->
+       Just (gbl_env, local_gbl_env, export_avails, global_avail_env) ->
 
        -- DEAL WITH DEPRECATIONS
-    rnDeprecs local_gbl_env mod_deprec local_decls     `thenRn` \ my_deprecs ->
+    rnDeprecs local_gbl_env mod_deprec 
+             [d | DeprecD d <- local_decls]            `thenRn` \ my_deprecs ->
 
        -- DEAL WITH LOCAL FIXITIES
     fixitiesFromLocalDecls local_gbl_env local_decls   `thenRn` \ local_fixity_env ->
@@ -142,67 +140,48 @@ rename this_mod@(HsModule mod_name vers exports imports local_decls mod_deprec l
                -- when compiling the prelude, locally-defined (), Bool, etc
                -- override the implicit ones. 
     in
-    loadBuiltinRules builtinRules      `thenRn_`
     slurpImpDecls slurp_fvs            `thenRn` \ rn_imp_decls ->
 
        -- EXIT IF ERRORS FOUND
-    rnDump rn_imp_decls rn_local_decls         `thenRn` \ dump_action ->
+    rnDump rn_imp_decls rn_local_decls         `thenRn_` 
     checkErrsRn                                        `thenRn` \ no_errs_so_far ->
     if not no_errs_so_far then
        -- Found errors already, so exit now
-       returnRn (Nothing, dump_action)
+       returnRn Nothing
     else
 
        -- GENERATE THE VERSION/USAGE INFO
-    mkImportExportInfo mod_name export_avails exports  `thenRn` \ (my_exports, my_usages) ->
+    mkImportInfo mod_name imports      `thenRn` \ my_usages ->
 
        -- RETURN THE RENAMED MODULE
     getNameSupplyRn                    `thenRn` \ name_supply ->
     getIfacesRn                        `thenRn` \ ifaces ->
     let
-       direct_import_mods :: [Module]
-       direct_import_mods = [m | (_, _, Just (m, _, _, _, imp, _))
-                                 <- eltsFM (iImpModInfo ifaces), user_import imp]
-
-               -- *don't* just pick the forward edges.  It's entirely possible
-               -- that a module is only reachable via back edges.
-       user_import ImportByUser = True
-       user_import ImportByUserSource = True
-       user_import _ = False
-
-       this_module        = mkThisModule mod_name
-
-       -- Export only those fixities that are for names that are
-       --      (a) defined in this module
-       --      (b) exported
-       exported_fixities
-         = [ FixitySig (toRdrName name) fixity loc
-           | FixitySig name fixity loc <- nameEnvElts local_fixity_env,
-             isUserExportedName name
-           ]
-
-       new_iface = ParsedIface { pi_mod     = this_module
-                               , pi_vers    = initialVersion
-                               , pi_orphan  = any isOrphanDecl rn_local_decls
-                               , pi_exports = my_exports
-                               , pi_usages  = my_usages
-                               , pi_fixity  = (initialVersion, exported_fixities)
-                               , pi_deprecs = my_deprecs
-                                       -- These ones get filled in later
-                               , pi_insts = [], pi_decls = []
-                               , pi_rules = (initialVersion, [])
-                       }
+       direct_import_mods :: [ModuleName]
+       direct_import_mods = nub [m | ImportDecl m _ _ _ _ _ <- imports]
+
+       -- We record fixities even for things that aren't exported,
+       -- so that we can change into the context of this moodule easily
+       fixities = mkNameEnv [ (name, fixity)
+                            | FixitySig name fixity loc <- nameEnvElts local_fixity_env
+                            ]
+
+
+       -- Sort the exports to make them easier to compare for versions
+       my_exports = groupAvails export_avails
        
-       renamed_module = HsModule mod_name vers 
-                                 trashed_exports trashed_imports
-                                 (rn_local_decls ++ rn_imp_decls)
-                                 mod_deprec
-                                 loc
-
-       result = (this_module,   renamed_module, 
-                 old_iface,   new_iface,
-                 name_supply, local_fixity_env,
-                 direct_import_mods)
+       mod_iface = ModIface {  mi_module   = this_module,
+                               mi_version  = initialVersionInfo,
+                               mi_orphan   = any isOrphanDecl rn_local_decls,
+                               mi_exports  = my_exports,
+                               mi_globals  = gbl_env,
+                               mi_usages   = my_usages,
+                               mi_fixities = fixities,
+                               mi_deprecs  = my_deprecs,
+                               mi_decls    = panic "mi_decls"
+                   }
+
+       final_decls = rn_local_decls ++ rn_imp_decls
     in
 
        -- REPORT UNUSED NAMES, AND DEBUG DUMP 
@@ -211,10 +190,8 @@ rename this_mod@(HsModule mod_name vers exports imports local_decls mod_deprec l
                      export_avails source_fvs
                      rn_imp_decls                      `thenRn_`
 
-    returnRn (Just result, dump_action) }
-  where
-    trashed_exports  = {-trace "rnSource:trashed_exports"-} Nothing
-    trashed_imports  = {-trace "rnSource:trashed_imports"-} []
+    returnRn (Just (mod_iface, final_decls))
+    }
 \end{code}
 
 @implicitFVs@ forces the renamer to slurp in some things which aren't
@@ -250,7 +227,7 @@ implicitFVs mod_name decls
     string_occs = [unpackCString_RDR, unpackCStringFoldr_RDR, unpackCStringUtf8_RDR,
                   eqString_RDR]
 
-    get (TyClD (TyData _ _ _ _ _ _ (Just deriv_classes) _ _ _ _))
+    get (TyClD (TyData _ _ _ _ _ _ (Just deriv_classes) _ _ _))
        = concat (map get_deriv deriv_classes)
     get other = []
 
@@ -289,378 +266,240 @@ isOrphanDecl other = False
 \end{code}
 
 
-\begin{code}
-dupDefaultDeclErrRn (DefaultDecl _ locn1 : dup_things)
-  = pushSrcLocRn locn1 $
-    addErrRn msg
-  where
-    msg = hang (ptext SLIT("Multiple default declarations"))
-              4  (vcat (map pp dup_things))
-    pp (DefaultDecl _ locn) = ptext SLIT("here was another default declaration") <+> ppr locn
-\end{code}
-
-
 %*********************************************************
 %*                                                      *
-\subsection{Slurping declarations}
+\subsection{Fixities}
 %*                                                      *
 %*********************************************************
 
 \begin{code}
--------------------------------------------------------
-slurpImpDecls source_fvs
-  = 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) ->
-
-       -- Then get everything else
-    closeDecls decls needed                    `thenRn` \ decls1 ->
-
-       -- Finally, get any deferred data type decls
-    slurpDeferredDecls decls1                  `thenRn` \ final_decls -> 
-
-    returnRn final_decls
-
--------------------------------------------------------
-slurpSourceRefs :: NameSet                     -- Variables defined in source
-               -> 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
-  = go_outer []                        -- Accumulating decls
-            emptyFVs                   -- Unsatisfied needs
-            emptyFVs                   -- Accumulating gates
-            (nameSetToList source_fvs) -- Things whose defn hasn't been loaded yet
+fixitiesFromLocalDecls :: GlobalRdrEnv -> [RdrNameHsDecl] -> RnMG LocalFixityEnv
+fixitiesFromLocalDecls gbl_env decls
+  = doptRn Opt_WarnUnusedBinds                           `thenRn` \ warn_unused ->
+    foldlRn (getFixities warn_unused) emptyNameEnv decls  `thenRn` \ env -> 
+    traceRn (text "fixity env" <+> vcat (map ppr (nameEnvElts env)))
+                                                         `thenRn_`
+    returnRn env
   where
-       -- The outer loop repeatedly slurps the decls for the current 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_`
-         foldlRn go_inner (decls, fvs, emptyFVs) refs          `thenRn` \ (decls1, fvs1, gates1) ->
-         getImportedInstDecls (all_gates `plusFV` gates1)      `thenRn` \ inst_decls ->
-         rnInstDecls 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
-
-    go_inner (decls, fvs, gates) wanted_name
-       = importDecl wanted_name                `thenRn` \ import_result ->
-         case import_result of
-           AlreadySlurped -> returnRn (decls, fvs, gates)
-           WiredIn        -> returnRn (decls, fvs, gates `plusFV` getWiredInGates wanted_name)
-           Deferred       -> returnRn (decls, fvs, gates `addOneFV` wanted_name)       -- It's a type constructor
-                       
-           HereItIs decl -> rnIfaceDecl decl           `thenRn` \ (new_decl, fvs1) ->
-                            returnRn (new_decl : decls, 
-                                      fvs1 `plusFV` fvs,
-                                      gates `plusFV` getGates source_fvs new_decl)
-
-rnInstDecls decls fvs gates []
-  = returnRn (decls, fvs, gates)
-rnInstDecls decls fvs gates (d:ds) 
-  = rnIfaceDecl d              `thenRn` \ (new_decl, fvs1) ->
-    rnInstDecls (new_decl:decls) 
-               (fvs1 `plusFV` fvs)
-               (gates `plusFV` getInstDeclGates new_decl)
-               ds
-\end{code}
+    getFixities :: Bool -> LocalFixityEnv -> RdrNameHsDecl -> RnMG LocalFixityEnv
+    getFixities warn_uu acc (FixD fix)
+      = fix_decl warn_uu acc fix
 
+    getFixities warn_uu acc (TyClD (ClassDecl _ _ _ _ sigs _ _ _ ))
+      = foldlRn (fix_decl warn_uu) acc [sig | FixSig sig <- sigs]
+               -- Get fixities from class decl sigs too.
+    getFixities warn_uu acc other_decl
+      = returnRn acc
 
-\begin{code}
--------------------------------------------------------
--- closeDecls keeps going until the free-var set is empty
-closeDecls decls needed
-  | not (isEmptyFVs needed)
-  = slurpDecls decls needed    `thenRn` \ (decls1, needed1) ->
-    closeDecls decls1 needed1
-
-  | otherwise
-  = getImportedRules                   `thenRn` \ rule_decls ->
-    case rule_decls of
-       []    -> returnRn decls -- No new rules, so we are done
-       other -> rnIfaceDecls decls emptyFVs rule_decls         `thenRn` \ (decls1, needed1) ->
-                closeDecls decls1 needed1
-                
-
--------------------------------------------------------
--- Augment decls with any decls needed by needed.
--- Return also free vars of the new decls (only)
-slurpDecls decls needed
-  = go decls emptyFVs (nameSetToList needed) 
-  where
-    go decls fvs []         = returnRn (decls, fvs)
-    go decls fvs (ref:refs) = slurpDecl decls fvs ref  `thenRn` \ (decls1, fvs1) ->
-                             go decls1 fvs1 refs
-
--------------------------------------------------------
-slurpDecl decls fvs wanted_name
-  = importDecl wanted_name             `thenRn` \ import_result ->
-    case import_result of
-       -- Found a declaration... rename it
-       HereItIs decl -> rnIfaceDecl decl               `thenRn` \ (new_decl, fvs1) ->
-                        returnRn (new_decl:decls, fvs1 `plusFV` fvs)
-
-       -- No declaration... (wired in thing, or deferred, or already slurped)
-       other -> returnRn (decls, fvs)
-
-
--------------------------------------------------------
-rnIfaceDecls :: [RenamedHsDecl] -> FreeVars
-            -> [(Module, RdrNameHsDecl)]
-            -> RnM d ([RenamedHsDecl], FreeVars)
-rnIfaceDecls decls fvs []     = returnRn (decls, fvs)
-rnIfaceDecls decls fvs (d:ds) = rnIfaceDecl d          `thenRn` \ (new_decl, fvs1) ->
-                               rnIfaceDecls (new_decl:decls) (fvs1 `plusFV` fvs) ds
-
-rnIfaceDecl (mod, decl) = initIfaceRnMS mod (rnDecl decl)      
+    fix_decl warn_uu acc sig@(FixitySig rdr_name fixity loc)
+       =       -- Check for fixity decl for something not declared
+         pushSrcLocRn loc                      $
+         lookupGlobalRn gbl_env rdr_name       `thenRn` \  maybe_name ->
+         case maybe_name of {
+           Nothing ->  checkRn (not warn_uu) (unusedFixityDecl rdr_name fixity)        `thenRn_` 
+                       returnRn acc ;
+
+           Just name ->
+
+               -- Check for duplicate fixity decl
+         case lookupNameEnv acc name of {
+           Just (FixitySig _ _ loc') -> addErrRn (dupFixityDecl rdr_name loc loc')
+                                        `thenRn_` returnRn acc ;
+
+           Nothing -> returnRn (extendNameEnv acc name (FixitySig name fixity loc))
+         }}
 \end{code}
 
 
 %*********************************************************
 %*                                                      *
-\subsection{Deferred declarations}
+\subsection{Deprecations}
 %*                                                      *
 %*********************************************************
 
-The idea of deferred declarations is this.  Suppose we have a function
-       f :: T -> Int
-       data T = T1 A | T2 B
-       data A = A1 X | A2 Y
-       data B = B1 P | B2 Q
-Then we don't want to load T and all its constructors, and all
-the types those constructors refer to, and all the types *those*
-constructors refer to, and so on.  That might mean loading many more
-interface files than is really necessary.  So we 'defer' loading T.
-
-But f might be strict, and the calling convention for evaluating
-values of type T depends on how many constructors T has, so 
-we do need to load T, but not the full details of the type T.
-So we load the full decl for T, but only skeleton decls for A and B:
-       f :: T -> Int
-       data T = {- 2 constructors -}
-
-Whether all this is worth it is moot.
+For deprecations, all we do is check that the names are in scope.
+It's only imported deprecations, dealt with in RnIfaces, that we
+gather them together.
 
 \begin{code}
-slurpDeferredDecls :: [RenamedHsDecl] -> RnMG [RenamedHsDecl]
-slurpDeferredDecls decls
-  = getDeferredDecls                                           `thenRn` \ def_decls ->
-    rnIfaceDecls decls emptyFVs (map stripDecl def_decls)      `thenRn` \ (decls1, fvs) ->
-    ASSERT( isEmptyFVs fvs )
-    returnRn decls1
-
-stripDecl (mod, TyClD (TyData dt _ tc tvs _ nconstrs _ _ loc name1 name2))
-  = (mod, TyClD (TyData dt [] tc tvs [] nconstrs Nothing NoDataPragmas loc
-               name1 name2))
-       -- Nuke the context and constructors
-       -- But retain the *number* of constructors!
-       -- Also the tvs will have kinds on them.
-\end{code}
+rnDeprecs :: GlobalRdrEnv -> Maybe DeprecTxt
+          -> [RdrNameDeprecation] -> RnMG Deprecations
+rnDeprecs gbl_env Nothing []
+ = returnRn NoDeprecs
 
+rnDeprecs gbl_env (Just txt) decls
+ = mapRn (addErrRn . badDeprec) decls  `thenRn_` 
+   returnRn (DeprecAll txt)
 
-%*********************************************************
-%*                                                      *
-\subsection{Extracting the `gates'}
-%*                                                      *
-%*********************************************************
+rnDeprecs gbl_env Nothing decls
+  = mapRn rn_deprec decls      `thenRn` \ pairs ->
+    returnRn (DeprecSome (mkNameEnv (catMaybes pairs)))
+ where
+   rn_deprec (Deprecation rdr_name txt loc)
+     = pushSrcLocRn loc                        $
+       lookupGlobalRn gbl_env rdr_name `thenRn` \ maybe_name ->
+       case maybe_name of
+        Just n  -> returnRn (Just (n,txt))
+        Nothing -> returnRn Nothing
+\end{code}
 
-When we import a declaration like
-\begin{verbatim}
-       data T = T1 Wibble | T2 Wobble
-\end{verbatim}
-we don't want to treat @Wibble@ and @Wobble@ as gates
-{\em unless} @T1@, @T2@ respectively are mentioned by the user program.
-If only @T@ is mentioned
-we want only @T@ to be a gate;
-that way we don't suck in useless instance
-decls for (say) @Eq Wibble@, when they can't possibly be useful.
 
-@getGates@ takes a newly imported (and renamed) decl, and the free
-vars of the source program, and extracts from the decl the gate names.
+%************************************************************************
+%*                                                                     *
+\subsection{Grabbing the old interface file and checking versions}
+%*                                                                     *
+%************************************************************************
 
 \begin{code}
-getGates source_fvs (SigD (IfaceSig _ ty _ _))
-  = extractHsTyNames ty
-
-getGates source_fvs (TyClD (ClassDecl ctxt cls tvs _ sigs _ _ _ _ ))
-  = (delListFromNameSet (foldr (plusFV . get) (extractHsCtxtTyNames ctxt) sigs)
-                       (hsTyVarNames tvs)
-     `addOneToNameSet` cls)
-    `plusFV` maybe_double
-  where
-    get (ClassOpSig n _ ty _) 
-       | n `elemNameSet` source_fvs = 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
-
-getGates source_fvs (TyClD (TySynonym tycon tvs ty _))
-  = delListFromNameSet (extractHsTyNames ty)
-                      (hsTyVarNames tvs)
-       -- A type synonym type constructor isn't a "gate" for instance decls
-
-getGates source_fvs (TyClD (TyData _ ctxt tycon tvs cons _ _ _ _ _ _))
-  = delListFromNameSet (foldr (plusFV . get) (extractHsCtxtTyNames ctxt) cons)
-                      (hsTyVarNames tvs)
-    `addOneToNameSet` tycon
-  where
-    get (ConDecl n _ tvs ctxt details _)
-       | n `elemNameSet` source_fvs
-               -- If the constructor is method, get fvs from all its fields
-       = delListFromNameSet (get_details details `plusFV` 
-                             extractHsCtxtTyNames ctxt)
-                            (hsTyVarNames tvs)
-    get (ConDecl n _ tvs ctxt (RecCon fields) _)
-               -- Even if the constructor isn't mentioned, the fields
-               -- might be, as selectors.  They can't mention existentially
-               -- bound tyvars (typechecker checks for that) so no need for 
-               -- the deleteListFromNameSet part
-       = foldr (plusFV . get_field) emptyFVs fields
+checkOldIface :: DynFlags -> Finder
+             -> HomeIfaceTable -> HomeSymbolTable
+             -> PersistentCompilerState
+             -> Module 
+             -> Bool                   -- Source unchanged
+             -> Maybe ModIface         -- Old interface from compilation manager, if any
+             -> IO (PersistentCompilerState, Bool, (RecompileRequired, Maybe ModIface))
+                               -- True <=> errors happened
+
+checkOldIface dflags finder hit hst pcs mod source_unchanged maybe_iface
+  = initRn dflags finder hit hst pcs mod $
        
-    get other_con = emptyFVs
-
-    get_details (VanillaCon tys) = plusFVs (map get_bang tys)
-    get_details (InfixCon t1 t2) = get_bang t1 `plusFV` get_bang t2
-    get_details (RecCon fields)  = plusFVs [get_bang t | (_, t) <- fields]
-
-    get_field (fs,t) | any (`elemNameSet` source_fvs) fs = get_bang t
-                    | otherwise                         = emptyFVs
+       -- Load the old interface file, if we havn't already got it
+    loadOldIface mod maybe_iface                       `thenRn` \ maybe_iface ->
 
-    get_bang bty = extractHsTyNames (getBangType bty)
+       -- Check versions
+    recompileRequired mod source_unchanged maybe_iface `thenRn` \ recompile ->
 
-getGates source_fvs other_decl = emptyFVs
+    returnRn (recompile, maybe_iface)
 \end{code}
 
-@getWiredInGates@ is just like @getGates@, but it sees a wired-in @Name@
-rather than a declaration.
 
 \begin{code}
-getWiredInGates :: Name -> FreeVars
-getWiredInGates name   -- No classes are wired in
-  | is_id               = getWiredInGates_s (namesOfType (idType the_id))
-  | isSynTyCon the_tycon = getWiredInGates_s
-        (delListFromNameSet (namesOfType ty) (map getName tyvars))
-  | otherwise           = unitFV name
-  where
-    maybe_wired_in_id    = maybeWiredInIdName name
-    is_id               = maybeToBool maybe_wired_in_id
-    maybe_wired_in_tycon = maybeWiredInTyConName name
-    Just the_id         = maybe_wired_in_id
-    Just the_tycon      = maybe_wired_in_tycon
-    (tyvars,ty)         = getSynTyConDefn the_tycon
-
-getWiredInGates_s names = foldr (plusFV . getWiredInGates) emptyFVs (nameSetToList names)
-\end{code}
+loadOldIface :: Module -> Maybe ModIface -> RnMG (Maybe ModIface)
+loadOldIface mod (Just iface) 
+  = returnRn (Just iface)
+
+loadOldIface mod Nothing
+  =    -- LOAD THE OLD INTERFACE FILE
+    findAndReadIface doc_str (moduleName mod) False {- Not hi-boot -}  `thenRn` \ read_result ->
+    case read_result of {
+       Left err ->     -- Old interface file not found, or garbled, so we'd better bail out
+                   traceRn (vcat [ptext SLIT("No old interface file:"), err])  `thenRn_`
+                   returnRn Nothing ;
+
+       Right (_, iface) ->
+
+       -- RENAME IT
+    initIfaceRnMS mod (
+       loadHomeDecls (pi_decls iface)  `thenRn` \ decls ->
+       loadHomeRules (pi_rules iface)  `thenRn` \ rules -> 
+       loadHomeInsts (pi_insts iface)  `thenRn` \ insts ->
+       returnRn (decls, rules, insts)
+    )                          `thenRn` \ ((decls_vers, new_decls), (rule_vers, new_rules), new_insts) ->
+
+    mapRn loadHomeUsage        (pi_usages iface)       `thenRn` \ usages ->
+    loadExports        (pi_exports iface)      `thenRn` \ (export_vers, avails) ->
+    loadFixDecls mod   (pi_fixity iface)       `thenRn` \ fix_env ->
+    loadDeprecs mod    (pi_deprecs iface)      `thenRn` \ deprec_env ->
+    let
+       version = VersionInfo { vers_module  = pi_vers iface, 
+                               vers_exports = export_vers,
+                               vers_rules   = rule_vers,
+                               vers_decls   = decls_vers }
+
+       decls = IfaceDecls { dcl_tycl = new_decls,
+                            dcl_rules = new_rules,
+                            dcl_insts = new_insts }
+
+       mod_iface = ModIface { mi_module = mod, mi_version = version,
+                              mi_exports = avails, mi_orphan = pi_orphan iface,
+                              mi_fixities = fix_env, mi_deprecs = deprec_env,
+                              mi_usages  = usages,
+                              mi_decls   = decls,
+                              mi_globals = panic "No mi_globals in old interface"
+                   }
+    in
+    returnRn (Just mod_iface)
+    }
 
-\begin{code}
-getInstDeclGates (InstD (InstDecl inst_ty _ _ _ _)) = extractHsTyNames inst_ty
-getInstDeclGates other                             = emptyFVs
+    
+  where
+    doc_str = ptext SLIT("need usage info from") <+> ppr mod
 \end{code}
 
-
-%*********************************************************
-%*                                                      *
-\subsection{Fixities}
-%*                                                      *
-%*********************************************************
-
 \begin{code}
-fixitiesFromLocalDecls :: GlobalRdrEnv -> [RdrNameHsDecl] -> RnMG FixityEnv
-fixitiesFromLocalDecls gbl_env decls
-  = foldlRn getFixities emptyNameEnv decls                             `thenRn` \ env -> 
-    traceRn (text "fixity env" <+> vcat (map ppr (nameEnvElts env)))   `thenRn_`
-    returnRn env
+loadHomeDecls :: [(Version, RdrNameTyClDecl)]
+             -> RnMS (NameEnv Version, [RenamedTyClDecl])
+loadHomeDecls decls = foldlRn loadHomeDecl (emptyNameEnv, []) decls
+
+loadHomeDecl :: (NameEnv Version, [RenamedTyClDecl])
+            -> (Version, RdrNameTyClDecl)
+            -> RnMS (NameEnv Version, [RenamedTyClDecl])
+loadHomeDecl (version_map, decls) (version, decl)
+  = rnTyClDecl decl    `thenRn` \ decl' ->
+    returnRn (extendNameEnv version_map (tyClDeclName decl') version, decl':decls)
+
+------------------
+loadHomeRules :: (Version, [RdrNameRuleDecl])
+             -> RnMS (Version, [RenamedRuleDecl])
+loadHomeRules (version, rules)
+  = mapRn rnIfaceRuleDecl rules        `thenRn` \ rules' ->
+    returnRn (version, rules')
+
+------------------
+loadHomeInsts :: [RdrNameInstDecl]
+             -> RnMS [RenamedInstDecl]
+loadHomeInsts insts = mapRn rnInstDecl insts
+
+------------------
+loadHomeUsage :: ImportVersion OccName
+             -> RnMG (ImportVersion Name)
+loadHomeUsage (mod_name, orphans, is_boot, whats_imported)
+  = rn_imps whats_imported     `thenRn` \ whats_imported' ->
+    returnRn (mod_name, orphans, is_boot, whats_imported')
   where
-    getFixities :: FixityEnv -> RdrNameHsDecl -> RnMG FixityEnv
-    getFixities acc (FixD fix)
-      = fix_decl acc fix
-
-    getFixities acc (TyClD (ClassDecl _ _ _ _ sigs _ _ _ _ ))
-      = foldlRn fix_decl acc [sig | FixSig sig <- sigs]
-               -- Get fixities from class decl sigs too.
-    getFixities acc other_decl
-      = returnRn acc
-
-    fix_decl acc sig@(FixitySig rdr_name fixity loc)
-       =       -- Check for fixity decl for something not declared
-         case lookupRdrEnv gbl_env rdr_name of {
-           Nothing | opt_WarnUnusedBinds 
-                   -> pushSrcLocRn loc (addWarnRn (unusedFixityDecl rdr_name fixity))
-                      `thenRn_` returnRn acc 
-                   | otherwise -> returnRn acc ;
-       
-           Just ((name,_):_) ->
-
-               -- Check for duplicate fixity decl
-         case lookupNameEnv acc name of {
-           Just (FixitySig _ _ loc') -> addErrRn (dupFixityDecl rdr_name loc loc')
-                                        `thenRn_` returnRn acc ;
-
-           Nothing -> returnRn (extendNameEnv acc name (FixitySig name fixity loc))
-         }}
+    rn_imps NothingAtAll                 = returnRn NothingAtAll
+    rn_imps (Everything v)               = returnRn (Everything v)
+    rn_imps (Specifically mv ev items rv) = mapRn rn_imp items         `thenRn` \ items' ->
+                                           returnRn (Specifically mv ev items' rv)
+    rn_imp (occ,vers) = newGlobalName mod_name occ     `thenRn` \ name ->
+                       returnRn (name,vers)
 \end{code}
 
 
+
 %*********************************************************
 %*                                                      *
-\subsection{Deprecations}
+\subsection{Closing up the interface decls}
 %*                                                      *
 %*********************************************************
 
-For deprecations, all we do is check that the names are in scope.
-It's only imported deprecations, dealt with in RnIfaces, that we
-gather them together.
+Suppose we discover we don't need to recompile.   Then we start from the
+IfaceDecls in the ModIface, and fluff them up by sucking in all the decls they need.
 
 \begin{code}
-rnDeprecs :: GlobalRdrEnv -> Maybe DeprecTxt
-          -> [RdrNameHsDecl] -> RnMG [RdrNameDeprecation]
-rnDeprecs gbl_env mod_deprec decls
- = mapRn rn_deprec deprecs     `thenRn_` 
-   returnRn (extra_deprec ++ deprecs)
- where
-   deprecs = [d | DeprecD d <- decls]
-   extra_deprec = case mod_deprec of
-                  Nothing  -> []
-                  Just txt -> [Deprecation (IEModuleContents undefined) txt noSrcLoc]
-
-   rn_deprec (Deprecation ie txt loc)
-     = pushSrcLocRn loc                $
-       mapRn check (ieNames ie)
-
-   check n = case lookupRdrEnv gbl_env n of
-               Nothing -> addErrRn (unknownNameErr n)
-               Just _  -> returnRn ()
-\end{code}
+closeIfaceDecls :: DynFlags -> Finder
+               -> HomeIfaceTable -> HomeSymbolTable
+               -> PersistentCompilerState
+               -> ModIface     -- Get the decls from here
+               -> IO (PersistentCompilerState, Bool, [RenamedHsDecl])
+                               -- True <=> errors happened
+closeIfaceDecls dflags finder hit hst pcs
+               mod_iface@(ModIface { mi_module = mod, mi_decls = iface_decls })
+  = initRn dflags finder hit hst pcs mod $
 
+    let
+       rule_decls = dcl_rules iface_decls
+       inst_decls = dcl_insts iface_decls
+       tycl_decls = dcl_tycl  iface_decls
+       decls = map RuleD rule_decls ++
+               map InstD inst_decls ++
+               map TyClD tycl_decls
+       needed = unionManyNameSets (map ruleDeclFVs rule_decls) `unionNameSets`
+                unionManyNameSets (map instDeclFVs inst_decls) `unionNameSets`
+                unionManyNameSets (map tyClDeclFVs tycl_decls)
+    in
+    closeDecls decls needed
+\end{code}
 
 %*********************************************************
 %*                                                      *
@@ -669,7 +508,7 @@ rnDeprecs gbl_env mod_deprec decls
 %*********************************************************
 
 \begin{code}
-reportUnusedNames :: ModuleName -> [Module] 
+reportUnusedNames :: ModuleName -> [ModuleName] 
                  -> GlobalRdrEnv -> AvailEnv
                  -> Avails -> NameSet -> [RenamedHsDecl] 
                  -> RnMG ()
@@ -677,122 +516,134 @@ reportUnusedNames mod_name direct_import_mods
                  gbl_env avail_env 
                  export_avails mentioned_names
                  imported_decls
-  = let
-       used_names = mentioned_names `unionNameSets` availsToNameSet export_avails
-
-       -- Now, a use of C implies a use of T,
-       -- if C was brought into scope by T(..) or T(C)
-       really_used_names = used_names `unionNameSets`
-         mkNameSet [ availName parent_avail
-                   | sub_name <- nameSetToList used_names
-                   , isValOcc (getOccName sub_name)
-
-                       -- Usually, every used name will appear in avail_env, but there 
-                       -- is one time when it doesn't: tuples and other built in syntax.  When you
-                       -- write (a,b) that gives rise to a *use* of "(,)", so that the
-                       -- instances will get pulled in, but the tycon "(,)" isn't actually
-                       -- in scope.  Hence the isValOcc filter.
-                       --
-                       -- Also, (-x) gives rise to an implicit use of 'negate'; similarly, 
-                       --   3.5 gives rise to an implcit use of :%
-                       -- hence the isUserImportedName filter on the warning
-                     
-                   , let parent_avail 
-                           = case lookupNameEnv avail_env sub_name of
-                               Just avail -> avail
-                               Nothing -> WARN( isUserImportedName sub_name,
-                                                text "reportUnusedName: not in avail_env" <+> 
-                                                       ppr sub_name )
-                                          Avail sub_name
-                     
-                   , case parent_avail of { AvailTC _ _ -> True; other -> False }
-                   ]
-
-       defined_names, defined_but_not_used :: [(Name,Provenance)]
-       defined_names        = concat (rdrEnvElts gbl_env)
-       defined_but_not_used = filter not_used defined_names
-       not_used name        = not (name `elemNameSet` really_used_names)
-
-       -- Filter out the ones only defined implicitly
-       bad_locals :: [Name]
-       bad_locals     = [n     | (n,LocalDef) <- defined_but_not_used]
-       
-       bad_imp_names :: [(Name,Provenance)]
-       bad_imp_names  = [(n,p) | (n,p@(UserImport mod _ True) <- defined_but_not_used,
-                                 not (module_unused mod)]
-
-       deprec_used deprec_env = [ (n,txt)
-                                 | n <- nameSetToList mentioned_names,
-                                   not (isLocallyDefined n),
-                                   Just txt <- [lookupNameEnv deprec_env n] ]
-
-       -- inst_mods are directly-imported modules that 
-       --      contain instance decl(s) that the renamer decided to suck in
-       -- It's not necessarily redundant to import such modules.
-       --
-       -- NOTE: Consider 
-       --            module This
-       --              import M ()
-       --
-       --       The import M() is not *necessarily* redundant, even if
-       --       we suck in no instance decls from M (e.g. it contains 
-       --       no instance decls, or This contains no code).  It may be 
-       --       that we import M solely to ensure that M's orphan instance 
-       --       decls (or those in its imports) are visible to people who 
-       --       import This.  Sigh. 
-       --       There's really no good way to detect this, so the error message 
-       --       in RnEnv.warnUnusedModules is weakened instead
-       inst_mods = [m | InstD (InstDecl _ _ _ (Just dfun) _) <- imported_decls,
-                        let m = nameModule dfun,
-                        m `elem` direct_import_mods
-                   ]
-
-       minimal_imports :: FiniteMap Module AvailEnv
-       minimal_imports0 = emptyFM
-       minimal_imports1 = foldNameSet add_name minimal_imports0 really_used_names
-       minimal_imports  = foldr   add_inst_mod minimal_imports1 inst_mods
-       
-       add_name n acc = case maybeUserImportedFrom n of
-                          Nothing -> acc
-                          Just m  -> addToFM_C plusAvailEnv acc m
-                                               (unitAvailEnv (mk_avail n))
-       add_inst_mod m acc 
-         | m `elemFM` acc = acc        -- We import something already
-         | otherwise      = addToFM acc m emptyAvailEnv
-               -- Add an empty collection of imports for a module
-               -- from which we have sucked only instance decls
-
-       mk_avail n = case lookupNameEnv avail_env n of
-                       Just (AvailTC m _) | n==m      -> AvailTC n [n]
-                                          | otherwise -> AvailTC m [n,m]
-                       Just avail         -> Avail n
-                       Nothing            -> pprPanic "mk_avail" (ppr n)
-
-       -- unused_imp_mods are the directly-imported modules 
-       -- that are not mentioned in minimal_imports
-       unused_imp_mods = [m | m <- direct_import_mods,
-                              not (maybeToBool (lookupFM minimal_imports m)),
-                              moduleName m /= pRELUDE_Name]
-
-       module_unused :: Module -> Bool
-       module_unused mod = mod `elem` unused_imp_mods
-
-    in
-    warnUnusedModules unused_imp_mods                          `thenRn_`
+  = warnUnusedModules unused_imp_mods                          `thenRn_`
     warnUnusedLocalBinds bad_locals                            `thenRn_`
     warnUnusedImports bad_imp_names                            `thenRn_`
     printMinimalImports mod_name minimal_imports               `thenRn_`
-    getIfacesRn                                                        `thenRn` \ ifaces ->
-    (if opt_WarnDeprecations
-       then mapRn_ warnDeprec (deprec_used (iDeprecs ifaces))
-       else returnRn ())
+    warnDeprecations really_used_names                         `thenRn_`
+    returnRn ()
+
+  where
+    used_names = mentioned_names `unionNameSets` availsToNameSet export_avails
+    
+    -- Now, a use of C implies a use of T,
+    -- if C was brought into scope by T(..) or T(C)
+    really_used_names = used_names `unionNameSets`
+      mkNameSet [ parent_name
+               | sub_name <- nameSetToList used_names
+    
+               -- Usually, every used name will appear in avail_env, but there 
+               -- is one time when it doesn't: tuples and other built in syntax.  When you
+               -- write (a,b) that gives rise to a *use* of "(,)", so that the
+               -- instances will get pulled in, but the tycon "(,)" isn't actually
+               -- in scope.  Also, (-x) gives rise to an implicit use of 'negate'; 
+               -- similarly,   3.5 gives rise to an implcit use of :%
+               -- Hence the silent 'False' in all other cases
+             
+               , Just parent_name <- [case lookupNameEnv avail_env sub_name of
+                                       Just (AvailTC n _) -> Just n
+                                       other              -> Nothing]
+           ]
+    
+    defined_names, defined_and_used, defined_but_not_used :: [(Name,Provenance)]
+    defined_names                           = concat (rdrEnvElts gbl_env)
+    (defined_and_used, defined_but_not_used) = partition used defined_names
+    used (name,_)                           = not (name `elemNameSet` really_used_names)
+    
+    -- Filter out the ones only defined implicitly
+    bad_locals :: [Name]
+    bad_locals     = [n     | (n,LocalDef) <- defined_but_not_used]
+    
+    bad_imp_names :: [(Name,Provenance)]
+    bad_imp_names  = [(n,p) | (n,p@(NonLocalDef (UserImport mod _ True) _)) <- defined_but_not_used,
+                             not (module_unused mod)]
+    
+    -- inst_mods are directly-imported modules that 
+    -- contain instance decl(s) that the renamer decided to suck in
+    -- It's not necessarily redundant to import such modules.
+    --
+    -- NOTE: Consider 
+    --       module This
+    --         import M ()
+    --
+    --  The import M() is not *necessarily* redundant, even if
+    --          we suck in no instance decls from M (e.g. it contains 
+    --  no instance decls, or This contains no code).  It may be 
+    --  that we import M solely to ensure that M's orphan instance 
+    --  decls (or those in its imports) are visible to people who 
+    --  import This.  Sigh. 
+    --  There's really no good way to detect this, so the error message 
+    --  in RnEnv.warnUnusedModules is weakened instead
+    inst_mods :: [ModuleName]
+    inst_mods = [m | InstD (InstDecl _ _ _ (Just dfun) _) <- imported_decls,
+                let m = moduleName (nameModule dfun),
+                m `elem` direct_import_mods
+           ]
+    
+    -- To figure out the minimal set of imports, start with the things
+    -- that are in scope (i.e. in gbl_env).  Then just combine them
+    -- into a bunch of avails, so they are properly grouped
+    minimal_imports :: FiniteMap ModuleName AvailEnv
+    minimal_imports0 = emptyFM
+    minimal_imports1 = foldr add_name     minimal_imports0 defined_and_used
+    minimal_imports  = foldr add_inst_mod minimal_imports1 inst_mods
+    
+    add_name (n,NonLocalDef (UserImport m _ _) _) acc = addToFM_C plusAvailEnv acc (moduleName (nameModule n))
+                                                                 (unitAvailEnv (mk_avail n))
+    add_name (n,other_prov)                      acc = acc
+
+    mk_avail n = case lookupNameEnv avail_env n of
+               Just (AvailTC m _) | n==m      -> AvailTC n [n]
+                                  | otherwise -> AvailTC m [n,m]
+               Just avail         -> Avail n
+               Nothing            -> pprPanic "mk_avail" (ppr n)
+    
+    add_inst_mod m acc 
+      | m `elemFM` acc = acc   -- We import something already
+      | otherwise      = addToFM acc m emptyAvailEnv
+       -- Add an empty collection of imports for a module
+       -- from which we have sucked only instance decls
+    
+    -- unused_imp_mods are the directly-imported modules 
+    -- that are not mentioned in minimal_imports
+    unused_imp_mods = [m | m <- direct_import_mods,
+                      not (maybeToBool (lookupFM minimal_imports m)),
+                      m /= pRELUDE_Name]
+    
+    module_unused :: Module -> Bool
+    module_unused mod = moduleName mod `elem` unused_imp_mods
+
+
+warnDeprecations used_names
+  = doptRn Opt_WarnDeprecations                                `thenRn` \ warn_drs ->
+    if not warn_drs then returnRn () else
+
+    getIfacesRn                                                `thenRn` \ ifaces ->
+    getHomeIfaceTableRn                                        `thenRn` \ hit ->
+    let
+       pit     = iPIT ifaces
+       deprecs = [ (n,txt)
+                  | n <- nameSetToList used_names,
+                    Just txt <- [lookup_deprec hit pit n] ]
+    in                   
+    mapRn_ warnDeprec deprecs
+
+  where
+    lookup_deprec hit pit n
+       = case lookupModuleEnv hit mod of
+               Just iface -> lookupDeprec iface n
+               Nothing    -> case lookupModuleEnv pit mod of
+                               Just iface -> lookupDeprec iface n
+                               Nothing    -> pprPanic "warnDeprecations:" (ppr n)
+       where
+         mod = nameModule n
 
 -- ToDo: deal with original imports with 'qualified' and 'as M' clauses
 printMinimalImports mod_name imps
-  | not opt_D_dump_minimal_imports
-  = returnRn ()
-  | otherwise
-  = mapRn to_ies (fmToList imps)               `thenRn` \ mod_ies ->
+  = doptRn Opt_D_dump_minimal_imports          `thenRn` \ dump_minimal ->
+    if not dump_minimal then returnRn () else
+
+    mapRn to_ies (fmToList imps)               `thenRn` \ mod_ies ->
     ioToRnM (do { h <- openFile filename WriteMode ;
                  printForUser h (vcat (map ppr_mod_ie mod_ies))
        })                                      `thenRn_`
@@ -807,34 +658,43 @@ printMinimalImports mod_name imps
                            parens (fsep (punctuate comma (map ppr ies)))
 
     to_ies (mod, avail_env) = mapRn to_ie (availEnvElts avail_env)     `thenRn` \ ies ->
-                             returnRn (moduleName mod, ies)
+                             returnRn (mod, ies)
 
     to_ie :: AvailInfo -> RnMG (IE Name)
     to_ie (Avail n)       = returnRn (IEVar n)
     to_ie (AvailTC n [m]) = ASSERT( n==m ) 
                            returnRn (IEThingAbs n)
-    to_ie (AvailTC n ns)  = getInterfaceExports (moduleName (nameModule n)) 
-                                               ImportBySystem          `thenRn` \ (_, avails) ->
-                           case [ms | AvailTC m ms <- avails, m == n] of
-                             [ms] | all (`elem` ns) ms -> returnRn (IEThingAll n)
-                                  | otherwise          -> returnRn (IEThingWith n (filter (/= n) ns))
-                             other -> pprTrace "to_ie" (ppr n <+> ppr (nameModule n) <+> ppr other) $
-                                      returnRn (IEVar n)
+    to_ie (AvailTC n ns)  
+       = getInterfaceExports n_mod ImportBySystem              `thenRn` \ (_, avails_by_module) ->
+         case [xs | (m,as) <- avails_by_module,
+                    m == n_mod,
+                    AvailTC x xs <- as, 
+                    x == n] of
+             [xs] | all (`elem` ns) xs -> returnRn (IEThingAll n)
+                  | otherwise          -> returnRn (IEThingWith n (filter (/= n) ns))
+             other                     -> pprTrace "to_ie" (ppr n <+> ppr (nameModule n) <+> ppr other) $
+                                          returnRn (IEVar n)
+       where
+         n_mod = moduleName (nameModule n)
 
 rnDump  :: [RenamedHsDecl]     -- Renamed imported decls
        -> [RenamedHsDecl]      -- Renamed local decls
-       -> RnMG (IO ())
+       -> RnMG ()
 rnDump imp_decls local_decls
-        | opt_D_dump_rn_trace || 
-         opt_D_dump_rn_stats ||
-         opt_D_dump_rn 
-       = getRnStats imp_decls          `thenRn` \ stats_msg ->
+  = doptRn Opt_D_dump_rn_trace         `thenRn` \ dump_rn_trace ->
+    doptRn Opt_D_dump_rn_stats         `thenRn` \ dump_rn_stats ->
+    doptRn Opt_D_dump_rn               `thenRn` \ dump_rn ->
+    getIfacesRn                        `thenRn` \ ifaces ->
 
-         returnRn (printErrs stats_msg >> 
-                   dumpIfSet opt_D_dump_rn "Renamer:" 
-                             (vcat (map ppr (local_decls ++ imp_decls))))
+    ioToRnM (do { dumpIfSet (dump_rn_trace || dump_rn_stats || dump_rn)
+                           "Renamer statistics"
+                           (getRnStats imp_decls ifaces) ;
 
-       | otherwise = returnRn (return ())
+                 dumpIfSet dump_rn "Renamer:" 
+                           (vcat (map ppr (local_decls ++ imp_decls)))
+    })                         `thenRn_`
+
+    returnRn ()
 \end{code}
 
 
@@ -845,47 +705,45 @@ rnDump imp_decls local_decls
 %*********************************************************
 
 \begin{code}
-getRnStats :: [RenamedHsDecl] -> RnMG SDoc
-getRnStats imported_decls
-  = getIfacesRn                `thenRn` \ ifaces ->
-    let
-       n_mods = length [() | (_, _, Just _) <- eltsFM (iImpModInfo ifaces)]
-
-       decls_read     = [decl | (_, avail, True, (_,decl)) <- nameEnvElts (iDecls ifaces),
-                               -- Data, newtype, and class decls are in the decls_fm
-                               -- under multiple names; the tycon/class, and each
-                               -- constructor/class op too.
-                               -- The 'True' selects just the 'main' decl
-                                not (isLocallyDefined (availName avail))
-                            ]
-
-       (cd_rd, dd_rd, nd_rd, sd_rd, vd_rd,     _) = count_decls decls_read
-       (cd_sp, dd_sp, nd_sp, sd_sp, vd_sp, id_sp) = count_decls imported_decls
-
-       unslurped_insts       = iInsts ifaces
-       inst_decls_unslurped  = length (bagToList unslurped_insts)
-       inst_decls_read       = id_sp + inst_decls_unslurped
-
-       stats = vcat 
-               [int n_mods <+> text "interfaces read",
-                hsep [ int cd_sp, text "class decls imported, out of", 
-                       int cd_rd, text "read"],
-                hsep [ int dd_sp, text "data decls imported, out of",  
-                       int dd_rd, text "read"],
-                hsep [ int nd_sp, text "newtype decls imported, out of",  
-                       int nd_rd, text "read"],
-                hsep [int sd_sp, text "type synonym decls imported, out of",  
-                       int sd_rd, text "read"],
-                hsep [int vd_sp, text "value signatures imported, out of",  
-                       int vd_rd, text "read"],
-                hsep [int id_sp, text "instance decls imported, out of",  
-                       int inst_decls_read, text "read"],
-                text "cls dcls slurp" <+> fsep (map (ppr . tyClDeclName) 
-                                          [d | TyClD d <- imported_decls, isClassDecl d]),
-                text "cls dcls read"  <+> fsep (map (ppr . tyClDeclName) 
-                                          [d | TyClD d <- decls_read, isClassDecl d])]
-    in
-    returnRn (hcat [text "Renamer stats: ", stats])
+getRnStats :: [RenamedHsDecl] -> Ifaces -> SDoc
+getRnStats imported_decls ifaces
+  = hcat [text "Renamer stats: ", stats]
+  where
+    n_mods = length [() | (_, _, True) <- eltsFM (iImpModInfo ifaces)]
+    
+    decls_read     = [decl | (avail, True, (_,decl)) <- nameEnvElts (iDecls ifaces),
+                       -- Data, newtype, and class decls are in the decls_fm
+                       -- under multiple names; the tycon/class, and each
+                       -- constructor/class op too.
+                       -- The 'True' selects just the 'main' decl
+                        not (isLocallyDefined (availName avail))
+                    ]
+    
+    (cd_rd, dd_rd, nd_rd, sd_rd, vd_rd)        = countTyClDecls decls_read
+    (cd_sp, dd_sp, nd_sp, sd_sp, vd_sp, id_sp) = count_decls imported_decls
+    
+    unslurped_insts       = iInsts ifaces
+    inst_decls_unslurped  = length (bagToList unslurped_insts)
+    inst_decls_read          = id_sp + inst_decls_unslurped
+    
+    stats = vcat 
+       [int n_mods <+> text "interfaces read",
+        hsep [ int cd_sp, text "class decls imported, out of", 
+               int cd_rd, text "read"],
+        hsep [ int dd_sp, text "data decls imported, out of",  
+               int dd_rd, text "read"],
+        hsep [ int nd_sp, text "newtype decls imported, out of",  
+               int nd_rd, text "read"],
+        hsep [int sd_sp, text "type synonym decls imported, out of",  
+               int sd_rd, text "read"],
+        hsep [int vd_sp, text "value signatures imported, out of",  
+               int vd_rd, text "read"],
+        hsep [int id_sp, text "instance decls imported, out of",  
+               int inst_decls_read, text "read"],
+        text "cls dcls slurp" <+> fsep (map (ppr . tyClDeclName) 
+                                  [d | TyClD d <- imported_decls, isClassDecl d]),
+        text "cls dcls read"  <+> fsep (map (ppr . tyClDeclName) 
+                                          [d | d <- decls_read, isClassDecl d])]
 
 count_decls decls
   = (class_decls, 
@@ -896,9 +754,8 @@ count_decls decls
      inst_decls)
   where
     tycl_decls = [d | TyClD d <- decls]
-    (class_decls, data_decls, newtype_decls, syn_decls) = countTyClDecls tycl_decls
+    (class_decls, data_decls, newtype_decls, syn_decls, val_decls) = countTyClDecls tycl_decls
 
-    val_decls     = length [() | SigD _          <- decls]
     inst_decls    = length [() | InstD _  <- decls]
 \end{code}    
 
@@ -925,4 +782,10 @@ dupFixityDecl rdr_name loc1 loc2
   = vcat [ptext SLIT("Multiple fixity declarations for") <+> quotes (ppr rdr_name),
          ptext SLIT("at ") <+> ppr loc1,
          ptext SLIT("and") <+> ppr loc2]
+
+badDeprec d
+  = sep [ptext SLIT("Illegal deprecation when whole module is deprecated"),
+        nest 4 (ppr d)]
 \end{code}
+
+