ModuleGraph, emptyMG,
ModDetails(..), emptyModDetails,
- ModGuts(..), ModImports(..), ForeignStubs(..),
+ ModGuts(..), CgGuts(..), ModImports(..), ForeignStubs(..),
ModSummary(..), showModMsg, isBootSummary,
msHsFilePath, msHiFilePath, msObjFilePath,
WhetherHasOrphans, IsBootInterface, Usage(..),
Dependencies(..), noDependencies,
- InstPool, Gated, addInstsToPool,
- RulePool, addRulesToPool,
NameCache(..), OrigNameCache, OrigIParamCache,
Avails, availsToNameSet, availName, availNames,
GenAvailInfo(..), AvailInfo, RdrAvailInfo,
Deprecations, DeprecTxt, lookupDeprec, plusDeprecs,
- InstEnv, DFunId,
PackageInstEnv, PackageRuleBase,
-- Linker stuff
import OccName ( OccName, OccEnv, lookupOccEnv, mkOccEnv, emptyOccEnv,
extendOccEnv )
import Module
-import InstEnv ( InstEnv, DFunId )
+import InstEnv ( InstEnv, Instance )
import Rules ( RuleBase )
import CoreSyn ( CoreBind )
import Id ( Id )
import IfaceSyn ( IfaceInst, IfaceRule, IfaceDecl(ifName) )
import FiniteMap ( FiniteMap )
-import CoreSyn ( IdCoreRule )
+import CoreSyn ( CoreRule )
import Maybes ( orElse, fromJust, expectJust )
import Outputable
import SrcLoc ( SrcSpan )
-- module. If so, use this instead of the file contents (this
-- is for use in an IDE where the file hasn't been saved by
-- the user yet).
-data Target = Target TargetId (Maybe StringBuffer)
+data Target = Target TargetId (Maybe (StringBuffer,ClockTime))
data TargetId
- = TargetModule Module -- | A module name: search for the file
- | TargetFile FilePath -- | A filename: parse it to find the module name.
-
+ = TargetModule Module -- ^ A module name: search for the file
+ | TargetFile FilePath -- ^ A filename: parse it to find the module name.
+ deriving Eq
pprTarget :: Target -> SDoc
pprTarget (Target id _) = pprTargetId id
\begin{code}
-hptInstances :: HscEnv -> (Module -> Bool) -> [DFunId]
+hptInstances :: HscEnv -> (Module -> Bool) -> [Instance]
-- Find all the instance declarations that are in modules imported
-- by this one, directly or indirectly, and are in the Home Package Table
-- This ensures that we don't see instances from modules --make compiled
-- before this one, but which are not below this one
hptInstances hsc_env want_this_module
- = [ dfun
+ = [ ispec
| mod_info <- moduleEnvElts (hsc_HPT hsc_env)
, want_this_module (mi_module (hm_iface mod_info))
- , dfun <- md_insts (hm_details mod_info) ]
+ , ispec <- md_insts (hm_details mod_info) ]
-hptRules :: HscEnv -> [(Module, IsBootInterface)] -> [IdCoreRule]
+hptRules :: HscEnv -> [(Module, IsBootInterface)] -> [CoreRule]
-- Get rules from modules "below" this one (in the dependency sense)
-- C.f Inst.hptInstances
hptRules hsc_env deps
data ModDetails
= ModDetails {
-- The next three fields are created by the typechecker
+ md_exports :: NameSet,
md_types :: !TypeEnv,
- md_insts :: ![DFunId], -- Dfun-ids for the instances in this module
- md_rules :: ![IdCoreRule] -- Domain may include Ids from other modules
+ md_insts :: ![Instance], -- Dfun-ids for the instances in this module
+ md_rules :: ![CoreRule] -- Domain may include Ids from other modules
}
emptyModDetails = ModDetails { md_types = emptyTypeEnv,
+ md_exports = emptyNameSet,
md_insts = [],
md_rules = [] }
mg_deprecs :: !Deprecations, -- Deprecations declared in the module
mg_types :: !TypeEnv,
- mg_insts :: ![DFunId], -- Instances
- mg_rules :: ![IdCoreRule], -- Rules from this module
+ mg_insts :: ![Instance], -- Instances
+ mg_rules :: ![CoreRule], -- Rules from this module
mg_binds :: ![CoreBind], -- Bindings for this module
mg_foreign :: !ForeignStubs
}
-- After simplification, the following fields change slightly:
-- mg_rules Orphan rules only (local ones now attached to binds)
-- mg_binds With rules attached
---
--- After CoreTidy, the following fields change slightly:
--- mg_types Now contains Ids as well, replete with final IdInfo
--- The Ids are only the ones that are visible from
--- importing modules. Without -O that means only
--- exported Ids, but with -O importing modules may
--- see ids mentioned in unfoldings of exported Ids
---
--- mg_insts Same DFunIds as before, but with final IdInfo,
--- and the unique might have changed; remember that
--- CoreTidy links up the uniques of old and new versions
---
--- mg_rules All rules for exported things, substituted with final Ids
---
--- mg_binds Tidied
+---------------------------------------------------------
+-- The Tidy pass forks the information about this module:
+-- * one lot goes to interface file generation (ModIface)
+-- and later compilations (ModDetails)
+-- * the other lot goes to code generation (CgGuts)
+data CgGuts
+ = CgGuts {
+ cg_module :: !Module,
+
+ cg_tycons :: [TyCon], -- Algebraic data types (including ones that started life
+ -- as classes); generate constructors and info tables
+ -- Includes newtypes, just for the benefit of External Core
+
+ cg_binds :: [CoreBind], -- The tidied main bindings, including previously-implicit
+ -- bindings for record and class selectors, and
+ -- data construtor wrappers.
+ -- But *not* data constructor workers; reason: we
+ -- we regard them as part of the code-gen of tycons
+
+ cg_dir_imps :: ![Module], -- Directly-imported modules; used to generate
+ -- initialisation code
+
+ cg_foreign :: !ForeignStubs,
+ cg_dep_pkgs :: ![PackageId] -- Used to generate #includes for C code gen
+ }
+-----------------------------------
data ModImports
= ModImports {
imp_direct :: ![(Module,Bool)], -- Explicitly-imported modules
-- directly or indirectly
}
+-----------------------------------
data ForeignStubs = NoStubs
| ForeignStubs
SDoc -- Header file prototypes for
-- The ModuleIFaces for modules in external packages
-- whose interfaces we have opened
-- The declarations in these interface files are held in
- -- eps_decls, eps_insts, eps_rules (below), not in the
+ -- eps_decls, eps_inst_env, eps_rules (below), not in the
-- mi_decls fields of the iPIT.
-- What _is_ in the iPIT is:
-- * The Module
-- all the external-package modules
eps_rule_base :: !PackageRuleBase, -- Ditto RuleEnv
-
- -- Holding pens for stuff that has been read in from file,
- -- but not yet slurped into the renamer
- eps_insts :: !InstPool,
- -- The as-yet un-slurped instance decls
- -- Decls move from here to eps_inst_env
- -- Each instance is 'gated' by the names that must be
- -- available before this instance decl is needed.
-
- eps_rules :: !RulePool,
- -- The as-yet un-slurped rules
-
eps_stats :: !EpsStats
}
, n_decls_in, n_decls_out
, n_rules_in, n_rules_out
, n_insts_in, n_insts_out :: !Int }
+
+addEpsInStats :: EpsStats -> Int -> Int -> Int -> EpsStats
+-- Add stats for one newly-read interface
+addEpsInStats stats n_decls n_insts n_rules
+ = stats { n_ifaces_in = n_ifaces_in stats + 1
+ , n_decls_in = n_decls_in stats + n_decls
+ , n_insts_in = n_insts_in stats + n_insts
+ , n_rules_in = n_rules_in stats + n_rules }
\end{code}
The NameCache makes sure that there is just one Unique assigned for
interface file); so we give it 'noSrcLoc' then. Later, when we find
its binding site, we fix it up.
-Exactly the same is true of the Module stored in the Name. When we first
-encounter the occurrence, we may not know the details of the module, so
-we just store junk. Then when we find the binding site, we fix it up.
-
\begin{code}
data NameCache
= NameCache { nsUniqs :: UniqSupply,
type OrigIParamCache = FiniteMap (IPName OccName) (IPName Name)
\end{code}
-\begin{code}
-type Gated d = ([Name], (Module, SDoc, d))
- -- The [Name] 'gate' the declaration; always non-empty
- -- Module records which module this decl belongs to
- -- SDoc records the pathname of the file, or similar err-ctxt info
-
-type RulePool = [Gated IfaceRule]
-
-addRulesToPool :: RulePool
- -> [Gated IfaceRule]
- -> RulePool
-addRulesToPool rules new_rules = new_rules ++ rules
-
--------------------------
-addEpsInStats :: EpsStats -> Int -> Int -> Int -> EpsStats
--- Add stats for one newly-read interface
-addEpsInStats stats n_decls n_insts n_rules
- = stats { n_ifaces_in = n_ifaces_in stats + 1
- , n_decls_in = n_decls_in stats + n_decls
- , n_insts_in = n_insts_in stats + n_insts
- , n_rules_in = n_rules_in stats + n_rules }
-
--------------------------
-type InstPool = NameEnv [Gated IfaceInst]
- -- The key of the Pool is the Class
- -- The Names are the TyCons in the instance head
- -- For example, suppose this is in an interface file
- -- instance C T where ...
- -- We want to slurp this decl if both C and T are "visible" in
- -- the importing module. See "The gating story" in RnIfaces for details.
-
-
-addInstsToPool :: InstPool -> [(Name, Gated IfaceInst)] -> InstPool
-addInstsToPool insts new_insts
- = foldr add insts new_insts
- where
- add :: (Name, Gated IfaceInst) -> NameEnv [Gated IfaceInst] -> NameEnv [Gated IfaceInst]
- add (cls,new_inst) insts = extendNameEnv_C combine insts cls [new_inst]
- where
- combine old_insts _ = new_inst : old_insts
-\end{code}
%************************************************************************
projects / ghc-hetmet.git / blobdiff