TcRnTypes

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_us :: !(IORef UniqSupply)
• env_gbl :: gbl
• env_lcl :: lcl

Instances

ContainsModule gbl => ContainsModule (Env gbl lcl)

Defined in TcRnTypes

Methods

extractModule :: Env gbl lcl -> Module

ContainsDynFlags (Env gbl lcl)

Defined in TcRnTypes

Methods

extractDynFlags :: Env gbl lcl -> DynFlags

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 HscTypes

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

• tcg_type_env_var :: TcRef 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 HscMain) - To create the Dependencies field in interface (mkDependencies)

• tcg_dus :: DefUses

  What is defined in this module and what is used.

• tcg_used_gres :: TcRef [GlobalRdrElt]

  Records occurrences of imported entities One entry for each occurrence; but may have different GREs for the same Name See Note [Tracking unused binding and imports]

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

  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 rule
  • 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, 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_top_level_locs :: TcRef (Set RealSrcSpan)

  Locations of the top-level splices; used for providing details on scope in error messages for out-of-scope variables

• 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 [(Located (IE 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_ev_binds :: Bag EvBind
• tcg_tr_module :: Maybe Id
• tcg_binds :: LHsBinds GhcTc
• tcg_sigs :: NameSet
• tcg_imp_specs :: [LTcSpecPrag]
• tcg_warns :: Warnings
• tcg_anns :: [Annotation]
• tcg_tcs :: [TyCon]
• tcg_insts :: [ClsInst]
• tcg_fam_insts :: [FamInst]
• tcg_rules :: [LRuleDecl GhcTc]
• tcg_fords :: [LForeignDecl GhcTc]
• tcg_patsyns :: [PatSyn]
• tcg_doc_hdr :: Maybe LHsDocString

  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_safeInfer :: TcRef (Bool, WarningMessages)

  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_tc_plugins :: [TcPluginSolver]

  A list of user-defined plugins for the constraint solver.

• 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 :: [CompleteMatch]

  Tracking indices for cost centre annotations

• tcg_cc_st :: TcRef CostCentreState

Instances

ContainsModule TcGblEnv

Defined in TcRnTypes

Methods

extractModule :: TcGblEnv -> Module

data TcLclEnv

Constructors

TcLclEnv

Fields

• tcl_loc :: RealSrcSpan
• tcl_ctxt :: [ErrCtxt]
• tcl_tclvl :: TcLevel
• tcl_th_ctxt :: ThStage
• tcl_th_bndrs :: ThBindEnv
• tcl_arrow_ctxt :: ArrowCtxt
• tcl_rdr :: LocalRdrEnv
• tcl_env :: TcTypeEnv
• tcl_bndrs :: TcBinderStack
• tcl_tyvars :: TcRef TcTyVarSet
• tcl_lie :: TcRef WantedConstraints
• tcl_errs :: TcRef Messages

data IfGblEnv

Constructors

IfGblEnv

Fields

• if_doc :: SDoc
• if_rec_types :: Maybe (Module, IfG TypeEnv)

data IfLclEnv

Constructors

IfLclEnv

Fields

• if_mod :: Module
• if_boot :: Bool
• 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 FrontendResult

FrontendResult describes the result of running the frontend of a Haskell module. Usually, you'll get a FrontendTypecheck, since running the frontend involves typechecking a program, but for an hs-boot merge you'll just get a ModIface, since no actual typechecking occurred.

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

Constructors

FrontendTypecheck TcGblEnv

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

type RecFieldEnv = NameEnv [FieldLabel]

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 HscTypes 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_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 :: Set InstalledUnitId

  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 :: Set InstalledUnitId

  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 (UnitId, 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)

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 TcRnTypes

Methods

ppr :: WhereFrom -> SDoc

pprPrec :: Rational -> WhereFrom -> SDoc

mkModDeps :: [(ModuleName, IsBootInterface)] -> ModuleNameEnv (ModuleName, IsBootInterface)

modDepsElts :: ModuleNameEnv (ModuleName, IsBootInterface) -> [(ModuleName, IsBootInterface)]

type TcTypeEnv = NameEnv TcTyThing

type TcBinderStack = [TcBinder]

data TcBinder

Constructors

TcIdBndr TcId TopLevelFlag

TcIdBndr_ExpType Name ExpType TopLevelFlag

TcTvBndr Name TyVar

Instances

Outputable TcBinder

Defined in TcRnTypes

Methods

ppr :: TcBinder -> SDoc

pprPrec :: Rational -> TcBinder -> SDoc

HasOccName TcBinder

Defined in TcRnTypes

Methods

occName :: TcBinder -> OccName

data TcTyThing

A typecheckable thing available in a local context. Could be AGlobal TyThing, but also lexically scoped variables, etc. See TcEnv 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 TcRnTypes

Methods

ppr :: TcTyThing -> SDoc

pprPrec :: Rational -> TcTyThing -> SDoc

data PromotionErr

Constructors

TyConPE

ClassPE

FamDataConPE

ConstrainedDataConPE PredType

PatSynPE

PatSynExPE

RecDataConPE

NoDataKindsTC

NoDataKindsDC

Instances

Outputable PromotionErr

Defined in TcRnTypes

Methods

ppr :: PromotionErr -> SDoc

pprPrec :: Rational -> PromotionErr -> SDoc

data IdBindingInfo

IdBindingInfo describes how an Id is bound.

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

Constructors

NotLetBound

ClosedLet

NonClosedLet RhsNames ClosedTypeId

Instances

Outputable IdBindingInfo

Defined in TcRnTypes

Methods

ppr :: IdBindingInfo -> SDoc

pprPrec :: Rational -> 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

pprTcTyThingCategory :: TcTyThing -> SDoc

pprPECategory :: PromotionErr -> SDoc

data CompleteMatch

A list of conlikes which represents a complete pattern match. These arise from COMPLETE signatures.

Constructors

CompleteMatch

Fields

• completeMatchConLikes :: [Name]

  The ConLikes that form a covering family (e.g. Nothing, Just)

• completeMatchTyCon :: Name

  The TyCon that they cover (e.g. Maybe)

Instances

Outputable CompleteMatch

Defined in HscTypes

Methods

ppr :: CompleteMatch -> SDoc

pprPrec :: Rational -> CompleteMatch -> SDoc

type DsM = TcRnIf DsGblEnv DsLclEnv

data DsLclEnv

Constructors

DsLclEnv

Fields

• dsl_meta :: DsMetaEnv
• dsl_loc :: RealSrcSpan
• dsl_dicts :: Bag EvVar
• dsl_tm_cs :: Bag SimpleEq
• dsl_pm_iter :: IORef Int

data DsGblEnv

Constructors

DsGblEnv

Fields

• ds_mod :: Module
• ds_fam_inst_env :: FamInstEnv
• ds_unqual :: PrintUnqualified
• ds_msgs :: IORef Messages
• ds_if_env :: (IfGblEnv, IfLclEnv)
• ds_complete_matches :: CompleteMatchMap
• ds_cc_st :: IORef CostCentreState

Instances

ContainsModule DsGblEnv

Defined in TcRnTypes

Methods

extractModule :: DsGblEnv -> Module

type DsMetaEnv = NameEnv DsMetaVal

data DsMetaVal

Constructors

DsBound Id

DsSplice (HsExpr GhcTc)

type CompleteMatchMap = UniqFM [CompleteMatch]

A map keyed by the completeMatchTyCon.

mkCompleteMatchMap :: [CompleteMatch] -> CompleteMatchMap

extendCompleteMatchMap :: CompleteMatchMap -> [CompleteMatch] -> CompleteMatchMap

data ThStage

Constructors

Splice SpliceType

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

Comp

Brack ThStage PendingStuff

Instances

Outputable ThStage

Defined in TcRnTypes

Methods

ppr :: ThStage -> SDoc

pprPrec :: Rational -> ThStage -> SDoc

data SpliceType

Constructors

Typed

Untyped

data PendingStuff

Constructors

RnPendingUntyped (TcRef [PendingRnSplice])

RnPendingTyped

TcPending (TcRef [PendingTcSplice]) (TcRef WantedConstraints)

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

Eq ForeignSrcLang

Defined in GHC.ForeignSrcLang.Type

Methods

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

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

Show ForeignSrcLang

Defined in GHC.ForeignSrcLang.Type

Methods

showsPrec :: Int -> ForeignSrcLang -> ShowS

show :: ForeignSrcLang -> String

showList :: [ForeignSrcLang] -> ShowS

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

Binary ForeignSrcLang

Defined in GHC.ForeignSrcLang

Methods

put :: ForeignSrcLang -> Put

get :: Get ForeignSrcLang

putList :: [ForeignSrcLang] -> Put

type Rep ForeignSrcLang

Defined in GHC.ForeignSrcLang.Type

type Rep ForeignSrcLang = D1 (MetaData "ForeignSrcLang" "GHC.ForeignSrcLang.Type" "ghc-lib-parser-8.8.2.20200205-FYvk4aUArajAwkHF90NG4N" 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))))

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 TcRnTypes

