X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Frename%2FRnMonad.lhs;h=27feac14f33e998caeec8eb3c83ab2b55a05b546;hb=438596897ebbe25a07e1c82085cfbc5bdb00f09e;hp=37363ed75c3b647f6868b89e4ad2dfd1ba200dfa;hpb=cd7f4d50fcbcadfc764b0aa764d5ead690a4d3bf;p=ghc-hetmet.git

diff --git a/ghc/compiler/rename/RnMonad.lhs b/ghc/compiler/rename/RnMonad.lhs
index 37363ed..27feac1 100644
--- a/ghc/compiler/rename/RnMonad.lhs
+++ b/ghc/compiler/rename/RnMonad.lhs
@@ -1,68 +1,59 @@
 %
-% (c) The GRASP/AQUA Project, Glasgow University, 1992-1997
+% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
 %
 \section[RnMonad]{The monad used by the renamer}
 
 \begin{code}
-#include "HsVersions.h"
-
 module RnMonad(
-	EXP_MODULE(RnMonad),
-	 -- close it up (partly done to allow unfoldings)
-	EXP_MODULE(SST),
-	SYN_IE(Module),
+	module RnMonad,
+	Module,
 	FiniteMap,
 	Bag,
 	Name,
-	SYN_IE(RdrNameHsDecl),
-	SYN_IE(RdrNameInstDecl),
-	SYN_IE(Version),
-	SYN_IE(NameSet),
+	RdrNameHsDecl,
+	RdrNameInstDecl,
+	Version,
+	NameSet,
 	OccName,
 	Fixity
     ) where
 
-IMP_Ubiq(){-uitous-}
+#include "HsVersions.h"
 
 import SST
-#if __GLASGOW_HASKELL__ <= 201
-import PreludeGlaST	( SYN_IE(ST), thenStrictlyST, returnStrictlyST )
-#define MkIO
-#else
-import GlaExts
-import IO
-import ST
-import IOBase
-#define IOError13 IOError
-#define MkIO IO
-#endif
+import GlaExts		( RealWorld, stToIO )
+import List		( intersperse )
 
 import HsSyn		
 import RdrHsSyn
