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

module GHC.Parser.Errors.Types where

import GHC.Prelude

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