GHC.Tc.Types

Various types used during typechecking.

Please see GHC.Tc.Utils.Monad as well for operations on these types. You probably want to import it, instead of this module.

All the monads exported here are built on top of the same IOEnv monad. The monad functions like a Reader monad in the way it passes the environment around. This is done to allow the environment to be manipulated in a stack like fashion when entering expressions... etc.

For state that is global and should be returned at the end (e.g not part of the stack mechanism), you should use a TcRef (= IORef) to store them.

Documentation

type TcRnIf a b = IOEnv (Env a b)

type TcRn = TcRnIf TcGblEnv TcLclEnv

type TcM = TcRn

Historical "type-checking monad" (now it's just TcRn).

type RnM = TcRn

Historical "renaming monad" (now it's just TcRn).

type IfM lcl = TcRnIf IfGblEnv lcl

type IfL = IfM IfLclEnv

type IfG = IfM ()

type TcRef a = IORef a

Type alias for IORef; the convention is we'll use this for mutable bits of data in TcGblEnv which are updated during typechecking and returned at the end.

data Env gbl lcl

Constructors

Env

Fields

• env_top :: !HscEnv
• env_um :: !Char
• env_gbl :: gbl
• env_lcl :: lcl

Instances

ContainsHooks (Env gbl lcl)

Defined in GHC.Tc.Types

Methods

extractHooks :: Env gbl lcl -> Hooks

ContainsDynFlags (Env gbl lcl)

Defined in GHC.Tc.Types

Methods

extractDynFlags :: Env gbl lcl -> DynFlags

ContainsModule gbl => ContainsModule (Env gbl lcl)

Defined in GHC.Tc.Types

Methods

extractModule :: Env gbl lcl -> Module

ContainsLogger (Env gbl lcl)

Defined in GHC.Tc.Types

Methods

extractLogger :: Env gbl lcl -> Logger

data TcGblEnv

TcGblEnv describes the top-level of the module at the point at which the typechecker is finished work. It is this structure that is handed on to the desugarer For state that needs to be updated during the typechecking phase and returned at end, use a TcRef (= IORef).

Constructors

TcGblEnv

Fields

• tcg_mod :: Module

  Module being compiled

• tcg_semantic_mod :: Module

  If a signature, the backing module See also Note [Identity versus semantic module]

• tcg_src :: HscSource

  What kind of module (regular Haskell, hs-boot, hsig)

• tcg_rdr_env :: GlobalRdrEnv

  Top level envt; used during renaming

• tcg_default :: Maybe [Type]

  Types used for defaulting. Nothing => no default decl

• tcg_fix_env :: FixityEnv

  Just for things in this module

• tcg_field_env :: RecFieldEnv

  Just for things in this module See Note [The interactive package] in GHC.Runtime.Context

• 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)

  NB: for what "things in this module" means, see Note [The interactive package] in GHC.Runtime.Context

• tcg_type_env_var :: KnotVars (IORef TypeEnv)
• tcg_inst_env :: !InstEnv

  Instance envt for all home-package modules; Includes the dfuns in tcg_insts NB. BangPattern is to fix a leak, see #15111

• tcg_fam_inst_env :: !FamInstEnv

  Ditto for family instances NB. BangPattern is to fix a leak, see #15111

• tcg_ann_env :: AnnEnv

  And for annotations

• tcg_exports :: [AvailInfo]

  What is exported

• tcg_imports :: ImportAvails

  Information about what was imported from where, including things bound in this module. Also store Safe Haskell info here about transitive trusted package requirements.

  There are not many uses of this field, so you can grep for all them.

  The ImportAvails records information about the following things:

  1. All of the modules you directly imported (tcRnImports)
  2. The orphans (only!) of all imported modules in a GHCi session (runTcInteractive)
  3. The module that instantiated a signature
  4. Each of the signatures that merged in

  It is used in the following ways: - imp_orphs is used to determine what orphan modules should be visible in the context (tcVisibleOrphanMods) - imp_finsts is used to determine what family instances should be visible (tcExtendLocalFamInstEnv) - To resolve the meaning of the export list of a module (tcRnExports) - imp_mods is used to compute usage info (mkIfaceTc, deSugar) - imp_trust_own_pkg is used for Safe Haskell in interfaces (mkIfaceTc, as well as in GHC.Driver.Main) - To create the Dependencies field in interface (mkDependencies)

• tcg_dus :: DefUses
• tcg_used_gres :: TcRef [GlobalRdrElt]
• tcg_keep :: TcRef NameSet
• 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, because 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 mutable variable.

• tcg_th_splice_used :: TcRef Bool

  True <=> A Template Haskell splice was used.

  Splices disable recompilation avoidance (see #481)

• tcg_th_needed_deps :: TcRef ([Linkable], PkgsLoaded)

  The set of runtime dependencies required by this module See Note [Object File Dependencies]

• tcg_dfun_n :: TcRef OccSet

  Allows us to choose unique DFun names.

• tcg_merged :: [(Module, Fingerprint)]

  The requirements we merged with; we always have to recompile if any of these changed.

• tcg_rn_exports :: Maybe [(LIE GhcRn, Avails)]
• tcg_rn_imports :: [LImportDecl GhcRn]
• tcg_rn_decls :: Maybe (HsGroup GhcRn)

  Renamed decls, maybe. Nothing <=> Don't retain renamed decls.

• tcg_dependent_files :: TcRef [FilePath]

  dependencies from addDependentFile

• tcg_th_topdecls :: TcRef [LHsDecl GhcPs]

  Top-level declarations from addTopDecls

• tcg_th_foreign_files :: TcRef [(ForeignSrcLang, FilePath)]

  Foreign files emitted from TH.

• tcg_th_topnames :: TcRef NameSet

  Exact names bound in top-level declarations in tcg_th_topdecls

• tcg_th_modfinalizers :: TcRef [(TcLclEnv, ThModFinalizers)]

  Template Haskell module finalizers.

  They can use particular local environments.

• tcg_th_coreplugins :: TcRef [String]

  Core plugins added by Template Haskell code.

• tcg_th_state :: TcRef (Map TypeRep Dynamic)
• tcg_th_remote_state :: TcRef (Maybe (ForeignRef (IORef QState)))

  Template Haskell state

• tcg_th_docs :: TcRef THDocs

  Docs added in Template Haskell via putDoc.

• tcg_ev_binds :: Bag EvBind
• tcg_tr_module :: Maybe Id
• tcg_binds :: LHsBinds GhcTc
• tcg_sigs :: NameSet
• tcg_imp_specs :: [LTcSpecPrag]
• tcg_warns :: Warnings GhcRn
• tcg_anns :: [Annotation]
• tcg_tcs :: [TyCon]
• tcg_ksigs :: NameSet
• tcg_insts :: [ClsInst]
• tcg_fam_insts :: [FamInst]
• tcg_rules :: [LRuleDecl GhcTc]
• tcg_fords :: [LForeignDecl GhcTc]
• tcg_patsyns :: [PatSyn]
• tcg_doc_hdr :: Maybe (LHsDoc GhcRn)

  Maybe Haddock header docs

• tcg_hpc :: !AnyHpcUsage

  True if any part of the prog uses hpc instrumentation. NB. BangPattern is to fix a leak, see #15111

• tcg_self_boot :: SelfBootInfo

  Whether this module has a corresponding hi-boot file

• tcg_main :: Maybe Name

  The Name of the main function, if this module is the main module.

• tcg_safe_infer :: TcRef Bool

  Has the typechecker inferred this module as -XSafe (Safe Haskell)? See Note [Safe Haskell Overlapping Instances Implementation], although this is used for more than just that failure case.

• tcg_safe_infer_reasons :: TcRef (Messages TcRnMessage)

  Unreported reasons why tcg_safe_infer is False. INVARIANT: If this Messages is non-empty, then tcg_safe_infer is False. It may be that tcg_safe_infer is False but this is empty, if no reasons are supplied (#19714), or if those reasons have already been reported by GHC.Driver.Main.markUnsafeInfer

• tcg_tc_plugin_solvers :: [TcPluginSolver]

  A list of user-defined type-checking plugins for constraint solving.

• tcg_tc_plugin_rewriters :: UniqFM TyCon [TcPluginRewriter]

  A collection of all the user-defined type-checking plugins for rewriting type family applications, collated by their type family TyCons.

• tcg_defaulting_plugins :: [FillDefaulting]

  A list of user-defined plugins for type defaulting plugins.

• tcg_hf_plugins :: [HoleFitPlugin]

  A list of user-defined plugins for hole fit suggestions.

• tcg_top_loc :: RealSrcSpan

  The RealSrcSpan this module came from

• tcg_static_wc :: TcRef WantedConstraints

  Wanted constraints of static forms. See Note [Constraints in static forms].

• tcg_complete_matches :: !CompleteMatches

  Tracking indices for cost centre annotations

• tcg_cc_st :: TcRef CostCentreState
• tcg_next_wrapper_num :: TcRef (ModuleEnv Int)

  See Note [Generating fresh names for FFI wrappers]

Instances

ContainsModule TcGblEnv

Defined in GHC.Tc.Types

Methods

extractModule :: TcGblEnv -> Module

data TcLclEnv

Constructors

TcLclEnv

Fields

• tcl_loc :: RealSrcSpan
• tcl_ctxt :: [ErrCtxt]
• tcl_in_gen_code :: Bool
• tcl_tclvl :: TcLevel
• tcl_th_ctxt :: ThStage
• tcl_th_bndrs :: ThBindEnv
• tcl_arrow_ctxt :: ArrowCtxt
• tcl_rdr :: LocalRdrEnv
• tcl_env :: TcTypeEnv
• tcl_usage :: TcRef UsageEnv
• tcl_bndrs :: TcBinderStack
• tcl_lie :: TcRef WantedConstraints
• tcl_errs :: TcRef (Messages TcRnMessage)

setLclEnvTcLevel :: TcLclEnv -> TcLevel -> TcLclEnv

getLclEnvTcLevel :: TcLclEnv -> TcLevel

setLclEnvLoc :: TcLclEnv -> RealSrcSpan -> TcLclEnv

getLclEnvLoc :: TcLclEnv -> RealSrcSpan

data IfGblEnv

Constructors

IfGblEnv

Fields

• if_doc :: SDoc
• if_rec_types :: KnotVars (IfG TypeEnv)

data IfLclEnv

Constructors

IfLclEnv

Fields

• if_mod :: !Module
• if_boot :: IsBootInterface
• if_loc :: SDoc
• if_nsubst :: Maybe NameShape
• if_implicits_env :: Maybe TypeEnv
• if_tv_env :: FastStringEnv TyVar
• if_id_env :: FastStringEnv Id

tcVisibleOrphanMods :: TcGblEnv -> ModuleSet

data RewriteEnv

A RewriteEnv carries the necessary context for performing rewrites (i.e. type family reductions and following filled-in metavariables) in the solver.

Constructors

RE

Fields

• re_loc :: !CtLoc

  In which context are we rewriting?

  Type-checking plugins might want to use this location information when emitting new Wanted constraints when rewriting type family applications. This ensures that such Wanted constraints will, when unsolved, give rise to error messages with the correct source location.

• re_flavour :: !CtFlavour
• re_eq_rel :: !EqRel

  At what role are we rewriting?

  See Note [Rewriter EqRels] in GHC.Tc.Solver.Rewrite

• re_rewriters :: !(TcRef RewriterSet)

  See Note [Wanteds rewrite Wanteds]

data FrontendResult

FrontendResult describes the result of running the frontend of a Haskell module. Currently one always gets a FrontendTypecheck, since running the frontend involves typechecking a program. hs-sig merges are not handled here.

This data type really should be in GHC.Driver.Env, but it needs to have a TcGblEnv which is only defined here.

Constructors

FrontendTypecheck TcGblEnv

type ErrCtxt = (Bool, TidyEnv -> TcM (TidyEnv, SDoc))

type RecFieldEnv = NameEnv [FieldLabel]

pushErrCtxt :: CtOrigin -> ErrCtxt -> CtLoc -> CtLoc

pushErrCtxtSameOrigin :: ErrCtxt -> CtLoc -> CtLoc

data ImportAvails

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

Constructors

ImportAvails

Fields

• imp_mods :: ImportedMods

  Domain is all directly-imported modules

  See the documentation on ImportedModsVal in GHC.Unit.Module.Imported for the meaning of the fields.

  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 future).

• imp_direct_dep_mods :: InstalledModuleEnv ModuleNameWithIsBoot

  Home-package modules directly imported by the module being compiled.

• imp_dep_direct_pkgs :: Set UnitId

  Packages directly needed by the module being compiled

• 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 [Trust Own Package] in GHC.Rename.Names

• imp_trust_pkgs :: Set UnitId

  This 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. See Note [Tracking Trust Transitively] in GHC.Rename.Names

• imp_boot_mods :: InstalledModuleEnv ModuleNameWithIsBoot

  Domain is all modules which have hs-boot files, and whether we should import the boot version of interface file. Only used in one-shot mode to populate eps_is_boot.

• imp_sig_mods :: [ModuleName]

  Signature modules below this one

• 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)

emptyImportAvails :: ImportAvails

plusImportAvails :: ImportAvails -> ImportAvails -> ImportAvails

Union two ImportAvails

This function is a key part of Import handling, basically for each import we create a separate ImportAvails structure and then union them all together with this function.

data WhereFrom

Constructors

ImportByUser IsBootInterface

ImportBySystem

ImportByPlugin

Instances

Outputable WhereFrom

Defined in GHC.Tc.Types

Methods

ppr :: WhereFrom -> SDoc

mkModDeps :: Set (UnitId, ModuleNameWithIsBoot) -> InstalledModuleEnv ModuleNameWithIsBoot

type TcTypeEnv = NameEnv TcTyThing

type TcBinderStack = [TcBinder]

data TcBinder

Constructors

TcIdBndr TcId TopLevelFlag

TcIdBndr_ExpType Name ExpType TopLevelFlag

TcTvBndr Name TyVar

Instances

HasOccName TcBinder

Defined in GHC.Tc.Types

Methods

occName :: TcBinder -> OccName

Outputable TcBinder

Defined in GHC.Tc.Types

Methods

ppr :: TcBinder -> SDoc

data TcTyThing

A typecheckable thing available in a local context. Could be AGlobal TyThing, but also lexically scoped variables, etc. See GHC.Tc.Utils.Env for how to retrieve a TyThing given a Name.

Constructors

AGlobal TyThing

ATcId

Fields

• tct_id :: TcId
• tct_info :: IdBindingInfo

ATyVar Name TcTyVar

ATcTyCon TyCon

APromotionErr PromotionErr

Instances

Outputable TcTyThing

Defined in GHC.Tc.Types

Methods

ppr :: TcTyThing -> SDoc

tcTyThingTyCon_maybe :: TcTyThing -> Maybe TyCon

Matches on either a global TyCon or a TcTyCon.

data PromotionErr

Constructors

TyConPE

ClassPE

FamDataConPE

ConstrainedDataConPE PredType

PatSynPE

RecDataConPE

NoDataKindsDC

Instances

Outputable PromotionErr

Defined in GHC.Tc.Types

Methods

ppr :: PromotionErr -> SDoc

data IdBindingInfo

IdBindingInfo describes how an Id is bound.

It is used for the following purposes: a) for static forms in checkClosedInStaticForm and b) to figure out when a nested binding can be generalised, in decideGeneralisationPlan.

