Safe Haskell	None
Language	Haskell2010

TcRnTypes

Synopsis

Documentation

type TcRnIf a b = IOEnv (Env a b) Source

type TcRn = TcRnIf TcGblEnv TcLclEnv Source

type TcM = TcRn Source

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

type RnM = TcRn Source

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

type IfM lcl = TcRnIf IfGblEnv lcl Source

type IfL = IfM IfLclEnv Source

type IfG = IfM () Source

type TcRef a = IORef a Source

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 Source

Constructors

Env
Fields env_top :: HscEnv env_us :: !(IORef UniqSupply) env_gbl :: gbl env_lcl :: lcl

Instances

ContainsModule gbl => ContainsModule (Env gbl lcl)
Methods extractModule :: Env gbl lcl -> Module Source
ContainsDynFlags (Env gbl lcl)
Methods extractDynFlags :: Env gbl lcl -> DynFlags Source

data TcGblEnv Source

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_src :: HscSource
What kind of module (regular Haskell, hs-boot, hsig)
tcg_sig_of :: Maybe Module
Are we being compiled as a signature of an implementation?
tcg_impl_rdr_env :: Maybe GlobalRdrEnv
Environment used only during -sig-of for resolving top level bindings. See Note [Signature parameters in TcGblEnv and DynFlags]
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
tcg_fam_inst_env :: FamInstEnv
Ditto for family instances
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 transative trusted packaage requirements.
tcg_dus :: DefUses
What is defined in this module and what is used.
tcg_used_gres :: TcRef [GlobalRdrElt]
Records occurrences of imported entities 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_dfun_n :: TcRef OccSet
Allows us to choose unique DFun names.
tcg_rn_exports :: Maybe [Located (IE Name)]
tcg_rn_imports :: [LImportDecl Name]
tcg_rn_decls :: Maybe (HsGroup Name)
Renamed decls, maybe. Nothing = Don't retain renamed decls.
tcg_dependent_files :: TcRef [FilePath]
dependencies from addDependentFile
tcg_th_topdecls :: TcRef [LHsDecl RdrName]
Top-level declarations from addTopDecls
tcg_th_topnames :: TcRef NameSet
Exact names bound in top-level declarations in tcg_th_topdecls
tcg_th_modfinalizers :: TcRef [Q ()]
Template Haskell module finalizers
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 Id
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 Id]
tcg_fords :: [LForeignDecl Id]
tcg_vects :: [LVectDecl Id]
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.
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_static_wc :: TcRef WantedConstraints
Wanted constraints of static forms.

Instances

ContainsModule TcGblEnv
Methods extractModule :: TcGblEnv -> Module Source

data TcLclEnv Source

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 :: TcIdBinderStack tcl_tidy :: TidyEnv tcl_tyvars :: TcRef TcTyVarSet tcl_lie :: TcRef WantedConstraints tcl_errs :: TcRef Messages

data IfGblEnv Source

Constructors

IfGblEnv
Fields if_rec_types :: Maybe (Module, IfG TypeEnv)

data IfLclEnv Source

Constructors

IfLclEnv
Fields if_mod :: Module if_loc :: SDoc if_tv_env :: UniqFM TyVar if_id_env :: UniqFM Id

tcVisibleOrphanMods :: TcGblEnv -> ModuleSet Source

data FrontendResult Source

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

type RecFieldEnv = NameEnv [FieldLabel] Source

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

Constructors

ImportAvails

Fields

imp_mods :: ImportedMods
Domain is all directly-imported modules
See the documentaion 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 :: [UnitId]
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 :: [UnitId]
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 Source

plusImportAvails :: ImportAvails -> ImportAvails -> ImportAvails Source

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 Source

Constructors

ImportByUser IsBootInterface
ImportBySystem
ImportByPlugin

Instances

Outputable WhereFrom
Methods ppr :: WhereFrom -> SDoc Source pprPrec :: Rational -> WhereFrom -> SDoc Source

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

type TcTypeEnv = NameEnv TcTyThing Source

type TcIdBinderStack = [TcIdBinder] Source

data TcIdBinder Source

Constructors

TcIdBndr TcId TopLevelFlag
TcIdBndr_ExpType Name ExpType TopLevelFlag

Instances

Outputable TcIdBinder
Methods ppr :: TcIdBinder -> SDoc Source pprPrec :: Rational -> TcIdBinder -> SDoc Source

