)
import Name ( Name, OccName, NamedThing(..), getSrcLoc,
isLocallyDefinedName, nameModule, nameOccName,
- decode, mkLocalName, mkUnboundName, mkKnownKeyGlobal,
- NameEnv, lookupNameEnv, emptyNameEnv, unitNameEnv, extendNameEnvList
+ decode, mkLocalName, mkKnownKeyGlobal,
+ NameEnv, lookupNameEnv, emptyNameEnv, unitNameEnv,
+ extendNameEnvList
)
import Module ( Module, ModuleName, WhereFrom, moduleName )
import NameSet
import CmdLineOpts ( DynFlags, dopt_D_dump_rn_trace )
-import PrelInfo ( wiredInNames, knownKeyRdrNames )
-import SrcLoc ( SrcLoc, mkGeneratedSrcLoc )
+import SrcLoc ( SrcLoc, generatedSrcLoc )
import Unique ( Unique )
import FiniteMap ( FiniteMap, emptyFM, listToFM, plusFM )
import Bag ( Bag, mapBag, emptyBag, isEmptyBag, snocBag )
import UniqSupply
import Outputable
import CmFind ( Finder )
+import PrelNames ( mkUnboundName )
+import HscTypes ( GlobalSymbolTable, OrigNameEnv, AvailEnv,
+ WhetherHasOrphans, ImportVersion, ExportItem,
+ PersistentRenamerState(..), IsBootInterface, Avails,
+ DeclsMap, IfaceInsts, IfaceRules, DeprecationEnv,
+ HomeSymbolTable, PackageSymbolTable,
+ PersistentCompilerState(..), GlobalRdrEnv )
infixr 9 `thenRn`, `thenRn_`
\end{code}
-- Common part
data RnDown
= RnDown {
- rn_mod :: Module, -- This module
- rn_loc :: SrcLoc, -- Current locn
+ rn_mod :: Module, -- This module
+ rn_loc :: SrcLoc, -- Current locn
rn_finder :: Finder,
rn_dflags :: DynFlags,
- rn_gst :: GlobalSymbolTable, -- Both home modules and packages,
- -- at the moment we started compiling
- -- this module
+ rn_hst :: HomeSymbolTable,
rn_errs :: IORef (Bag WarnMsg, Bag ErrMsg),
- rn_ns :: IORef NameSupply,
+ rn_ns :: IORef (UniqSupply, OrigNameEnv),
rn_ifaces :: IORef Ifaces
}
-- We still need the unsullied global name env so that
-- we can look up record field names
- rn_fixenv :: FixityEnv -- Local fixities
+ rn_fixenv :: LocalFixityEnv -- Local fixities
-- The global fixities are held in the
-- rn_ifaces field. Why? See the comments
- -- with RnIfaces.lookupFixity
+ -- with RnIfaces.lookupLocalFixity
}
data RnMode = SourceMode -- Renaming source code
\begin{code}
--------------------------------
-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
-
---------------------------------
-type FixityEnv = NameEnv RenamedFixitySig
+type LocalRdrEnv = RdrNameEnv Name
+type LocalFixityEnv = NameEnv RenamedFixitySig
-- We keep the whole fixity sig so that we
-- can report line-number info when there is a duplicate
-- fixity declaration
-lookupFixity :: FixityEnv -> Name -> Fixity
-lookupFixity env name
+lookupLocalFixity :: LocalFixityEnv -> Name -> Fixity
+lookupLocalFixity env name
= case lookupNameEnv env name of
Just (FixitySig _ fix _) -> fix
Nothing -> defaultFixity
%===================================================
\begin{code}
-type ExportItem = (ModuleName, [RdrAvailInfo])
-
-type ImportVersion name = (ModuleName, WhetherHasOrphans, IsBootInterface, WhatsImported name)
-
-type ModVersionInfo = (Version, -- Version of the whole module
- Version, -- Version number for all fixity decls together
- Version) -- ...ditto all rules together
-
-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.
-
-type IsBootInterface = Bool
-
-data WhatsImported name = NothingAtAll -- The module is below us in the
- -- hierarchy, but we import nothing
-
- | Everything Version -- The module version
-
- | Specifically Version -- Module version
- Version -- Fixity version
- Version -- Rules version
- [(name,Version)] -- List guaranteed non-empty
- deriving( Eq )
- -- 'Specifically' doesn't let you say "I imported f but none of the fixities in
- -- the module". If you use anything in the module you get its fixity and rule version
- -- So if the fixities or rules change, you'll recompile, even if you don't use either.
- -- This is easy to implement, and it's safer: you might not have used the rules last
- -- time round, but if someone has added a new rule you might need it this time
-
- -- 'Everything' means there was a "module M" in
- -- this module's export list, so we just have to go by M's version,
- -- not the list of (name,version) pairs
data ParsedIface
= ParsedIface {
pi_rules :: (Version, [RdrNameRuleDecl]), -- Rules, with their version
pi_deprecs :: [RdrNameDeprecation] -- Deprecations
}
-
-
-type RdrNamePragma = () -- Fudge for now
--------------------
-
\end{code}
%************************************************************************
\begin{code}
data Ifaces = Ifaces {
-
- -- PERSISTENT FIELDS
- 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
- -- we can get away with importing them abstractly
-
- iInsts :: IfaceInsts,
+ -- PERSISTENT FIELDS
+ iPST :: PackageSymbolTable,
+ -- The ModuleDetails for modules in other packages
+ -- whose interfaces we have opened
+ -- The contents of those interface files may be mostly
+ -- in the iDecls, iInsts, iRules (below), but what *will*
+ -- be in the PackageSymbolTable is:
+ -- * The Module
+ -- * Version info
+ -- * Its exports
+ -- * Fixities
+ -- * Deprecations
+ -- This field is initialised from the compiler's persistent
+ -- package symbol table, and the renamer incrementally adds
+ -- to it.
+
+ iDecls :: DeclsMap,
+ -- A single, global map of Names to unslurped decls
+
+ iInsts :: IfaceInsts,
-- 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 :: IfaceRules,
+ iRules :: IfaceRules,
-- Similar to instance decls, only for rules
- -- SEMI-EPHEMERAL FIELDS
- -- iFixes and iDeprecs are accumulated here while one module
- -- is compiled, but are transferred to the package symbol table
- -- at the end. We don't add them to the table as we encounter them
- -- because doing so would require us to have a mutable symbol table
- -- which is yukky.
-
- iFixes :: FixityEnv, -- A single, global map of Names to fixities
- -- See comments with RnIfaces.lookupFixity
- iDeprecs :: DeprecationEnv,
-
- -- EPHEMERAL FIELDS
- -- These fields persist during the compilation of a single module only
+ -- EPHEMERAL FIELDS
+ -- These fields persist during the compilation of a single module only
+ 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.
- iSlurp :: NameSet,
+ 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)]
+ 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.
- }
-
-type ImportedModuleInfo
- = FiniteMap ModuleName (WhetherHasOrphans, IsBootInterface,
- Maybe (Module, Version, Version, Version, WhereFrom, Avails))
- -- The three Versions are module version, fixity version, rules version
-
- -- 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 ImportedModuleInfo = FiniteMap ModuleName
+ (WhetherHasOrphans, IsBootInterface, IsLoaded)
+type IsLoaded = Bool
\end{code}
%************************************************************************
\begin{code}
-initRn :: DynFlags -> Finder -> GlobalSymbolTable
- -> PersistentRenamerState
+initRn :: DynFlags -> Finder -> HomeSymbolTable
+ -> PersistentCompilerState
-> Module -> SrcLoc
-
-initRn dflags finder gst prs mod loc do_rn = do
- names_var <- newIORef (prsNS pcs)
- errs_var <- newIORef (emptyBag,emptyBag)
- iface_var <- newIORef (initIfaces prs)
- let
- rn_down = RnDown { rn_mod = mod,
- rn_loc = loc,
-
- rn_finder = finder,
- rn_dflags = dflags,
- rn_gst = gst,
-
- rn_ns = names_var,
- rn_errs = errs_var,
- rn_ifaces = iface_var,
- }
-
+ -> RnMG t
+ -> IO (t, PersistentCompilerState, (Bag WarnMsg, Bag ErrMsg))
+
+initRn dflags finder hst pcs mod loc do_rn
+ = do
+ let prs = pcs_PRS pcs
+ uniqs <- mkSplitUniqSupply 'r'
+ names_var <- newIORef (uniqs, prsOrig prs)
+ errs_var <- newIORef (emptyBag,emptyBag)
+ iface_var <- newIORef (initIfaces pcs)
+ let rn_down = RnDown { rn_mod = mod,
+ rn_loc = loc,
+
+ rn_finder = finder,
+ rn_dflags = dflags,
+ rn_hst = hst,
+
+ rn_ns = names_var,
+ rn_errs = errs_var,
+ rn_ifaces = iface_var,
+ }
+
-- do the business
- res <- do_rn rn_down ()
-
- -- grab errors and return
- (warns, errs) <- readIORef errs_var
-
- return (res, errs, warns)
+ res <- do_rn rn_down ()
+
+ -- Grab state and record it
+ (warns, errs) <- readIORef errs_var
+ new_ifaces <- readIORef iface_var
+ (_, new_orig) <- readIORef names_var
+
+ let new_prs = prs { prsOrig = new_orig,
+ prsDecls = iDecls new_ifaces,
+ prsInsts = iInsts new_ifaces,
+ prsRules = iRules new_ifaces }
+ let new_pcs = pcs { pcs_PST = iPST new_ifaces,
+ pcs_PRS = new_prs }
+
+ return (res, new_pcs, (warns, errs))
-initIfaces :: PersistentRenamerState -> Ifaces
-initIfaces prs
- = Ifaces { iDecls = prsDecls prs,
+initIfaces :: PersistentCompilerState -> Ifaces
+initIfaces (PCS { pcs_PST = pst, pcs_PRS = prs })
+ = Ifaces { iPST = pst,
+ iDecls = prsDecls prs,
iInsts = prsInsts prs,
- iRules = prsRules rules,
-
- iFixes = emptyNameEnv,
- iDeprecs = emptyNameEnv,
+ iRules = prsRules prs,
iImpModInfo = emptyFM,
- iDeferred = emptyNameSet,
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,
}
-initRnMS :: GlobalRdrEnv -> FixityEnv -> RnMode -> RnMS r -> RnM d r
+initRnMS :: GlobalRdrEnv -> LocalFixityEnv -> RnMode -> RnMS r -> RnM d r
initRnMS rn_env fixity_env mode thing_inside rn_down g_down
= let
s_down = SDown { rn_genv = rn_env, rn_lenv = emptyRdrEnv,
= initRnMS emptyRdrEnv emptyNameEnv InterfaceMode $
setModuleRn mod thing_inside
-builtins :: FiniteMap (ModuleName,OccName) Name
-builtins = listToFM wired_in `plusFM` listToFM known_key
- where
- wired_in = [ ((moduleName (nameModule name), nameOccName name), name)
- | name <- wiredInNames ]
-
- known_key = [ ((rdrNameModule rdr_name, rdrNameOcc rdr_name), mkKnownKeyGlobal rdr_name uniq)
- | (rdr_name, uniq) <- knownKeyRdrNames ]
\end{code}
@renameSourceCode@ is used to rename stuff ``out-of-line'';
-- only do any I/O if we need to read in a fixity declaration;
-- and that doesn't happen in pragmas etc
- newIORef name_supply >>= \ names_var ->
- newIORef (emptyBag,emptyBag) >>= \ errs_var ->
+ mkSplitUniqSupply 'r' >>= \ new_us ->
+ newIORef (new_us, prsOrig prs) >>= \ names_var ->
+ newIORef (emptyBag,emptyBag) >>= \ errs_var ->
let
rn_down = RnDown { rn_dflags = dflags,
- rn_loc = mkGeneratedSrcLoc, rn_ns = names_var,
+ rn_loc = generatedSrcLoc, rn_ns = names_var,
rn_errs = errs_var,
rn_mod = mod,
rn_ifaces = panic "rnameSourceCode: rn_ifaces" -- Not required
\end{code}
%================
-\subsubsection{ Name supply}
+\subsubsection{The finder and home symbol table}
%=====================
\begin{code}
-getNameSupplyRn :: RnM d NameSupply
+getFinderRn :: RnM d Finder
+getFinderRn down l_down = return (rn_finder down)
+
+getHomeSymbolTableRn :: RnM d HomeSymbolTable
+getHomeSymbolTableRn down l_down = return (rn_hst down)
+\end{code}
+
+%================
+\subsubsection{Name supply}
+%=====================
+
+\begin{code}
+getNameSupplyRn :: RnM d (UniqSupply, OrigNameEnv)
getNameSupplyRn rn_down l_down
= readIORef (rn_ns rn_down)
-setNameSupplyRn :: NameSupply -> RnM d ()
+setNameSupplyRn :: (UniqSupply, OrigNameEnv) -> RnM d ()
setNameSupplyRn names' (RnDown {rn_ns = names_var}) l_down
= writeIORef names_var names'
getUniqRn :: RnM d Unique
getUniqRn (RnDown {rn_ns = names_var}) l_down
- = readIORef names_var >>= \ (us, cache, ipcache) ->
+ = readIORef names_var >>= \ (us, {-cache,-} ipcache) ->
let
(us1,us') = splitUniqSupply us
in
- writeIORef names_var (us', cache, ipcache) >>
+ writeIORef names_var (us', {-cache,-} ipcache) >>
return (uniqFromSupply us1)
\end{code}
%=====================
\begin{code}
-getNameEnvs :: RnMS (GlobalRdrEnv, LocalRdrEnv)
-getNameEnvs rn_down (SDown {rn_genv = global_env, rn_lenv = local_env})
- = return (global_env, local_env)
-
getLocalNameEnv :: RnMS LocalRdrEnv
getLocalNameEnv rn_down (SDown {rn_lenv = local_env})
= return local_env
setLocalNameEnv local_env' m rn_down l_down
= m rn_down (l_down {rn_lenv = local_env'})
-getFixityEnv :: RnMS FixityEnv
+getFixityEnv :: RnMS LocalFixityEnv
getFixityEnv rn_down (SDown {rn_fixenv = fixity_env})
= return fixity_env
projects / ghc-hetmet.git / blobdiff