Constructors

NotLetBound

ClosedLet

NonClosedLet RhsNames ClosedTypeId

Instances

Outputable IdBindingInfo

Defined in GHC.Tc.Types

Methods

ppr :: IdBindingInfo -> SDoc

type ClosedTypeId = Bool

type RhsNames = NameSet

data IsGroupClosed

IsGroupClosed describes a group of mutually-recursive bindings

Constructors

IsGroupClosed (NameEnv RhsNames) ClosedTypeId

data SelfBootInfo

Constructors

NoSelfBoot

SelfBoot

Fields

• sb_mds :: ModDetails
• sb_tcs :: NameSet

bootExports :: SelfBootInfo -> NameSet

tcTyThingCategory :: TcTyThing -> String

pprTcTyThingCategory :: TcTyThing -> SDoc

peCategory :: PromotionErr -> String

pprPECategory :: PromotionErr -> SDoc

data CompleteMatch

A list of conlikes which represents a complete pattern match. These arise from COMPLETE signatures. See also Note [Implementation of COMPLETE pragmas].

Instances

Outputable CompleteMatch

Defined in GHC.Types.CompleteMatch

Methods

ppr :: CompleteMatch -> SDoc

type CompleteMatches = [CompleteMatch]

data ThStage

Constructors

Splice SpliceType