data TcTyThing Source

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_closed :: TopLevelFlag
ATyVar Name TcTyVar
ATcTyCon TyCon
APromotionErr PromotionErr

Instances

Outputable TcTyThing
Methods ppr :: TcTyThing -> SDoc Source pprPrec :: Rational -> TcTyThing -> SDoc Source

data PromotionErr Source

Constructors

TyConPE
ClassPE
FamDataConPE
PatSynPE
RecDataConPE
NoDataKinds
NoTypeInTypeTC
NoTypeInTypeDC

Instances

Outputable PromotionErr
Methods ppr :: PromotionErr -> SDoc Source pprPrec :: Rational -> PromotionErr -> SDoc Source

data SelfBootInfo Source

Constructors

NoSelfBoot
SelfBoot
Fields sb_mds :: ModDetails sb_tcs :: NameSet sb_ids :: NameSet

pprTcTyThingCategory :: TcTyThing -> SDoc Source

pprPECategory :: PromotionErr -> SDoc Source

type DsM = TcRnIf DsGblEnv DsLclEnv Source

data DsLclEnv Source

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 Source

Constructors

DsGblEnv
Fields ds_mod :: Module ds_fam_inst_env :: FamInstEnv ds_unqual :: PrintUnqualified ds_msgs :: IORef Messages ds_if_env :: (IfGblEnv, IfLclEnv) ds_dph_env :: GlobalRdrEnv ds_parr_bi :: PArrBuiltin ds_static_binds :: IORef [(Fingerprint, (Id, CoreExpr))] Bindings resulted from floating static forms

Instances

ContainsModule DsGblEnv
Methods extractModule :: DsGblEnv -> Module Source

data PArrBuiltin Source

Constructors

PArrBuiltin
Fields lengthPVar :: Var lengthP replicatePVar :: Var replicateP singletonPVar :: Var singletonP mapPVar :: Var mapP filterPVar :: Var filterP zipPVar :: Var zipP crossMapPVar :: Var crossMapP indexPVar :: Var (!:) emptyPVar :: Var emptyP appPVar :: Var (+:+) enumFromToPVar :: Var enumFromToP enumFromThenToPVar :: Var enumFromThenToP

type DsMetaEnv = NameEnv DsMetaVal Source

data DsMetaVal Source

Constructors

DsBound Id
DsSplice (HsExpr Id)

data ThStage Source

Constructors

Splice SpliceType
Comp
Brack ThStage PendingStuff

Instances

Outputable ThStage
Methods ppr :: ThStage -> SDoc Source pprPrec :: Rational -> ThStage -> SDoc Source

data SpliceType Source

Constructors

Typed
Untyped

data PendingStuff Source

Constructors

RnPendingUntyped (TcRef [PendingRnSplice])
RnPendingTyped
TcPending (TcRef [PendingTcSplice]) (TcRef WantedConstraints)

topStage :: ThStage Source

topAnnStage :: ThStage Source

topSpliceStage :: ThStage Source

type ThLevel = Int Source

impLevel :: ThLevel Source

outerLevel :: ThLevel Source

thLevel :: ThStage -> ThLevel Source

data ArrowCtxt Source

Constructors

NoArrowCtxt
ArrowCtxt LocalRdrEnv (TcRef WantedConstraints)

type TcSigFun = Name -> Maybe TcSigInfo Source

data TcSigInfo Source

Constructors

TcIdSig TcIdSigInfo
TcPatSynSig TcPatSynInfo

Instances

Outputable TcSigInfo
Methods ppr :: TcSigInfo -> SDoc Source pprPrec :: Rational -> TcSigInfo -> SDoc Source

data TcIdSigInfo Source

Constructors

TISI
Fields sig_bndr :: TcIdSigBndr sig_skols :: [(Name, TcTyVar)] sig_theta :: TcThetaType sig_tau :: TcSigmaType sig_ctxt :: UserTypeCtxt sig_loc :: SrcSpan

Instances

Outputable TcIdSigInfo
Methods ppr :: TcIdSigInfo -> SDoc Source pprPrec :: Rational -> TcIdSigInfo -> SDoc Source

data TcPatSynInfo Source

Constructors

TPSI
Fields patsig_name :: Name patsig_univ_tvs :: [TcTyVar] patsig_req :: TcThetaType patsig_ex_tvs :: [TcTyVar] patsig_prov :: TcThetaType patsig_arg_tys :: [TcSigmaType] patsig_body_ty :: TcSigmaType

