\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 ErrUtils ( addErrLoc, addShortErrLocLine, addShortWarnLocLine,
- pprBagOfErrors, SYN_IE(Error), SYN_IE(Warning)
+import BasicTypes ( Version, NewOrData, pprModule )
+import SrcLoc ( noSrcLoc )
+import ErrUtils ( addShortErrLocLine, addShortWarnLocLine,
+ pprBagOfErrors, ErrMsg, WarnMsg
)
-import Name ( SYN_IE(Module), Name, OccName, Provenance, SYN_IE(NameSet), emptyNameSet,
+import Maybes ( seqMaybe, mapMaybe )
+import Name ( Module, Name, OccName, PrintUnqualified, NameSet, emptyNameSet,
isLocallyDefinedName,
modAndOcc, NamedThing(..)
)
-import CmdLineOpts ( opt_D_show_rn_trace, opt_IgnoreIfacePragmas )
+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 PprStyle ( PprStyle(..) )
import SrcLoc ( SrcLoc, mkGeneratedSrcLoc )
import Unique ( Unique )
-import FiniteMap ( FiniteMap, emptyFM, bagToFM )
+import UniqFM ( UniqFM )
+import FiniteMap ( FiniteMap, emptyFM, bagToFM, lookupFM, addToFM, addListToFM_C )
import Bag ( Bag, mapBag, emptyBag, isEmptyBag, snocBag )
import UniqSet
-import Util
-#if __GLASGOW_HASKELL__ >= 202
import UniqSupply
-#endif
+import Util
+import Outputable
+import DirUtils ( getDirectoryContents )
infixr 9 `thenRn`, `thenRn_`
\end{code}
%************************************************************************
\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
-
-traceRn :: Doc -> RnMG ()
-traceRn msg | opt_D_show_rn_trace = ioToRnMG (hPutStr stderr (show msg) >>
- hPutStr stderr "\n") `thenRn_`
- returnRn ()
+sstToIO :: SST RealWorld r -> IO r
+sstToIO sst = stToIO (sstToST sst)
+
+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 :: SDoc -> RnMG ()
+putDocRn msg = ioToRnMG (printErrs msg) `thenRn_`
+ returnRn ()
\end{code}
\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,Necessity)]) -- Occurrences
+ (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
-- For getting global names
data GDown = GDown
- SearchPath
- (MutVar Ifaces)
+ ModuleHiMap
+ (SSTRWRef Ifaces)
-- For renaming source code
data SDown s = SDown
RnSMode
-data RnSMode = SourceMode
- | InterfaceMode
+data RnSMode = SourceMode -- Renaming source code
+ | 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,
+ -- 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}
===================================================
\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
-data RnEnv = RnEnv NameEnv FixityEnv
-emptyRnEnv = RnEnv emptyNameEnv emptyFixityEnv
+type GlobalNameEnv = FiniteMap RdrName (Name, HowInScope)
+emptyGlobalNameEnv = emptyFM
+
+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:
--
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 ModuleAvails = FiniteMap Module Avails
+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)
+
+ UniqFM AvailInfo) -- Used to figure out all other export specifiers.
+ -- Maps a Name to the AvailInfo that contains it
+ -- NB: Contain bindings for class ops but
+ -- not constructors (see defn of availEntityNames)
-data AvailInfo = NotAvailable
- | Avail Name -- An ordinary identifier
- | AvailTC Name -- The name of the type or class
- [Name] -- The available pieces of type/class. NB: If the type or
+
+data GenAvailInfo name = NotAvailable
+ | Avail name -- An ordinary identifier
+ | AvailTC name -- The name of the type or class
+ [name] -- The available pieces of type/class. NB: If the type or
-- class is itself to be in scope, it must be in this list.
-- Thus, typically: AvailTC Eq [Eq, ==, /=]
+type AvailInfo = GenAvailInfo Name
+type RdrAvailInfo = GenAvailInfo OccName
\end{code}
===================================================
===================================================
\begin{code}
-type ExportItem = (Module, [(OccName, [OccName])])
+type ExportItem = (Module, IfaceFlavour, [RdrAvailInfo])
type VersionInfo name = [ImportVersion name]
-type ImportVersion name = (Module, 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
[(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
-------------------
data Ifaces = Ifaces
- Module -- Name of this module
- (FiniteMap Module Version)
- (FiniteMap Module (Avails, [(OccName,Fixity)])) -- Exports
+ Module -- Name of this module
+ (FiniteMap Module (IfaceFlavour, -- Exports
+ Version,
+ Avails,
+ [(OccName,Fixity)]))
DeclsMap
NameSet -- All the names (whether "big" or "small", whether wired-in or not,
-- This is used to generate the "usage" information for this module.
-- Subset of the previous field.
- (Bag IfaceInst) -- The as-yet un-slurped instance decls; this bag is depleted when we
- -- slurp an instance decl so that we don't slurp the same one twice.
+ (Bag IfaceInst, NameSet) -- The as-yet un-slurped instance decls; this bag is depleted when we
+ -- slurp an instance decl so that we don't slurp the same one twice.
+ -- Together with them is the set of tycons/classes that may allow
+ -- the instance decls in.
(FiniteMap Name RdrNameTyDecl)
-- Deferred data type declarations; each has the following properties
\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
+ -> 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 <- mkModuleHiMap dirs
+ let
+ rn_down = RnDown loc names_var errs_var occs_var
+ g_down = GDown himap iface_var
+
-- do the buisness
- do_rn rn_down g_down `thenSST` \ res ->
+ 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
emptyIfaces :: Module -> Ifaces
-emptyIfaces mod = Ifaces mod emptyFM emptyFM emptyFM emptyNameSet [] emptyBag emptyFM []
+emptyIfaces mod = Ifaces mod emptyFM emptyFM emptyNameSet [] (emptyBag, emptyNameSet) emptyFM []
builtins :: FiniteMap (Module,OccName) Name
builtins = bagToFM (mapBag (\ name -> (modAndOcc name, name)) builtinNames)
-- Initial value for the occurrence pool.
-initOccs :: [(Name,Necessity)]
-initOccs = [(getName boolTyCon, Compulsory)]
+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}
+mkModuleHiMap :: SearchPath -> IO ModuleHiMap
+mkModuleHiMap dirs = do
+ lss <- mapM (uncurry getAllFilesMatching) dirs
+ let ls = concat lss
+ if opt_WarnHiShadows
+ then return (addListToFM_C conflict env ls)
+ else return (addListToFM_C (\ old new -> old) env ls)
+ where
+ env = emptyFM
+
+ 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.
+
+getAllFilesMatching :: FilePath -> String -> IO [(String, FilePath)]
+getAllFilesMatching dir_path suffix = do
+ fpaths <- getDirectoryContents dir_path
+ -- fpaths entries do not have dir_path prepended
+ return (mapMaybe withSuffix fpaths)
+ where
+ xiffus = reverse dotted_suffix
+
+ dotted_suffix =
+ case suffix of
+ [] -> []
+ ('.':xs) -> suffix
+ ls -> '.':ls
+
+ -- filter out files that have the desired suffix
+ withSuffix nm = go "" xiffus rev_nm `seqMaybe`
+ go "b" "toob-ih." rev_nm
+ where
+ rev_nm = reverse nm
+
+ -- the prefix is needed to distinguish between a .hi-boot
+ -- file and a normal interface file, i.e., I'm not willing
+ -- to guarantee that the presence of the SOURCE pragma
+ --
+ -- import {-# SOURCE #-} Foo (x)
+ -- import Bar
+ --
+ -- will not cause Foo.hi to somehow be looked at when
+ -- slurping in Bar.
+ --
+ go pre [] xs = Just (pre ++ reverse xs, dir_path ++'/':nm)
+ go _ _ [] = Nothing
+ go pre (x:xs) (y:ys)
+ | x == y = go pre xs ys
+ | otherwise = Nothing
\end{code}
\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:
= runSST (
newMutVarSST name_supply `thenSST` \ names_var ->
newMutVarSST (emptyBag,emptyBag) `thenSST` \ errs_var ->
- newMutVarSST [] `thenSST` \ occs_var ->
+ newMutVarSST ([],[]) `thenSST` \ occs_var ->
let
rn_down = RnDown mkGeneratedSrcLoc names_var errs_var occs_var
- s_down = SDown emptyRnEnv emptyNameEnv mod_name InterfaceMode
+ 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_ #-}
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])
= 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}
================ 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_`
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_`
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
================ 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 =====================
+Every time we get an occurrence of a name we put it in one of two lists:
+ one for "compulsory" occurrences
+ one for "optional" occurrences
+
+The significance of "compulsory" is
+ (a) we *must* find the declaration
+ (b) in the case of type or class names, the name is part of the
+ source level program, and we must slurp in any instance decls
+ involving it.
+
+We don't need instance decls "optional" names, because the type inference
+process will never come across them. Optional names are buried inside
+type checked (but not renamed) cross-module unfoldings and such.
+
+The pair of lists is held in a mutable variable in RnDown.
+
+The lists are kept separate so that we can process all the compulsory occurrences
+before any of the optional ones. Why? Because suppose we processed an optional
+"g", and slurped an interface decl of g::T->T. Then we'd rename the type T->T in
+optional mode. But if we later need g compulsorily we'll find that it's already
+been slurped and will do nothing. We could, I suppose, rename it a second time,
+but it seems simpler just to do all the compulsory ones first.
+
\begin{code}
-addOccurrenceName :: Necessity -> Name -> RnM s d Name -- Same name returned as passed
-addOccurrenceName necessity name (RnDown loc names_var errs_var occs_var) l_down
+addOccurrenceName :: Name -> RnMS s Name -- Same name returned as passed
+addOccurrenceName name (RnDown loc names_var errs_var occs_var)
+ (SDown rn_env local_env mod_name mode)
| isLocallyDefinedName name ||
not_necessary necessity
= returnSST name
| otherwise
- = readMutVarSST occs_var `thenSST` \ occs ->
- writeMutVarSST occs_var ((name,necessity) : occs) `thenSST_`
+ = readMutVarSST occs_var `thenSST` \ (comp_occs, opt_occs) ->
+ let
+ new_occ_pair = case necessity of
+ 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
- not_necessary Compulsory = False
- not_necessary Optional = opt_IgnoreIfacePragmas
- -- Never look for optional things if we're
- -- ignoring optional input interface information
+ necessity = modeToNecessity mode
-addOccurrenceNames :: Necessity -> [Name] -> RnM s d ()
-addOccurrenceNames necessity names (RnDown loc names_var errs_var occs_var) l_down
- = readMutVarSST occs_var `thenSST` \ occs ->
- writeMutVarSST occs_var ([(name,necessity) | name <- names, not (isLocallyDefinedName name)] ++ occs)
-popOccurrenceName :: RnM s d (Maybe (Name,Necessity))
-popOccurrenceName (RnDown loc names_var errs_var occs_var) l_down
+addOccurrenceNames :: [Name] -> RnMS s ()
+addOccurrenceNames names (RnDown loc names_var errs_var occs_var)
+ (SDown rn_env local_env mod_name mode)
+ | not_necessary necessity
+ = returnSST ()
+
+ | otherwise
+ = readMutVarSST occs_var `thenSST` \ (comp_occs, opt_occs) ->
+ let
+ new_occ_pair = case necessity of
+ 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_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 :: RnSMode -> RnM s d (Maybe Occurrence)
+popOccurrenceName mode (RnDown loc names_var errs_var occs_var) l_down
= readMutVarSST occs_var `thenSST` \ occs ->
- case occs of
- [] -> returnSST Nothing
- (occ:occs) -> writeMutVarSST occs_var occs `thenSST_`
- returnSST (Just occ)
+ case (mode, occs) of
+ -- Find a compulsory occurrence
+ (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
+ (InterfaceMode Optional _, (comps, opt:opts))
+ -> ASSERT( null comps )
+ writeMutVarSST occs_var (comps, opts) `thenSST_`
+ returnSST (Just opt)
+
+ -- No suitable occurrence
+ other -> returnSST Nothing
-- findOccurrencesRn does the enclosed thing with a *fresh* occurrences
-- variable, and returns the list of occurrences thus found. It's useful
findOccurrencesRn :: RnM s d a -> RnM s d [Name]
findOccurrencesRn enclosed_thing (RnDown loc names_var errs_var occs_var) l_down
- = newMutVarSST [] `thenSST` \ new_occs_var ->
+ = 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 ->
+ readMutVarSST new_occs_var `thenSST` \ (occs,_) ->
returnSST (map fst occs)
\end{code}
================ 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
getModeRn :: RnMS s RnSMode
getModeRn rn_down (SDown rn_env local_env mod_name mode)
= returnSST mode
+
+setModeRn :: RnSMode -> RnMS s a -> RnMS s a
+setModeRn new_mode thing_inside rn_down (SDown rn_env local_env mod_name mode)
+ = thing_inside rn_down (SDown rn_env local_env mod_name new_mode)
\end{code}
setIfacesRn ifaces rn_down (GDown dirs iface_var)
= writeMutVarSST iface_var ifaces
+{-
getSearchPathRn :: RnMG SearchPath
getSearchPathRn rn_down (GDown dirs iface_var)
= returnSST dirs
+-}
+
+getModuleHiMap :: RnMG ModuleHiMap
+getModuleHiMap rn_down (GDown himap iface_var)
+ = 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}