RunSplice (TcRef [ForeignRef (Q ())])

Comp

Brack ThStage PendingStuff

Instances

Outputable ThStage

Defined in GHC.Tc.Types

Methods

ppr :: ThStage -> SDoc

data SpliceType

Constructors

Typed

Untyped

data PendingStuff

Constructors

RnPendingUntyped (TcRef [PendingRnSplice])

RnPendingTyped

TcPending (TcRef [PendingTcSplice]) (TcRef WantedConstraints) QuoteWrapper

topStage :: ThStage

topAnnStage :: ThStage

topSpliceStage :: ThStage

type ThLevel = Int

impLevel :: ThLevel

outerLevel :: ThLevel

thLevel :: ThStage -> ThLevel

data ForeignSrcLang

Foreign formats supported by GHC via TH

Constructors

LangC

C

LangCxx

C++

LangObjc

Objective C

LangObjcxx

Objective C++

LangAsm

Assembly language (.s)

RawObject

Object (.o)

Instances

Generic ForeignSrcLang

Defined in GHC.ForeignSrcLang.Type

Associated Types

type Rep ForeignSrcLang :: Type -> Type

Methods

from :: ForeignSrcLang -> Rep ForeignSrcLang x

to :: Rep ForeignSrcLang x -> ForeignSrcLang

