%
-% (c) The GRASP/AQUA Project, Glasgow University, 1992-1997
+% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
%
\section[RnMonad]{The monad used by the renamer}
\begin{code}
-#include "HsVersions.h"
-
module RnMonad(
- EXP_MODULE(RnMonad),
- -- close it up (partly done to allow unfoldings)
- EXP_MODULE(SST),
- SYN_IE(Module),
+ module RnMonad,
+ Module,
FiniteMap,
Bag,
Name,
- SYN_IE(RdrNameHsDecl),
- SYN_IE(RdrNameInstDecl),
- SYN_IE(Version),
- SYN_IE(NameSet),
+ RdrNameHsDecl,
+ RdrNameInstDecl,
+ Version,
+ NameSet,
OccName,
Fixity
) where
-IMP_Ubiq(){-uitous-}
+#include "HsVersions.h"
-import SST
-#if __GLASGOW_HASKELL__ <= 201
-import PreludeGlaST ( SYN_IE(ST), thenStrictlyST, returnStrictlyST )
-#define MkIO
+#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 302
+import PrelIOBase ( fixIO ) -- Should be in GlaExts
#else
-import GlaExts
-import IO
-import ST
-import IOBase
-#define IOError13 IOError
-#define MkIO IO
+import IOBase ( fixIO )
#endif
-
+import IOExts ( IORef, newIORef, readIORef, writeIORef, unsafePerformIO )
+
import HsSyn
import RdrHsSyn
-import BasicTypes ( SYN_IE(Version), NewOrData )
-import ErrUtils ( addErrLoc, addShortErrLocLine, addShortWarnLocLine,
- pprBagOfErrors, SYN_IE(Error), SYN_IE(Warning)
+import RnHsSyn ( RenamedFixitySig )
+import BasicTypes ( Version )
+import SrcLoc ( noSrcLoc )
+import ErrUtils ( addShortErrLocLine, addShortWarnLocLine,
+ pprBagOfErrors, ErrMsg, WarnMsg, Message
)
-import Name ( SYN_IE(Module), Name, OccName, Provenance, SYN_IE(NameSet), emptyNameSet,
- isLocallyDefinedName,
- modAndOcc, NamedThing(..)
+import Name ( Name, OccName, NamedThing(..),
+ isLocallyDefinedName, nameModule, nameOccName,
+ decode, mkLocalName
)
-import CmdLineOpts ( opt_D_show_rn_trace, opt_IgnoreIfacePragmas )
+import Module ( Module, ModuleName, ModuleHiMap, SearchPath, WhereFrom,
+ mkModuleHiMaps, moduleName, mkVanillaModule, mkSearchPath
+ )
+import NameSet
+import RdrName ( RdrName, dummyRdrVarName, rdrNameOcc )
+import CmdLineOpts ( opt_D_dump_rn_trace, opt_HiMap )
import PrelInfo ( builtinNames )
-import TyCon ( TyCon {- instance NamedThing -} )
import TysWiredIn ( boolTyCon )
-import Pretty
-import Outputable ( PprStyle(..) )
import SrcLoc ( SrcLoc, mkGeneratedSrcLoc )
-import Unique ( Unique )
+import Unique ( Unique, getUnique, unboundKey )
import UniqFM ( UniqFM )
-import FiniteMap ( FiniteMap, emptyFM, bagToFM )
+import FiniteMap ( FiniteMap, emptyFM, bagToFM, lookupFM, addToFM, addListToFM,
+ addListToFM_C, addToFM_C, eltsFM, fmToList
+ )
import Bag ( Bag, mapBag, emptyBag, isEmptyBag, snocBag )
+import Maybes ( mapMaybe )
import UniqSet
-import Util
-#if __GLASGOW_HASKELL__ >= 202
+import UniqFM
import UniqSupply
-#endif
+import Util
+import Outputable
infixr 9 `thenRn`, `thenRn_`
\end{code}
%************************************************************************
\begin{code}
-#if __GLASGOW_HASKELL__ >= 200
-# define REAL_WORLD RealWorld
-#else
-# define REAL_WORLD _RealWorld
-#endif
-\end{code}
-
-\begin{code}
-sstToIO :: SST REAL_WORLD r -> IO r
-sstToIO sst =
- MkIO (
- sstToST sst `thenStrictlyST` \ r ->
- returnStrictlyST (Right r))
-
-ioToRnMG :: IO r -> RnMG (Either IOError13 r)
-ioToRnMG (MkIO io) rn_down g_down = stToSST io
-
-traceRn :: Doc -> RnMG ()
-traceRn msg | opt_D_show_rn_trace = putDocRn msg
+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 | opt_D_dump_rn_trace = putDocRn msg
| otherwise = returnRn ()
-putDocRn :: Doc -> RnMG ()
-putDocRn msg = ioToRnMG (hPutStr stderr (show msg) >>
- hPutStr stderr "\n") `thenRn_`
+putDocRn :: SDoc -> RnM d ()
+putDocRn msg = ioToRnM (printErrs msg) `thenRn_`
returnRn ()
\end{code}
%* *
%************************************************************************
-===================================================
- MONAD TYPES
-===================================================
+%===================================================
+\subsubsection{ 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
+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 s = RnDown
- SrcLoc
- (MutableVar s RnNameSupply)
- (MutableVar s (Bag Warning, Bag Error))
- (MutableVar s ([Name],[Name])) -- Occurrences: compulsory and optional resp
-
-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)
+data RnDown = RnDown {
+ rn_mod :: ModuleName,
+ rn_loc :: SrcLoc,
+ rn_ns :: IORef RnNameSupply,
+ rn_errs :: IORef (Bag WarnMsg, Bag ErrMsg),
+ rn_ifaces :: IORef Ifaces,
+ rn_hi_maps :: (ModuleHiMap, -- for .hi files
+ ModuleHiMap) -- for .hi-boot files
+ }
-- 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 -- Renaming source code
- | InterfaceMode Necessity -- Renaming interface declarations. The "necessity"
- -- flag says free variables *must* be found and slurped
- -- or whether they need not be. For value signatures of
- -- things that are themselves compulsorily imported
- -- we arrange that the type signature is read in compulsory mode,
- -- but the pragmas in optional mode.
-
-type SearchPath = [(String,String)] -- List of (directory,suffix) pairs to search
- -- for interface files.
-type FreeVars = NameSet
+data SDown = SDown {
+ rn_mode :: RnMode,
+
+ rn_genv :: GlobalRdrEnv,
+ -- Global envt; the fixity component gets extended
+ -- with local fixity decls
+
+ 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 :: FixityEnv -- Local fixities
+ -- The global ones are held in the
+ -- rn_ifaces field
+ }
+
+data RnMode = SourceMode -- Renaming source code
+ | InterfaceMode -- Renaming interface declarations.
\end{code}
-===================================================
- ENVIRONMENTS
-===================================================
+%===================================================
+\subsubsection{ 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 ExportAvails = (FiniteMap Module Avails, -- Used to figure out "module M" export specifiers
- -- Includes avails only from *unqualified* imports
- -- (see 1.4 Report Section 5.1.1)
-
- UniqFM AvailInfo) -- Used to figure out all other export specifiers.
- -- Maps a Name to the AvailInfo that contains it
- -- NB: Contain bindings for class ops but
- -- not constructors (see defn of availEntityNames)
-
-
-data GenAvailInfo name = NotAvailable
- | Avail name -- An ordinary identifier
- | AvailTC name -- The name of the type or class
- [name] -- The available pieces of type/class. NB: If the type or
- -- class is itself to be in scope, it must be in this list.
- -- Thus, typically: AvailTC Eq [Eq, ==, /=]
+--------------------------------
+type RdrNameEnv a = FiniteMap RdrName a
+type GlobalRdrEnv = RdrNameEnv [Name] -- The list is because there may be name clashes
+ -- These only get reported on lookup,
+ -- not on construction
+type LocalRdrEnv = RdrNameEnv Name
+
+emptyRdrEnv :: RdrNameEnv a
+lookupRdrEnv :: RdrNameEnv a -> RdrName -> Maybe a
+addListToRdrEnv :: RdrNameEnv a -> [(RdrName,a)] -> RdrNameEnv a
+extendRdrEnv :: RdrNameEnv a -> RdrName -> a -> RdrNameEnv a
+
+emptyRdrEnv = emptyFM
+lookupRdrEnv = lookupFM
+addListToRdrEnv = addListToFM
+rdrEnvElts = eltsFM
+extendRdrEnv = addToFM
+rdrEnvToList = fmToList
+
+--------------------------------
+type NameEnv a = UniqFM a -- Domain is Name
+
+emptyNameEnv :: NameEnv a
+nameEnvElts :: NameEnv a -> [a]
+addToNameEnv_C :: (a->a->a) -> NameEnv a -> Name -> a -> NameEnv a
+addToNameEnv :: NameEnv a -> Name -> a -> NameEnv a
+plusNameEnv :: NameEnv a -> NameEnv a -> NameEnv a
+extendNameEnv :: NameEnv a -> [(Name,a)] -> NameEnv a
+lookupNameEnv :: NameEnv a -> Name -> Maybe a
+delFromNameEnv :: NameEnv a -> Name -> NameEnv a
+elemNameEnv :: Name -> NameEnv a -> Bool
+
+emptyNameEnv = emptyUFM
+nameEnvElts = eltsUFM
+addToNameEnv_C = addToUFM_C
+addToNameEnv = addToUFM
+plusNameEnv = plusUFM
+extendNameEnv = addListToUFM
+lookupNameEnv = lookupUFM
+delFromNameEnv = delFromUFM
+elemNameEnv = elemUFM
+
+--------------------------------
+type FixityEnv = NameEnv RenamedFixitySig
+ -- We keep the whole fixity sig so that we
+ -- can report line-number info when there is a duplicate
+ -- fixity declaration
+\end{code}
+
+\begin{code}
+--------------------------------
+type RnNameSupply
+ = ( UniqSupply
+
+ , FiniteMap String Int
+ -- This is used as a name supply for dictionary functions
+ -- From the inst decl we derive a string, usually by glomming together
+ -- the class and tycon name -- but it doesn't matter exactly how;
+ -- this map then gives a unique int for each inst decl with that
+ -- string. (In Haskell 98 there can only be one,
+ -- but not so in more extended versions; also class CC type T
+ -- and class C type TT might both give the string CCT
+ --
+ -- We could just use one Int for all the instance decls, but this
+ -- way the uniques change less when you add an instance decl,
+ -- hence less recompilation
+
+ , FiniteMap (ModuleName, OccName) Name
+ -- Ensures that one (module,occname) pair gets one unique
+ )
+
+
+--------------------------------
+data ExportEnv = ExportEnv Avails Fixities
+type Avails = [AvailInfo]
+type Fixities = [(Name, Fixity)]
+
+type ExportAvails = (FiniteMap ModuleName Avails,
+ -- Used to figure out "module M" export specifiers
+ -- Includes avails only from *unqualified* imports
+ -- (see 1.4 Report Section 5.1.1)
+
+ NameEnv AvailInfo) -- Used to figure out all other export specifiers.
+ -- Maps a Name to the AvailInfo that contains it
+
+
+data GenAvailInfo name = Avail name -- An ordinary identifier
+ | AvailTC name -- The name of the type or class
+ [name] -- The available pieces of type/class.
+ -- NB: If the type or class is itself
+ -- to be in scope, it must be in this list.
+ -- Thus, typically: AvailTC Eq [Eq, ==, /=]
+
type AvailInfo = GenAvailInfo Name
type RdrAvailInfo = GenAvailInfo OccName
\end{code}
-===================================================
- INTERFACE FILE STUFF
-===================================================
+%===================================================
+\subsubsection{ INTERFACE FILE STUFF}
+%===================================================
\begin{code}
-type ExportItem = (Module, IfaceFlavour, [RdrAvailInfo])
+type ExportItem = (ModuleName, [RdrAvailInfo])
type VersionInfo name = [ImportVersion name]
-type ImportVersion name = (Module, IfaceFlavour, Version, [LocalVersion name])
+
+type ImportVersion name = (ModuleName, Version, WhetherHasOrphans, WhatsImported name)
+
+type WhetherHasOrphans = Bool
+ -- An "orphan" is
+ -- * an instance decl in a module other than the defn module for
+ -- one of the tycons or classes in the instance head
+ -- * a transformation rule in a module other than the one defining
+ -- the function in the head of the rule.
+
+data WhatsImported name = Everything
+ | Specifically [LocalVersion name] -- List guaranteed non-empty
+
+ -- ("M", hif, ver, Everything) means there was a "module M" in
+ -- this module's export list, so we just have to go by M's version, "ver",
+ -- not the list of LocalVersions.
+
+
type LocalVersion name = (name, Version)
data ParsedIface
- = ParsedIface
- 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
+ = ParsedIface {
+ pi_mod :: Version, -- Module version number
+ pi_orphan :: WhetherHasOrphans, -- Whether this module has orphans
+ pi_usages :: [ImportVersion OccName], -- Usages
+ pi_exports :: [ExportItem], -- Exports
+ pi_decls :: [(Version, RdrNameHsDecl)], -- Local definitions
+ pi_insts :: [RdrNameInstDecl], -- Local instance declarations
+ pi_rules :: [RdrNameRuleDecl] -- Rules
+ }
+
+type InterfaceDetails = (WhetherHasOrphans,
+ VersionInfo Name, -- Version information for what this module imports
+ ExportEnv) -- What modules this one depends on
+
+
+-- needed by Main to fish out the fixities assoc list.
+getIfaceFixities :: InterfaceDetails -> Fixities
+getIfaceFixities (_, _, ExportEnv _ fs) = fs
+
type RdrNamePragma = () -- Fudge for now
-------------------
-data Ifaces = Ifaces
- Module -- Name of this module
- (FiniteMap Module (IfaceFlavour, -- Exports
- Version,
- Avails,
- [(OccName,Fixity)]))
- DeclsMap
-
- NameSet -- All the names (whether "big" or "small", whether wired-in or not,
- -- 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.
- -- This is used to generate the "usage" information for this module.
- -- Subset of the previous field.
-
- (Bag IfaceInst, NameSet) -- The as-yet un-slurped instance decls; this bag is depleted when we
- -- slurp an instance decl so that we don't slurp the same one twice.
- -- Together with them is the set of tycons/classes that may allow
- -- the instance decls in.
-
- (FiniteMap Name RdrNameTyDecl)
- -- Deferred data type declarations; each has the following properties
- -- * it's a data type decl
- -- * its TyCon is needed
- -- * the decl may or may not have been slurped, depending on whether any
- -- of the constrs are needed.
-
- [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.
+data Ifaces = Ifaces {
+ 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.
+
+ iDecls :: DeclsMap, -- A single, global map of Names to decls
+
+ iFixes :: FixityEnv, -- A single, global map of Names to fixities
+
+ iSlurp :: NameSet,
+ -- All the names (whether "big" or "small", whether wired-in or not,
+ -- whether locally defined or not) that have been slurped in so far.
+
+ iVSlurp :: [(Name,Version)],
+ -- All the (a) non-wired-in (b) "big" (c) non-locally-defined
+ -- names that have been slurped in so far, with their versions.
+ -- This is used to generate the "usage" information for this module.
+ -- Subset of the previous field.
+
+ iInsts :: Bag GatedDecl,
+ -- 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 :: Bag GatedDecl
+ -- Ditto transformation rules
+ }
+
+type GatedDecl = (NameSet, (Module, RdrNameHsDecl))
+
+type ImportedModuleInfo
+ = FiniteMap ModuleName (Version, Bool, Maybe (Module, Bool, Avails))
+ -- Suppose the domain element is module 'A'
+ --
+ -- The first Bool is True if A contains
+ -- 'orphan' rules or instance decls
+
+ -- The second Bool is true if the interface file actually
+ -- read was an .hi-boot file
+
+ -- Nothing => A's interface not yet read, but this module has
+ -- imported a module, B, that itself depends on A
+ --
+ -- Just xx => A's interface has been read. The Module in
+ -- the Just has the correct Dll flag
+
+ -- This set is used to decide whether to look for
+ -- A.hi or A.hi-boot when importing A.f.
+ -- Basically, we look for A.hi if A is in the map, and A.hi-boot
+ -- otherwise
+
+type DeclsMap = NameEnv (Version, AvailInfo, Bool, (Module, RdrNameHsDecl))
+ -- A DeclsMap contains a binding for each Name in the declaration
+ -- including the constructors of a type decl etc.
+ -- The Bool is True just for the 'main' Name.
\end{code}
%************************************************************************
\begin{code}
-initRn :: Module -> UniqSupply -> SearchPath -> SrcLoc
+initRn :: ModuleName -> 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 g_down `thenSST` \ res ->
+ -> IO (r, Bag ErrMsg, Bag WarnMsg)
+
+initRn mod us dirs loc do_rn = do
+ himaps <- mkModuleHiMaps dirs
+ names_var <- newIORef (us, emptyFM, builtins)
+ errs_var <- newIORef (emptyBag,emptyBag)
+ iface_var <- newIORef emptyIfaces
+ let
+ rn_down = RnDown { rn_loc = loc, rn_ns = names_var,
+ rn_errs = errs_var,
+ rn_hi_maps = himaps,
+ rn_ifaces = iface_var,
+ rn_mod = mod }
+
+ -- do the business
+ res <- do_rn rn_down ()
-- grab errors and return
- readMutVarSST errs_var `thenSST` \ (warns,errs) ->
- returnSST (res, errs, warns)
+ (warns, errs) <- readIORef errs_var
+
+ return (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
+initRnMS :: GlobalRdrEnv -> FixityEnv -> RnMode -> RnMS r -> RnM d r
+initRnMS rn_env fixity_env mode thing_inside rn_down g_down
= let
- s_down = SDown rn_env name_env mod_name mode
+ s_down = SDown { rn_genv = rn_env, rn_lenv = emptyRdrEnv,
+ rn_fixenv = fixity_env, rn_mode = mode }
in
- m rn_down s_down
-
-
-emptyIfaces :: Module -> Ifaces
-emptyIfaces mod = Ifaces mod emptyFM emptyFM emptyNameSet [] (emptyBag, emptyNameSet) emptyFM []
-
-builtins :: FiniteMap (Module,OccName) Name
-builtins = bagToFM (mapBag (\ name -> (modAndOcc name, name)) builtinNames)
-
- -- Initial value for the occurrence pool.
-initOccs :: ([Name],[Name]) -- Compulsory and optional respectively
-initOccs = ([getName boolTyCon], [])
- -- 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}
-
+ thing_inside rn_down s_down
+
+initIfaceRnMS :: Module -> RnMS r -> RnM d r
+initIfaceRnMS mod thing_inside
+ = initRnMS emptyRdrEnv emptyNameEnv InterfaceMode $
+ setModuleRn (moduleName mod) thing_inside
+
+emptyIfaces :: Ifaces
+emptyIfaces = Ifaces { iImpModInfo = emptyFM,
+ iDecls = emptyNameEnv,
+ iFixes = emptyNameEnv,
+ 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 = [],
+ iInsts = emptyBag,
+ iRules = emptyBag
+ }
+
+-- mkUnboundName makes a place-holder Name; it shouldn't be looked at except possibly
+-- during compiler debugging.
+mkUnboundName :: RdrName -> Name
+mkUnboundName rdr_name = mkLocalName unboundKey (rdrNameOcc rdr_name) noSrcLoc
+
+isUnboundName :: Name -> Bool
+isUnboundName name = getUnique name == unboundKey
+
+builtins :: FiniteMap (ModuleName,OccName) Name
+builtins =
+ bagToFM (
+ mapBag (\ name -> ((moduleName (nameModule name), nameOccName name), name))
+ builtinNames)
\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.
+@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 @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
+renameSourceCode :: ModuleName
+ -> RnNameSupply
+ -> RnMS 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 ->
+ = 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
+
+ mkModuleHiMaps (mkSearchPath opt_HiMap) >>= \ himaps ->
+ newIORef name_supply >>= \ names_var ->
+ newIORef (emptyBag,emptyBag) >>= \ errs_var ->
let
- rn_down = RnDown mkGeneratedSrcLoc names_var errs_var occs_var
- s_down = SDown emptyRnEnv emptyNameEnv mod_name (InterfaceMode Compulsory)
+ rn_down = RnDown { rn_loc = mkGeneratedSrcLoc, rn_ns = names_var,
+ rn_errs = errs_var, rn_hi_maps = himaps,
+ rn_mod = mod_name }
+ 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 `thenSST` \ result ->
+ m rn_down s_down >>= \ result ->
- readMutVarSST errs_var `thenSST` \ (warns,errs) ->
+ readIORef errs_var >>= \ (warns,errs) ->
(if not (isEmptyBag errs) then
- trace ("Urk! renameSourceCode found errors" ++ display errs)
+ pprTrace "Urk! renameSourceCode found errors" (display errs)
+#ifdef DEBUG
else if not (isEmptyBag warns) then
- trace ("Urk! renameSourceCode found warnings" ++ display warns)
+ pprTrace "Note: renameSourceCode found warnings" (display warns)
+#endif
else
id) $
- returnSST result
+ return result
)
where
- display errs = show (pprBagOfErrors PprDebug errs)
+ display errs = pprBagOfErrors errs
{-# INLINE thenRn #-}
{-# INLINE thenRn_ #-}
{-# INLINE returnRn #-}
{-# INLINE andRn #-}
-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)
+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]
+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 `thenSST` \ res1 ->
- m2 gdown ldown `thenSST` \ res2 ->
- returnSST (combiner res1 res2)
+ = m1 gdown ldown >>= \ res1 ->
+ m2 gdown ldown >>= \ res2 ->
+ return (combiner res1 res2)
sequenceRn [] = returnRn []
sequenceRn (m:ms) = m `thenRn` \ r ->
mapRn f xs `thenRn` \ rs ->
returnRn (r:rs)
+mapRn_ f [] = returnRn ()
+mapRn_ f (x:xs) =
+ f x `thenRn_`
+ mapRn_ f xs
+
foldlRn k z [] = returnRn z
foldlRn k z (x:xs) = k z x `thenRn` \ z' ->
foldlRn k z' xs
= f x `thenRn` \ (r1, r2, r3) ->
mapAndUnzip3Rn f xs `thenRn` \ (rs1, rs2, rs3) ->
returnRn (r1:rs1, r2:rs2, r3:rs3)
+
+mapMaybeRn f [] = returnRn []
+mapMaybeRn f (x:xs) = f x `thenRn` \ maybe_r ->
+ mapMaybeRn f xs `thenRn` \ rs ->
+ case maybe_r of
+ Nothing -> returnRn rs
+ Just r -> returnRn (r:rs)
\end{code}
%************************************************************************
-================ Errors and warnings =====================
+%================
+\subsubsection{ Errors and warnings}
+%=====================
\begin{code}
-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
+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
err = addShortErrLocLine loc msg
-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
+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
warn = addShortWarnLocLine loc msg
-addErrRn :: Error -> RnM s d ()
+addErrRn :: Message -> RnM d ()
addErrRn err = failWithRn () err
-checkRn :: Bool -> Error -> RnM s d () -- Check that a condition is true
-checkRn False err = addErrRn err
-checkRn True err = returnRn ()
+checkRn :: Bool -> Message -> RnM d () -- Check that a condition is true
+checkRn False err = addErrRn err
+checkRn True err = returnRn ()
+
+warnCheckRn :: Bool -> Message -> RnM d () -- Check that a condition is true
+warnCheckRn False err = addWarnRn err
+warnCheckRn True err = returnRn ()
-addWarnRn :: Warning -> RnM s d ()
+addWarnRn :: Message -> RnM d ()
addWarnRn warn = warnWithRn () warn
-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)
+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)
\end{code}
-================ Source location =====================
+%================
+\subsubsection{ Source location}
+%=====================
\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
+pushSrcLocRn :: SrcLoc -> RnM d a -> RnM d a
+pushSrcLocRn loc' m down l_down
+ = m (down {rn_loc = loc'}) l_down
-getSrcLocRn :: RnM s d SrcLoc
-getSrcLocRn (RnDown loc names_var errs_var occs_var) l_down
- = returnSST loc
+getSrcLocRn :: RnM d SrcLoc
+getSrcLocRn down l_down
+ = return (rn_loc down)
\end{code}
-================ Name supply =====================
+%================
+\subsubsection{ Name supply}
+%=====================
\begin{code}
-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}
-
-================ Occurrences =====================
-
-Every time we get an occurrence of a name we put it in one of two lists:
- one for "compulsory" occurrences
- one for "optional" occurrences
-
-The significance of "compulsory" is
- (a) we *must* find the declaration
- (b) in the case of type or class names, the name is part of the
- source level program, and we must slurp in any instance decls
- involving it.
-
-We don't need instance decls "optional" names, because the type inference
-process will never come across them. Optional names are buried inside
-type checked (but not renamed) cross-module unfoldings and such.
-
-The pair of lists is held in a mutable variable in RnDown.
-
-The lists are kept separate so that we can process all the compulsory occurrences
-before any of the optional ones. Why? Because suppose we processed an optional
-"g", and slurped an interface decl of g::T->T. Then we'd rename the type T->T in
-optional mode. But if we later need g compulsorily we'll find that it's already
-been slurped and will do nothing. We could, I suppose, rename it a second time,
-but it seems simpler just to do all the compulsory ones first.
-
-\begin{code}
-addOccurrenceName :: Name -> RnMS s Name -- Same name returned as passed
-addOccurrenceName name (RnDown loc names_var errs_var occs_var)
- (SDown rn_env local_env mod_name mode)
- | isLocallyDefinedName name ||
- not_necessary necessity
- = returnSST name
-
- | otherwise
- = readMutVarSST occs_var `thenSST` \ (comp_occs, opt_occs) ->
+getNameSupplyRn :: RnM d RnNameSupply
+getNameSupplyRn rn_down l_down
+ = readIORef (rn_ns rn_down)
+
+setNameSupplyRn :: RnNameSupply -> RnM d ()
+setNameSupplyRn names' (RnDown {rn_ns = names_var}) l_down
+ = writeIORef names_var names'
+
+-- See comments with RnNameSupply above.
+newInstUniq :: String -> RnM d Int
+newInstUniq key (RnDown {rn_ns = names_var}) l_down
+ = readIORef names_var >>= \ (us, mapInst, cache) ->
let
- new_occ_pair = case necessity of
- Optional -> (comp_occs, name:opt_occs)
- Compulsory -> (name:comp_occs, opt_occs)
+ uniq = case lookupFM mapInst key of
+ Just x -> x+1
+ Nothing -> 0
+ mapInst' = addToFM mapInst key uniq
in
- writeMutVarSST occs_var new_occ_pair `thenSST_`
- returnSST name
- where
- necessity = case mode of
- SourceMode -> Compulsory
- InterfaceMode necessity -> necessity
+ writeIORef names_var (us, mapInst', cache) >>
+ return uniq
+
+getUniqRn :: RnM d Unique
+getUniqRn (RnDown {rn_ns = names_var}) l_down
+ = readIORef names_var >>= \ (us, mapInst, cache) ->
+ let
+ (us1,us') = splitUniqSupply us
+ in
+ writeIORef names_var (us', mapInst, cache) >>
+ return (uniqFromSupply us1)
+\end{code}
+%================
+\subsubsection{ Module}
+%=====================
-addOccurrenceNames :: [Name] -> RnMS s ()
-addOccurrenceNames names (RnDown loc names_var errs_var occs_var)
- (SDown rn_env local_env mod_name mode)
- | not_necessary necessity
- = returnSST ()
+\begin{code}
+getModuleRn :: RnM d ModuleName
+getModuleRn (RnDown {rn_mod = mod_name}) l_down
+ = return mod_name
- | otherwise
- = readMutVarSST occs_var `thenSST` \ (comp_occs, opt_occs) ->
- let
- new_occ_pair = case necessity of
- Optional -> (comp_occs, non_local_names ++ opt_occs)
- Compulsory -> (non_local_names ++ comp_occs, opt_occs)
- in
- writeMutVarSST occs_var new_occ_pair
- where
- non_local_names = filter (not . isLocallyDefinedName) names
- necessity = case mode of
- SourceMode -> Compulsory
- InterfaceMode necessity -> necessity
-
- -- Never look for optional things if we're
- -- ignoring optional input interface information
-not_necessary Compulsory = False
-not_necessary Optional = opt_IgnoreIfacePragmas
-
-popOccurrenceName :: Necessity -> RnM s d (Maybe Name)
-popOccurrenceName necessity (RnDown loc names_var errs_var occs_var) l_down
- = readMutVarSST occs_var `thenSST` \ occs ->
- case (necessity, occs) of
- -- Find a compulsory occurrence
- (Compulsory, (comp:comps, opts)) -> writeMutVarSST occs_var (comps, opts) `thenSST_`
- returnSST (Just comp)
-
- -- Find an optional occurrence
- -- We shouldn't be looking unless we've done all the compulsories
- (Optional, (comps, opt:opts)) -> ASSERT( null comps )
- writeMutVarSST occs_var (comps, opts) `thenSST_`
- returnSST (Just opt)
-
- -- No suitable occurrence
- other -> returnSST Nothing
-
--- findOccurrencesRn does the enclosed thing with a *fresh* occurrences
--- variable, and returns the list of occurrences thus found. It's useful
--- 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 occs
+setModuleRn :: ModuleName -> 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}
%* *
%************************************************************************
-================ RnEnv =====================
+%================
+\subsubsection{ RnEnv}
+%=====================
\begin{code}
-getGlobalNameEnv :: RnMS s NameEnv
-getGlobalNameEnv rn_down (SDown (RnEnv global_env fixity_env) local_env mod_name mode)
- = returnSST global_env
-
-getNameEnv :: RnMS s NameEnv
-getNameEnv rn_down (SDown rn_env local_env mod_name mode)
- = returnSST local_env
+getNameEnvs :: RnMS (GlobalRdrEnv, LocalRdrEnv)
+getNameEnvs rn_down (SDown {rn_genv = global_env, rn_lenv = local_env})
+ = return (global_env, local_env)
-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)
+getLocalNameEnv :: RnMS LocalRdrEnv
+getLocalNameEnv rn_down (SDown {rn_lenv = local_env})
+ = return local_env
-getFixityEnv :: RnMS s FixityEnv
-getFixityEnv rn_down (SDown (RnEnv name_env fixity_env) local_env mod_name mode)
- = returnSST fixity_env
-\end{code}
+setLocalNameEnv :: LocalRdrEnv -> RnMS a -> RnMS a
+setLocalNameEnv local_env' m rn_down l_down
+ = m rn_down (l_down {rn_lenv = local_env'})
-================ Module and Mode =====================
+getFixityEnv :: RnMS FixityEnv
+getFixityEnv rn_down (SDown {rn_fixenv = fixity_env})
+ = return fixity_env
-\begin{code}
-getModuleRn :: RnMS s Module
-getModuleRn rn_down (SDown rn_env local_env mod_name mode)
- = returnSST mod_name
+extendFixityEnv :: [(Name, RenamedFixitySig)] -> RnMS a -> RnMS a
+extendFixityEnv fixes enclosed_scope
+ rn_down l_down@(SDown {rn_fixenv = fixity_env})
+ = let
+ new_fixity_env = extendNameEnv fixity_env fixes
+ in
+ enclosed_scope rn_down (l_down {rn_fixenv = new_fixity_env})
\end{code}
+%================
+\subsubsection{ Mode}
+%=====================
+
\begin{code}
-getModeRn :: RnMS s RnSMode
-getModeRn rn_down (SDown rn_env local_env mod_name mode)
- = returnSST mode
+getModeRn :: RnMS RnMode
+getModeRn rn_down (SDown {rn_mode = mode})
+ = return mode
-setModeRn :: RnSMode -> RnMS s a -> RnMS s a
-setModeRn new_mode thing_inside rn_down (SDown rn_env local_env mod_name mode)
- = thing_inside rn_down (SDown rn_env local_env mod_name new_mode)
+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}
-getIfacesRn :: RnMG Ifaces
-getIfacesRn rn_down (GDown dirs iface_var)
- = readMutVarSST iface_var
+getIfacesRn :: RnM d Ifaces
+getIfacesRn (RnDown {rn_ifaces = iface_var}) _
+ = readIORef iface_var
-setIfacesRn :: Ifaces -> RnMG ()
-setIfacesRn ifaces rn_down (GDown dirs iface_var)
- = writeMutVarSST iface_var ifaces
+setIfacesRn :: Ifaces -> RnM d ()
+setIfacesRn ifaces (RnDown {rn_ifaces = iface_var}) _
+ = writeIORef iface_var ifaces
+
+getHiMaps :: RnM d (ModuleHiMap, ModuleHiMap)
+getHiMaps (RnDown {rn_hi_maps = himaps}) _
+ = return himaps
+\end{code}
+
+\begin{code}
+lookupModuleRn :: ModuleName -> RnM d Module
+lookupModuleRn x =
+ getHiMaps `thenRn` \ (himap, _) ->
+ case lookupFM himap x of
+ Nothing -> returnRn (mkVanillaModule x)
+ Just (_,x) -> returnRn x
-getSearchPathRn :: RnMG SearchPath
-getSearchPathRn rn_down (GDown dirs iface_var)
- = returnSST dirs
\end{code}
projects / ghc-hetmet.git / blobdiff