%
-% (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 RdrName, -- Re-exports
+ module Name, -- from these two
+
+ Module,
+ FiniteMap,
+ Bag,
+ 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,
+#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 405
+import IOExts ( fixIO )
+#elif defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 302
+import PrelIOBase ( fixIO ) -- Should be in GlaExts
+#else
+import IOBase ( fixIO )
+#endif
+import IOExts ( IORef, newIORef, readIORef, writeIORef, unsafePerformIO )
+
+import HsSyn
+import RdrHsSyn
+import RnHsSyn ( RenamedFixitySig )
+import BasicTypes ( Version, defaultFixity )
+import ErrUtils ( addShortErrLocLine, addShortWarnLocLine,
+ pprBagOfErrors, ErrMsg, WarnMsg, Message
+ )
+import RdrName ( RdrName, dummyRdrVarName, rdrNameModule, rdrNameOcc,
+ RdrNameEnv, emptyRdrEnv, extendRdrEnv,
+ lookupRdrEnv, addListToRdrEnv, rdrEnvToList, rdrEnvElts
+ )
+import Name ( Name, OccName, NamedThing(..), getSrcLoc,
+ isLocallyDefinedName, nameModule, nameOccName,
+ decode, mkLocalName, mkKnownKeyGlobal,
+ NameEnv, lookupNameEnv, emptyNameEnv, unitNameEnv,
+ extendNameEnvList
+ )
+import Module ( Module, ModuleName, WhereFrom, moduleName )
+import NameSet
+import CmdLineOpts ( DynFlags, DynFlag(..), dopt )
+import SrcLoc ( SrcLoc, generatedSrcLoc )
+import Unique ( Unique )
+import FiniteMap ( FiniteMap, emptyFM, listToFM, plusFM )
+import Bag ( Bag, mapBag, emptyBag, isEmptyBag, snocBag )
+import UniqSupply
+import Outputable
+import Finder ( Finder )
+import PrelNames ( mkUnboundName )
+import HscTypes ( GlobalSymbolTable, AvailEnv,
+ OrigNameEnv(..), OrigNameNameEnv, OrigNameIParamEnv,
+ WhetherHasOrphans, ImportVersion, ExportItem,
+ PersistentRenamerState(..), IsBootInterface, Avails,
+ DeclsMap, IfaceInsts, IfaceRules, DeprecationEnv,
+ HomeSymbolTable, PackageSymbolTable,
+ PersistentCompilerState(..), GlobalRdrEnv,
+ HomeIfaceTable, PackageIfaceTable )
- 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}
+ioToRnM :: IO r -> RnM d (Either IOError r)
+ioToRnM io rn_down g_down = (io >>= \ ok -> return (Right ok))
+ `catch`
+ (\ err -> return (Left err))
+
+traceRn :: SDoc -> RnM d ()
+traceRn msg
+ = doptRn Opt_D_dump_rn_trace `thenRn` \b ->
+ if b then putDocRn msg else returnRn ()
+
+putDocRn :: SDoc -> RnM d ()
+putDocRn msg = ioToRnM (printErrs msg) `thenRn_`
+ returnRn ()
+\end{code}
-import Ubiq{-uitous-}
-
-import SST
-
-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, negateNameWarn )
-
-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
-infixr 9 `thenRn`, `thenRn_`
+%************************************************************************
+%* *
+\subsection{Data types}
+%* *
+%************************************************************************
+
+%===================================================
+\subsubsection{ MONAD TYPES}
+%===================================================
+
+\begin{code}
+type RnM d r = RnDown -> d -> IO r
+type RnMS r = RnM SDown r -- Renaming source
+type RnMG r = RnM () r -- Getting global names etc
+
+ -- Common part
+data RnDown
+ = RnDown {
+ rn_mod :: Module, -- This module
+ rn_loc :: SrcLoc, -- Current locn
+
+ rn_finder :: Finder,
+ rn_dflags :: DynFlags,
+ rn_hit :: HomeIfaceTable,
+ rn_done :: Name -> Bool, -- available before compiling this module?
+
+ rn_errs :: IORef (Bag WarnMsg, Bag ErrMsg),
+
+ -- The second and third components are a flattened-out OrigNameEnv
+ rn_ns :: IORef (UniqSupply, OrigNameNameEnv, OrigNameIParamEnv),
+ rn_ifaces :: IORef Ifaces
+ }
+
+ -- For renaming source code
+data SDown = SDown {
+ rn_mode :: RnMode,
+
+ rn_genv :: GlobalRdrEnv, -- Global envt
+
+ rn_lenv :: LocalRdrEnv, -- Local name envt
+ -- Does *not* include 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
+
+ rn_fixenv :: LocalFixityEnv -- Local fixities
+ -- The global fixities are held in the
+ -- rn_ifaces field. Why? See the comments
+ -- with RnIfaces.lookupLocalFixity
+ }
+
+data RnMode = SourceMode -- Renaming source code
+ | InterfaceMode -- Renaming interface declarations.
\end{code}
+%===================================================
+\subsubsection{ ENVIRONMENTS}
+%===================================================
+
\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 LocalRdrEnv = RdrNameEnv Name
+type LocalFixityEnv = NameEnv RenamedFixitySig
+ -- We keep the whole fixity sig so that we
+ -- can report line-number info when there is a duplicate
+ -- fixity declaration
+
+lookupLocalFixity :: LocalFixityEnv -> Name -> Fixity
+lookupLocalFixity env name
+ = case lookupNameEnv env name of
+ Just (FixitySig _ fix _) -> fix
+ Nothing -> defaultFixity
+\end{code}
+
+\begin{code}
+type ExportAvails = (FiniteMap ModuleName Avails,
+ -- Used to figure out "module M" export specifiers
+ -- Includes avails only from *unqualified* imports
+ -- (see 1.4 Report Section 5.1.1)
- -- grab errors and return
- readMutVarSST errs_var `thenSST` \ (warns,errs) ->
- returnSST (res, errs, warns)
+ AvailEnv) -- Used to figure out all other export specifiers.
+\end{code}
+
+%===================================================
+\subsubsection{ INTERFACE FILE STUFF}
+%===================================================
+
+\begin{code}
+
+data ParsedIface
+ = ParsedIface {
+ pi_mod :: Module, -- Complete with package info
+ pi_vers :: Version, -- Module version number
+ pi_orphan :: WhetherHasOrphans, -- Whether this module has orphans
+ pi_usages :: [ImportVersion OccName], -- Usages
+ pi_exports :: [ExportItem], -- Exports
+ pi_insts :: [RdrNameInstDecl], -- Local instance declarations
+ pi_decls :: [(Version, RdrNameHsDecl)], -- Local definitions
+ pi_fixity :: (Version, [RdrNameFixitySig]), -- Local fixity declarations,
+ -- with their version
+ pi_rules :: (Version, [RdrNameRuleDecl]), -- Rules, with their version
+ pi_deprecs :: [RdrNameDeprecation] -- Deprecations
+ }
+\end{code}
+
+%************************************************************************
+%* *
+\subsection{The renamer state}
+%* *
+%************************************************************************
+
+\begin{code}
+data Ifaces = Ifaces {
+ -- PERSISTENT FIELDS
+ iPIT :: PackageIfaceTable,
+ -- The ModuleIFaces for modules in other packages
+ -- whose interfaces we have opened
+ -- The declarations in these interface files are held in
+ -- iDecls, iInsts, iRules (below), not in the mi_decls fields
+ -- of the iPIT. What _is_ in the iPIT is:
+ -- * The Module
+ -- * Version info
+ -- * Its exports
+ -- * Fixities
+ -- * Deprecations
+ -- The iPIT field is initialised from the compiler's persistent
+ -- package symbol table, and the renamer incrementally adds
+ -- to it.
+
+ iDecls :: DeclsMap,
+ -- A single, global map of Names to unslurped decls
+
+ iInsts :: IfaceInsts,
+ -- 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.
+ -- Each is 'gated' by the names that must be available before
+ -- this instance decl is needed.
+
+ iRules :: IfaceRules,
+ -- Similar to instance decls, only for rules
+
+ -- EPHEMERAL FIELDS
+ -- These fields persist during the compilation of a single module only
+ iImpModInfo :: ImportedModuleInfo,
+ -- Modules this one depends on: that is, the union
+ -- of the modules its *direct* imports depend on.
+ -- NB: The direct imports have .hi files that enumerate *all* the
+ -- dependencies (direct or not) of the imported module.
+
+ 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.
+ }
+
+type ImportedModuleInfo = FiniteMap ModuleName
+ (WhetherHasOrphans, IsBootInterface, IsLoaded)
+type IsLoaded = Bool
+\end{code}
+
+
+%************************************************************************
+%* *
+\subsection{Main monad code}
+%* *
+%************************************************************************
+
+\begin{code}
+initRn :: DynFlags
+ -> Finder
+ -> HomeIfaceTable
+ -> PersistentCompilerState
+ -> Module
+ -> SrcLoc
+ -> RnMG t
+ -> IO (t, PersistentCompilerState, (Bag WarnMsg, Bag ErrMsg))
+
+initRn dflags finder hit pcs mod loc do_rn
+ = do
+ let prs = pcs_PRS pcs
+ uniqs <- mkSplitUniqSupply 'r'
+ names_var <- newIORef (uniqs, origNames (prsOrig prs),
+ origIParam (prsOrig prs))
+ errs_var <- newIORef (emptyBag,emptyBag)
+ iface_var <- newIORef (initIfaces pcs)
+ let rn_down = RnDown { rn_mod = mod,
+ rn_loc = loc,
+
+ rn_finder = finder,
+ rn_dflags = dflags,
+ rn_hit = hit,
+
+ rn_ns = names_var,
+ rn_errs = errs_var,
+ rn_ifaces = iface_var,
+ }
+
+ -- do the business
+ res <- do_rn rn_down ()
+
+ -- Grab state and record it
+ (warns, errs) <- readIORef errs_var
+ new_ifaces <- readIORef iface_var
+ (_, new_origN, new_origIP) <- readIORef names_var
+ let new_orig = Orig { origNames = new_origN, origIParam = new_origIP }
+ let new_prs = prs { prsOrig = new_orig,
+ prsDecls = iDecls new_ifaces,
+ prsInsts = iInsts new_ifaces,
+ prsRules = iRules new_ifaces }
+ let new_pcs = pcs { pcs_PST = iPST new_ifaces,
+ pcs_PRS = new_prs }
+
+ return (res, new_pcs, (warns, errs))
+
+
+initIfaces :: PersistentCompilerState -> Ifaces
+initIfaces (PCS { pcs_PST = pst, pcs_PRS = prs })
+ = Ifaces { iPST = pst,
+ iDecls = prsDecls prs,
+ iInsts = prsInsts prs,
+ iRules = prsRules prs,
+
+ iImpModInfo = emptyFM,
+ iSlurp = unitNameSet (mkUnboundName dummyRdrVarName),
+ -- Pretend that the dummy unbound name has already been
+ -- slurped. This is what's returned for an out-of-scope name,
+ -- and we don't want thereby to try to suck it in!
+ iVSlurp = []
+ }
+
+
+initRnMS :: GlobalRdrEnv -> LocalFixityEnv -> RnMode -> RnMS r -> RnM d r
+initRnMS rn_env fixity_env mode thing_inside rn_down g_down
+ = let
+ s_down = SDown { rn_genv = rn_env, rn_lenv = emptyRdrEnv,
+ rn_fixenv = fixity_env, rn_mode = mode }
+ in
+ thing_inside rn_down s_down
+
+initIfaceRnMS :: Module -> RnMS r -> RnM d r
+initIfaceRnMS mod thing_inside
+ = initRnMS emptyRdrEnv emptyNameEnv InterfaceMode $
+ setModuleRn mod thing_inside
+
+\end{code}
+
+@renameSourceCode@ is used to rename stuff ``out-of-line'';
+that is, not as part of the main renamer.
+Sole examples: derived definitions,
+which are only generated in the type checker.
+
+The @NameSupply@ 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 :: DynFlags
+ -> Module
+ -> PersistentRenamerState
+ -> RnMS r
+ -> r
+
+renameSourceCode dflags mod prs m
+ = unsafePerformIO (
+ -- It's not really unsafe! When renaming source code we
+ -- only do any I/O if we need to read in a fixity declaration;
+ -- and that doesn't happen in pragmas etc
+
+ mkSplitUniqSupply 'r' >>= \ new_us ->
+ newIORef (new_us, origNames (prsOrig prs),
+ origIParam (prsOrig prs)) >>= \ names_var ->
+ newIORef (emptyBag,emptyBag) >>= \ errs_var ->
+ let
+ rn_down = RnDown { rn_dflags = dflags,
+ rn_loc = generatedSrcLoc, rn_ns = names_var,
+ rn_errs = errs_var,
+ rn_mod = mod,
+ rn_ifaces = panic "rnameSourceCode: rn_ifaces" -- Not required
+ }
+ s_down = SDown { rn_mode = InterfaceMode,
+ -- So that we can refer to PrelBase.True etc
+ rn_genv = emptyRdrEnv, rn_lenv = emptyRdrEnv,
+ rn_fixenv = emptyNameEnv }
+ in
+ m rn_down s_down >>= \ result ->
+
+ readIORef errs_var >>= \ (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) $
+
+ return 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 ->
- returnSST (combiner res1 res2)
+returnRn :: a -> RnM d a
+thenRn :: RnM d a -> (a -> RnM d b) -> RnM d b
+thenRn_ :: RnM d a -> RnM d b -> RnM d b
+andRn :: (a -> a -> a) -> RnM d a -> RnM d a -> RnM d a
+mapRn :: (a -> RnM d b) -> [a] -> RnM d [b]
+mapRn_ :: (a -> RnM d b) -> [a] -> RnM d ()
+mapMaybeRn :: (a -> RnM d (Maybe b)) -> [a] -> RnM d [b]
+flatMapRn :: (a -> RnM d [b]) -> [a] -> RnM d [b]
+sequenceRn :: [RnM d a] -> RnM d [a]
+foldlRn :: (b -> a -> RnM d b) -> b -> [a] -> RnM d b
+mapAndUnzipRn :: (a -> RnM d (b,c)) -> [a] -> RnM d ([b],[c])
+fixRn :: (a -> RnM d a) -> RnM d a
+
+returnRn v gdown ldown = return v
+thenRn m k gdown ldown = m gdown ldown >>= \ r -> k r gdown ldown
+thenRn_ m k gdown ldown = m gdown ldown >> k gdown ldown
+fixRn m gdown ldown = fixIO (\r -> m r gdown ldown)
+andRn combiner m1 m2 gdown ldown
+ = m1 gdown ldown >>= \ res1 ->
+ m2 gdown ldown >>= \ res2 ->
+ return (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)
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
-
-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}
-
-\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"
+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)
+
+flatMapRn f [] = returnRn []
+flatMapRn f (x:xs) = f x `thenRn` \ r ->
+ flatMapRn f xs `thenRn` \ rs ->
+ returnRn (r ++ rs)
\end{code}
-\begin{code}
-rnGetUnique :: RnMonad x s Unique
-rnGetUnique (RnDown _ _ _ _ _ us_var _)
- = get_unique us_var
-
-rnGetUniques :: Int -> RnMonad x s [Unique]
-rnGetUniques n (RnDown _ _ _ _ _ us_var _)
- = get_uniques n us_var
-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
-
-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
+%************************************************************************
+%* *
+\subsection{Boring plumbing for common part}
+%* *
+%************************************************************************
-snoc_bag_var add bag_var
- = readMutVarSST bag_var `thenSST` \ bag ->
- writeMutVarSST bag_var (bag `snocBag` add)
-\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.
+%================
+\subsubsection{ Errors and warnings}
+%=====================
\begin{code}
-newLocalNames :: String -- Documentation string
- -> [(RdrName, SrcLoc)]
- -> RnMonad x s [RnName]
-
-newLocalNames str names_w_loc
- = mapRn (addWarnRn . negateNameWarn) negs `thenRn_`
- mapRn (addErrRn . qualNameErr str) quals `thenRn_`
- mapRn (addErrRn . dupNamesErr str) dups `thenRn_`
- mkLocalNames these
+failWithRn :: a -> Message -> RnM d a
+failWithRn res msg (RnDown {rn_errs = errs_var, rn_loc = loc}) l_down
+ = readIORef errs_var >>= \ (warns,errs) ->
+ writeIORef errs_var (warns, errs `snocBag` err) >>
+ return res
where
- negs = filter ((== Unqual SLIT("negate")).fst) names_w_loc
- quals = filter (isQual.fst) names_w_loc
- (these, dups) = removeDups cmp_fst names_w_loc
- cmp_fst (a,_) (b,_) = cmp a b
-\end{code}
+ err = addShortErrLocLine loc msg
-\begin{code}
-mkLocalNames :: [(RdrName, SrcLoc)] -> RnMonad x s [RnName]
-mkLocalNames names_w_locs
- = rnGetUniques (length names_w_locs) `thenRn` \ uniqs ->
- returnRn (zipWithEqual new_local uniqs names_w_locs)
+warnWithRn :: a -> Message -> RnM d a
+warnWithRn res msg (RnDown {rn_errs = errs_var, rn_loc = loc}) l_down
+ = readIORef errs_var >>= \ (warns,errs) ->
+ writeIORef errs_var (warns `snocBag` warn, errs) >>
+ return res
where
- new_local uniq (Unqual str, srcloc)
- = mkRnName (mkLocalName uniq str srcloc)
-\end{code}
+ warn = addShortWarnLocLine loc msg
+addErrRn :: Message -> RnM d ()
+addErrRn err = failWithRn () err
-*********************************************************
-* *
-\subsection{Looking up values}
-* *
-*********************************************************
+checkRn :: Bool -> Message -> RnM d () -- Check that a condition is true
+checkRn False err = addErrRn err
+checkRn True err = returnRn ()
-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}
+warnCheckRn :: Bool -> Message -> RnM d () -- Check that a condition is true
+warnCheckRn False err = addWarnRn err
+warnCheckRn True err = returnRn ()
-\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
+addWarnRn :: Message -> RnM d ()
+addWarnRn warn = warnWithRn () warn
-lookupValue rdr
- = lookup_val rdr lookupRnEnv (\ rn -> True) (unknownNameErr "value")
+checkErrsRn :: RnM d Bool -- True <=> no errors so far
+checkErrsRn (RnDown {rn_errs = errs_var}) l_down
+ = readIORef errs_var >>= \ (warns,errs) ->
+ return (isEmptyBag errs)
-lookupConstr rdr
- = lookup_val rdr lookupGlobalRnEnv isRnConstr (unknownNameErr "constructor")
+doptRn :: DynFlag -> RnM d Bool
+doptRn dflag (RnDown { rn_dflags = dflags}) l_down
+ = return (dopt dflag dflags)
-lookupField rdr
- = lookup_val rdr lookupGlobalRnEnv isRnField (unknownNameErr "field")
+getDOptsRn :: RnM d DynFlags
+getDOptsRn (RnDown { rn_dflags = dflags}) l_down
+ = return dflags
+\end{code}
-lookupClassOp cls rdr
- = lookup_val rdr lookupGlobalRnEnv (\ rn -> isRnClassOp cls rn) (badClassOpErr cls)
--- Note: the lookup checks are only performed when renaming source
+%================
+\subsubsection{Source location}
+%=====================
-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
+\begin{code}
+pushSrcLocRn :: SrcLoc -> RnM d a -> RnM d a
+pushSrcLocRn loc' m down l_down
+ = m (down {rn_loc = loc'}) l_down
- 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
+getSrcLocRn :: RnM d SrcLoc
+getSrcLocRn down l_down
+ = return (rn_loc down)
\end{code}
+%================
+\subsubsection{The finder and home symbol table}
+%=====================
\begin{code}
-lookupTyCon :: RdrName -> RnMonad x s RnName
-lookupClass :: RdrName -> RnMonad x s RnName
-
-lookupTyCon rdr
- = lookup_tc rdr isRnTyCon mkRnImplicitTyCon "type constructor"
-
-lookupClass rdr
- = lookup_tc rdr isRnClass mkRnImplicitClass "class"
+getFinderRn :: RnM d Finder
+getFinderRn down l_down = return (rn_finder down)
-lookupTyConOrClass rdr
- = lookup_tc rdr isRnTyConOrClass
- (panic "lookupTC:mk_implicit") "class or type constructor"
-
-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
- 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
+getHomeIfaceTableRn :: RnM d HomeIfaceTable
+getHomeIfaceTableRn down l_down = return (rn_hit down)
\end{code}
-
-@extendSS@ extends the scope; @extendSS2@ also removes the newly bound
-free vars from the result.
+%================
+\subsubsection{Name supply}
+%=====================
\begin{code}
-extendSS :: [RnName] -- Newly bound names
- -> RnMonad x s a
- -> RnMonad x s a
+getNameSupplyRn :: RnM d (UniqSupply, OrigNameNameEnv, OrigNameIParamEnv)
+getNameSupplyRn rn_down l_down
+ = readIORef (rn_ns rn_down)
+
+setNameSupplyRn :: (UniqSupply, OrigNameNameEnv, OrigNameIParamEnv) -> RnM d ()
+setNameSupplyRn names' (RnDown {rn_ns = names_var}) l_down
+ = writeIORef names_var names'
+
+getUniqRn :: RnM d Unique
+getUniqRn (RnDown {rn_ns = names_var}) l_down
+ = readIORef names_var >>= \ (us, cache, ipcache) ->
+ let
+ (us1,us') = splitUniqSupply us
+ in
+ writeIORef names_var (us', cache, ipcache) >>
+ return (uniqFromSupply us1)
+\end{code}
-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
+%================
+\subsubsection{ Module}
+%=====================
-extendSS2 :: [RnName] -- Newly bound names
- -> RnMonad x s (a, UniqSet RnName)
- -> RnMonad x s (a, UniqSet RnName)
+\begin{code}
+getModuleRn :: RnM d Module
+getModuleRn (RnDown {rn_mod = mod}) l_down
+ = return mod
-extendSS2 binders m
- = extendSS binders m `thenRn` \ (r, fvs) ->
- returnRn (r, fvs `minusUniqSet` (mkUniqSet binders))
+setModuleRn :: Module -> RnM d a -> RnM d a
+setModuleRn new_mod enclosed_thing rn_down l_down
+ = enclosed_thing (rn_down {rn_mod = new_mod}) l_down
\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}
-* *
-*********************************************************
+%================
+\subsubsection{ RnEnv}
+%=====================
\begin{code}
-type TyVarNamesEnv = [(RdrName, RnName)]
-
-nullTyVarNamesEnv :: TyVarNamesEnv
-nullTyVarNamesEnv = []
-
-catTyVarNamesEnvs :: TyVarNamesEnv -> TyVarNamesEnv -> TyVarNamesEnv
-catTyVarNamesEnvs e1 e2 = e1 ++ e2
-
-domTyVarNamesEnv :: TyVarNamesEnv -> [RdrName]
-domTyVarNamesEnv env = map fst env
+getLocalNameEnv :: RnMS LocalRdrEnv
+getLocalNameEnv rn_down (SDown {rn_lenv = local_env})
+ = return local_env
+
+getGlobalNameEnv :: RnMS GlobalRdrEnv
+getGlobalNameEnv rn_down (SDown {rn_genv = global_env})
+ = return global_env
+
+setLocalNameEnv :: LocalRdrEnv -> RnMS a -> RnMS a
+setLocalNameEnv local_env' m rn_down l_down
+ = m rn_down (l_down {rn_lenv = local_env'})
+
+getFixityEnv :: RnMS LocalFixityEnv
+getFixityEnv rn_down (SDown {rn_fixenv = fixity_env})
+ = return fixity_env
+
+extendFixityEnv :: [(Name, RenamedFixitySig)] -> RnMS a -> RnMS a
+extendFixityEnv fixes enclosed_scope
+ rn_down l_down@(SDown {rn_fixenv = fixity_env})
+ = let
+ new_fixity_env = extendNameEnvList fixity_env fixes
+ in
+ enclosed_scope rn_down (l_down {rn_fixenv = new_fixity_env})
\end{code}
-@mkTyVarNamesEnv@ checks for duplicates, and complains if so.
+%================
+\subsubsection{ Mode}
+%=====================
\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)
+getModeRn :: RnMS RnMode
+getModeRn rn_down (SDown {rn_mode = mode})
+ = return mode
- lookup_occ_name :: [(RdrName, RnName)] -> RdrName -> (RdrName, RnName)
- lookup_occ_name pairs tyvar_occ
- = (tyvar_occ, assoc "mkTyVarNamesEnv" pairs tyvar_occ)
+setModeRn :: RnMode -> RnMS a -> RnMS a
+setModeRn new_mode thing_inside rn_down l_down
+ = thing_inside rn_down (l_down {rn_mode = new_mode})
\end{code}
-\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)
-\end{code}
+%************************************************************************
+%* *
+\subsection{Plumbing for rename-globals part}
+%* *
+%************************************************************************
\begin{code}
-fixIO :: (a -> IO a) -> IO a
-fixIO k s = let
- result = k loop s
- (Right loop, _) = result
- in
- result
+getIfacesRn :: RnM d Ifaces
+getIfacesRn (RnDown {rn_ifaces = iface_var}) _
+ = readIORef iface_var
+
+setIfacesRn :: Ifaces -> RnM d ()
+setIfacesRn ifaces (RnDown {rn_ifaces = iface_var}) _
+ = writeIORef iface_var ifaces
\end{code}