Show ForeignSrcLang

Defined in GHC.ForeignSrcLang.Type

Methods

showsPrec :: Int -> ForeignSrcLang -> ShowS

show :: ForeignSrcLang -> String

showList :: [ForeignSrcLang] -> ShowS

Binary ForeignSrcLang

Defined in GHC.ForeignSrcLang

Methods

put :: ForeignSrcLang -> Put

get :: Get ForeignSrcLang

putList :: [ForeignSrcLang] -> Put

Eq ForeignSrcLang

Defined in GHC.ForeignSrcLang.Type

Methods

(==) :: ForeignSrcLang -> ForeignSrcLang -> Bool

(/=) :: ForeignSrcLang -> ForeignSrcLang -> Bool

type Rep ForeignSrcLang

Defined in GHC.ForeignSrcLang.Type

type Rep ForeignSrcLang = D1 ('MetaData "ForeignSrcLang" "GHC.ForeignSrcLang.Type" "ghc-lib-parser-9.4.7.20230826-8eYN3wH3H8LE10ZNUI0TAV" 'False) ((C1 ('MetaCons "LangC" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "LangCxx" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "LangObjc" 'PrefixI 'False) (U1 :: Type -> Type))) :+: (C1 ('MetaCons "LangObjcxx" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "LangAsm" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "RawObject" 'PrefixI 'False) (U1 :: Type -> Type))))

