import HsSyn
import RdrHsSyn
-import BasicTypes ( Version, pprModule, IfaceFlavour(..) )
+import RnHsSyn ( RenamedFixitySig )
+import BasicTypes ( Version )
import SrcLoc ( noSrcLoc )
import ErrUtils ( addShortErrLocLine, addShortWarnLocLine,
- pprBagOfErrors, ErrMsg, WarnMsg
+ pprBagOfErrors, ErrMsg, WarnMsg, Message
)
-import Name ( Module, Name, OccName, PrintUnqualified,
- isLocallyDefinedName,
- modAndOcc, NamedThing(..)
+import Name ( Name, OccName, NamedThing(..),
+ isLocallyDefinedName, nameModule, nameOccName,
+ decode
+ )
+import Module ( Module, IfaceFlavour, setModuleFlavour, mkSysModuleFS,
+ bootFlavour, moduleString, moduleIfaceFlavour, mkDynFlavour
)
import NameSet
-import CmdLineOpts ( opt_D_show_rn_trace, opt_IgnoreIfacePragmas, opt_WarnHiShadows )
+import RdrName ( RdrName )
+import CmdLineOpts ( opt_D_show_rn_trace, opt_IgnoreIfacePragmas,
+ opt_WarnHiShadows, opt_Static
+ )
import PrelInfo ( builtinNames )
import TysWiredIn ( boolTyCon )
import SrcLoc ( SrcLoc, mkGeneratedSrcLoc )
import Unique ( Unique )
import UniqFM ( UniqFM )
-import FiniteMap ( FiniteMap, emptyFM, bagToFM, lookupFM, addToFM, addListToFM_C, addToFM_C )
+import FiniteMap ( FiniteMap, emptyFM, bagToFM, lookupFM, addToFM, addListToFM,
+ addListToFM_C, addToFM_C, eltsFM
+ )
import Bag ( Bag, mapBag, emptyBag, isEmptyBag, snocBag )
import Maybes ( seqMaybe, mapMaybe )
import UniqSet
+import UniqFM
import UniqSupply
import Util
import Outputable
import DirUtils ( getDirectoryContents )
+import Directory ( doesFileExist )
import IO ( hPutStrLn, stderr, isDoesNotExistError )
import Monad ( foldM )
import Maybe ( fromMaybe )
type SSTRWRef a = SSTRef RealWorld a -- ToDo: there ought to be a standard defn of this
-- Common part
-data RnDown s = RnDown
- SrcLoc
- (SSTRef s (GenRnNameSupply s))
- (SSTRef s (Bag WarnMsg, Bag ErrMsg))
- (SSTRef s ([Occurrence],[Occurrence])) -- Occurrences: compulsory and optional resp
+data RnDown s = RnDown {
+ rn_loc :: SrcLoc,
+ rn_omit :: Name -> Bool, -- True <=> omit qualifier when printing
+ rn_ns :: SSTRef s RnNameSupply,
+ rn_errs :: SSTRef s (Bag WarnMsg, Bag ErrMsg),
+ rn_occs :: SSTRef s ([Occurrence],[Occurrence]), -- Occurrences: compulsory and optional resp
+ rn_hi_map :: ModuleHiMap, -- for .hi files
+ rn_hiboot_map :: ModuleHiMap, -- for .hi-boot files
+ rn_mod :: Module
+ }
type Occurrence = (Name, SrcLoc) -- The srcloc is the occurrence site
-- for optional ones.
-- For getting global names
-data GDown = GDown
- ModuleHiMap -- for .hi files
- ModuleHiMap -- for .hi-boot files
- (SSTRWRef Ifaces)
+data GDown = GDown {
+ rn_ifaces :: SSTRWRef 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 -- Renaming source code
+data SDown s = SDown {
+ rn_mode :: RnMode,
+ rn_genv :: RnEnv, -- Global envt; the fixity component gets extended
+ -- with local fixity decls
+ rn_lenv :: LocalRdrEnv -- Local name envt
+ -- Does *not* includes 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
+ }
+
+data RnMode = SourceMode -- Renaming source code
| InterfaceMode -- Renaming interface declarations.
Necessity -- The "necessity"
-- flag says free variables *must* be found and slurped
-- we arrange that the type signature is read
-- in compulsory mode,
-- but the pragmas in optional mode.
- (Name -> PrintUnqualified) -- Tells whether the thing can be printed unqualified
type SearchPath = [(String,String)] -- List of (directory,suffix) pairs to search
-- for interface files.
-type ModuleHiMap = FiniteMap String String
+type ModuleHiMap = FiniteMap String (String, Bool)
-- mapping from module name to the file path of its corresponding
-- interface file.
-
-type FreeVars = NameSet
\end{code}
===================================================
===================================================
\begin{code}
-type RnNameSupply = GenRnNameSupply RealWorld
+--------------------------------
+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
+
+emptyRdrEnv = emptyFM
+lookupRdrEnv = lookupFM
+addListToRdrEnv = addListToFM
+rdrEnvElts = eltsFM
+
+--------------------------------
+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
+
+--------------------------------
+data RnEnv = RnEnv GlobalRdrEnv FixityEnv
+emptyRnEnv = RnEnv emptyRdrEnv emptyNameEnv
+\end{code}
-type GenRnNameSupply s
+\begin{code}
+--------------------------------
+type RnNameSupply
= ( UniqSupply
- , FiniteMap FAST_STRING (SSTRef s Int)
- , FiniteMap (Module,OccName) Name
- )
- -- Ensures that one (m,n) pair gets one unique
- -- The finite map on FAST_STRINGS is used to give a per-class unique to each
- -- instance declaration; it's really a separate name supply.
-
-data RnEnv = RnEnv GlobalNameEnv FixityEnv
-emptyRnEnv = RnEnv emptyNameEnv emptyFixityEnv
-
-type GlobalNameEnv = FiniteMap RdrName (Name, HowInScope)
-emptyGlobalNameEnv = emptyFM
-data HowInScope -- Used for error messages only
- = FromLocalDefn SrcLoc
- | FromImportDecl Module SrcLoc
+ , FiniteMap (OccName, OccName) Int
+ -- This is used as a name supply for dictionary functions
+ -- From the inst decl we derive a (class, tycon) pair;
+ -- this map then gives a unique int for each inst decl with that
+ -- (class, tycon) pair. (In Haskell 98 there can only be one,
+ -- but not so in more extended versions.)
+ --
+ -- 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
-type NameEnv = FiniteMap RdrName Name
-emptyNameEnv = emptyFM
+ , FiniteMap (Module,OccName) Name
+ -- Ensures that one (module,occname) pair gets one unique
+ )
-type FixityEnv = FiniteMap RdrName (Fixity, HowInScope)
-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)]
+--------------------------------
+data ExportEnv = ExportEnv Avails Fixities
+type Avails = [AvailInfo]
+type Fixities = [(Name, Fixity)]
-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)
+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)
+ NameEnv AvailInfo) -- Used to figure out all other export specifiers.
+ -- Maps a Name to the AvailInfo that contains it
-data GenAvailInfo name = NotAvailable
- | Avail name -- An ordinary identifier
+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.
===================================================
\begin{code}
-type ExportItem = (Module, IfaceFlavour, [RdrAvailInfo])
+type ExportItem = (Module, [RdrAvailInfo])
type VersionInfo name = [ImportVersion name]
-type ImportVersion name = (Module, IfaceFlavour, Version, WhatsImported name)
+type ImportVersion name = (Module, Version, WhatsImported name)
data WhatsImported name = Everything
| Specifically [LocalVersion name] -- List guaranteed non-empty
data ParsedIface
= ParsedIface
- Module -- Module name
- Version -- Module version number
+ Version -- Module version number
[ImportVersion OccName] -- Usages
[ExportItem] -- Exports
[Module] -- Special instance modules
- [(OccName,Fixity)] -- Fixities
[(Version, RdrNameHsDecl)] -- Local definitions
[RdrNameInstDecl] -- Local instance declarations
ExportEnv, -- What this module exports
[Module]) -- Instance modules
+
+-- 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
+data Ifaces = Ifaces {
+ iMod :: Module, -- Name of the module being compiled
+
+ iModMap :: FiniteMap Module (IfaceFlavour, -- Exports
+ Version,
+ Avails),
+
+ iDecls :: DeclsMap, -- A single, global map of Names to decls
- NameSet -- All the names (whether "big" or "small", whether wired-in or not,
+ 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.
- [(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.
+ 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.
- (Bag IfaceInst, NameSet) -- The as-yet un-slurped instance decls; this bag is depleted when we
+ iDefInsts :: (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)
+ iDefData :: NameEnv (Module, RdrNameTyClDecl),
-- 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
+ iInstMods :: [Module] -- Set of modules with "special" instance declarations
-- Excludes this module
+ }
+
+type DeclsMap = NameEnv (Version, AvailInfo, RdrNameHsDecl, Bool)
+ -- 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.
-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
+type IfaceInst = ((Module, RdrNameInstDecl), -- Instance decl
+ NameSet) -- "Gate" names. Slurp this instance decl when this
+ -- set becomes empty. It's depleted whenever we
-- slurp another type or class decl.
\end{code}
-> IO (r, Bag ErrMsg, Bag WarnMsg)
initRn mod us dirs loc do_rn = do
+ (himap, hibmap) <- mkModuleHiMaps dirs
names_var <- sstToIO (newMutVarSST (us, emptyFM, builtins))
errs_var <- sstToIO (newMutVarSST (emptyBag,emptyBag))
iface_var <- sstToIO (newMutVarSST (emptyIfaces mod))
occs_var <- sstToIO (newMutVarSST initOccs)
- (himap, hibmap) <- mkModuleHiMaps dirs
let
- rn_down = RnDown loc names_var errs_var occs_var
- g_down = GDown himap hibmap iface_var
+ rn_down = RnDown { rn_loc = loc, rn_omit = \n -> False, rn_ns = names_var,
+ rn_errs = errs_var, rn_occs = occs_var,
+ rn_hi_map = himap, rn_hiboot_map = hibmap,
+ rn_mod = mod }
+ g_down = GDown {rn_ifaces = iface_var }
-- do the business
res <- sstToIO (do_rn rn_down g_down)
return (res, errs, warns)
-initRnMS :: RnEnv -> Module -> RnSMode -> RnMS RealWorld r -> RnMG r
-initRnMS rn_env@(RnEnv name_env _) mod_name mode m rn_down g_down
+initRnMS :: RnEnv -> RnMode -> RnMS RealWorld r -> RnMG r
+initRnMS rn_env mode m rn_down g_down
= let
- s_down = SDown rn_env emptyNameEnv mod_name mode
+ s_down = SDown { rn_genv = rn_env, rn_lenv = emptyRdrEnv, rn_mode = mode }
in
m rn_down s_down
emptyIfaces :: Module -> Ifaces
-emptyIfaces mod = Ifaces mod emptyFM emptyFM emptyNameSet [] (emptyBag, emptyNameSet) emptyFM []
-
+emptyIfaces mod = Ifaces { iMod = mod,
+ iModMap = emptyFM,
+ iDecls = emptyNameEnv,
+ iFixes = emptyNameEnv,
+ iSlurp = emptyNameSet,
+ iVSlurp = [],
+ iDefInsts = (emptyBag, emptyNameSet),
+ iDefData = emptyNameEnv,
+ iInstMods = []
+ }
builtins :: FiniteMap (Module,OccName) Name
-builtins = bagToFM (mapBag (\ name -> (modAndOcc name, name)) builtinNames)
+builtins =
+ bagToFM (
+ mapBag (\ name -> ((nameModule name, nameOccName name), name))
+ builtinNames)
-- Initial value for the occurrence pool.
initOccs :: ([Occurrence],[Occurrence]) -- Compulsory and optional respectively
-- to do as much as possible explicitly.
\end{code}
+We (allege) that it is quicker to build up a mapping from module names
+to the paths to their corresponding interface files once, than to search
+along the import part every time we slurp in a new module (which we
+do quite a lot of.)
+
\begin{code}
mkModuleHiMaps :: SearchPath -> IO (ModuleHiMap, ModuleHiMap)
mkModuleHiMaps dirs = foldM (getAllFilesMatching dirs) (env,env) dirs
where
env = emptyFM
+{- a pseudo file which signals that the interface files
+ contained in a particular directory have got their
+ corresponding object codes stashed away in a DLL
+
+ This stuff is only needed to deal with Win32 DLLs,
+ and conceivably we conditionally compile in support
+ for handling it. (ToDo?)
+-}
+dir_contain_dll_his = "dLL_ifs.hi"
+
getAllFilesMatching :: SearchPath
-> (ModuleHiMap, ModuleHiMap)
-> (FilePath, String)
-> IO (ModuleHiMap, ModuleHiMap)
getAllFilesMatching dirs hims (dir_path, suffix) = ( do
-- fpaths entries do not have dir_path prepended
- fpaths <- getDirectoryContents dir_path
- return (foldl addModules hims fpaths)
+ fpaths <- getDirectoryContents dir_path
+ is_dyns <- catch
+ (if opt_Static || dir_path == "." then
+ return False
+ else
+ doesFileExist (dir_path ++ '/': dir_contain_dll_his))
+ (\ _ {-don't care-} -> return False)
+ return (foldl (addModules is_dyns) hims fpaths)
) -- soft failure
`catch`
(\ err -> do
- hPutStrLn stderr
+ hPutStrLn stderr
("Import path element `" ++ dir_path ++
if (isDoesNotExistError err) then
"' does not exist, ignoring."
reverse (show interfaceFileFormatVersion) ++ '-':hi_boot_xiffus
hi_boot_xiffus = "toob-ih." -- .hi-boot reversed.
- addModules his@(hi_env, hib_env) nm = fromMaybe his $
- map (\ (mod_nm,v) -> (addToFM_C addNewOne hi_env mod_nm v, hib_env))
+ addModules is_dll his@(hi_env, hib_env) nm = fromMaybe his $
+ FMAP (\ (mod_nm,v) -> (addToFM_C addNewOne hi_env mod_nm (v, is_dll), hib_env))
(go xiffus rev_nm) `seqMaybe`
- map (\ (mod_nm,v) -> (hi_env, addToFM_C overrideNew hib_env mod_nm v))
+ FMAP (\ (mod_nm,v) -> (hi_env, addToFM_C overrideNew hib_env mod_nm (v,is_dll)))
(go hi_boot_version_xiffus rev_nm) `seqMaybe`
- map (\ (mod_nm,v) -> (hi_env, addToFM_C addNewOne hib_env mod_nm v))
+ FMAP (\ (mod_nm,v) -> (hi_env, addToFM_C addNewOne hib_env mod_nm (v,is_dll)))
(go hi_boot_xiffus rev_nm)
where
rev_nm = reverse nm
conflict old_path new_path
| old_path /= new_path =
- pprTrace "Warning: " (text "Identically named interface files present on import path, " $$
+ pprTrace "Warning: " (text "Identically named interface files present on the import path, " $$
text (show old_path) <+> text "shadows" $$
text (show new_path) $$
text "on the import path: " <+>
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 Compulsory (\_ -> False))
+ rn_down = RnDown { rn_loc = mkGeneratedSrcLoc, rn_ns = names_var,
+ rn_errs = errs_var, rn_occs = occs_var,
+ rn_mod = mod_name }
+ s_down = SDown { rn_mode = InterfaceMode Compulsory,
+ rn_genv = emptyRnEnv, rn_lenv = emptyRdrEnv }
in
m rn_down s_down `thenSST` \ result ->
pprTrace "Urk! renameSourceCode found errors" (display errs)
#ifdef DEBUG
else if not (isEmptyBag warns) then
- pprTrace "Urk! renameSourceCode found warnings" (display warns)
+ pprTrace "Note: renameSourceCode found warnings" (display warns)
#endif
else
id) $
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]
-mapMaybeRn :: (a -> RnM s d b) -> b -> Maybe a -> RnM s d b
+mapRn_ :: (a -> RnM s d b) -> [a] -> RnM s d ()
+mapMaybeRn :: (a -> RnM s d (Maybe 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])
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
mapAndUnzip3Rn f xs `thenRn` \ (rs1, rs2, rs3) ->
returnRn (r1:rs1, r2:rs2, r3:rs3)
-mapMaybeRn f def Nothing = returnRn def
-mapMaybeRn f def (Just v) = f v
+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 =====================
\begin{code}
-failWithRn :: a -> ErrMsg -> RnM s d a
-failWithRn res msg (RnDown loc names_var errs_var occs_var) l_down
+failWithRn :: a -> Message -> RnM s d a
+failWithRn res msg (RnDown {rn_errs = errs_var, rn_loc = loc}) 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 -> WarnMsg -> RnM s d a
-warnWithRn res msg (RnDown loc names_var errs_var occs_var) l_down
+warnWithRn :: a -> Message -> RnM s d a
+warnWithRn res msg (RnDown {rn_errs = errs_var, rn_loc = loc}) l_down
= readMutVarSST errs_var `thenSST` \ (warns,errs) ->
writeMutVarSST errs_var (warns `snocBag` warn, errs) `thenSST_`
returnSST res
where
warn = addShortWarnLocLine loc msg
-addErrRn :: ErrMsg -> RnM s d ()
+addErrRn :: Message -> RnM s d ()
addErrRn err = failWithRn () err
-checkRn :: Bool -> ErrMsg -> RnM s d () -- Check that a condition is true
-checkRn False err = addErrRn err
-checkRn True err = returnRn ()
+checkRn :: Bool -> Message -> RnM s d () -- Check that a condition is true
+checkRn False err = addErrRn err
+checkRn True err = returnRn ()
-addWarnRn :: WarnMsg -> RnM s d ()
+warnCheckRn :: Bool -> Message -> RnM s d () -- Check that a condition is true
+warnCheckRn False err = addWarnRn err
+warnCheckRn True err = returnRn ()
+
+addWarnRn :: Message -> 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
+checkErrsRn (RnDown {rn_errs = errs_var}) l_down
= readMutVarSST errs_var `thenSST` \ (warns,errs) ->
returnSST (isEmptyBag errs)
\end{code}
\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 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 down l_down
+ = returnSST (rn_loc down)
\end{code}
================ Name supply =====================
\begin{code}
-getNameSupplyRn :: RnM s d (GenRnNameSupply s)
-getNameSupplyRn (RnDown loc names_var errs_var occs_var) l_down
- = readMutVarSST names_var
+getNameSupplyRn :: RnM s d RnNameSupply
+getNameSupplyRn rn_down l_down
+ = readMutVarSST (rn_ns rn_down)
-setNameSupplyRn :: GenRnNameSupply s -> RnM s d ()
-setNameSupplyRn names' (RnDown loc names_var errs_var occs_var) l_down
+setNameSupplyRn :: RnNameSupply -> RnM s d ()
+setNameSupplyRn names' (RnDown {rn_ns = names_var}) l_down
= writeMutVarSST names_var names'
--- The "instance-decl unique supply", inst, is really a map from class names
--- to unique supplies. Having per-class unique numbers for instance decls helps
--- the recompilation checker.
-newInstUniq :: FAST_STRING -> RnM s d Int
-newInstUniq cname (RnDown loc names_var errs_var occs_var) l_down
+-- See comments with RnNameSupply above.
+newInstUniq :: (OccName, OccName) -> RnM s d Int
+newInstUniq key (RnDown {rn_ns = names_var}) l_down
= readMutVarSST names_var `thenSST` \ (us, mapInst, cache) ->
- case lookupFM mapInst cname of
- Just class_us ->
- readMutVarSST class_us `thenSST` \ v ->
- writeMutVarSST class_us (v+1) `thenSST_`
- returnSST v
- Nothing -> -- first time caller gets to add a unique supply
- -- to the finite map for that class.
- newMutVarSST 1 `thenSST` \ class_us ->
- let
- mapInst' = addToFM mapInst cname class_us
- in
- writeMutVarSST names_var (us, mapInst', cache) `thenSST_`
- returnSST 0
-
+ let
+ uniq = case lookupFM mapInst key of
+ Just x -> x+1
+ Nothing -> 0
+ mapInst' = addToFM mapInst key uniq
+ in
+ writeMutVarSST names_var (us, mapInst', cache) `thenSST_`
+ returnSST uniq
+
+getUniqRn :: RnM s d Unique
+getUniqRn (RnDown {rn_ns = names_var}) l_down
+ = readMutVarSST names_var `thenSST` \ (us, mapInst, cache) ->
+ let
+ (us1,us') = splitUniqSupply us
+ in
+ writeMutVarSST names_var (us', mapInst, cache) `thenSST_`
+ returnSST (uniqFromSupply us1)
\end{code}
================ Occurrences =====================
\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)
+addOccurrenceName name (RnDown {rn_loc = loc, rn_occs = occs_var})
+ (SDown {rn_mode = mode})
| isLocallyDefinedName name ||
not_necessary necessity
= returnSST name
addOccurrenceNames :: [Name] -> RnMS s ()
-addOccurrenceNames names (RnDown loc names_var errs_var occs_var)
- (SDown rn_env local_env mod_name mode)
+addOccurrenceNames names (RnDown {rn_loc = loc, rn_occs = occs_var})
+ (SDown {rn_mode = mode})
| not_necessary necessity
= returnSST ()
not_necessary Compulsory = False
not_necessary Optional = opt_IgnoreIfacePragmas
-popOccurrenceName :: RnSMode -> RnM s d (Maybe Occurrence)
-popOccurrenceName mode (RnDown loc names_var errs_var occs_var) l_down
+popOccurrenceName :: RnMode -> RnM s d (Maybe Occurrence)
+popOccurrenceName mode (RnDown {rn_occs = occs_var}) l_down
= readMutVarSST occs_var `thenSST` \ occs ->
case (mode, occs) of
-- Find a compulsory occurrence
- (InterfaceMode Compulsory _, (comp:comps, opts))
+ (InterfaceMode 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
- (InterfaceMode Optional _, (comps, opt:opts))
- -> ASSERT( null comps )
+ (InterfaceMode Optional, (comps, opt:opts))
+ -> ASSERT2( null comps, ppr 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
+-- discardOccurrencesRn does the enclosed thing with a *fresh* occurrences
+-- variable, and discards 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
+discardOccurrencesRn :: RnM s d a -> RnM s d a
+discardOccurrencesRn enclosed_thing rn_down 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)
+ enclosed_thing (rn_down {rn_occs = new_occs_var}) l_down
\end{code}
+================ Module =====================
+
+\begin{code}
+getModuleRn :: RnM s d Module
+getModuleRn (RnDown {rn_mod = mod_name}) l_down
+ = returnSST mod_name
+
+setModuleRn :: Module -> RnM s d a -> RnM s d a
+setModuleRn new_mod enclosed_thing rn_down l_down
+ = enclosed_thing (rn_down {rn_mod = new_mod}) l_down
+\end{code}
+
+\begin{code}
+setOmitQualFn :: (Name -> Bool) -> RnM s d a -> RnM s d a
+setOmitQualFn fn m g_down l_down = m (g_down { rn_omit = fn }) l_down
+
+getOmitQualFn :: RnM s d (Name -> Bool)
+getOmitQualFn (RnDown {rn_omit = omit_fn}) l_down
+ = returnSST omit_fn
+\end{code}
+
%************************************************************************
%* *
\subsection{Plumbing for rename-source part}
================ RnEnv =====================
\begin{code}
--- Look in global env only
-lookupGlobalNameRn :: RdrName -> RnMS s (Maybe Name)
-lookupGlobalNameRn rdr_name rn_down (SDown (RnEnv global_env fixity_env) local_env mod_name mode)
- = case lookupFM global_env rdr_name of
- Just (name, _) -> returnSST (Just name)
- Nothing -> returnSST Nothing
-
--- Look in both local and global env
-lookupNameRn :: RdrName -> RnMS s (Maybe Name)
-lookupNameRn rdr_name rn_down (SDown (RnEnv global_env fixity_env) local_env mod_name mode)
- = case lookupFM local_env rdr_name of
- Just name -> returnSST (Just name)
- Nothing -> case lookupFM global_env rdr_name of
- Just (name, _) -> returnSST (Just name)
- Nothing -> returnSST Nothing
-
-getNameEnvs :: RnMS s (GlobalNameEnv, NameEnv)
-getNameEnvs rn_down (SDown (RnEnv global_env fixity_env) local_env mod_name mode)
+getNameEnvs :: RnMS s (GlobalRdrEnv, LocalRdrEnv)
+getNameEnvs rn_down (SDown {rn_genv = RnEnv global_env fixity_env, rn_lenv = local_env})
= returnSST (global_env, local_env)
-getLocalNameEnv :: RnMS s NameEnv
-getLocalNameEnv rn_down (SDown rn_env local_env mod_name mode)
+getLocalNameEnv :: RnMS s LocalRdrEnv
+getLocalNameEnv rn_down (SDown {rn_lenv = local_env})
= returnSST local_env
-setLocalNameEnv :: NameEnv -> RnMS s a -> RnMS s a
-setLocalNameEnv local_env' m rn_down (SDown rn_env local_env mod_name mode)
- = m rn_down (SDown rn_env local_env' mod_name mode)
+setLocalNameEnv :: LocalRdrEnv -> RnMS s a -> RnMS s a
+setLocalNameEnv local_env' m rn_down l_down
+ = m rn_down (l_down {rn_lenv = local_env'})
getFixityEnv :: RnMS s FixityEnv
-getFixityEnv rn_down (SDown (RnEnv name_env fixity_env) local_env mod_name mode)
+getFixityEnv rn_down (SDown {rn_genv = RnEnv name_env fixity_env})
= returnSST fixity_env
-\end{code}
-
-================ Module and Mode =====================
-\begin{code}
-getModuleRn :: RnMS s Module
-getModuleRn rn_down (SDown rn_env local_env mod_name mode)
- = returnSST mod_name
+extendFixityEnv :: [(Name, RenamedFixitySig)] -> RnMS s a -> RnMS s a
+extendFixityEnv fixes enclosed_scope
+ rn_down l_down@(SDown {rn_genv = RnEnv name_env fixity_env})
+ = let
+ new_fixity_env = extendNameEnv fixity_env fixes
+ in
+ enclosed_scope rn_down (l_down {rn_genv = RnEnv name_env new_fixity_env})
\end{code}
+================ Mode =====================
+
\begin{code}
-getModeRn :: RnMS s RnSMode
-getModeRn rn_down (SDown rn_env local_env mod_name mode)
+getModeRn :: RnMS s RnMode
+getModeRn rn_down (SDown {rn_mode = mode})
= returnSST 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 s a -> RnMS s 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 himap hibmap iface_var)
+getIfacesRn rn_down (GDown {rn_ifaces = iface_var})
= readMutVarSST iface_var
setIfacesRn :: Ifaces -> RnMG ()
-setIfacesRn ifaces rn_down (GDown himap hibmap iface_var)
+setIfacesRn ifaces rn_down (GDown {rn_ifaces = iface_var})
= writeMutVarSST iface_var ifaces
-getModuleHiMap :: IfaceFlavour -> RnMG ModuleHiMap
-getModuleHiMap as_source rn_down (GDown himap hibmap iface_var)
- = case as_source of
- HiBootFile -> returnSST hibmap
- _ -> returnSST himap
+getModuleHiMap :: Bool -> RnM s d ModuleHiMap
+getModuleHiMap want_hi_boot (RnDown {rn_hi_map = himap, rn_hiboot_map = hibmap}) _
+ | want_hi_boot = returnSST hibmap
+ | otherwise = returnSST himap
+\end{code}
+
+The interface file format is capable of distinguishing
+between normal imports/exports of names from other modules
+and 'hi-boot' mentions of names, with the flavour in the
+being encoded inside a @Module@.
+
+@setModuleFlavourRn@ fixes up @Module@ values containing
+normal flavours, returning a @Module@ value containing
+the attributes of the module that's in scope. The only
+attribute at the moment is the DLLness of a module, i.e.,
+whether the object code for that module resides in a
+Win32 DLL or not.
+
+\begin{code}
+setModuleFlavourRn :: Module -> RnM s d Module
+setModuleFlavourRn mod
+ | bootFlavour hif = returnRn mod
+ | otherwise =
+ getModuleHiMap (bootFlavour hif) `thenRn` \ himap ->
+ case (lookupFM himap mod_pstr) of
+ Nothing -> returnRn mod
+ Just (_, is_in_a_dll) ->
+ returnRn (setModuleFlavour (mkDynFlavour is_in_a_dll hif) mod)
+ where
+ mod_pstr = moduleString mod
+ hif = moduleIfaceFlavour mod
\end{code}
%************************************************************************
\begin{code}
-instance Outputable HowInScope where
- ppr (FromLocalDefn loc) = ptext SLIT("Defined at") <+> ppr loc
- ppr (FromImportDecl mod loc) = ptext SLIT("Imported from") <+> quotes (pprModule mod) <+>
- ptext SLIT("at") <+> ppr loc
-\end{code}
-
-
-\begin{code}
-modeToNecessity SourceMode = Compulsory
-modeToNecessity (InterfaceMode necessity _) = necessity
+modeToNecessity SourceMode = Compulsory
+modeToNecessity (InterfaceMode necessity) = necessity
\end{code}
projects / ghc-hetmet.git / blobdiff