-%
-% (c) The GRASP/AQUA Project, Glasgow University, 1992-1996
-%
-\section[RnMonad]{The monad used by the renamer}
-
-\begin{code}
-#include "HsVersions.h"
-
-module RnMonad (
- RnMonad(..), RnM(..), RnM_Fixes(..), RnDown, SST_R,
- initRn, thenRn, thenRn_, andRn, returnRn,
- mapRn, mapAndUnzipRn, mapAndUnzip3Rn,
-
- addErrRn, addErrIfRn, addWarnRn, addWarnIfRn,
- failButContinueRn, warnAndContinueRn,
- setExtraRn, getExtraRn, getRnEnv,
- getModuleRn, pushSrcLocRn, getSrcLocRn,
- getSourceRn, getOccurrenceUpRn,
- getImplicitUpRn, ImplicitEnv(..), emptyImplicitEnv,
- rnGetUnique, rnGetUniques,
-
- newLocalNames,
- lookupValue, lookupConstr, lookupField, lookupClassOp,
- lookupTyCon, lookupClass, lookupTyConOrClass,
- extendSS2, extendSS,
-
- TyVarNamesEnv(..), mkTyVarNamesEnv, domTyVarNamesEnv,
- lookupTyVarName, nullTyVarNamesEnv, catTyVarNamesEnvs,
-
- fixIO
- ) where
-
-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
- )
-
-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_`
-\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 ->
-
- -- grab errors and return
- readMutVarSST errs_var `thenSST` \ (warns,errs) ->
- returnSST (res, errs, warns)
- )
-
-{-# 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)
-
-mapRn f [] = returnRn []
-mapRn f (x:xs)
- = f x `thenRn` \ r ->
- mapRn f xs `thenRn` \ rs ->
- returnRn (r:rs)
-
-mapAndUnzipRn f [] = returnRn ([],[])
-mapAndUnzipRn f (x:xs)
- = f x `thenRn` \ (r1, r2) ->
- mapAndUnzipRn f xs `thenRn` \ (rs1, rs2) ->
- returnRn (r1:rs1, r2:rs2)
-
-mapAndUnzip3Rn f [] = returnRn ([],[],[])
-mapAndUnzip3Rn f (x:xs)
- = 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"
-\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
-
-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.
-
-\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}
-
-\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)
-\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}
-
-\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")
-
-lookupConstr rdr
- = lookup_val rdr lookupGlobalRnEnv isRnConstr (unknownNameErr "constructor")
-
-lookupField rdr
- = lookup_val rdr lookupGlobalRnEnv isRnField (unknownNameErr "field")
-
-lookupClassOp cls rdr
- = lookup_val rdr lookupGlobalRnEnv (\ rn -> isRnClassOp cls rn) (badClassOpErr cls)
-
--- Note: the lookup checks are only performed when renaming source
-
-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
-
- 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}
-
-
-\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"
-
-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
-\end{code}
-
-
-@extendSS@ extends the scope; @extendSS2@ also removes the newly bound
-free vars from the result.
-
-\begin{code}
-extendSS :: [RnName] -- Newly bound names
- -> RnMonad x s a
- -> RnMonad x s a
-
-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
-
-extendSS2 :: [RnName] -- Newly bound names
- -> RnMonad x s (a, UniqSet RnName)
- -> RnMonad x s (a, UniqSet RnName)
-
-extendSS2 binders m
- = extendSS binders m `thenRn` \ (r, fvs) ->
- returnRn (r, fvs `minusUniqSet` (mkUniqSet binders))
-\end{code}
-
-The free var set returned by @(extendSS binders m)@ is that returned
-by @m@, {\em minus} binders.
-
-
-*********************************************************
-* *
-\subsection{TyVarNamesEnv}
-* *
-*********************************************************
-
-\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
-\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)
-
- lookup_occ_name :: [(RdrName, RnName)] -> RdrName -> (RdrName, RnName)
- lookup_occ_name pairs tyvar_occ
- = (tyvar_occ, assoc "mkTyVarNamesEnv" pairs tyvar_occ)
-\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}
-
-
-\begin{code}
-fixIO :: (a -> IO a) -> IO a
-fixIO k s = let
- result = k loop s
- (Right loop, _) = result
- in
- result
-\end{code}
+%\r
+% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998\r
+%\r
+\section[RnMonad]{The monad used by the renamer}\r
+\r
+\begin{code}\r
+module RnMonad(\r
+ module RnMonad,\r
+ Module,\r
+ FiniteMap,\r
+ Bag,\r
+ Name,\r
+ RdrNameHsDecl,\r
+ RdrNameInstDecl,\r
+ Version,\r
+ NameSet,\r
+ OccName,\r
+ Fixity\r
+ ) where\r
+\r
+#include "HsVersions.h"\r
+\r
+import PrelIOBase ( fixIO ) -- Should be in GlaExts\r
+import IOExts ( IORef, newIORef, readIORef, writeIORef, unsafePerformIO )\r
+ \r
+import HsSyn \r
+import RdrHsSyn\r
+import RnHsSyn ( RenamedFixitySig )\r
+import BasicTypes ( Version )\r
+import SrcLoc ( noSrcLoc )\r
+import ErrUtils ( addShortErrLocLine, addShortWarnLocLine,\r
+ pprBagOfErrors, ErrMsg, WarnMsg, Message\r
+ )\r
+import Name ( Name, OccName, NamedThing(..),\r
+ isLocallyDefinedName, nameModule, nameOccName,\r
+ decode, mkLocalName\r
+ )\r
+import Module ( Module, ModuleName, ModuleHiMap, SearchPath, WhereFrom,\r
+ mkModuleHiMaps, moduleName\r
+ )\r
+import NameSet \r
+import RdrName ( RdrName, dummyRdrVarName, rdrNameOcc )\r
+import CmdLineOpts ( opt_D_dump_rn_trace, opt_IgnoreIfacePragmas )\r
+import PrelInfo ( builtinNames )\r
+import TysWiredIn ( boolTyCon )\r
+import SrcLoc ( SrcLoc, mkGeneratedSrcLoc )\r
+import Unique ( Unique, getUnique, unboundKey )\r
+import UniqFM ( UniqFM )\r
+import FiniteMap ( FiniteMap, emptyFM, bagToFM, lookupFM, addToFM, addListToFM, \r
+ addListToFM_C, addToFM_C, eltsFM, fmToList\r
+ )\r
+import Bag ( Bag, mapBag, emptyBag, isEmptyBag, snocBag )\r
+import Maybes ( mapMaybe )\r
+import UniqSet\r
+import UniqFM\r
+import UniqSupply\r
+import Util\r
+import Outputable\r
+\r
+infixr 9 `thenRn`, `thenRn_`\r
+\end{code}\r
+\r
+\r
+%************************************************************************\r
+%* *\r
+\subsection{Somewhat magical interface to other monads}\r
+%* *\r
+%************************************************************************\r
+\r
+\begin{code}\r
+ioToRnM :: IO r -> RnM d (Either IOError r)\r
+ioToRnM io rn_down g_down = (io >>= \ ok -> return (Right ok)) \r
+ `catch` \r
+ (\ err -> return (Left err))\r
+ \r
+traceRn :: SDoc -> RnM d ()\r
+traceRn msg | opt_D_dump_rn_trace = putDocRn msg\r
+ | otherwise = returnRn ()\r
+\r
+putDocRn :: SDoc -> RnM d ()\r
+putDocRn msg = ioToRnM (printErrs msg) `thenRn_`\r
+ returnRn ()\r
+\end{code}\r
+\r
+\r
+%************************************************************************\r
+%* *\r
+\subsection{Data types}\r
+%* *\r
+%************************************************************************\r
+\r
+===================================================\r
+ MONAD TYPES\r
+===================================================\r
+\r
+\begin{code}\r
+type RnM d r = RnDown -> d -> IO r\r
+type RnMS r = RnM SDown r -- Renaming source\r
+type RnMG r = RnM () r -- Getting global names etc\r
+\r
+ -- Common part\r
+data RnDown = RnDown {\r
+ rn_mod :: ModuleName,\r
+ rn_loc :: SrcLoc,\r
+ rn_ns :: IORef RnNameSupply,\r
+ rn_errs :: IORef (Bag WarnMsg, Bag ErrMsg),\r
+ rn_ifaces :: IORef Ifaces,\r
+ rn_hi_maps :: (ModuleHiMap, -- for .hi files\r
+ ModuleHiMap) -- for .hi-boot files\r
+ }\r
+\r
+ -- For renaming source code\r
+data SDown = SDown {\r
+ rn_mode :: RnMode,\r
+\r
+ rn_genv :: GlobalRdrEnv, -- Global envt; the fixity component gets extended\r
+ -- with local fixity decls\r
+\r
+ rn_lenv :: LocalRdrEnv, -- Local name envt\r
+ -- Does *not* includes global name envt; may shadow it\r
+ -- Includes both ordinary variables and type variables;\r
+ -- they are kept distinct because tyvar have a different\r
+ -- occurrence contructor (Name.TvOcc)\r
+ -- We still need the unsullied global name env so that\r
+ -- we can look up record field names\r
+\r
+ rn_fixenv :: FixityEnv -- Local fixities\r
+ -- The global ones are held in the\r
+ -- rn_ifaces field\r
+ }\r
+\r
+data RnMode = SourceMode -- Renaming source code\r
+ | InterfaceMode -- Renaming interface declarations. \r
+\end{code}\r
+\r
+===================================================\r
+ ENVIRONMENTS\r
+===================================================\r
+\r
+\begin{code}\r
+--------------------------------\r
+type RdrNameEnv a = FiniteMap RdrName a\r
+type GlobalRdrEnv = RdrNameEnv [Name] -- The list is because there may be name clashes\r
+ -- These only get reported on lookup,\r
+ -- not on construction\r
+type LocalRdrEnv = RdrNameEnv Name\r
+\r
+emptyRdrEnv :: RdrNameEnv a\r
+lookupRdrEnv :: RdrNameEnv a -> RdrName -> Maybe a\r
+addListToRdrEnv :: RdrNameEnv a -> [(RdrName,a)] -> RdrNameEnv a\r
+extendRdrEnv :: RdrNameEnv a -> RdrName -> a -> RdrNameEnv a\r
+\r
+emptyRdrEnv = emptyFM\r
+lookupRdrEnv = lookupFM\r
+addListToRdrEnv = addListToFM\r
+rdrEnvElts = eltsFM\r
+extendRdrEnv = addToFM\r
+rdrEnvToList = fmToList\r
+\r
+--------------------------------\r
+type NameEnv a = UniqFM a -- Domain is Name\r
+\r
+emptyNameEnv :: NameEnv a\r
+nameEnvElts :: NameEnv a -> [a]\r
+addToNameEnv_C :: (a->a->a) -> NameEnv a -> Name -> a -> NameEnv a\r
+addToNameEnv :: NameEnv a -> Name -> a -> NameEnv a\r
+plusNameEnv :: NameEnv a -> NameEnv a -> NameEnv a\r
+extendNameEnv :: NameEnv a -> [(Name,a)] -> NameEnv a\r
+lookupNameEnv :: NameEnv a -> Name -> Maybe a\r
+delFromNameEnv :: NameEnv a -> Name -> NameEnv a\r
+elemNameEnv :: Name -> NameEnv a -> Bool\r
+\r
+emptyNameEnv = emptyUFM\r
+nameEnvElts = eltsUFM\r
+addToNameEnv_C = addToUFM_C\r
+addToNameEnv = addToUFM\r
+plusNameEnv = plusUFM\r
+extendNameEnv = addListToUFM\r
+lookupNameEnv = lookupUFM\r
+delFromNameEnv = delFromUFM\r
+elemNameEnv = elemUFM\r
+\r
+--------------------------------\r
+type FixityEnv = NameEnv RenamedFixitySig\r
+ -- We keep the whole fixity sig so that we\r
+ -- can report line-number info when there is a duplicate\r
+ -- fixity declaration\r
+\end{code}\r
+\r
+\begin{code}\r
+--------------------------------\r
+type RnNameSupply\r
+ = ( UniqSupply\r
+\r
+ , FiniteMap (OccName, OccName) Int\r
+ -- This is used as a name supply for dictionary functions\r
+ -- From the inst decl we derive a (class, tycon) pair;\r
+ -- this map then gives a unique int for each inst decl with that\r
+ -- (class, tycon) pair. (In Haskell 98 there can only be one,\r
+ -- but not so in more extended versions.)\r
+ -- \r
+ -- We could just use one Int for all the instance decls, but this\r
+ -- way the uniques change less when you add an instance decl, \r
+ -- hence less recompilation\r
+\r
+ , FiniteMap (ModuleName, OccName) Name\r
+ -- Ensures that one (module,occname) pair gets one unique\r
+ )\r
+\r
+\r
+--------------------------------\r
+data ExportEnv = ExportEnv Avails Fixities\r
+type Avails = [AvailInfo]\r
+type Fixities = [(Name, Fixity)]\r
+\r
+type ExportAvails = (FiniteMap ModuleName Avails, -- Used to figure out "module M" export specifiers\r
+ -- Includes avails only from *unqualified* imports\r
+ -- (see 1.4 Report Section 5.1.1)\r
+\r
+ NameEnv AvailInfo) -- Used to figure out all other export specifiers.\r
+ -- Maps a Name to the AvailInfo that contains it\r
+\r
+\r
+data GenAvailInfo name = Avail name -- An ordinary identifier\r
+ | AvailTC name -- The name of the type or class\r
+ [name] -- The available pieces of type/class. NB: If the type or\r
+ -- class is itself to be in scope, it must be in this list.\r
+ -- Thus, typically: AvailTC Eq [Eq, ==, /=]\r
+type AvailInfo = GenAvailInfo Name\r
+type RdrAvailInfo = GenAvailInfo OccName\r
+\end{code}\r
+\r
+===================================================\r
+ INTERFACE FILE STUFF\r
+===================================================\r
+\r
+\begin{code}\r
+type ExportItem = (ModuleName, [RdrAvailInfo])\r
+type VersionInfo name = [ImportVersion name]\r
+\r
+type ImportVersion name = (ModuleName, Version, WhetherHasOrphans, WhatsImported name)\r
+\r
+type WhetherHasOrphans = Bool\r
+ -- An "orphan" is \r
+ -- * an instance decl in a module other than the defn module for \r
+ -- one of the tycons or classes in the instance head\r
+ -- * a transformation rule in a module other than the one defining\r
+ -- the function in the head of the rule.\r
+\r
+data WhatsImported name = Everything \r
+ | Specifically [LocalVersion name] -- List guaranteed non-empty\r
+\r
+ -- ("M", hif, ver, Everything) means there was a "module M" in \r
+ -- this module's export list, so we just have to go by M's version, "ver",\r
+ -- not the list of LocalVersions.\r
+\r
+\r
+type LocalVersion name = (name, Version)\r
+\r
+data ParsedIface\r
+ = ParsedIface {\r
+ pi_mod :: Version, -- Module version number\r
+ pi_orphan :: WhetherHasOrphans, -- Whether this module has orphans\r
+ pi_usages :: [ImportVersion OccName], -- Usages\r
+ pi_exports :: [ExportItem], -- Exports\r
+ pi_decls :: [(Version, RdrNameHsDecl)], -- Local definitions\r
+ pi_insts :: [RdrNameInstDecl], -- Local instance declarations\r
+ pi_rules :: [RdrNameRuleDecl] -- Rules\r
+ }\r
+\r
+type InterfaceDetails = (WhetherHasOrphans,\r
+ VersionInfo Name, -- Version information for what this module imports\r
+ ExportEnv) -- What modules this one depends on\r
+\r
+\r
+-- needed by Main to fish out the fixities assoc list.\r
+getIfaceFixities :: InterfaceDetails -> Fixities\r
+getIfaceFixities (_, _, ExportEnv _ fs) = fs\r
+\r
+\r
+type RdrNamePragma = () -- Fudge for now\r
+-------------------\r
+\r
+data Ifaces = Ifaces {\r
+ iImpModInfo :: ImportedModuleInfo,\r
+ -- Modules this one depends on: that is, the union \r
+ -- of the modules its direct imports depend on.\r
+\r
+ iDecls :: DeclsMap, -- A single, global map of Names to decls\r
+\r
+ iFixes :: FixityEnv, -- A single, global map of Names to fixities\r
+\r
+ iSlurp :: NameSet, -- All the names (whether "big" or "small", whether wired-in or not,\r
+ -- whether locally defined or not) that have been slurped in so far.\r
+\r
+ iVSlurp :: [(Name,Version)], -- All the (a) non-wired-in (b) "big" (c) non-locally-defined \r
+ -- names that have been slurped in so far, with their versions. \r
+ -- This is used to generate the "usage" information for this module.\r
+ -- Subset of the previous field.\r
+\r
+ iInsts :: Bag GatedDecl,\r
+ -- The as-yet un-slurped instance decls; this bag is depleted when we\r
+ -- slurp an instance decl so that we don't slurp the same one twice.\r
+ -- Each is 'gated' by the names that must be available before\r
+ -- this instance decl is needed.\r
+\r
+ iRules :: Bag GatedDecl\r
+ -- Ditto transformation rules\r
+ }\r
+\r
+type GatedDecl = (NameSet, (Module, RdrNameHsDecl))\r
+\r
+type ImportedModuleInfo \r
+ = FiniteMap ModuleName (Version, Bool, Maybe (Module, Bool, Avails))\r
+ -- Suppose the domain element is module 'A'\r
+ --\r
+ -- The first Bool is True if A contains \r
+ -- 'orphan' rules or instance decls\r
+\r
+ -- The second Bool is true if the interface file actually\r
+ -- read was an .hi-boot file\r
+\r
+ -- Nothing => A's interface not yet read, but this module has\r
+ -- imported a module, B, that itself depends on A\r
+ --\r
+ -- Just xx => A's interface has been read. The Module in \r
+ -- the Just has the correct Dll flag\r
+\r
+ -- This set is used to decide whether to look for\r
+ -- A.hi or A.hi-boot when importing A.f.\r
+ -- Basically, we look for A.hi if A is in the map, and A.hi-boot\r
+ -- otherwise\r
+\r
+type DeclsMap = NameEnv (Version, AvailInfo, Bool, (Module, RdrNameHsDecl))\r
+ -- A DeclsMap contains a binding for each Name in the declaration\r
+ -- including the constructors of a type decl etc.\r
+ -- The Bool is True just for the 'main' Name.\r
+\end{code}\r
+\r
+\r
+%************************************************************************\r
+%* *\r
+\subsection{Main monad code}\r
+%* *\r
+%************************************************************************\r
+\r
+\begin{code}\r
+initRn :: ModuleName -> UniqSupply -> SearchPath -> SrcLoc\r
+ -> RnMG r\r
+ -> IO (r, Bag ErrMsg, Bag WarnMsg)\r
+\r
+initRn mod us dirs loc do_rn = do\r
+ himaps <- mkModuleHiMaps dirs\r
+ names_var <- newIORef (us, emptyFM, builtins)\r
+ errs_var <- newIORef (emptyBag,emptyBag)\r
+ iface_var <- newIORef emptyIfaces \r
+ let\r
+ rn_down = RnDown { rn_loc = loc, rn_ns = names_var, \r
+ rn_errs = errs_var, \r
+ rn_hi_maps = himaps, \r
+ rn_ifaces = iface_var,\r
+ rn_mod = mod }\r
+\r
+ -- do the business\r
+ res <- do_rn rn_down ()\r
+\r
+ -- grab errors and return\r
+ (warns, errs) <- readIORef errs_var\r
+\r
+ return (res, errs, warns)\r
+\r
+\r
+initRnMS :: GlobalRdrEnv -> FixityEnv -> RnMode -> RnMS r -> RnM d r\r
+initRnMS rn_env fixity_env mode thing_inside rn_down g_down\r
+ = let\r
+ s_down = SDown { rn_genv = rn_env, rn_lenv = emptyRdrEnv, \r
+ rn_fixenv = fixity_env, rn_mode = mode }\r
+ in\r
+ thing_inside rn_down s_down\r
+\r
+initIfaceRnMS :: Module -> RnMS r -> RnM d r\r
+initIfaceRnMS mod thing_inside \r
+ = initRnMS emptyRdrEnv emptyNameEnv InterfaceMode $\r
+ setModuleRn (moduleName mod) thing_inside\r
+\r
+emptyIfaces :: Ifaces\r
+emptyIfaces = Ifaces { iImpModInfo = emptyFM,\r
+ iDecls = emptyNameEnv,\r
+ iFixes = emptyNameEnv,\r
+ iSlurp = unitNameSet (mkUnboundName dummyRdrVarName),\r
+ -- Pretend that the dummy unbound name has already been\r
+ -- slurped. This is what's returned for an out-of-scope name,\r
+ -- and we don't want thereby to try to suck it in!\r
+ iVSlurp = [],\r
+ iInsts = emptyBag,\r
+ iRules = emptyBag\r
+ }\r
+\r
+-- mkUnboundName makes a place-holder Name; it shouldn't be looked at except possibly\r
+-- during compiler debugging.\r
+mkUnboundName :: RdrName -> Name\r
+mkUnboundName rdr_name = mkLocalName unboundKey (rdrNameOcc rdr_name) noSrcLoc\r
+\r
+isUnboundName :: Name -> Bool\r
+isUnboundName name = getUnique name == unboundKey\r
+\r
+builtins :: FiniteMap (ModuleName,OccName) Name\r
+builtins = \r
+ bagToFM (\r
+ mapBag (\ name -> ((moduleName (nameModule name), nameOccName name), name))\r
+ builtinNames)\r
+\end{code}\r
+\r
+@renameSourceCode@ is used to rename stuff "out-of-line"; that is, not as part of\r
+the main renamer. Sole examples: derived definitions, which are only generated\r
+in the type checker.\r
+\r
+The @RnNameSupply@ includes a @UniqueSupply@, so if you call it more than\r
+once you must either split it, or install a fresh unique supply.\r
+\r
+\begin{code}\r
+renameSourceCode :: ModuleName\r
+ -> RnNameSupply\r
+ -> RnMS r\r
+ -> r\r
+\r
+renameSourceCode mod_name name_supply m\r
+ = unsafePerformIO (\r
+ -- It's not really unsafe! When renaming source code we\r
+ -- only do any I/O if we need to read in a fixity declaration;\r
+ -- and that doesn't happen in pragmas etc\r
+\r
+ newIORef name_supply >>= \ names_var ->\r
+ newIORef (emptyBag,emptyBag) >>= \ errs_var ->\r
+ let\r
+ rn_down = RnDown { rn_loc = mkGeneratedSrcLoc, rn_ns = names_var,\r
+ rn_errs = errs_var,\r
+ rn_mod = mod_name }\r
+ s_down = SDown { rn_mode = InterfaceMode, -- So that we can refer to PrelBase.True etc\r
+ rn_genv = emptyRdrEnv, rn_lenv = emptyRdrEnv,\r
+ rn_fixenv = emptyNameEnv }\r
+ in\r
+ m rn_down s_down >>= \ result ->\r
+ \r
+ readIORef errs_var >>= \ (warns,errs) ->\r
+\r
+ (if not (isEmptyBag errs) then\r
+ pprTrace "Urk! renameSourceCode found errors" (display errs) \r
+#ifdef DEBUG\r
+ else if not (isEmptyBag warns) then\r
+ pprTrace "Note: renameSourceCode found warnings" (display warns)\r
+#endif\r
+ else\r
+ id) $\r
+\r
+ return result\r
+ )\r
+ where\r
+ display errs = pprBagOfErrors errs\r
+\r
+{-# INLINE thenRn #-}\r
+{-# INLINE thenRn_ #-}\r
+{-# INLINE returnRn #-}\r
+{-# INLINE andRn #-}\r
+\r
+returnRn :: a -> RnM d a\r
+thenRn :: RnM d a -> (a -> RnM d b) -> RnM d b\r
+thenRn_ :: RnM d a -> RnM d b -> RnM d b\r
+andRn :: (a -> a -> a) -> RnM d a -> RnM d a -> RnM d a\r
+mapRn :: (a -> RnM d b) -> [a] -> RnM d [b]\r
+mapRn_ :: (a -> RnM d b) -> [a] -> RnM d ()\r
+mapMaybeRn :: (a -> RnM d (Maybe b)) -> [a] -> RnM d [b]\r
+sequenceRn :: [RnM d a] -> RnM d [a]\r
+foldlRn :: (b -> a -> RnM d b) -> b -> [a] -> RnM d b\r
+mapAndUnzipRn :: (a -> RnM d (b,c)) -> [a] -> RnM d ([b],[c])\r
+fixRn :: (a -> RnM d a) -> RnM d a\r
+\r
+returnRn v gdown ldown = return v\r
+thenRn m k gdown ldown = m gdown ldown >>= \ r -> k r gdown ldown\r
+thenRn_ m k gdown ldown = m gdown ldown >> k gdown ldown\r
+fixRn m gdown ldown = fixIO (\r -> m r gdown ldown)\r
+andRn combiner m1 m2 gdown ldown\r
+ = m1 gdown ldown >>= \ res1 ->\r
+ m2 gdown ldown >>= \ res2 ->\r
+ return (combiner res1 res2)\r
+\r
+sequenceRn [] = returnRn []\r
+sequenceRn (m:ms) = m `thenRn` \ r ->\r
+ sequenceRn ms `thenRn` \ rs ->\r
+ returnRn (r:rs)\r
+\r
+mapRn f [] = returnRn []\r
+mapRn f (x:xs)\r
+ = f x `thenRn` \ r ->\r
+ mapRn f xs `thenRn` \ rs ->\r
+ returnRn (r:rs)\r
+\r
+mapRn_ f [] = returnRn ()\r
+mapRn_ f (x:xs) = \r
+ f x `thenRn_`\r
+ mapRn_ f xs\r
+\r
+foldlRn k z [] = returnRn z\r
+foldlRn k z (x:xs) = k z x `thenRn` \ z' ->\r
+ foldlRn k z' xs\r
+\r
+mapAndUnzipRn f [] = returnRn ([],[])\r
+mapAndUnzipRn f (x:xs)\r
+ = f x `thenRn` \ (r1, r2) ->\r
+ mapAndUnzipRn f xs `thenRn` \ (rs1, rs2) ->\r
+ returnRn (r1:rs1, r2:rs2)\r
+\r
+mapAndUnzip3Rn f [] = returnRn ([],[],[])\r
+mapAndUnzip3Rn f (x:xs)\r
+ = f x `thenRn` \ (r1, r2, r3) ->\r
+ mapAndUnzip3Rn f xs `thenRn` \ (rs1, rs2, rs3) ->\r
+ returnRn (r1:rs1, r2:rs2, r3:rs3)\r
+\r
+mapMaybeRn f [] = returnRn []\r
+mapMaybeRn f (x:xs) = f x `thenRn` \ maybe_r ->\r
+ mapMaybeRn f xs `thenRn` \ rs ->\r
+ case maybe_r of\r
+ Nothing -> returnRn rs\r
+ Just r -> returnRn (r:rs)\r
+\end{code}\r
+\r
+\r
+\r
+%************************************************************************\r
+%* *\r
+\subsection{Boring plumbing for common part}\r
+%* *\r
+%************************************************************************\r
+\r
+\r
+================ Errors and warnings =====================\r
+\r
+\begin{code}\r
+failWithRn :: a -> Message -> RnM d a\r
+failWithRn res msg (RnDown {rn_errs = errs_var, rn_loc = loc}) l_down\r
+ = readIORef errs_var >>= \ (warns,errs) ->\r
+ writeIORef errs_var (warns, errs `snocBag` err) >> \r
+ return res\r
+ where\r
+ err = addShortErrLocLine loc msg\r
+\r
+warnWithRn :: a -> Message -> RnM d a\r
+warnWithRn res msg (RnDown {rn_errs = errs_var, rn_loc = loc}) l_down\r
+ = readIORef errs_var >>= \ (warns,errs) ->\r
+ writeIORef errs_var (warns `snocBag` warn, errs) >> \r
+ return res\r
+ where\r
+ warn = addShortWarnLocLine loc msg\r
+\r
+addErrRn :: Message -> RnM d ()\r
+addErrRn err = failWithRn () err\r
+\r
+checkRn :: Bool -> Message -> RnM d () -- Check that a condition is true\r
+checkRn False err = addErrRn err\r
+checkRn True err = returnRn ()\r
+\r
+warnCheckRn :: Bool -> Message -> RnM d () -- Check that a condition is true\r
+warnCheckRn False err = addWarnRn err\r
+warnCheckRn True err = returnRn ()\r
+\r
+addWarnRn :: Message -> RnM d ()\r
+addWarnRn warn = warnWithRn () warn\r
+\r
+checkErrsRn :: RnM d Bool -- True <=> no errors so far\r
+checkErrsRn (RnDown {rn_errs = errs_var}) l_down\r
+ = readIORef errs_var >>= \ (warns,errs) ->\r
+ return (isEmptyBag errs)\r
+\end{code}\r
+\r
+\r
+================ Source location =====================\r
+\r
+\begin{code}\r
+pushSrcLocRn :: SrcLoc -> RnM d a -> RnM d a\r
+pushSrcLocRn loc' m down l_down\r
+ = m (down {rn_loc = loc'}) l_down\r
+\r
+getSrcLocRn :: RnM d SrcLoc\r
+getSrcLocRn down l_down\r
+ = return (rn_loc down)\r
+\end{code}\r
+\r
+================ Name supply =====================\r
+\r
+\begin{code}\r
+getNameSupplyRn :: RnM d RnNameSupply\r
+getNameSupplyRn rn_down l_down\r
+ = readIORef (rn_ns rn_down)\r
+\r
+setNameSupplyRn :: RnNameSupply -> RnM d ()\r
+setNameSupplyRn names' (RnDown {rn_ns = names_var}) l_down\r
+ = writeIORef names_var names'\r
+\r
+-- See comments with RnNameSupply above.\r
+newInstUniq :: (OccName, OccName) -> RnM d Int\r
+newInstUniq key (RnDown {rn_ns = names_var}) l_down\r
+ = readIORef names_var >>= \ (us, mapInst, cache) ->\r
+ let\r
+ uniq = case lookupFM mapInst key of\r
+ Just x -> x+1\r
+ Nothing -> 0\r
+ mapInst' = addToFM mapInst key uniq\r
+ in\r
+ writeIORef names_var (us, mapInst', cache) >>\r
+ return uniq\r
+\r
+getUniqRn :: RnM d Unique\r
+getUniqRn (RnDown {rn_ns = names_var}) l_down\r
+ = readIORef names_var >>= \ (us, mapInst, cache) ->\r
+ let\r
+ (us1,us') = splitUniqSupply us\r
+ in\r
+ writeIORef names_var (us', mapInst, cache) >>\r
+ return (uniqFromSupply us1)\r
+\end{code}\r
+\r
+================ Module =====================\r
+\r
+\begin{code}\r
+getModuleRn :: RnM d ModuleName\r
+getModuleRn (RnDown {rn_mod = mod_name}) l_down\r
+ = return mod_name\r
+\r
+setModuleRn :: ModuleName -> RnM d a -> RnM d a\r
+setModuleRn new_mod enclosed_thing rn_down l_down\r
+ = enclosed_thing (rn_down {rn_mod = new_mod}) l_down\r
+\end{code}\r
+\r
+\r
+%************************************************************************\r
+%* *\r
+\subsection{Plumbing for rename-source part}\r
+%* *\r
+%************************************************************************\r
+\r
+================ RnEnv =====================\r
+\r
+\begin{code}\r
+getNameEnvs :: RnMS (GlobalRdrEnv, LocalRdrEnv)\r
+getNameEnvs rn_down (SDown {rn_genv = global_env, rn_lenv = local_env})\r
+ = return (global_env, local_env)\r
+\r
+getLocalNameEnv :: RnMS LocalRdrEnv\r
+getLocalNameEnv rn_down (SDown {rn_lenv = local_env})\r
+ = return local_env\r
+\r
+setLocalNameEnv :: LocalRdrEnv -> RnMS a -> RnMS a\r
+setLocalNameEnv local_env' m rn_down l_down\r
+ = m rn_down (l_down {rn_lenv = local_env'})\r
+\r
+getFixityEnv :: RnMS FixityEnv\r
+getFixityEnv rn_down (SDown {rn_fixenv = fixity_env})\r
+ = return fixity_env\r
+\r
+extendFixityEnv :: [(Name, RenamedFixitySig)] -> RnMS a -> RnMS a\r
+extendFixityEnv fixes enclosed_scope\r
+ rn_down l_down@(SDown {rn_fixenv = fixity_env})\r
+ = let\r
+ new_fixity_env = extendNameEnv fixity_env fixes\r
+ in\r
+ enclosed_scope rn_down (l_down {rn_fixenv = new_fixity_env})\r
+\end{code}\r
+\r
+================ Mode =====================\r
+\r
+\begin{code}\r
+getModeRn :: RnMS RnMode\r
+getModeRn rn_down (SDown {rn_mode = mode})\r
+ = return mode\r
+\r
+setModeRn :: RnMode -> RnMS a -> RnMS a\r
+setModeRn new_mode thing_inside rn_down l_down\r
+ = thing_inside rn_down (l_down {rn_mode = new_mode})\r
+\end{code}\r
+\r
+\r
+%************************************************************************\r
+%* *\r
+\subsection{Plumbing for rename-globals part}\r
+%* *\r
+%************************************************************************\r
+\r
+\begin{code}\r
+getIfacesRn :: RnM d Ifaces\r
+getIfacesRn (RnDown {rn_ifaces = iface_var}) _\r
+ = readIORef iface_var\r
+\r
+setIfacesRn :: Ifaces -> RnM d ()\r
+setIfacesRn ifaces (RnDown {rn_ifaces = iface_var}) _\r
+ = writeIORef iface_var ifaces\r
+\r
+getHiMaps :: RnM d (ModuleHiMap, ModuleHiMap)\r
+getHiMaps (RnDown {rn_hi_maps = himaps}) _ \r
+ = return himaps\r
+\end{code}\r
projects / ghc-hetmet.git / blobdiff