type THDocs = Map DocLoc (HsDoc GhcRn)

The current collection of docs that Template Haskell has built up via putDoc.

data DocLoc

This is a mirror of Template Haskell's DocLoc, but the TH names are resolved to GHC names.

Constructors

DeclDoc Name

ArgDoc Name Int

InstDoc Name

ModuleDoc

Instances

Eq DocLoc

Defined in GHC.Tc.Types

Methods

(==) :: DocLoc -> DocLoc -> Bool

(/=) :: DocLoc -> DocLoc -> Bool

Ord DocLoc

Defined in GHC.Tc.Types

Methods

compare :: DocLoc -> DocLoc -> Ordering

(<) :: DocLoc -> DocLoc -> Bool

(<=) :: DocLoc -> DocLoc -> Bool

(>) :: DocLoc -> DocLoc -> Bool

(>=) :: DocLoc -> DocLoc -> Bool

max :: DocLoc -> DocLoc -> DocLoc

min :: DocLoc -> DocLoc -> DocLoc

type ThBindEnv = NameEnv (TopLevelFlag, ThLevel)

data ArrowCtxt

Constructors

NoArrowCtxt

ArrowCtxt LocalRdrEnv (TcRef WantedConstraints)

type TcSigFun = Name -> Maybe TcSigInfo

