%
-% (c) The GRASP/AQUA Project, Glasgow University, 1992-1996
+% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
%
\section[RnMonad]{The monad used by the renamer}
\begin{code}
+module RnMonad(
+ module RnMonad,
+ Module,
+ FiniteMap,
+ Bag,
+ Name,
+ RdrNameHsDecl,
+ RdrNameInstDecl,
+ Version,
+ NameSet,
+ OccName,
+ Fixity
+ ) where
+
#include "HsVersions.h"
-module RnMonad (
- RnMonad(..), RnM(..), RnM_Fixes(..), RnDown, SST_R,
- initRn, thenRn, thenRn_, andRn, returnRn,
- mapRn, mapAndUnzipRn, mapAndUnzip3Rn,
+import SST
+import GlaExts ( RealWorld, stToIO )
+import List ( intersperse )
+
+import HsSyn
+import RdrHsSyn
+import RnHsSyn ( RenamedFixitySig )
+import BasicTypes ( Version )
+import SrcLoc ( noSrcLoc )
+import ErrUtils ( addShortErrLocLine, addShortWarnLocLine,
+ pprBagOfErrors, ErrMsg, WarnMsg, Message
+ )
+import Name ( Name, OccName, NamedThing(..),
+ isLocallyDefinedName, nameModule, nameOccName,
+ decode
+ )
+import Module ( Module, IfaceFlavour, setModuleFlavour, mkSysModuleFS,
+ bootFlavour, moduleString, moduleIfaceFlavour, mkDynFlavour
+ )
+import NameSet
+import RdrName ( RdrName )
+import CmdLineOpts ( opt_D_show_rn_trace, opt_IgnoreIfacePragmas,
+ opt_WarnHiShadows, opt_Static
+ )
+import PrelInfo ( builtinNames )
+import TysWiredIn ( boolTyCon )
+import SrcLoc ( SrcLoc, mkGeneratedSrcLoc )
+import Unique ( Unique )
+import UniqFM ( UniqFM )
+import FiniteMap ( FiniteMap, emptyFM, bagToFM, lookupFM, addToFM, addListToFM,
+ addListToFM_C, addToFM_C, eltsFM
+ )
+import Bag ( Bag, mapBag, emptyBag, isEmptyBag, snocBag )
+import Maybes ( seqMaybe, mapMaybe )
+import UniqSet
+import UniqFM
+import UniqSupply
+import Util
+import Outputable
+import DirUtils ( getDirectoryContents )
+import Directory ( doesFileExist )
+import IO ( hPutStrLn, stderr, isDoesNotExistError )
+import Monad ( foldM )
+import Maybe ( fromMaybe )
+import Constants ( interfaceFileFormatVersion )
- addErrRn, addErrIfRn, addWarnRn, addWarnIfRn,
- failButContinueRn, warnAndContinueRn,
- setExtraRn, getExtraRn, getRnEnv,
- getModuleRn, pushSrcLocRn, getSrcLocRn,
- getSourceRn, getOccurrenceUpRn,
- getImplicitUpRn, ImplicitEnv(..), emptyImplicitEnv,
- rnGetUnique, rnGetUniques,
+infixr 9 `thenRn`, `thenRn_`
+\end{code}
- newLocalNames,
- lookupValue, lookupConstr, lookupField, lookupClassOp,
- lookupTyCon, lookupClass, lookupTyConOrClass,
- extendSS2, extendSS,
- TyVarNamesEnv(..), mkTyVarNamesEnv, domTyVarNamesEnv,
- lookupTyVarName, nullTyVarNamesEnv, catTyVarNamesEnvs,
+%************************************************************************
+%* *
+\subsection{Somewhat magical interface to other monads}
+%* *
+%************************************************************************
- fixIO
- ) where
+\begin{code}
+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}
-import Ubiq{-uitous-}
-import SST
+%************************************************************************
+%* *
+\subsection{Data types}
+%* *
+%************************************************************************
-import HsSyn ( FixityDecl )
-import RnHsSyn ( RnName, mkRnName, mkRnUnbound, mkRnImplicit,
- mkRnImplicitTyCon, mkRnImplicitClass,
- isRnLocal, isRnWired, isRnTyCon, isRnClass,
- isRnTyConOrClass, isRnConstr, isRnField,
- isRnClassOp, RenamedFixityDecl(..) )
-import RnUtils ( RnEnv(..), extendLocalRnEnv,
- lookupRnEnv, lookupGlobalRnEnv, lookupTcRnEnv,
- unknownNameErr, badClassOpErr, qualNameErr,
- dupNamesErr, shadowedNameWarn
- )
+===================================================
+ MONAD TYPES
+===================================================
-import Bag ( Bag, emptyBag, isEmptyBag, snocBag )
-import CmdLineOpts ( opt_WarnNameShadowing )
-import ErrUtils ( Error(..), Warning(..) )
-import FiniteMap ( FiniteMap, emptyFM, lookupFM, addToFM )
-import Maybes ( assocMaybe )
-import Name ( Module(..), RdrName(..), isQual,
- Name, mkLocalName, mkImplicitName,
- getOccName
- )
-import PrelInfo ( builtinNameInfo, BuiltinNames(..), BuiltinKeys(..) )
-import Pretty ( Pretty(..), PrettyRep )
-import SrcLoc ( SrcLoc, mkUnknownSrcLoc )
-import UniqFM ( UniqFM, emptyUFM )
-import UniqSet ( UniqSet(..), mkUniqSet, minusUniqSet )
-import UniqSupply ( UniqSupply, getUnique, getUniques, splitUniqSupply )
-import Unique ( Unique )
-import Util
+\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 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 {
+ rn_loc :: SrcLoc,
+ rn_omit :: Name -> Bool, -- True <=> omit qualifier when printing
+ rn_ns :: SSTRef s RnNameSupply,
+ rn_errs :: SSTRef s (Bag WarnMsg, Bag ErrMsg),
+ rn_occs :: SSTRef s ([Occurrence],[Occurrence]), -- Occurrences: compulsory and optional resp
+ rn_hi_map :: ModuleHiMap, -- for .hi files
+ rn_hiboot_map :: ModuleHiMap, -- for .hi-boot files
+ rn_mod :: Module
+ }
+
+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 optional ones.
+
+ -- For getting global names
+data GDown = GDown {
+ rn_ifaces :: SSTRWRef Ifaces
+ }
+
+ -- For renaming source code
+data SDown s = SDown {
+ rn_mode :: RnMode,
+ rn_genv :: RnEnv, -- Global envt; the fixity component gets extended
+ -- with local fixity decls
+ rn_lenv :: LocalRdrEnv -- Local name envt
+ -- Does *not* includes global name envt; may shadow it
+ -- Includes both ordinary variables and type variables;
+ -- they are kept distinct because tyvar have a different
+ -- occurrence contructor (Name.TvOcc)
+ -- We still need the unsullied global name env so that
+ -- we can look up record field names
+ }
+
+data RnMode = 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.
+
+type SearchPath = [(String,String)] -- List of (directory,suffix) pairs to search
+ -- for interface files.
+
+type ModuleHiMap = FiniteMap String (String, Bool)
+ -- mapping from module name to the file path of its corresponding
+ -- interface file.
+\end{code}
-infixr 9 `thenRn`, `thenRn_`
+===================================================
+ ENVIRONMENTS
+===================================================
+
+\begin{code}
+--------------------------------
+type RdrNameEnv a = FiniteMap RdrName a
+type GlobalRdrEnv = RdrNameEnv [Name] -- The list is because there may be name clashes
+ -- These only get reported on lookup,
+ -- not on construction
+type LocalRdrEnv = RdrNameEnv Name
+
+emptyRdrEnv :: RdrNameEnv a
+lookupRdrEnv :: RdrNameEnv a -> RdrName -> Maybe a
+addListToRdrEnv :: RdrNameEnv a -> [(RdrName,a)] -> RdrNameEnv a
+
+emptyRdrEnv = emptyFM
+lookupRdrEnv = lookupFM
+addListToRdrEnv = addListToFM
+rdrEnvElts = eltsFM
+
+--------------------------------
+type NameEnv a = UniqFM a -- Domain is Name
+
+emptyNameEnv :: NameEnv a
+nameEnvElts :: NameEnv a -> [a]
+addToNameEnv_C :: (a->a->a) -> NameEnv a -> Name -> a -> NameEnv a
+addToNameEnv :: NameEnv a -> Name -> a -> NameEnv a
+plusNameEnv :: NameEnv a -> NameEnv a -> NameEnv a
+extendNameEnv :: NameEnv a -> [(Name,a)] -> NameEnv a
+lookupNameEnv :: NameEnv a -> Name -> Maybe a
+delFromNameEnv :: NameEnv a -> Name -> NameEnv a
+elemNameEnv :: Name -> NameEnv a -> Bool
+
+emptyNameEnv = emptyUFM
+nameEnvElts = eltsUFM
+addToNameEnv_C = addToUFM_C
+addToNameEnv = addToUFM
+plusNameEnv = plusUFM
+extendNameEnv = addListToUFM
+lookupNameEnv = lookupUFM
+delFromNameEnv = delFromUFM
+elemNameEnv = elemUFM
+
+--------------------------------
+type FixityEnv = NameEnv RenamedFixitySig
+
+--------------------------------
+data RnEnv = RnEnv GlobalRdrEnv FixityEnv
+emptyRnEnv = RnEnv emptyRdrEnv emptyNameEnv
\end{code}
\begin{code}
-type RnM s r = RnMonad () s r
-type RnM_Fixes s r = RnMonad (UniqFM RenamedFixityDecl) s r
-
-type RnMonad x s r = RnDown x s -> SST s r
-
-data RnDown x s
- = RnDown
- x
- Module -- Module name
- SrcLoc -- Source location
- (RnMode s) -- Source or Iface
- RnEnv -- Renaming environment
- (MutableVar s UniqSupply) -- Unique supply
- (MutableVar s (Bag Warning, -- Warnings and Errors
- Bag Error))
-
-data RnMode s
- = RnSource (MutableVar s (Bag (RnName, RdrName)))
- -- Renaming source; returning occurences
-
- | RnIface BuiltinNames BuiltinKeys
- (MutableVar s ImplicitEnv)
- -- Renaming interface; creating and returning implicit names
- -- ImplicitEnv: one map for Values and one for TyCons/Classes.
-
-type ImplicitEnv = (FiniteMap RdrName RnName, FiniteMap RdrName RnName)
-emptyImplicitEnv :: ImplicitEnv
-emptyImplicitEnv = (emptyFM, emptyFM)
-
--- With a builtin polymorphic type for _runSST the type for
--- initTc should use RnM s r instead of RnM _RealWorld r
-
-initRn :: Bool -- True => Source; False => Iface
- -> Module
- -> RnEnv
- -> UniqSupply
- -> RnM _RealWorld r
- -> (r, Bag Error, Bag Warning)
-
-initRn source mod env us do_rn
- = _runSST (
- newMutVarSST emptyBag `thenSST` \ occ_var ->
- newMutVarSST emptyImplicitEnv `thenSST` \ imp_var ->
- newMutVarSST us `thenSST` \ us_var ->
- newMutVarSST (emptyBag,emptyBag) `thenSST` \ errs_var ->
- let
- mode = if source then
- RnSource occ_var
- else
- case builtinNameInfo of { (wiredin_fm, key_fm, _) ->
- RnIface wiredin_fm key_fm imp_var }
-
- rn_down = RnDown () mod mkUnknownSrcLoc mode env us_var errs_var
- in
- -- do the buisness
- do_rn rn_down `thenSST` \ res ->
+--------------------------------
+type RnNameSupply
+ = ( UniqSupply
+
+ , FiniteMap (OccName, OccName) Int
+ -- This is used as a name supply for dictionary functions
+ -- From the inst decl we derive a (class, tycon) pair;
+ -- this map then gives a unique int for each inst decl with that
+ -- (class, tycon) pair. (In Haskell 98 there can only be one,
+ -- but not so in more extended versions.)
+ --
+ -- We could just use one Int for all the instance decls, but this
+ -- way the uniques change less when you add an instance decl,
+ -- hence less recompilation
+
+ , FiniteMap (Module,OccName) Name
+ -- Ensures that one (module,occname) pair gets one unique
+ )
+
+
+--------------------------------
+data ExportEnv = ExportEnv Avails Fixities
+type Avails = [AvailInfo]
+type Fixities = [(Name, 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)
+
+ NameEnv AvailInfo) -- Used to figure out all other export specifiers.
+ -- Maps a Name to the AvailInfo that contains it
+
+
+data GenAvailInfo name = 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}
+
+===================================================
+ INTERFACE FILE STUFF
+===================================================
+
+\begin{code}
+type ExportItem = (Module, [RdrAvailInfo])
+type VersionInfo name = [ImportVersion name]
+
+type ImportVersion name = (Module, 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
+ = ParsedIface
+ Version -- Module version number
+ [ImportVersion OccName] -- Usages
+ [ExportItem] -- Exports
+ [Module] -- Special instance modules
+ [(Version, RdrNameHsDecl)] -- Local definitions
+ [RdrNameInstDecl] -- Local instance declarations
+
+type InterfaceDetails = (VersionInfo Name, -- Version information for what this module imports
+ ExportEnv, -- What this module exports
+ [Module]) -- Instance modules
+
+
+-- needed by Main to fish out the fixities assoc list.
+getIfaceFixities :: InterfaceDetails -> Fixities
+getIfaceFixities (_, ExportEnv _ fs, _) = fs
+
+
+type RdrNamePragma = () -- Fudge for now
+-------------------
+
+data Ifaces = Ifaces {
+ iMod :: Module, -- Name of the module being compiled
+
+ iModMap :: FiniteMap Module (IfaceFlavour, -- Exports
+ Version,
+ Avails),
+
+ iDecls :: DeclsMap, -- A single, global map of Names to decls
+
+ iFixes :: FixityEnv, -- A single, global map of Names to fixities
+
+ iSlurp :: NameSet, -- All the names (whether "big" or "small", whether wired-in or not,
+ -- whether locally defined or not) that have been slurped in so far.
+
+ iVSlurp :: [(Name,Version)], -- All the (a) non-wired-in (b) "big" (c) non-locally-defined names that
+ -- have been slurped in so far, with their versions.
+ -- This is used to generate the "usage" information for this module.
+ -- Subset of the previous field.
+
+ iDefInsts :: (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.
+
+ iDefData :: NameEnv (Module, RdrNameTyClDecl),
+ -- Deferred data type declarations; each has the following properties
+ -- * it's a data type decl
+ -- * its TyCon is needed
+ -- * the decl may or may not have been slurped, depending on whether any
+ -- of the constrs are needed.
+
+ iInstMods :: [Module] -- Set of modules with "special" instance declarations
+ -- Excludes this module
+ }
+
+
+type DeclsMap = NameEnv (Version, AvailInfo, RdrNameHsDecl, Bool)
+ -- A DeclsMap contains a binding for each Name in the declaration
+ -- including the constructors of a type decl etc.
+ -- The Bool is True just for the 'main' Name.
+
+type IfaceInst = ((Module, RdrNameInstDecl), -- Instance decl
+ NameSet) -- "Gate" names. Slurp this instance decl when this
+ -- set becomes empty. It's depleted whenever we
+ -- slurp another type or class decl.
+\end{code}
+
+
+%************************************************************************
+%* *
+\subsection{Main monad code}
+%* *
+%************************************************************************
+
+\begin{code}
+initRn :: Module -> UniqSupply -> SearchPath -> SrcLoc
+ -> RnMG r
+ -> IO (r, Bag ErrMsg, Bag WarnMsg)
+
+initRn mod us dirs loc do_rn = do
+ (himap, hibmap) <- mkModuleHiMaps dirs
+ names_var <- sstToIO (newMutVarSST (us, emptyFM, builtins))
+ errs_var <- sstToIO (newMutVarSST (emptyBag,emptyBag))
+ iface_var <- sstToIO (newMutVarSST (emptyIfaces mod))
+ occs_var <- sstToIO (newMutVarSST initOccs)
+ let
+ rn_down = RnDown { rn_loc = loc, rn_omit = \n -> False, rn_ns = names_var,
+ rn_errs = errs_var, rn_occs = occs_var,
+ rn_hi_map = himap, rn_hiboot_map = hibmap,
+ rn_mod = mod }
+ g_down = GDown {rn_ifaces = 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 -> RnMode -> RnMS RealWorld r -> RnMG r
+initRnMS rn_env mode m rn_down g_down
+ = let
+ s_down = SDown { rn_genv = rn_env, rn_lenv = emptyRdrEnv, rn_mode = mode }
+ in
+ m rn_down s_down
+
+
+emptyIfaces :: Module -> Ifaces
+emptyIfaces mod = Ifaces { iMod = mod,
+ iModMap = emptyFM,
+ iDecls = emptyNameEnv,
+ iFixes = emptyNameEnv,
+ iSlurp = emptyNameSet,
+ iVSlurp = [],
+ iDefInsts = (emptyBag, emptyNameSet),
+ iDefData = emptyNameEnv,
+ iInstMods = []
+ }
+builtins :: FiniteMap (Module,OccName) Name
+builtins =
+ bagToFM (
+ mapBag (\ name -> ((nameModule name, nameOccName name), name))
+ builtinNames)
+
+ -- Initial value for the occurrence pool.
+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}
+
+We (allege) that it is quicker to build up a mapping from module names
+to the paths to their corresponding interface files once, than to search
+along the import part every time we slurp in a new module (which we
+do quite a lot of.)
+
+\begin{code}
+mkModuleHiMaps :: SearchPath -> IO (ModuleHiMap, ModuleHiMap)
+mkModuleHiMaps dirs = foldM (getAllFilesMatching dirs) (env,env) dirs
+ where
+ env = emptyFM
+
+{- a pseudo file which signals that the interface files
+ contained in a particular directory have got their
+ corresponding object codes stashed away in a DLL
+
+ This stuff is only needed to deal with Win32 DLLs,
+ and conceivably we conditionally compile in support
+ for handling it. (ToDo?)
+-}
+dir_contain_dll_his = "dLL_ifs.hi"
+
+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
+ is_dyns <- catch
+ (if opt_Static || dir_path == "." then
+ return False
+ else
+ doesFileExist (dir_path ++ '/': dir_contain_dll_his))
+ (\ _ {-don't care-} -> return False)
+ return (foldl (addModules is_dyns) 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 is_dll his@(hi_env, hib_env) nm = fromMaybe his $
+ FMAP (\ (mod_nm,v) -> (addToFM_C addNewOne hi_env mod_nm (v, is_dll), hib_env))
+ (go xiffus rev_nm) `seqMaybe`
+
+ FMAP (\ (mod_nm,v) -> (hi_env, addToFM_C overrideNew hib_env mod_nm (v,is_dll)))
+ (go hi_boot_version_xiffus rev_nm) `seqMaybe`
+
+ FMAP (\ (mod_nm,v) -> (hi_env, addToFM_C addNewOne hib_env mod_nm (v,is_dll)))
+ (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 the 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}
+
+
+@renameSourceCode@ is used to rename stuff "out-of-line"; that is, not as part of
+the main renamer. Examples: pragmas (which we don't want to rename unless
+we actually explore them); and derived definitions, which are only generated
+in the type checker.
+
+The @RnNameSupply@ includes a @UniqueSupply@, so if you call it more than
+once you must either split it, or install a fresh unique supply.
+
+\begin{code}
+renameSourceCode :: Module
+ -> RnNameSupply
+ -> RnMS RealWorld r
+ -> r
+
+-- Alas, we can't use the real runST, with the desired signature:
+-- renameSourceCode :: RnNameSupply -> RnMS s r -> r
+-- because we can't manufacture "new versions of runST".
+
+renameSourceCode mod_name name_supply m
+ = runSST (
+ newMutVarSST name_supply `thenSST` \ names_var ->
+ newMutVarSST (emptyBag,emptyBag) `thenSST` \ errs_var ->
+ newMutVarSST ([],[]) `thenSST` \ occs_var ->
+ let
+ rn_down = RnDown { rn_loc = mkGeneratedSrcLoc, rn_ns = names_var,
+ rn_errs = errs_var, rn_occs = occs_var,
+ rn_mod = mod_name }
+ s_down = SDown { rn_mode = InterfaceMode Compulsory,
+ rn_genv = emptyRnEnv, rn_lenv = emptyRdrEnv }
+ in
+ m rn_down s_down `thenSST` \ result ->
+
+ readMutVarSST errs_var `thenSST` \ (warns,errs) ->
+
+ (if not (isEmptyBag errs) then
+ pprTrace "Urk! renameSourceCode found errors" (display errs)
+#ifdef DEBUG
+ else if not (isEmptyBag warns) then
+ pprTrace "Note: renameSourceCode found warnings" (display warns)
+#endif
+ else
+ id) $
+
+ returnSST result
)
+ where
+ display errs = pprBagOfErrors errs
{-# INLINE thenRn #-}
{-# INLINE thenRn_ #-}
{-# INLINE returnRn #-}
{-# INLINE andRn #-}
-returnRn :: a -> RnMonad x s a
-thenRn :: RnMonad x s a -> (a -> RnMonad x s b) -> RnMonad x s b
-thenRn_ :: RnMonad x s a -> RnMonad x s b -> RnMonad x s b
-andRn :: (a -> a -> a) -> RnMonad x s a -> RnMonad x s a -> RnMonad x s a
-mapRn :: (a -> RnMonad x s b) -> [a] -> RnMonad x s [b]
-mapAndUnzipRn :: (a -> RnMonad x s (b,c)) -> [a] -> RnMonad x s ([b],[c])
-
-returnRn v down = returnSST v
-thenRn m k down = m down `thenSST` \ r -> k r down
-thenRn_ m k down = m down `thenSST_` k down
-
-andRn combiner m1 m2 down
- = m1 down `thenSST` \ res1 ->
- m2 down `thenSST` \ res2 ->
+returnRn :: a -> RnM s d a
+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]
+mapRn_ :: (a -> RnM s d b) -> [a] -> RnM s d ()
+mapMaybeRn :: (a -> RnM s d (Maybe b)) -> [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])
+fixRn :: (a -> RnM s d a) -> RnM s d a
+
+returnRn v gdown ldown = returnSST v
+thenRn m k gdown ldown = m gdown ldown `thenSST` \ r -> k r gdown ldown
+thenRn_ m k gdown ldown = m gdown ldown `thenSST_` k gdown ldown
+fixRn m gdown ldown = fixSST (\r -> m r gdown ldown)
+andRn combiner m1 m2 gdown ldown
+ = m1 gdown ldown `thenSST` \ res1 ->
+ m2 gdown ldown `thenSST` \ res2 ->
returnSST (combiner res1 res2)
+sequenceRn [] = returnRn []
+sequenceRn (m:ms) = m `thenRn` \ r ->
+ sequenceRn ms `thenRn` \ rs ->
+ returnRn (r:rs)
+
mapRn f [] = returnRn []
mapRn f (x:xs)
= f x `thenRn` \ r ->
mapRn f xs `thenRn` \ rs ->
returnRn (r:rs)
+mapRn_ f [] = returnRn ()
+mapRn_ f (x:xs) =
+ f x `thenRn_`
+ mapRn_ f xs
+
+foldlRn k z [] = returnRn z
+foldlRn k z (x:xs) = k z x `thenRn` \ z' ->
+ foldlRn k z' xs
+
mapAndUnzipRn f [] = returnRn ([],[])
mapAndUnzipRn f (x:xs)
= f x `thenRn` \ (r1, r2) ->
= f x `thenRn` \ (r1, r2, r3) ->
mapAndUnzip3Rn f xs `thenRn` \ (rs1, rs2, rs3) ->
returnRn (r1:rs1, r2:rs2, r3:rs3)
-\end{code}
-For errors and warnings ...
-\begin{code}
-failButContinueRn :: a -> Error -> RnMonad x s a
-failButContinueRn res err (RnDown _ _ _ _ _ _ errs_var)
- = readMutVarSST errs_var `thenSST` \ (warns,errs) ->
- writeMutVarSST errs_var (warns, errs `snocBag` err) `thenSST_`
- returnSST res
-
-warnAndContinueRn :: a -> Warning -> RnMonad x s a
-warnAndContinueRn res warn (RnDown _ _ _ _ _ _ errs_var)
- = readMutVarSST errs_var `thenSST` \ (warns,errs) ->
- writeMutVarSST errs_var (warns `snocBag` warn, errs) `thenSST_`
- returnSST res
-
-addErrRn :: Error -> RnMonad x s ()
-addErrRn err = failButContinueRn () err
+mapMaybeRn f [] = returnRn []
+mapMaybeRn f (x:xs) = f x `thenRn` \ maybe_r ->
+ mapMaybeRn f xs `thenRn` \ rs ->
+ case maybe_r of
+ Nothing -> returnRn rs
+ Just r -> returnRn (r:rs)
+\end{code}
-addErrIfRn :: Bool -> Error -> RnMonad x s ()
-addErrIfRn True err = addErrRn err
-addErrIfRn False err = returnRn ()
-addWarnRn :: Warning -> RnMonad x s ()
-addWarnRn warn = warnAndContinueRn () warn
-addWarnIfRn :: Bool -> Warning -> RnMonad x s ()
-addWarnIfRn True warn = addWarnRn warn
-addWarnIfRn False warn = returnRn ()
-\end{code}
+%************************************************************************
+%* *
+\subsection{Boring plumbing for common part}
+%* *
+%************************************************************************
-\begin{code}
-getRnEnv :: RnMonad x s RnEnv
-getRnEnv (RnDown _ _ _ _ env _ _)
- = returnSST env
-
-setExtraRn :: x -> RnMonad x s r -> RnMonad y s r
-setExtraRn x m (RnDown _ mod locn mode env us errs)
- = m (RnDown x mod locn mode env us errs)
-
-getExtraRn :: RnMonad x s x
-getExtraRn (RnDown x _ _ _ _ _ _)
- = returnSST x
-
-getModuleRn :: RnMonad x s Module
-getModuleRn (RnDown _ mod _ _ _ _ _)
- = returnSST mod
-
-pushSrcLocRn :: SrcLoc -> RnMonad x s a -> RnMonad x s a
-pushSrcLocRn locn m (RnDown x mod _ mode env us errs)
- = m (RnDown x mod locn mode env us errs)
-
-getSrcLocRn :: RnMonad x s SrcLoc
-getSrcLocRn (RnDown _ _ locn _ _ _ _)
- = returnSST locn
-
-getSourceRn :: RnMonad x s Bool
-getSourceRn (RnDown _ _ _ (RnSource _) _ _ _) = returnSST True
-getSourceRn (RnDown _ _ _ (RnIface _ _ _) _ _ _) = returnSST False
-
-getOccurrenceUpRn :: RnMonad x s (Bag (RnName, RdrName))
-getOccurrenceUpRn (RnDown _ _ _ (RnSource occ_var) _ _ _)
- = readMutVarSST occ_var
-getOccurrenceUpRn (RnDown _ _ _ (RnIface _ _ _) _ _ _)
- = panic "getOccurrenceUpRn:RnIface"
-
-getImplicitUpRn :: RnMonad x s ImplicitEnv
-getImplicitUpRn (RnDown _ _ _ (RnIface _ _ imp_var) _ _ _)
- = readMutVarSST imp_var
-getImplicitUpRn (RnDown _ _ _(RnSource _) _ _ _)
- = panic "getImplicitUpRn:RnIface"
-\end{code}
+================ Errors and warnings =====================
\begin{code}
-rnGetUnique :: RnMonad x s Unique
-rnGetUnique (RnDown _ _ _ _ _ us_var _)
- = get_unique us_var
+failWithRn :: a -> Message -> RnM s d a
+failWithRn res msg (RnDown {rn_errs = errs_var, rn_loc = loc}) l_down
+ = readMutVarSST errs_var `thenSST` \ (warns,errs) ->
+ writeMutVarSST errs_var (warns, errs `snocBag` err) `thenSST_`
+ returnSST res
+ where
+ err = addShortErrLocLine loc msg
-rnGetUniques :: Int -> RnMonad x s [Unique]
-rnGetUniques n (RnDown _ _ _ _ _ us_var _)
- = get_uniques n us_var
+warnWithRn :: a -> Message -> RnM s d a
+warnWithRn res msg (RnDown {rn_errs = errs_var, rn_loc = loc}) l_down
+ = readMutVarSST errs_var `thenSST` \ (warns,errs) ->
+ writeMutVarSST errs_var (warns `snocBag` warn, errs) `thenSST_`
+ returnSST res
+ where
+ warn = addShortWarnLocLine loc msg
+addErrRn :: Message -> RnM s d ()
+addErrRn err = failWithRn () err
-get_unique us_var
- = readMutVarSST us_var `thenSST` \ uniq_supply ->
- let
- (new_uniq_supply, uniq_s) = splitUniqSupply uniq_supply
- uniq = getUnique uniq_s
- in
- writeMutVarSST us_var new_uniq_supply `thenSST_`
- returnSST uniq
+checkRn :: Bool -> Message -> RnM s d () -- Check that a condition is true
+checkRn False err = addErrRn err
+checkRn True err = returnRn ()
-get_uniques n us_var
- = readMutVarSST us_var `thenSST` \ uniq_supply ->
- let
- (new_uniq_supply, uniq_s) = splitUniqSupply uniq_supply
- uniqs = getUniques n uniq_s
- in
- writeMutVarSST us_var new_uniq_supply `thenSST_`
- returnSST uniqs
+warnCheckRn :: Bool -> Message -> RnM s d () -- Check that a condition is true
+warnCheckRn False err = addWarnRn err
+warnCheckRn True err = returnRn ()
-snoc_bag_var add bag_var
- = readMutVarSST bag_var `thenSST` \ bag ->
- writeMutVarSST bag_var (bag `snocBag` add)
+addWarnRn :: Message -> RnM s d ()
+addWarnRn warn = warnWithRn () warn
+checkErrsRn :: RnM s d Bool -- True <=> no errors so far
+checkErrsRn (RnDown {rn_errs = errs_var}) l_down
+ = readMutVarSST errs_var `thenSST` \ (warns,errs) ->
+ returnSST (isEmptyBag errs)
\end{code}
-*********************************************************
-* *
-\subsection{Making new names}
-* *
-*********************************************************
-@newLocalNames@ takes a bunch of RdrNames, which are defined together
-in a group (eg a pattern or set of bindings), checks they are
-unqualified and distinct, and creates new Names for them.
+================ Source location =====================
\begin{code}
-newLocalNames :: String -- Documentation string
- -> [(RdrName, SrcLoc)]
- -> RnMonad x s [RnName]
-
-newLocalNames str names_w_loc
- = mapRn (addErrRn . qualNameErr str) quals `thenRn_`
- mapRn (addErrRn . dupNamesErr str) dups `thenRn_`
- mkLocalNames these
- where
- quals = filter (isQual.fst) names_w_loc
- (these, dups) = removeDups cmp_fst names_w_loc
- cmp_fst (a,_) (b,_) = cmp a b
-\end{code}
+pushSrcLocRn :: SrcLoc -> RnM s d a -> RnM s d a
+pushSrcLocRn loc' m down l_down
+ = m (down {rn_loc = loc'}) l_down
-\begin{code}
-mkLocalNames :: [(RdrName, SrcLoc)] -> RnMonad x s [RnName]
-mkLocalNames names_w_locs
- = rnGetUniques (length names_w_locs) `thenRn` \ uniqs ->
- returnRn (zipWithEqual "mkLocalNames" new_local uniqs names_w_locs)
- where
- new_local uniq (Unqual str, srcloc)
- = mkRnName (mkLocalName uniq str False{-emph names-} srcloc)
+getSrcLocRn :: RnM s d SrcLoc
+getSrcLocRn down l_down
+ = returnSST (rn_loc down)
\end{code}
-
-*********************************************************
-* *
-\subsection{Looking up values}
-* *
-*********************************************************
-
-Action to look up a value depends on the RnMode.
-\begin{description}
-\item[RnSource:]
-Lookup value in RnEnv, recording occurrence for non-local values found.
-If not found report error and return Unbound name.
-\item[RnIface:]
-Lookup value in RnEnv. If not found lookup in implicit name env.
-If not found create new implicit name, adding it to the implicit env.
-\end{description}
+================ Name supply =====================
\begin{code}
-lookupValue :: RdrName -> RnMonad x s RnName
-lookupConstr :: RdrName -> RnMonad x s RnName
-lookupField :: RdrName -> RnMonad x s RnName
-lookupClassOp :: RnName -> RdrName -> RnMonad x s RnName
-
-lookupValue rdr
- = lookup_val rdr lookupRnEnv (\ rn -> True) (unknownNameErr "value")
+getNameSupplyRn :: RnM s d RnNameSupply
+getNameSupplyRn rn_down l_down
+ = readMutVarSST (rn_ns rn_down)
+
+setNameSupplyRn :: RnNameSupply -> RnM s d ()
+setNameSupplyRn names' (RnDown {rn_ns = names_var}) l_down
+ = writeMutVarSST names_var names'
+
+-- See comments with RnNameSupply above.
+newInstUniq :: (OccName, OccName) -> RnM s d Int
+newInstUniq key (RnDown {rn_ns = names_var}) l_down
+ = readMutVarSST names_var `thenSST` \ (us, mapInst, cache) ->
+ let
+ uniq = case lookupFM mapInst key of
+ Just x -> x+1
+ Nothing -> 0
+ mapInst' = addToFM mapInst key uniq
+ in
+ writeMutVarSST names_var (us, mapInst', cache) `thenSST_`
+ returnSST uniq
-lookupConstr rdr
- = lookup_val rdr lookupGlobalRnEnv isRnConstr (unknownNameErr "constructor")
+getUniqRn :: RnM s d Unique
+getUniqRn (RnDown {rn_ns = names_var}) l_down
+ = readMutVarSST names_var `thenSST` \ (us, mapInst, cache) ->
+ let
+ (us1,us') = splitUniqSupply us
+ in
+ writeMutVarSST names_var (us', mapInst, cache) `thenSST_`
+ returnSST (uniqFromSupply us1)
+\end{code}
-lookupField rdr
- = lookup_val rdr lookupGlobalRnEnv isRnField (unknownNameErr "field")
+================ Occurrences =====================
-lookupClassOp cls rdr
- = lookup_val rdr lookupGlobalRnEnv (\ rn -> isRnClassOp cls rn) (badClassOpErr cls)
+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
--- Note: the lookup checks are only performed when renaming source
+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.
-lookup_val rdr lookup check do_err down@(RnDown _ _ locn (RnSource occ_var) env _ _)
- = case lookup env rdr of
- Just name | check name -> succ name
- | otherwise -> fail
- Nothing -> fail
+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.
- where
- succ name = if isRnLocal name || isRnWired name then
- returnSST name
- else
- snoc_bag_var (name,rdr) occ_var `thenSST_`
- returnSST name
- fail = failButContinueRn (mkRnUnbound rdr) (do_err rdr locn) down
-
-lookup_val rdr lookup check do_err down@(RnDown _ _ locn (RnIface b_names b_key imp_var) env us_var _)
- = case lookup env rdr of
- Just name -> returnSST name
- Nothing -> lookup_nonexisting_val b_names b_key imp_var us_var rdr
-
-lookup_nonexisting_val (b_names,_) b_key imp_var us_var rdr
- = case rdr of
- Qual _ _ -> -- builtin things *don't* have Qual names
- lookup_or_create_implicit_val b_key imp_var us_var rdr
-
- Unqual n -> case (lookupFM b_names n) of
- Nothing -> lookup_or_create_implicit_val b_key imp_var us_var rdr
- Just xx -> returnSST xx
-
-lookup_or_create_implicit_val b_key imp_var us_var rdr
- = readMutVarSST imp_var `thenSST` \ (implicit_val_fm, implicit_tc_fm) ->
- case lookupFM implicit_val_fm rdr of
- Just implicit -> returnSST implicit
- Nothing ->
- (case rdr of
- Qual _ _ -> get_unique us_var
- Unqual n -> case (lookupFM b_key n) of
- Just (u,_) -> returnSST u
- _ -> get_unique us_var
- ) `thenSST` \ uniq ->
- let
- implicit = mkRnImplicit (mkImplicitName uniq rdr)
- new_val_fm = addToFM implicit_val_fm rdr implicit
- in
- writeMutVarSST imp_var (new_val_fm, implicit_tc_fm) `thenSST_`
- returnSST implicit
-\end{code}
+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}
-lookupTyCon :: RdrName -> RnMonad x s RnName
-lookupClass :: RdrName -> RnMonad x s RnName
-
-lookupTyCon rdr
- = lookup_tc rdr isRnTyCon mkRnImplicitTyCon "type constructor"
+addOccurrenceName :: Name -> RnMS s Name -- Same name returned as passed
+addOccurrenceName name (RnDown {rn_loc = loc, rn_occs = occs_var})
+ (SDown {rn_mode = mode})
+ | isLocallyDefinedName name ||
+ not_necessary necessity
+ = returnSST name
+
+ | otherwise
+ = 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
+ necessity = modeToNecessity mode
-lookupClass rdr
- = lookup_tc rdr isRnClass mkRnImplicitClass "class"
-lookupTyConOrClass rdr
- = lookup_tc rdr isRnTyConOrClass
- (panic "lookupTC:mk_implicit") "class or type constructor"
+addOccurrenceNames :: [Name] -> RnMS s ()
+addOccurrenceNames names (RnDown {rn_loc = loc, rn_occs = occs_var})
+ (SDown {rn_mode = mode})
+ | not_necessary necessity
+ = returnSST ()
-lookup_tc rdr check mk_implicit err_str down@(RnDown _ _ locn (RnSource occ_var) env _ _)
- = case lookupTcRnEnv env rdr of
- Just name | check name -> succ name
- | otherwise -> fail
- Nothing -> fail
- where
- succ name = snoc_bag_var (name,rdr) occ_var `thenSST_`
- returnSST name
- fail = failButContinueRn (mkRnUnbound rdr) (unknownNameErr err_str rdr locn) down
-
-lookup_tc rdr check mk_implicit err_str down@(RnDown _ _ locn (RnIface b_names b_key imp_var) env us_var _)
- = case lookupTcRnEnv env rdr of
- Just name | check name -> returnSST name
- | otherwise -> fail
- Nothing -> lookup_nonexisting_tc check mk_implicit fail b_names b_key imp_var us_var rdr
+ | 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
- fail = failButContinueRn (mkRnUnbound rdr) (unknownNameErr err_str rdr locn) down
-
-lookup_nonexisting_tc check mk_implicit fail (_,b_names) b_key imp_var us_var rdr
- = case rdr of
- Qual _ _ -> -- builtin things *don't* have Qual names
- lookup_or_create_implicit_tc check mk_implicit fail b_key imp_var us_var rdr
-
- Unqual n -> case (lookupFM b_names n) of
- Nothing -> lookup_or_create_implicit_tc check mk_implicit fail b_key imp_var us_var rdr
- Just xx -> returnSST xx
-
-lookup_or_create_implicit_tc check mk_implicit fail b_key imp_var us_var rdr
- = readMutVarSST imp_var `thenSST` \ (implicit_val_fm, implicit_tc_fm) ->
- case lookupFM implicit_tc_fm rdr of
- Just implicit | check implicit -> returnSST implicit
- | otherwise -> fail
- Nothing ->
- (case rdr of
- Qual _ _ -> get_unique us_var
- Unqual n -> case (lookupFM b_key n) of
- Just (u,_) -> returnSST u
- _ -> get_unique us_var
- ) `thenSST` \ uniq ->
- let
- implicit = mk_implicit (mkImplicitName uniq rdr)
- new_tc_fm = addToFM implicit_tc_fm rdr implicit
- in
- writeMutVarSST imp_var (implicit_val_fm, new_tc_fm) `thenSST_`
- returnSST implicit
+ 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 :: RnMode -> RnM s d (Maybe Occurrence)
+popOccurrenceName mode (RnDown {rn_occs = occs_var}) l_down
+ = readMutVarSST occs_var `thenSST` \ occs ->
+ 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))
+ -> ASSERT2( null comps, ppr comps )
+ writeMutVarSST occs_var (comps, opts) `thenSST_`
+ returnSST (Just opt)
+
+ -- No suitable occurrence
+ other -> returnSST Nothing
+
+-- discardOccurrencesRn does the enclosed thing with a *fresh* occurrences
+-- variable, and discards the list of occurrences thus found. It's useful
+-- when loading instance decls and specialisation signatures, when we want to
+-- know the names of the things in the types, but we don't want to treat them
+-- as occurrences.
+
+discardOccurrencesRn :: RnM s d a -> RnM s d a
+discardOccurrencesRn enclosed_thing rn_down l_down
+ = newMutVarSST ([],[]) `thenSST` \ new_occs_var ->
+ enclosed_thing (rn_down {rn_occs = new_occs_var}) l_down
\end{code}
-@extendSS@ extends the scope; @extendSS2@ also removes the newly bound
-free vars from the result.
+================ Module =====================
\begin{code}
-extendSS :: [RnName] -- Newly bound names
- -> RnMonad x s a
- -> RnMonad x s a
+getModuleRn :: RnM s d Module
+getModuleRn (RnDown {rn_mod = mod_name}) l_down
+ = returnSST mod_name
-extendSS binders m down@(RnDown x mod locn mode env us errs)
- = (mapRn (addErrRn . shadowedNameWarn locn) dups `thenRn_`
- m) (RnDown x mod locn mode new_env us errs)
- where
- (new_env,dups) = extendLocalRnEnv opt_WarnNameShadowing env binders
+setModuleRn :: Module -> RnM s d a -> RnM s d a
+setModuleRn new_mod enclosed_thing rn_down l_down
+ = enclosed_thing (rn_down {rn_mod = new_mod}) l_down
+\end{code}
-extendSS2 :: [RnName] -- Newly bound names
- -> RnMonad x s (a, UniqSet RnName)
- -> RnMonad x s (a, UniqSet RnName)
+\begin{code}
+setOmitQualFn :: (Name -> Bool) -> RnM s d a -> RnM s d a
+setOmitQualFn fn m g_down l_down = m (g_down { rn_omit = fn }) l_down
-extendSS2 binders m
- = extendSS binders m `thenRn` \ (r, fvs) ->
- returnRn (r, fvs `minusUniqSet` (mkUniqSet binders))
+getOmitQualFn :: RnM s d (Name -> Bool)
+getOmitQualFn (RnDown {rn_omit = omit_fn}) l_down
+ = returnSST omit_fn
\end{code}
-The free var set returned by @(extendSS binders m)@ is that returned
-by @m@, {\em minus} binders.
-
+%************************************************************************
+%* *
+\subsection{Plumbing for rename-source part}
+%* *
+%************************************************************************
-*********************************************************
-* *
-\subsection{TyVarNamesEnv}
-* *
-*********************************************************
+================ RnEnv =====================
\begin{code}
-type TyVarNamesEnv = [(RdrName, RnName)]
+getNameEnvs :: RnMS s (GlobalRdrEnv, LocalRdrEnv)
+getNameEnvs rn_down (SDown {rn_genv = RnEnv global_env fixity_env, rn_lenv = local_env})
+ = returnSST (global_env, local_env)
+
+getLocalNameEnv :: RnMS s LocalRdrEnv
+getLocalNameEnv rn_down (SDown {rn_lenv = local_env})
+ = returnSST local_env
+
+setLocalNameEnv :: LocalRdrEnv -> RnMS s a -> RnMS s a
+setLocalNameEnv local_env' m rn_down l_down
+ = m rn_down (l_down {rn_lenv = local_env'})
+
+getFixityEnv :: RnMS s FixityEnv
+getFixityEnv rn_down (SDown {rn_genv = RnEnv name_env fixity_env})
+ = returnSST fixity_env
+
+extendFixityEnv :: [(Name, RenamedFixitySig)] -> RnMS s a -> RnMS s a
+extendFixityEnv fixes enclosed_scope
+ rn_down l_down@(SDown {rn_genv = RnEnv name_env fixity_env})
+ = let
+ new_fixity_env = extendNameEnv fixity_env fixes
+ in
+ enclosed_scope rn_down (l_down {rn_genv = RnEnv name_env new_fixity_env})
+\end{code}
-nullTyVarNamesEnv :: TyVarNamesEnv
-nullTyVarNamesEnv = []
+================ Mode =====================
-catTyVarNamesEnvs :: TyVarNamesEnv -> TyVarNamesEnv -> TyVarNamesEnv
-catTyVarNamesEnvs e1 e2 = e1 ++ e2
+\begin{code}
+getModeRn :: RnMS s RnMode
+getModeRn rn_down (SDown {rn_mode = mode})
+ = returnSST mode
-domTyVarNamesEnv :: TyVarNamesEnv -> [RdrName]
-domTyVarNamesEnv env = map fst env
+setModeRn :: RnMode -> RnMS s a -> RnMS s a
+setModeRn new_mode thing_inside rn_down l_down
+ = thing_inside rn_down (l_down {rn_mode = new_mode})
\end{code}
-@mkTyVarNamesEnv@ checks for duplicates, and complains if so.
-\begin{code}
-mkTyVarNamesEnv
- :: SrcLoc
- -> [RdrName] -- The type variables
- -> RnMonad x s (TyVarNamesEnv,[RnName]) -- Environment and renamed tyvars
-
-mkTyVarNamesEnv src_loc tyvars
- = newLocalNames "type variable"
- (tyvars `zip` repeat src_loc) `thenRn` \ rn_tyvars ->
-
- -- rn_tyvars may not be in the same order as tyvars, so we need some
- -- jiggery pokery to build the right tyvar env, and return the
- -- renamed tyvars in the original order.
- let tv_occ_name_pairs = map tv_occ_name_pair rn_tyvars
- tv_env = map (lookup_occ_name tv_occ_name_pairs) tyvars
- rn_tyvars_in_orig_order = map snd tv_env
- in
- returnRn (tv_env, rn_tyvars_in_orig_order)
- where
- tv_occ_name_pair :: RnName -> (RdrName, RnName)
- tv_occ_name_pair rn_name = (getOccName rn_name, rn_name)
+%************************************************************************
+%* *
+\subsection{Plumbing for rename-globals part}
+%* *
+%************************************************************************
- lookup_occ_name :: [(RdrName, RnName)] -> RdrName -> (RdrName, RnName)
- lookup_occ_name pairs tyvar_occ
- = (tyvar_occ, assoc "mkTyVarNamesEnv" pairs tyvar_occ)
+\begin{code}
+getIfacesRn :: RnMG Ifaces
+getIfacesRn rn_down (GDown {rn_ifaces = iface_var})
+ = readMutVarSST iface_var
+
+setIfacesRn :: Ifaces -> RnMG ()
+setIfacesRn ifaces rn_down (GDown {rn_ifaces = iface_var})
+ = writeMutVarSST iface_var ifaces
+
+getModuleHiMap :: Bool -> RnM s d ModuleHiMap
+getModuleHiMap want_hi_boot (RnDown {rn_hi_map = himap, rn_hiboot_map = hibmap}) _
+ | want_hi_boot = returnSST hibmap
+ | otherwise = returnSST himap
\end{code}
+The interface file format is capable of distinguishing
+between normal imports/exports of names from other modules
+and 'hi-boot' mentions of names, with the flavour in the
+being encoded inside a @Module@.
+
+@setModuleFlavourRn@ fixes up @Module@ values containing
+normal flavours, returning a @Module@ value containing
+the attributes of the module that's in scope. The only
+attribute at the moment is the DLLness of a module, i.e.,
+whether the object code for that module resides in a
+Win32 DLL or not.
+
\begin{code}
-lookupTyVarName :: TyVarNamesEnv -> RdrName -> RnMonad x s RnName
-lookupTyVarName env occ
- = case (assocMaybe env occ) of
- Just name -> returnRn name
- Nothing -> getSrcLocRn `thenRn` \ loc ->
- failButContinueRn (mkRnUnbound occ)
- (unknownNameErr "type variable" occ loc)
+setModuleFlavourRn :: Module -> RnM s d Module
+setModuleFlavourRn mod
+ | bootFlavour hif = returnRn mod
+ | otherwise =
+ getModuleHiMap (bootFlavour hif) `thenRn` \ himap ->
+ case (lookupFM himap mod_pstr) of
+ Nothing -> returnRn mod
+ Just (_, is_in_a_dll) ->
+ returnRn (setModuleFlavour (mkDynFlavour is_in_a_dll hif) mod)
+ where
+ mod_pstr = moduleString mod
+ hif = moduleIfaceFlavour mod
+
\end{code}
+%************************************************************************
+%* *
+\subsection{HowInScope}
+%* *
+%************************************************************************
\begin{code}
-fixIO :: (a -> IO a) -> IO a
-fixIO k s = let
- result = k loop s
- (Right loop, _) = result
- in
- result
+modeToNecessity SourceMode = Compulsory
+modeToNecessity (InterfaceMode necessity) = necessity
\end{code}