GHC.Tc.Types.Origin

Describes the provenance of types as they flow through the type-checker. The datatypes here are mainly used for error message generation.

UserTypeCtxt

data UserTypeCtxt

UserTypeCtxt describes the origin of the polymorphic type in the places where we need an expression to have that type

Constructors

FunSigCtxt Name ReportRedundantConstraints

InfSigCtxt Name

ExprSigCtxt ReportRedundantConstraints

KindSigCtxt

StandaloneKindSigCtxt Name

TypeAppCtxt

ConArgCtxt Name

TySynCtxt Name

PatSynCtxt Name

PatSigCtxt

RuleSigCtxt FastString Name

ForSigCtxt Name

DefaultDeclCtxt

InstDeclCtxt Bool

SpecInstCtxt

GenSigCtxt

GhciCtxt Bool

ClassSCCtxt Name

SigmaCtxt

DataTyCtxt Name

DerivClauseCtxt

TyVarBndrKindCtxt Name

DataKindCtxt Name

TySynKindCtxt Name

TyFamResKindCtxt Name

Instances

Eq UserTypeCtxt

Defined in GHC.Tc.Types.Origin

Methods

(==) :: UserTypeCtxt -> UserTypeCtxt -> Bool

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

pprUserTypeCtxt :: UserTypeCtxt -> SDoc

isSigMaybe :: UserTypeCtxt -> Maybe Name

data ReportRedundantConstraints

Report Redundant Constraints.

Constructors

NoRRC

Don't report redundant constraints

WantRRC SrcSpan

Report redundant constraints, and here is the SrcSpan for the constraints E.g. f :: (Eq a, Ord b) => blah The span is for the (Eq a, Ord b)

Instances

Eq ReportRedundantConstraints

Defined in GHC.Tc.Types.Origin

Methods

(==) :: ReportRedundantConstraints -> ReportRedundantConstraints -> Bool

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

reportRedundantConstraints :: ReportRedundantConstraints -> Bool

redundantConstraintsSpan :: UserTypeCtxt -> SrcSpan

SkolemInfo

data SkolemInfo

SkolemInfo stores the origin of a skolem type variable, so that we can display this information to the user in case of a type error.

The Unique field allows us to report all skolem type variables bound in the same place in a single report.

Constructors

SkolemInfo

Fields

• Unique

  used to common up skolem variables bound at the same location (only used in pprSkols)

• SkolemInfoAnon

  the information about the origin of the skolem type variable

Instances

Uniquable SkolemInfo

Defined in GHC.Tc.Types.Origin

Methods

getUnique :: SkolemInfo -> Unique

Outputable SkolemInfo

Defined in GHC.Tc.Types.Origin

Methods

ppr :: SkolemInfo -> SDoc

data SkolemInfoAnon

SkolemInfoAnon stores the origin of a skolem type variable (e.g. bound by a user-written forall, the header of a data declaration, a deriving clause, ...).

This information is displayed when reporting an error message, such as

"Couldn't match k with l"

This allows us to explain where the type variable came from.

When several skolem type variables are bound at once, prefer using SkolemInfo, which stores a Unique which allows these type variables to be reported

Constructors

SigSkol UserTypeCtxt TcType [(Name, TcTyVar)]

SigTypeSkol UserTypeCtxt

ForAllSkol TyVarBndrs

DerivSkol Type

InstSkol

FamInstSkol

PatSkol ConLike (HsMatchContext GhcTc)

IPSkol [HsIPName]

RuleSkol RuleName

InferSkol [(Name, TcType)]

BracketSkol

UnifyForAllSkol TcType

TyConSkol TyConFlavour Name

DataConSkol Name

ReifySkol

QuantCtxtSkol

RuntimeUnkSkol

ArrowReboundIfSkol

UnkSkol CallStack

Instances

Outputable SkolemInfoAnon

Defined in GHC.Tc.Types.Origin

Methods

ppr :: SkolemInfoAnon -> SDoc

mkSkolemInfo :: MonadIO m => SkolemInfoAnon -> m SkolemInfo

Wrap up the origin of a skolem type variable with a new Unique, so that we can common up skolem type variables whose SkolemInfo shares a certain Unique.

getSkolemInfo :: SkolemInfo -> SkolemInfoAnon

pprSigSkolInfo :: UserTypeCtxt -> TcType -> SDoc

pprSkolInfo :: SkolemInfoAnon -> SDoc

unkSkol :: HasCallStack => SkolemInfo

Use this when you can't specify a helpful origin for some skolem type variable.