Instances

Outputable TcPatSynInfo
Methods ppr :: TcPatSynInfo -> SDoc Source pprPrec :: Rational -> TcPatSynInfo -> SDoc Source

data TcIdSigBndr Source

Constructors

CompleteSig TcId
PartialSig
Fields sig_name :: Name sig_hs_ty :: LHsType Name sig_wcs :: [(Name, TcTyVar)] sig_cts :: Maybe SrcSpan

Instances

Outputable TcIdSigBndr
Methods ppr :: TcIdSigBndr -> SDoc Source pprPrec :: Rational -> TcIdSigBndr -> SDoc Source

findScopedTyVars :: TcType -> [TcTyVar] -> [(Name, TcTyVar)] Source

isPartialSig :: TcIdSigInfo -> Bool Source

noCompleteSig :: Maybe TcSigInfo -> Bool Source

No signature or a partial signature

tcSigInfoName :: TcSigInfo -> Name Source

completeIdSigPolyId :: TcIdSigInfo -> TcId Source

completeSigPolyId_maybe :: TcSigInfo -> Maybe TcId Source

completeIdSigPolyId_maybe :: TcIdSigInfo -> Maybe TcId Source

type Xi = Type Source

data Ct Source

Constructors

CDictCan
Fields cc_ev :: CtEvidence cc_class :: Class cc_tyargs :: [Xi] cc_pend_sc :: Bool
CIrredEvCan
Fields cc_ev :: CtEvidence
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_occ :: OccName cc_hole :: HoleSort

Instances

Outputable Ct
Methods ppr :: Ct -> SDoc Source pprPrec :: Rational -> Ct -> SDoc Source

type Cts = Bag Ct Source

emptyCts :: Cts Source

andCts :: Cts -> Cts -> Cts Source

andManyCts :: [Cts] -> Cts Source

pprCts :: Cts -> SDoc Source

singleCt :: Ct -> Cts Source

listToCts :: [Ct] -> Cts Source

ctsElts :: Cts -> [Ct] Source

consCts :: Ct -> Cts -> Cts Source

snocCts :: Cts -> Ct -> Cts Source

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

isEmptyCts :: Cts -> Bool Source

isCTyEqCan :: Ct -> Bool Source

isCFunEqCan :: Ct -> Bool Source

isPendingScDict :: Ct -> Maybe Ct Source

superClassesMightHelp :: Ct -> Bool Source

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 superclases help]

isCDictCan_Maybe :: Ct -> Maybe Class Source

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

isCIrredEvCan :: Ct -> Bool Source

isCNonCanonical :: Ct -> Bool Source

isWantedCt :: Ct -> Bool Source

isDerivedCt :: Ct -> Bool Source

isGivenCt :: Ct -> Bool Source

isHoleCt :: Ct -> Bool Source

isOutOfScopeCt :: Ct -> Bool Source

isExprHoleCt :: Ct -> Bool Source

isTypeHoleCt :: Ct -> Bool Source

isUserTypeErrorCt :: Ct -> Bool Source

isCallStackDict :: Class -> [Type] -> Maybe FastString Source

Are we looking at an Implicit CallStack (i.e. IP "name" CallStack)?

If so, returns Just "name".

getUserTypeErrorMsg :: Ct -> Maybe Type Source

The following constraints are considered to be a custom type error: 1. TypeError msg a b c 2. TypeError msg a b c ~ Something (and the other way around) 4. C (TypeError msg a b c) (for any parameter of class constraint)

ctEvidence :: Ct -> CtEvidence Source

ctLoc :: Ct -> CtLoc Source

setCtLoc :: Ct -> CtLoc -> Ct Source

ctPred :: Ct -> PredType Source

ctFlavour :: Ct -> CtFlavour Source

Get the flavour of the given Ct

ctEqRel :: Ct -> EqRel Source

Get the equality relation for the given Ct

ctOrigin :: Ct -> CtOrigin Source

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

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

mkNonCanonical :: CtEvidence -> Ct Source

mkNonCanonicalCt :: Ct -> Ct Source

ctEvPred :: CtEvidence -> TcPredType Source

ctEvLoc :: CtEvidence -> CtLoc Source

ctEvOrigin :: CtEvidence -> CtOrigin Source

ctEvEqRel :: CtEvidence -> EqRel Source

Get the equality relation relevant for a CtEvidence

ctEvTerm :: CtEvidence -> EvTerm Source

