GHC.Tc.Errors.Types

Main types

data TcRnMessage where

An error which might arise during typechecking/renaming.

Constructors

TcRnUnknownMessage :: (Diagnostic a, Typeable a) => a -> TcRnMessage

Simply wraps a generic Diagnostic message a. It can be used by plugins to provide custom diagnostic messages originated during typechecking/renaming.

TcRnMessageWithInfo

TcRnMessageWithInfo is a constructor which is used when extra information is needed to be provided in order to qualify a diagnostic and where it was originated (and why). It carries an extra UnitState which can be used to pretty-print some names and it wraps a TcRnMessageDetailed, which includes any extra context associated with this diagnostic.

Fields

• :: !UnitState

  The UnitState will allow us to pretty-print some diagnostics with more detail.

• -> !TcRnMessageDetailed
• -> TcRnMessage

TcRnSolverReport :: [SolverReportWithCtxt] -> DiagnosticReason -> [GhcHint] -> TcRnMessage

TcRnSolverReport is the constructor used to report unsolved constraints after constraint solving, as well as other errors such as hole fit errors.

See the documentation of the TcSolverReportMsg datatype for an overview of the different errors.

TcRnRedundantConstraints

TcRnRedundantConstraints is a warning that is emitted when a binding has a user-written type signature which contains superfluous constraints.

Example:

f :: (Eq a, Ord a) => a -> a -> a f x y = (x < y) || x == y -- `Eq a` is superfluous: the `Ord a` constraint suffices.

Test cases: T9939, T10632, T18036a, T20602, PluralS, T19296.

Fields

• :: [Id]
• -> (SkolemInfoAnon, Bool)

  The contextual skolem info. The boolean controls whether we want to show it in the user message. (Nice to keep track of the info in either case, for other users of the GHC API.)

• -> TcRnMessage

TcRnInaccessibleCode

TcRnInaccessibleCode is a warning that is emitted when the RHS of a pattern match is inaccessible, because the constraint solver has detected a contradiction.

Example:

data B a where { MkTrue :: B True; MkFalse :: B False }

foo :: B False -> Bool foo MkFalse = False foo MkTrue = True -- Inaccessible: requires True ~ False

Test cases: T7293, T7294, T15558, T17646, T18572, T18610, tcfail167.

Fields

• :: Implication

  The implication containing a contradiction.

• -> NonEmpty SolverReportWithCtxt

  The contradiction(s).

• -> TcRnMessage

TcRnTypeDoesNotHaveFixedRuntimeRep :: !Type -> !FixedRuntimeRepProvenance -> !ErrInfo -> TcRnMessage

A type which was expected to have a fixed runtime representation does not have a fixed runtime representation.

Example:

data D (a :: TYPE r) = MkD a

Test cases: T11724, T18534, RepPolyPatSynArg, RepPolyPatSynUnliftedNewtype, RepPolyPatSynRes, T20423

TcRnImplicitLift :: Outputable var => var -> !ErrInfo -> TcRnMessage

TcRnImplicitLift is a warning (controlled with -Wimplicit-lift) that occurs when a Template Haskell quote implicitly uses lift.

Example: warning1 :: Lift t => t -> Q Exp warning1 x = [| x |]

Test cases: th/T17804

TcRnUnusedPatternBinds :: HsBind GhcRn -> TcRnMessage

TcRnUnusedPatternBinds is a warning (controlled with -Wunused-pattern-binds) that occurs if a pattern binding binds no variables at all, unless it is a lone wild-card pattern, or a banged pattern.

Example: Just _ = rhs3 -- Warning: unused pattern binding (_, _) = rhs4 -- Warning: unused pattern binding _ = rhs3 -- No warning: lone wild-card pattern !() = rhs4 -- No warning: banged pattern; behaves like seq

Test cases: rename/{T13646,T17c,T17e,T7085}

TcRnDodgyImports :: RdrName -> TcRnMessage

TcRnDodgyImports is a warning (controlled with -Wdodgy-imports) that occurs when a datatype T is imported with all constructors, i.e. 'T(..)', but has been exported abstractly, i.e. T.

Test cases: renameshould_compileT7167

TcRnDodgyExports :: Name -> TcRnMessage

TcRnDodgyExports is a warning (controlled by -Wdodgy-exports) that occurs when a datatype T is exported with all constructors, i.e. 'T(..)', but is it just a type synonym or a type/data family.

Example: module Foo ( T(..) -- Warning: T is a type synonym , A(..) -- Warning: A is a type family , C(..) -- Warning: C is a data family ) where

type T = Int type family A :: * -> * data family C :: * -> *

Test cases: warningsshould_compileDodgyExports01

TcRnMissingImportList :: IE GhcPs -> TcRnMessage

TcRnMissingImportList is a warning (controlled by -Wmissing-import-lists) that occurs when an import declaration does not explicitly list all the names brought into scope.

Test cases: renameshould_compileT4489

TcRnUnsafeDueToPlugin :: TcRnMessage

When a module marked trustworthy or unsafe (using -XTrustworthy or -XUnsafe) is compiled with a plugin, the TcRnUnsafeDueToPlugin warning (controlled by -Wunsafe) is used as the reason the module was inferred to be unsafe. This warning is not raised if the -fplugin-trustworthy flag is passed.

Test cases: plugins/T19926

TcRnModMissingRealSrcSpan :: Module -> TcRnMessage

TcRnModMissingRealSrcSpan is an error that occurrs when compiling a module that lacks an associated RealSrcSpan.

Test cases: None

TcRnIdNotExportedFromModuleSig :: Name -> Module -> TcRnMessage

TcRnIdNotExportedFromModuleSig is an error pertaining to backpack that occurs when an identifier required by a signature is not exported by the module or signature that is being used as a substitution for that signature.

Example(s): None

Test cases: backpackshould_failbkpfail36

TcRnIdNotExportedFromLocalSig :: Name -> TcRnMessage

TcRnIdNotExportedFromLocalSig is an error pertaining to backpack that occurs when an identifier which is necessary for implementing a module signature is not exported from that signature.

Example(s): None

Test cases: backpackshould_failbkpfail30 backpackshould_failbkpfail31 backpackshould_failbkpfail34

TcRnShadowedName :: OccName -> ShadowedNameProvenance -> TcRnMessage

TcRnShadowedName is a warning (controlled by -Wname-shadowing) that occurs whenever an inner-scope value has the same name as an outer-scope value, i.e. the inner value shadows the outer one. This can catch typographical errors that turn into hard-to-find bugs. The warning is suppressed for names beginning with an underscore.

Examples(s): f = ... let f = id in ... f ... -- NOT OK, f is shadowed f x = do { _ignore <- this; _ignore <- that; return (the other) } -- suppressed via underscore

Test cases: typecheckshould_compileT10971a renameshould_compilern039 renameshould_compilern064 renameshould_compileT1972 renameshould_failT2723 renameshould_compileT3262 driver/werror

TcRnDuplicateWarningDecls :: !(LocatedN RdrName) -> !RdrName -> TcRnMessage

TcRnDuplicateWarningDecls is an error that occurs whenever a warning is declared twice.

Examples(s): None.

Test cases: None.

TcRnSimplifierTooManyIterations

TcRnDuplicateWarningDecls is an error that occurs whenever the constraint solver in the simplifier hits the iterations' limit.

Examples(s): None.

Test cases: None.

Fields

• :: Cts
• -> !IntWithInf

  The limit.

• -> WantedConstraints
• -> TcRnMessage

TcRnIllegalPatSynDecl :: !(LIdP GhcPs) -> TcRnMessage

TcRnIllegalPatSynDecl is an error that occurs whenever there is an illegal pattern synonym declaration.

Examples(s):

varWithLocalPatSyn x = case x of P -> () where pattern P = () -- not valid, it can't be local, it must be defined at top-level.

Test cases: patsynshould_faillocal

TcRnLinearPatSyn :: !Type -> TcRnMessage

TcRnLinearPatSyn is an error that occurs whenever a pattern synonym signature uses a field that is not unrestricted.

Example(s): None

Test cases: linearshould_failLinearPatSyn2

TcRnEmptyRecordUpdate :: TcRnMessage

TcRnEmptyRecordUpdate is an error that occurs whenever a record is updated without specifying any field.

Examples(s):

$(deriveJSON defaultOptions{} ''Bad) -- not ok, no fields selected for update of defaultOptions

Test cases: th/T12788

TcRnIllegalFieldPunning :: !(Located RdrName) -> TcRnMessage

TcRnIllegalFieldPunning is an error that occurs whenever field punning is used without the NamedFieldPuns extension enabled.

Examples(s):

data Foo = Foo { a :: Int }

foo :: Foo -> Int foo Foo{a} = a -- Not ok, punning used without extension.

Test cases: parsershould_failRecordDotSyntaxFail12

TcRnIllegalWildcardsInRecord :: !RecordFieldPart -> TcRnMessage

TcRnIllegalWildcardsInRecord is an error that occurs whenever wildcards (..) are used in a record without the relevant extension being enabled.

Examples(s):

data Foo = Foo { a :: Int }

foo :: Foo -> Int foo Foo{..} = a -- Not ok, wildcards used without extension.

Test cases: parsershould_failRecordWildCardsFail

TcRnIllegalWildcardInType

TcRnIllegalWildcardInType is an error that occurs when a wildcard appears in a type in a location in which wildcards aren't allowed.

Examples:

Type synonyms:

type T = _

Class declarations and instances:

class C _ instance C _

Standalone kind signatures:

type D :: _ data D