We're hoping to be able to get rid of this entirely, but for the moment it's still needed.

unkSkolAnon :: HasCallStack => SkolemInfoAnon

CtOrigin

data CtOrigin

Constructors

GivenOrigin SkolemInfoAnon

A given constraint from a user-written type signature. The SkolemInfo inside gives more information.

InstSCOrigin

InstSCOrigin is used for a Given constraint obtained by superclass selection from the context of an instance declaration. E.g. instance (Foo a, Bar a) => C [a] where ... When typechecking the instance decl itself, including producing evidence for the superclasses of C, the superclasses of (Foo a) and (Bar a) will have InstSCOrigin origin.

Fields

• ScDepth

  The number of superclass selections necessary to get this constraint; see Note [Replacement vs keeping] and Note [Use only the best local instance], both in GHC.Tc.Solver.Interact

• TypeSize

  If (C ty1 .. tyn) is the largest class from which we made a superclass selection in the chain, then TypeSize = sizeTypes [ty1, .., tyn] See Note [Solving superclass constraints] in GHC.Tc.TyCl.Instance

OtherSCOrigin

OtherSCOrigin is used for a Given constraint obtained by superclass selection from a constraint other than the context of an instance declaration. (For the latter we use InstSCOrigin.) E.g. f :: Foo a => blah f = e When typechecking body of f, the superclasses of the Given (Foo a) will have OtherSCOrigin. Needed for Note [Replacement vs keeping] and Note [Use only the best local instance], both in GHC.Tc.Solver.Interact.

Fields

• ScDepth

  The number of superclass selections necessary to get this constraint

• SkolemInfoAnon

  Where the sub-class constraint arose from (used only for printing)

OccurrenceOf Name

OccurrenceOfRecSel RdrName

AppOrigin

SpecPragOrigin UserTypeCtxt

TypeEqOrigin

Fields

• uo_actual :: TcType
• uo_expected :: TcType
• uo_thing :: Maybe TypedThing

  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 TcType CtOrigin (Maybe TypeOrKind)

IPOccOrigin HsIPName

OverLabelOrigin FastString

LiteralOrigin (HsOverLit GhcRn)

NegateOrigin

ArithSeqOrigin (ArithSeqInfo GhcRn)

AssocFamPatOrigin

SectionOrigin

HasFieldOrigin FastString

TupleOrigin

ExprSigOrigin

PatSigOrigin

PatOrigin

ProvCtxtOrigin (PatSynBind GhcRn GhcRn)

RecordUpdOrigin

ViewPatOrigin

ScOrigin TypeSize

ScOrigin is used only for the Wanted constraints for the superclasses of an instance declaration. If the instance head is C ty1 .. tyn then TypeSize = sizeTypes [ty1, .., tyn] See Note [Solving superclass constraints] in GHC.Tc.TyCl.Instance

DerivClauseOrigin

DerivOriginDC DataCon Int Bool

DerivOriginCoerce Id Type Type Bool

StandAloneDerivOrigin

DefaultOrigin

DoOrigin

DoPatOrigin (LPat GhcRn)

MCompOrigin

MCompPatOrigin (LPat GhcRn)

ProcOrigin

ArrowCmdOrigin

AnnOrigin

FunDepOrigin1 PredType CtOrigin RealSrcSpan PredType CtOrigin RealSrcSpan

FunDepOrigin2 PredType CtOrigin PredType SrcSpan

InjTFOrigin1 PredType CtOrigin RealSrcSpan PredType CtOrigin RealSrcSpan

ExprHoleOrigin (Maybe OccName)

TypeHoleOrigin OccName

PatCheckOrigin

ListOrigin

IfThenElseOrigin

BracketOrigin

StaticOrigin

Shouldn'tHappenOrigin String

GhcBug20076

InstProvidedOrigin

Testing whether the constraint associated with an instance declaration in a signature file is satisfied upon instantiation.

Test cases: backpackshould_failbkpfail{11,43}.bkp

Fields

• Module

  Module in which the instance was declared

• ClsInst

  The declared typeclass instance

NonLinearPatternOrigin

UsageEnvironmentOf Name

CycleBreakerOrigin CtOrigin

FRROrigin FixedRuntimeRepOrigin

WantedSuperclassOrigin PredType CtOrigin

InstanceSigOrigin Name Type Type

AmbiguityCheckOrigin UserTypeCtxt

Instances

Outputable CtOrigin

Defined in GHC.Tc.Types.Origin

Methods

ppr :: 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

pprCtOrigin :: CtOrigin -> SDoc