data TcSigInfo

Constructors

TcIdSig TcIdSigInfo

TcPatSynSig TcPatSynInfo

Instances

Outputable TcSigInfo

Defined in GHC.Tc.Types

Methods

ppr :: TcSigInfo -> SDoc

data TcIdSigInfo

Constructors

CompleteSig

Fields

• sig_bndr :: TcId
• sig_ctxt :: UserTypeCtxt
• sig_loc :: SrcSpan

PartialSig

Fields

• psig_name :: Name
• psig_hs_ty :: LHsSigWcType GhcRn
• sig_ctxt :: UserTypeCtxt
• sig_loc :: SrcSpan

Instances

Outputable TcIdSigInfo

Defined in GHC.Tc.Types

Methods

ppr :: TcIdSigInfo -> SDoc

data TcIdSigInst

Constructors

TISI

Fields

• sig_inst_sig :: TcIdSigInfo
• sig_inst_skols :: [(Name, InvisTVBinder)]
• sig_inst_theta :: TcThetaType
• sig_inst_tau :: TcSigmaType
• sig_inst_wcs :: [(Name, TcTyVar)]
• sig_inst_wcx :: Maybe TcType

Instances

Outputable TcIdSigInst

Defined in GHC.Tc.Types

Methods

ppr :: TcIdSigInst -> SDoc

data TcPatSynInfo

Constructors

TPSI

Fields

• patsig_name :: Name
• patsig_implicit_bndrs :: [InvisTVBinder]
• patsig_univ_bndrs :: [InvisTVBinder]
• patsig_req :: TcThetaType
• patsig_ex_bndrs :: [InvisTVBinder]
• patsig_prov :: TcThetaType
• patsig_body_ty :: TcSigmaType

Instances

Outputable TcPatSynInfo

Defined in GHC.Tc.Types

Methods

ppr :: TcPatSynInfo -> SDoc

isPartialSig :: TcIdSigInst -> Bool

hasCompleteSig :: TcSigFun -> Name -> Bool

No signature or a partial signature

type TcId = Id

type TcIdSet = IdSet

data NameShape

A NameShape is a substitution on Names that can be used to refine the identities of a hole while we are renaming interfaces (see GHC.Iface.Rename). Specifically, a NameShape for ns_module_name A, defines a mapping from {A.T} (for some OccName T) to some arbitrary other Name.

