    {-# LANGUAGE LambdaCase #-}
    {-# LANGUAGE GADTs #-}
    {-# LANGUAGE FlexibleContexts #-}

    module GHC.Parser.Errors.Ppr
       ( pprWarning
       , pprError
       )
    where

    import GHC.Prelude
    import GHC.Driver.Flags
    import GHC.Parser.Errors
    import GHC.Parser.Types
    import GHC.Types.Basic
    import GHC.Types.SrcLoc
    import GHC.Types.Name.Reader (starInfo, rdrNameOcc, opIsAt, mkUnqual)
    import GHC.Types.Name.Occurrence (isSymOcc, occNameFS, varName)
    import GHC.Utils.Error
    import GHC.Utils.Outputable
    import GHC.Utils.Misc
    import GHC.Data.FastString
    import GHC.Hs.Expr (prependQualified,HsExpr(..))
    import GHC.Hs.Type (pprLHsContext)
    import GHC.Builtin.Names (allNameStrings)
    import GHC.Builtin.Types (filterCTuple)
    import Data.List.NonEmpty (NonEmpty((:|)))

    mkParserErr :: SrcSpan -> SDoc -> MsgEnvelope DecoratedSDoc
    mkParserErr :: SrcSpan -> SDoc -> MsgEnvelope DecoratedSDoc
    mkParserErr SrcSpan
    span SDoc
    doc = MsgEnvelope
       { errMsgSpan :: SrcSpan
    errMsgSpan        = SrcSpan
    span
       , errMsgContext :: PrintUnqualified
    errMsgContext     = PrintUnqualified
    alwaysQualify
       , errMsgDiagnostic :: DecoratedSDoc
    errMsgDiagnostic  = [SDoc] -> DecoratedSDoc
    mkDecorated [SDoc
    doc]
       , errMsgSeverity :: Severity
    errMsgSeverity    = Severity
    SevError
       , errMsgReason :: WarnReason
    errMsgReason      = WarnReason
    NoReason
       }

    mkParserWarn :: WarningFlag -> SrcSpan -> SDoc -> MsgEnvelope DecoratedSDoc
    mkParserWarn :: WarningFlag -> SrcSpan -> SDoc -> MsgEnvelope DecoratedSDoc
    mkParserWarn WarningFlag
    flag SrcSpan
    span SDoc
    doc = MsgEnvelope
       { errMsgSpan :: SrcSpan
    errMsgSpan        = SrcSpan
    span
       , errMsgContext :: PrintUnqualified
    errMsgContext     = PrintUnqualified
    alwaysQualify
       , errMsgDiagnostic :: DecoratedSDoc
    errMsgDiagnostic  = [SDoc] -> DecoratedSDoc
    mkDecorated [SDoc
    doc]
       , errMsgSeverity :: Severity
    errMsgSeverity    = Severity
    SevWarning
       , errMsgReason :: WarnReason
    errMsgReason      = WarningFlag -> WarnReason
    Reason WarningFlag
    flag
       }

    pprWarning :: PsWarning -> MsgEnvelope DecoratedSDoc
    pprWarning :: PsWarning -> MsgEnvelope DecoratedSDoc
    pprWarning = \case
       PsWarnTab SrcSpan
    loc Word
    tc
          -> WarningFlag -> SrcSpan -> SDoc -> MsgEnvelope DecoratedSDoc
    mkParserWarn WarningFlag
    Opt_WarnTabs SrcSpan
    loc forall a b. (a -> b) -> a -> b
    $
              String -> SDoc
    text String
    "Tab character found here"
                SDoc -> SDoc -> SDoc
    <> (if Word
    tc forall a. Eq a => a -> a -> Bool
    == Word
    1
                    then String -> SDoc
    text String
    ""
                    else String -> SDoc
    text String
    ", and in" SDoc -> SDoc -> SDoc
    <+> Int -> SDoc -> SDoc
    speakNOf (forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word
    tc forall a. Num a => a -> a -> a
    - Word
    1)) (String -> SDoc
    text String
    "further location"))
                SDoc -> SDoc -> SDoc
    <> String -> SDoc
    text String
    "."
                SDoc -> SDoc -> SDoc
    $+$ String -> SDoc
    text String
    "Please use spaces instead."

       PsWarnTransitionalLayout SrcSpan
    loc TransLayoutReason
    reason
          -> WarningFlag -> SrcSpan -> SDoc -> MsgEnvelope DecoratedSDoc
    mkParserWarn WarningFlag
    Opt_WarnAlternativeLayoutRuleTransitional SrcSpan
    loc forall a b. (a -> b) -> a -> b
    $
                String -> SDoc
    text String
    "transitional layout will not be accepted in the future:"
                SDoc -> SDoc -> SDoc
    $$ String -> SDoc
    text (case TransLayoutReason
    reason of
                   TransLayoutReason
    TransLayout_Where -> String
    "`where' clause at the same depth as implicit layout block"
                   TransLayoutReason
    TransLayout_Pipe  -> String
    "`|' at the same depth as implicit layout block"
                )

       PsWarnBidirectionalFormatChars ((PsLoc
    loc,Char
    _,String
    desc) :| [(PsLoc, Char, String)]
    xs)
          -> WarningFlag -> SrcSpan -> SDoc -> MsgEnvelope DecoratedSDoc
    mkParserWarn WarningFlag
    Opt_WarnUnicodeBidirectionalFormatCharacters (RealSrcSpan -> Maybe BufSpan -> SrcSpan
    RealSrcSpan (RealSrcLoc -> RealSrcSpan
    realSrcLocSpan forall a b. (a -> b) -> a -> b
    $ PsLoc -> RealSrcLoc
    psRealLoc PsLoc
    loc) forall a. Maybe a
    Nothing) forall a b. (a -> b) -> a -> b
    $
                String -> SDoc
    text String
    "A unicode bidirectional formatting character" SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    parens (String -> SDoc
    text String
    desc)
             SDoc -> SDoc -> SDoc
    $$ String -> SDoc
    text String
    "was found at offset" SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr (BufPos -> Int
    bufPos (PsLoc -> BufPos
    psBufPos PsLoc
    loc)) SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "in the file"
             SDoc -> SDoc -> SDoc
    $$ (case [(PsLoc, Char, String)]
    xs of
               [] -> SDoc
    empty
               [(PsLoc, Char, String)]
    xs -> String -> SDoc
    text String
    "along with further bidirectional formatting characters at" SDoc -> SDoc -> SDoc
    <+> forall {b}. [(PsLoc, b, String)] -> SDoc
    pprChars [(PsLoc, Char, String)]
    xs
                where
                  pprChars :: [(PsLoc, b, String)] -> SDoc
    pprChars [] = SDoc
    empty
                  pprChars ((PsLoc
    loc,b
    _,String
    desc):[(PsLoc, b, String)]
    xs) = String -> SDoc
    text String
    "offset" SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr (BufPos -> Int
    bufPos (PsLoc -> BufPos
    psBufPos PsLoc
    loc)) SDoc -> SDoc -> SDoc
    <> String -> SDoc
    text String
    ":" SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    desc
                                           SDoc -> SDoc -> SDoc
    $$ [(PsLoc, b, String)] -> SDoc
    pprChars [(PsLoc, b, String)]
    xs
                  )
             SDoc -> SDoc -> SDoc
    $$ String -> SDoc
    text String
    "Bidirectional formatting characters may be rendered misleadingly in certain editors"

       PsWarnUnrecognisedPragma SrcSpan
    loc
          -> WarningFlag -> SrcSpan -> SDoc -> MsgEnvelope DecoratedSDoc
    mkParserWarn WarningFlag
    Opt_WarnUnrecognisedPragmas SrcSpan
    loc forall a b. (a -> b) -> a -> b
    $
                String -> SDoc
    text String
    "Unrecognised pragma"

       PsWarnHaddockInvalidPos SrcSpan
    loc
          -> WarningFlag -> SrcSpan -> SDoc -> MsgEnvelope DecoratedSDoc
    mkParserWarn WarningFlag
    Opt_WarnInvalidHaddock SrcSpan
    loc forall a b. (a -> b) -> a -> b
    $
                String -> SDoc
    text String
    "A Haddock comment cannot appear in this position and will be ignored."

       PsWarnHaddockIgnoreMulti SrcSpan
    loc
          -> WarningFlag -> SrcSpan -> SDoc -> MsgEnvelope DecoratedSDoc
    mkParserWarn WarningFlag
    Opt_WarnInvalidHaddock SrcSpan
    loc forall a b. (a -> b) -> a -> b
    $
                String -> SDoc
    text String
    "Multiple Haddock comments for a single entity are not allowed." SDoc -> SDoc -> SDoc
    $$
                String -> SDoc
    text String
    "The extraneous comment will be ignored."

       PsWarnStarBinder SrcSpan
    loc
          -> WarningFlag -> SrcSpan -> SDoc -> MsgEnvelope DecoratedSDoc
    mkParserWarn WarningFlag
    Opt_WarnStarBinder SrcSpan
    loc forall a b. (a -> b) -> a -> b
    $
                String -> SDoc
    text String
    "Found binding occurrence of" SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (String -> SDoc
    text String
    "*")
                SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "yet StarIsType is enabled."
             SDoc -> SDoc -> SDoc
    $$ String -> SDoc
    text String
    "NB. To use (or export) this operator in"
                SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "modules with StarIsType,"
             SDoc -> SDoc -> SDoc
    $$ String -> SDoc
    text String
    "    including the definition module, you must qualify it."

       PsWarnStarIsType SrcSpan
    loc
          -> WarningFlag -> SrcSpan -> SDoc -> MsgEnvelope DecoratedSDoc
    mkParserWarn WarningFlag
    Opt_WarnStarIsType SrcSpan
    loc forall a b. (a -> b) -> a -> b
    $
                 String -> SDoc
    text String
    "Using" SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (String -> SDoc
    text String
    "*")
                 SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "(or its Unicode variant) to mean"
                 SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (String -> SDoc
    text String
    "Data.Kind.Type")
              SDoc -> SDoc -> SDoc
    $$ String -> SDoc
    text String
    "relies on the StarIsType extension, which will become"
              SDoc -> SDoc -> SDoc
    $$ String -> SDoc
    text String
    "deprecated in the future."
              SDoc -> SDoc -> SDoc
    $$ String -> SDoc
    text String
    "Suggested fix: use" SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (String -> SDoc
    text String
    "Type")
               SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "from" SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (String -> SDoc
    text String
    "Data.Kind") SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "instead."

       PsWarnImportPreQualified SrcSpan
    loc
          -> WarningFlag -> SrcSpan -> SDoc -> MsgEnvelope DecoratedSDoc
    mkParserWarn WarningFlag
    Opt_WarnPrepositiveQualifiedModule SrcSpan
    loc forall a b. (a -> b) -> a -> b
    $
                String -> SDoc
    text String
    "Found" SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (String -> SDoc
    text String
    "qualified")
                 SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "in prepositive position"
             SDoc -> SDoc -> SDoc
    $$ String -> SDoc
    text String
    "Suggested fix: place " SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (String -> SDoc
    text String
    "qualified")
                 SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "after the module name instead."
             SDoc -> SDoc -> SDoc
    $$ String -> SDoc
    text String
    "To allow this, enable language extension 'ImportQualifiedPost'"

       PsWarnOperatorWhitespaceExtConflict SrcSpan
    loc OperatorWhitespaceSymbol
    sym
          -> WarningFlag -> SrcSpan -> SDoc -> MsgEnvelope DecoratedSDoc
    mkParserWarn WarningFlag
    Opt_WarnOperatorWhitespaceExtConflict SrcSpan
    loc forall a b. (a -> b) -> a -> b
    $
             let mk_prefix_msg :: String -> String -> String -> SDoc
    mk_prefix_msg String
    operator_symbol String
    extension_name String
    syntax_meaning =
                      String -> SDoc
    text String
    "The prefix use of a" SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (String -> SDoc
    text String
    operator_symbol)
                        SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "would denote" SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    syntax_meaning
                   SDoc -> SDoc -> SDoc
    $$ Int -> SDoc -> SDoc
    nest Int
    2 (String -> SDoc
    text String
    "were the" SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    extension_name SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "extension enabled.")
                   SDoc -> SDoc -> SDoc
    $$ String -> SDoc
    text String
    "Suggested fix: add whitespace after the"
                        SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (String -> SDoc
    text String
    operator_symbol) SDoc -> SDoc -> SDoc
    <> Char -> SDoc
    char Char
    '.'
             in
             case OperatorWhitespaceSymbol
    sym of
               OperatorWhitespaceSymbol
    OperatorWhitespaceSymbol_PrefixPercent -> String -> String -> String -> SDoc
    mk_prefix_msg String
    "%" String
    "LinearTypes" String
    "a multiplicity annotation"
               OperatorWhitespaceSymbol
    OperatorWhitespaceSymbol_PrefixDollar -> String -> String -> String -> SDoc
    mk_prefix_msg String
    "$" String
    "TemplateHaskell" String
    "an untyped splice"
               OperatorWhitespaceSymbol
    OperatorWhitespaceSymbol_PrefixDollarDollar -> String -> String -> String -> SDoc
    mk_prefix_msg String
    "$$" String
    "TemplateHaskell" String
    "a typed splice"

       PsWarnOperatorWhitespace SrcSpan
    loc FastString
    sym OperatorWhitespaceOccurrence
    occ_type
          -> WarningFlag -> SrcSpan -> SDoc -> MsgEnvelope DecoratedSDoc
    mkParserWarn WarningFlag
    Opt_WarnOperatorWhitespace SrcSpan
    loc forall a b. (a -> b) -> a -> b
    $
             let mk_msg :: String -> SDoc
    mk_msg String
    occ_type_str =
                      String -> SDoc
    text String
    "The" SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    occ_type_str SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "use of a" SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (FastString -> SDoc
    ftext FastString
    sym)
                        SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "might be repurposed as special syntax"
                   SDoc -> SDoc -> SDoc
    $$ Int -> SDoc -> SDoc
    nest Int
    2 (String -> SDoc
    text String
    "by a future language extension.")
                   SDoc -> SDoc -> SDoc
    $$ String -> SDoc
    text String
    "Suggested fix: add whitespace around it."
             in
             case OperatorWhitespaceOccurrence
    occ_type of
               OperatorWhitespaceOccurrence
    OperatorWhitespaceOccurrence_Prefix -> String -> SDoc
    mk_msg String
    "prefix"
               OperatorWhitespaceOccurrence
    OperatorWhitespaceOccurrence_Suffix -> String -> SDoc
    mk_msg String
    "suffix"
               OperatorWhitespaceOccurrence
    OperatorWhitespaceOccurrence_TightInfix -> String -> SDoc
    mk_msg String
    "tight infix"

    pprError :: PsError -> MsgEnvelope DecoratedSDoc
    pprError :: PsError -> MsgEnvelope DecoratedSDoc
    pprError PsError
    err = SrcSpan -> SDoc -> MsgEnvelope DecoratedSDoc
    mkParserErr (PsError -> SrcSpan
    errLoc PsError
    err) forall a b. (a -> b) -> a -> b
    $ [SDoc] -> SDoc
    vcat
       (PsErrorDesc -> SDoc
    pp_err (PsError -> PsErrorDesc
    errDesc PsError
    err) forall a. a -> [a] -> [a]
    : forall a b. (a -> b) -> [a] -> [b]
    map Hint -> SDoc
    pp_hint (PsError -> [Hint]
    errHints PsError
    err))

    pp_err :: PsErrorDesc -> SDoc
    pp_err :: PsErrorDesc -> SDoc
    pp_err = \case
       PsErrorDesc
    PsErrLambdaCase
          -> String -> SDoc
    text String
    "Illegal lambda-case (use LambdaCase)"

       PsErrNumUnderscores NumUnderscoreReason
    reason
          -> String -> SDoc
    text forall a b. (a -> b) -> a -> b
    $ case NumUnderscoreReason
    reason of
                NumUnderscoreReason
    NumUnderscore_Integral -> String
    "Use NumericUnderscores to allow underscores in integer literals"
                NumUnderscoreReason
    NumUnderscore_Float    -> String
    "Use NumericUnderscores to allow underscores in floating literals"

       PsErrorDesc
    PsErrPrimStringInvalidChar
          -> String -> SDoc
    text String
    "primitive string literal must contain only characters <= \'\\xFF\'"

       PsErrorDesc
    PsErrMissingBlock
          -> String -> SDoc
    text String
    "Missing block"

       PsErrLexer LexErr
    err LexErrKind
    kind
          -> [SDoc] -> SDoc
    hcat
             [ String -> SDoc
    text forall a b. (a -> b) -> a -> b
    $ case LexErr
    err of
                LexErr
    LexError               -> String
    "lexical error"
                LexErr
    LexUnknownPragma       -> String
    "unknown pragma"
                LexErr
    LexErrorInPragma       -> String
    "lexical error in pragma"
                LexErr
    LexNumEscapeRange      -> String
    "numeric escape sequence out of range"
                LexErr
    LexStringCharLit       -> String
    "lexical error in string/character literal"
                LexErr
    LexStringCharLitEOF    -> String
    "unexpected end-of-file in string/character literal"
                LexErr
    LexUnterminatedComment -> String
    "unterminated `{-'"
                LexErr
    LexUnterminatedOptions -> String
    "unterminated OPTIONS pragma"
                LexErr
    LexUnterminatedQQ      -> String
    "unterminated quasiquotation"

             , String -> SDoc
    text forall a b. (a -> b) -> a -> b
    $ case LexErrKind
    kind of
                LexErrKind
    LexErrKind_EOF    -> String
    " at end of input"
                LexErrKind
    LexErrKind_UTF8   -> String
    " (UTF-8 decoding error)"
                LexErrKind_Char Char
    c -> String
    " at character " forall a. [a] -> [a] -> [a]
    ++ forall a. Show a => a -> String
    show Char
    c
             ]

       PsErrorDesc
    PsErrSuffixAT
          -> String -> SDoc
    text String
    "Suffix occurrence of @. For an as-pattern, remove the leading whitespace."

       PsErrParse String
    token
          | forall (t :: * -> *) a. Foldable t => t a -> Bool
    null String
    token
          -> String -> SDoc
    text String
    "parse error (possibly incorrect indentation or mismatched brackets)"

          | Bool
    otherwise
          -> String -> SDoc
    text String
    "parse error on input" SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (String -> SDoc
    text String
    token)

       PsErrorDesc
    PsErrCmmLexer
          -> String -> SDoc
    text String
    "Cmm lexical error"

       PsErrUnsupportedBoxedSumExpr SumOrTuple (HsExpr GhcPs)
    s
          -> SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    text String
    "Boxed sums not supported:") Int
    2
                  (forall b. Outputable b => Boxity -> SumOrTuple b -> SDoc
    pprSumOrTuple Boxity
    Boxed SumOrTuple (HsExpr GhcPs)
    s)

       PsErrUnsupportedBoxedSumPat SumOrTuple (PatBuilder GhcPs)
    s
          -> SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    text String
    "Boxed sums not supported:") Int
    2
                  (forall b. Outputable b => Boxity -> SumOrTuple b -> SDoc
    pprSumOrTuple Boxity
    Boxed SumOrTuple (PatBuilder GhcPs)
    s)

       PsErrUnexpectedQualifiedConstructor RdrName
    v
          -> SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    text String
    "Expected an unqualified type constructor:") Int
    2
                  (forall a. Outputable a => a -> SDoc
    ppr RdrName
    v)

       PsErrorDesc
    PsErrTupleSectionInPat
          -> String -> SDoc
    text String
    "Tuple section in pattern context"

       PsErrIllegalBangPattern Pat GhcPs
    e
          -> String -> SDoc
    text String
    "Illegal bang-pattern (use BangPatterns):" SDoc -> SDoc -> SDoc
    $$ forall a. Outputable a => a -> SDoc
    ppr Pat GhcPs
    e

       PsErrOpFewArgs (StarIsType Bool
    star_is_type) RdrName
    op
          -> String -> SDoc
    text String
    "Operator applied to too few arguments:" SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr RdrName
    op
             SDoc -> SDoc -> SDoc
    $$ Bool -> RdrName -> SDoc
    starInfo Bool
    star_is_type RdrName
    op

       PsErrorDesc
    PsErrImportQualifiedTwice
          -> String -> SDoc
    text String
    "Multiple occurrences of 'qualified'"

       PsErrorDesc
    PsErrImportPostQualified
          -> String -> SDoc
    text String
    "Found" SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (String -> SDoc
    text String
    "qualified")
              SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "in postpositive position. "
             SDoc -> SDoc -> SDoc
    $$ String -> SDoc
    text String
    "To allow this, enable language extension 'ImportQualifiedPost'"

       PsErrorDesc
    PsErrIllegalExplicitNamespace
          -> String -> SDoc
    text String
    "Illegal keyword 'type' (use ExplicitNamespaces to enable)"

       PsErrVarForTyCon RdrName
    name
          -> String -> SDoc
    text String
    "Expecting a type constructor but found a variable,"
               SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (forall a. Outputable a => a -> SDoc
    ppr RdrName
    name) SDoc -> SDoc -> SDoc
    <> String -> SDoc
    text String
    "."
             SDoc -> SDoc -> SDoc
    $$ if OccName -> Bool
    isSymOcc forall a b. (a -> b) -> a -> b
    $ RdrName -> OccName
    rdrNameOcc RdrName
    name
                then String -> SDoc
    text String
    "If" SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (forall a. Outputable a => a -> SDoc
    ppr RdrName
    name) SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "is a type constructor"
                      SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "then enable ExplicitNamespaces and use the 'type' keyword."
                else SDoc
    empty

       PsErrorDesc
    PsErrIllegalPatSynExport
          -> String -> SDoc
    text String
    "Illegal export form (use PatternSynonyms to enable)"

       PsErrorDesc
    PsErrMalformedEntityString
          -> String -> SDoc
    text String
    "Malformed entity string"

       PsErrorDesc
    PsErrDotsInRecordUpdate
          -> String -> SDoc
    text String
    "You cannot use `..' in a record update"

       PsErrPrecedenceOutOfRange Int
    i
          -> String -> SDoc
    text String
    "Precedence out of range: " SDoc -> SDoc -> SDoc
    <> Int -> SDoc
    int Int
    i

       PsErrorDesc
    PsErrOverloadedRecordDotInvalid
          -> String -> SDoc
    text String
    "Use of OverloadedRecordDot '.' not valid ('.' isn't allowed when constructing records or in record patterns)"

       PsErrorDesc
    PsErrOverloadedRecordUpdateNoQualifiedFields
          -> String -> SDoc
    text String
    "Fields cannot be qualified when OverloadedRecordUpdate is enabled"

       PsErrorDesc
    PsErrOverloadedRecordUpdateNotEnabled
          -> String -> SDoc
    text String
    "OverloadedRecordUpdate needs to be enabled"

       PsErrInvalidDataCon HsType GhcPs
    t
          -> SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    text String
    "Cannot parse data constructor in a data/newtype declaration:") Int
    2
                  (forall a. Outputable a => a -> SDoc
    ppr HsType GhcPs
    t)

       PsErrInvalidInfixDataCon HsType GhcPs
    lhs RdrName
    tc HsType GhcPs
    rhs
          -> SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    text String
    "Cannot parse an infix data constructor in a data/newtype declaration:")
                Int
    2 (forall a. Outputable a => a -> SDoc
    ppr HsType GhcPs
    lhs SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr RdrName
    tc SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr HsType GhcPs
    rhs)

       PsErrorDesc
    PsErrUnpackDataCon
          -> String -> SDoc
    text String
    "{-# UNPACK #-} cannot be applied to a data constructor."

       PsErrUnexpectedKindAppInDataCon DataConBuilder
    lhs HsType GhcPs
    ki
          -> SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    text String
    "Unexpected kind application in a data/newtype declaration:") Int
    2
                  (forall a. Outputable a => a -> SDoc
    ppr DataConBuilder
    lhs SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "@" SDoc -> SDoc -> SDoc
    <> forall a. Outputable a => a -> SDoc
    ppr HsType GhcPs
    ki)

       PsErrInvalidRecordCon PatBuilder GhcPs
    p
          -> String -> SDoc
    text String
    "Not a record constructor:" SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr PatBuilder GhcPs
    p

       PsErrIllegalUnboxedStringInPat HsLit GhcPs
    lit
          -> String -> SDoc
    text String
    "Illegal unboxed string literal in pattern:" SDoc -> SDoc -> SDoc
    $$ forall a. Outputable a => a -> SDoc
    ppr HsLit GhcPs
    lit

       PsErrorDesc
    PsErrDoNotationInPat
          -> String -> SDoc
    text String
    "do-notation in pattern"

       PsErrorDesc
    PsErrIfTheElseInPat
          -> String -> SDoc
    text String
    "(if ... then ... else ...)-syntax in pattern"

       PsErrorDesc
    PsErrLambdaCaseInPat
          -> String -> SDoc
    text String
    "(\\case ...)-syntax in pattern"

       PsErrorDesc
    PsErrCaseInPat
          -> String -> SDoc
    text String
    "(case ... of ...)-syntax in pattern"

       PsErrorDesc
    PsErrLetInPat
          -> String -> SDoc
    text String
    "(let ... in ...)-syntax in pattern"

       PsErrorDesc
    PsErrLambdaInPat
          -> String -> SDoc
    text String
    "Lambda-syntax in pattern."
             SDoc -> SDoc -> SDoc
    $$ String -> SDoc
    text String
    "Pattern matching on functions is not possible."

       PsErrArrowExprInPat HsExpr GhcPs
    e
          -> String -> SDoc
    text String
    "Expression syntax in pattern:" SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr HsExpr GhcPs
    e

       PsErrArrowCmdInPat HsCmd GhcPs
    c
          -> String -> SDoc
    text String
    "Command syntax in pattern:" SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr HsCmd GhcPs
    c

       PsErrArrowCmdInExpr HsCmd GhcPs
    c
          -> [SDoc] -> SDoc
    vcat
             [ String -> SDoc
    text String
    "Arrow command found where an expression was expected:"
             , Int -> SDoc -> SDoc
    nest Int
    2 (forall a. Outputable a => a -> SDoc
    ppr HsCmd GhcPs
    c)
             ]

       PsErrViewPatInExpr XRec GhcPs (HsExpr GhcPs)
    a XRec GhcPs (HsExpr GhcPs)
    b
          -> [SDoc] -> SDoc
    sep [ String -> SDoc
    text String
    "View pattern in expression context:"
                 , Int -> SDoc -> SDoc
    nest Int
    4 (forall a. Outputable a => a -> SDoc
    ppr XRec GhcPs (HsExpr GhcPs)
    a SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "->" SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr XRec GhcPs (HsExpr GhcPs)
    b)
                 ]

       PsErrTypeAppWithoutSpace RdrName
    v XRec GhcPs (HsExpr GhcPs)
    e
          -> [SDoc] -> SDoc
    sep [ String -> SDoc
    text String
    "@-pattern in expression context:"
                 , Int -> SDoc -> SDoc
    nest Int
    4 (forall a. OutputableBndr a => a -> SDoc
    pprPrefixOcc RdrName
    v SDoc -> SDoc -> SDoc
    <> String -> SDoc
    text String
    "@" SDoc -> SDoc -> SDoc
    <> forall a. Outputable a => a -> SDoc
    ppr XRec GhcPs (HsExpr GhcPs)
    e)
                 ]
             SDoc -> SDoc -> SDoc
    $$ String -> SDoc
    text String
    "Type application syntax requires a space before '@'"

       PsErrLazyPatWithoutSpace XRec GhcPs (HsExpr GhcPs)
    e
          -> [SDoc] -> SDoc
    sep [ String -> SDoc
    text String
    "Lazy pattern in expression context:"
                 , Int -> SDoc -> SDoc
    nest Int
    4 (String -> SDoc
    text String
    "~" SDoc -> SDoc -> SDoc
    <> forall a. Outputable a => a -> SDoc
    ppr XRec GhcPs (HsExpr GhcPs)
    e)
                 ]
             SDoc -> SDoc -> SDoc
    $$ String -> SDoc
    text String
    "Did you mean to add a space after the '~'?"

       PsErrBangPatWithoutSpace XRec GhcPs (HsExpr GhcPs)
    e
          -> [SDoc] -> SDoc
    sep [ String -> SDoc
    text String
    "Bang pattern in expression context:"
                 , Int -> SDoc -> SDoc
    nest Int
    4 (String -> SDoc
    text String
    "!" SDoc -> SDoc -> SDoc
    <> forall a. Outputable a => a -> SDoc
    ppr XRec GhcPs (HsExpr GhcPs)
    e)
                 ]
             SDoc -> SDoc -> SDoc
    $$ String -> SDoc
    text String
    "Did you mean to add a space after the '!'?"

       PsErrUnallowedPragma HsPragE GhcPs
    prag
          -> SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    text String
    "A pragma is not allowed in this position:") Int
    2
                  (forall a. Outputable a => a -> SDoc
    ppr HsPragE GhcPs
    prag)

       PsErrQualifiedDoInCmd ModuleName
    m
          -> SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    text String
    "Parse error in command:") Int
    2 forall a b. (a -> b) -> a -> b
    $
                String -> SDoc
    text String
    "Found a qualified" SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr ModuleName
    m SDoc -> SDoc -> SDoc
    <> String -> SDoc
    text String
    ".do block in a command, but"
                SDoc -> SDoc -> SDoc
    $$ String -> SDoc
    text String
    "qualified 'do' is not supported in commands."

       PsErrParseErrorInCmd SDoc
    s
          -> SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    text String
    "Parse error in command:") Int
    2 SDoc
    s

       PsErrParseErrorInPat SDoc
    s
          -> String -> SDoc
    text String
    "Parse error in pattern:" SDoc -> SDoc -> SDoc
    <+> SDoc
    s

       PsErrorDesc
    PsErrInvalidInfixHole
          -> String -> SDoc
    text String
    "Invalid infix hole, expected an infix operator"

       PsErrSemiColonsInCondExpr HsExpr GhcPs
    c Bool
    st HsExpr GhcPs
    t Bool
    se HsExpr GhcPs
    e
          -> String -> SDoc
    text String
    "Unexpected semi-colons in conditional:"
             SDoc -> SDoc -> SDoc
    $$ Int -> SDoc -> SDoc
    nest Int
    4 SDoc
    expr
             SDoc -> SDoc -> SDoc
    $$ String -> SDoc
    text String
    "Perhaps you meant to use DoAndIfThenElse?"
             where
                pprOptSemi :: Bool -> SDoc
    pprOptSemi Bool
    True  = SDoc
    semi
                pprOptSemi Bool
    False = SDoc
    empty
                expr :: SDoc
    expr = String -> SDoc
    text String
    "if"   SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr HsExpr GhcPs
    c SDoc -> SDoc -> SDoc
    <> Bool -> SDoc
    pprOptSemi Bool
    st SDoc -> SDoc -> SDoc
    <+>
                       String -> SDoc
    text String
    "then" SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr HsExpr GhcPs
    t SDoc -> SDoc -> SDoc
    <> Bool -> SDoc
    pprOptSemi Bool
    se SDoc -> SDoc -> SDoc
    <+>
                       String -> SDoc
    text String
    "else" SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr HsExpr GhcPs
    e

       PsErrSemiColonsInCondCmd HsExpr GhcPs
    c Bool
    st HsCmd GhcPs
    t Bool
    se HsCmd GhcPs
    e
          -> String -> SDoc
    text String
    "Unexpected semi-colons in conditional:"
             SDoc -> SDoc -> SDoc
    $$ Int -> SDoc -> SDoc
    nest Int
    4 SDoc
    expr
             SDoc -> SDoc -> SDoc
    $$ String -> SDoc
    text String
    "Perhaps you meant to use DoAndIfThenElse?"
             where
                pprOptSemi :: Bool -> SDoc
    pprOptSemi Bool
    True  = SDoc
    semi
                pprOptSemi Bool
    False = SDoc
    empty
                expr :: SDoc
    expr = String -> SDoc
    text String
    "if"   SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr HsExpr GhcPs
    c SDoc -> SDoc -> SDoc
    <> Bool -> SDoc
    pprOptSemi Bool
    st SDoc -> SDoc -> SDoc
    <+>
                       String -> SDoc
    text String
    "then" SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr HsCmd GhcPs
    t SDoc -> SDoc -> SDoc
    <> Bool -> SDoc
    pprOptSemi Bool
    se SDoc -> SDoc -> SDoc
    <+>
                       String -> SDoc
    text String
    "else" SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr HsCmd GhcPs
    e

       PsErrorDesc
    PsErrAtInPatPos
          -> String -> SDoc
    text String
    "Found a binding for the"
             SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (String -> SDoc
    text String
    "@")
             SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "operator in a pattern position."
             SDoc -> SDoc -> SDoc
    $$ SDoc
    perhaps_as_pat

       PsErrLambdaCmdInFunAppCmd LHsCmd GhcPs
    a
          -> forall a. Outputable a => SDoc -> a -> SDoc
    pp_unexpected_fun_app (String -> SDoc
    text String
    "lambda command") LHsCmd GhcPs
    a

       PsErrCaseCmdInFunAppCmd LHsCmd GhcPs
    a
          -> forall a. Outputable a => SDoc -> a -> SDoc
    pp_unexpected_fun_app (String -> SDoc
    text String
    "case command") LHsCmd GhcPs
    a

       PsErrIfCmdInFunAppCmd LHsCmd GhcPs
    a
          -> forall a. Outputable a => SDoc -> a -> SDoc
    pp_unexpected_fun_app (String -> SDoc
    text String
    "if command") LHsCmd GhcPs
    a

       PsErrLetCmdInFunAppCmd LHsCmd GhcPs
    a
          -> forall a. Outputable a => SDoc -> a -> SDoc
    pp_unexpected_fun_app (String -> SDoc
    text String
    "let command") LHsCmd GhcPs
    a

       PsErrDoCmdInFunAppCmd LHsCmd GhcPs
    a
          -> forall a. Outputable a => SDoc -> a -> SDoc
    pp_unexpected_fun_app (String -> SDoc
    text String
    "do command") LHsCmd GhcPs
    a

       PsErrDoInFunAppExpr Maybe ModuleName
    m XRec GhcPs (HsExpr GhcPs)
    a
          -> forall a. Outputable a => SDoc -> a -> SDoc
    pp_unexpected_fun_app (Maybe ModuleName -> SDoc -> SDoc
    prependQualified Maybe ModuleName
    m (String -> SDoc
    text String
    "do block")) XRec GhcPs (HsExpr GhcPs)
    a

       PsErrMDoInFunAppExpr Maybe ModuleName
    m XRec GhcPs (HsExpr GhcPs)
    a
          -> forall a. Outputable a => SDoc -> a -> SDoc
    pp_unexpected_fun_app (Maybe ModuleName -> SDoc -> SDoc
    prependQualified Maybe ModuleName
    m (String -> SDoc
    text String
    "mdo block")) XRec GhcPs (HsExpr GhcPs)
    a

       PsErrLambdaInFunAppExpr XRec GhcPs (HsExpr GhcPs)
    a
          -> forall a. Outputable a => SDoc -> a -> SDoc
    pp_unexpected_fun_app (String -> SDoc
    text String
    "lambda expression") XRec GhcPs (HsExpr GhcPs)
    a

       PsErrCaseInFunAppExpr XRec GhcPs (HsExpr GhcPs)
    a
          -> forall a. Outputable a => SDoc -> a -> SDoc
    pp_unexpected_fun_app (String -> SDoc
    text String
    "case expression") XRec GhcPs (HsExpr GhcPs)
    a

       PsErrLambdaCaseInFunAppExpr XRec GhcPs (HsExpr GhcPs)
    a
          -> forall a. Outputable a => SDoc -> a -> SDoc
    pp_unexpected_fun_app (String -> SDoc
    text String
    "lambda-case expression") XRec GhcPs (HsExpr GhcPs)
    a

       PsErrLetInFunAppExpr XRec GhcPs (HsExpr GhcPs)
    a
          -> forall a. Outputable a => SDoc -> a -> SDoc
    pp_unexpected_fun_app (String -> SDoc
    text String
    "let expression") XRec GhcPs (HsExpr GhcPs)
    a

       PsErrIfInFunAppExpr XRec GhcPs (HsExpr GhcPs)
    a
          -> forall a. Outputable a => SDoc -> a -> SDoc
    pp_unexpected_fun_app (String -> SDoc
    text String
    "if expression") XRec GhcPs (HsExpr GhcPs)
    a

       PsErrProcInFunAppExpr XRec GhcPs (HsExpr GhcPs)
    a
          -> forall a. Outputable a => SDoc -> a -> SDoc
    pp_unexpected_fun_app (String -> SDoc
    text String
    "proc expression") XRec GhcPs (HsExpr GhcPs)
    a

       PsErrMalformedTyOrClDecl LHsType GhcPs
    ty
          -> String -> SDoc
    text String
    "Malformed head of type or class declaration:"
             SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr LHsType GhcPs
    ty

       PsErrorDesc
    PsErrIllegalWhereInDataDecl
          -> [SDoc] -> SDoc
    vcat
                [ String -> SDoc
    text String
    "Illegal keyword 'where' in data declaration"
                , String -> SDoc
    text String
    "Perhaps you intended to use GADTs or a similar language"
                , String -> SDoc
    text String
    "extension to enable syntax: data T where"
                ]

       PsErrIllegalTraditionalRecordSyntax SDoc
    s
          -> String -> SDoc
    text String
    "Illegal record syntax (use TraditionalRecordSyntax):"
             SDoc -> SDoc -> SDoc
    <+> SDoc
    s

       PsErrParseErrorOnInput OccName
    occ
          -> String -> SDoc
    text String
    "parse error on input" SDoc -> SDoc -> SDoc
    <+> FastString -> SDoc
    ftext (OccName -> FastString
    occNameFS OccName
    occ)

       PsErrIllegalDataTypeContext LHsContext GhcPs
    c
          -> String -> SDoc
    text String
    "Illegal datatype context (use DatatypeContexts):"
             SDoc -> SDoc -> SDoc
    <+> forall (p :: Pass).
    OutputableBndrId p =>
    Maybe (LHsContext (GhcPass p)) -> SDoc
    pprLHsContext (forall a. a -> Maybe a
    Just LHsContext GhcPs
    c)

       PsErrMalformedDecl SDoc
    what RdrName
    for
          -> String -> SDoc
    text String
    "Malformed" SDoc -> SDoc -> SDoc
    <+> SDoc
    what
             SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "declaration for" SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (forall a. Outputable a => a -> SDoc
    ppr RdrName
    for)

       PsErrUnexpectedTypeAppInDecl LHsType GhcPs
    ki SDoc
    what RdrName
    for
          -> [SDoc] -> SDoc
    vcat [ String -> SDoc
    text String
    "Unexpected type application"
                    SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "@" SDoc -> SDoc -> SDoc
    <> forall a. Outputable a => a -> SDoc
    ppr LHsType GhcPs
    ki
                  , String -> SDoc
    text String
    "In the" SDoc -> SDoc -> SDoc
    <+> SDoc
    what
                    SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "declaration for"
                    SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (forall a. Outputable a => a -> SDoc
    ppr RdrName
    for)
                  ]

       PsErrNotADataCon RdrName
    name
          -> String -> SDoc
    text String
    "Not a data constructor:" SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (forall a. Outputable a => a -> SDoc
    ppr RdrName
    name)

       PsErrRecordSyntaxInPatSynDecl LPat GhcPs
    pat
          -> String -> SDoc
    text String
    "record syntax not supported for pattern synonym declarations:"
             SDoc -> SDoc -> SDoc
    $$ forall a. Outputable a => a -> SDoc
    ppr LPat GhcPs
    pat

       PsErrEmptyWhereInPatSynDecl RdrName
    patsyn_name
          -> String -> SDoc
    text String
    "pattern synonym 'where' clause cannot be empty"
             SDoc -> SDoc -> SDoc
    $$ String -> SDoc
    text String
    "In the pattern synonym declaration for: "
                SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr (RdrName
    patsyn_name)

       PsErrInvalidWhereBindInPatSynDecl RdrName
    patsyn_name HsDecl GhcPs
    decl
          -> String -> SDoc
    text String
    "pattern synonym 'where' clause must bind the pattern synonym's name"
             SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (forall a. Outputable a => a -> SDoc
    ppr RdrName
    patsyn_name) SDoc -> SDoc -> SDoc
    $$ forall a. Outputable a => a -> SDoc
    ppr HsDecl GhcPs
    decl

       PsErrNoSingleWhereBindInPatSynDecl RdrName
    _patsyn_name HsDecl GhcPs
    decl
          -> String -> SDoc
    text String
    "pattern synonym 'where' clause must contain a single binding:"
             SDoc -> SDoc -> SDoc
    $$ forall a. Outputable a => a -> SDoc
    ppr HsDecl GhcPs
    decl

       PsErrDeclSpliceNotAtTopLevel SpliceDecl GhcPs
    d
          -> SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    text String
    "Declaration splices are allowed only"
                   SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "at the top level:")
               Int
    2 (forall a. Outputable a => a -> SDoc
    ppr SpliceDecl GhcPs
    d)

       PsErrorDesc
    PsErrInferredTypeVarNotAllowed
          -> String -> SDoc
    text String
    "Inferred type variables are not allowed here"

       PsErrIllegalRoleName FastString
    role [Role]
    nearby
          -> String -> SDoc
    text String
    "Illegal role name" SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (forall a. Outputable a => a -> SDoc
    ppr FastString
    role)
             SDoc -> SDoc -> SDoc
    $$ case [Role]
    nearby of
                 []  -> SDoc
    empty
                 [Role
    r] -> String -> SDoc
    text String
    "Perhaps you meant" SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (forall a. Outputable a => a -> SDoc
    ppr Role
    r)
                 -- will this last case ever happen??
                 [Role]
    _   -> SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    text String
    "Perhaps you meant one of these:")
                             Int
    2 (forall a. (a -> SDoc) -> [a] -> SDoc
    pprWithCommas (SDoc -> SDoc
    quotes forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. Outputable a => a -> SDoc
    ppr) [Role]
    nearby)

       PsErrMultipleNamesInStandaloneKindSignature [XRec GhcPs (IdP GhcPs)]
    vs
          -> [SDoc] -> SDoc
    vcat [ SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    text String
    "Standalone kind signatures do not support multiple names at the moment:")
                    Int
    2 (forall a. (a -> SDoc) -> [a] -> SDoc
    pprWithCommas forall a. Outputable a => a -> SDoc
    ppr [XRec GhcPs (IdP GhcPs)]
    vs)
                  , String -> SDoc
    text String
    "See https://gitlab.haskell.org/ghc/ghc/issues/16754 for details."
                  ]

       PsErrorDesc
    PsErrIllegalImportBundleForm
          -> String -> SDoc
    text String
    "Illegal import form, this syntax can only be used to bundle"
             SDoc -> SDoc -> SDoc
    $+$ String -> SDoc
    text String
    "pattern synonyms with types in module exports."

       PsErrInvalidTypeSignature XRec GhcPs (HsExpr GhcPs)
    lhs
          -> String -> SDoc
    text String
    "Invalid type signature:"
             SDoc -> SDoc -> SDoc
    <+> forall a. Outputable a => a -> SDoc
    ppr XRec GhcPs (HsExpr GhcPs)
    lhs
             SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    ":: ..."
             SDoc -> SDoc -> SDoc
    $$ String -> SDoc
    text String
    hint
             where
             hint :: String
    hint | RdrName
    foreign_RDR forall {p} {l} {l}.
    (XRec p (IdP p) ~ GenLocated l (IdP p),
     XRec p (HsExpr p) ~ GenLocated l (HsExpr p), Eq (IdP p)) =>
    IdP p -> GenLocated l (HsExpr p) -> Bool
    `looks_like` XRec GhcPs (HsExpr GhcPs)
    lhs
                  = String
    "Perhaps you meant to use ForeignFunctionInterface?"
                  | RdrName
    default_RDR forall {p} {l} {l}.
    (XRec p (IdP p) ~ GenLocated l (IdP p),
     XRec p (HsExpr p) ~ GenLocated l (HsExpr p), Eq (IdP p)) =>
    IdP p -> GenLocated l (HsExpr p) -> Bool
    `looks_like` XRec GhcPs (HsExpr GhcPs)
    lhs
                  = String
    "Perhaps you meant to use DefaultSignatures?"
                  | RdrName
    pattern_RDR forall {p} {l} {l}.
    (XRec p (IdP p) ~ GenLocated l (IdP p),
     XRec p (HsExpr p) ~ GenLocated l (HsExpr p), Eq (IdP p)) =>
    IdP p -> GenLocated l (HsExpr p) -> Bool
    `looks_like` XRec GhcPs (HsExpr GhcPs)
    lhs
                  = String
    "Perhaps you meant to use PatternSynonyms?"
                  | Bool
    otherwise
                  = String
    "Should be of form <variable> :: <type>"

             -- A common error is to forget the ForeignFunctionInterface flag
             -- so check for that, and suggest.  cf #3805
             -- Sadly 'foreign import' still barfs 'parse error' because
             --  'import' is a keyword
             -- looks_like :: RdrName -> LHsExpr GhcPs -> Bool -- AZ
             looks_like :: IdP p -> GenLocated l (HsExpr p) -> Bool
    looks_like IdP p
    s (L l
    _ (HsVar XVar p
    _ (L l
    _ IdP p
    v))) = IdP p
    v forall a. Eq a => a -> a -> Bool
    == IdP p
    s
             looks_like IdP p
    s (L l
    _ (HsApp XApp p
    _ XRec p (HsExpr p)
    lhs XRec p (HsExpr p)
    _))   = IdP p -> GenLocated l (HsExpr p) -> Bool
    looks_like IdP p
    s XRec p (HsExpr p)
    lhs
             looks_like IdP p
    _ GenLocated l (HsExpr p)
    _                       = Bool
    False

             foreign_RDR :: RdrName
    foreign_RDR = NameSpace -> FastString -> RdrName
    mkUnqual NameSpace
    varName (String -> FastString
    fsLit String
    "foreign")
             default_RDR :: RdrName
    default_RDR = NameSpace -> FastString -> RdrName
    mkUnqual NameSpace
    varName (String -> FastString
    fsLit String
    "default")
             pattern_RDR :: RdrName
    pattern_RDR = NameSpace -> FastString -> RdrName
    mkUnqual NameSpace
    varName (String -> FastString
    fsLit String
    "pattern")

       PsErrUnexpectedTypeInDecl LHsType GhcPs
    t SDoc
    what RdrName
    tc [LHsTypeArg GhcPs]
    tparms SDoc
    equals_or_where
          -> [SDoc] -> SDoc
    vcat [ String -> SDoc
    text String
    "Unexpected type" SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (forall a. Outputable a => a -> SDoc
    ppr LHsType GhcPs
    t)
                  , String -> SDoc
    text String
    "In the" SDoc -> SDoc -> SDoc
    <+> SDoc
    what
                    SDoc -> SDoc -> SDoc
    <+> PtrString -> SDoc
    ptext (String -> PtrString
    sLit String
    "declaration for") SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes SDoc
    tc'
                  , [SDoc] -> SDoc
    vcat[ (String -> SDoc
    text String
    "A" SDoc -> SDoc -> SDoc
    <+> SDoc
    what
                           SDoc -> SDoc -> SDoc
    <+> PtrString -> SDoc
    ptext (String -> PtrString
    sLit String
    "declaration should have form"))
                  , Int -> SDoc -> SDoc
    nest Int
    2
                    (SDoc
    what
                     SDoc -> SDoc -> SDoc
    <+> SDoc
    tc'
                     SDoc -> SDoc -> SDoc
    <+> [SDoc] -> SDoc
    hsep (forall a b. (a -> b) -> [a] -> [b]
    map String -> SDoc
    text (forall b a. [b] -> [a] -> [a]
    takeList [LHsTypeArg GhcPs]
    tparms [String]
    allNameStrings))
                     SDoc -> SDoc -> SDoc
    <+> SDoc
    equals_or_where) ] ]
              where
                -- Avoid printing a constraint tuple in the error message. Print
                -- a plain old tuple instead (since that's what the user probably
                -- wrote). See #14907
                tc' :: SDoc
    tc' = forall a. Outputable a => a -> SDoc
    ppr forall a b. (a -> b) -> a -> b
    $ RdrName -> RdrName
    filterCTuple RdrName
    tc

       PsErrCmmParser CmmParserError
    cmm_err -> case CmmParserError
    cmm_err of
          CmmUnknownPrimitive FastString
    name     -> String -> SDoc
    text String
    "unknown primitive" SDoc -> SDoc -> SDoc
    <+> FastString -> SDoc
    ftext FastString
    name
          CmmUnknownMacro FastString
    fun          -> String -> SDoc
    text String
    "unknown macro" SDoc -> SDoc -> SDoc
    <+> FastString -> SDoc
    ftext FastString
    fun
          CmmUnknownCConv String
    cconv        -> String -> SDoc
    text String
    "unknown calling convention:" SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    cconv
          CmmUnrecognisedSafety String
    safety -> String -> SDoc
    text String
    "unrecognised safety" SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    safety
          CmmUnrecognisedHint String
    hint     -> String -> SDoc
    text String
    "unrecognised hint:" SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    hint

       PsErrorDesc
    PsErrExpectedHyphen
          -> String -> SDoc
    text String
    "Expected a hyphen"

       PsErrorDesc
    PsErrSpaceInSCC
          -> String -> SDoc
    text String
    "Spaces are not allowed in SCCs"

       PsErrEmptyDoubleQuotes Bool
    th_on
          -> if Bool
    th_on then [SDoc] -> SDoc
    vcat ([SDoc]
    msg forall a. [a] -> [a] -> [a]
    ++ [SDoc]
    th_msg) else [SDoc] -> SDoc
    vcat [SDoc]
    msg
             where
                msg :: [SDoc]
    msg    = [ String -> SDoc
    text String
    "Parser error on `''`"
                         , String -> SDoc
    text String
    "Character literals may not be empty"
                         ]
                th_msg :: [SDoc]
    th_msg = [ String -> SDoc
    text String
    "Or perhaps you intended to use quotation syntax of TemplateHaskell,"
                         , String -> SDoc
    text String
    "but the type variable or constructor is missing"
                         ]

       PsErrInvalidPackageName FastString
    pkg
          -> [SDoc] -> SDoc
    vcat
                [ String -> SDoc
    text String
    "Parse error" SDoc -> SDoc -> SDoc
    <> SDoc
    colon SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (FastString -> SDoc
    ftext FastString
    pkg)
                , String -> SDoc
    text String
    "Version number or non-alphanumeric" SDoc -> SDoc -> SDoc
    <+>
                  String -> SDoc
    text String
    "character in package name"
                ]

       PsErrorDesc
    PsErrInvalidRuleActivationMarker
          -> String -> SDoc
    text String
    "Invalid rule activation marker"

       PsErrorDesc
    PsErrLinearFunction
          -> String -> SDoc
    text String
    "Enable LinearTypes to allow linear functions"

       PsErrInvalidCApiImport {}
          -> String -> SDoc
    text String
    "Wrapper stubs can't be used with CApiFFI."

       PsErrorDesc
    PsErrMultiWayIf
          -> String -> SDoc
    text String
    "Multi-way if-expressions need MultiWayIf turned on"

       PsErrExplicitForall Bool
    is_unicode
          -> [SDoc] -> SDoc
    vcat
             [ String -> SDoc
    text String
    "Illegal symbol" SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (Bool -> SDoc
    forallSym Bool
    is_unicode) SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "in type"
             , String -> SDoc
    text String
    "Perhaps you intended to use RankNTypes or a similar language"
             , String -> SDoc
    text String
    "extension to enable explicit-forall syntax:" SDoc -> SDoc -> SDoc
    <+>
               Bool -> SDoc
    forallSym Bool
    is_unicode SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "<tvs>. <type>"
             ]
             where
              forallSym :: Bool -> SDoc
    forallSym Bool
    True  = String -> SDoc
    text String
    "∀"
              forallSym Bool
    False = String -> SDoc
    text String
    "forall"

       PsErrIllegalQualifiedDo SDoc
    qdoDoc
          -> [SDoc] -> SDoc
    vcat
             [ String -> SDoc
    text String
    "Illegal qualified" SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes SDoc
    qdoDoc SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "block"
             , String -> SDoc
    text String
    "Perhaps you intended to use QualifiedDo"
             ]

    pp_unexpected_fun_app :: Outputable a => SDoc -> a -> SDoc
    pp_unexpected_fun_app :: forall a. Outputable a => SDoc -> a -> SDoc
    pp_unexpected_fun_app SDoc
    e a
    a =
       String -> SDoc
    text String
    "Unexpected " SDoc -> SDoc -> SDoc
    <> SDoc
    e SDoc -> SDoc -> SDoc
    <> String -> SDoc
    text String
    " in function application:"
        SDoc -> SDoc -> SDoc
    $$ Int -> SDoc -> SDoc
    nest Int
    4 (forall a. Outputable a => a -> SDoc
    ppr a
    a)
        SDoc -> SDoc -> SDoc
    $$ String -> SDoc
    text String
    "You could write it with parentheses"
        SDoc -> SDoc -> SDoc
    $$ String -> SDoc
    text String
    "Or perhaps you meant to enable BlockArguments?"

    pp_hint :: Hint -> SDoc
    pp_hint :: Hint -> SDoc
    pp_hint = \case
       Hint
    SuggestTH              -> String -> SDoc
    text String
    "Perhaps you intended to use TemplateHaskell"
       Hint
    SuggestDo              -> String -> SDoc
    text String
    "Perhaps this statement should be within a 'do' block?"
       Hint
    SuggestMissingDo       -> String -> SDoc
    text String
    "Possibly caused by a missing 'do'?"
       Hint
    SuggestRecursiveDo     -> String -> SDoc
    text String
    "Perhaps you intended to use RecursiveDo"
       Hint
    SuggestLetInDo         -> String -> SDoc
    text String
    "Perhaps you need a 'let' in a 'do' block?"
                                 SDoc -> SDoc -> SDoc
    $$ String -> SDoc
    text String
    "e.g. 'let x = 5' instead of 'x = 5'"
       Hint
    SuggestPatternSynonyms -> String -> SDoc
    text String
    "Perhaps you intended to use PatternSynonyms"

       SuggestInfixBindMaybeAtPat RdrName
    fun
          -> String -> SDoc
    text String
    "In a function binding for the"
                SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    quotes (forall a. Outputable a => a -> SDoc
    ppr RdrName
    fun)
                SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "operator."
             SDoc -> SDoc -> SDoc
    $$ if RdrName -> Bool
    opIsAt RdrName
    fun
                   then SDoc
    perhaps_as_pat
                   else SDoc
    empty
       Hint
    TypeApplicationsInPatternsOnlyDataCons ->
         String -> SDoc
    text String
    "Type applications in patterns are only allowed on data constructors."

    perhaps_as_pat :: SDoc
    perhaps_as_pat :: SDoc
    perhaps_as_pat = String -> SDoc
    text String
    "Perhaps you meant an as-pattern, which must not be surrounded by whitespace"