%
-% (c) The GRASP/AQUA Project, Glasgow University, 1992-1996
+% (c) The GRASP/AQUA Project, Glasgow University, 1992-1997
%
\section[RnMonad]{The monad used by the renamer}
\begin{code}
#include "HsVersions.h"
-module RnMonad (
- SYN_IE(RnMonad), SYN_IE(RnM), SYN_IE(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, SYN_IE(ImplicitEnv), emptyImplicitEnv,
- rnGetUnique, rnGetUniques,
-
- newLocalNames,
- lookupValue, lookupConstr, lookupField, lookupClassOp,
- lookupTyCon, lookupClass, lookupTyConOrClass,
- extendSS2, extendSS,
-
- SYN_IE(TyVarNamesEnv), mkTyVarNamesEnv, domTyVarNamesEnv,
- lookupTyVarName, nullTyVarNamesEnv, catTyVarNamesEnvs,
-
- fixIO
+module RnMonad(
+ EXP_MODULE(RnMonad),
+ -- close it up (partly done to allow unfoldings)
+ EXP_MODULE(SST),
+ SYN_IE(Module),
+ FiniteMap,
+ Bag,
+ Name,
+ SYN_IE(RdrNameHsDecl),
+ SYN_IE(RdrNameInstDecl),
+ SYN_IE(Version),
+ SYN_IE(NameSet),
+ OccName,
+ Fixity
) where
IMP_Ubiq(){-uitous-}
-IMPORT_1_3(GHCbase(fixIO))
import SST
+import PreludeGlaST ( SYN_IE(ST), thenStrictlyST, returnStrictlyST )
-import HsSyn ( FixityDecl )
-import RnHsSyn ( RnName, mkRnName, mkRnUnbound, mkRnImplicit,
- mkRnImplicitTyCon, mkRnImplicitClass,
- isRnLocal, isRnWired, isRnTyCon, isRnClass,
- isRnTyConOrClass, isRnConstr, isRnField,
- isRnClassOp, RenamedFixityDecl(..) )
-import RnUtils ( SYN_IE(RnEnv), extendLocalRnEnv,
- lookupRnEnv, lookupGlobalRnEnv, lookupTcRnEnv,
- qualNameErr, dupNamesErr
- )
-
-import Bag ( Bag, emptyBag, isEmptyBag, snocBag )
-import CmdLineOpts ( opt_WarnNameShadowing )
+import HsSyn
+import RdrHsSyn
import ErrUtils ( addErrLoc, addShortErrLocLine, addShortWarnLocLine,
- SYN_IE(Error), SYN_IE(Warning)
+ pprBagOfErrors, SYN_IE(Error), SYN_IE(Warning)
)
-import FiniteMap ( FiniteMap, emptyFM, lookupFM, addToFM, fmToList{-ToDo:rm-} )
-import Maybes ( assocMaybe )
-import Name ( SYN_IE(Module), RdrName(..), isQual,
- OrigName(..), Name, mkLocalName, mkImplicitName,
- getOccName, pprNonSym
+import Name ( SYN_IE(Module), Name, OccName, Provenance, SYN_IE(NameSet), emptyNameSet,
+ isLocallyDefinedName,
+ modAndOcc, NamedThing(..)
)
-import PrelInfo ( builtinNameMaps, builtinKeysMap, SYN_IE(BuiltinNames), SYN_IE(BuiltinKeys) )
-import PrelMods ( pRELUDE )
-import PprStyle{-ToDo:rm-}
-import Outputable{-ToDo:rm-}
-import Pretty--ToDo:rm ( SYN_IE(Pretty), PrettyRep )
-import SrcLoc ( SrcLoc, mkUnknownSrcLoc )
-import UniqFM ( UniqFM, emptyUFM )
-import UniqSet ( SYN_IE(UniqSet), mkUniqSet, minusUniqSet )
-import UniqSupply ( UniqSupply, getUnique, getUniques, splitUniqSupply )
+import CmdLineOpts ( opt_D_show_rn_trace, opt_IgnoreIfacePragmas )
+import PrelInfo ( builtinNames )
+import TyCon ( TyCon {- instance NamedThing -} )
+import TysWiredIn ( boolTyCon )
+import Pretty
+import PprStyle ( PprStyle(..) )
+import SrcLoc ( SrcLoc, mkGeneratedSrcLoc )
import Unique ( Unique )
+import FiniteMap ( FiniteMap, emptyFM, bagToFM )
+import Bag ( Bag, mapBag, emptyBag, isEmptyBag, snocBag )
+import UniqSet
import Util
infixr 9 `thenRn`, `thenRn_`
\end{code}
+
+%************************************************************************
+%* *
+\subsection{Somewhat magical interface to other monads}
+%* *
+%************************************************************************
+
\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 OrigName RnName, FiniteMap OrigName 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
#if __GLASGOW_HASKELL__ >= 200
-# define REAL_WORLD GHCbuiltins.RealWorld
+# define REAL_WORLD RealWorld
#else
# define REAL_WORLD _RealWorld
#endif
+\end{code}
-initRn :: Bool -- True => Source; False => Iface
- -> Module
- -> RnEnv
- -> UniqSupply
- -> RnM REAL_WORLD r
- -> (r, Bag Error, Bag Warning)
+\begin{code}
+sstToIO :: SST REAL_WORLD r -> IO r
+sstToIO sst
+ = sstToST sst `thenStrictlyST` \ r ->
+ returnStrictlyST (Right r)
+
+ioToRnMG :: IO r -> RnMG (Either IOError13 r)
+ioToRnMG io rn_down g_down = stToSST io
+
+traceRn :: Pretty -> RnMG ()
+traceRn msg | opt_D_show_rn_trace = ioToRnMG (hPutStr stderr (ppShow 80 msg) >>
+ hPutStr stderr "\n") `thenRn_`
+ returnRn ()
+ | otherwise = returnRn ()
+\end{code}
-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
- RnIface builtinNameMaps builtinKeysMap imp_var
-
- rn_down = RnDown () mod mkUnknownSrcLoc mode env us_var errs_var
- in
+
+%************************************************************************
+%* *
+\subsection{Data types}
+%* *
+%************************************************************************
+
+===================================================
+ MONAD TYPES
+===================================================
+
+\begin{code}
+type RnM s d r = RnDown s -> d -> SST s r
+type RnMS s r = RnM s (SDown s) r -- Renaming source
+type RnMG r = RnM REAL_WORLD GDown r -- Getting global names etc
+type MutVar a = MutableVar REAL_WORLD a -- ToDo: there ought to be a standard defn of this
+
+ -- Common part
+data RnDown s = RnDown
+ SrcLoc
+ (MutableVar s RnNameSupply)
+ (MutableVar s (Bag Warning, Bag Error))
+ (MutableVar s [(Name,Necessity)]) -- Occurrences
+
+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
+ SearchPath
+ (MutVar Ifaces)
+
+ -- For renaming source code
+data SDown s = SDown
+ RnEnv -- Global envt
+ NameEnv -- Local name envt (includes global name envt,
+ -- but may shadow it)
+ Module
+ RnSMode
+
+
+data RnSMode = SourceMode
+ | InterfaceMode
+
+type SearchPath = [String] -- List of directories to seach for interface files
+type FreeVars = NameSet
+\end{code}
+
+===================================================
+ ENVIRONMENTS
+===================================================
+
+\begin{code}
+type RnNameSupply = (UniqSupply, Int, FiniteMap (Module,OccName) Name)
+ -- Ensures that one (m,n) pair gets one unique
+ -- The Int is used to give a number to each instance declaration;
+ -- it's really a separate name supply.
+
+data RnEnv = RnEnv NameEnv FixityEnv
+emptyRnEnv = RnEnv emptyNameEnv emptyFixityEnv
+
+type NameEnv = FiniteMap RdrName Name
+emptyNameEnv = emptyFM
+
+type FixityEnv = FiniteMap RdrName (Fixity, Provenance)
+emptyFixityEnv = emptyFM
+ -- It's possible to have a different fixity for B.op than for op:
+ --
+ -- module A( op ) where module B where
+ -- import qualified B( op ) infixr 2 op
+ -- infixl 9 `op` op = ...
+ -- op a b = a `B.op` b
+
+data ExportEnv = ExportEnv Avails Fixities
+type Avails = [AvailInfo]
+type Fixities = [(OccName, (Fixity, Provenance))]
+ -- Can contain duplicates, if one module defines the same fixity,
+ -- or the same type/class/id, more than once. Hence a boring old list.
+ -- This allows us to report duplicates in just one place, namely plusRnEnv.
+
+type ModuleAvails = FiniteMap Module Avails
+
+data AvailInfo = NotAvailable
+ | Avail Name -- An ordinary identifier
+ | AvailTC Name -- The name of the type or class
+ [Name] -- The available pieces of type/class. NB: If the type or
+ -- class is itself to be in scope, it must be in this list.
+ -- Thus, typically: Avail Eq [Eq, ==, /=]
+\end{code}
+
+===================================================
+ INTERFACE FILE STUFF
+===================================================
+
+\begin{code}
+type ExportItem = (Module, [(OccName, [OccName])])
+type VersionInfo name = [ImportVersion name]
+type ImportVersion name = (Module, Version, [LocalVersion name])
+type LocalVersion name = (name, Version)
+
+data ParsedIface
+ = ParsedIface
+ Module -- Module name
+ Version -- Module version number
+ [ImportVersion OccName] -- Usages
+ [ExportItem] -- Exports
+ [Module] -- Special instance modules
+ [(OccName,Fixity)] -- Fixities
+ [(Version, RdrNameHsDecl)] -- Local definitions
+ [RdrNameInstDecl] -- Local instance declarations
+
+type InterfaceDetails = (VersionInfo Name, -- Version information
+ ExportEnv, -- What this module exports
+ [Module]) -- Instance modules
+
+type RdrNamePragma = () -- Fudge for now
+-------------------
+
+data Ifaces = Ifaces
+ Module -- Name of this module
+ (FiniteMap Module Version)
+ (FiniteMap Module (Avails, [(OccName,Fixity)])) -- Exports
+ DeclsMap
+
+ 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.
+
+ [(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. Subset of
+ -- the previous field. This is used to generate the "usage" information
+ -- for this module.
+
+ (Bag IfaceInst) -- Un-slurped instance decls; this bag is depleted when we
+ -- slurp an instance decl so that we don't slurp the same one twice.
+
+ [Module] -- Set of modules with "special" instance declarations
+ -- Excludes this module
+
+type DeclsMap = FiniteMap Name (Version, AvailInfo, RdrNameHsDecl)
+type IfaceInst = ((Module, RdrNameInstDecl), -- Instance decl
+ [Name]) -- "Gate" names. Slurp this instance decl when this
+ -- list 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 Error, Bag Warning)
+
+initRn mod us dirs loc do_rn
+ = sstToIO $
+ newMutVarSST (us, 1, builtins) `thenSST` \ names_var ->
+ newMutVarSST (emptyBag,emptyBag) `thenSST` \ errs_var ->
+ newMutVarSST (emptyIfaces mod) `thenSST` \ iface_var ->
+ newMutVarSST initOccs `thenSST` \ occs_var ->
+ let
+ rn_down = RnDown loc names_var errs_var occs_var
+ g_down = GDown dirs iface_var
+ in
-- do the buisness
- do_rn rn_down `thenSST` \ res ->
+ do_rn rn_down g_down `thenSST` \ res ->
-- grab errors and return
- readMutVarSST errs_var `thenSST` \ (warns,errs) ->
- returnSST (res, errs, warns)
+ readMutVarSST errs_var `thenSST` \ (warns,errs) ->
+ returnSST (res, errs, warns)
+
+
+initRnMS :: RnEnv -> Module -> RnSMode -> RnMS REAL_WORLD r -> RnMG r
+initRnMS rn_env@(RnEnv name_env _) mod_name mode m rn_down g_down
+ = let
+ s_down = SDown rn_env name_env mod_name mode
+ in
+ m rn_down s_down
+
+
+emptyIfaces :: Module -> Ifaces
+emptyIfaces mod = Ifaces mod emptyFM emptyFM emptyFM emptyNameSet [] emptyBag []
+
+builtins :: FiniteMap (Module,OccName) Name
+builtins = bagToFM (mapBag (\ name -> (modAndOcc name, name)) builtinNames)
+
+ -- Initial value for the occurrence pool.
+initOccs :: [(Name,Necessity)]
+initOccs = [(getName boolTyCon, Compulsory)]
+ -- 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}
+
+\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 REAL_WORLD 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 mkGeneratedSrcLoc names_var errs_var occs_var
+ s_down = SDown emptyRnEnv emptyNameEnv mod_name InterfaceMode
+ in
+ m rn_down s_down `thenSST` \ result ->
+
+ readMutVarSST errs_var `thenSST` \ (warns,errs) ->
+
+ (if not (isEmptyBag errs) then
+ trace ("Urk! renameSourceCode found errors" ++ display errs)
+ else if not (isEmptyBag warns) then
+ trace ("Urk! renameSourceCode found warnings" ++ display warns)
+ else
+ id) $
+
+ returnSST result
)
+ where
+ display errs = ppShow 80 (pprBagOfErrors PprDebug 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]
+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)
+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) ->
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{Boring plumbing for common part}
+%* *
+%************************************************************************
-*********************************************************
-* *
-\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.
+================ Errors and warnings =====================
\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
+failWithRn :: a -> Error -> RnM s d a
+failWithRn res msg (RnDown loc names_var errs_var occs_var) l_down
+ = readMutVarSST errs_var `thenSST` \ (warns,errs) ->
+ writeMutVarSST errs_var (warns, errs `snocBag` err) `thenSST_`
+ returnSST res
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}
+ 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 "mkLocalNames" new_local uniqs names_w_locs)
+warnWithRn :: a -> Warning -> RnM s d a
+warnWithRn res msg (RnDown loc names_var errs_var occs_var) l_down
+ = readMutVarSST errs_var `thenSST` \ (warns,errs) ->
+ writeMutVarSST errs_var (warns `snocBag` warn, errs) `thenSST_`
+ returnSST res
where
- new_local uniq (Unqual str, srcloc)
- = mkRnName (mkLocalName uniq str False{-emph names-} srcloc)
-\end{code}
-
+ warn = addShortWarnLocLine loc msg
-*********************************************************
-* *
-\subsection{Looking up values}
-* *
-*********************************************************
+addErrRn :: Error -> RnM s d ()
+addErrRn err = failWithRn () err
-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
+checkRn :: Bool -> Error -> RnM s d () -- Check that a condition is true
+checkRn False err = addErrRn err
+checkRn True err = returnRn ()
-lookupValue rdr
- = lookup_val rdr lookupRnEnv (\ rn -> True) (unknownNameErr "value")
+addWarnRn :: Warning -> RnM s d ()
+addWarnRn warn = warnWithRn () warn
-lookupConstr rdr
- = lookup_val rdr lookupGlobalRnEnv isRnConstr (unknownNameErr "constructor")
-
-lookupField rdr
- = lookup_val rdr lookupGlobalRnEnv isRnField (unknownNameErr "field")
+checkErrsRn :: RnM s d Bool -- True <=> no errors so far
+checkErrsRn (RnDown loc names_var errs_var occs_var) l_down
+ = readMutVarSST errs_var `thenSST` \ (warns,errs) ->
+ returnSST (isEmptyBag errs)
+\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
+================ 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 s d a -> RnM s d a
+pushSrcLocRn loc' m (RnDown loc names_var errs_var occs_var) l_down
+ = m (RnDown loc' names_var errs_var occs_var) 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 -> case rdr of
- Unqual n -> panic ("lookup_val:"++ _UNPK_ n)
- Qual m n ->
- lookup_nonexisting_val b_names b_key imp_var us_var (OrigName m n)
-
-lookup_nonexisting_val (b_names,_) b_key imp_var us_var orig
- = case (lookupFM b_names orig) of
- Just xx -> returnSST xx
- Nothing -> lookup_or_create_implicit_val b_key imp_var us_var orig
-
-lookup_or_create_implicit_val b_key imp_var us_var orig
- = readMutVarSST imp_var `thenSST` \ (implicit_val_fm, implicit_tc_fm) ->
- case (lookupFM implicit_val_fm orig) of
- Just implicit -> returnSST implicit
- Nothing ->
- (case (lookupFM b_key orig) of
- Just (u,_) -> returnSST u
- _ -> get_unique us_var
- ) `thenSST` \ uniq ->
- let
- implicit = mkRnImplicit (mkImplicitName uniq orig)
- new_val_fm = addToFM implicit_val_fm orig implicit
- in
- writeMutVarSST imp_var (new_val_fm, implicit_tc_fm) `thenSST_`
- returnSST implicit
+getSrcLocRn :: RnM s d SrcLoc
+getSrcLocRn (RnDown loc names_var errs_var occs_var) l_down
+ = returnSST loc
\end{code}
+================ Name supply =====================
\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@(Qual m n) 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 (OrigName m n)
- 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 orig--@(OrigName m n)
- = --pprTrace "lookup:" (ppAboves [case str_mod of {(n,m)->ppCat [ppPStr n, ppPStr m]}, ppAboves [ ppCat [ppPStr n, ppPStr m] | ((n,m), _) <- fmToList b_names]]) $
- case (lookupFM b_names orig) of
- Just xx -> returnSST xx
- Nothing -> lookup_or_create_implicit_tc check mk_implicit fail b_key imp_var us_var orig
-
-lookup_or_create_implicit_tc check mk_implicit fail b_key imp_var us_var orig
- = readMutVarSST imp_var `thenSST` \ (implicit_val_fm, implicit_tc_fm) ->
- case (lookupFM implicit_tc_fm orig) of
- Just implicit | check implicit -> returnSST implicit
- | otherwise -> fail
- Nothing ->
- (case (lookupFM b_key orig) of
- Just (u,_) -> returnSST u
- _ -> get_unique us_var
- ) `thenSST` \ uniq ->
- let
- implicit = mk_implicit (mkImplicitName uniq orig)
- new_tc_fm = addToFM implicit_tc_fm orig implicit
- in
- writeMutVarSST imp_var (implicit_val_fm, new_tc_fm) `thenSST_`
- returnSST implicit
+getNameSupplyRn :: RnM s d RnNameSupply
+getNameSupplyRn (RnDown loc names_var errs_var occs_var) l_down
+ = readMutVarSST names_var
+
+setNameSupplyRn :: RnNameSupply -> RnM s d ()
+setNameSupplyRn names' (RnDown loc names_var errs_var occs_var) l_down
+ = writeMutVarSST names_var names'
+
+-- The "instance-decl unique supply", inst, is just an integer that's used to
+-- give a unique number for each instance declaration.
+newInstUniq :: RnM s d Int
+newInstUniq (RnDown loc names_var errs_var occs_var) l_down
+ = readMutVarSST names_var `thenSST` \ (us, inst, cache) ->
+ writeMutVarSST names_var (us, inst+1, cache) `thenSST_`
+ returnSST inst
\end{code}
-
-@extendSS@ extends the scope; @extendSS2@ also removes the newly bound
-free vars from the result.
+================ Occurrences =====================
\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)
+addOccurrenceName :: Necessity -> Name -> RnM s d Name -- Same name returned as passed
+addOccurrenceName necessity name (RnDown loc names_var errs_var occs_var) l_down
+ | isLocallyDefinedName name ||
+ not_necessary necessity
+ = returnSST name
+
+ | otherwise
+ = readMutVarSST occs_var `thenSST` \ occs ->
+ writeMutVarSST occs_var ((name,necessity) : occs) `thenSST_`
+ returnSST name
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))
+ not_necessary Compulsory = False
+ not_necessary Optional = opt_IgnoreIfacePragmas
+ -- Never look for optional things if we're
+ -- ignoring optional input interface information
+
+addOccurrenceNames :: Necessity -> [Name] -> RnM s d ()
+addOccurrenceNames necessity names (RnDown loc names_var errs_var occs_var) l_down
+ = readMutVarSST occs_var `thenSST` \ occs ->
+ writeMutVarSST occs_var ([(name,necessity) | name <- names, not (isLocallyDefinedName name)] ++ occs)
+
+popOccurrenceName :: RnM s d (Maybe (Name,Necessity))
+popOccurrenceName (RnDown loc names_var errs_var occs_var) l_down
+ = readMutVarSST occs_var `thenSST` \ occs ->
+ case occs of
+ [] -> returnSST Nothing
+ (occ:occs) -> writeMutVarSST occs_var occs `thenSST_`
+ returnSST (Just occ)
+
+-- findOccurrencesRn does the enclosed thing with a *fresh* occurrences
+-- variable, and returns 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.
+
+findOccurrencesRn :: RnM s d a -> RnM s d [Name]
+findOccurrencesRn enclosed_thing (RnDown loc names_var errs_var occs_var) l_down
+ = newMutVarSST [] `thenSST` \ new_occs_var ->
+ enclosed_thing (RnDown loc names_var errs_var new_occs_var) l_down `thenSST_`
+ readMutVarSST new_occs_var `thenSST` \ occs ->
+ returnSST (map fst occs)
\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)]
+getGlobalNameEnv :: RnMS s NameEnv
+getGlobalNameEnv rn_down (SDown (RnEnv global_env fixity_env) local_env mod_name mode)
+ = returnSST global_env
-nullTyVarNamesEnv :: TyVarNamesEnv
-nullTyVarNamesEnv = []
+getNameEnv :: RnMS s NameEnv
+getNameEnv rn_down (SDown rn_env local_env mod_name mode)
+ = returnSST local_env
-catTyVarNamesEnvs :: TyVarNamesEnv -> TyVarNamesEnv -> TyVarNamesEnv
-catTyVarNamesEnvs e1 e2 = e1 ++ e2
+setNameEnv :: NameEnv -> RnMS s a -> RnMS s a
+setNameEnv local_env' m rn_down (SDown rn_env local_env mod_name mode)
+ = m rn_down (SDown rn_env local_env' mod_name mode)
-domTyVarNamesEnv :: TyVarNamesEnv -> [RdrName]
-domTyVarNamesEnv env = map fst env
+getFixityEnv :: RnMS s FixityEnv
+getFixityEnv rn_down (SDown (RnEnv name_env fixity_env) local_env mod_name mode)
+ = returnSST fixity_env
\end{code}
-@mkTyVarNamesEnv@ checks for duplicates, and complains if so.
+================ Module and 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)
-
- lookup_occ_name :: [(RdrName, RnName)] -> RdrName -> (RdrName, RnName)
- lookup_occ_name pairs tyvar_occ
- = (tyvar_occ, assoc "mkTyVarNamesEnv" pairs tyvar_occ)
+getModuleRn :: RnMS s Module
+getModuleRn rn_down (SDown rn_env local_env mod_name mode)
+ = returnSST mod_name
\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)
+getModeRn :: RnMS s RnSMode
+getModeRn rn_down (SDown rn_env local_env mod_name mode)
+ = returnSST mode
\end{code}
-\begin{code}
-#if __GLASGOW_HASKELL__ >= 200
- -- can get it from GHCbase
-#else
-fixIO :: (a -> IO a) -> IO a
+%************************************************************************
+%* *
+\subsection{Plumbing for rename-globals part}
+%* *
+%************************************************************************
-fixIO k s = let
- result = k loop s
- (Right loop, _) = result
- in
- result
-#endif
-\end{code}
+\begin{code}
+getIfacesRn :: RnMG Ifaces
+getIfacesRn rn_down (GDown dirs iface_var)
+ = readMutVarSST iface_var
-*********************************************************
-* *
-\subsection{Errors used in RnMonad}
-* *
-*********************************************************
+setIfacesRn :: Ifaces -> RnMG ()
+setIfacesRn ifaces rn_down (GDown dirs iface_var)
+ = writeMutVarSST iface_var ifaces
-\begin{code}
-unknownNameErr descriptor name locn
- = addShortErrLocLine locn $ \ sty ->
- ppBesides [ppStr "undefined ", ppStr descriptor, ppStr ": ", pprNonSym sty name]
-
-badClassOpErr clas op locn
- = addErrLoc locn "" $ \ sty ->
- ppBesides [ppChar '`', pprNonSym sty op, ppStr "' is not an operation of class `",
- ppr sty clas, ppStr "'"]
-
-shadowedNameWarn locn shadow
- = addShortWarnLocLine locn $ \ sty ->
- ppBesides [ppStr "more than one value with the same name (shadowing): ", ppr sty shadow]
+getSearchPathRn :: RnMG SearchPath
+getSearchPathRn rn_down (GDown dirs iface_var)
+ = returnSST dirs
\end{code}
projects / ghc-hetmet.git / blobdiff