    {-# LANGUAGE DeriveGeneric #-}
    {-# LANGUAGE TypeFamilies #-}
    {-# LANGUAGE DataKinds #-}

    module GHC.Parser.Errors.Types where

    import GHC.Prelude

    import GHC.Core.TyCon (Role)
    import GHC.Data.FastString
    import GHC.Hs
    import GHC.Parser.Types
    import GHC.Parser.Errors.Basic
    import GHC.Types.Error
    import GHC.Types.Hint
    import GHC.Types.Name.Occurrence (OccName)
    import GHC.Types.Name.Reader
    import Data.List.NonEmpty (NonEmpty)
    import GHC.Types.SrcLoc (PsLoc)

    import GHC.Generics ( Generic )

    -- The type aliases below are useful to make some type signatures a bit more
    -- descriptive, like 'handleWarningsThrowErrors' in 'GHC.Driver.Main'.

    type PsWarning = PsMessage   -- /INVARIANT/: The diagnosticReason is a Warning reason
    type PsError   = PsMessage   -- /INVARIANT/: The diagnosticReason is ErrorWithoutFlag

    {-
    Note [Messages from GHC.Parser.Header
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    We group the messages from 'GHC.Parser.Header' because we need to
    be able to pattern match on them in the driver code. This is because
    in functions like 'GHC.Driver.Pipeline.preprocess' we want to handle
    only a specific subset of parser messages, during dependency analysis,
    and having a single constructor to handle them all is handy.

    -}

    data PsHeaderMessage
      = PsErrParseLanguagePragma
      | PsErrUnsupportedExt !String ![String]
      | PsErrParseOptionsPragma !String

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

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

          Test case(s):

            tests/safeHaskell/flags/SafeFlags28
            tests/safeHaskell/flags/SafeFlags19
            tests/safeHaskell/flags/SafeFlags29
            tests/parser/should_fail/T19923c
            tests/parser/should_fail/T19923b
            tests/parser/should_fail/readFail044
            tests/driver/T2499
      -}
      | PsErrUnknownOptionsPragma !String
      deriving (forall x. PsHeaderMessage -> Rep PsHeaderMessage x)
    -> (forall x. Rep PsHeaderMessage x -> PsHeaderMessage)
    -> Generic PsHeaderMessage
    forall x. Rep PsHeaderMessage x -> PsHeaderMessage
    forall x. PsHeaderMessage -> Rep PsHeaderMessage x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. PsHeaderMessage -> Rep PsHeaderMessage x
    from :: forall x. PsHeaderMessage -> Rep PsHeaderMessage x
    $cto :: forall x. Rep PsHeaderMessage x -> PsHeaderMessage
    to :: forall x. Rep PsHeaderMessage x -> PsHeaderMessage
    Generic

    data PsMessage
      =
        {-| 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.
        -}
        PsUnknownMessage (UnknownDiagnosticFor PsMessage)

        {-| A group of parser messages emitted in 'GHC.Parser.Header'.
            See Note [Messages from GHC.Parser.Header].
        -}
       | PsHeaderMessage !PsHeaderMessage

       {-| 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.
       -}
       | PsWarnBidirectionalFormatChars (NonEmpty (PsLoc, Char, String))

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

           Test case(s): parser/should_fail/T12610
                         parser/should_compile/T9723b
                         parser/should_compile/T9723a
                         parser/should_compile/read043
                         parser/should_fail/T16270
                         warnings/should_compile/T9230

       -}
       | PsWarnTab !Word -- ^ Number of other occurrences other than the first one

       {-| 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

       -}
       | PsWarnTransitionalLayout !TransLayoutReason

       -- | Unrecognised pragma. First field is the actual pragma name which
       -- might be empty. Second field is the set of valid candidate pragmas.
       | PsWarnUnrecognisedPragma !String ![String]
       | PsWarnMisplacedPragma !FileHeaderPragmaType

       -- | Invalid Haddock comment position
       | PsWarnHaddockInvalidPos

       -- | Multiple Haddock comment for the same entity
       | PsWarnHaddockIgnoreMulti

       -- | Found binding occurrence of "*" while StarIsType is enabled
       | PsWarnStarBinder

       -- | Using "*" for "Type" without StarIsType enabled
       | PsWarnStarIsType

       -- | Pre qualified import with 'WarnPrepositiveQualifiedModule' enabled
       | PsWarnImportPreQualified

       | PsWarnOperatorWhitespaceExtConflict !OperatorWhitespaceSymbol

       | PsWarnOperatorWhitespace !FastString !OperatorWhitespaceOccurrence

       {- | 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
       -}
       | PsWarnViewPatternSignatures !(LPat GhcPs) !(LPat GhcPs)

       -- | LambdaCase syntax used without the extension enabled
       | PsErrLambdaCase

       -- | A lambda requires at least one parameter
       | PsErrEmptyLambda

       -- | Underscores in literals without the extension enabled
       | PsErrNumUnderscores !NumUnderscoreReason

       -- | Invalid character in primitive string
       | PsErrPrimStringInvalidChar

       -- | Missing block
       | PsErrMissingBlock

       -- | Lexer error
       | PsErrLexer !LexErr !LexErrKind

       -- | Suffix occurrence of `@`
       | PsErrSuffixAT

       -- | Parse errors
       | PsErrParse !String !PsErrParseDetails

       -- | Cmm lexer error
       | PsErrCmmLexer

       -- | Unsupported boxed sum in expression
       | PsErrUnsupportedBoxedSumExpr !(SumOrTuple (HsExpr GhcPs))

       -- | Unsupported boxed sum in pattern
       | PsErrUnsupportedBoxedSumPat !(SumOrTuple (PatBuilder GhcPs))

       -- | Unexpected qualified constructor
       | PsErrUnexpectedQualifiedConstructor !RdrName

       -- | Tuple section in pattern context
       | PsErrTupleSectionInPat

       -- | Bang-pattern without BangPattterns enabled
       | PsErrIllegalBangPattern !(Pat GhcPs)

       -- | Operator applied to too few arguments
       | PsErrOpFewArgs !StarIsType !RdrName

       -- | Import: multiple occurrences of 'qualified'
       | PsErrImportQualifiedTwice

       -- | Multiple occurrences of a splice or quote keyword
       | PsErrSpliceOrQuoteTwice

       -- | Post qualified import without 'ImportQualifiedPost'
       | PsErrImportPostQualified

       -- | Explicit namespace keyword without 'ExplicitNamespaces'
       | PsErrIllegalExplicitNamespace !ExplicitNamespaceKeyword

       -- | Expecting a type constructor but found a variable
       | PsErrVarForTyCon !RdrName

       -- | Illegal export form allowed by PatternSynonyms
       | PsErrIllegalPatSynExport

       -- | Malformed entity string
       | PsErrMalformedEntityString

       -- | Dots used in record update
       | PsErrDotsInRecordUpdate

       -- | Precedence out of range
       | PsErrPrecedenceOutOfRange !Int

       -- | Invalid use of record dot syntax `.'
       | PsErrOverloadedRecordDotInvalid

       -- | `OverloadedRecordUpdate` is not enabled.
       | PsErrOverloadedRecordUpdateNotEnabled

       -- | Can't use qualified fields when OverloadedRecordUpdate is enabled.
       | PsErrOverloadedRecordUpdateNoQualifiedFields

       -- | Cannot parse data constructor in a data/newtype declaration
       | PsErrInvalidDataCon !(HsType GhcPs)

       -- | Cannot parse data constructor in a data/newtype declaration
       | PsErrInvalidInfixDataCon !(HsType GhcPs) !RdrName !(HsType GhcPs)

       -- | Illegal DataKinds quote mark in data/newtype constructor declaration
       | PsErrIllegalPromotionQuoteDataCon !RdrName

       -- | UNPACK applied to a data constructor
       | PsErrUnpackDataCon

       -- | Unexpected kind application in data/newtype declaration
       | PsErrUnexpectedKindAppInDataCon !DataConBuilder !(HsType GhcPs)

       -- | Not a record constructor
       | PsErrInvalidRecordCon !(PatBuilder GhcPs)

       -- | Illegal unboxed string literal in pattern
       | PsErrIllegalUnboxedStringInPat !(HsLit GhcPs)

       -- | Illegal primitive floating point literal in pattern
       | PsErrIllegalUnboxedFloatingLitInPat !(HsLit GhcPs)

       -- | Do-notation in pattern
       | PsErrDoNotationInPat

       -- | If-then-else syntax in pattern
       | PsErrIfThenElseInPat

       -- | Lambda or Lambda-case in pattern
       | PsErrLambdaInPat HsLamVariant

       -- | case..of in pattern
       | PsErrCaseInPat

       -- | let-syntax in pattern
       | PsErrLetInPat

       -- | Arrow expression-syntax in pattern
       | PsErrArrowExprInPat !(HsExpr GhcPs)

       -- | Arrow command-syntax in pattern
       | PsErrArrowCmdInPat !(HsCmd GhcPs)

       -- | Arrow command-syntax in expression
       | PsErrArrowCmdInExpr !(HsCmd GhcPs)

       -- | Or-pattern in expression
       | PsErrOrPatInExpr !(LPat GhcPs)

       -- | Type-application without space before '@'
       | PsErrTypeAppWithoutSpace !RdrName !(LHsExpr GhcPs)

       -- | Lazy-pattern ('~') without space after it
       | PsErrLazyPatWithoutSpace !(LHsExpr GhcPs)

       -- | Bang-pattern ('!') without space after it
       | PsErrBangPatWithoutSpace !(LHsExpr GhcPs)

       -- | Pragma not allowed in this position
       | PsErrUnallowedPragma !(HsPragE GhcPs)

       -- | Qualified do block in command
       | PsErrQualifiedDoInCmd !ModuleName

       -- | Invalid infix hole, expected an infix operator
       | PsErrInvalidInfixHole

       -- | Unexpected semi-colons in conditional expression
       | PsErrSemiColonsInCondExpr
           !(HsExpr GhcPs) -- ^ conditional expr
           !Bool           -- ^ "then" semi-colon?
           !(HsExpr GhcPs) -- ^ "then" expr
           !Bool           -- ^ "else" semi-colon?
           !(HsExpr GhcPs) -- ^ "else" expr

       -- | Unexpected semi-colons in conditional command
       | PsErrSemiColonsInCondCmd
           !(HsExpr GhcPs) -- ^ conditional expr
           !Bool           -- ^ "then" semi-colon?
           !(HsCmd GhcPs)  -- ^ "then" expr
           !Bool           -- ^ "else" semi-colon?
           !(HsCmd GhcPs)  -- ^ "else" expr

       -- | @-operator in a pattern position
       | PsErrAtInPatPos

       -- | Unexpected case command in function application
       | PsErrCaseCmdInFunAppCmd !(LHsCmd GhcPs)

       -- | Unexpected lambda or \case(s) command in function application
       | PsErrLambdaCmdInFunAppCmd !HsLamVariant !(LHsCmd GhcPs)

       -- | Unexpected if command in function application
       | PsErrIfCmdInFunAppCmd !(LHsCmd GhcPs)

       -- | Unexpected let command in function application
       | PsErrLetCmdInFunAppCmd !(LHsCmd GhcPs)

       -- | Unexpected do command in function application
       | PsErrDoCmdInFunAppCmd !(LHsCmd GhcPs)

       -- | Unexpected do block in function application
       | PsErrDoInFunAppExpr !(Maybe ModuleName) !(LHsExpr GhcPs)

       -- | Unexpected mdo block in function application
       | PsErrMDoInFunAppExpr !(Maybe ModuleName) !(LHsExpr GhcPs)

       -- | Unexpected case expression in function application
       | PsErrCaseInFunAppExpr !(LHsExpr GhcPs)

       -- | Unexpected lambda or \case(s) expression in function application
       | PsErrLambdaInFunAppExpr !HsLamVariant !(LHsExpr GhcPs)

       -- | Unexpected let expression in function application
       | PsErrLetInFunAppExpr !(LHsExpr GhcPs)

       -- | Unexpected if expression in function application
       | PsErrIfInFunAppExpr !(LHsExpr GhcPs)

       -- | Unexpected proc expression in function application
       | PsErrProcInFunAppExpr !(LHsExpr GhcPs)

       -- | Malformed head of type or class declaration
       | PsErrMalformedTyOrClDecl !(LHsType GhcPs)

       -- | Illegal 'where' keyword in data declaration
       | PsErrIllegalWhereInDataDecl

       -- | Illegal datatype context
       | PsErrIllegalDataTypeContext !(LHsContext GhcPs)

       -- | Parse error on input
       | PsErrParseErrorOnInput !OccName

       -- | Malformed ... declaration for ...
       | PsErrMalformedDecl !SDoc !RdrName

       -- | Not a data constructor
       | PsErrNotADataCon !RdrName

       -- | Record syntax used in pattern synonym declaration
       | PsErrRecordSyntaxInPatSynDecl !(LPat GhcPs)

       -- | Empty 'where' clause in pattern-synonym declaration
       | PsErrEmptyWhereInPatSynDecl !RdrName

       -- | Invalid binding name in 'where' clause of pattern-synonym declaration
       | PsErrInvalidWhereBindInPatSynDecl !RdrName !(HsDecl GhcPs)

       -- | Multiple bindings in 'where' clause of pattern-synonym declaration
       | PsErrNoSingleWhereBindInPatSynDecl !RdrName !(HsDecl GhcPs)

       -- | Declaration splice not a top-level
       | PsErrDeclSpliceNotAtTopLevel !(SpliceDecl GhcPs)

       -- | Inferred type variables not allowed here
       | PsErrInferredTypeVarNotAllowed

       -- | Multiple names in standalone kind signatures
       | PsErrMultipleNamesInStandaloneKindSignature [LIdP GhcPs]

       -- | Illegal import bundle form
       | PsErrIllegalImportBundleForm

       -- | Illegal role name
       | PsErrIllegalRoleName !FastString [Role]

       -- | Invalid type signature
       | PsErrInvalidTypeSignature !PsInvalidTypeSignature !(LHsExpr GhcPs)

       -- | Unexpected type in declaration
       | PsErrUnexpectedTypeInDecl !(LHsType GhcPs)
                                   !SDoc
                                   !RdrName
                                   [LHsTypeArg GhcPs]
                                   !SDoc

       -- | Expected a hyphen
       | PsErrExpectedHyphen

       -- | Found a space in a SCC
       | PsErrSpaceInSCC

       -- | Found two single quotes
       | PsErrEmptyDoubleQuotes !Bool
                                -- ^ Is TH on?

       -- | Invalid package name
       | PsErrInvalidPackageName !FastString

       -- | Invalid rule activation marker
       | PsErrInvalidRuleActivationMarker

       -- | Linear function found but LinearTypes not enabled
       | PsErrLinearFunction

       -- | Multi-way if-expression found but MultiWayIf not enabled
       | PsErrMultiWayIf

       -- | Explicit forall found but no extension allowing it is enabled
       | PsErrExplicitForall !Bool
                             -- ^ is Unicode forall?

       -- | Found qualified-do without QualifiedDo enabled
       | PsErrIllegalQualifiedDo !SDoc

       -- | Cmm parser error
       | PsErrCmmParser !CmmParserError

       -- | Illegal traditional record syntax
       --
       -- TODO: distinguish errors without using SDoc
       | PsErrIllegalTraditionalRecordSyntax !SDoc

       -- | Parse error in command
       --
       -- TODO: distinguish errors without using SDoc
       | PsErrParseErrorInCmd !SDoc

       -- | Parse error in pattern
       | PsErrInPat !(PatBuilder GhcPs) !PsErrInPatDetails

       -- | Parse error in right operator section pattern
       -- TODO: embed the proper operator, if possible
       | PsErrParseRightOpSectionInPat !RdrName !(PatBuilder GhcPs)

       -- | Illegal linear arrow or multiplicity annotation in GADT record syntax
       | PsErrIllegalGadtRecordMultiplicity !(HsMultAnn GhcPs)

       | PsErrInvalidCApiImport

       | PsErrMultipleConForNewtype !RdrName !Int

       | PsErrUnicodeCharLooksLike
          Char -- ^ the problematic character
          Char -- ^ the character it looks like
          String -- ^ the name of the character that it looks like

       | PsErrInvalidPun !PsErrPunDetails

       -- | Or pattern used without -XOrPatterns
       | PsErrIllegalOrPat (LPat GhcPs)

       -- | 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
       | PsErrTypeSyntaxInPat !PsErrTypeSyntaxDetails

       -- | '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 #-}
       | PsErrSpecExprMultipleTypeAscription

       -- | '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.
       | PsWarnSpecMultipleTypeAscription

       -- | The deprecated ``pattern`` namespace specifier was used in an import or
       -- export list. Suggested fix: use the ``data`` keyword instead.
       | PsWarnPatternNamespaceSpecifier
          !Bool -- ^ Is ExplicitNamespaces on?

       deriving (forall x. PsMessage -> Rep PsMessage x)
    -> (forall x. Rep PsMessage x -> PsMessage) -> Generic PsMessage
    forall x. Rep PsMessage x -> PsMessage
    forall x. PsMessage -> Rep PsMessage x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. PsMessage -> Rep PsMessage x
    from :: forall x. PsMessage -> Rep PsMessage x
    $cto :: forall x. Rep PsMessage x -> PsMessage
    to :: forall x. Rep PsMessage x -> PsMessage
    Generic

    -- | Extra details about a parse error, which helps
    -- us in determining which should be the hints to
    -- suggest.
    data PsErrParseDetails
      = PsErrParseDetails
      { PsErrParseDetails -> Bool
    ped_th_enabled :: !Bool
        -- Is 'TemplateHaskell' enabled?
      , PsErrParseDetails -> Bool
    ped_do_in_last_100 :: !Bool
        -- ^ Is there a 'do' in the last 100 characters?
      , PsErrParseDetails -> Bool
    ped_mdo_in_last_100 :: !Bool
        -- ^ Is there an 'mdo' in the last 100 characters?
      , PsErrParseDetails -> Bool
    ped_pat_syn_enabled :: !Bool
        -- ^ Is 'PatternSynonyms' enabled?
      , PsErrParseDetails -> Bool
    ped_pattern_parsed :: !Bool
        -- ^ Did we parse a \"pattern\" keyword?
      }

    data PsInvalidTypeSignature
      = PsErrInvalidTypeSig_Qualified
      | PsErrInvalidTypeSig_DataCon
      | PsErrInvalidTypeSig_Other

    -- | Is the parsed pattern recursive?
    data PatIsRecursive
      = YesPatIsRecursive
      | NoPatIsRecursive

    data PatIncompleteDoBlock
      = YesIncompleteDoBlock
      | NoIncompleteDoBlock
      deriving PatIncompleteDoBlock -> PatIncompleteDoBlock -> Bool
    (PatIncompleteDoBlock -> PatIncompleteDoBlock -> Bool)
    -> (PatIncompleteDoBlock -> PatIncompleteDoBlock -> Bool)
    -> Eq PatIncompleteDoBlock
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PatIncompleteDoBlock -> PatIncompleteDoBlock -> Bool
    == :: PatIncompleteDoBlock -> PatIncompleteDoBlock -> Bool
    $c/= :: PatIncompleteDoBlock -> PatIncompleteDoBlock -> Bool
    /= :: PatIncompleteDoBlock -> PatIncompleteDoBlock -> Bool
    Eq

    -- | Extra information for the expression GHC is currently inspecting/parsing.
    -- It can be used to generate more informative parser diagnostics and hints.
    data ParseContext
      = ParseContext
      { ParseContext -> Maybe RdrName
    is_infix :: !(Maybe RdrName)
        -- ^ If 'Just', this is an infix
        -- pattern with the bound operator name
      , ParseContext -> PatIncompleteDoBlock
    incomplete_do_block :: !PatIncompleteDoBlock
        -- ^ Did the parser likely fail due to an incomplete do block?
      } deriving ParseContext -> ParseContext -> Bool
    (ParseContext -> ParseContext -> Bool)
    -> (ParseContext -> ParseContext -> Bool) -> Eq ParseContext
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ParseContext -> ParseContext -> Bool
    == :: ParseContext -> ParseContext -> Bool
    $c/= :: ParseContext -> ParseContext -> Bool
    /= :: ParseContext -> ParseContext -> Bool
    Eq

    data PsErrInPatDetails
      = PEIP_NegApp
        -- ^ Negative application pattern?
      | PEIP_RecPattern [LPat GhcPs]    -- ^ The pattern arguments
                        !PatIsRecursive -- ^ Is the parsed pattern recursive?
                        !ParseContext
      | PEIP_OtherPatDetails !ParseContext

    data PsErrPunDetails
      = PEP_QuoteDisambiguation
      | PEP_TupleSyntaxType
      | PEP_SumSyntaxType

    data PsErrTypeSyntaxDetails
      = PETS_FunctionArrow
          !(LocatedA (PatBuilder GhcPs))
          !(HsMultAnnOf (LocatedA (PatBuilder GhcPs)) GhcPs)
          !(LocatedA (PatBuilder GhcPs))
      | PETS_Multiplicity
          !(EpToken "%")
          !(LocatedA (PatBuilder GhcPs))
      | PETS_ForallTelescope
          !(HsForAllTelescope GhcPs)
          !(LocatedA (PatBuilder GhcPs))
      | PETS_ConstraintContext !(LocatedA (PatBuilder GhcPs))

    noParseContext :: ParseContext
    noParseContext :: ParseContext
    noParseContext = Maybe RdrName -> PatIncompleteDoBlock -> ParseContext
    ParseContext Maybe RdrName
    forall a. Maybe a
    Nothing PatIncompleteDoBlock
    NoIncompleteDoBlock

    incompleteDoBlock :: ParseContext
    incompleteDoBlock :: ParseContext
    incompleteDoBlock = Maybe RdrName -> PatIncompleteDoBlock -> ParseContext
    ParseContext Maybe RdrName
    forall a. Maybe a
    Nothing PatIncompleteDoBlock
    YesIncompleteDoBlock

    -- | Builds a 'PsErrInPatDetails' with the information provided by the 'ParseContext'.
    fromParseContext :: ParseContext -> PsErrInPatDetails
    fromParseContext :: ParseContext -> PsErrInPatDetails
    fromParseContext = ParseContext -> PsErrInPatDetails
    PEIP_OtherPatDetails

    data NumUnderscoreReason
       = NumUnderscore_Integral
       | NumUnderscore_Float
       deriving (Int -> NumUnderscoreReason -> ShowS
    [NumUnderscoreReason] -> ShowS
    NumUnderscoreReason -> String
    (Int -> NumUnderscoreReason -> ShowS)
    -> (NumUnderscoreReason -> String)
    -> ([NumUnderscoreReason] -> ShowS)
    -> Show NumUnderscoreReason
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> NumUnderscoreReason -> ShowS
    showsPrec :: Int -> NumUnderscoreReason -> ShowS
    $cshow :: NumUnderscoreReason -> String
    show :: NumUnderscoreReason -> String
    $cshowList :: [NumUnderscoreReason] -> ShowS
    showList :: [NumUnderscoreReason] -> ShowS
    Show,NumUnderscoreReason -> NumUnderscoreReason -> Bool
    (NumUnderscoreReason -> NumUnderscoreReason -> Bool)
    -> (NumUnderscoreReason -> NumUnderscoreReason -> Bool)
    -> Eq NumUnderscoreReason
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: NumUnderscoreReason -> NumUnderscoreReason -> Bool
    == :: NumUnderscoreReason -> NumUnderscoreReason -> Bool
    $c/= :: NumUnderscoreReason -> NumUnderscoreReason -> Bool
    /= :: NumUnderscoreReason -> NumUnderscoreReason -> Bool
    Eq,Eq NumUnderscoreReason
    Eq NumUnderscoreReason =>
    (NumUnderscoreReason -> NumUnderscoreReason -> Ordering)
    -> (NumUnderscoreReason -> NumUnderscoreReason -> Bool)
    -> (NumUnderscoreReason -> NumUnderscoreReason -> Bool)
    -> (NumUnderscoreReason -> NumUnderscoreReason -> Bool)
    -> (NumUnderscoreReason -> NumUnderscoreReason -> Bool)
    -> (NumUnderscoreReason
        -> NumUnderscoreReason -> NumUnderscoreReason)
    -> (NumUnderscoreReason
        -> NumUnderscoreReason -> NumUnderscoreReason)
    -> Ord NumUnderscoreReason
    NumUnderscoreReason -> NumUnderscoreReason -> Bool
    NumUnderscoreReason -> NumUnderscoreReason -> Ordering
    NumUnderscoreReason -> NumUnderscoreReason -> NumUnderscoreReason
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: NumUnderscoreReason -> NumUnderscoreReason -> Ordering
    compare :: NumUnderscoreReason -> NumUnderscoreReason -> Ordering
    $c< :: NumUnderscoreReason -> NumUnderscoreReason -> Bool
    < :: NumUnderscoreReason -> NumUnderscoreReason -> Bool
    $c<= :: NumUnderscoreReason -> NumUnderscoreReason -> Bool
    <= :: NumUnderscoreReason -> NumUnderscoreReason -> Bool
    $c> :: NumUnderscoreReason -> NumUnderscoreReason -> Bool
    > :: NumUnderscoreReason -> NumUnderscoreReason -> Bool
    $c>= :: NumUnderscoreReason -> NumUnderscoreReason -> Bool
    >= :: NumUnderscoreReason -> NumUnderscoreReason -> Bool
    $cmax :: NumUnderscoreReason -> NumUnderscoreReason -> NumUnderscoreReason
    max :: NumUnderscoreReason -> NumUnderscoreReason -> NumUnderscoreReason
    $cmin :: NumUnderscoreReason -> NumUnderscoreReason -> NumUnderscoreReason
    min :: NumUnderscoreReason -> NumUnderscoreReason -> NumUnderscoreReason
    Ord)

    data LexErrKind
       = LexErrKind_EOF        -- ^ End of input
       | LexErrKind_UTF8       -- ^ UTF-8 decoding error
       | LexErrKind_Char !Char -- ^ Error at given character
       deriving (Int -> LexErrKind -> ShowS
    [LexErrKind] -> ShowS
    LexErrKind -> String
    (Int -> LexErrKind -> ShowS)
    -> (LexErrKind -> String)
    -> ([LexErrKind] -> ShowS)
    -> Show LexErrKind
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> LexErrKind -> ShowS
    showsPrec :: Int -> LexErrKind -> ShowS
    $cshow :: LexErrKind -> String
    show :: LexErrKind -> String
    $cshowList :: [LexErrKind] -> ShowS
    showList :: [LexErrKind] -> ShowS
    Show,LexErrKind -> LexErrKind -> Bool
    (LexErrKind -> LexErrKind -> Bool)
    -> (LexErrKind -> LexErrKind -> Bool) -> Eq LexErrKind
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: LexErrKind -> LexErrKind -> Bool
    == :: LexErrKind -> LexErrKind -> Bool
    $c/= :: LexErrKind -> LexErrKind -> Bool
    /= :: LexErrKind -> LexErrKind -> Bool
    Eq,Eq LexErrKind
    Eq LexErrKind =>
    (LexErrKind -> LexErrKind -> Ordering)
    -> (LexErrKind -> LexErrKind -> Bool)
    -> (LexErrKind -> LexErrKind -> Bool)
    -> (LexErrKind -> LexErrKind -> Bool)
    -> (LexErrKind -> LexErrKind -> Bool)
    -> (LexErrKind -> LexErrKind -> LexErrKind)
    -> (LexErrKind -> LexErrKind -> LexErrKind)
    -> Ord LexErrKind
    LexErrKind -> LexErrKind -> Bool
    LexErrKind -> LexErrKind -> Ordering
    LexErrKind -> LexErrKind -> LexErrKind
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: LexErrKind -> LexErrKind -> Ordering
    compare :: LexErrKind -> LexErrKind -> Ordering
    $c< :: LexErrKind -> LexErrKind -> Bool
    < :: LexErrKind -> LexErrKind -> Bool
    $c<= :: LexErrKind -> LexErrKind -> Bool
    <= :: LexErrKind -> LexErrKind -> Bool
    $c> :: LexErrKind -> LexErrKind -> Bool
    > :: LexErrKind -> LexErrKind -> Bool
    $c>= :: LexErrKind -> LexErrKind -> Bool
    >= :: LexErrKind -> LexErrKind -> Bool
    $cmax :: LexErrKind -> LexErrKind -> LexErrKind
    max :: LexErrKind -> LexErrKind -> LexErrKind
    $cmin :: LexErrKind -> LexErrKind -> LexErrKind
    min :: LexErrKind -> LexErrKind -> LexErrKind
    Ord)

    data LexErr
       = LexError               -- ^ Lexical error
       | LexUnknownPragma       -- ^ Unknown pragma
       | LexErrorInPragma       -- ^ Lexical error in pragma
       | LexNumEscapeRange      -- ^ Numeric escape sequence out of range
       | LexUnterminatedComment -- ^ Unterminated `{-'
       | LexUnterminatedOptions -- ^ Unterminated OPTIONS pragma
       | LexUnterminatedQQ      -- ^ Unterminated quasiquotation
       deriving (Int -> LexErr -> ShowS
    [LexErr] -> ShowS
    LexErr -> String
    (Int -> LexErr -> ShowS)
    -> (LexErr -> String) -> ([LexErr] -> ShowS) -> Show LexErr
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> LexErr -> ShowS
    showsPrec :: Int -> LexErr -> ShowS
    $cshow :: LexErr -> String
    show :: LexErr -> String
    $cshowList :: [LexErr] -> ShowS
    showList :: [LexErr] -> ShowS
    Show,LexErr -> LexErr -> Bool
    (LexErr -> LexErr -> Bool)
    -> (LexErr -> LexErr -> Bool) -> Eq LexErr
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: LexErr -> LexErr -> Bool
    == :: LexErr -> LexErr -> Bool
    $c/= :: LexErr -> LexErr -> Bool
    /= :: LexErr -> LexErr -> Bool
    Eq,Eq LexErr
    Eq LexErr =>
    (LexErr -> LexErr -> Ordering)
    -> (LexErr -> LexErr -> Bool)
    -> (LexErr -> LexErr -> Bool)
    -> (LexErr -> LexErr -> Bool)
    -> (LexErr -> LexErr -> Bool)
    -> (LexErr -> LexErr -> LexErr)
    -> (LexErr -> LexErr -> LexErr)
    -> Ord LexErr
    LexErr -> LexErr -> Bool
    LexErr -> LexErr -> Ordering
    LexErr -> LexErr -> LexErr
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: LexErr -> LexErr -> Ordering
    compare :: LexErr -> LexErr -> Ordering
    $c< :: LexErr -> LexErr -> Bool
    < :: LexErr -> LexErr -> Bool
    $c<= :: LexErr -> LexErr -> Bool
    <= :: LexErr -> LexErr -> Bool
    $c> :: LexErr -> LexErr -> Bool
    > :: LexErr -> LexErr -> Bool
    $c>= :: LexErr -> LexErr -> Bool
    >= :: LexErr -> LexErr -> Bool
    $cmax :: LexErr -> LexErr -> LexErr
    max :: LexErr -> LexErr -> LexErr
    $cmin :: LexErr -> LexErr -> LexErr
    min :: LexErr -> LexErr -> LexErr
    Ord)

    -- | Errors from the Cmm parser
    data CmmParserError
       = CmmUnknownPrimitive    !FastString -- ^ Unknown Cmm primitive
       | CmmUnknownMacro        !FastString -- ^ Unknown macro
       | CmmUnknownCConv        !String     -- ^ Unknown calling convention
       | CmmUnrecognisedSafety  !String     -- ^ Unrecognised safety
       | CmmUnrecognisedHint    !String     -- ^ Unrecognised hint

    data TransLayoutReason
       = TransLayout_Where -- ^ "`where' clause at the same depth as implicit layout block"
       | TransLayout_Pipe  -- ^ "`|' at the same depth as implicit layout block")

    data FileHeaderPragmaType
      = OptionsPrag
      | IncludePrag
      | LanguagePrag
      | DocOptionsPrag