[project @ 1997-03-17 20:34:25 by simonpj]
[ghc-hetmet.git] / ghc / compiler / rename / RnIfaces.lhs
index 063bfbc..453fda3 100644 (file)
 #include "HsVersions.h"
 
 module RnIfaces (
-       findHiFiles,
-       cachedIface,
-       cachedDecl,
-       readIface,
-       rnIfaces,
-       finalIfaceInfo,
-       IfaceCache(..),
-       VersionInfo(..)
+       getInterfaceExports,
+       getImportedInstDecls,
+       getSpecialInstModules,
+       importDecl, recordSlurp,
+       getImportVersions, 
+
+       checkUpToDate,
+
+       getDeclBinders,
+       mkSearchPath
     ) where
 
-import Ubiq
+IMP_Ubiq()
 
-import LibDirectory
-import PreludeGlaST    ( thenPrimIO, seqPrimIO, readVar, writeVar, MutableVar(..) )
 
-import HsSyn
+import CmdLineOpts     ( opt_HiSuffix, opt_HiSuffixPrelude )
+import HsSyn           ( HsDecl(..), TyDecl(..), ClassDecl(..), HsTyVar, Bind, HsExpr, Sig(..), HsType(..),
+                         HsBinds(..), MonoBinds, DefaultDecl, ConDecl(..), BangType, IfaceSig(..),
+                         FixityDecl(..), Fixity, Fake, InPat, InstDecl(..), SYN_IE(Version), HsIdInfo,
+                         IE(..)
+                       )
 import HsPragmas       ( noGenPragmas )
-import RdrHsSyn
-import RnHsSyn
-
+import RdrHsSyn                ( SYN_IE(RdrNameHsDecl), SYN_IE(RdrNameInstDecl), 
+                         RdrName, rdrNameOcc
+                       )
+import RnEnv           ( newGlobalName, lookupRn, addImplicitOccsRn, 
+                         availName, availNames, addAvailToNameSet, pprAvail
+                       )
+import RnSource                ( rnHsType )
 import RnMonad
-import RnSource                ( rnTyDecl, rnClassDecl, rnInstDecl, rnPolyType )
-import RnUtils         ( RnEnv(..), lookupRnEnv, lookupTcRnEnv, extendGlobalRnEnv )
 import ParseIface      ( parseIface )
-import ParseUtils      ( ParsedIface(..), RdrIfaceDecl(..), RdrIfaceInst(..) )
 
-import Bag             ( emptyBag, snocBag, unionBags, unionManyBags, isEmptyBag, bagToList )
-import CmdLineOpts     ( opt_HiSuffix, opt_SysHiSuffix )
-import ErrUtils                ( Error(..), Warning(..) )
-import FiniteMap       ( emptyFM, lookupFM, addToFM, plusFM, eltsFM,
-                         fmToList, delListFromFM, keysFM{-ToDo:rm-}
-                       )
-import Maybes          ( maybeToBool )
-import Name            ( moduleNamePair, origName, isRdrLexCon,
-                         RdrName(..){-instance NamedThing-}
-                       )
-import PprStyle                -- ToDo:rm
-import Outputable      -- ToDo:rm
-import PrelInfo                ( builtinNameInfo )
+import ErrUtils                ( SYN_IE(Error), SYN_IE(Warning) )
+import FiniteMap       ( FiniteMap, emptyFM, unitFM, lookupFM, addToFM, addToFM_C, addListToFM, fmToList )
+import Name            ( Name {-instance NamedThing-}, Provenance, OccName(..),
+                         modAndOcc, occNameString, moduleString, pprModule,
+                         NameSet(..), emptyNameSet, unionNameSets, nameSetToList,
+                         minusNameSet, mkNameSet, elemNameSet,
+                         isWiredInName, maybeWiredInTyConName, maybeWiredInIdName
+                        )
+import Id              ( GenId, Id(..), idType, dataConTyCon, isDataCon )
+import TyCon           ( TyCon, tyConDataCons, isSynTyCon, getSynTyConDefn )
+import Type            ( namesOfType )
+import TyVar           ( GenTyVar )
+import SrcLoc          ( mkIfaceSrcLoc )
+import PrelMods                ( gHC__, isPreludeModule )
+import Bag
+import Maybes          ( MaybeErr(..), expectJust, maybeToBool )
+import ListSetOps      ( unionLists )
 import Pretty
-import Maybes          ( MaybeErr(..) )
-import UniqFM          ( emptyUFM )
-import UniqSupply      ( splitUniqSupply )
-import Util            ( startsWith, panic, pprPanic, assertPanic, pprTrace{-ToDo:rm-} )
+import PprStyle                ( PprStyle(..) )
+import Util            ( pprPanic, pprTrace )
+import StringBuffer     ( StringBuffer, hGetStringBuffer, freeStringBuffer )
+
 \end{code}
 
-\begin{code}
-type ModuleToIfaceContents = FiniteMap Module ParsedIface
-type ModuleToIfaceFilePath = FiniteMap Module FilePath
 
-type IfaceCache
-  = MutableVar _RealWorld (ModuleToIfaceContents,
-                          ModuleToIfaceFilePath)
-\end{code}
 
-*********************************************************
-*                                                      *
-\subsection{Looking for interface files}
-*                                                      *
-*********************************************************
+%*********************************************************
+%*                                                     *
+\subsection{Loading a new interface file}
+%*                                                     *
+%*********************************************************
 
-Return a mapping from module-name to
-absolute-filename-for-that-interface.
 \begin{code}
-findHiFiles :: [FilePath] -> [FilePath] -> IO (FiniteMap Module FilePath)
+loadInterface :: Pretty -> Module -> RnMG Ifaces
+loadInterface doc_str load_mod 
+  = getIfacesRn                `thenRn` \ ifaces ->
+    let
+       Ifaces this_mod mod_vers_map export_envs decls all_names imp_names insts inst_mods = ifaces
+    in
+       -- CHECK WHETHER WE HAVE IT ALREADY
+    if maybeToBool (lookupFM export_envs load_mod) 
+    then
+       returnRn ifaces         -- Already in the cache; don't re-read it
+    else
+
+       -- READ THE MODULE IN
+    findAndReadIface doc_str load_mod          `thenRn` \ read_result ->
+    case read_result of {
+       -- Check for not found
+       Nothing ->      -- Not found, so add an empty export env to the Ifaces map
+                       -- so that we don't look again
+                  let
+                       new_export_envs = addToFM export_envs load_mod ([],[])
+                       new_ifaces = Ifaces this_mod mod_vers_map
+                                           new_export_envs
+                                           decls all_names imp_names insts inst_mods
+                  in
+                  setIfacesRn new_ifaces               `thenRn_`
+                  failWithRn new_ifaces (noIfaceErr load_mod) ;
+
+       -- Found and parsed!
+       Just (ParsedIface _ mod_vers usages exports rd_inst_mods fixs rd_decls rd_insts) ->
+
+       -- LOAD IT INTO Ifaces
+    mapRn loadExport exports                           `thenRn` \ avails_s ->
+    foldlRn (loadDecl load_mod) decls rd_decls         `thenRn` \ new_decls ->
+    foldlRn (loadInstDecl load_mod) insts rd_insts     `thenRn` \ new_insts ->
+    let
+        export_env = (concat avails_s, fixs)
+
+                       -- Exclude this module from the "special-inst" modules
+        new_inst_mods = inst_mods `unionLists` (filter (/= this_mod) rd_inst_mods)
+
+        new_ifaces = Ifaces this_mod
+                            (addToFM mod_vers_map load_mod mod_vers)
+                            (addToFM export_envs load_mod export_env)
+                            new_decls
+                            all_names imp_names
+                            new_insts
+                            new_inst_mods 
+    in
+    setIfacesRn new_ifaces             `thenRn_`
+    returnRn new_ifaces
+    }
 