ctEvCoercion :: CtEvidence -> Coercion Source

ctEvId :: CtEvidence -> TcId Source

tyCoVarsOfCt :: Ct -> TcTyCoVarSet Source

Returns free variables of constraints as a non-deterministic set

tyCoVarsOfCts :: Cts -> TcTyCoVarSet Source

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

tyCoVarsOfCtList :: Ct -> [TcTyCoVar] Source

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

tyCoVarsOfCtsList :: Cts -> [TcTyCoVar] Source

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

toDerivedCt :: Ct -> Ct Source

Convert a Wanted to a Derived

data WantedConstraints Source

Constructors

WC
Fields wc_simple :: Cts wc_impl :: Bag Implication wc_insol :: Cts

Instances

Outputable WantedConstraints
Methods ppr :: WantedConstraints -> SDoc Source pprPrec :: Rational -> WantedConstraints -> SDoc Source

insolubleWC :: TcLevel -> WantedConstraints -> Bool Source

emptyWC :: WantedConstraints Source

isEmptyWC :: WantedConstraints -> Bool Source

toDerivedWC :: WantedConstraints -> WantedConstraints Source

Convert all Wanteds into Deriveds (ignoring insolubles)

andWC :: WantedConstraints -> WantedConstraints -> WantedConstraints Source

unionsWC :: [WantedConstraints] -> WantedConstraints Source

mkSimpleWC :: [CtEvidence] -> WantedConstraints Source

mkImplicWC :: Bag Implication -> WantedConstraints Source

addInsols :: WantedConstraints -> Bag Ct -> WantedConstraints Source

addSimples :: WantedConstraints -> Bag Ct -> WantedConstraints Source

addImplics :: WantedConstraints -> Bag Implication -> WantedConstraints Source

tyCoVarsOfWC :: WantedConstraints -> TyCoVarSet Source

dropDerivedWC :: WantedConstraints -> WantedConstraints Source

dropDerivedSimples :: Cts -> Cts Source

dropDerivedInsols :: Cts -> Cts Source

isDroppableDerivedLoc :: CtLoc -> Bool Source

insolubleImplic :: Implication -> Bool Source

arisesFromGivens :: Ct -> Bool Source

data Implication Source

Constructors

Implic
Fields ic_tclvl :: TcLevel ic_skols :: [TcTyVar] ic_info :: SkolemInfo ic_given :: [EvVar] ic_no_eqs :: Bool ic_env :: TcLclEnv ic_wanted :: WantedConstraints ic_binds :: Maybe EvBindsVar ic_status :: ImplicStatus

Instances

Outputable Implication
Methods ppr :: Implication -> SDoc Source pprPrec :: Rational -> Implication -> SDoc Source

data ImplicStatus Source

Constructors

IC_Solved
Fields ics_need :: VarSet ics_dead :: [EvVar]
IC_Insoluble
IC_Unsolved

Instances

Outputable ImplicStatus
Methods ppr :: ImplicStatus -> SDoc Source pprPrec :: Rational -> ImplicStatus -> SDoc Source

isInsolubleStatus :: ImplicStatus -> Bool Source

data SubGoalDepth Source

See Note [SubGoalDepth]

Instances

Eq SubGoalDepth
Methods (==) :: SubGoalDepth -> SubGoalDepth -> Bool (/=) :: SubGoalDepth -> SubGoalDepth -> Bool
Ord SubGoalDepth
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
Methods ppr :: SubGoalDepth -> SDoc Source pprPrec :: Rational -> SubGoalDepth -> SDoc Source

initialSubGoalDepth :: SubGoalDepth Source

bumpSubGoalDepth :: SubGoalDepth -> SubGoalDepth Source

subGoalDepthExceeded :: DynFlags -> SubGoalDepth -> Bool Source

data CtLoc Source

Constructors

CtLoc
Fields ctl_origin :: CtOrigin ctl_env :: TcLclEnv ctl_t_or_k :: Maybe TypeOrKind ctl_depth :: !SubGoalDepth

ctLocSpan :: CtLoc -> RealSrcSpan Source

ctLocEnv :: CtLoc -> TcLclEnv Source

ctLocLevel :: CtLoc -> TcLevel Source

ctLocOrigin :: CtLoc -> CtOrigin Source

ctLocTypeOrKind_maybe :: CtLoc -> Maybe TypeOrKind Source

ctLocDepth :: CtLoc -> SubGoalDepth Source

