ghc-9.6.3: The GHC API
Safe HaskellSafe-Inferred
LanguageHaskell2010

GHC.Tc.Types.Origin

Description

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

Synopsis

UserTypeCtxt

data UserTypeCtxt Source #

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

Instances details
Eq UserTypeCtxt Source # 
Instance details

Defined in GHC.Tc.Types.Origin

Methods

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

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

pprUserTypeCtxt :: UserTypeCtxt -> SDoc Source #

isSigMaybe :: UserTypeCtxt -> Maybe Name Source #

data ReportRedundantConstraints Source #

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

Instances details
Eq ReportRedundantConstraints Source # 
Instance details

Defined in GHC.Tc.Types.Origin

Methods

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

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

reportRedundantConstraints :: ReportRedundantConstraints -> Bool Source #

redundantConstraintsSpan :: UserTypeCtxt -> SrcSpan Source #

SkolemInfo

data SkolemInfo Source #

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

    The Unique is 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

Instances details
Uniquable SkolemInfo Source # 
Instance details

Defined in GHC.Tc.Types.Origin

Methods

getUnique :: SkolemInfo -> Unique Source #

Outputable SkolemInfo Source # 
Instance details

Defined in GHC.Tc.Types.Origin

Methods

ppr :: SkolemInfo -> SDoc Source #

data SkolemInfoAnon Source #

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 ClsInstOrQC PatersonSize 
FamInstSkol 
PatSkol ConLike (HsMatchContext GhcTc) 
IPSkol [HsIPName] 
RuleSkol RuleName 
InferSkol [(Name, TcType)] 
BracketSkol 
UnifyForAllSkol TcType 
TyConSkol TyConFlavour Name 
DataConSkol Name 
ReifySkol 
RuntimeUnkSkol 
ArrowReboundIfSkol 
UnkSkol CallStack 

Instances

Instances details
Outputable SkolemInfoAnon Source # 
Instance details

Defined in GHC.Tc.Types.Origin

Methods

ppr :: SkolemInfoAnon -> SDoc Source #

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

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

pprSigSkolInfo :: UserTypeCtxt -> TcType -> SDoc Source #

pprSkolInfo :: SkolemInfoAnon -> SDoc Source #

unkSkol :: HasCallStack => SkolemInfo Source #

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

mkClsInstSkol :: Class -> [Type] -> SkolemInfoAnon Source #

CtOrigin

data CtOrigin Source #

Constructors

GivenOrigin SkolemInfoAnon

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

GivenSCOrigin

GivenSCOrigin 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 GivenSCOrigin origin.

Fields

  • SkolemInfoAnon

    Just like GivenOrigin

  • ScDepth

    The number of superclass selections necessary to get this constraint; see Note [Replacement vs keeping] in GHC.Tc.Solver.Interact

  • Bool

    True => "blocked": cannot use this to solve naked superclass Wanteds i.e. ones with (ScOrigin _ NakedSc) False => can use this to solve all Wanted constraints See Note [Solving superclass constraints] in GHC.Tc.TyCl.Instance

OccurrenceOf Name 
OccurrenceOfRecSel RdrName 
AppOrigin 
SpecPragOrigin UserTypeCtxt 
TypeEqOrigin 

Fields

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 ClsInstOrQC NakedScFlag

ScOrigin is used only for the Wanted constraints for the superclasses of an instance declaration.

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

Instances details
Outputable CtOrigin Source # 
Instance details

Defined in GHC.Tc.Types.Origin

Methods

ppr :: CtOrigin -> SDoc Source #

exprCtOrigin :: HsExpr GhcRn -> CtOrigin Source #

lexprCtOrigin :: LHsExpr GhcRn -> CtOrigin Source #

Extract a suitable CtOrigin from a HsExpr

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

Extract a suitable CtOrigin from a MatchGroup

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

Extract a suitable CtOrigin from guarded RHSs

isVisibleOrigin :: CtOrigin -> Bool Source #