-findHiFiles dirs sysdirs
-  = do_dirs emptyFM (dirs ++ sysdirs)
+loadExport :: ExportItem -> RnMG [AvailInfo]
+loadExport (mod, entities)
+  = mapRn load_entity entities
+  where
+    new_name occ = newGlobalName mod occ
+
+-- The communcation between this little code fragment and the "entity" rule
+-- in ParseIface.y is a bit gruesome.  The idea is that things which are
+-- destined to be AvailTCs show up as (occ, [non-empty-list]), whereas
+-- things destined to be Avails show up as (occ, [])
+
+    load_entity (occ, occs)
+      =        new_name occ            `thenRn` \ name ->
+       if null occs then
+               returnRn (Avail name)
+       else
+               mapRn new_name occs     `thenRn` \ names ->
+               returnRn (AvailTC name names)
+
+loadDecl :: Module -> DeclsMap
+        -> (Version, RdrNameHsDecl)
+        -> RnMG DeclsMap
+loadDecl mod decls_map (version, decl)
+  = getDeclBinders new_implicit_name decl      `thenRn` \ avail ->
+    returnRn (addListToFM decls_map
+                         [(name,(version,avail,decl)) | name <- availNames avail]
+    )
   where
-    do_dirs env [] = return env
-    do_dirs env (dir:dirs)
-      = do_dir  env     dir    >>= \ new_env ->
-       do_dirs new_env dirs
-    -------
-    do_dir env dir
-      = --trace ("Having a go on..."++dir) $
-       getDirectoryContents dir    >>= \ entries ->
-       do_entries env entries
-      where
-       do_entries env [] = return env
-       do_entries env (e:es)
-         = do_entry   env     e    >>= \ new_env ->
-           do_entries new_env es
-       -------
-       do_entry env e
-         = case (acceptable_hi (reverse e)) of
-             Nothing  -> --trace ("Deemed uncool:"++e) $
-                         return env
-             Just mod ->
-               let
-                     pmod = _PK_ mod
-               in
-               case (lookupFM env pmod) of
-                 Nothing -> --trace ("Adding "++mod++" -> "++e) $
-                            return (addToFM env pmod (dir ++ '/':e))
-                            -- ToDo: use DIR_SEP, not /
-
-                 Just xx -> ( if de_dot xx /= e then trace ("Already mapped!! "++mod++" -> "++xx++"; ignoring:"++e) else id) $
-                            return env
-    -------
-    acceptable_hi rev_e -- looking at pathname *backwards*
-      = case (startsWith (reverse opt_HiSuffix) rev_e) of
-         Nothing -> Nothing
-         Just xs -> plausible_modname xs{-reversed-}
-
-    -------
-    de_dot ('.' : '/' : xs) = xs
-    de_dot xs              = xs
-
-    -------
-    plausible_modname rev_e
-      = let
-           cand = reverse (takeWhile is_modname_char rev_e)
-       in
-       if null cand || not (isUpper (head cand))
-       then Nothing
-       else Just cand
-      where
-       is_modname_char c = isAlphanum c || c == '_'
+    new_implicit_name rdr_name loc = newGlobalName mod (rdrNameOcc rdr_name)
+
+loadInstDecl :: Module
+            -> Bag IfaceInst
+            -> RdrNameInstDecl
+            -> RnMG (Bag IfaceInst)
+loadInstDecl mod_name insts decl@(InstDecl inst_ty binds uprags dfun_name src_loc)
+  = 
+       -- Find out what type constructors and classes are "gates" for the
+       -- instance declaration.  If all these "gates" are slurped in then
+       -- we should slurp the instance decl too.
+       -- 
+       -- We *don't* want to count names in the context part as gates, though.
+       -- For example:
+       --              instance Foo a => Baz (T a) where ...
+       --
+       -- Here the gates are Baz and T, but *not* Foo.
+    let 
+       munged_inst_ty = case inst_ty of
+                               HsForAllTy tvs cxt ty -> HsForAllTy tvs [] ty
+                               HsPreForAllTy cxt ty  -> HsPreForAllTy [] ty
+                               other                 -> inst_ty
+    in
+       -- We find the gates by renaming the instance type with in a 
+       -- and returning the occurrence pool.
+    initRnMS emptyRnEnv mod_name InterfaceMode (
+        findOccurrencesRn (rnHsType munged_inst_ty)    
+    )                                          `thenRn` \ gate_names ->
+    returnRn (((mod_name, decl), gate_names) `consBag` insts)
 \end{code}
 
-*********************************************************
-*                                                      *
-\subsection{Reading interface files}
-*                                                      *
-*********************************************************
 
-Return cached info about a Module's interface; otherwise,
-read the interface (using our @ModuleToIfaceFilePath@ map
-to decide where to look).
+%********************************************************
+%*                                                     *
+\subsection{Loading usage information}
+%*                                                     *
+%********************************************************
 
 \begin{code}