-import BasicTypes	( SYN_IE(Version), NewOrData )
-import ErrUtils		( addErrLoc, addShortErrLocLine, addShortWarnLocLine,
-			  pprBagOfErrors, SYN_IE(Error), SYN_IE(Warning)
+import BasicTypes	( Version, pprModule, IfaceFlavour(..) )
+import SrcLoc		( noSrcLoc )
+import ErrUtils		( addShortErrLocLine, addShortWarnLocLine,
+			  pprBagOfErrors, ErrMsg, WarnMsg
 			)
-import Name		( SYN_IE(Module), Name, OccName, Provenance, SYN_IE(NameSet), emptyNameSet,
+import Name		( Module, Name, OccName, PrintUnqualified,
 			  isLocallyDefinedName,
 			  modAndOcc, NamedThing(..)
 			)
-import CmdLineOpts	( opt_D_show_rn_trace, opt_IgnoreIfacePragmas )
+import NameSet		
+import CmdLineOpts	( opt_D_show_rn_trace, opt_IgnoreIfacePragmas, opt_WarnHiShadows )
 import PrelInfo		( builtinNames )
-import TyCon		( TyCon {- instance NamedThing -} )
 import TysWiredIn	( boolTyCon )
-import Pretty
-import Outputable	( PprStyle(..) )
 import SrcLoc		( SrcLoc, mkGeneratedSrcLoc )
 import Unique		( Unique )
 import UniqFM		( UniqFM )
-import FiniteMap	( FiniteMap, emptyFM, bagToFM )
+import FiniteMap	( FiniteMap, emptyFM, bagToFM, lookupFM, addToFM, addListToFM_C, addToFM_C )
 import Bag		( Bag, mapBag, emptyBag, isEmptyBag, snocBag )
+import Maybes		( seqMaybe, mapMaybe )
 import UniqSet
-import Util
-#if __GLASGOW_HASKELL__ >= 202
 import UniqSupply
-#endif
+import Util
+import Outputable
+import DirUtils		( getDirectoryContents )
+import IO		( hPutStrLn, stderr, isDoesNotExistError )
+import Monad		( foldM )
+import Maybe		( fromMaybe )
+import Constants	( interfaceFileFormatVersion )
 
 infixr 9 `thenRn`, `thenRn_`
 \end{code}
@@ -75,30 +66,18 @@ infixr 9 `thenRn`, `thenRn_`
 %************************************************************************
 
 \begin{code}
-#if __GLASGOW_HASKELL__ >= 200
-# define REAL_WORLD RealWorld
-#else
-# define REAL_WORLD _RealWorld
-#endif
-\end{code}
-
-\begin{code}
-sstToIO :: SST REAL_WORLD r -> IO r
-sstToIO sst =
-    MkIO (
-    sstToST sst 	`thenStrictlyST` \ r -> 
-    returnStrictlyST (Right r))
-
-ioToRnMG :: IO r -> RnMG (Either IOError13 r)
-ioToRnMG (MkIO io) rn_down g_down = stToSST io
+sstToIO :: SST RealWorld r -> IO r
+sstToIO sst = stToIO (sstToST sst)
 
-traceRn :: Doc -> RnMG ()
+ioToRnMG :: IO r -> RnMG (Either IOError r)
+ioToRnMG io rn_down g_down = ioToSST io
+	    
+traceRn :: SDoc -> RnMG ()
 traceRn msg | opt_D_show_rn_trace = putDocRn msg
 	    | otherwise		  = returnRn ()
 
-putDocRn :: Doc -> RnMG ()
-putDocRn msg = ioToRnMG (hPutStr stderr (show msg) >> 
-	       hPutStr stderr "\n")	`thenRn_`
+putDocRn :: SDoc -> RnMG ()
+putDocRn msg = ioToRnMG (printErrs msg)	`thenRn_`
 	       returnRn ()
 \end{code}
 
@@ -115,16 +94,18 @@ putDocRn msg = ioToRnMG (hPutStr stderr (show msg) >>
 
 \begin{code}
 type RnM s d r = RnDown s -> d -> SST s r
-type RnMS s r   = RnM s          (SDown s) r		-- Renaming source
-type RnMG r     = RnM REAL_WORLD GDown     r		-- Getting global names etc
-type MutVar a  = MutableVar REAL_WORLD a		-- ToDo: there ought to be a standard defn of this
+type RnMS s r   = RnM s         (SDown s) r		-- Renaming source
+type RnMG r     = RnM RealWorld GDown     r		-- Getting global names etc
+type SSTRWRef a = SSTRef RealWorld a		-- ToDo: there ought to be a standard defn of this
 
 	-- Common part
 data RnDown s = RnDown
 		  SrcLoc
-		  (MutableVar s RnNameSupply)
-		  (MutableVar s (Bag Warning, Bag Error))
-		  (MutableVar s ([Name],[Name]))	-- Occurrences: compulsory and optional resp
+		  (SSTRef s (GenRnNameSupply s))
+		  (SSTRef s (Bag WarnMsg, Bag ErrMsg))
+		  (SSTRef s ([Occurrence],[Occurrence]))	-- Occurrences: compulsory and optional resp
+
+type Occurrence = (Name, SrcLoc)		-- The srcloc is the occurrence site
 
 data Necessity = Compulsory | Optional		-- We *must* find definitions for
 						-- compulsory occurrences; we *may* find them
@@ -132,8 +113,9 @@ data Necessity = Compulsory | Optional		-- We *must* find definitions for
 
 	-- For getting global names
 data GDown = GDown
-		SearchPath
-		(MutVar Ifaces)
+		ModuleHiMap   -- for .hi files
+		ModuleHiMap   -- for .hi-boot files
+		(SSTRWRef Ifaces)
 
 	-- For renaming source code
 data SDown s = SDown
@@ -145,15 +127,23 @@ data SDown s = SDown
 
 
 data RnSMode	= SourceMode			-- Renaming source code
-		| InterfaceMode Necessity	-- Renaming interface declarations.  The "necessity"
+		| InterfaceMode			-- Renaming interface declarations.  
+			Necessity		-- The "necessity"
 						-- flag says free variables *must* be found and slurped
 						-- or whether they need not be.  For value signatures of
 						-- things that are themselves compulsorily imported
-						-- we arrange that the type signature is read in compulsory mode,
+						-- we arrange that the type signature is read 
+						-- in compulsory mode,
 						-- but the pragmas in optional mode.
+			(Name -> PrintUnqualified)	-- Tells whether the thing can be printed unqualified
 
 type SearchPath = [(String,String)]	-- List of (directory,suffix) pairs to search 
                                         -- for interface files.
+
+type ModuleHiMap = FiniteMap String String
+   -- mapping from module name to the file path of its corresponding
+   -- interface file.
+
 type FreeVars	= NameSet
 \end{code}
 
@@ -162,18 +152,31 @@ type FreeVars	= NameSet
 ===================================================
 
 \begin{code}
-type RnNameSupply = (UniqSupply, Int, FiniteMap (Module,OccName) Name)
+type RnNameSupply = GenRnNameSupply RealWorld
+
+type GenRnNameSupply s
+ = ( UniqSupply
+   , FiniteMap FAST_STRING (SSTRef s Int)
+   , FiniteMap (Module,OccName) Name
+   )
 	-- Ensures that one (m,n) pair gets one unique
-	-- The Int is used to give a number to each instance declaration;
-	-- it's really a separate name supply.
+	-- The finite map on FAST_STRINGS is used to give a per-class unique to each
+	-- instance declaration; it's really a separate name supply.
+
+data RnEnv     	= RnEnv GlobalNameEnv FixityEnv
+emptyRnEnv	= RnEnv emptyNameEnv  emptyFixityEnv
+
+type GlobalNameEnv = FiniteMap RdrName (Name, HowInScope)
+emptyGlobalNameEnv = emptyFM
 
-data RnEnv     	= RnEnv NameEnv FixityEnv
-emptyRnEnv	= RnEnv emptyNameEnv emptyFixityEnv
+data HowInScope		-- Used for error messages only
+   = FromLocalDefn SrcLoc
+   | FromImportDecl Module SrcLoc
 
 type NameEnv	= FiniteMap RdrName Name
 emptyNameEnv	= emptyFM
 
-type FixityEnv		= FiniteMap RdrName (Fixity, Provenance)
+type FixityEnv		= FiniteMap RdrName (Fixity, HowInScope)
 emptyFixityEnv	        = emptyFM
 	-- It's possible to have a different fixity for B.op than for op:
 	--
@@ -184,11 +187,8 @@ emptyFixityEnv	        = emptyFM
 
 data ExportEnv		= ExportEnv Avails Fixities
 type Avails		= [AvailInfo]
-type Fixities		= [(OccName, (Fixity, Provenance))]
-	-- Can contain duplicates, if one module defines the same fixity,
-	-- or the same type/class/id, more than once.   Hence a boring old list.
-	-- This allows us to report duplicates in just one place, namely plusRnEnv.
-	
+type Fixities		= [(OccName, Fixity)]
+
 type ExportAvails	= (FiniteMap Module Avails,	-- Used to figure out "module M" export specifiers
 							-- Includes avails only from *unqualified* imports
 							-- (see 1.4 Report Section 5.1.1)
@@ -216,7 +216,16 @@ type RdrAvailInfo = GenAvailInfo OccName
 \begin{code}
 type ExportItem		 = (Module, IfaceFlavour, [RdrAvailInfo])
 type VersionInfo name    = [ImportVersion name]
-type ImportVersion name  = (Module, IfaceFlavour, Version, [LocalVersion name])
+
+type ImportVersion name  = (Module, IfaceFlavour, Version, WhatsImported name)
+data WhatsImported name  = Everything 
+			 | Specifically [LocalVersion name]	-- List guaranteed non-empty
+
+    -- ("M", hif, ver, Everything) means there was a "module M" in 
+    -- this module's export list, so we just have to go by M's version, "ver",
+    -- not the list of LocalVersions.
+
+
 type LocalVersion name   = (name, Version)
 
 data ParsedIface
@@ -230,7 +239,7 @@ data ParsedIface
       [(Version, RdrNameHsDecl)]	-- Local definitions
       [RdrNameInstDecl]			-- Local instance declarations
 
-type InterfaceDetails = (VersionInfo Name,	-- Version information
+type InterfaceDetails = (VersionInfo Name,	-- Version information for what this module imports
 			 ExportEnv, 		-- What this module exports
 			 [Module])		-- Instance modules
 
@@ -286,30 +295,30 @@ type IfaceInst   = ((Module, RdrNameInstDecl),	-- Instance decl
 \begin{code}
 initRn :: Module -> UniqSupply -> SearchPath -> SrcLoc
        -> RnMG r
-       -> IO (r, Bag Error, Bag Warning)
-
-initRn mod us dirs loc do_rn
-  = sstToIO $
-    newMutVarSST (us, 1, builtins)	`thenSST` \ names_var ->
-    newMutVarSST (emptyBag,emptyBag)	`thenSST` \ errs_var ->
-    newMutVarSST (emptyIfaces mod)	`thenSST` \ iface_var -> 
-    newMutVarSST initOccs		`thenSST` \ occs_var ->
-    let
-	rn_down = RnDown loc names_var errs_var occs_var
-	g_down  = GDown dirs iface_var
-    in
-	-- do the buisness
-    do_rn rn_down g_down		`thenSST` \ res ->
+       -> IO (r, Bag ErrMsg, Bag WarnMsg)
+
+initRn mod us dirs loc do_rn = do
+  names_var <- sstToIO (newMutVarSST (us, emptyFM, builtins))
+  errs_var  <- sstToIO (newMutVarSST (emptyBag,emptyBag))
+  iface_var <- sstToIO (newMutVarSST (emptyIfaces mod))
+  occs_var  <- sstToIO (newMutVarSST initOccs)
+  (himap, hibmap) <- mkModuleHiMaps dirs
+  let
+        rn_down = RnDown loc names_var errs_var occs_var
+	g_down  = GDown himap hibmap iface_var
+
+	-- do the business
+  res <- sstToIO (do_rn rn_down g_down)
 
 	-- grab errors and return
-    readMutVarSST errs_var			`thenSST` \ (warns,errs) ->
-    returnSST (res, errs, warns)
+  (warns, errs) <- sstToIO (readMutVarSST errs_var)
+  return (res, errs, warns)
 
 
-initRnMS :: RnEnv -> Module -> RnSMode -> RnMS REAL_WORLD r -> RnMG r
+initRnMS :: RnEnv -> Module -> RnSMode -> RnMS RealWorld r -> RnMG r
 initRnMS rn_env@(RnEnv name_env _) mod_name mode m rn_down g_down
   = let
-	s_down = SDown rn_env name_env mod_name mode
+	s_down = SDown rn_env emptyNameEnv mod_name mode
     in
     m rn_down s_down
 
@@ -321,14 +330,88 @@ builtins :: FiniteMap (Module,OccName) Name
 builtins = bagToFM (mapBag (\ name -> (modAndOcc name, name)) builtinNames)
 
 	-- Initial value for the occurrence pool.
-initOccs :: ([Name],[Name])	-- Compulsory and optional respectively
-initOccs = ([getName boolTyCon], [])
+initOccs :: ([Occurrence],[Occurrence])	-- Compulsory and optional respectively
+initOccs = ([(getName boolTyCon, noSrcLoc)], [])
 	-- Booleans occur implicitly a lot, so it's tiresome to keep recording the fact, and
 	-- rather implausible that not one will be used in the module.
 	-- We could add some other common types, notably lists, but the general idea is
 	-- to do as much as possible explicitly.
 \end{code}
 
+\begin{code}
+mkModuleHiMaps :: SearchPath -> IO (ModuleHiMap, ModuleHiMap)
+mkModuleHiMaps dirs = foldM (getAllFilesMatching dirs) (env,env) dirs
+ where
+  env = emptyFM
+
+getAllFilesMatching :: SearchPath
+		    -> (ModuleHiMap, ModuleHiMap)
+		    -> (FilePath, String) 
+		    -> IO (ModuleHiMap, ModuleHiMap)
+getAllFilesMatching dirs hims (dir_path, suffix) = ( do
+    -- fpaths entries do not have dir_path prepended
+  fpaths <- getDirectoryContents dir_path
+  return (foldl addModules hims fpaths)
+   )  -- soft failure
+      `catch` 
+        (\ err -> do
+	      hPutStrLn stderr 
+		     ("Import path element `" ++ dir_path ++ 
+		      if (isDoesNotExistError err) then
+	                 "' does not exist, ignoring."
+		      else
+	                "' couldn't read, ignoring.")
+	       
+              return hims
+	    )
+ where
+   xiffus = reverse dotted_suffix 
+  
+   dotted_suffix =
+    case suffix of
+      [] -> []
+      ('.':xs) -> suffix
+      ls -> '.':ls
+
+   hi_boot_version_xiffus = 
+      reverse (show interfaceFileFormatVersion) ++ '-':hi_boot_xiffus
+   hi_boot_xiffus = "toob-ih." -- .hi-boot reversed.
+
+   addModules his@(hi_env, hib_env) nm = fromMaybe his $ 
+        map (\ (mod_nm,v) -> (addToFM_C addNewOne hi_env mod_nm v, hib_env))
+	    (go xiffus rev_nm)		       `seqMaybe`
+
+        map (\ (mod_nm,v) -> (hi_env, addToFM_C overrideNew hib_env mod_nm v))
+	    (go hi_boot_version_xiffus rev_nm) `seqMaybe`
+
+	map (\ (mod_nm,v) -> (hi_env, addToFM_C addNewOne hib_env mod_nm v))
+	    (go hi_boot_xiffus rev_nm)
+    where
+     rev_nm  = reverse nm
+
+     go [] xs         = Just (reverse xs, dir_path ++'/':nm)
+     go _  []         = Nothing
+     go (x:xs) (y:ys) 
+       | x == y       = go xs ys 
+       | otherwise    = Nothing
+
+   addNewOne
+    | opt_WarnHiShadows = conflict
+    | otherwise         = stickWithOld
+
+   stickWithOld old new = old
+   overrideNew old new  = new
+
+   conflict old_path new_path
+    | old_path /= new_path = 
+        pprTrace "Warning: " (text "Identically named interface files present on import path, " $$
+			      text (show old_path) <+> text "shadows" $$
+			      text (show new_path) $$
+			      text "on the import path: " <+> 
+			      text (concat (intersperse ":" (map fst dirs))))
+        old_path
+    | otherwise = old_path  -- don't warn about innocous shadowings.
+
 \end{code}
 
 
@@ -342,8 +425,8 @@ once you must either split it, or install a fresh unique supply.
 
 \begin{code}
 renameSourceCode :: Module 
-		 -> RnNameSupply 
-	         -> RnMS REAL_WORLD r
+		 -> RnNameSupply
+	         -> RnMS RealWorld r
 	         -> r
 
 -- Alas, we can't use the real runST, with the desired signature:
@@ -357,23 +440,25 @@ renameSourceCode mod_name name_supply m
 	newMutVarSST ([],[])			`thenSST` \ occs_var ->
     	let
 	    rn_down = RnDown mkGeneratedSrcLoc names_var errs_var occs_var
-	    s_down = SDown emptyRnEnv emptyNameEnv mod_name (InterfaceMode Compulsory)
+	    s_down = SDown emptyRnEnv emptyNameEnv mod_name (InterfaceMode Compulsory (\_ -> False))
 	in
 	m rn_down s_down			`thenSST` \ result ->
 	
 	readMutVarSST errs_var			`thenSST` \ (warns,errs) ->
 
 	(if not (isEmptyBag errs) then
-		trace ("Urk! renameSourceCode found errors" ++ display errs) 
+		pprTrace "Urk! renameSourceCode found errors" (display errs) 
+#ifdef DEBUG
 	 else if not (isEmptyBag warns) then
-		trace ("Urk! renameSourceCode found warnings" ++ display warns)
+		pprTrace "Urk! renameSourceCode found warnings" (display warns)
+#endif
 	 else
 		id) $
 
 	returnSST result
     )
   where
-    display errs = show (pprBagOfErrors PprDebug errs)
+    display errs = pprBagOfErrors errs
 
 {-# INLINE thenRn #-}
 {-# INLINE thenRn_ #-}
@@ -385,6 +470,7 @@ thenRn   :: RnM s d a -> (a -> RnM s d b) -> RnM s d b
 thenRn_  :: RnM s d a -> RnM s d b -> RnM s d b
 andRn    :: (a -> a -> a) -> RnM s d a -> RnM s d a -> RnM s d a
 mapRn    :: (a -> RnM s d b) -> [a] -> RnM s d [b]
+mapMaybeRn :: (a -> RnM s d b) -> b -> Maybe a -> RnM s d b
 sequenceRn :: [RnM s d a] -> RnM s d [a]
 foldlRn :: (b  -> a -> RnM s d b) -> b -> [a] -> RnM s d b
 mapAndUnzipRn :: (a -> RnM s d (b,c)) -> [a] -> RnM s d ([b],[c])
@@ -425,6 +511,9 @@ mapAndUnzip3Rn f (x:xs)
   = f x		    	`thenRn` \ (r1,  r2,  r3)  ->
     mapAndUnzip3Rn f xs	`thenRn` \ (rs1, rs2, rs3) ->
     returnRn (r1:rs1, r2:rs2, r3:rs3)
+
+mapMaybeRn f def Nothing  = returnRn def
+mapMaybeRn f def (Just v) = f v
 \end{code}
 
 
@@ -439,7 +528,7 @@ mapAndUnzip3Rn f (x:xs)
 ================  Errors and warnings =====================
 
 \begin{code}
-failWithRn :: a -> Error -> RnM s d a
+failWithRn :: a -> ErrMsg -> RnM s d a
 failWithRn res msg (RnDown loc names_var errs_var occs_var) l_down
   = readMutVarSST  errs_var  					`thenSST`  \ (warns,errs) ->
     writeMutVarSST errs_var (warns, errs `snocBag` err)		`thenSST_` 
@@ -447,7 +536,7 @@ failWithRn res msg (RnDown loc names_var errs_var occs_var) l_down
   where
     err = addShortErrLocLine loc msg
 
-warnWithRn :: a -> Warning -> RnM s d a
+warnWithRn :: a -> WarnMsg -> RnM s d a
 warnWithRn res msg (RnDown loc names_var errs_var occs_var) l_down
   = readMutVarSST  errs_var  				 	`thenSST`  \ (warns,errs) ->
     writeMutVarSST errs_var (warns `snocBag` warn, errs)	`thenSST_` 
@@ -455,14 +544,14 @@ warnWithRn res msg (RnDown loc names_var errs_var occs_var) l_down
   where
     warn = addShortWarnLocLine loc msg
 
-addErrRn :: Error -> RnM s d ()
+addErrRn :: ErrMsg -> RnM s d ()
 addErrRn err = failWithRn () err
 
-checkRn :: Bool -> Error -> RnM s d ()	-- Check that a condition is true
+checkRn :: Bool -> ErrMsg -> RnM s d ()	-- Check that a condition is true
 checkRn False err  = addErrRn err
 checkRn True err = returnRn ()
 
-addWarnRn :: Warning -> RnM s d ()
+addWarnRn :: WarnMsg -> RnM s d ()
 addWarnRn warn = warnWithRn () warn
 
 checkErrsRn :: RnM s d Bool		-- True <=> no errors so far
@@ -487,21 +576,34 @@ getSrcLocRn (RnDown loc names_var errs_var occs_var) l_down
 ================  Name supply =====================
 
 \begin{code}
-getNameSupplyRn :: RnM s d RnNameSupply
+getNameSupplyRn :: RnM s d (GenRnNameSupply s)
 getNameSupplyRn (RnDown loc names_var errs_var occs_var) l_down
   = readMutVarSST names_var
 
-setNameSupplyRn :: RnNameSupply -> RnM s d ()
+setNameSupplyRn :: GenRnNameSupply s -> RnM s d ()
 setNameSupplyRn names' (RnDown loc names_var errs_var occs_var) l_down
   = writeMutVarSST names_var names'
 
--- The "instance-decl unique supply", inst, is just an integer that's used to
--- give a unique number for each instance declaration.
-newInstUniq :: RnM s d Int
-newInstUniq (RnDown loc names_var errs_var occs_var) l_down
-  = readMutVarSST names_var				`thenSST` \ (us, inst, cache) ->
-    writeMutVarSST names_var (us, inst+1, cache)	`thenSST_` 
-    returnSST inst
+-- The "instance-decl unique supply", inst, is really a map from class names
+-- to unique supplies. Having per-class unique numbers for instance decls helps
+-- the recompilation checker.
+newInstUniq :: FAST_STRING -> RnM s d Int
+newInstUniq cname (RnDown loc names_var errs_var occs_var) l_down
+  = readMutVarSST names_var				`thenSST` \ (us, mapInst, cache) ->
+    case lookupFM mapInst cname of
+      Just class_us ->
+         readMutVarSST  class_us       `thenSST`  \ v ->
+	 writeMutVarSST class_us (v+1) `thenSST_`
+         returnSST v
+      Nothing -> -- first time caller gets to add a unique supply
+                 -- to the finite map for that class.
+        newMutVarSST 1 `thenSST` \ class_us ->
+	let 
+	  mapInst' = addToFM mapInst cname class_us
+	in
+	writeMutVarSST names_var (us, mapInst', cache)	`thenSST_` 
+        returnSST 0
+
 \end{code}
 
 ================  Occurrences =====================
@@ -541,15 +643,13 @@ addOccurrenceName name (RnDown loc names_var errs_var occs_var)
   = readMutVarSST occs_var			`thenSST` \ (comp_occs, opt_occs) ->
     let
 	new_occ_pair = case necessity of
-			 Optional   -> (comp_occs, name:opt_occs)
-			 Compulsory -> (name:comp_occs, opt_occs)
+			 Optional   -> (comp_occs, (name,loc):opt_occs)
+			 Compulsory -> ((name,loc):comp_occs, opt_occs)
     in
     writeMutVarSST occs_var new_occ_pair	`thenSST_`
     returnSST name
   where
-    necessity = case mode of 
-		  SourceMode	          -> Compulsory
-		  InterfaceMode necessity -> necessity
+    necessity = modeToNecessity mode
 
 
 addOccurrenceNames :: [Name] -> RnMS s ()
@@ -562,34 +662,34 @@ addOccurrenceNames names (RnDown loc names_var errs_var occs_var)
   = readMutVarSST occs_var			`thenSST` \ (comp_occs, opt_occs) ->
     let
 	new_occ_pair = case necessity of
-			 Optional   -> (comp_occs, non_local_names ++ opt_occs)
-			 Compulsory -> (non_local_names ++ comp_occs, opt_occs)
+			 Optional   -> (comp_occs, non_local_occs ++ opt_occs)
+			 Compulsory -> (non_local_occs ++ comp_occs, opt_occs)
     in
     writeMutVarSST occs_var new_occ_pair
   where
-    non_local_names = filter (not . isLocallyDefinedName) names
-    necessity = case mode of 
-		  SourceMode	          -> Compulsory
-		  InterfaceMode necessity -> necessity
+    non_local_occs = [(name, loc) | name <- names, not (isLocallyDefinedName name)]
+    necessity = modeToNecessity mode
 
 	-- Never look for optional things if we're
 	-- ignoring optional input interface information
 not_necessary Compulsory = False
 not_necessary Optional   = opt_IgnoreIfacePragmas
 
-popOccurrenceName :: Necessity -> RnM s d (Maybe Name)
-popOccurrenceName necessity (RnDown loc names_var errs_var occs_var) l_down
+popOccurrenceName :: RnSMode -> RnM s d (Maybe Occurrence)
+popOccurrenceName mode (RnDown loc names_var errs_var occs_var) l_down
   = readMutVarSST occs_var			`thenSST` \ occs ->
-    case (necessity, occs) of
+    case (mode, occs) of
 		-- Find a compulsory occurrence
-	(Compulsory, (comp:comps, opts)) -> writeMutVarSST occs_var (comps, opts)	`thenSST_`
-					    returnSST (Just comp)
+	(InterfaceMode Compulsory _, (comp:comps, opts))
+		-> writeMutVarSST occs_var (comps, opts)	`thenSST_`
+		   returnSST (Just comp)
 
 		-- Find an optional occurrence
 		-- We shouldn't be looking unless we've done all the compulsories
-	(Optional, (comps, opt:opts)) -> ASSERT( null comps )
-					 writeMutVarSST occs_var (comps, opts)	`thenSST_`
-					 returnSST (Just opt)
+	(InterfaceMode Optional _, (comps, opt:opts))
+		-> ASSERT( null comps )
+		   writeMutVarSST occs_var (comps, opts)	`thenSST_`
+		   returnSST (Just opt)
 
 		-- No suitable occurrence
 	other -> returnSST Nothing
@@ -605,7 +705,7 @@ findOccurrencesRn enclosed_thing (RnDown loc names_var errs_var occs_var) l_down
   = newMutVarSST ([],[])						`thenSST` \ new_occs_var ->
     enclosed_thing (RnDown loc names_var errs_var new_occs_var) l_down	`thenSST_`
     readMutVarSST new_occs_var						`thenSST` \ (occs,_) ->
-    returnSST occs
+    returnSST (map fst occs)
 \end{code}
 
 
@@ -618,16 +718,32 @@ findOccurrencesRn enclosed_thing (RnDown loc names_var errs_var occs_var) l_down
 ================  RnEnv  =====================
 
 \begin{code}
-getGlobalNameEnv :: RnMS s NameEnv
-getGlobalNameEnv rn_down (SDown (RnEnv global_env fixity_env) local_env mod_name mode)
-  = returnSST global_env
-
-getNameEnv :: RnMS s NameEnv
-getNameEnv rn_down (SDown rn_env local_env mod_name mode)
+-- Look in global env only
+lookupGlobalNameRn :: RdrName -> RnMS s (Maybe Name)
+lookupGlobalNameRn rdr_name rn_down (SDown (RnEnv global_env fixity_env) local_env mod_name mode)
+  = case lookupFM global_env rdr_name of
+	  Just (name, _) -> returnSST (Just name)
+	  Nothing 	 -> returnSST Nothing
+  
+-- Look in both local and global env
+lookupNameRn :: RdrName -> RnMS s (Maybe Name)
+lookupNameRn rdr_name rn_down (SDown (RnEnv global_env fixity_env) local_env mod_name mode)
+  = case lookupFM local_env rdr_name of
+	  Just name -> returnSST (Just name)
+	  Nothing   -> case lookupFM global_env rdr_name of
+			  Just (name, _) -> returnSST (Just name)
+			  Nothing        -> returnSST Nothing
+
+getNameEnvs :: RnMS s (GlobalNameEnv, NameEnv)
+getNameEnvs rn_down (SDown (RnEnv global_env fixity_env) local_env mod_name mode)
+  = returnSST (global_env, local_env)
+
+getLocalNameEnv :: RnMS s NameEnv
+getLocalNameEnv rn_down (SDown rn_env local_env mod_name mode)
   = returnSST local_env
 
-setNameEnv :: NameEnv -> RnMS s a -> RnMS s a
-setNameEnv local_env' m rn_down (SDown rn_env local_env mod_name mode)
+setLocalNameEnv :: NameEnv -> RnMS s a -> RnMS s a
+setLocalNameEnv local_env' m rn_down (SDown rn_env local_env mod_name mode)
   = m rn_down (SDown rn_env local_env' mod_name mode)
 
 getFixityEnv :: RnMS s FixityEnv
@@ -662,14 +778,36 @@ setModeRn new_mode thing_inside rn_down (SDown rn_env local_env mod_name mode)
 
 \begin{code}
 getIfacesRn :: RnMG Ifaces
-getIfacesRn rn_down (GDown dirs iface_var)
+getIfacesRn rn_down (GDown himap hibmap iface_var)
   = readMutVarSST iface_var
 
 setIfacesRn :: Ifaces -> RnMG ()
-setIfacesRn ifaces rn_down (GDown dirs iface_var)
+setIfacesRn ifaces rn_down (GDown himap hibmap iface_var)
   = writeMutVarSST iface_var ifaces
 
-getSearchPathRn :: RnMG SearchPath
-getSearchPathRn rn_down (GDown dirs iface_var)
-  = returnSST dirs
+getModuleHiMap :: IfaceFlavour -> RnMG ModuleHiMap
+getModuleHiMap as_source rn_down (GDown himap hibmap iface_var)
+  = case as_source of
+      HiBootFile -> returnSST hibmap
+      _		 -> returnSST himap
+
+\end{code}
+
+%************************************************************************
+%*									*
+\subsection{HowInScope}
+%*									*
+%************************************************************************
+
+\begin{code}
+instance Outputable HowInScope where
+  ppr (FromLocalDefn loc)      = ptext SLIT("Defined at") <+> ppr loc
+  ppr (FromImportDecl mod loc) = ptext SLIT("Imported from") <+> quotes (pprModule mod) <+>
+		  	         ptext SLIT("at") <+> ppr loc
+\end{code}
+
+
+\begin{code}
+modeToNecessity SourceMode		    = Compulsory
+modeToNecessity (InterfaceMode necessity _) = necessity
 \end{code}