Methods

ppr :: TcSigInfo -> SDoc

pprPrec :: Rational -> 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 TcRnTypes

Methods

ppr :: TcIdSigInfo -> SDoc

pprPrec :: Rational -> TcIdSigInfo -> SDoc

data TcIdSigInst

Constructors

TISI

Fields

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

Instances

Outputable TcIdSigInst

Defined in TcRnTypes

Methods

ppr :: TcIdSigInst -> SDoc

pprPrec :: Rational -> TcIdSigInst -> SDoc

data TcPatSynInfo

Constructors

TPSI

Fields

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

Instances

Outputable TcPatSynInfo

Defined in TcRnTypes

Methods

ppr :: TcPatSynInfo -> SDoc

pprPrec :: Rational -> TcPatSynInfo -> SDoc

isPartialSig :: TcIdSigInst -> Bool

hasCompleteSig :: TcSigFun -> Name -> Bool

No signature or a partial signature

data QCInst

Constructors

QCI

Fields

• qci_ev :: CtEvidence
• qci_tvs :: [TcTyVar]
• qci_pred :: TcPredType
• qci_pend_sc :: Bool

Instances

Outputable QCInst

Defined in TcRnTypes

Methods

ppr :: QCInst -> SDoc

pprPrec :: Rational -> QCInst -> SDoc