isGivenOrigin :: CtOrigin -> Bool

isWantedWantedFunDepOrigin :: CtOrigin -> Bool

isWantedSuperclassOrigin :: CtOrigin -> Bool

Did a constraint arise from expanding a Wanted constraint to look at superclasses?

data TypedThing

Some thing which has a type.

This datatype is used when we want to report to the user that something has an unexpected type.

Constructors

HsTypeRnThing (HsType GhcRn)

TypeThing Type

HsExprRnThing (HsExpr GhcRn)

NameThing Name

Instances

Outputable TypedThing

Defined in GHC.Tc.Types.Origin

Methods

ppr :: TypedThing -> SDoc

data TyVarBndrs

Some kind of type variable binder.

Used for reporting errors, in SkolemInfo and TcSolverReportMsg.

Constructors

forall flag.OutputableBndrFlag flag 'Renamed => HsTyVarBndrsRn [HsTyVarBndr flag GhcRn]

Instances

Outputable TyVarBndrs

Defined in GHC.Tc.Types.Origin

Methods

ppr :: TyVarBndrs -> SDoc

CtOrigin and CallStack

isPushCallStackOrigin :: CtOrigin -> Bool

callStackOriginFS :: CtOrigin -> FastString

FixedRuntimeRep origin

data FixedRuntimeRepOrigin

The context for a representation-polymorphism check.

For example, when typechecking (a :: k) -> ..., we are checking the type a because it's the type of a term variable bound in a lambda, so we use FRRBinder.

Constructors

FixedRuntimeRepOrigin

Fields

• frr_type :: Type

  What type are we checking? For example, `a[tau]` in `a[tau] :: TYPE rr[tau]`.

• frr_context :: FixedRuntimeRepContext

  What context requires a fixed runtime representation?

data FixedRuntimeRepContext

The context in which a representation-polymorphism check was performed.

Does not include the type on which the check was performed; see FixedRuntimeRepOrigin for that.

Constructors

FRRRecordUpdate !RdrName !(HsExpr GhcTc)

Record fields in record updates must have a fixed runtime representation.

Test case: RepPolyRecordUpdate.

FRRBinder !Name

Variable binders must have a fixed runtime representation.

Test cases: LevPolyLet, RepPolyPatBind.

FRRPatBind

Pattern binds must have a fixed runtime representation.

Test case: RepPolyInferPatBind.

FRRPatSynArg

Pattern synonym arguments must have a fixed runtime representation.

Test case: RepPolyInferPatSyn.

FRRCase

The type of the scrutinee in a case statement must have a fixed runtime representation.

Test cases: RepPolyCase{1,2}.

FRRDataConArg !ExprOrPat !DataCon !Int

An instantiation of a newtype/data constructor in which an argument type does not have a fixed runtime representation.

The argument can either be an expression or a pattern.

Test cases: Expression: UnliftedNewtypesLevityBinder. Pattern: T20363.

FRRNoBindingResArg !Id !Int

An instantiation of an Id with no binding (e.g. coerce, `unsafeCoerce#`) in which one of the remaining arguments types does not have a fixed runtime representation.

Test cases: RepPolyWrappedVar, T14561, UnliftedNewtypesCoerceFail.

FRRTupleArg !Int

Arguments to unboxed tuples must have fixed runtime representations.

Test case: RepPolyTuple.

FRRTupleSection !Int

Tuple sections must have a fixed runtime representation.

Test case: RepPolyTupleSection.

FRRUnboxedSum

Unboxed sums must have a fixed runtime representation.

Test cases: RepPolySum.

FRRBodyStmt !StmtOrigin !Int

The body of a do expression or a monad comprehension must have a fixed runtime representation.

Test cases: RepPolyDoBody{1,2}, RepPolyMcBody.

FRRBodyStmtGuard

Arguments to a guard in a monad comprehesion must have a fixed runtime representation.

Test case: RepPolyMcGuard.

FRRBindStmt !StmtOrigin

Arguments to (>>=) arising from a do expression or a monad comprehension must have a fixed runtime representation.

Test cases: RepPolyDoBind, RepPolyMcBind.

FRRBindStmtGuard

A value bound by a pattern guard must have a fixed runtime representation.

Test cases: none.

FRRArrow !FRRArrowContext

A representation-polymorphism check arising from arrow notation.

See FRRArrowContext for more details.

FRRExpectedFunTy

A representation-polymorphic check arising from a call to matchExpectedFunTys or matchActualFunTySigma.

See ExpectedFunTyOrigin for more details.

Fields