-cachedIface :: IfaceCache
-           -> Module
-           -> IO (MaybeErr ParsedIface Error)
-
-cachedIface iface_cache mod
-  = readVar iface_cache `thenPrimIO` \ (iface_fm, file_fm) ->
-
-    case (lookupFM iface_fm mod) of
-      Just iface -> return (Succeeded iface)
-      Nothing    ->
-       case (lookupFM file_fm mod) of
-         Nothing   -> return (Failed (noIfaceErr mod))
-         Just file ->
-           readIface file mod >>= \ read_iface ->
-           case read_iface of
-             Failed err      -> -- pprTrace "module-file map:\n" (ppAboves [ppCat [ppPStr m, ppStr f] | (m,f) <- fmToList file_fm]) $
-                                return (Failed err)
-             Succeeded iface ->
-               let
-                   iface_fm' = addToFM iface_fm mod iface
-               in
-               writeVar iface_cache (iface_fm', file_fm) `seqPrimIO`
-               return (Succeeded iface)
-
-----------
-cachedDecl :: IfaceCache
-          -> Bool      -- True <=> tycon or class name
-          -> RdrName
-          -> IO (MaybeErr RdrIfaceDecl Error)
-
--- ToDo: this is where the check for Prelude.map being
---       located in PreludeList.map should be done ...
-
-cachedDecl iface_cache class_or_tycon orig 
-  = cachedIface iface_cache mod        >>= \ maybe_iface ->
-    case maybe_iface of
-      Failed err -> return (Failed err)
-      Succeeded (ParsedIface _ _ _ _ exps _ _ tdefs vdefs _ _) -> 
-       case (lookupFM (if class_or_tycon then tdefs else vdefs) str) of
-         Just decl -> return (Succeeded decl)
-         Nothing   -> return (Failed (noDeclInIfaceErr mod str))
+checkUpToDate :: Module -> RnMG Bool           -- True <=> no need to recompile
+checkUpToDate mod_name
+  = findAndReadIface doc_str mod_name          `thenRn` \ read_result ->
+    case read_result of
+       Nothing ->      -- Old interface file not found, so we'd better bail out
+                   traceRn (ppSep [ppPStr SLIT("Didnt find old iface"), 
+                                   pprModule PprDebug mod_name])       `thenRn_`
+                   returnRn False
+
+       Just (ParsedIface _ _ usages _ _ _ _ _) 
+               ->      -- Found it, so now check it
+                   checkModUsage usages
   where
-    (mod, str) = moduleNamePair orig
-
-----------
-cachedDeclByType :: IfaceCache
-                -> RnName{-NB: diff type than cachedDecl -}
-                -> IO (MaybeErr RdrIfaceDecl Error)
-
-cachedDeclByType iface_cache rn
-    -- the idea is: check that, e.g., if we're given an
-    -- RnClass, then we really get back a ClassDecl from
-    -- the cache (not an RnData, or something silly)
-  = cachedDecl iface_cache (isRnTyConOrClass rn) (origName rn)  >>= \ maybe_decl ->
+       -- Only look in current directory, with suffix .hi
+    doc_str = ppSep [ppPStr SLIT("Need usage info from"), pprModule PprDebug mod_name]
+
+
+checkModUsage [] = returnRn True               -- Yes!  Everything is up to date!
+
+checkModUsage ((mod, old_mod_vers, old_local_vers) : rest)
+  = loadInterface doc_str mod          `thenRn` \ ifaces ->
     let
-       return_maybe_decl = return maybe_decl
-       return_failed msg = return (Failed msg)
+       Ifaces _ mod_vers _ decls _ _ _ _ = ifaces
+       maybe_new_mod_vers = lookupFM mod_vers mod
+       Just new_mod_vers  = maybe_new_mod_vers
     in
-    case maybe_decl of
-      Failed _ -> return_maybe_decl
-      Succeeded if_decl ->
-       case rn of
-         WiredInId _       -> return_failed (ifaceLookupWiredErr "value" rn)
-         WiredInTyCon _    -> return_failed (ifaceLookupWiredErr "type constructor" rn)
-         RnUnbound _       -> pprPanic "cachedDeclByType:" (ppr PprDebug rn)
-         
-         RnSyn _           -> return_maybe_decl
-         RnData _ _        -> return_maybe_decl
-         RnImplicitTyCon _ -> if is_tycon_decl if_decl
-                              then return_maybe_decl
-                              else return_failed (badIfaceLookupErr "type constructor" rn if_decl)
-         
-         RnClass _ _       -> return_maybe_decl
-         RnImplicitClass _ -> if is_class_decl if_decl
-                              then return_maybe_decl
-                              else return_failed (badIfaceLookupErr "class" rn if_decl)
-         
-         RnName _          ->  return_maybe_decl
-         RnConstr _ _      ->  return_maybe_decl
-         RnClassOp _ _     ->  return_maybe_decl
-         RnImplicit _      ->  if is_val_decl if_decl
-                               then return_maybe_decl
-                               else return_failed (badIfaceLookupErr "value/method" rn if_decl)
+       -- If we can't find a version number for the old module then
+       -- bail out saying things aren't up to date
+    if not (maybeToBool maybe_new_mod_vers) then
+       returnRn False
+    else
+
+       -- If the module version hasn't changed, just move on
+    if new_mod_vers == old_mod_vers then
+       traceRn (ppSep [ppPStr SLIT("Module version unchanged:"), pprModule PprDebug mod])      `thenRn_`
+       checkModUsage rest
+    else
+    traceRn (ppSep [ppPStr SLIT("Module version has changed:"), pprModule PprDebug mod])       `thenRn_`
+
+       -- New module version, so check entities inside
+    checkEntityUsage mod decls old_local_vers  `thenRn` \ up_to_date ->
+    if up_to_date then
+       traceRn (ppPStr SLIT("...but the bits I use haven't.")) `thenRn_`
+       checkModUsage rest      -- This one's ok, so check the rest
+    else
+       returnRn False          -- This one failed, so just bail out now
   where
-    is_tycon_decl (TypeSig _ _ _)      = True
-    is_tycon_decl (NewTypeSig _ _ _ _) = True
-    is_tycon_decl (DataSig _ _ _ _)    = True
-    is_tycon_decl _                    = False
-
-    is_class_decl (ClassSig _ _ _ _)   = True
-    is_class_decl _                    = False
-
-    is_val_decl (ValSig _ _ _)         = True
-    is_val_decl (ClassSig _ _ _ _)     = True  -- if the thing we were after *happens* to
-                                               -- be a class op; we will have fished a ClassSig
-                                               -- out of the interface for it.
-    is_val_decl _                      = False
+    doc_str = ppSep [ppPStr SLIT("need version info for"), pprModule PprDebug mod]
+
+
+checkEntityUsage mod decls [] 
+  = returnRn True      -- Yes!  All up to date!
+
+checkEntityUsage mod decls ((occ_name,old_vers) : rest)
+  = newGlobalName mod occ_name         `thenRn` \ name ->
+    case lookupFM decls name of
+
+       Nothing       ->        -- We used it before, but it ain't there now
+                         traceRn (ppSep [ppPStr SLIT("...and this no longer exported:"), ppr PprDebug name])   `thenRn_`
+                         returnRn False
+
+       Just (new_vers,_,_)     -- It's there, but is it up to date?
+               | new_vers == old_vers
+                       -- Up to date, so check the rest
+               -> checkEntityUsage mod decls rest
+
+               | otherwise
+                       -- Out of date, so bale out
+               -> traceRn (ppSep [ppPStr SLIT("...and this is out of date:"), ppr PprDebug name])  `thenRn_`
+                  returnRn False
 \end{code}
 
+
+%*********************************************************
+%*                                                     *
+\subsection{Getting in a declaration}
+%*                                                     *
+%*********************************************************
+
 \begin{code}
-readIface :: FilePath -> Module
-             -> IO (MaybeErr ParsedIface Error)
+importDecl :: Name -> Necessity -> RnMG (Maybe RdrNameHsDecl)
+       -- Returns Nothing for a wired-in or already-slurped decl
+
+importDecl name necessity
+  = checkSlurped name                  `thenRn` \ already_slurped ->
+    if already_slurped then
+       -- traceRn (ppSep [ppStr "Already slurped:", ppr PprDebug name])        `thenRn_`
+       returnRn Nothing        -- Already dealt with
+    else
+    if isWiredInName name then
+       getWiredInDecl name
+    else 
+       getIfacesRn             `thenRn` \ ifaces ->
+       let
+         Ifaces this_mod _ _ _ _ _ _ _ = ifaces
+         (mod,_) = modAndOcc name
+       in
+       if mod == this_mod  then    -- Don't bring in decls from
+         pprTrace "importDecl wierdness:" (ppr PprDebug name) $
+         returnRn Nothing         -- the renamed module's own interface file
+                                  -- 
+       else
+       getNonWiredInDecl name necessity
 
-readIface file mod
-  = readFile file   `thenPrimIO` \ read_result ->
-    case read_result of
-      Left  err      -> return (Failed (cannaeReadErr file err))
-      Right contents -> return (parseIface contents)
 \end{code}
 
+\begin{code}
+getNonWiredInDecl :: Name -> Necessity -> RnMG (Maybe RdrNameHsDecl)
+getNonWiredInDecl name necessity
+  = traceRn doc_str                    `thenRn_`
+    loadInterface doc_str mod          `thenRn` \ (Ifaces _ _ _ decls _ _ _ _) ->
+    case lookupFM decls name of
+
+      Just (version,avail,decl) -> recordSlurp (Just version) avail    `thenRn_`
+                                  returnRn (Just decl)
+
+      Nothing ->       -- Can happen legitimately for "Optional" occurrences
+                  case necessity of { 
+                               Optional -> addWarnRn (getDeclWarn name);
+                               other    -> addErrRn  (getDeclErr  name)
+                  }                                            `thenRn_` 
+                  returnRn Nothing
+  where
+     doc_str = ppSep [ppPStr SLIT("Need decl for"), ppr PprDebug name]
+     (mod,_) = modAndOcc name
+\end{code}
+
+@getWiredInDecl@ maps a wired-in @Name@ to what it makes available.
+It behaves exactly as if the wired in decl were actually in an interface file.
+Specifically,
+
+  *    if the wired-in name is a data type constructor or a data constructor, 
+       it brings in the type constructor and all the data constructors; and
+       marks as "occurrences" any free vars of the data con.
+
+  *    similarly for synonum type constructor
 
+  *    if the wired-in name is another wired-in Id, it marks as "occurrences"
+       the free vars of the Id's type.
+
+  *    it loads the interface file for the wired-in thing for the
+       sole purpose of making sure that its instance declarations are available
+
+All this is necessary so that we know all types that are "in play", so
+that we know just what instances to bring into scope.
+       
 \begin{code}
-rnIfaces :: IfaceCache                 -- iface cache (mutvar)
-        -> UniqSupply
-        -> RnEnv                       -- defined (in the source) name env
-        -> RnEnv                       -- mentioned (in the source) name env 
-        -> RenamedHsModule             -- module to extend with iface decls
-        -> [RnName]                    -- imported names required (really the
-                                       -- same info as in mentioned name env)
-                                       -- Also, all the things we may look up
-                                       -- later by key (Unique).
-        -> IO (RenamedHsModule,        -- extended module
-               ImplicitEnv,            -- implicit names used (for usage info)
-               Bag Error,
-               Bag Warning)
-
-rnIfaces iface_cache us
-        def_env@((dqual, dunqual, dtc_qual, dtc_unqual), dstack)
-        occ_env@((qual, unqual, tc_qual, tc_unqual), stack)
-        rn_module@(HsModule modname iface_version exports imports fixities
-                     typedecls typesigs classdecls instdecls instsigs
-                     defdecls binds sigs src_loc)
-        todo
-  = {-pprTrace "rnIfaces:going after:" (ppCat (map (ppr PprDebug) todo)) $
-
-    pprTrace "rnIfaces:qual:"      (ppCat [ppBesides[ppPStr m,ppChar '.',ppPStr n] | (m,n) <- keysFM qual]) $
-    pprTrace "rnIfaces:unqual:"    (ppCat (map ppPStr (keysFM unqual))) $
-    pprTrace "rnIfaces:tc_qual:"   (ppCat [ppBesides[ppPStr m,ppChar '.',ppPStr n] | (m,n) <- keysFM tc_qual]) $
-    pprTrace "rnIfaces:tc_unqual:" (ppCat (map ppPStr (keysFM tc_unqual))) $
-
-    pprTrace "rnIfaces:dqual:"     (ppCat [ppBesides[ppPStr m,ppChar '.',ppPStr n] | (m,n) <- keysFM dqual]) $
-    pprTrace "rnIfaces:dunqual:"   (ppCat (map ppPStr (keysFM dunqual))) $
-    pprTrace "rnIfaces:dtc_qual:"  (ppCat [ppBesides[ppPStr m,ppChar '.',ppPStr n] | (m,n) <- keysFM dtc_qual]) $
-    pprTrace "rnIfaces:dtc_unqual:"(ppCat (map ppPStr (keysFM dtc_unqual))) $
-    -}
+getWiredInDecl name
+  = get_wired                          `thenRn` \ avail ->
+    recordSlurp Nothing avail          `thenRn_`
+
+       -- Force in the home module in case it has instance decls for
+       -- the thing we are interested in.
+       --
+       -- Mini hack 1: no point for non-tycons/class; and if we
+       -- do this we find PrelNum trying to import PackedString,
+       -- because PrelBase's .hi file mentions PackedString.unpackString
+       -- But PackedString.hi isn't built by that point!
+       --
+       -- Mini hack 2; GHC is guaranteed not to have
+       -- instance decls, so it's a waste of time to read it
+       --
+       -- NB: We *must* look at the availName of the slurped avail, 
+       -- not the name passed to getWiredInDecl!  Why?  Because if a data constructor 
+       -- or class op is passed to getWiredInDecl we'll pull in the whole data/class
+       -- decl, and recordSlurp will record that fact.  But since the data constructor
+       -- isn't a tycon/class we won't force in the home module.  And even if the
+       -- type constructor/class comes along later, loadDecl will say that it's already
+       -- been slurped, so getWiredInDecl won't even be called.  Pretty obscure bug, this was.
     let
-       (us1,us2) = splitUniqSupply us
+       main_name  = availName avail
+       main_is_tc = case avail of { AvailTC _ _ -> True; Avail _ -> False }
+       (mod,_)    = modAndOcc main_name
+       doc_str    = ppSep [ppPStr SLIT("Need home module for wired in thing"), ppr PprDebug name]
     in
-
-    -- do transitive closure to bring in all needed names/defns:
-
-    loop todo        -- initial batch of names to process
-        (def_env, occ_env, us1) -- init stuff down
-        empty_return -- init acc results
-        >>= \ (((if_typedecls, if_classdecls, if_sigs),
-                if_implicits,
-                (if_errs, if_warns)),
-               new_occ_env) ->
-
-    -- go back and handle instance things:
-
-    rnIfaceInstStuff iface_cache modname us2 new_occ_env if_implicits
-        >>= \ (if_instdecls, (ifi_errs, ifi_warns)) ->
-
-    return (
-       HsModule modname iface_version exports imports fixities
-                (typedecls ++ if_typedecls)
-                typesigs
-                (classdecls ++ if_classdecls)
-                (instdecls  ++ if_instdecls)
-                instsigs defdecls binds
-                (sigs ++ if_sigs)
-                src_loc,
-       if_implicits,
-       if_errs  `unionBags` ifi_errs,
-       if_warns `unionBags` ifi_warns
-    )
+    (if not main_is_tc || mod == gHC__ then
+       returnRn ()             
+    else
+       loadInterface doc_str mod       `thenRn_`
+       returnRn ()
+    )                                  `thenRn_`
+
+    returnRn Nothing           -- No declaration to process further
   where
-    loop :: [RnName]     -- Names we're looking for; we keep adding/deleting
-                         -- from this list; we're done when empty (nothing
-                         -- more needs to be looked for)
-        -> Go_Down       -- see defn below
-        -> To_Return     -- accumulated result
-        -> IO (To_Return, RnEnv{-final occurrence env; to pass on for doing instances-})
-
-    loop to_find@[] down to_return = return (to_return, occenv down)
-
-    loop to_find@(n:ns) down to_return 
-      = case (lookup_defd down (origName n)) of
-         Just  _ -> -- previous processing must've found the stuff for this name;
-                    -- continue with the rest:
-                    -- pprTrace "loop:done:" (ppr PprDebug n) $
-                    loop ns down to_return
-
-         Nothing -> -- OK, see what the cache has for us...
-
-           cachedDeclByType iface_cache n >>= \ maybe_ans ->
-           case maybe_ans of
-             Failed err -> -- add the error, but keep going:
-                           -- pprTrace "loop:cache error:" (ppr PprDebug n) $
-                           loop ns down (add_err err to_return)
-
-             Succeeded iface_decl -> -- something needing renaming!
-               let
-                   (us1, us2) = splitUniqSupply (uniqsupply down)
-               in
-               case (initRn False{-iface-} modname (occenv down) us1 (
-                       setExtraRn emptyUFM{-ignore fixities-} $
-                       rnIfaceDecl iface_decl)) of {
-                 ((if_decl, if_defd, if_implicits), if_errs, if_warns) ->
-                   let
-                       new_unknowns = eltsFM (fst if_implicits) ++ eltsFM (snd if_implicits)
-                   in
---                 pprTrace "loop:renamed:" (ppAboves [ppr PprDebug n
---                     , ppCat [ppStr "new unknowns:", interpp'SP PprDebug new_unknowns]
---                     , ppCat [ppStr "defd vals:", interpp'SP PprDebug [n | (_,n) <- fst if_defd] ]
---                     , ppCat [ppStr "defd  tcs:", interpp'SP PprDebug [n | (_,n) <- snd if_defd] ]
---                     ]) $
-                   loop (new_unknowns ++ ns)
-                        (add_occs       if_defd if_implicits $
-                         new_uniqsupply us2 down)
-                        (add_decl       if_decl        $
-                         add_implicits  if_implicits   $
-                         add_errs       if_errs        $
-                         add_warns      if_warns to_return)
-               }
-
------------
-type Go_Down   = (RnEnv,       -- stuff we already have defns for;
-                               -- to check quickly if we've already
-                               -- found something for the name under consideration,
-                               -- due to previous processing.
-                               -- It starts off just w/ the defns for
-                               -- the things in this module.
-                 RnEnv,        -- occurrence env; this gets added to as
-                               -- we process new iface decls.  It includes
-                               -- entries for *all* occurrences, including those
-                               -- for which we have definitions.
-                 UniqSupply    -- the obvious
-                )
-
-lookup_defd (def_env, _, _) n
-  = (if isRdrLexCon n then lookupTcRnEnv else lookupRnEnv) def_env n
-
-occenv    (_, occ_env, _) = occ_env
-uniqsupply (_, _,      us) = us
-
-new_uniqsupply us (def_env, occ_env, _) = (def_env, occ_env, us)
-
-add_occs (val_defds, tc_defds) (val_imps, tc_imps) (def_env, occ_env, us)
-  = case (extendGlobalRnEnv def_env val_defds tc_defds) of { (new_def_env, def_dups) ->
-    ASSERT(isEmptyBag def_dups)
-    let
-       val_occs = val_defds ++ fmToList val_imps
-       tc_occs  = tc_defds  ++ fmToList tc_imps
-    in
-    case (extendGlobalRnEnv occ_env val_occs tc_occs)   of { (new_occ_env, occ_dups) ->
 
---  ASSERT(isEmptyBag occ_dups)
--- False because we may get a dup on the name we just shoved in
+    get_wired | is_tycon                       -- ... a type constructor
+             = get_wired_tycon the_tycon
 
-    (new_def_env, new_occ_env, us) }}
+             | (isDataCon the_id)              -- ... a wired-in data constructor
+             = get_wired_tycon (dataConTyCon the_id)
 
-----------------
-type To_Return = (([RenamedTyDecl], [RenamedClassDecl], [RenamedSig]),
-                 ImplicitEnv,  -- new names used implicitly
-                 (Bag Error, Bag Warning)
-                )
-
-empty_return :: To_Return
-empty_return = (([],[],[]), emptyImplicitEnv, (emptyBag,emptyBag))
-
-add_decl decl ((tydecls, classdecls, sigs), implicit, msgs)
-  = case decl of
-      AddedTy   t -> ((t:tydecls, classdecls, sigs), implicit, msgs)
-      AddedClass c -> ((tydecls, c:classdecls, sigs), implicit, msgs)
-      AddedSig  s -> ((tydecls, classdecls, s:sigs), implicit, msgs)
-
-add_implicits (val_imps, tc_imps) (decls, (val_fm, tc_fm), msgs)
-  = (decls, (val_fm `plusFM` val_imps, tc_fm `plusFM`  tc_imps), msgs)
+             | otherwise                       -- ... a wired-in non data-constructor
+             = get_wired_id the_id
+
+    maybe_wired_in_tycon = maybeWiredInTyConName name
+    is_tycon            = maybeToBool maybe_wired_in_tycon
+    maybe_wired_in_id    = maybeWiredInIdName    name
+    Just the_tycon      = maybe_wired_in_tycon
+    Just the_id         = maybe_wired_in_id
+
+
+get_wired_id id
+  = addImplicitOccsRn (nameSetToList id_mentioned)     `thenRn_`
+    returnRn (Avail (getName id))
   where
-    pairify rn = (origName rn, rn)
+    id_mentioned = namesOfType (idType id)
 
-add_err  err (decls,implicit,(errs,warns)) = (decls,implicit,(errs `snocBag`   err,warns))
-add_errs ers (decls,implicit,(errs,warns)) = (decls,implicit,(errs `unionBags` ers,warns))
-add_warns ws (decls,implicit,(errs,warns)) = (decls,implicit,(errs, warns `unionBags` ws))
+get_wired_tycon tycon 
+  | isSynTyCon tycon
+  = addImplicitOccsRn (nameSetToList mentioned)                `thenRn_`
+    returnRn (Avail (getName tycon))
+  where
+    (tyvars,ty) = getSynTyConDefn tycon
+    mentioned = namesOfType ty `minusNameSet` mkNameSet (map getName tyvars)
+
+get_wired_tycon tycon 
+  | otherwise          -- data or newtype
+  = addImplicitOccsRn (nameSetToList mentioned)                `thenRn_`
+    returnRn (AvailTC tycon_name (tycon_name : map getName data_cons))
+  where
+    tycon_name = getName tycon
+    data_cons  = tyConDataCons tycon
+    mentioned  = foldr (unionNameSets . namesOfType . idType) emptyNameSet data_cons
 \end{code}
 
+
 \begin{code}
-data AddedDecl -- purely local
-  = AddedTy    RenamedTyDecl
-  | AddedClass RenamedClassDecl
-  | AddedSig   RenamedSig
-
-rnIfaceDecl :: RdrIfaceDecl
-           -> RnM_Fixes _RealWorld
-                  (AddedDecl,  -- the resulting decl to add to the pot
-                   ([(RdrName,RnName)], [(RdrName,RnName)]),
-                               -- new val/tycon-class names that have
-                               -- *been defined* while processing this decl
-                   ImplicitEnv -- new implicit val/tycon-class names that we
-                               -- stumbled into
-                  )
-
-rnIfaceDecl (TypeSig tc _ decl)
-  = rnTyDecl    decl   `thenRn` \ rn_decl   ->
-    lookupTyCon tc     `thenRn` \ rn_tc     ->
-    getImplicitUpRn    `thenRn` \ mentioned ->
-    let
-       defds = ([], [(tc, rn_tc)])
-       implicits = mentioned `sub` defds
-    in
-    returnRn (AddedTy rn_decl, defds, implicits)
+checkSlurped name
+  = getIfacesRn        `thenRn` \ (Ifaces _ _ _ _ slurped_names _ _ _) ->
+    returnRn (name `elemNameSet` slurped_names)
 
-rnIfaceDecl (NewTypeSig tc dc _ decl)
-  = rnTyDecl    decl   `thenRn` \ rn_decl   ->
-    lookupTyCon tc     `thenRn` \ rn_tc     ->
-    lookupValue dc     `thenRn` \ rn_dc     ->
-    getImplicitUpRn    `thenRn` \ mentioned ->
+recordSlurp maybe_version avail
+  = -- traceRn (ppSep [ppStr "Record slurp:", pprAvail PprDebug avail])        `thenRn_`
+    getIfacesRn        `thenRn` \ ifaces ->
     let
-       defds = ([(dc, rn_dc)], [(tc, rn_tc)])
-       implicits = mentioned `sub` defds
+       Ifaces this_mod mod_vers export_envs decls slurped_names imp_names insts inst_mods = ifaces
+       new_slurped_names = addAvailToNameSet slurped_names avail
+
+       new_imp_names = case maybe_version of
+                          Just version -> (availName avail, version) : imp_names
+                          Nothing      -> imp_names
+
+       new_ifaces = Ifaces this_mod mod_vers export_envs decls 
+                           new_slurped_names 
+                           new_imp_names
+                           insts
+                           inst_mods
     in
-    returnRn (AddedTy rn_decl, defds, implicits)
+    setIfacesRn new_ifaces
+\end{code}
+    
+%*********************************************************
+%*                                                     *
+\subsection{Getting other stuff}
+%*                                                     *
+%*********************************************************
 
-rnIfaceDecl (DataSig tc dcs _ decl)
-  = rnTyDecl    decl           `thenRn` \ rn_decl   ->
-    lookupTyCon tc             `thenRn` \ rn_tc     ->
-    mapRn lookupValue dcs      `thenRn` \ rn_dcs    ->
-    getImplicitUpRn            `thenRn` \ mentioned ->
-    let
-       defds = (dcs `zip` rn_dcs, [(tc, rn_tc)])
-       implicits = mentioned `sub` defds
-    in
-    returnRn (AddedTy rn_decl, defds, implicits)
+\begin{code}
+getInterfaceExports :: Module -> RnMG (Avails, [(OccName,Fixity)])
+getInterfaceExports mod
+  = loadInterface doc_str mod          `thenRn` \ (Ifaces _ _ export_envs _ _ _ _ _) ->
+    case lookupFM export_envs mod of
+       Nothing ->      -- Not there; it must be that the interface file wasn't found;
+                       -- the error will have been reported already.
+                       -- (Actually loadInterface should put the empty export env in there
+                       --  anyway, but this does no harm.)
+                     returnRn ([],[])
+
+       Just stuff -> returnRn stuff
+  where
+    doc_str = ppSep [pprModule PprDebug mod, ppPStr SLIT("is directly imported")]
+
+
+getImportedInstDecls :: RnMG [(Module,RdrNameInstDecl)]
+getImportedInstDecls
+  =    -- First load any special-instance modules that aren't aready loaded
+    getSpecialInstModules                      `thenRn` \ inst_mods ->
+    mapRn load_it inst_mods                    `thenRn_`
 
-rnIfaceDecl (ClassSig clas ops _ decl)
-  = rnClassDecl decl                   `thenRn` \ rn_decl   ->
-    lookupClass clas                   `thenRn` \ rn_clas   ->
-    mapRn (lookupClassOp rn_clas) ops  `thenRn` \ rn_ops    ->
-    getImplicitUpRn                    `thenRn` \ mentioned ->
+       -- Now we're ready to grab the instance declarations
+       -- Find the un-gated ones and return them, 
+       -- removing them from the bag kept in Ifaces
+    getIfacesRn        `thenRn` \ ifaces ->
     let
-       defds = (ops `zip` rn_ops, [(clas, rn_clas)])
-       implicits = mentioned `sub` defds
+       Ifaces this_mod mod_vers export_envs decls slurped_names imp_names insts inst_mods = ifaces
+
+               -- An instance decl is ungated if all its gates have been slurped
+        select_ungated :: IfaceInst                                    -- A gated inst decl
+
+                      -> ([(Module, RdrNameInstDecl)], [IfaceInst])    -- Accumulator
+
+                      -> ([(Module, RdrNameInstDecl)],                 -- The ungated ones
+                          [IfaceInst])                                 -- Still gated, but with
+                                                                       -- depeleted gates
+       select_ungated (decl,gates) (ungated_decls, gated_decls)
+         | null remaining_gates
+         = (decl : ungated_decls, gated_decls)
+         | otherwise
+         = (ungated_decls, (decl, remaining_gates) : gated_decls)
+         where
+           remaining_gates = filter (not . (`elemNameSet` slurped_names)) gates
+
+       (un_gated_insts, still_gated_insts) = foldrBag select_ungated ([], []) insts
+       
+       new_ifaces = Ifaces this_mod mod_vers export_envs decls slurped_names imp_names
+                           (listToBag still_gated_insts)
+                           inst_mods
     in
-    returnRn (AddedClass rn_decl, defds, implicits)
-
-rnIfaceDecl (ValSig f src_loc ty)
-    -- should rename_sig in RnBinds be used here? ToDo
-  = lookupValue f                      `thenRn` \ rn_f  ->
-    -- pprTrace "rnIfaceDecl:ValSig:" (ppr PprDebug ty) $
-    rnPolyType nullTyVarNamesEnv ty    `thenRn` \ rn_ty ->
-    getImplicitUpRn                    `thenRn` \ mentioned ->
+    setIfacesRn new_ifaces     `thenRn_`
+    returnRn un_gated_insts
+  where
+    load_it mod = loadInterface (doc_str mod) mod
+    doc_str mod = ppSep [pprModule PprDebug mod, ppPStr SLIT("is a special-instance module")]
+
+
+getSpecialInstModules :: RnMG [Module]
+getSpecialInstModules 
+  = getIfacesRn                                                `thenRn` \ ifaces ->
     let
-       defds = ([(f, rn_f)], [])
-       implicits = mentioned `sub` defds
+        Ifaces _ _ _ _ _ _ _ inst_mods = ifaces
     in
-    returnRn (AddedSig (Sig rn_f rn_ty noGenPragmas src_loc), defds, implicits)
+    returnRn inst_mods
+\end{code}
 
-----
-sub :: ImplicitEnv -> ([(RdrName,RnName)], [(RdrName,RnName)]) -> ImplicitEnv
+getImportVersions figures out what the "usage information" for this moudule is;
+that is, what it must record in its interface file as the things it uses.
+It records:
+       - anything reachable from its body code
+       - any module exported with a "module Foo".
 
-sub (val_ment, tc_ment) (val_defds, tc_defds)
-  = (delListFromFM val_ment (map fst val_defds),
-     delListFromFM tc_ment  (map fst tc_defds))
-\end{code}
+Why the latter?  Because if Foo changes then this module's export list
+will change, so we must recompile this module at least as far as
+making a new interface file --- but in practice that means complete
+recompilation.
+
+What about this? 
+       module A( f, g ) where          module B( f ) where
+         import B( f )                   f = h 3
+         g = ...                         h = ...
+
+Should we record B.f in A's usages?  In fact we don't.  Certainly, if
+anything about B.f changes than anyone who imports A should be recompiled;
+they'll get an early exit if they don't use B.f.  However, even if B.f
+doesn't change at all, B.h may do so, and this change may not be reflected
+in f's version number.  So there are two things going on when compiling module A:
 
-% ------------------------------
+1.  Are A.o and A.hi correct?  Then we can bale out early.
+2.  Should modules that import A be recompiled?
 
-@rnIfaceInstStuff@: Deal with instance declarations from interface files.
+For (1) it is slightly harmful to record B.f in A's usages, because a change in
+B.f's version will provoke full recompilation of A, producing an identical A.o,
+and A.hi differing only in its usage-version of B.f (which isn't used by any importer).
+
+For (2), because of the tricky B.h question above, we ensure that A.hi is touched
+(even if identical to its previous version) if A's recompilation was triggered by
+an imported .hi file date change.  Given that, there's no need to record B.f in
+A's usages.
+
+On the other hand, if A exports "module B" then we *do* count module B among
+A's usages, because we must recompile A to ensure that A.hi changes appropriately.
 
 \begin{code}
-rnIfaceInstStuff
-       :: IfaceCache   -- all about ifaces we've read
-       -> Module
-       -> UniqSupply
-       -> RnEnv
-       -> ImplicitEnv  -- info about all names we've used
-       -> IO ([RenamedInstDecl],
-              (Bag Error, Bag Warning))
-
-rnIfaceInstStuff iface_cache modname us occ_env implicit_env
-  = -- nearly all the instance decls we might even want
-    -- to consider are in the ParsedIfaces that are in our
-    -- cache; any *other* instances to consider are in any
-    -- "instance modules" fields that we've encounted.
-    -- Get both:
-
-    readVar iface_cache        `thenPrimIO` \ (iface_fm, _) ->
-    let
-       ifaces_so_far   = eltsFM iface_fm
-       all_iface_imods = unionManyBags (map get_ims   ifaces_so_far)
-       insts_so_far    = unionManyBags (map get_insts ifaces_so_far)
-    in
-    -- OK, get all the instance decls out of the "instance module"
-    -- modules:
+getImportVersions :: Module                    -- Name of this module
+                 -> Maybe [IE any]             -- Export list for this module
+                 -> RnMG (VersionInfo Name)    -- Version info for these names
 
-    read_iface_imods iface_fm (bagToList all_iface_imods) emptyBag emptyBag{-accumulators-}
-                       >>= \ (more_insts, ims_errs) ->
+getImportVersions this_mod exports
+  = getIfacesRn                                        `thenRn` \ ifaces ->
     let
-       all_insts = insts_so_far `unionBags` more_insts
+        Ifaces _ mod_versions_map _ _ _ imp_names _ _ = ifaces
+        mod_version mod = expectJust "import_versions" (lookupFM mod_versions_map mod)
 
-       -- an instance decl can only be of interest if *both*
-       -- its class and tycon have made their way into our
-       -- purview:
-       interesting_insts = filter (good_inst implicit_env) (bagToList all_insts)
+        -- mv_map groups together all the things imported from a particular module.
+        mv_map, mv_map_mod :: FiniteMap Module [LocalVersion Name]
+
+        mv_map_mod = foldl add_mod emptyFM export_mods
+               -- mv_map_mod records all the modules that have a "module M"
+               -- in this module's export list
+
+        mv_map = foldl add_mv mv_map_mod imp_names
+               -- mv_map adds the version numbers of things exported individually
     in
---    pprTrace "in implicit:\n"            (ppCat (map (ppr PprDebug) (keysFM (snd implicit_env)))) $
---    pprTrace "insts_so_far:\n"      (ppr_insts (bagToList insts_so_far)) $
---    pprTrace "more_insts:\n"        (ppr_insts (bagToList more_insts)) $
---    pprTrace "interesting_insts:\n" (ppr_insts interesting_insts) $
-    -- Do the renaming for real:
-    --
-    case (initRn False{-iface-} modname occ_env us (
-           setExtraRn emptyUFM{-ignore fixities-} $
-           mapRn rnIfaceInst interesting_insts)) of {
-      (if_inst_decls, if_errs, if_warns) ->
-
-       return (if_inst_decls, (ims_errs `unionBags` if_errs, if_warns))
-    }
+    returnRn [ (mod, mod_version mod, local_versions)
+            | (mod, local_versions) <- fmToList mv_map
+            ]
+
   where
-    get_insts (ParsedIface _ _ _ _ _   _ _ _ _ insts _) = insts
-    get_ims   (ParsedIface _ _ _ _ _ ims _ _ _     _ _) = ims
-
-    good_inst (_, tc_imp_env) i@(InstSig clas tycon _ _)
-      = -- it's a "good instance" (one to hang onto) if we have
-       -- some chance of referring to *both* the class and tycon
-       -- later on.
-       mentionable clas && mentionable tycon
-      where
-       mentionable nm
-         = case (lookupFM tc_imp_env nm) of
-             Just  _ -> True
-             Nothing -> -- maybe it's builtin
-               case nm of
-                 Qual _ _ -> False
-                 Unqual n ->
-                   case (lookupFM b_tc_names n) of
-                     Just  _ -> True
-                     Nothing -> maybeToBool (lookupFM b_keys n)
-
-    (b_tc_names, b_keys) -- pretty UGLY ...
-      = case builtinNameInfo of ((_,builtin_tcs),b_keys,_) -> (builtin_tcs,b_keys)
-
-    ppr_insts insts
-      = ppAboves (map ppr_inst insts)
-      where
-       ppr_inst (InstSig c t _ inst_decl)
-         = ppCat [ppr PprDebug c, ppr PprDebug t, ppr PprDebug inst_decl]
-
-    read_iface_imods :: ModuleToIfaceContents
-                    -> [Module]
-                    -> Bag RdrIfaceInst -> Bag Error
-                    -> IO (Bag RdrIfaceInst, Bag Error)
-
-    read_iface_imods iface_fm []     iacc eacc = return (iacc, eacc)
-    read_iface_imods iface_fm (m:ms) iacc eacc
-      = case (lookupFM iface_fm m) of
-         Just  _ -> -- module's already in our cache; keep going
-                    read_iface_imods iface_fm ms iacc eacc
-
-         Nothing -> -- bring it in
-           cachedIface iface_cache m   >>= \ read_res ->
-           case read_res of
-             Failed msg -> -- oh well, keep going anyway (saving the error)
-               read_iface_imods iface_fm ms iacc (eacc `snocBag` msg)
-
-             Succeeded iface ->
-               read_iface_imods iface_fm ms (iacc `unionBags` get_insts iface) eacc
+     export_mods = case exports of
+                       Nothing -> []
+                       Just es -> [mod | IEModuleContents mod <- es, mod /= this_mod]
+
+     add_mv mv_map v@(name, version) 
+      = addToFM_C (\ ls _ -> (v:ls)) mv_map mod [v] 
+       where
+        (mod,_) = modAndOcc name
+
+     add_mod mv_map mod = addToFM mv_map mod []
 \end{code}
 
+%*********************************************************
+%*                                                     *
+\subsection{Getting binders out of a declaration}
+%*                                                     *
+%*********************************************************
+
+@getDeclBinders@ returns the names for a @RdrNameHsDecl@.
+It's used for both source code (from @availsFromDecl@) and interface files
+(from @loadDecl@).
+
+It doesn't deal with source-code specific things: ValD, DefD.  They
+are handled by the sourc-code specific stuff in RnNames.
+
 \begin{code}
-rnIfaceInst :: RdrIfaceInst -> RnM_Fixes _RealWorld RenamedInstDecl
+getDeclBinders :: (RdrName -> SrcLoc -> RnMG Name)             -- New-name function
+               -> RdrNameHsDecl
+               -> RnMG AvailInfo
 
-rnIfaceInst (InstSig _ _ _ inst_decl) = rnInstDecl inst_decl
+getDeclBinders new_name (TyD (TyData _ tycon _ condecls _ _ src_loc))
+  = new_name tycon src_loc                     `thenRn` \ tycon_name ->
+    getConFieldNames new_name condecls         `thenRn` \ sub_names ->
+    returnRn (AvailTC tycon_name (tycon_name : sub_names))
+
+getDeclBinders new_name (TyD (TyNew _ tycon _ (NewConDecl con _ con_loc) _ _ src_loc))
+  = new_name tycon src_loc             `thenRn` \ tycon_name ->
+    new_name con src_loc               `thenRn` \ con_name ->
+    returnRn (AvailTC tycon_name [tycon_name, con_name])
+
+getDeclBinders new_name (TyD (TySynonym tycon _ _ src_loc))
+  = new_name tycon src_loc             `thenRn` \ tycon_name ->
+    returnRn (Avail tycon_name)
+
+getDeclBinders new_name (ClD (ClassDecl _ cname _ sigs _ _ src_loc))
+  = new_name cname src_loc                     `thenRn` \ class_name ->
+    mapRn (getClassOpNames new_name) sigs      `thenRn` \ sub_names ->
+    returnRn (AvailTC class_name (class_name : sub_names))
+
+getDeclBinders new_name (SigD (IfaceSig var ty prags src_loc))
+  = new_name var src_loc                       `thenRn` \ var_name ->
+    returnRn (Avail var_name)
+
+getDeclBinders new_name (DefD _)  = returnRn NotAvailable
+getDeclBinders new_name (InstD _) = returnRn NotAvailable
+
+----------------
+getConFieldNames new_name (ConDecl con _ src_loc : rest)
+  = new_name con src_loc               `thenRn` \ n ->
+    getConFieldNames new_name rest     `thenRn` \ ns -> 
+    returnRn (n:ns)
+
+getConFieldNames new_name (NewConDecl con _ src_loc : rest)
+  = new_name con src_loc               `thenRn` \ n ->
+    getConFieldNames new_name rest     `thenRn` \ ns -> 
+    returnRn (n:ns)
+
+getConFieldNames new_name (ConOpDecl _ con _ src_loc : rest)
+  = new_name con src_loc               `thenRn` \ n ->
+    getConFieldNames new_name rest     `thenRn` \ ns -> 
+    returnRn (n:ns)
+
+getConFieldNames new_name (RecConDecl con fielddecls src_loc : rest)
+  = mapRn (\n -> new_name n src_loc) (con:fields)      `thenRn` \ cfs ->
+    getConFieldNames new_name rest                     `thenRn` \ ns  -> 
+    returnRn (cfs ++ ns)
+  where
+    fields = concat (map fst fielddecls)
+
+getConFieldNames new_name [] = returnRn []
+
+getClassOpNames new_name (ClassOpSig op _ _ src_loc) = new_name op src_loc
+\end{code}
+
+
+%*********************************************************
+%*                                                     *
+\subsection{Reading an interface file}
+%*                                                     *
+%*********************************************************
+
+\begin{code}
+findAndReadIface :: Pretty -> Module -> RnMG (Maybe ParsedIface)
+       -- Nothing <=> file not found, or unreadable, or illegible
+       -- Just x  <=> successfully found and parsed 
+findAndReadIface doc_str mod
+  = traceRn trace_msg                  `thenRn_`
+    getSearchPathRn                    `thenRn` \ dirs ->
+    try dirs dirs
+  where
+    trace_msg = ppHang (ppBesides [ppPStr SLIT("Reading interface for "), 
+                                  pprModule PprDebug mod, ppSemi])
+                    4 (ppBesides [ppPStr SLIT("reason: "), doc_str])
+
+    mod_str = moduleString mod
+    hisuf =
+      if isPreludeModule mod then
+         case opt_HiSuffixPrelude of { Just hisuf -> hisuf; _ -> ".hi"}
+      else
+         case opt_HiSuffix of {Just hisuf -> hisuf; _ -> ".hi"}
+
+    try all_dirs [] = traceRn (ppPStr SLIT("...failed"))       `thenRn_`
+                     returnRn Nothing
+
+    try all_dirs (dir:dirs)
+       = readIface file_path   `thenRn` \ read_result ->
+         case read_result of
+               Nothing    -> try all_dirs dirs
+               Just iface -> traceRn (ppPStr SLIT("...done"))  `thenRn_`
+                             returnRn (Just iface)
+       where
+         file_path = dir ++ "/" ++ moduleString mod ++ hisuf
 \end{code}
 
+@readIface@ trys just one file.
+
 \begin{code}
-finalIfaceInfo ::
-          IfaceCache                   -- iface cache
-       -> [RnName]                     -- all imported names required
-       -> [Module]                     -- directly imported modules
-       -> IO (VersionInfo,             -- info about version numbers
-              [Module])                -- special instance modules
+readIface :: String -> RnMG (Maybe ParsedIface)        
+       -- Nothing <=> file not found, or unreadable, or illegible
+       -- Just x  <=> successfully found and parsed 
+readIface file_path
+  = ioToRnMG (hGetStringBuffer file_path)      `thenRn` \ read_result ->
+--OLD:  = ioToRnMG (readFile file_path)        `thenRn` \ read_result ->
+    case read_result of
+       Right contents    -> case parseIface contents of
+                               Failed err      -> --ioToRnMG (freeStringBuffer contents) `thenRn` \ _ -> 
+                                                  failWithRn Nothing err 
+                               Succeeded iface -> --ioToRnMG (freeStringBuffer contents) `thenRn` \ _ ->
+                                                  returnRn (Just iface)
+
+       Left  (NoSuchThing _) -> returnRn Nothing
 
-type VersionInfo = [(Module, Version, [(FAST_STRING, Version)])]
+       Left  err             -> failWithRn Nothing
+                                           (cannaeReadFile file_path err)
 
-finalIfaceInfo iface_cache imps_reqd imp_mods
-  = return ([], [])
 \end{code}
 
+mkSearchPath takes a string consisting of a colon-separated list of directories, and turns it into
+a list of directories.  For example:
+
+       mkSearchPath "foo:.:baz"  =  ["foo", ".", "baz"]
 
 \begin{code}
-noIfaceErr mod sty
-  = ppCat [ppPStr SLIT("Could not find interface for:"), ppPStr mod]
+mkSearchPath :: Maybe String -> SearchPath
+mkSearchPath Nothing = ["."]
+mkSearchPath (Just s)
+  = go s
+  where
+    go "" = []
+    go s  = first : go (drop 1 rest)
+         where
+           (first,rest) = span (/= ':') s
+\end{code}
 
-noDeclInIfaceErr mod str sty
-  = ppBesides [ppPStr SLIT("Could not find interface declaration of: "),
-              ppPStr mod, ppStr ".", ppPStr str]
+%*********************************************************
+%*                                                     *
+\subsection{Errors}
+%*                                                     *
+%*********************************************************
+
+\begin{code}
+noIfaceErr mod sty
+  = ppBesides [ppPStr SLIT("Could not find valid interface file for "), ppQuote (pprModule sty mod)]
+--     , ppStr " in"]) 4 (ppAboves (map ppStr dirs))
 
-cannaeReadErr file err sty
-  = ppBesides [ppPStr SLIT("Failed in reading file: "), ppStr file, ppStr "; error=", ppStr (show err)]
+cannaeReadFile file err sty
+  = ppBesides [ppPStr SLIT("Failed in reading file: "), ppStr file, ppPStr SLIT("; error="), ppStr (show err)]
 
-ifaceLookupWiredErr msg n sty
-  = ppBesides [ppPStr SLIT("Why am I looking up a wired-in "), ppStr msg, ppChar ':', ppr sty n]
+getDeclErr name sty
+  = ppSep [ppPStr SLIT("Failed to find interface decl for"), ppr sty name]
 
-badIfaceLookupErr msg name decl sty
-  = ppBesides [ppPStr SLIT("Expected a "), ppStr msg, ppPStr SLIT(" declaration, but got this: ???")]
+getDeclWarn name sty
+  = ppSep [ppPStr SLIT("Warning: failed to find (optional) interface decl for"), ppr sty name]
 \end{code}