Test cases: ExtraConstraintsWildcardInTypeSplice2 ExtraConstraintsWildcardInTypeSpliceUsed ExtraConstraintsWildcardNotLast ExtraConstraintsWildcardTwice NestedExtraConstraintsWildcard NestedNamedExtraConstraintsWildcard PartialClassMethodSignature PartialClassMethodSignature2 T12039 T13324_fail1 UnnamedConstraintWildcard1 UnnamedConstraintWildcard2 WildcardInADT1 WildcardInADT2 WildcardInADT3 WildcardInADTContext1 WildcardInDefault WildcardInDefaultSignature WildcardInDeriving WildcardInForeignExport WildcardInForeignImport WildcardInGADT1 WildcardInGADT2 WildcardInInstanceHead WildcardInInstanceSig WildcardInNewtype WildcardInPatSynSig WildcardInStandaloneDeriving WildcardInTypeFamilyInstanceRHS WildcardInTypeSynonymRHS saks_fail003 T15433a

Fields

• :: Maybe Name

  the wildcard name, or Nothing for an anonymous wildcard

• -> !BadAnonWildcardContext
• -> !(Maybe HsDocContext)
• -> TcRnMessage

TcRnDuplicateFieldName :: !RecordFieldPart -> NonEmpty RdrName -> TcRnMessage

TcRnDuplicateFieldName is an error that occurs whenever there are duplicate field names in a record.

Examples(s): None.

Test cases: None.

TcRnIllegalViewPattern :: !(Pat GhcPs) -> TcRnMessage

TcRnIllegalViewPattern is an error that occurs whenever the ViewPatterns syntax is used but the ViewPatterns language extension is not enabled.

Examples(s): data Foo = Foo { a :: Int }

foo :: Foo -> Int foo (a -> l) = l -- not OK, the ViewPattern extension is not enabled.

Test cases: parsershould_failViewPatternsFail

TcRnCharLiteralOutOfRange :: !Char -> TcRnMessage

TcRnCharLiteralOutOfRange is an error that occurs whenever a character is out of range.

Examples(s): None

Test cases: None

TcRnIllegalWildcardsInConstructor :: !Name -> TcRnMessage

TcRnIllegalWildcardsInConstructor is an error that occurs whenever the record wildcards '..' are used inside a constructor without labeled fields.

Examples(s): None

Test cases: None

TcRnIgnoringAnnotations :: [LAnnDecl GhcRn] -> TcRnMessage

TcRnIgnoringAnnotations is a warning that occurs when the source code contains annotation pragmas but the platform in use does not support an external interpreter such as GHCi and therefore the annotations are ignored.

Example(s): None

Test cases: None

TcRnAnnotationInSafeHaskell :: TcRnMessage

TcRnAnnotationInSafeHaskell is an error that occurs if annotation pragmas are used in conjunction with Safe Haskell.

Example(s): None

Test cases: annotationsshould_failT10826

TcRnInvalidTypeApplication :: Type -> LHsWcType GhcRn -> TcRnMessage

TcRnInvalidTypeApplication is an error that occurs when a visible type application is used with an expression that does not accept "specified" type arguments.

Example(s): foo :: forall {a}. a -> a foo x = x bar :: () bar = let x = foo @Int 42 in ()

Test cases: overloadedrecfldsshould_failoverloadedlabelsfail03 typecheckshould_failExplicitSpecificity1 typecheckshould_failExplicitSpecificity10 typecheckshould_failExplicitSpecificity2 typecheckshould_failT17173 typecheckshould_failVtaFail

TcRnTagToEnumMissingValArg :: TcRnMessage

TcRnTagToEnumMissingValArg is an error that occurs when the 'tagToEnum#' function is not applied to a single value argument.

Example(s): tagToEnum# 1 2

Test cases: None

TcRnTagToEnumUnspecifiedResTy :: Type -> TcRnMessage

TcRnTagToEnumUnspecifiedResTy is an error that occurs when the 'tagToEnum#' function is not given a concrete result type.

Example(s): foo :: forall a. a foo = tagToEnum# 0#

Test cases: typecheckshould_failtcfail164

TcRnTagToEnumResTyNotAnEnum :: Type -> TcRnMessage

TcRnTagToEnumResTyNotAnEnum is an error that occurs when the 'tagToEnum#' function is given a result type that is not an enumeration type.

Example(s): foo :: Int -- not an enumeration TyCon foo = tagToEnum# 0#

Test cases: typecheckshould_failtcfail164

TcRnArrowIfThenElsePredDependsOnResultTy :: TcRnMessage

TcRnArrowIfThenElsePredDependsOnResultTy is an error that occurs when the predicate type of an ifThenElse expression in arrow notation depends on the type of the result.

Example(s): None

Test cases: None

TcRnIllegalHsBootFileDecl :: TcRnMessage

TcRnIllegalHsBootFileDecl is an error that occurs when an hs-boot file contains declarations that are not allowed, such as bindings.

Example(s): None

Test cases: None

TcRnRecursivePatternSynonym :: LHsBinds GhcRn -> TcRnMessage

TcRnRecursivePatternSynonym is an error that occurs when a pattern synonym is defined in terms of itself, either directly or indirectly.

Example(s): pattern A = B pattern B = A

Test cases: patsynshould_failT16900

TcRnPartialTypeSigTyVarMismatch

TcRnPartialTypeSigTyVarMismatch is an error that occurs when a partial type signature attempts to unify two different types.

Example(s): f :: a -> b -> _ f x y = [x, y]

Test cases: partial-sigsshould_failT14449

Fields

• :: Name

  first type variable

• -> Name

  second type variable

• -> Name

  function name

• -> LHsSigWcType GhcRn
• -> TcRnMessage

TcRnPartialTypeSigBadQuantifier

TcRnPartialTypeSigBadQuantifier is an error that occurs when a type variable being quantified over in the partial type signature of a function gets unified with a type that is free in that function's context.

Example(s): foo :: Num a => a -> a foo xxx = g xxx where g :: forall b. Num b => _ -> b g y = xxx + y

Test cases: partial-sigshould_failT14479

Fields

• :: Name

  user-written name of type variable being quantified

• -> Name

  function name

• -> Maybe Type

  type the variable unified with, if known

• -> LHsSigWcType GhcRn

  partial type signature

• -> TcRnMessage

TcRnMissingSignature

TcRnMissingSignature is a warning that occurs when a top-level binding or a pattern synonym does not have a type signature.

Controlled by the flags: -Wmissing-signatures -Wmissing-exported-signatures -Wmissing-pattern-synonym-signatures -Wmissing-exported-pattern-synonym-signatures -Wmissing-kind-signatures

Test cases: T11077 (top-level bindings) T12484 (pattern synonyms) T19564 (kind signatures)

Fields

• :: MissingSignature
• -> Exported
• -> Bool

  True: -Wmissing-signatures overrides -Wmissing-exported-signatures, or -Wmissing-pattern-synonym-signatures overrides -Wmissing-exported-pattern-synonym-signatures

• -> TcRnMessage

TcRnPolymorphicBinderMissingSig :: Name -> Type -> TcRnMessage

TcRnPolymorphicBinderMissingSig is a warning controlled by -Wmissing-local-signatures that occurs when a local polymorphic binding lacks a type signature.

Example(s): id a = a

Test cases: warningsshould_compileT12574

TcRnOverloadedSig :: TcIdSigInfo -> TcRnMessage

TcRnOverloadedSig is an error that occurs when a binding group conflicts with the monomorphism restriction.

Example(s): data T a = T a mono = ... where x :: Applicative f => f a T x = ...

Test cases: typecheckshould_compileT11339

TcRnTupleConstraintInst :: !Class -> TcRnMessage

TcRnTupleConstraintInst is an error that occurs whenever an instance for a tuple constraint is specified.

Examples(s): class C m a class D m a f :: (forall a. Eq a => (C m a, D m a)) => m a f = undefined

Test cases: quantified-constraints/T15334

TcRnAbstractClassInst :: !Class -> TcRnMessage

TcRnAbstractClassInst is an error that occurs whenever an instance of an abstract class is specified.

Examples(s): -- A.hs-boot module A where class C a