isPendingScInst :: QCInst -> Maybe QCInst

type Xi = Type

data Ct

Constructors

CDictCan

Fields

• cc_ev :: CtEvidence
• cc_class :: Class
• cc_tyargs :: [Xi]
• cc_pend_sc :: Bool

CIrredCan

Fields

• cc_ev :: CtEvidence
• cc_insol :: Bool

CTyEqCan

Fields

• cc_ev :: CtEvidence
• cc_tyvar :: TcTyVar
• cc_rhs :: TcType
• cc_eq_rel :: EqRel

CFunEqCan

Fields

• cc_ev :: CtEvidence
• cc_fun :: TyCon
• cc_tyargs :: [Xi]
• cc_fsk :: TcTyVar

CNonCanonical

Fields

• cc_ev :: CtEvidence

CHoleCan

Fields

• cc_ev :: CtEvidence
• cc_hole :: Hole

CQuantCan QCInst

Instances

Outputable Ct

Defined in TcRnTypes

Methods

ppr :: Ct -> SDoc

pprPrec :: Rational -> Ct -> SDoc

type Cts = Bag Ct

emptyCts :: Cts

andCts :: Cts -> Cts -> Cts

andManyCts :: [Cts] -> Cts

pprCts :: Cts -> SDoc

singleCt :: Ct -> Cts

listToCts :: [Ct] -> Cts

ctsElts :: Cts -> [Ct]

consCts :: Ct -> Cts -> Cts

snocCts :: Cts -> Ct -> Cts