bumpCtLocDepth :: CtLoc -> CtLoc Source

setCtLocOrigin :: CtLoc -> CtOrigin -> CtLoc Source

setCtLocEnv :: CtLoc -> TcLclEnv -> CtLoc Source

setCtLocSpan :: CtLoc -> RealSrcSpan -> CtLoc Source

data CtOrigin Source

Constructors

GivenOrigin SkolemInfo
OccurrenceOf Name
OccurrenceOfRecSel RdrName
AppOrigin
SpecPragOrigin UserTypeCtxt
TypeEqOrigin
Fields uo_actual :: TcType uo_expected :: ExpType uo_thing :: Maybe ErrorThing The thing that has type "actual"
KindEqOrigin TcType (Maybe TcType) CtOrigin (Maybe TypeOrKind)
IPOccOrigin HsIPName
OverLabelOrigin FastString
LiteralOrigin (HsOverLit Name)
NegateOrigin
ArithSeqOrigin (ArithSeqInfo Name)
PArrSeqOrigin (ArithSeqInfo Name)
SectionOrigin
TupleOrigin
ExprSigOrigin
PatSigOrigin
PatOrigin
RecordUpdOrigin
ViewPatOrigin
ScOrigin TypeSize
DerivOrigin
DerivOriginDC DataCon Int
DerivOriginCoerce Id Type Type
StandAloneDerivOrigin
DefaultOrigin
DoOrigin
DoPatOrigin (LPat Name)
MCompOrigin
MCompPatOrigin (LPat Name)
IfOrigin
ProcOrigin
AnnOrigin
FunDepOrigin1 PredType CtLoc PredType CtLoc
FunDepOrigin2 PredType CtOrigin PredType SrcSpan
HoleOrigin
UnboundOccurrenceOf OccName
ListOrigin
StaticOrigin
FailablePattern (LPat TcId)
Shouldn'tHappenOrigin String

Instances

Outputable CtOrigin
Methods ppr :: CtOrigin -> SDoc Source pprPrec :: Rational -> CtOrigin -> SDoc Source

exprCtOrigin :: HsExpr Name -> CtOrigin Source

Extract a suitable CtOrigin from a HsExpr

matchesCtOrigin :: MatchGroup Name (LHsExpr Name) -> CtOrigin Source

Extract a suitable CtOrigin from a MatchGroup

grhssCtOrigin :: GRHSs Name (LHsExpr Name) -> CtOrigin Source

Extract a suitable CtOrigin from guarded RHSs

data ErrorThing Source

A thing that can be stored for error message generation only. It is stored with a function to zonk and tidy the thing.

Constructors

Outputable a => ErrorThing a (Maybe Arity) (TidyEnv -> a -> TcM (TidyEnv, a))

Instances

Outputable ErrorThing
Methods ppr :: ErrorThing -> SDoc Source pprPrec :: Rational -> ErrorThing -> SDoc Source

mkErrorThing :: Outputable a => a -> ErrorThing Source

Make an ErrorThing that doesn't need tidying or zonking

errorThingNumArgs_maybe :: ErrorThing -> Maybe Arity Source

Retrieve the # of arguments in the error thing, if known

data TypeOrKind Source

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

Constructors

TypeLevel
KindLevel

Instances

Eq TypeOrKind
Methods (==) :: TypeOrKind -> TypeOrKind -> Bool (/=) :: TypeOrKind -> TypeOrKind -> Bool
Outputable TypeOrKind
Methods ppr :: TypeOrKind -> SDoc Source pprPrec :: Rational -> TypeOrKind -> SDoc Source

isTypeLevel :: TypeOrKind -> Bool Source

isKindLevel :: TypeOrKind -> Bool Source

pprCtOrigin :: CtOrigin -> SDoc Source

pprCtLoc :: CtLoc -> SDoc Source

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

pushErrCtxtSameOrigin :: ErrCtxt -> CtLoc -> CtLoc Source

data SkolemInfo Source

Instances

Outputable SkolemInfo
Methods ppr :: SkolemInfo -> SDoc Source pprPrec :: Rational -> SkolemInfo -> SDoc Source

pprSigSkolInfo :: UserTypeCtxt -> ExpType -> SDoc Source

pprSkolInfo :: SkolemInfo -> SDoc Source

data CtEvidence Source

Constructors