• - B.hs module B where import {-# SOURCE #-} A instance C Int where
• - A.hs module A where import B class C a where f :: a
• - Main.hs import A main = print (f :: Int)

Test cases: typecheckshould_failT13068

TcRnNoClassInstHead :: !Type -> TcRnMessage

TcRnNoClassInstHead is an error that occurs whenever an instance head is not headed by a class.

Examples(s): instance c

Test cases: typecheckrenameT5513 typecheckrenameT16385

TcRnUserTypeError :: !Type -> TcRnMessage

TcRnUserTypeError is an error that occurs due to a user's custom type error, which can be triggered by adding a TypeError constraint in a type signature or typeclass instance.

Examples(s): f :: TypeError (Text "This is a type error") f = undefined

Test cases: typecheckshould_failCustomTypeErrors02 typecheckshould_failCustomTypeErrors03

TcRnConstraintInKind :: !Type -> TcRnMessage

TcRnConstraintInKind is an error that occurs whenever a constraint is specified in a kind.

Examples(s): data Q :: Eq a => Type where {}

Test cases: dependentshould_failT13895 polykinds/T16263 saksshould_failsaks_fail004 typecheckshould_failT16059a typecheckshould_failT18714

TcRnUnboxedTupleOrSumTypeFuncArg

TcRnUnboxedTupleTypeFuncArg is an error that occurs whenever an unboxed tuple or unboxed sum type is specified as a function argument, when the appropriate extension (`-XUnboxedTuples` or `-XUnboxedSums`) isn't enabled.

Examples(s): -- T15073.hs import T15073a newtype Foo a = MkFoo a deriving P

• - T15073a.hs class P a where p :: a -> (# a #)

Test cases: derivingshould_failT15073.hs derivingshould_failT15073a.hs typecheckshould_failT16059d

Fields

• :: UnboxedTupleOrSum

  whether this is an unboxed tuple or an unboxed sum

• -> !Type
• -> TcRnMessage

TcRnLinearFuncInKind :: !Type -> TcRnMessage

TcRnLinearFuncInKind is an error that occurs whenever a linear function is specified in a kind.

Examples(s): data A :: * %1 -> *

Test cases: linearshould_failLinearKind linearshould_failLinearKind2 linearshould_failLinearKind3

TcRnForAllEscapeError :: !Type -> !Kind -> TcRnMessage

TcRnForAllEscapeError is an error that occurs whenever a quantified type's kind mentions quantified type variable.

Examples(s): type T :: TYPE (BoxedRep l) data T = MkT

Test cases: unlifted-datatypesshould_failUnlDataNullaryPoly

TcRnVDQInTermType :: !Type -> TcRnMessage

TcRnVDQInTermType is an error that occurs whenever a visible dependent quantification is specified in the type of a term.

Examples(s): a = (undefined :: forall k -> k -> Type) @Int

Test cases: dependentshould_failT15859 dependentshould_failT16326_Fail1 dependentshould_failT16326_Fail2 dependentshould_failT16326_Fail3 dependentshould_failT16326_Fail4 dependentshould_failT16326_Fail5 dependentshould_failT16326_Fail6 dependentshould_failT16326_Fail7 dependentshould_failT16326_Fail8 dependentshould_failT16326_Fail9 dependentshould_failT16326_Fail10 dependentshould_failT16326_Fail11 dependentshould_failT16326_Fail12 dependentshould_failT17687 dependentshould_failT18271

TcRnBadQuantPredHead :: !Type -> TcRnMessage

TcRnBadQuantPredHead is an error that occurs whenever a quantified predicate lacks a class or type variable head.

Examples(s): class (forall a. A t a => A t [a]) => B t where type A t a :: Constraint

Test cases: quantified-constraints/T16474

TcRnIllegalTupleConstraint :: !Type -> TcRnMessage

TcRnIllegalTupleConstraint is an error that occurs whenever an illegal tuple constraint is specified.

Examples(s): g :: ((Show a, Num a), Eq a) => a -> a g = undefined

Test cases: typecheckshould_failtcfail209a

TcRnNonTypeVarArgInConstraint :: !Type -> TcRnMessage

TcRnNonTypeVarArgInConstraint is an error that occurs whenever a non type-variable argument is specified in a constraint.

Examples(s): data T instance Eq Int => Eq T

Test cases: ghciscriptsT13202 ghciscriptsT13202a polykinds/T12055a typecheckshould_failT10351 typecheckshould_failT19187 typecheckshould_failT6022 typecheckshould_failT8883

TcRnIllegalImplicitParam :: !Type -> TcRnMessage

TcRnIllegalImplicitParam is an error that occurs whenever an illegal implicit parameter is specified.

Examples(s): type Bla = ?x::Int data T = T instance Bla => Eq T

Test cases: polykinds/T11466 typecheckshould_failT8912 typecheckshould_failtcfail041 typecheckshould_failtcfail211 typecheckshould_failtcrun045

TcRnIllegalConstraintSynonymOfKind :: !Type -> TcRnMessage

TcRnIllegalConstraintSynonymOfKind is an error that occurs whenever an illegal constraint synonym of kind is specified.

Examples(s): type Showish = Show f :: (Showish a) => a -> a f = undefined

Test cases: typecheckshould_failtcfail209

TcRnIllegalClassInst :: !TyConFlavour -> TcRnMessage

TcRnIllegalClassInst is an error that occurs whenever a class instance is specified for a non-class.

Examples(s): type C1 a = (Show (a -> Bool)) instance C1 Int where

Test cases: polykinds/T13267

TcRnOversaturatedVisibleKindArg :: !Type -> TcRnMessage

TcRnOversaturatedVisibleKindArg is an error that occurs whenever an illegal oversaturated visible kind argument is specified.

Examples(s): type family F2 :: forall (a :: Type). Type where F2 @a = Maybe a

Test cases: typecheckshould_failT15793 typecheckshould_failT16255

TcRnBadAssociatedType :: !Name -> !Name -> TcRnMessage

TcRnBadAssociatedType is an error that occurs whenever a class doesn't have an associated type.

Examples(s): $(do d <- instanceD (cxt []) (conT ''Eq appT conT ''Foo) [tySynInstD $ tySynEqn Nothing (conT ''Rep appT conT ''Foo) (conT ''Maybe)] return [d]) ======> instance Eq Foo where type Rep Foo = Maybe

Test cases: th/T12387a

TcRnForAllRankErr :: !Rank -> !Type -> TcRnMessage

TcRnForAllRankErr is an error that occurs whenever an illegal ranked type is specified.

Examples(s): foo :: (a,b) -> (a~b => t) -> (a,b) foo p x = p

Test cases: - ghcishould_runT15806 - indexed-typesshould_failSimpleFail15 - typecheckshould_failT11355 - typecheckshould_failT12083a - typecheckshould_failT12083b - typecheckshould_failT16059c - typecheckshould_failT16059e - typecheckshould_failT17213 - typecheckshould_failT18939_Fail - typecheckshould_failT2538 - typecheckshould_failT5957 - typecheckshould_failT7019 - typecheckshould_failT7019a - typecheckshould_failT7809 - typecheckshould_failT9196 - typecheckshould_failtcfail127 - typecheckshould_failtcfail184 - typecheckshould_failtcfail196 - typecheckshould_failtcfail197

TcRnMonomorphicBindings :: [Name] -> TcRnMessage

TcRnMonomorphicBindings is a warning (controlled by -Wmonomorphism-restriction) that arise when the monomorphism restriction applies to the given bindings.

Examples(s): {-# OPTIONS_GHC -Wmonomorphism-restriction #-}

bar = 10

foo :: Int foo = bar

main :: IO () main = print foo

The example above emits the warning (for bar), because without monomorphism restriction the inferred type for bar is 'bar :: Num p => p'. This warning tells us that if we were to enable '-XMonomorphismRestriction' we would make bar less polymorphic, as its type would become 'bar :: Int', so GHC warns us about that.

Test cases: typecheckshould_compileT13785

TcRnOrphanInstance :: ClsInst -> TcRnMessage

TcRnOrphanInstance is a warning (controlled by -Wwarn-orphans) that arises when a typeclass instance is an "orphan", i.e. if it appears in a module in which neither the class nor the type being instanced are declared in the same module.

Examples(s): None

Test cases: warningsshould_compileT9178 typecheckshould_compileT4912

TcRnFunDepConflict :: !UnitState -> NonEmpty ClsInst -> TcRnMessage

TcRnFunDepConflict is an error that occurs when there are functional dependencies conflicts between instance declarations.

Examples(s): None

Test cases: typecheckshould_failT2307 typecheckshould_failtcfail096 typecheckshould_failtcfail202

TcRnDupInstanceDecls :: !UnitState -> NonEmpty ClsInst -> TcRnMessage

TcRnDupInstanceDecls is an error that occurs when there are duplicate instance declarations.

Examples(s): class Foo a where foo :: a -> Int

instance Foo Int where foo = id

instance Foo Int where foo = const 42

Test cases: cabalT12733T12733 typecheckshould_failtcfail035 typecheckshould_failtcfail023 backpackshould_failbkpfail18 typecheckshould_failTcNullaryTCFail typecheckshould_failtcfail036 typecheckshould_failtcfail073 module/mod51 module/mod52 module/mod44

TcRnConflictingFamInstDecls :: NonEmpty FamInst -> TcRnMessage

TcRnConflictingFamInstDecls is an error that occurs when there are conflicting family instance declarations.

Examples(s): None.

Test cases: indexed-typesshould_failExplicitForAllFams4b indexed-typesshould_failNoGood indexed-typesshould_failOver indexed-typesshould_failOverDirectThisMod indexed-typesshould_failOverIndirectThisMod indexed-typesshould_failSimpleFail11a indexed-typesshould_failSimpleFail11b indexed-typesshould_failSimpleFail11c indexed-typesshould_failSimpleFail11d indexed-typesshould_failSimpleFail2a indexed-typesshould_failSimpleFail2b indexed-typesshould_failT13092/T13092 indexed-typesshould_failT13092c/T13092c indexed-typesshould_failT14179 indexed-typesshould_failT2334A indexed-typesshould_failT2677 indexed-typesshould_failT3330b indexed-typesshould_failT4246 indexed-typesshould_failT7102a indexed-typesshould_failT9371 polykinds/T7524 typecheckshould_failUnliftedNewtypesOverlap

TcRnFamInstNotInjective :: InjectivityErrReason -> TyCon -> NonEmpty CoAxBranch -> TcRnMessage

TcRnBangOnUnliftedType :: !Type -> TcRnMessage

TcRnBangOnUnliftedType is a warning (controlled by -Wredundant-strictness-flags) that occurs when a strictness annotation is applied to an unlifted type.

Example(s): data T = MkT !Int# -- Strictness flag has no effect on unlifted types

Test cases: typecheckshould_compileT20187a typecheckshould_compileT20187b

TcRnMultipleDefaultDeclarations :: [LDefaultDecl GhcRn] -> TcRnMessage

TcRnMultipleDefaultDeclarations is an error that occurs when a module has more than one default declaration.

Example: default (Integer, Int) default (Double, Float) -- 2nd default declaration not allowed

Text cases: module/mod58

TcRnBadDefaultType :: Type -> [Class] -> TcRnMessage

TcRnBadDefaultType is an error that occurs when a type used in a default declaration does not have an instance for any of the applicable classes.

Example(s): data Foo default (Foo)

Test cases: typecheckshould_failT11974b

TcRnPatSynBundledWithNonDataCon :: TcRnMessage

TcRnPatSynBundledWithNonDataCon is an error that occurs when a module's export list bundles a pattern synonym with a type that is not a proper `data` or `newtype` construction.

Example(s): module Foo (MyClass(.., P)) where pattern P = Nothing class MyClass a where foo :: a -> Int

Test cases: patsynshould_failexport-class

TcRnPatSynBundledWithWrongType :: Type -> Type -> TcRnMessage

TcRnPatSynBundledWithWrongType is an error that occurs when the export list of a module has a pattern synonym bundled with a type that does not match the type of the pattern synonym.

Example(s): module Foo (R(P,x)) where data Q = Q Int data R = R pattern P{x} = Q x

Text cases: patsynshould_failexport-ps-rec-sel patsynshould_failexport-type-synonym patsynshould_failexport-type

TcRnDupeModuleExport :: ModuleName -> TcRnMessage

TcRnDupeModuleExport is a warning controlled by -Wduplicate-exports that occurs when a module appears more than once in an export list.

Example(s): module Foo (module Bar, module Bar) import Bar

Text cases: None

TcRnExportedModNotImported :: ModuleName -> TcRnMessage

TcRnExportedModNotImported is an error that occurs when an export list contains a module that is not imported.

Example(s): None

Text cases: module/mod135 module/mod8 renameshould_failrnfail028 backpackshould_failbkpfail48

TcRnNullExportedModule :: ModuleName -> TcRnMessage

TcRnNullExportedModule is a warning controlled by -Wdodgy-exports that occurs when an export list contains a module that has no exports.

Example(s): module Foo (module Bar) where import Bar ()

Test cases: None

TcRnMissingExportList :: ModuleName -> TcRnMessage

TcRnMissingExportList is a warning controlled by -Wmissing-export-lists that occurs when a module does not have an explicit export list.

Example(s): None

Test cases: typecheckshould_failMissingExportList03

TcRnExportHiddenComponents :: IE GhcPs -> TcRnMessage

TcRnExportHiddenComponents is an error that occurs when an export contains constructor or class methods that are not visible.

Example(s): None

Test cases: None

TcRnDuplicateExport :: GreName -> IE GhcPs -> IE GhcPs -> TcRnMessage

TcRnDuplicateExport is a warning (controlled by -Wduplicate-exports) that occurs when an identifier appears in an export list more than once.

Example(s): None

Test cases: module/MultiExport module/mod128 module/mod14 module/mod5 overloadedrecfldsshould_failDuplicateExports patsynshould_compileT11959

TcRnExportedParentChildMismatch :: Name -> TyThing -> GreName -> [Name] -> TcRnMessage

TcRnExportedParentChildMismatch is an error that occurs when an export is bundled with a parent that it does not belong to

Example(s): module Foo (T(a)) where data T a = True

Test cases: module/T11970 module/T11970B module/mod17 module/mod3 overloadedrecfldsshould_failNoParent

TcRnConflictingExports

TcRnConflictingExports is an error that occurs when different identifiers that have the same name are being exported by a module.

Example(s): module Foo (Bar.f, module Baz) where import qualified Bar (f) import Baz (f)

Test cases: module/mod131 module/mod142 module/mod143 module/mod144 module/mod145 module/mod146 module/mod150 module/mod155 overloadedrecfldsshould_failT14953 overloadedrecfldsshould_failoverloadedrecfldsfail10 renameshould_failrnfail029 renameshould_failrnfail040 typecheckshould_failT16453E2 typecheckshould_failtcfail025 typecheckshould_failtcfail026

Fields

• :: OccName

  Occurrence name shared by both exports

• -> GreName

  Name of first export

• -> GlobalRdrElt

  Provenance for definition site of first export

• -> IE GhcPs

  Export decl of first export

• -> GreName

  Name of second export

• -> GlobalRdrElt

  Provenance for definition site of second export

• -> IE GhcPs

  Export decl of second export

• -> TcRnMessage

TcRnAmbiguousField

TcRnAmbiguousField is a warning controlled by -Wambiguous-fields occurring when a record update's type cannot be precisely determined. This will not be supported by -XDuplicateRecordFields in future releases.

Example(s): data Person = MkPerson { personId :: Int, name :: String } data Address = MkAddress { personId :: Int, address :: String } bad1 x = x { personId = 4 } :: Person -- ambiguous bad2 (x :: Person) = x { personId = 4 } -- ambiguous good x = (x :: Person) { personId = 4 } -- not ambiguous

Test cases: overloadedrecfldsshould_failoverloadedrecfldsfail06

Fields

• :: HsExpr GhcRn

  Field update

• -> TyCon

  Record type

• -> TcRnMessage

TcRnMissingFields :: ConLike -> [(FieldLabelString, TcType)] -> TcRnMessage

TcRnMissingFields is a warning controlled by -Wmissing-fields occurring when the intialisation of a record is missing one or more (lazy) fields.

Example(s): data Rec = Rec { a :: Int, b :: String, c :: Bool } x = Rec { a = 1, b = "two" } -- missing field c

Test cases: deSugarshould_compileT13870 deSugarshould_compileds041 patsynshould_compileT11283 renameshould_compileT5334 renameshould_compileT12229 renameshould_compileT5892a warningsshould_failWerrorFail2

TcRnFieldUpdateInvalidType :: [(FieldLabelString, TcType)] -> TcRnMessage

TcRnFieldUpdateInvalidType is an error occurring when an updated field's type mentions something that is outside the universally quantified variables of the data constructor, such as an existentially quantified type.

Example(s): data X = forall a. MkX { f :: a } x = (MkX ()) { f = False }

Test cases: patsynshould_failrecords-exquant typecheckshould_failT3323

TcRnNoConstructorHasAllFields :: [FieldLabelString] -> TcRnMessage

TcRnNoConstructorHasAllFields is an error that occurs when a record update has fields that no single constructor encompasses.

Example(s): data Foo = A { x :: Bool } | B { y :: Int } foo = (A False) { x = True, y = 5 }

Test cases: overloadedrecfldsshould_failoverloadedrecfldsfail08 patsynshould_failmixed-pat-syn-record-sels typecheckshould_failT7989

TcRnMixedSelectors

Fields

• :: Name

  Record

• -> [Id]

  Record selectors

• -> Name

  Pattern synonym

• -> [Id]

  Pattern selectors

• -> TcRnMessage

TcRnMissingStrictFields :: ConLike -> [(FieldLabelString, TcType)] -> TcRnMessage

TcRnNoPossibleParentForFields :: [LHsRecUpdField GhcRn] -> TcRnMessage

TcRnBadOverloadedRecordUpdate :: [LHsRecUpdField GhcRn] -> TcRnMessage

TcRnStaticFormNotClosed :: Name -> NotClosedReason -> TcRnMessage

TcRnSpecialClassInst

TcRnSpecialClassInst is an error that occurs when a user attempts to define an instance for a built-in typeclass such as Coercible, Typeable, or KnownNat, outside of a signature file.

Test cases: derivingshould_failT9687 derivingshould_failT14916 polykinds/T8132 typecheckshould_failTcCoercibleFail2 typecheckshould_failT12837 typecheckshould_failT14390

Fields

• :: !Class
• -> !Bool

  Whether the error is due to Safe Haskell being enabled

• -> TcRnMessage

TcRnUselessTypeable :: TcRnMessage

TcRnUselessTypeable is a warning (controlled by -Wderiving-typeable) that occurs when trying to derive an instance of the Typeable class. Deriving Typeable is no longer necessary (hence the "useless") as all types automatically derive Typeable in modern GHC versions.

Example(s): None.

Test cases: warningsshould_compileDerivingTypeable

TcRnDerivingDefaults :: !Class -> TcRnMessage

TcRnDerivingDefaults is a warning (controlled by -Wderiving-defaults) that occurs when both DeriveAnyClass and GeneralizedNewtypeDeriving are enabled, and therefore GHC defaults to DeriveAnyClass, which might not be what the user wants.

Example(s): None.

Test cases: typecheckshould_compileT15839a derivingshould_compileT16179

TcRnNonUnaryTypeclassConstraint :: !(LHsSigType GhcRn) -> TcRnMessage

TcRnNonUnaryTypeclassConstraint is an error that occurs when GHC encounters a non-unary constraint when trying to derive a typeclass.

Example(s): class A deriving instance A data B deriving A -- We cannot derive A, is not unary (i.e. 'class A a').

Test cases: derivingshould_failT7959 derivingshould_faildrvfail005 derivingshould_faildrvfail009 derivingshould_faildrvfail006

TcRnPartialTypeSignatures :: !SuggestPartialTypeSignatures -> !ThetaType -> TcRnMessage

TcRnPartialTypeSignatures is a warning (controlled by -Wpartial-type-signatures) that occurs when a wildcard '_' is found in place of a type in a signature or a type class derivation

Example(s): foo :: _ -> Int foo = ...

deriving instance _ => Eq (Foo a)

Test cases: dependentshould_compileT11241 dependentshould_compileT15076 dependentshould_compileT14880-2 typecheckshould_compileT17024 typecheckshould_compileT10072 partial-sigsshould_failTidyClash2 partial-sigsshould_failDefaulting1MROff partial-sigsshould_failWildcardsInPatternAndExprSig partial-sigsshould_failT10615 partial-sigsshould_failT14584a partial-sigsshould_failTidyClash partial-sigsshould_failT11122 partial-sigsshould_failT14584 partial-sigsshould_failT10045 partial-sigsshould_failPartialTypeSignaturesDisabled partial-sigsshould_failT10999 partial-sigsshould_failExtraConstraintsWildcardInExpressionSignature partial-sigsshould_failExtraConstraintsWildcardInPatternSplice partial-sigsshould_failWildcardInstantiations partial-sigsshould_runT15415 partial-sigsshould_compileT10463 partial-sigsshould_compileT15039a partial-sigsshould_compileT16728b partial-sigsshould_compileT15039c partial-sigsshould_compileT10438 partial-sigsshould_compileSplicesUsed partial-sigsshould_compileT18008 partial-sigsshould_compileExprSigLocal partial-sigsshould_compileT11339a partial-sigsshould_compileT11670 partial-sigsshould_compileWarningWildcardInstantiations partial-sigsshould_compileT16728 partial-sigsshould_compileT12033 partial-sigsshould_compileT15039b partial-sigsshould_compileT10403 partial-sigsshould_compileT11192 partial-sigsshould_compileT16728a partial-sigsshould_compileTypedSplice partial-sigsshould_compileT15039d partial-sigsshould_compileT11016 partial-sigsshould_compileT13324_compile2 linearshould_failLinearPartialSig polykinds/T14265 polykinds/T14172

TcRnCannotDeriveInstance

TcRnCannotDeriveInstance is an error that occurs every time a typeclass instance can't be derived. The DeriveInstanceErrReason will contain the specific reason this error arose.

Example(s): None.

Test cases: genericsT10604T10604_no_PolyKinds derivingshould_faildrvfail009 derivingshould_faildrvfail-functor2 derivingshould_failT10598_fail3 derivingshould_failderiving-via-fail2 derivingshould_failderiving-via-fail derivingshould_failT16181

Fields

• :: !Class

  The typeclass we are trying to derive an instance for

• -> [Type]

  The typeclass arguments, if any.

• -> !(Maybe (DerivStrategy GhcTc))

  The derivation strategy, if any.

• -> !UsingGeneralizedNewtypeDeriving

  Is '-XGeneralizedNewtypeDeriving' enabled?

• -> !DeriveInstanceErrReason

  The specific reason why we couldn't derive an instance for the class.

• -> TcRnMessage

TcRnLazyGADTPattern :: TcRnMessage

TcRnLazyGADTPattern is an error that occurs when a user writes a nested GADT pattern match inside a lazy (~) pattern.

Test case: gadt/lazypat

TcRnArrowProcGADTPattern :: TcRnMessage

TcRnArrowProcGADTPattern is an error that occurs when a user writes a GADT pattern inside arrow proc notation.

Test case: arrowsshould_failarrowfail004.

TcRnForallIdentifier :: RdrName -> TcRnMessage

TcRnForallIdentifier is a warning (controlled with -Wforall-identifier) that occurs when a definition uses forall as an identifier.

Example: forall x = () g forall = ()

Test cases: T20609 T20609a T20609b T20609c T20609d

TcRnTypeEqualityOutOfScope :: TcRnMessage

TcRnTypeEqualityOutOfScope is a warning (controlled by -Wtype-equality-out-of-scope) that occurs when the type equality (a ~ b) is not in scope.

Test case: T18862b

TcRnTypeEqualityRequiresOperators :: TcRnMessage

TcRnTypeEqualityRequiresOperators is a warning (controlled by -Wtype-equality-requires-operators) that occurs when the type equality (a ~ b) is used without the TypeOperators extension.

Example: {-# LANGUAGE NoTypeOperators #-} f :: (a ~ b) => a -> b

Test case: T18862a

TcRnIllegalTypeOperator :: !SDoc -> !RdrName -> TcRnMessage

TcRnIllegalTypeOperator is an error that occurs when a type operator is used without the TypeOperators extension.

Example: {-# LANGUAGE NoTypeOperators #-} f :: Vec a n -> Vec a m -> Vec a (n + m)

Test case: T12811

TcRnGADTMonoLocalBinds :: TcRnMessage

TcRnGADTMonoLocalBinds is a warning controlled by -Wgadt-mono-local-binds that occurs when pattern matching on a GADT when -XMonoLocalBinds is off.

Example(s): None

Test cases: T20485, T20485a

TcRnNotInScope

The TcRnNotInScope constructor is used for various not-in-scope errors. See NotInScopeError for more details.

Fields

• :: NotInScopeError

  what the problem is

• -> RdrName

  the name that is not in scope

• -> [ImportError]

  import errors that are relevant

• -> [GhcHint]

  hints, e.g. enable DataKinds to refer to a promoted data constructor

• -> TcRnMessage

TcRnUntickedPromotedThing :: UntickedPromotedThing -> TcRnMessage

TcRnUntickedPromotedThing is a warning (controlled with -Wunticked-promoted-constructors) that is triggered by an unticked occurrence of a promoted data constructor.

Examples:

data A = MkA type family F (a :: A) where { F MkA = Bool }

type B = [ Int, Bool ]

Test cases: T9778, T19984.

TcRnIllegalBuiltinSyntax

TcRnIllegalBuiltinSyntax is an error that occurs when built-in syntax appears in an unexpected location, e.g. as a data constructor or in a fixity declaration.

Examples:

infixl 5 :

data P = (,)

Test cases: rnfail042, T14907b, T15124, T15233.

Fields

• :: SDoc

  what kind of thing this is (a binding, fixity declaration, ...)

• -> RdrName
• -> TcRnMessage

TcRnWarnDefaulting

TcRnWarnDefaulting is a warning (controlled by -Wtype-defaults) that is triggered whenever a Wanted typeclass constraint is solving through the defaulting of a type variable.

Example:

one = show 1 -- We get Wanteds Show a0, Num a0, and default a0 to Integer.

Test cases: none (which are really specific to defaulting), but see e.g. tcfail204.

Fields

• :: [Ct]

  Wanted constraints in which defaulting occurred

• -> Maybe TyVar

  The type variable being defaulted

• -> Type

  The default type

• -> TcRnMessage

TcRnIncorrectNameSpace

TcRnIncorrectNameSpace is an error that occurs when a Name is used in the incorrect NameSpace, e.g. a type constructor or class used in a term, or a term variable used in a type.

Example:

f x = Int

Test cases: T18740a, T20884.

Fields

• :: Name
• -> Bool

  whether the error is happening in a Template Haskell tick (so we should give a Template Haskell hint)

• -> TcRnMessage

TcRnForeignImportPrimExtNotSet :: ForeignImport -> TcRnMessage

TcRnForeignImportPrimSafeAnn :: ForeignImport -> TcRnMessage

TcRnForeignFunctionImportAsValue :: ForeignImport -> TcRnMessage

TcRnFunPtrImportWithoutAmpersand :: ForeignImport -> TcRnMessage

TcRnIllegalForeignDeclBackend :: Either ForeignExport ForeignImport -> Backend -> ExpectedBackends -> TcRnMessage

TcRnUnsupportedCallConv :: Either ForeignExport ForeignImport -> UnsupportedCallConvention -> TcRnMessage

TcRnIllegalForeignType :: !(Maybe ArgOrResult) -> !IllegalForeignTypeReason -> TcRnMessage

TcRnInvalidCIdentifier :: !CLabelString -> TcRnMessage

Instances

Diagnostic TcRnMessage

Defined in GHC.Tc.Errors.Ppr

Methods

diagnosticMessage :: TcRnMessage -> DecoratedSDoc

diagnosticReason :: TcRnMessage -> DiagnosticReason

diagnosticHints :: TcRnMessage -> [GhcHint]

data TcRnMessageDetailed

TcRnMessageDetailed is an "internal" type (used only inside Monad that wraps a TcRnMessage while also providing any extra info needed to correctly pretty-print this diagnostic later on.

Constructors

TcRnMessageDetailed

Fields

• !ErrInfo

  Extra info associated with the message

• !TcRnMessage

data ErrInfo

Constructors

ErrInfo

Fields

• errInfoContext :: !SDoc

  Extra context associated to the error.

• errInfoSupplementary :: !SDoc

  Extra supplementary info associated to the error.

data FixedRuntimeRepProvenance

In what context did we require a type to have a fixed runtime representation?

Used by checkTypeHasFixedRuntimeRep for throwing representation polymorphism errors when validity checking.

See Note [Representation polymorphism checking] in GHC.Tc.Utils.Concrete

Constructors

FixedRuntimeRepDataConField

Data constructor fields must have a fixed runtime representation.

Tests: T11734, T18534.

FixedRuntimeRepPatSynSigArg

Pattern synonym signature arguments must have a fixed runtime representation.

Test: RepPolyPatSynArg.

FixedRuntimeRepPatSynSigRes

Pattern synonym signature scrutinee must have a fixed runtime representation.

Test: RepPolyPatSynRes.

pprFixedRuntimeRepProvenance :: FixedRuntimeRepProvenance -> SDoc

data ShadowedNameProvenance

Where a shadowed name comes from

Constructors

ShadowedNameProvenanceLocal !SrcLoc

The shadowed name is local to the module

ShadowedNameProvenanceGlobal [GlobalRdrElt]

The shadowed name is global, typically imported from elsewhere.

data RecordFieldPart

Which parts of a record field are affected by a particular error or warning.

Constructors

RecordFieldConstructor !Name

RecordFieldPattern !Name

RecordFieldUpdate

data InjectivityErrReason

Why the particular injectivity error arose together with more information, if any.

Constructors

InjErrRhsBareTyVar [Type]

InjErrRhsCannotBeATypeFam

InjErrRhsOverlap

InjErrCannotInferFromRhs !TyVarSet !HasKinds !SuggestUndecidableInstances

data HasKinds

Constructors

YesHasKinds

NoHasKinds

Instances

Show HasKinds

Defined in GHC.Tc.Errors.Types

Methods

showsPrec :: Int -> HasKinds -> ShowS

show :: HasKinds -> String

showList :: [HasKinds] -> ShowS

Eq HasKinds

Defined in GHC.Tc.Errors.Types

Methods

(==) :: HasKinds -> HasKinds -> Bool

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

hasKinds :: Bool -> HasKinds

data SuggestUndecidableInstances

Constructors

YesSuggestUndecidableInstaces

NoSuggestUndecidableInstaces

Instances

Show SuggestUndecidableInstances

Defined in GHC.Tc.Errors.Types

Methods

showsPrec :: Int -> SuggestUndecidableInstances -> ShowS

show :: SuggestUndecidableInstances -> String

showList :: [SuggestUndecidableInstances] -> ShowS

Eq SuggestUndecidableInstances

Defined in GHC.Tc.Errors.Types

Methods

(==) :: SuggestUndecidableInstances -> SuggestUndecidableInstances -> Bool

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

suggestUndecidableInstances :: Bool -> SuggestUndecidableInstances

data NotClosedReason

A data type to describe why a variable is not closed. See Note [Not-closed error messages] in GHC.Tc.Gen.Expr

Constructors

NotLetBoundReason

NotTypeClosed VarSet

NotClosed Name NotClosedReason

data SuggestPartialTypeSignatures

Constructors

YesSuggestPartialTypeSignatures

NoSuggestPartialTypeSignatures

Instances

Show SuggestPartialTypeSignatures

Defined in GHC.Tc.Errors.Types

Methods

showsPrec :: Int -> SuggestPartialTypeSignatures -> ShowS

show :: SuggestPartialTypeSignatures -> String

showList :: [SuggestPartialTypeSignatures] -> ShowS

Eq SuggestPartialTypeSignatures

Defined in GHC.Tc.Errors.Types

Methods

(==) :: SuggestPartialTypeSignatures -> SuggestPartialTypeSignatures -> Bool

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

suggestPartialTypeSignatures :: Bool -> SuggestPartialTypeSignatures

data DeriveInstanceErrReason

Why a particular typeclass instance couldn't be derived.

Constructors

DerivErrNotWellKinded

The typeclass instance is not well-kinded.

Fields

• !TyCon

  The type constructor that occurs in the typeclass instance declaration.

• !Kind

  The typeclass kind.

• !Int

  The number of typeclass arguments that GHC kept. See Note [tc_args and tycon arity] in GHC.Tc.Deriv. | Generic instances can only be derived using the stock strategy in Safe Haskell.

DerivErrSafeHaskellGenericInst

DerivErrDerivingViaWrongKind !Kind !Type !Kind

DerivErrNoEtaReduce !Type

The instance type | We cannot derive instances in boot files

DerivErrBootFileFound

DerivErrDataConsNotAllInScope !TyCon

DerivErrGNDUsedOnData

We cannot use GND on non-newtype types

DerivErrNullaryClasses

We cannot derive instances of nullary classes

DerivErrLastArgMustBeApp

Last arg must be newtype or data application

DerivErrNoFamilyInstance !TyCon [Type]

DerivErrNotStockDeriveable !DeriveAnyClassEnabled

DerivErrHasAssociatedDatatypes !HasAssociatedDataFamInsts !AssociatedTyLastVarInKind !AssociatedTyNotParamOverLastTyVar

DerivErrNewtypeNonDeriveableClass

DerivErrCannotEtaReduceEnough !Bool

DerivErrOnlyAnyClassDeriveable

Fields

• !TyCon

  Type constructor for which the instance is requested

• !DeriveAnyClassEnabled

  Whether or not -XDeriveAnyClass is enabled already. | Stock deriving won't work, but perhas DeriveAnyClass will.

DerivErrNotDeriveable !DeriveAnyClassEnabled

DerivErrNotAClass !PredType

The given PredType is not a class.

DerivErrNoConstructors !TyCon

The given (representation of the) TyCon has no data constructors.

DerivErrLangExtRequired !Extension

DerivErrDunnoHowToDeriveForType !Type

GHC simply doesn't how to how derive the input Class for the given Type.

DerivErrMustBeEnumType !TyCon

The given TyCon must be an enumeration. See Note [Enumeration types] in GHC.Core.TyCon

DerivErrMustHaveExactlyOneConstructor !TyCon

The given TyCon must have precisely one constructor.

DerivErrMustHaveSomeParameters !TyCon

The given data type must have some parameters.

DerivErrMustNotHaveClassContext !TyCon !ThetaType

The given data type must not have a class context.

DerivErrBadConstructor !(Maybe HasWildcard) [DeriveInstanceBadConstructor]

We couldn't derive an instance for a particular data constructor for a variety of reasons.

DerivErrGenerics [DeriveGenericsErrReason]

We couldn't derive a Generic instance for the given type for a variety of reasons

DerivErrEnumOrProduct !DeriveInstanceErrReason !DeriveInstanceErrReason

We couldn't derive an instance either because the type was not an enum type or because it did have more than one constructor.

data UsingGeneralizedNewtypeDeriving

Constructors

YesGeneralizedNewtypeDeriving

NoGeneralizedNewtypeDeriving

Instances

Eq UsingGeneralizedNewtypeDeriving

Defined in GHC.Tc.Errors.Types

Methods

(==) :: UsingGeneralizedNewtypeDeriving -> UsingGeneralizedNewtypeDeriving -> Bool

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

usingGeneralizedNewtypeDeriving :: Bool -> UsingGeneralizedNewtypeDeriving

data DeriveAnyClassEnabled

Constructors

YesDeriveAnyClassEnabled

NoDeriveAnyClassEnabled

Instances

Eq DeriveAnyClassEnabled

Defined in GHC.Tc.Errors.Types

Methods

(==) :: DeriveAnyClassEnabled -> DeriveAnyClassEnabled -> Bool

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

deriveAnyClassEnabled :: Bool -> DeriveAnyClassEnabled

data DeriveInstanceBadConstructor

Constructors

DerivErrBadConExistential !DataCon

The given DataCon must be truly polymorphic in the last argument of the data type.

DerivErrBadConCovariant !DataCon

The given DataCon must not use the type variable in a function argument"

DerivErrBadConFunTypes !DataCon

The given DataCon must not contain function types

DerivErrBadConWrongArg !DataCon

The given DataCon must use the type variable only as the last argument of a data type

DerivErrBadConIsGADT !DataCon

The given DataCon is a GADT so we cannot directly derive an istance for it.

DerivErrBadConHasExistentials !DataCon

The given DataCon has existentials type vars in its type.

DerivErrBadConHasConstraints !DataCon

The given DataCon has constraints in its type.

DerivErrBadConHasHigherRankType !DataCon

The given DataCon has a higher-rank type.

data HasWildcard

Constructors

YesHasWildcard

NoHasWildcard

Instances

Eq HasWildcard

Defined in GHC.Tc.Errors.Types

Methods

(==) :: HasWildcard -> HasWildcard -> Bool

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

hasWildcard :: Bool -> HasWildcard

data BadAnonWildcardContext

A context in which we don't allow anonymous wildcards.

Constructors

WildcardNotLastInConstraint

ExtraConstraintWildcardNotAllowed SoleExtraConstraintWildcardAllowed

WildcardsNotAllowedAtAll

data SoleExtraConstraintWildcardAllowed

Whether a sole extra-constraint wildcard is allowed, e.g. _ => .. as opposed to ( .., _ ) => ...

Constructors

SoleExtraConstraintWildcardNotAllowed

SoleExtraConstraintWildcardAllowed

data DeriveGenericsErrReason

Constructors

DerivErrGenericsMustNotHaveDatatypeContext !TyCon

The type must not have some datatype context.

DerivErrGenericsMustNotHaveExoticArgs !DataCon

The data constructor must not have exotic unlifted or polymorphic arguments.

DerivErrGenericsMustBeVanillaDataCon !DataCon

The data constructor must be a vanilla constructor.

DerivErrGenericsMustHaveSomeTypeParams !TyCon

The type must have some type parameters. check (d) from Note [Requirements for deriving Generic and Rep] in GHC.Tc.Deriv.Generics.

DerivErrGenericsMustNotHaveExistentials !DataCon

The data constructor must not have existential arguments.

DerivErrGenericsWrongArgKind !DataCon

The derivation applies a type to an argument involving the last parameter but the applied type is not of kind * -> *.

data HasAssociatedDataFamInsts

A type representing whether or not the input type has associated data family instances.

Constructors

YesHasAdfs

NoHasAdfs

Instances

Eq HasAssociatedDataFamInsts

Defined in GHC.Tc.Errors.Types

Methods

(==) :: HasAssociatedDataFamInsts -> HasAssociatedDataFamInsts -> Bool

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

hasAssociatedDataFamInsts :: Bool -> HasAssociatedDataFamInsts

data AssociatedTyLastVarInKind

If YesAssocTyLastVarInKind, the associated type of a typeclass contains the last type variable of the class in a kind, which is not (yet) allowed by GHC.

Constructors

YesAssocTyLastVarInKind !TyCon

The associated type family of the class

NoAssocTyLastVarInKind

Instances

Eq AssociatedTyLastVarInKind

Defined in GHC.Tc.Errors.Types

Methods

(==) :: AssociatedTyLastVarInKind -> AssociatedTyLastVarInKind -> Bool

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

associatedTyLastVarInKind :: Maybe TyCon -> AssociatedTyLastVarInKind

data AssociatedTyNotParamOverLastTyVar

If NoAssociatedTyNotParamOverLastTyVar, the associated type of a typeclass is not parameterized over the last type variable of the class

Constructors

YesAssociatedTyNotParamOverLastTyVar !TyCon

The associated type family of the class

NoAssociatedTyNotParamOverLastTyVar

Instances

Eq AssociatedTyNotParamOverLastTyVar

Defined in GHC.Tc.Errors.Types

Methods

(==) :: AssociatedTyNotParamOverLastTyVar -> AssociatedTyNotParamOverLastTyVar -> Bool

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

associatedTyNotParamOverLastTyVar :: Maybe TyCon -> AssociatedTyNotParamOverLastTyVar

data MissingSignature

What kind of thing is missing a type signature?

Used for reporting "missing signature" warnings, see tcRnMissingSignature.

Constructors

MissingTopLevelBindingSig Name Type

MissingPatSynSig PatSyn

MissingTyConKindSig TyCon Bool

whether -XCUSKs is enabled

data Exported

Is the object we are dealing with exported or not?

Used for reporting "missing signature" warnings, see TcRnMissingSignature.

Constructors

IsNotExported

IsExported

Instances

Outputable Exported

Defined in GHC.Tc.Errors.Types

Methods

ppr :: Exported -> SDoc

data HsDocContext

Constructors

TypeSigCtx SDoc

StandaloneKindSigCtx SDoc

PatCtx

SpecInstSigCtx

DefaultDeclCtx

ForeignDeclCtx (LocatedN RdrName)

DerivDeclCtx

RuleCtx FastString

TyDataCtx (LocatedN RdrName)

TySynCtx (LocatedN RdrName)

TyFamilyCtx (LocatedN RdrName)

FamPatCtx (LocatedN RdrName)

ConDeclCtx [LocatedN Name]

ClassDeclCtx (LocatedN RdrName)

ExprWithTySigCtx

TypBrCtx

HsTypeCtx

HsTypePatCtx

GHCiCtx

SpliceTypeCtx (LHsType GhcPs)

ClassInstanceCtx

GenericCtx SDoc

data FixedRuntimeRepErrorInfo

Stores the information to be reported in a representation-polymorphism error message.

Constructors

FRR_Info

Fields

• frr_info_origin :: FixedRuntimeRepOrigin

  What is the original type we checked for representation-polymorphism, and what specific check did we perform?

• frr_info_not_concrete :: Maybe (TcTyVar, TcType)

  Which non-concrete type did we try to unify this concrete type variable with?

data ErrorItem

A predicate with its arising location; used to encapsulate a constraint that will give rise to a diagnostic.

Constructors

EI

Fields

• ei_pred :: PredType
• ei_evdest :: Maybe TcEvDest
• ei_flavour :: CtFlavour
• ei_loc :: CtLoc
• ei_m_reason :: Maybe CtIrredReason
• ei_suppress :: Bool

Instances

Outputable ErrorItem

Defined in GHC.Tc.Errors.Types

Methods

ppr :: ErrorItem -> SDoc

errorItemOrigin :: ErrorItem -> CtOrigin

errorItemEqRel :: ErrorItem -> EqRel

errorItemPred :: ErrorItem -> PredType

errorItemCtLoc :: ErrorItem -> CtLoc

data SolverReport

A collection of main error messages and supplementary information.

In practice, we will: - display the important messages first, - then the error context (e.g. by way of a call to mkErrorReport), - then the supplementary information (e.g. relevant bindings, valid hole fits), - then the hints ("Possible fix: ...").

So this is mostly just a way of making sure that the error context appears early on rather than at the end of the message.

See Note [Error report] for details.

Constructors

SolverReport

Fields

• sr_important_msgs :: [SolverReportWithCtxt]
• sr_supplementary :: [SolverReportSupplementary]
• sr_hints :: [GhcHint]

Instances

Monoid SolverReport

Defined in GHC.Tc.Errors.Types

Methods

mempty :: SolverReport

mappend :: SolverReport -> SolverReport -> SolverReport

mconcat :: [SolverReport] -> SolverReport

Semigroup SolverReport

Defined in GHC.Tc.Errors.Types

Methods

(<>) :: SolverReport -> SolverReport -> SolverReport

sconcat :: NonEmpty SolverReport -> SolverReport

stimes :: Integral b => b -> SolverReport -> SolverReport

data SolverReportSupplementary

Additional information to print in a SolverReport, after the important messages and after the error context.

See Note [Error report].

Constructors

SupplementaryBindings RelevantBindings

SupplementaryHoleFits ValidHoleFits

SupplementaryCts [(PredType, RealSrcSpan)]

data SolverReportWithCtxt

A TcSolverReportMsg, together with context (e.g. enclosing implication constraints) that are needed in order to report it.

Constructors

SolverReportWithCtxt

Fields

• reportContext :: SolverReportErrCtxt

  Context for what we wish to report. This can change as we enter implications, so is stored alongside the content.

• reportContent :: TcSolverReportMsg

  The content of the message to report.

data SolverReportErrCtxt

Context needed when reporting a TcSolverReportMsg, such as the enclosing implication constraints or whether we are deferring type errors.

Constructors

CEC

Fields

• cec_encl :: [Implication]

  Enclosing implications (innermost first) ic_skols and givens are tidied, rest are not

• cec_tidy :: TidyEnv
• cec_binds :: EvBindsVar

  We make some errors (depending on cec_defer) into warnings, and emit evidence bindings into cec_binds for unsolved constraints

• cec_defer_type_errors :: DiagnosticReason

  Whether to defer type errors until runtime

• cec_expr_holes :: DiagnosticReason

  Reason for reporting holes in expressions.

• cec_type_holes :: DiagnosticReason

  Reason for reporting holes in types.

• cec_out_of_scope_holes :: DiagnosticReason

  Reason for reporting out of scope holes.

• cec_warn_redundant :: Bool

  True = -Wredundant-constraints

• cec_expand_syns :: Bool

  True = -fprint-expanded-synonyms

• cec_suppress :: Bool

  True = More important errors have occurred, so create bindings if need be, but don't issue any more errors/warnings See Note [Suppressing error messages]

Instances

Outputable SolverReportErrCtxt

Defined in GHC.Tc.Errors.Ppr

Methods

ppr :: SolverReportErrCtxt -> SDoc

getUserGivens :: SolverReportErrCtxt -> [UserGiven]

discardProvCtxtGivens :: CtOrigin -> [UserGiven] -> [UserGiven]

data TcSolverReportMsg

An error reported after constraint solving. This is usually, some sort of unsolved constraint error, but we try to be specific about the precise problem we encountered.

Constructors

TcReportWithInfo TcSolverReportMsg (NonEmpty TcSolverReportInfo)

Wrap a message with additional information.

Prefer using the mkTcReportWithInfo smart constructor

BadTelescope TyVarBndrs [TyCoVar]

Quantified variables appear out of dependency order.

Example:

forall (a :: k) k. ...

Test cases: BadTelescope2, T16418, T16247, T16726, T18451.

UserTypeError Type

We came across a custom type error and we have decided to report it.

Example:

type family F a where F a = TypeError (Text "error")

err :: F () err = ()

Test cases: CustomTypeErrors0{1,2,3,4,5}, T12104.

ReportHoleError Hole HoleError

We want to report an out of scope variable or a typed hole. See HoleError.

CannotUnifyWithPolytype ErrorItem TyVar Type

A type equality between a type variable and a polytype.

Test cases: T12427a, T2846b, T10194, ...

Mismatch

Couldn't unify two types or kinds.

Example:

3 + 3# -- can't match a lifted type with an unlifted type

Test cases: T1396, T8263, ...

Fields

• mismatch_ea :: Bool

  Should this be phrased in terms of expected vs actual?

• mismatch_item :: ErrorItem

  The constraint in which the mismatch originated.

• mismatch_ty1 :: Type

  First type (the expected type if if mismatch_ea is True)

• mismatch_ty2 :: Type

  Second type (the actual type if mismatch_ea is True)

KindMismatch

A type has an unexpected kind.

Test cases: T2994, T7609, ...

Fields

• kmismatch_what :: TypedThing

  What thing is kmismatch_actual the kind of?

• kmismatch_expected :: Type
• kmismatch_actual :: Type

TypeEqMismatch

A mismatch between two types, which arose from a type equality.

Test cases: T1470, tcfail212.

Fields

• teq_mismatch_ppr_explicit_kinds :: Bool
• teq_mismatch_item :: ErrorItem
• teq_mismatch_ty1 :: Type
• teq_mismatch_ty2 :: Type
• teq_mismatch_expected :: Type

  The overall expected type

• teq_mismatch_actual :: Type

  The overall actual type

• teq_mismatch_what :: Maybe TypedThing

  What thing is teq_mismatch_actual the kind of?

FixedRuntimeRepError [FixedRuntimeRepErrorInfo]

A violation of the representation-polymorphism invariants.

See FixedRuntimeRepErrorInfo and FixedRuntimeRepContext for more information.

SkolemEscape ErrorItem Implication [TyVar]

A skolem type variable escapes its scope.

Example:

data Ex where { MkEx :: a -> MkEx } foo (MkEx x) = x

Test cases: TypeSkolEscape, T11142.

UntouchableVariable TyVar Implication

Trying to unify an untouchable variable, e.g. a variable from an outer scope.

Test case: Simple14

BlockedEquality ErrorItem

An equality between two types is blocked on a kind equality beteen their kinds.

Test cases: none.

ExpectingMoreArguments Int TypedThing

Something was not applied to sufficiently many arguments.

Example:

instance Eq Maybe where {..}

Test case: T11563.

UnboundImplicitParams (NonEmpty ErrorItem)

Trying to use an unbound implicit parameter.

Example:

foo :: Int foo = ?param

Test case: tcfail130.

CouldNotDeduce

Couldn't solve some Wanted constraints using the Givens. This is the most commonly used constructor, used for generic "No instance for ..." and "Could not deduce ... from" messages.

Fields

• cnd_user_givens :: [Implication]
• cnd_wanted :: NonEmpty ErrorItem

  The Wanted constraints we couldn't solve.

  N.B.: the ErrorItem at the head of the list has been tidied, perhaps not the others.

• cnd_extra :: Maybe CND_Extra

  Some additional info consumed by mk_supplementary_ea_msg.

AmbiguityPreventsSolvingCt

A constraint couldn't be solved because it contains ambiguous type variables.

Example:

class C a b where f :: (a,b)

x = fst f

Test case: T4921.

Fields

• ErrorItem

  always a class constraint

• ([TyVar], [TyVar])

  ambiguous kind and type variables, respectively

CannotResolveInstance

Could not solve a constraint; there were several unifying candidate instances but no matching instances. This is used to report as much useful information as possible about why we couldn't choose any instance, e.g. because of ambiguous type variables.

Fields

• cannotResolve_item :: ErrorItem
• cannotResolve_unifiers :: [ClsInst]
• cannotResolve_candidates :: [ClsInst]
• cannotResolve_importErrors :: [ImportError]
• cannotResolve_suggestions :: [GhcHint]
• cannotResolve_relevant_bindings :: RelevantBindings

OverlappingInstances

Could not solve a constraint using available instances because the instances overlap.

Test cases: tcfail118, tcfail121, tcfail218.

Fields

• overlappingInstances_item :: ErrorItem
• overlappingInstances_matches :: [ClsInst]
• overlappingInstances_unifiers :: [ClsInst]

UnsafeOverlap

Could not solve a constraint from instances because instances declared in a Safe module cannot overlap instances from other modules (with -XSafeHaskell).

Test cases: SH_Overlap{1,2,5,6,7,11}.

Fields

• unsafeOverlap_item :: ErrorItem
• unsafeOverlap_matches :: [ClsInst]
• unsafeOverlapped :: [ClsInst]

data TcSolverReportInfo

Additional information that can be appended to an existing TcSolverReportMsg.

Constructors

Ambiguity

Some type variables remained ambiguous: print them to the user.

Fields

• lead_with_ambig_msg :: Bool

  True = start the message with "Ambiguous type variable ..." False = create a message of the form "The type variable is ambiguous."

• ambig_tyvars :: ([TyVar], [TyVar])

  Ambiguous kind and type variables, respectively. Guaranteed to not both be empty.

TyVarInfo TyVar

Specify some information about a type variable, e.g. its SkolemInfo.

NonInjectiveTyFam TyCon

Remind the user that a particular type family is not injective.

ReportCoercibleMsg CoercibleMsg

Explain why we couldn't coerce between two types. See CoercibleMsg.

ExpectedActual

Display the expected and actual types.

Fields

• ea_expected, ea_actual :: Type

ExpectedActualAfterTySynExpansion

Display the expected and actual types, after expanding type synonyms.

Fields

• ea_expanded_expected, ea_expanded_actual :: Type

WhenMatching TcType TcType CtOrigin (Maybe TypeOrKind)

Explain how a kind equality originated.

SameOcc

Add some information to disambiguate errors in which two Names would otherwise appear to be identical.

See Note [Disambiguating (X ~ X) errors].

Fields

• sameOcc_same_pkg :: Bool

  Whether the two Names also came from the same package.

• sameOcc_lhs :: Name
• sameOcc_rhs :: Name

OccursCheckInterestingTyVars (NonEmpty TyVar)

Report some type variables that might be participating in an occurs-check failure.

data CND_Extra

Additional information to be given in a CouldNotDeduce message, which is then passed on to mk_supplementary_ea_msg.

Constructors

CND_Extra TypeOrKind Type Type

mkTcReportWithInfo :: TcSolverReportMsg -> [TcSolverReportInfo] -> TcSolverReportMsg

Append additional information to a TcSolverReportMsg.

data FitsMbSuppressed

A collection of valid hole fits or refinement fits, in which some fits might have been suppressed.

Constructors

Fits

Fields

• fits :: [HoleFit]
• fitsSuppressed :: Bool

  Whether we have suppressed any fits because there were too many.

data ValidHoleFits

A collection of hole fits and refinement fits.

Constructors

ValidHoleFits

Fields

• holeFits :: FitsMbSuppressed
• refinementFits :: FitsMbSuppressed

noValidHoleFits :: ValidHoleFits

data HoleFitDispConfig

Configuration for pretty-printing valid hole fits.

Constructors

HFDC

Fields

• showWrap, showWrapVars, showType, showProv, showMatches :: Bool

data RelevantBindings

Constructors

RelevantBindings

Fields

• relevantBindingNamesAndTys :: [(Name, Type)]
• ranOutOfFuel :: Bool

  Whether we ran out of fuel generating the bindings.

pprRelevantBindings :: RelevantBindings -> SDoc

Display some relevant bindings.

data NotInScopeError

Some form of "not in scope" error. See also the OutOfScopeHole constructor of HoleError.

Constructors

NotInScope

A run-of-the-mill "not in scope" error.

NoExactName Name

An exact Name was not in scope.

This usually indicates a problem with a Template Haskell splice.

Test cases: T5971, T18263.

SameName [GlobalRdrElt]

always at least 2 elements

MissingBinding SDoc [GhcHint]

NoTopLevelBinding

Couldn't find a top-level binding.

Happens when specifying an annotation for something that is not in scope.

Test cases: annfail01, annfail02, annfail11.

UnknownSubordinate SDoc

A class doesnt have a method with this name, or, a class doesn't have an associated type with this name, or, a record doesn't have a record field with this name.

mkTcRnNotInScope :: RdrName -> NotInScopeError -> TcRnMessage

Create a "not in scope" error message for the given RdrName.

data ImportError

Explain a problem with an import.

Constructors

MissingModule ModuleName

Couldn't find a module with the requested name.

ModulesDoNotExport (NonEmpty Module) OccName

The imported modules don't export what we're looking for.

Instances

Outputable ImportError

Defined in GHC.Tc.Errors.Ppr

Methods

ppr :: ImportError -> SDoc

data HoleError

Report an error involving a Hole.

This could be an out of scope data constructor or variable, a typed hole, or a wildcard in a type.

Constructors

OutOfScopeHole [ImportError]

Report an out-of-scope data constructor or variable masquerading as an expression hole.

See Note [Insoluble holes] in GHC.Tc.Types.Constraint. See NotInScopeError for other not-in-scope errors.

Test cases: T9177a.

HoleError HoleSort [TcTyVar] [(SkolemInfoAnon, [TcTyVar])]

Report a typed hole, or wildcard, with additional information.

data CoercibleMsg

A message that aims to explain why two types couldn't be seen to be representationally equal.

Constructors

UnknownRoles Type

Not knowing the role of a type constructor prevents us from concluding that two types are representationally equal.

Example:

foo :: Applicative m => m (Sum Int) foo = coerce (pure $ 1 :: Int)

We don't know what role m has, so we can't coerce `m Int` to `m (Sum Int)`.

Test cases: T8984, TcCoercibleFail.

TyConIsAbstract TyCon

The fact that a TyCon is abstract prevents us from decomposing a TyConApp and deducing that two types are representationally equal.

Test cases: none.

OutOfScopeNewtypeConstructor TyCon DataCon

We can't unwrap a newtype whose constructor is not in scope.

Example:

import Data.Ord (Down) -- NB: not importing the constructor foo :: Int -> Down Int foo = coerce

Test cases: TcCoercibleFail.

data PotentialInstances

This datatype collates instances that match or unifier, in order to report an error message for an unsolved typeclass constraint.

Constructors

PotentialInstances

Fields

• matches :: [ClsInst]
• unifiers :: [ClsInst]

data UnsupportedCallConvention

Specifies which calling convention is unsupported on the current platform

Constructors

StdCallConvUnsupported

PrimCallConvUnsupported

JavaScriptCallConvUnsupported

Instances

Eq UnsupportedCallConvention

Defined in GHC.Tc.Errors.Types

Methods

(==) :: UnsupportedCallConvention -> UnsupportedCallConvention -> Bool

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

data ExpectedBackends

Specifies which backend code generators where expected for an FFI declaration

Constructors

COrAsmOrLlvm

C, Asm, or LLVM

COrAsmOrLlvmOrInterp

C, Asm, LLVM, or interpreted

Instances

Eq ExpectedBackends

Defined in GHC.Tc.Errors.Types

Methods

(==) :: ExpectedBackends -> ExpectedBackends -> Bool

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

data ArgOrResult

Whether the error pertains to a function argument or a result.

Constructors

Arg

Result