The most intruiging thing about a NameShape, however, is how it's constructed. A NameShape is *implied* by the exported AvailInfos of the implementor of an interface: if an implementor of signature <H> exports M.T, you implicitly define a substitution from {H.T} to M.T. So a NameShape is computed from the list of AvailInfos that are exported by the implementation of a module, or successively merged together by the export lists of signatures which are joining together.

It's not the most obvious way to go about doing this, but it does seem to work!

NB: Can't boot this and put it in NameShape because then we start pulling in too many DynFlags things.

Constructors

NameShape

Fields

• ns_mod_name :: ModuleName
• ns_exports :: [AvailInfo]
• ns_map :: OccEnv Name

removeBindingShadowing :: HasOccName a => [a] -> [a]

getPlatform :: TcM Platform

Get target platform

data TcPlugin

Constructors

forall s. TcPlugin

Fields

• tcPluginInit :: TcPluginM s

  Initialize plugin, when entering type-checker.

• tcPluginSolve :: s -> TcPluginSolver

  Solve some constraints.

  This function will be invoked at two points in the constraint solving process: once to simplify Given constraints, and once to solve Wanted constraints. In the first case (and only in the first case), no Wanted constraints will be passed to the plugin.

  The plugin can either return a contradiction, or specify that it has solved some constraints (with evidence), and possibly emit additional constraints. These returned constraints must be Givens in the first case, and Wanteds in the second.

  Use \ _ _ _ _ _ -> pure $ TcPluginOK [] [] if your plugin does not provide this functionality.

• tcPluginRewrite :: s -> UniqFM TyCon TcPluginRewriter

  Rewrite saturated type family applications.

  The plugin is expected to supply a mapping from type family names to rewriting functions. For each type family TyCon, the plugin should provide a function which takes in the given constraints and arguments of a saturated type family application, and return a possible rewriting. See TcPluginRewriter for the expected shape of such a function.

  Use \ _ -> emptyUFM if your plugin does not provide this functionality.

• tcPluginStop :: s -> TcPluginM ()

  Clean up after the plugin, when exiting the type-checker.

data TcPluginSolveResult

Result of running a solver plugin.

Constructors

TcPluginSolveResult

Fields

• tcPluginInsolubleCts :: [Ct]

  Insoluble constraints found by the plugin.

  These constraints will be added to the inert set, and reported as insoluble to the user.

• tcPluginSolvedCts :: [(EvTerm, Ct)]

  Solved constraints, together with their evidence.

  These are removed from the inert set, and the evidence for them is recorded.

• tcPluginNewCts :: [Ct]

  New constraints that the plugin wishes to emit.

  These will be added to the work list.

Bundled Patterns

pattern TcPluginContradiction :: [Ct] -> TcPluginSolveResult

The plugin found a contradiction. The returned constraints are removed from the inert set, and recorded as insoluble.

The returned list of constraints should never be empty.

pattern TcPluginOk :: [(EvTerm, Ct)] -> [Ct] -> TcPluginSolveResult

The plugin has not found any contradictions,

The first field is for constraints that were solved. The second field contains new work, that should be processed by the constraint solver.

data TcPluginRewriteResult

Constructors

TcPluginNoRewrite

The plugin does not rewrite the type family application.

TcPluginRewriteTo

The plugin rewrites the type family application providing a rewriting together with evidence: a Reduction, which contains the rewritten type together with a Coercion whose right-hand-side type is the rewritten type.

The plugin can also emit additional Wanted constraints.

Fields

• tcPluginReduction :: !Reduction
• tcRewriterNewWanteds :: [Ct]

type TcPluginSolver

Arguments

 = EvBindsVar

-> [Ct]

Givens

-> [Ct]

Wanteds

-> TcPluginM TcPluginSolveResult

The solve function of a type-checking plugin takes in Given and Wanted constraints, and should return a TcPluginSolveResult indicating which Wanted constraints it could solve, or whether any are insoluble.

