-%
-% (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..,
- SST_R
- ) where
-
-IMP_Ubiq(){-uitous-}
-
-import SST
-import PreludeGlaST ( SYN_IE(ST), thenST, returnST )
-
-import HsSyn
-import RdrHsSyn
-import ErrUtils ( addErrLoc, addShortErrLocLine, addShortWarnLocLine,
- pprBagOfErrors, SYN_IE(Error), SYN_IE(Warning)
- )
-import Name ( SYN_IE(Module), Name, OccName, Provenance, SYN_IE(NameSet),
- modAndOcc, NamedThing(..)
- )
-import CmdLineOpts ( opt_D_show_rn_trace )
-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}
-#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
- = sstToST sst `thenST` \ r ->
- returnST (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}
-
-
-%************************************************************************
-%* *
-\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
- 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 [Name]
-\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
- VersionMap
- DeclsMap
- (Bag IfaceInst)
- [Module] -- Set of modules with "special" instance declarations
- -- Excludes this module
-
-type DeclsMap = FiniteMap Name (AvailInfo, RdrNameHsDecl)
-type VersionMap = FiniteMap Name Version
-type IfaceInst = ([Name], Module, RdrNameInstDecl) -- The Names are those tycons and
- -- classes mentioned by the instance type
-\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 g_down `thenSST` \ res ->
-
- -- grab errors and return
- readMutVarSST errs_var `thenSST` \ (warns,errs) ->
- returnSST (res, errs, warns)
-
-
-initRnMS :: RnEnv -> Module -> RnSMode -> RnMS REAL_WORLD r -> RnMG r
-initRnMS env mod_name mode m rn_down g_down
- = let
- s_down = SDown env mod_name mode
- in
- m rn_down s_down
-
-
-emptyIfaces :: Module -> Ifaces
-emptyIfaces mod = Ifaces mod emptyFM emptyFM emptyFM emptyFM 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 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 -> 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) ->
- 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}
-
-
-
-%************************************************************************
-%* *
-\subsection{Boring plumbing for common part}
-%* *
-%************************************************************************
-
-
-================ 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
- 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
- where
- warn = addShortWarnLocLine loc msg
-
-addErrRn :: Error -> RnM s 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 ()
-
-addWarnRn :: Warning -> RnM s 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)
-\end{code}
-
-
-================ 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
-
-getSrcLocRn :: RnM s d SrcLoc
-getSrcLocRn (RnDown loc names_var errs_var occs_var) l_down
- = returnSST loc
-\end{code}
-
-================ 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'
-\end{code}
-
-================ Occurrences =====================
-
-\begin{code}
-addOccurrenceName :: Necessity -> Name -> RnM s d ()
-addOccurrenceName necessity name (RnDown loc names_var errs_var occs_var) l_down
- = readMutVarSST occs_var `thenSST` \ occs ->
- writeMutVarSST occs_var ((name,necessity) : occs)
-
-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] ++ 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}
-
-
-%************************************************************************
-%* *
-\subsection{Plumbing for rename-source part}
-%* *
-%************************************************************************
-
-================ RnEnv =====================
-
-\begin{code}
-getNameEnv :: RnMS s NameEnv
-getNameEnv rn_down (SDown (RnEnv name_env fixity_env) mod_name mode)
- = returnSST name_env
-
-setNameEnv :: NameEnv -> RnMS s a -> RnMS s a
-setNameEnv name_env' m rn_down (SDown (RnEnv name_env fixity_env) mod_name mode)
- = m rn_down (SDown (RnEnv name_env' fixity_env) mod_name mode)
-
-getFixityEnv :: RnMS s FixityEnv
-getFixityEnv rn_down (SDown (RnEnv name_env fixity_env) mod_name mode)
- = returnSST fixity_env
-
-setRnEnv :: RnEnv -> RnMS s a -> RnMS s a
-setRnEnv rn_env' m rn_down (SDown rn_env mod_name mode)
- = m rn_down (SDown rn_env' mod_name mode)
-\end{code}
-
-================ Module and Mode =====================
-
-\begin{code}
-getModuleRn :: RnMS s Module
-getModuleRn rn_down (SDown rn_env mod_name mode)
- = returnSST mod_name
-\end{code}
-
-\begin{code}
-getModeRn :: RnMS s RnSMode
-getModeRn rn_down (SDown rn_env mod_name mode)
- = returnSST mode
-\end{code}
-
-
-%************************************************************************
-%* *
-\subsection{Plumbing for rename-globals part}
-%* *
-%************************************************************************
-
-\begin{code}
-getIfacesRn :: RnMG Ifaces
-getIfacesRn rn_down (GDown dirs iface_var)
- = readMutVarSST iface_var
-
-setIfacesRn :: Ifaces -> RnMG ()
-setIfacesRn ifaces rn_down (GDown dirs iface_var)
- = writeMutVarSST iface_var ifaces
-
-getSearchPathRn :: RnMG SearchPath
-getSearchPathRn rn_down (GDown dirs iface_var)
- = returnSST dirs
-\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