extendCtsList :: Cts -> [Ct] -> Cts

isEmptyCts :: Cts -> Bool

isCTyEqCan :: Ct -> Bool

isCFunEqCan :: Ct -> Bool

isPendingScDict :: Ct -> Maybe Ct

superClassesMightHelp :: WantedConstraints -> Bool

True if taking superclasses of givens, or of wanteds (to perhaps expose more equalities or functional dependencies) might help to solve this constraint. See Note [When superclasses help]

getPendingWantedScs :: Cts -> ([Ct], Cts)

isCDictCan_Maybe :: Ct -> Maybe Class

isCFunEqCan_maybe :: Ct -> Maybe (TyCon, [Type])

isCNonCanonical :: Ct -> Bool

isWantedCt :: Ct -> Bool

isDerivedCt :: Ct -> Bool

isGivenCt :: Ct -> Bool

isHoleCt :: Ct -> Bool

isOutOfScopeCt :: Ct -> Bool

isExprHoleCt :: Ct -> Bool

isTypeHoleCt :: Ct -> Bool

isUserTypeErrorCt :: Ct -> Bool

getUserTypeErrorMsg :: Ct -> Maybe Type

A constraint is considered to be a custom type error, if it contains custom type errors anywhere in it. See Note [Custom type errors in constraints]

ctEvidence :: Ct -> CtEvidence

ctLoc :: Ct -> CtLoc

setCtLoc :: Ct -> CtLoc -> Ct

ctPred :: Ct -> PredType

ctFlavour :: Ct -> CtFlavour

Get the flavour of the given Ct

ctEqRel :: Ct -> EqRel

Get the equality relation for the given Ct

ctOrigin :: Ct -> CtOrigin

ctEvId :: Ct -> EvVar

mkTcEqPredLikeEv :: CtEvidence -> TcType -> TcType -> TcType

Makes a new equality predicate with the same role as the given evidence.

mkNonCanonical :: CtEvidence -> Ct

mkNonCanonicalCt :: Ct -> Ct

mkGivens :: CtLoc -> [EvId] -> [Ct]

mkIrredCt :: CtEvidence -> Ct

mkInsolubleCt :: CtEvidence -> Ct

ctEvPred :: CtEvidence -> TcPredType

ctEvLoc :: CtEvidence -> CtLoc

ctEvOrigin :: CtEvidence -> CtOrigin

ctEvEqRel :: CtEvidence -> EqRel

Get the equality relation relevant for a CtEvidence

ctEvExpr :: CtEvidence -> EvExpr

ctEvTerm :: CtEvidence -> EvTerm

ctEvCoercion :: HasDebugCallStack => CtEvidence -> Coercion

ctEvEvId :: CtEvidence -> EvVar

tyCoVarsOfCt :: Ct -> TcTyCoVarSet

Returns free variables of constraints as a non-deterministic set

tyCoVarsOfCts :: Cts -> TcTyCoVarSet

Returns free variables of a bag of constraints as a non-deterministic set. See Note [Deterministic FV] in FV.

tyCoVarsOfCtList :: Ct -> [TcTyCoVar]

Returns free variables of constraints as a deterministically ordered. list. See Note [Deterministic FV] in FV.

tyCoVarsOfCtsList :: Cts -> [TcTyCoVar]

Returns free variables of a bag of constraints as a deterministically odered list. See Note [Deterministic FV] in FV.

data WantedConstraints

Constructors

WC

Fields

• wc_simple :: Cts
• wc_impl :: Bag Implication

Instances

Outputable WantedConstraints

Defined in TcRnTypes

Methods

ppr :: WantedConstraints -> SDoc

pprPrec :: Rational -> WantedConstraints -> SDoc

insolubleWC :: WantedConstraints -> Bool

emptyWC :: WantedConstraints

isEmptyWC :: WantedConstraints -> Bool

isSolvedWC :: WantedConstraints -> Bool

Checks whether a the given wanted constraints are solved, i.e. that there are no simple constraints left and all the implications are solved.