• !ExpectedFunTyOrigin
• !Int

  argument position (1-indexed)

Instances

Outputable FixedRuntimeRepContext

Defined in GHC.Tc.Types.Origin

Methods

ppr :: FixedRuntimeRepContext -> SDoc

pprFixedRuntimeRepContext :: FixedRuntimeRepContext -> SDoc

Print the context for a FixedRuntimeRep representation-polymorphism check.

Note that this function does not include the specific RuntimeRep which is not fixed. That information is stored in FixedRuntimeRepOrigin and is reported separately.

data StmtOrigin

Are we in a do expression or a monad comprehension?

This datatype is only used to report this context to the user in error messages.

Constructors

MonadComprehension

DoNotation

Instances

Outputable StmtOrigin

Defined in GHC.Tc.Types.Origin

Methods

ppr :: StmtOrigin -> SDoc

Arrow command origin

data FRRArrowContext

While typechecking arrow notation, in which context did a representation polymorphism check arise?

See FixedRuntimeRepContext for more general origins of representation polymorphism checks.

Constructors

ArrowCmdResTy !(HsCmd GhcRn)

The result of an arrow command does not have a fixed runtime representation.

Test case: RepPolyArrowCmd.

ArrowCmdApp !(HsCmd GhcRn) !(HsExpr GhcRn)

The argument to an arrow in an arrow command application does not have a fixed runtime representation.

Test cases: none.

ArrowCmdArrApp !(HsExpr GhcRn) !(HsExpr GhcRn) !HsArrAppType

A function in an arrow application does not have a fixed runtime representation.

Test cases: none.

ArrowCmdCase

The scrutinee type in an arrow command case statement does not have a fixed runtime representation.

Test cases: none.

ArrowFun !(HsExpr GhcRn)

The overall type of an arrow proc expression does not have a fixed runtime representation.

Test case: RepPolyArrowFun.

Instances

Outputable FRRArrowContext

Defined in GHC.Tc.Types.Origin

Methods

ppr :: FRRArrowContext -> SDoc

pprFRRArrowContext :: FRRArrowContext -> SDoc

data ExpectedFunTyOrigin

In what context are we calling matchExpectedFunTys or matchActualFunTySigma?

Used for two things:

1. Reporting error messages which explain that a function has been given an unexpected number of arguments. Uses pprExpectedFunTyHerald. See Note [Herald for matchExpectedFunTys] in GHC.Tc.Utils.Unify.
2. Reporting representation-polymorphism errors when a function argument doesn't have a fixed RuntimeRep as per Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete. Uses pprExpectedFunTyOrigin. See FixedRuntimeRepContext for the situations in which representation-polymorphism checks are performed.

Constructors

ExpectedFunTySyntaxOp

A rebindable syntax operator is expected to have a function type.

Test cases for representation-polymorphism checks: RepPolyDoBind, RepPolyDoBody{1,2}, RepPolyMc{Bind,Body,Guard}, RepPolyNPlusK

Fields

• !CtOrigin
• !(HsExpr GhcRn)

  rebindable syntax operator

ExpectedFunTyViewPat

A view pattern must have a function type.

Test cases for representation-polymorphism checks: RepPolyBinder

Fields

• !(HsExpr GhcRn)

  function used in the view pattern

forall (p :: Pass).OutputableBndrId p => ExpectedFunTyArg

Need to be able to extract an argument type from a function type.

Test cases for representation-polymorphism checks: RepPolyApp

Fields

• !TypedThing

  function

• !(HsExpr (GhcPass p))

  argument

ExpectedFunTyMatches

Ensure that a function defined by equations indeed has a function type with the appropriate number of arguments.

Test cases for representation-polymorphism checks: RepPolyBinder, RepPolyRecordPattern, RepPolyWildcardPattern

Fields

• !TypedThing

  name of the function

• !(MatchGroup GhcRn (LHsExpr GhcRn))

  equations

ExpectedFunTyLam !(MatchGroup GhcRn (LHsExpr GhcRn))

Ensure that a lambda abstraction has a function type.

Test cases for representation-polymorphism checks: RepPolyLambda

ExpectedFunTyLamCase

Ensure that a lambda case expression has a function type.

Test cases for representation-polymorphism checks: RepPolyMatch

Fields

• LamCaseVariant
• !(HsExpr GhcRn)

  the entire lambda-case expression

pprExpectedFunTyOrigin

Arguments

:: ExpectedFunTyOrigin

-> Int

argument position (starting at 1)

-> SDoc

pprExpectedFunTyHerald :: ExpectedFunTyOrigin -> SDoc