GHC.Parser.Errors.Types

PsErrUnsupportedOptionsPragma is an error that occurs when an unknown OPTIONS_GHC pragma is supplied is found.

Example(s): {-# OPTIONS_GHC foo #-}

Test case(s):

testssafeHaskellflags/SafeFlags28 testssafeHaskellflags/SafeFlags19 testssafeHaskellflags/SafeFlags29 testsparsershould_fail/T19923c testsparsershould_fail/T19923b testsparsershould_fail/readFail044 testsdriverT2499

An "unknown" message from the parser. This type constructor allows arbitrary messages to be embedded. The typical use case would be GHC plugins willing to emit custom diagnostics.

A group of parser messages emitted in GHC.Parser.Header. See Note [Messages from GHC.Parser.Header].

PsWarnBidirectionalFormatChars is a warning (controlled by the -Wwarn-bidirectional-format-characters flag) that occurs when unicode bi-directional format characters are found within in a file

The PsLoc contains the exact position in the buffer the character occurred, and the string contains a description of the character.

PsWarnTab is a warning (controlled by the -Wwarn-tabs flag) that occurs when tabulations (tabs) are found within a file.

Test case(s): parsershould_failT12610 parsershould_compileT9723b parsershould_compileT9723a parsershould_compileread043 parsershould_failT16270 warningsshould_compileT9230

PsWarnTransitionalLayout is a warning (controlled by the -Walternative-layout-rule-transitional flag) that occurs when pipes (|) or where are at the same depth of an implicit layout block.

Example(s):

f :: IO () f | True = do let x = () y = () return () | True = return ()

Test case(s): layout/layout006 layout/layout003 layout/layout001

Unrecognised pragma. First field is the actual pragma name which might be empty. Second field is the set of valid candidate pragmas.

Invalid Haddock comment position

Multiple Haddock comment for the same entity

Found binding occurrence of "*" while StarIsType is enabled

Using "*" for Type, relying on the legacy extension StarIsType

Pre qualified import with WarnPrepositiveQualifiedModule enabled

PsWarnViewPatternSignatures is a warning triggered by view patterns whose RHS is an unparenthesised pattern signature. It warns on code that is highly likely to break when the precedence of view patterns relative to pattern signatures is changed per GHC Proposal #281. The suggested fix is to add parentheses.

Example: f1 (isJust -> True :: Bool) = ()

Suggested fix: f1 (isJust -> (True :: Bool)) = ()

Test cases: T24159_viewpat

LambdaCase syntax used without the extension enabled

A lambda requires at least one parameter

Underscores in literals without the extension enabled

Invalid character in primitive string

Missing block

Lexer error

Suffix occurrence of @

Parse errors

Cmm lexer error

Unsupported boxed sum in expression

Unsupported boxed sum in pattern

Unexpected qualified constructor

Tuple section in pattern context

Bang-pattern without BangPattterns enabled

Operator applied to too few arguments

Import: multiple occurrences of qualified

Multiple occurrences of a splice or quote keyword

Post qualified import without ImportQualifiedPost

Explicit namespace keyword without ExplicitNamespaces

Explicit namespace keyword in unsupported position

Plain top-level wildcard in an import list, e.g. import Data.Proxy (..)

Plain top-level wildcard in an export list, e.g. module M (..) where

Expecting a type constructor but found a variable

Illegal export form allowed by PatternSynonyms

Malformed entity string

Dots used in record update

Precedence out of range

Invalid use of record dot syntax .

OverloadedRecordUpdate is not enabled.

Can't use qualified fields when OverloadedRecordUpdate is enabled.

Cannot parse data constructor in a data/newtype declaration

Cannot parse data constructor in a data/newtype declaration

Illegal DataKinds quote mark in data/newtype constructor declaration

UNPACK applied to a data constructor

Unexpected kind application in data/newtype declaration

Not a record constructor

Illegal unboxed string literal in pattern

Illegal primitive floating point literal in pattern

Do-notation in pattern

If-then-else syntax in pattern

Lambda or Lambda-case in pattern

case..of in pattern

let-syntax in pattern

Arrow expression-syntax in pattern

Arrow command-syntax in pattern

Arrow command-syntax in expression

Or-pattern in expression

Type-application without space before @

Lazy-pattern (~) without space after it

Bang-pattern (!) without space after it

Pragma not allowed in this position

Qualified do block in command

Invalid infix hole, expected an infix operator

Unexpected semi-colons in conditional expression

Unexpected semi-colons in conditional command

@-operator in a pattern position

Unexpected case command in function application

Unexpected lambda or case(s) command in function application

Unexpected if command in function application

Unexpected let command in function application

Unexpected do command in function application

Unexpected do block in function application

Unexpected mdo block in function application

Unexpected case expression in function application

Unexpected lambda or case(s) expression in function application

Unexpected let expression in function application

Unexpected if expression in function application

Unexpected proc expression in function application

Malformed head of type or class declaration

Illegal where keyword in data declaration

Illegal datatype context

Parse error on input

Malformed ... declaration for ...

Not a data constructor

Record syntax used in pattern synonym declaration

Empty where clause in pattern-synonym declaration

Invalid binding name in where clause of pattern-synonym declaration

Multiple bindings in where clause of pattern-synonym declaration

Declaration splice not a top-level

Inferred type variables not allowed here

Multiple names in standalone kind signatures

Illegal import bundle form

Illegal role name

Invalid type signature

Unexpected type in declaration

Found a space in a SCC

Found two single quotes

Invalid package name

Invalid rule activation marker

Linear function found but neither Modifiers nor LinearTypes enabled

Other modifier syntax found, but it's illegal here or Modifiers not enabled

Multi-way if-expression found but MultiWayIf not enabled

Explicit forall found but no extension allowing it is enabled

Found qualified-do without QualifiedDo enabled

Found multiline string without MultilineStrings enabled

Cmm parser error

Illegal traditional record syntax

TODO: distinguish errors without using SDoc

Parse error in command

TODO: distinguish errors without using SDoc

Parse error in pattern

Parse error in right operator section pattern TODO: embed the proper operator, if possible

Illegal modifier or linear arrow in GADT record syntax, e.g.

data T where MkT :: { a :: Int } %1 -> T

Or pattern used without -XOrPatterns

Temporary error until GHC gains support for type syntax in patterns. Test cases: T24159_pat_parse_error_1 T24159_pat_parse_error_2 T24159_pat_parse_error_3 T24159_pat_parse_error_4 T24159_pat_parse_error_5 T24159_pat_parse_error_6

PsErrSpecExprMultipleTypeAscription is an error that occurs when a user attempts to use the new form SPECIALISE pragma syntax with multiple type signatures, e.g.

@{-# SPECIALISE foo 3 :: Float -> Float; Double -> Double #-}

PsWarnSpecMultipleTypeAscription is a warning that occurs when a user uses the old-form SPECIALISE pragma syntax with multiple type signatures, e.g.

@{-# SPECIALISE bar :: Float -> Float; Double -> Double #-}

This constructor is deprecated and will be removed in GHC 9.18.

The deprecated `pattern` namespace specifier was used in an import or export list. Suggested fix: use the `data` keyword instead.

We do not support import T(x, type ..)

Negative application pattern?

End of input

UTF-8 decoding error

Error at given character

Lexical error

Unknown pragma

Lexical error in pragma

Numeric escape sequence out of range

Unterminated `{-'

Unterminated OPTIONS pragma

Unterminated quasiquotation

Unknown Cmm primitive

Unknown macro

Unknown calling convention

Unrecognised safety

Unrecognised hint

"where clause at the same depth as implicit layout block"

"| at the same depth as implicit layout block")