CtGiven
Fields ctev_pred :: TcPredType ctev_evar :: EvVar ctev_loc :: CtLoc
CtWanted
Fields ctev_pred :: TcPredType ctev_dest :: TcEvDest ctev_loc :: CtLoc
CtDerived
Fields ctev_pred :: TcPredType ctev_loc :: CtLoc

Instances

Outputable CtEvidence
Methods ppr :: CtEvidence -> SDoc Source pprPrec :: Rational -> CtEvidence -> SDoc Source

data TcEvDest Source

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
HoleDest CoercionHole	fill in this hole with the evidence See Note [Coercion holes] in TyCoRep

Instances

Outputable TcEvDest
Methods ppr :: TcEvDest -> SDoc Source pprPrec :: Rational -> TcEvDest -> SDoc Source

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

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

toKindLoc :: CtLoc -> CtLoc Source

Take a CtLoc and moves it to the kind level

isWanted :: CtEvidence -> Bool Source

isGiven :: CtEvidence -> Bool Source

isDerived :: CtEvidence -> Bool Source

ctEvRole :: CtEvidence -> Role Source

Get the role relevant for a CtEvidence

data TcPlugin Source

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 Source

Constructors

TcPluginContradiction [Ct]	The plugin found a contradiction. The returned constraints are removed from the inert set, and recorded as insoluable.
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 Source

data TcPluginM a Source

Instances

Monad TcPluginM
Methods (>>=) :: TcPluginM a -> (a -> TcPluginM b) -> TcPluginM b Source (>>) :: TcPluginM a -> TcPluginM b -> TcPluginM b Source return :: a -> TcPluginM a Source fail :: String -> TcPluginM a Source
Functor TcPluginM
Methods fmap :: (a -> b) -> TcPluginM a -> TcPluginM b Source (<$) :: a -> TcPluginM b -> TcPluginM a Source
MonadFail TcPluginM
Methods fail :: String -> TcPluginM a Source
Applicative TcPluginM
Methods pure :: a -> TcPluginM a Source (<>) :: TcPluginM (a -> b) -> TcPluginM a -> TcPluginM b Source (>) :: TcPluginM a -> TcPluginM b -> TcPluginM b Source (<*) :: TcPluginM a -> TcPluginM b -> TcPluginM a Source

runTcPluginM :: TcPluginM a -> Maybe EvBindsVar -> TcM a Source

unsafeTcPluginTcM :: TcM a -> TcPluginM a Source

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_maybe :: TcPluginM (Maybe EvBindsVar) Source

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

data CtFlavour Source

Constructors

Given
Wanted
Derived

Instances

Eq CtFlavour
Methods (==) :: CtFlavour -> CtFlavour -> Bool (/=) :: CtFlavour -> CtFlavour -> Bool
Outputable CtFlavour
Methods ppr :: CtFlavour -> SDoc Source pprPrec :: Rational -> CtFlavour -> SDoc Source

ctEvFlavour :: CtEvidence -> CtFlavour Source

type CtFlavourRole = (CtFlavour, EqRel) Source

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 Source

Extract the flavour, role, and boxity from a CtEvidence

ctFlavourRole :: Ct -> CtFlavourRole Source

Extract the flavour, role, and boxity from a Ct

eqCanRewrite :: CtEvidence -> CtEvidence -> Bool Source

eqCanRewriteFR :: CtFlavourRole -> CtFlavourRole -> Bool Source

eqCanDischarge :: CtEvidence -> CtEvidence -> Bool Source

funEqCanDischarge :: CtEvidence -> CtEvidence -> Bool Source

funEqCanDischargeFR :: CtFlavourRole -> CtFlavourRole -> Bool Source

pprEvVarTheta :: [EvVar] -> SDoc Source

pprEvVars :: [EvVar] -> SDoc Source

pprEvVarWithType :: EvVar -> SDoc Source

type TcId = Id Source

type TcIdSet = IdSet Source

data HoleSort Source

Used to indicate which sort of hole we have.

Constructors

ExprHole	A hole in an expression (TypedHoles)
TypeHole	A hole in a type (PartialTypeSignatures)

SigSkol UserTypeCtxt ExpType
ClsSkol Class
DerivSkol Type
InstSkol
InstSC TypeSize
DataSkol
FamInstSkol
PatSkol ConLike (HsMatchContext Name)
ArrowSkol
IPSkol [HsIPName]
RuleSkol RuleName
InferSkol [(Name, TcType)]
BracketSkol
UnifyForAllSkol TcType
UnkSkol