andWC :: WantedConstraints -> WantedConstraints -> WantedConstraints

unionsWC :: [WantedConstraints] -> WantedConstraints

mkSimpleWC :: [CtEvidence] -> WantedConstraints

mkImplicWC :: Bag Implication -> WantedConstraints

addInsols :: WantedConstraints -> Bag Ct -> WantedConstraints

insolublesOnly :: WantedConstraints -> WantedConstraints

addSimples :: WantedConstraints -> Bag Ct -> WantedConstraints

addImplics :: WantedConstraints -> Bag Implication -> WantedConstraints

tyCoVarsOfWC :: WantedConstraints -> TyCoVarSet

Returns free variables of WantedConstraints as a non-deterministic set. See Note [Deterministic FV] in FV.

dropDerivedWC :: WantedConstraints -> WantedConstraints

dropDerivedSimples :: Cts -> Cts

tyCoVarsOfWCList :: WantedConstraints -> [TyCoVar]

Returns free variables of WantedConstraints as a deterministically ordered list. See Note [Deterministic FV] in FV.

insolubleCt :: Ct -> Bool

insolubleEqCt :: Ct -> Bool

isDroppableCt :: Ct -> Bool

insolubleImplic :: Implication -> Bool

arisesFromGivens :: Ct -> Bool

data Implication

Constructors

Implic

Fields

• ic_tclvl :: TcLevel
• ic_skols :: [TcTyVar]
• ic_info :: SkolemInfo
• ic_telescope :: Maybe SDoc
• ic_given :: [EvVar]
• ic_no_eqs :: Bool
• ic_env :: Env TcGblEnv TcLclEnv
• ic_wanted :: WantedConstraints
• ic_binds :: EvBindsVar
• ic_need_inner :: VarSet
• ic_need_outer :: VarSet
• ic_status :: ImplicStatus

Instances

Outputable Implication

Defined in TcRnTypes

Methods

ppr :: Implication -> SDoc

pprPrec :: Rational -> Implication -> SDoc

newImplication :: TcM Implication

Create a new Implication with as many sensible defaults for its fields as possible. Note that the ic_tclvl, ic_binds, and ic_info fields do not have sensible defaults, so they are initialized with lazy thunks that will panic if forced, so one should take care to initialize these fields after creation.

This is monadic purely to look up the Env, which is used to initialize ic_env.

implicationPrototype :: Implication

implicLclEnv :: Implication -> TcLclEnv

Retrieve the enclosed TcLclEnv from an Implication.

implicDynFlags :: Implication -> DynFlags

Retrieve the enclosed DynFlags from an Implication.

data ImplicStatus

Constructors

IC_Solved

Fields

• ics_dead :: [EvVar]

IC_Insoluble

IC_BadTelescope

IC_Unsolved

Instances

Outputable ImplicStatus

Defined in TcRnTypes

Methods

ppr :: ImplicStatus -> SDoc

pprPrec :: Rational -> ImplicStatus -> SDoc

isInsolubleStatus :: ImplicStatus -> Bool

isSolvedStatus :: ImplicStatus -> Bool

data SubGoalDepth

See Note [SubGoalDepth]

Instances

Eq SubGoalDepth

Defined in TcRnTypes

Methods

(==) :: SubGoalDepth -> SubGoalDepth -> Bool

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

Ord SubGoalDepth

Defined in TcRnTypes

Methods

compare :: SubGoalDepth -> SubGoalDepth -> Ordering

(<) :: SubGoalDepth -> SubGoalDepth -> Bool

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

(>) :: SubGoalDepth -> SubGoalDepth -> Bool

(>=) :: SubGoalDepth -> SubGoalDepth -> Bool

max :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth

min :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth

Outputable SubGoalDepth

Defined in TcRnTypes

Methods

ppr :: SubGoalDepth -> SDoc

pprPrec :: Rational -> SubGoalDepth -> SDoc

initialSubGoalDepth :: SubGoalDepth

maxSubGoalDepth :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth

bumpSubGoalDepth :: SubGoalDepth -> SubGoalDepth