type TcPluginRewriter

Arguments

 = RewriteEnv

Rewriter environment

-> [Ct]

Givens

-> [TcType]

type family arguments

-> TcPluginM TcPluginRewriteResult

For rewriting type family applications, a type-checking plugin provides a function of this type for each type family TyCon.

The function is provided with the current set of Given constraints, together with the arguments to the type family. The type family application will always be fully saturated.

data TcPluginM a

TcPluginM is the monad in which type-checking plugins operate.

Instances

MonadFail TcPluginM

Defined in GHC.Tc.Types

Methods

fail :: String -> TcPluginM a

Applicative TcPluginM

Defined in GHC.Tc.Types

Methods

pure :: a -> TcPluginM a

(<*>) :: TcPluginM (a -> b) -> TcPluginM a -> TcPluginM b

liftA2 :: (a -> b -> c) -> TcPluginM a -> TcPluginM b -> TcPluginM c

(*>) :: TcPluginM a -> TcPluginM b -> TcPluginM b

(<*) :: TcPluginM a -> TcPluginM b -> TcPluginM a

Functor TcPluginM

Defined in GHC.Tc.Types

Methods

fmap :: (a -> b) -> TcPluginM a -> TcPluginM b

(<$) :: a -> TcPluginM b -> TcPluginM a

Monad TcPluginM

Defined in GHC.Tc.Types

Methods

(>>=) :: TcPluginM a -> (a -> TcPluginM b) -> TcPluginM b

(>>) :: TcPluginM a -> TcPluginM b -> TcPluginM b

return :: a -> TcPluginM a

unsafeTcPluginTcM :: TcM a -> TcPluginM a

This function provides an escape for direct access to the TcM monad. It should not be used lightly, and the provided TcPluginM API should be favoured instead.

data DefaultingPlugin

A plugin for controlling defaulting.

Constructors

forall s. DefaultingPlugin

Fields

• dePluginInit :: TcPluginM s

  Initialize plugin, when entering type-checker.

• dePluginRun :: s -> FillDefaulting

  Default some types

• dePluginStop :: s -> TcPluginM ()

  Clean up after the plugin, when exiting the type-checker.

data DefaultingProposal

A collection of candidate default types for a type variable.

Constructors

DefaultingProposal

Fields

• deProposalTyVar :: TcTyVar

  The type variable to default.

• deProposalCandidates :: [Type]

  Candidate types to default the type variable to.

• deProposalCts :: [Ct]

  The constraints against which defaults are checked.

Instances

Outputable DefaultingProposal

Defined in GHC.Tc.Types

Methods

ppr :: DefaultingProposal -> SDoc

type FillDefaulting = WantedConstraints -> TcPluginM DefaultingPluginResult

type DefaultingPluginResult = [DefaultingProposal]

type RoleAnnotEnv = NameEnv (LRoleAnnotDecl GhcRn)

emptyRoleAnnotEnv :: RoleAnnotEnv

mkRoleAnnotEnv :: [LRoleAnnotDecl GhcRn] -> RoleAnnotEnv

lookupRoleAnnot :: RoleAnnotEnv -> Name -> Maybe (LRoleAnnotDecl GhcRn)

getRoleAnnots :: [Name] -> RoleAnnotEnv -> [LRoleAnnotDecl GhcRn]

lintGblEnv :: Logger -> DynFlags -> TcGblEnv -> TcM ()

Check the TcGblEnv for consistency. Currently, only checks axioms, but should check other aspects, too.

data TcRnMessage

An error which might arise during typechecking/renaming.

Instances

Diagnostic TcRnMessage

Defined in GHC.Tc.Errors.Ppr

Methods

diagnosticMessage :: TcRnMessage -> DecoratedSDoc

diagnosticReason :: TcRnMessage -> DiagnosticReason

diagnosticHints :: TcRnMessage -> [GhcHint]