toInvisibleOrigin :: CtOrigin -> CtOrigin Source #

pprCtOrigin :: CtOrigin -> SDoc Source #

isGivenOrigin :: CtOrigin -> Bool Source #

isWantedWantedFunDepOrigin :: CtOrigin -> Bool Source #

isWantedSuperclassOrigin :: CtOrigin -> Bool Source #

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

data TypedThing Source #

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

Instances details
Outputable TypedThing Source # 
Instance details

Defined in GHC.Tc.Types.Origin

Methods

ppr :: TypedThing -> SDoc Source #

data TyVarBndrs Source #

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

Instances details
Outputable TyVarBndrs Source # 
Instance details

Defined in GHC.Tc.Types.Origin

Methods

ppr :: TyVarBndrs -> SDoc Source #

CtOrigin and CallStack

isPushCallStackOrigin :: CtOrigin -> Bool Source #

callStackOriginFS :: CtOrigin -> FastString Source #

FixedRuntimeRep origin

data FixedRuntimeRepOrigin Source #

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

data FixedRuntimeRepContext Source #

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

FRRRecordCon !RdrName !(HsExpr GhcTc)

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

FRRRecordUpdate !Name !(HsExpr GhcRn)

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}.

FRRDataConPatArg !DataCon !Int

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

Test case: T20363.

FRRNoBindingResArg !RepPolyFun !ArgPos

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

Test cases: RepPolyWrappedVar, T14561, UnliftedNewtypesLevityBinder, 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 comprehension 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

Instances

Instances details
Outputable FixedRuntimeRepContext Source # 
Instance details

Defined in GHC.Tc.Types.Origin

Methods

ppr :: FixedRuntimeRepContext -> SDoc Source #

pprFixedRuntimeRepContext :: FixedRuntimeRepContext -> SDoc Source #

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

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

Instances details
Outputable StmtOrigin Source # 
Instance details

Defined in GHC.Tc.Types.Origin

Methods

ppr :: StmtOrigin -> SDoc Source #

data RepPolyFun Source #

A function with representation-polymorphic arguments, such as coerce or (#, #).

Used for reporting partial applications of representation-polymorphic functions in error messages.

Constructors

RepPolyWiredIn !Id

A wired-in function with representation-polymorphic arguments, such as coerce.

RepPolyDataCon !DataCon

A data constructor with representation-polymorphic arguments, such as an unboxed tuple or a newtype constructor with -XUnliftedNewtypes.

Instances

Instances details
Outputable RepPolyFun Source # 
Instance details

Defined in GHC.Tc.Types.Origin

Methods

ppr :: RepPolyFun -> SDoc Source #

data ArgPos Source #

The position of an argument (to be reported in an error message).

Constructors

ArgPosInvis

Invisible argument: don't report its position to the user.

ArgPosVis !Int

Visible argument in i-th position.

data ClsInstOrQC Source #

Constructors

IsClsInst 
IsQC CtOrigin 

data NakedScFlag Source #

Constructors

NakedSc 
NotNakedSc 

Instances

Instances details
Outputable NakedScFlag Source # 
Instance details

Defined in GHC.Tc.Types.Origin

Methods

ppr :: NakedScFlag -> SDoc Source #

Arrow command origin

data FRRArrowContext Source #

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

Instances details
Outputable FRRArrowContext Source # 
Instance details

Defined in GHC.Tc.Types.Origin

Methods

ppr :: FRRArrowContext -> SDoc Source #

pprFRRArrowContext :: FRRArrowContext -> SDoc Source #

data ExpectedFunTyOrigin Source #

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

ExpectedFunTyViewPat

A view pattern must have a function type.

Test cases for representation-polymorphism checks: RepPolyBinder

Fields

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

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

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

pprExpectedFunTyOrigin Source #

Arguments

:: ExpectedFunTyOrigin 
-> Int

argument position (starting at 1)

-> SDoc 

pprExpectedFunTyHerald :: ExpectedFunTyOrigin -> SDoc Source #