subGoalDepthExceeded :: DynFlags -> SubGoalDepth -> Bool

data CtLoc

Constructors

CtLoc

Fields

• ctl_origin :: CtOrigin
• ctl_env :: TcLclEnv
• ctl_t_or_k :: Maybe TypeOrKind
• ctl_depth :: !SubGoalDepth

ctLocSpan :: CtLoc -> RealSrcSpan

ctLocEnv :: CtLoc -> TcLclEnv

ctLocLevel :: CtLoc -> TcLevel

ctLocOrigin :: CtLoc -> CtOrigin

ctLocTypeOrKind_maybe :: CtLoc -> Maybe TypeOrKind

ctLocDepth :: CtLoc -> SubGoalDepth

bumpCtLocDepth :: CtLoc -> CtLoc

isGivenLoc :: CtLoc -> Bool

setCtLocOrigin :: CtLoc -> CtOrigin -> CtLoc

updateCtLocOrigin :: CtLoc -> (CtOrigin -> CtOrigin) -> CtLoc

setCtLocEnv :: CtLoc -> TcLclEnv -> CtLoc

setCtLocSpan :: CtLoc -> RealSrcSpan -> CtLoc

data CtOrigin

Constructors

GivenOrigin SkolemInfo

OccurrenceOf Name

OccurrenceOfRecSel RdrName

AppOrigin

SpecPragOrigin UserTypeCtxt

TypeEqOrigin

Fields

• uo_actual :: TcType
• uo_expected :: TcType
• uo_thing :: Maybe SDoc

  The thing that has type "actual"

• uo_visible :: Bool

  Is at least one of the three elements above visible? (Errors from the polymorphic subsumption check are considered visible.) Only used for prioritizing error messages.

KindEqOrigin TcType (Maybe TcType) CtOrigin (Maybe TypeOrKind)

IPOccOrigin HsIPName

OverLabelOrigin FastString

LiteralOrigin (HsOverLit GhcRn)

NegateOrigin

ArithSeqOrigin (ArithSeqInfo GhcRn)

AssocFamPatOrigin

SectionOrigin

TupleOrigin

ExprSigOrigin

PatSigOrigin

PatOrigin

ProvCtxtOrigin (PatSynBind GhcRn GhcRn)

RecordUpdOrigin

ViewPatOrigin

ScOrigin TypeSize

DerivClauseOrigin

DerivOriginDC DataCon Int Bool

DerivOriginCoerce Id Type Type Bool

StandAloneDerivOrigin

DefaultOrigin

DoOrigin

DoPatOrigin (LPat GhcRn)

MCompOrigin

MCompPatOrigin (LPat GhcRn)

IfOrigin

ProcOrigin

AnnOrigin

FunDepOrigin1 PredType CtLoc PredType CtLoc

FunDepOrigin2 PredType CtOrigin PredType SrcSpan

HoleOrigin

UnboundOccurrenceOf OccName

ListOrigin

StaticOrigin

FailablePattern (LPat GhcTcId)

Shouldn'tHappenOrigin String

InstProvidedOrigin Module ClsInst

Instances

Outputable CtOrigin

Defined in TcRnTypes

Methods

ppr :: CtOrigin -> SDoc

pprPrec :: Rational -> CtOrigin -> SDoc

exprCtOrigin :: HsExpr GhcRn -> CtOrigin

lexprCtOrigin :: LHsExpr GhcRn -> CtOrigin

Extract a suitable CtOrigin from a HsExpr

matchesCtOrigin :: MatchGroup GhcRn (LHsExpr GhcRn) -> CtOrigin

Extract a suitable CtOrigin from a MatchGroup

grhssCtOrigin :: GRHSs GhcRn (LHsExpr GhcRn) -> CtOrigin

Extract a suitable CtOrigin from guarded RHSs

isVisibleOrigin :: CtOrigin -> Bool

toInvisibleOrigin :: CtOrigin -> CtOrigin

data TypeOrKind

Flag to see whether we're type-checking terms or kind-checking types

