import HsSyn
import RdrHsSyn
import RnHsSyn ( RenamedFixitySig )
+import HscTypes ( AvailEnv, lookupType,
+ OrigNameEnv(..), OrigNameNameEnv, OrigNameIParamEnv,
+ WhetherHasOrphans, ImportVersion,
+ PersistentRenamerState(..), IsBootInterface, Avails,
+ DeclsMap, IfaceInsts, IfaceRules,
+ HomeSymbolTable, TyThing,
+ PersistentCompilerState(..), GlobalRdrEnv,
+ HomeIfaceTable, PackageIfaceTable,
+ RdrAvailInfo )
import BasicTypes ( Version, defaultFixity )
import ErrUtils ( addShortErrLocLine, addShortWarnLocLine,
pprBagOfErrors, ErrMsg, WarnMsg, Message
)
import RdrName ( RdrName, dummyRdrVarName, rdrNameModule, rdrNameOcc,
RdrNameEnv, emptyRdrEnv, extendRdrEnv,
- lookupRdrEnv, addListToRdrEnv, rdrEnvToList, rdrEnvElts
+ addListToRdrEnv, rdrEnvToList, rdrEnvElts
)
import Name ( Name, OccName, NamedThing(..), getSrcLoc,
- isLocallyDefinedName, nameModule, nameOccName,
- decode, mkLocalName, mkKnownKeyGlobal,
- NameEnv, lookupNameEnv, emptyNameEnv, unitNameEnv,
- extendNameEnvList
+ nameOccName,
+ decode, mkLocalName, mkKnownKeyGlobal
)
-import Module ( Module, ModuleName, WhereFrom, moduleName )
+import Name ( NameEnv, lookupNameEnv, emptyNameEnv, unitNameEnv, extendNameEnvList )
+import Module ( Module, ModuleName, ModuleSet, emptyModuleSet )
import NameSet
-import CmdLineOpts ( DynFlags, dopt_D_dump_rn_trace )
-import SrcLoc ( SrcLoc, mkGeneratedSrcLoc )
+import CmdLineOpts ( DynFlags, DynFlag(..), dopt )
+import SrcLoc ( SrcLoc, generatedSrcLoc, noSrcLoc )
import Unique ( Unique )
-import FiniteMap ( FiniteMap, emptyFM, listToFM, plusFM )
-import Bag ( Bag, mapBag, emptyBag, isEmptyBag, snocBag )
+import FiniteMap ( FiniteMap, emptyFM )
+import Bag ( Bag, 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 )
+import ErrUtils ( printErrorsAndWarnings )
infixr 9 `thenRn`, `thenRn_`
\end{code}
ioToRnM io rn_down g_down = (io >>= \ ok -> return (Right ok))
`catch`
(\ err -> return (Left err))
+
+ioToRnM_no_fail :: IO r -> RnM d r
+ioToRnM_no_fail io rn_down g_down
+ = (io >>= \ ok -> return ok)
+ `catch`
+ (\ err -> panic "ioToRnM_no_fail: the I/O operation failed!")
traceRn :: SDoc -> RnM d ()
traceRn msg
- = doptsRn dopt_D_dump_rn_trace `thenRn` \b ->
+ = doptRn Opt_D_dump_rn_trace `thenRn` \b ->
if b then putDocRn msg else returnRn ()
putDocRn :: SDoc -> RnM d ()
-- 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_hst :: HomeSymbolTable,
+
+ rn_hit :: HomeIfaceTable,
+ rn_done :: Name -> Maybe TyThing, -- Tells what things (both in the
+ -- home package and other packages)
+ -- were already available (i.e. in
+ -- the relevant SymbolTable) before
+ -- compiling this module
+ -- The Name passed to rn_done is guaranteed to be a Global,
+ -- so it has a Module, so it can be looked up
rn_errs :: IORef (Bag WarnMsg, Bag ErrMsg),
- rn_ns :: IORef (UniqSupply, OrigNameEnv),
+
+ -- The second and third components are a flattened-out OrigNameEnv
+ rn_ns :: IORef (UniqSupply, OrigNameNameEnv, OrigNameIParamEnv),
rn_ifaces :: IORef Ifaces
}
data SDown = SDown {
rn_mode :: RnMode,
- rn_genv :: GlobalRdrEnv, -- Global envt
+ rn_genv :: GlobalRdrEnv, -- Top level environment
rn_lenv :: LocalRdrEnv, -- Local name envt
-- Does *not* include global name envt; may shadow it
-- 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 (for non-top-level
+ -- declarations)
-- The global fixities are held in the
- -- rn_ifaces field. Why? See the comments
- -- with RnIfaces.lookupFixity
+ -- HIT or PIT. Why? See the comments
+ -- 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 IfaceDeprecs = Maybe (Either DeprecTxt [(RdrName,DeprecTxt)])
+ -- Nothing => NoDeprecs
+ -- Just (Left t) => DeprecAll
+ -- Just (Right p) => DeprecSome
data ParsedIface
= ParsedIface {
pi_vers :: Version, -- Module version number
pi_orphan :: WhetherHasOrphans, -- Whether this module has orphans
pi_usages :: [ImportVersion OccName], -- Usages
- pi_exports :: [ExportItem], -- Exports
+ pi_exports :: (Version, [ExportItem]), -- Exports
+ pi_decls :: [(Version, RdrNameTyClDecl)], -- Local definitions
+ pi_fixity :: [RdrNameFixitySig], -- Local fixity declarations,
pi_insts :: [RdrNameInstDecl], -- Local instance declarations
- pi_decls :: [(Version, RdrNameHsDecl)], -- Local definitions
- pi_fixity :: (Version, [RdrNameFixitySig]), -- Local fixity declarations, with their version
pi_rules :: (Version, [RdrNameRuleDecl]), -- Rules, with their version
- pi_deprecs :: [RdrNameDeprecation] -- Deprecations
+ pi_deprecs :: IfaceDeprecs -- Deprecations
}
\end{code}
\begin{code}
data Ifaces = Ifaces {
-- PERSISTENT FIELDS
- iPST :: PackageSymbolTable,
- -- The ModuleDetails for modules in other packages
+ iPIT :: PackageIfaceTable,
+ -- The ModuleIFaces 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 declarations in these interface files are held in
+ -- iDecls, iInsts, iRules (below), not in the mi_decls fields
+ -- of the iPIT. What _is_ in the iPIT is:
-- * The Module
-- * Version info
-- * Its exports
-- * Fixities
-- * Deprecations
- -- This field is initialised from the compiler's persistent
+ -- The iPIT field is initialised from the compiler's persistent
-- package symbol table, and the renamer incrementally adds
-- to it.
-- 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
+ iVSlurp :: (ModuleSet, NameSet)
+ -- The Names are all the (a) non-wired-in
+ -- (b) "big"
+ -- (c) non-locally-defined
+ -- (d) home-package
-- 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.
+ -- The module set is the non-home-package modules from which we have
+ -- slurped at least one name.
+ -- It's worth keeping separately, because there's no very easy
+ -- way to distinguish the "big" names from the "non-big" ones.
+ -- But this is a decision we might want to revisit.
}
-type ImportedModuleInfo
- = FiniteMap ModuleName (WhetherHasOrphans, IsBootInterface)
-
- -- 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)
+ -- Contains info ONLY about modules that have not yet
+ --- been loaded into the iPIT
\end{code}
%************************************************************************
\begin{code}
-initRn :: DynFlags -> Finder -> HomeSymbolTable
+initRn :: DynFlags
+ -> HomeIfaceTable -> HomeSymbolTable
-> PersistentCompilerState
- -> Module -> SrcLoc
+ -> Module
-> RnMG t
- -> IO (t, (Bag WarnMsg, Bag ErrMsg))
-
-initRn dflags finder hst pcs mod loc do_rn
- = do 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, (warns, errs))
-
-
-initIfaces :: PersistentCompilerState -> Ifaces
-initIfaces (PCS { pcsPST = pst, psrPRS = prs })
- = Ifaces { iPST = pst,
- iDecls = prsDecls prs,
- iInsts = prsInsts prs,
- iRules = prsRules prs,
-
- iImpModInfo = emptyFM,
- 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 = []
- }
-
-
-initRnMS :: GlobalRdrEnv -> FixityEnv -> RnMode -> RnMS r -> RnM d r
+ -> IO (PersistentCompilerState, Bool, t)
+ -- True <=> found errors
+
+initRn dflags hit hst pcs mod do_rn
+ = do
+ let prs = pcs_PRS pcs
+ let pte = pcs_PTE pcs
+ let ifaces = Ifaces { iPIT = pcs_PIT pcs,
+ iDecls = prsDecls prs,
+ iInsts = prsInsts prs,
+ iRules = prsRules prs,
+
+ iImpModInfo = emptyFM,
+ 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 = (emptyModuleSet, emptyNameSet)
+ }
+ let uniqs = prsNS prs
+
+ names_var <- newIORef (uniqs, origNames (prsOrig prs),
+ origIParam (prsOrig prs))
+ errs_var <- newIORef (emptyBag,emptyBag)
+ iface_var <- newIORef ifaces
+ let rn_down = RnDown { rn_mod = mod,
+ rn_loc = noSrcLoc,
+
+ rn_dflags = dflags,
+ rn_hit = hit,
+ rn_done = lookupType hst pte,
+
+ rn_ns = names_var,
+ rn_errs = errs_var,
+ rn_ifaces = iface_var,
+ }
+
+ -- do the business
+ res <- do_rn rn_down ()
+
+ -- Grab state and record it
+ (warns, errs) <- readIORef errs_var
+ new_ifaces <- readIORef iface_var
+ (new_NS, new_origN, new_origIP) <- readIORef names_var
+ let new_orig = Orig { origNames = new_origN, origIParam = new_origIP }
+ let new_prs = prs { prsOrig = new_orig,
+ prsDecls = iDecls new_ifaces,
+ prsInsts = iInsts new_ifaces,
+ prsRules = iRules new_ifaces,
+ prsNS = new_NS }
+ let new_pcs = pcs { pcs_PIT = iPIT new_ifaces,
+ pcs_PRS = new_prs }
+
+ -- Check for warnings
+ printErrorsAndWarnings (warns, errs) ;
+
+ return (new_pcs, not (isEmptyBag errs), res)
+
initRnMS rn_env fixity_env mode thing_inside rn_down g_down
+ -- The fixity_env appears in both the rn_fixenv field
+ -- and in the HIT. See comments with RnHiFiles.lookupFixityRn
= let
s_down = SDown { rn_genv = rn_env, rn_lenv = emptyRdrEnv,
rn_fixenv = fixity_env, rn_mode = mode }
initIfaceRnMS mod thing_inside
= initRnMS emptyRdrEnv emptyNameEnv InterfaceMode $
setModuleRn mod thing_inside
-
\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
- mkSplitUniqSupply 'r' >>= \ new_us ->
- newIORef (new_us, prsOrig prs) >>= \ names_var ->
- newIORef (emptyBag,emptyBag) >>= \ errs_var ->
+ mkSplitUniqSupply 'r' >>= \ new_us ->
+ newIORef (new_us, origNames (prsOrig prs),
+ origIParam (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
+ rn_done = bogus "rn_done", rn_hit = bogus "rn_hit",
+ rn_ifaces = bogus "rn_ifaces"
}
s_down = SDown { rn_mode = InterfaceMode,
-- So that we can refer to PrelBase.True etc
where
display errs = pprBagOfErrors errs
+bogus s = panic ("rnameSourceCode: " ++ s) -- Used for unused record fields
+
{-# INLINE thenRn #-}
{-# INLINE thenRn_ #-}
{-# INLINE returnRn #-}
= readIORef errs_var >>= \ (warns,errs) ->
return (isEmptyBag errs)
-doptsRn :: (DynFlags -> Bool) -> RnM d Bool
-doptsRn dopt (RnDown { rn_dflags = dflags}) l_down
- = return (dopt dflags)
+doptRn :: DynFlag -> RnM d Bool
+doptRn dflag (RnDown { rn_dflags = dflags}) l_down
+ = return (dopt dflag dflags)
+
+getDOptsRn :: RnM d DynFlags
+getDOptsRn (RnDown { rn_dflags = dflags}) l_down
+ = return dflags
\end{code}
%================
-\subsubsection{ Source location}
+\subsubsection{Source location}
%=====================
\begin{code}
\end{code}
%================
-\subsubsection{The finder}
+\subsubsection{The finder and home symbol table}
%=====================
\begin{code}
-getFinderRn :: RnM d Finder
-getFinderRn down l_down = return (rn_finder down)
+getHomeIfaceTableRn :: RnM d HomeIfaceTable
+getHomeIfaceTableRn down l_down = return (rn_hit down)
+
+getTypeEnvRn :: RnM d (Name -> Maybe TyThing)
+getTypeEnvRn down l_down = return (rn_done down)
\end{code}
%================
%=====================
\begin{code}
-getNameSupplyRn :: RnM d (UniqSupply, OrigNameEnv)
+getNameSupplyRn :: RnM d (UniqSupply, OrigNameNameEnv, OrigNameIParamEnv)
getNameSupplyRn rn_down l_down
= readIORef (rn_ns rn_down)
-setNameSupplyRn :: (UniqSupply, OrigNameEnv) -> RnM d ()
+setNameSupplyRn :: (UniqSupply, OrigNameNameEnv, OrigNameIParamEnv) -> 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