data TcGblEnv Source
- tcg_mod :: Module
Module being compiled
- tcg_src :: HscSource
What kind of module (regular Haskell, hs-boot, ext-core)
- tcg_rdr_env :: GlobalRdrEnv
Top level envt; used during renaming
- tcg_default :: Maybe [Type]
Types used for defaulting.
Nothing => no
- tcg_fix_env :: FixityEnv
Just for things in this module
- tcg_field_env :: RecFieldEnv
Just for things in this module
- tcg_type_env :: TypeEnv
Global type env for the module we are compiling now. All
TyCons and Classes (for this module) end up in here right away,
along with their derived constructors, selectors.
(Ids defined in this module start in the local envt, though they
move to the global envt during zonking)
- tcg_type_env_var :: TcRef TypeEnv
- tcg_inst_env :: InstEnv
Instance envt for home-package modules; Includes the dfuns in
- tcg_fam_inst_env :: FamInstEnv
Ditto for family instances
- tcg_exports :: [AvailInfo]
What is exported
- tcg_imports :: ImportAvails
Information about what was imported from where, including
things bound in this module.
- tcg_dus :: DefUses
What is defined in this module and what is used.
The latter is used to generate
(a) version tracking; no need to recompile if these things have
not changed version stamp
(b) unused-import info
- tcg_keep :: TcRef NameSet
Locally-defined top-level names to keep alive.
Keep alive means give them an Exported flag, so that the
simplifier does not discard them as dead code, and so that they
are exposed in the interface file (but not to export to the
Some things, like dict-fun Ids and default-method Ids are born
with the Exported flag on, for exactly the above reason, but some
we only discover as we go. Specifically:
- The to/from functions for generic data types
- Top-level variables appearing free in the RHS of an orphan
- Top-level variables appearing free in a TH bracket
- tcg_th_used :: TcRef Bool
True = Template Haskell syntax used.
We need this so that we can generate a dependency on the
Template Haskell package, becuase the desugarer is going
to emit loads of references to TH symbols. The reference
is implicit rather than explicit, so we have to zap a
- tcg_th_splice_used :: TcRef Bool
True = A Template Haskell splice was used.
Splices disable recompilation avoidance (see #481)
- tcg_dfun_n :: TcRef OccSet
Allows us to choose unique DFun names.
- tcg_rn_exports :: Maybe [Located (IE Name)]
- tcg_rn_imports :: [LImportDecl Name]
- tcg_used_rdrnames :: TcRef (Set RdrName)
- tcg_rn_decls :: Maybe (HsGroup Name)
Renamed decls, maybe.
Nothing = Don't retain renamed
- tcg_ev_binds :: Bag EvBind
- tcg_binds :: LHsBinds Id
- tcg_sigs :: NameSet
- tcg_imp_specs :: [LTcSpecPrag]
- tcg_warns :: Warnings
- tcg_anns :: [Annotation]
- tcg_insts :: [Instance]
- tcg_fam_insts :: [FamInst]
- tcg_rules :: [LRuleDecl Id]
- tcg_fords :: [LForeignDecl Id]
- tcg_vects :: [LVectDecl Id]
- tcg_doc_hdr :: Maybe LHsDocString
Maybe Haddock header docs
- tcg_hpc :: AnyHpcUsage
True if any part of the
prog uses hpc instrumentation.
- tcg_main :: Maybe Name
The Name of the main
function, if this module is
the main module.
data ImportAvails Source
ImportAvails summarises what was imported from where, irrespective of
whether the imported things are actually used or not. It is used:
- when processing the export list,
- when constructing usage info for the interface file,
- to identify the list of directly imported modules for initialisation
purposes and for optimised overlap checking of family instances,
- when figuring out what things are really unused
- imp_mods :: ImportedMods
Domain is all directly-imported modules
ModuleName is what the module was imported as, e.g. in
import Foo as Bar
True => import was
import Foo ()
False => import was some other form
(a) to help construct the usage information in the interface
file; if we import somethign we need to recompile if the
export version changes
(b) to specify what child modules to initialise
We need a full ModuleEnv rather than a ModuleNameEnv here,
because we might be importing modules of the same name from
different packages. (currently not the case, but might be in the
- imp_dep_mods :: ModuleNameEnv (ModuleName, IsBootInterface)
Home-package modules needed by the module being compiled
It doesn't matter whether any of these dependencies
are actually used when compiling the module; they
are listed if they are below it at all. For
example, suppose M imports A which imports X. Then
compiling M might not need to consult X.hi, but X
is still listed in M's dependencies.
- imp_dep_pkgs :: [PackageId]
Packages needed by the module being compiled, whether directly,
or via other modules in this package, or via modules imported
from other packages.
- imp_trust_pkgs :: [PackageId]
This is strictly a subset of imp_dep_pkgs and records the
packages the current module needs to trust for Safe Haskell
compilation to succeed. A package is required to be trusted if
we are dependent on a trustworthy module in that package.
While perhaps making imp_dep_pkgs a tuple of (PackageId, Bool)
where True for the bool indicates the package is required to be
trusted is the more logical design, doing so complicates a lot
of code not concerned with Safe Haskell.
See Note [RnNames . Tracking Trust Transitively]
- imp_trust_own_pkg :: Bool
Do we require that our own package is trusted?
This is to handle efficiently the case where a Safe module imports
a Trustworthy module that resides in the same package as it.
See Note [RnNames . Trust Own Package]
- imp_orphs :: [Module]
Orphan modules below us in the import tree (and maybe including
us for imported modules)
- imp_finsts :: [Module]
Family instance modules below us in the import tree (and maybe
including us for imported modules)