Constructors

TypeLevel

KindLevel

Instances

Eq TypeOrKind

Defined in TcRnTypes

Methods

(==) :: TypeOrKind -> TypeOrKind -> Bool

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

Outputable TypeOrKind

Defined in TcRnTypes

Methods

ppr :: TypeOrKind -> SDoc

pprPrec :: Rational -> TypeOrKind -> SDoc

isTypeLevel :: TypeOrKind -> Bool

isKindLevel :: TypeOrKind -> Bool

pprCtOrigin :: CtOrigin -> SDoc

pprCtLoc :: CtLoc -> SDoc

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

pushErrCtxtSameOrigin :: ErrCtxt -> CtLoc -> CtLoc

data SkolemInfo

Constructors

SigSkol UserTypeCtxt TcType [(Name, TcTyVar)]

SigTypeSkol UserTypeCtxt

ForAllSkol SDoc

DerivSkol Type

InstSkol

InstSC TypeSize

FamInstSkol

PatSkol ConLike (HsMatchContext Name)

ArrowSkol

IPSkol [HsIPName]

RuleSkol RuleName

InferSkol [(Name, TcType)]

BracketSkol

UnifyForAllSkol TcType

TyConSkol TyConFlavour Name

DataConSkol Name

ReifySkol

QuantCtxtSkol

UnkSkol

Instances

Outputable SkolemInfo

Defined in TcRnTypes

Methods

ppr :: SkolemInfo -> SDoc

pprPrec :: Rational -> SkolemInfo -> SDoc

pprSigSkolInfo :: UserTypeCtxt -> TcType -> SDoc

pprSkolInfo :: SkolemInfo -> SDoc

data CtEvidence

Constructors

CtGiven

Fields

• ctev_pred :: TcPredType
• ctev_evar :: EvVar
• ctev_loc :: CtLoc

CtWanted

Fields

• ctev_pred :: TcPredType
• ctev_dest :: TcEvDest
• ctev_nosh :: ShadowInfo
• ctev_loc :: CtLoc

CtDerived

Fields

• ctev_pred :: TcPredType
• ctev_loc :: CtLoc

Instances

Outputable CtEvidence

Defined in TcRnTypes

Methods

ppr :: CtEvidence -> SDoc

pprPrec :: Rational -> CtEvidence -> SDoc

data TcEvDest

A place for type-checking evidence to go after it is generated. Wanted equalities are always HoleDest; other wanteds are always EvVarDest.

Constructors

EvVarDest EvVar

bind this var to the evidence EvVarDest is always used for non-type-equalities e.g. class constraints

HoleDest CoercionHole

fill in this hole with the evidence HoleDest is always used for type-equalities See Note [Coercion holes] in TyCoRep

Instances

Outputable TcEvDest

Defined in TcRnTypes

Methods

ppr :: TcEvDest -> SDoc

pprPrec :: Rational -> TcEvDest -> SDoc

mkKindLoc :: TcType -> TcType -> CtLoc -> CtLoc

toKindLoc :: CtLoc -> CtLoc

Take a CtLoc and moves it to the kind level

mkGivenLoc :: TcLevel -> SkolemInfo -> TcLclEnv -> CtLoc

isWanted :: CtEvidence -> Bool

isGiven :: CtEvidence -> Bool

isDerived :: CtEvidence -> Bool

isGivenOrWDeriv :: CtFlavour -> Bool

ctEvRole :: CtEvidence -> Role

Get the role relevant for a CtEvidence

wrapType :: Type -> [TyVar] -> [PredType] -> Type

wrapTypeWithImplication :: Type -> Implication -> Type

Wraps the given type with the constraints (via ic_given) in the given implication, according to the variables mentioned (via ic_skols) in the implication, but taking care to only wrap those variables that are mentioned in the type or the implication.

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

data TcPlugin

Constructors

TcPlugin

Fields

• tcPluginInit :: TcPluginM s

  Initialize plugin, when entering type-checker.

• tcPluginSolve :: s -> TcPluginSolver

  Solve some constraints. TODO: WRITE MORE DETAILS ON HOW THIS WORKS.

• tcPluginStop :: s -> TcPluginM ()

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

data TcPluginResult

Constructors

TcPluginContradiction [Ct]

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

TcPluginOk [(EvTerm, Ct)] [Ct]

The first field is for constraints that were solved. These are removed from the inert set, and the evidence for them is recorded. The second field contains new work, that should be processed by the constraint solver.

type TcPluginSolver = [Ct] -> [Ct] -> [Ct] -> TcPluginM TcPluginResult

data TcPluginM a

Instances

Monad TcPluginM

Defined in TcRnTypes

Methods

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

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

return :: a -> TcPluginM a

fail :: String -> TcPluginM a

Functor TcPluginM

Defined in TcRnTypes

Methods

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

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

MonadFail TcPluginM

Defined in TcRnTypes

Methods

fail :: String -> TcPluginM a

Applicative TcPluginM

Defined in TcRnTypes

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

runTcPluginM :: TcPluginM a -> EvBindsVar -> TcM 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.

getEvBindsTcPluginM :: TcPluginM EvBindsVar

Access the EvBindsVar carried by the TcPluginM during constraint solving. Returns Nothing if invoked during tcPluginInit or tcPluginStop.

data CtFlavour

Constructors

Given

Wanted ShadowInfo

Derived

Instances

Eq CtFlavour

Defined in TcRnTypes

Methods

(==) :: CtFlavour -> CtFlavour -> Bool

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

Outputable CtFlavour

Defined in TcRnTypes

Methods

ppr :: CtFlavour -> SDoc

pprPrec :: Rational -> CtFlavour -> SDoc

data ShadowInfo

Constructors

WDeriv

WOnly

Instances

Eq ShadowInfo

Defined in TcRnTypes

Methods

(==) :: ShadowInfo -> ShadowInfo -> Bool

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

ctEvFlavour :: CtEvidence -> CtFlavour

type CtFlavourRole = (CtFlavour, EqRel)

Whether or not one Ct can rewrite another is determined by its flavour and its equality relation. See also Note [Flavours with roles] in TcSMonad

ctEvFlavourRole :: CtEvidence -> CtFlavourRole

Extract the flavour, role, and boxity from a CtEvidence

ctFlavourRole :: Ct -> CtFlavourRole

Extract the flavour and role from a Ct

eqCanRewrite :: EqRel -> EqRel -> Bool

eqCanRewriteFR :: CtFlavourRole -> CtFlavourRole -> Bool

eqMayRewriteFR :: CtFlavourRole -> CtFlavourRole -> Bool

eqCanDischargeFR :: CtFlavourRole -> CtFlavourRole -> Bool

funEqCanDischarge :: CtEvidence -> CtEvidence -> (SwapFlag, Bool)

funEqCanDischargeF :: CtFlavour -> CtFlavour -> (SwapFlag, Bool)

pprEvVarTheta :: [EvVar] -> SDoc

pprEvVars :: [EvVar] -> SDoc

pprEvVarWithType :: EvVar -> SDoc

type TcId = Id

type TcIdSet = IdSet

data Hole

An expression or type hole

Constructors

ExprHole UnboundVar

Either an out-of-scope variable or a "true" hole in an expression (TypedHoles)

TypeHole OccName

A hole in a type (PartialTypeSignatures)

Instances

Outputable Hole

Defined in TcRnTypes

Methods

ppr :: Hole -> SDoc

pprPrec :: Rational -> Hole -> SDoc

holeOcc :: Hole -> OccName

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

type RoleAnnotEnv = NameEnv (LRoleAnnotDecl GhcRn)

emptyRoleAnnotEnv :: RoleAnnotEnv

mkRoleAnnotEnv :: [LRoleAnnotDecl GhcRn] -> RoleAnnotEnv

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

getRoleAnnots :: [Name] -> RoleAnnotEnv -> ([LRoleAnnotDecl GhcRn], RoleAnnotEnv)