NoBlankEpAnnotations -> parens (case ap of

                                       (AnnParens       o c) -> text "AnnParens"       $$ vcat [showAstData' o, showAstData' c]

                                       (AnnParensHash   o c) -> text "AnnParensHash"   $$ vcat [showAstData' o, showAstData' c]

                                       )

             annClassDecl :: AnnClassDecl -> SDoc

 type instance XPar           GhcRn = NoExtField

 type instance XPar           GhcTc = NoExtField

 type instance XExplicitTuple GhcRn = NoExtField

 type instance XExplicitTuple GhcTc = NoExtField

 data AnnExplicitSum

   = AnnExplicitSum {

       aesBarsBefore :: [EpToken "|"],

       } deriving Data

 instance NoAnn AnnExplicitSum where

 data AnnFieldLabel

   = AnnFieldLabel {

 type instance XListPat GhcTc = Type

   -- List element type, for use in hsPatType.

 type instance XTuplePat GhcRn = NoExtField

 type instance XTuplePat GhcTc = [Type]

 -- API Annotations types

 data EpAnnSumPat = EpAnnSumPat

       , sumPatVbarsBefore :: [EpToken "|"]

       , sumPatVbarsAfter  :: [EpToken "|"]

       } deriving Data

 instance NoAnn EpAnnSumPat where

 -- ---------------------------------------------------------------------

 type instance XTyVar           (GhcPass _) = EpToken "'"

 type instance XAppTy           (GhcPass _) = NoExtField

 type instance XFunTy           (GhcPass _) = NoExtField

 type instance XTupleTy         (GhcPass _) = AnnParen

 type instance XSumTy           (GhcPass _) = AnnParen

 type instance XOpTy            (GhcPass _) = NoExtField

 type instance XExplicitListTy  GhcRn = NoExtField

 type instance XExplicitListTy  GhcTc = Kind

 type instance XExplicitTupleTy GhcRn = NoExtField

 type instance XExplicitTupleTy GhcTc = [Kind]

         | '(' ktype ')'               {% amsA' (sLL $1 $> $ HsParTy (epTok $1, epTok $3) $2) }

                                       -- see Note [Promotion] for the followings

         | SIMPLEQUOTE '(' ')'         {% do { requireLTPuns PEP_QuoteDisambiguation $1 $>

         | SIMPLEQUOTE gen_qcon {% amsA' (sLL $1 $> $ HsTyVar (epTok $1) IsPromoted $2) }

         | SIMPLEQUOTE sysdcon_nolist {% do { requireLTPuns PEP_QuoteDisambiguation $1 (reLoc $>)

                                            ; amsA' (sLL $1 $> $ HsTyVar (epTok $1) IsPromoted (L (getLoc $2) $ nameRdrName (dataConName (unLoc $2)))) }}

         | SIMPLEQUOTE  '(' ktype ',' comma_types1 ')'

                              {% do { requireLTPuns PEP_QuoteDisambiguation $1 $>

                                    ; h <- addTrailingCommaA $3 (epTok $4)

         | '[' ']'               {% withCombinedComments $1 $> (mkListSyntaxTy0 (epTok $1) (epTok $2)) }

         | SIMPLEQUOTE  '[' comma_types0 ']'     {% do { requireLTPuns PEP_QuoteDisambiguation $1 $>

                                                       ; amsA' (sLL $1 $> $ HsExplicitListTy (epTok $1, epTok $2, epTok $4) IsPromoted $3) }}

         | '(' tup_exprs ')'             { ECP $

                                            $2 >>= \ $2 ->

                                            mkSumOrTuplePV (noAnnSrcSpan $ comb2 $1 $>) Boxed $2

         | '(' orpats(exp2) ')'          {% do

                                               { pat <- hintOrPats (sL1a $2 (OrPat NoExtField (unLoc $2)))

         | '(#' texp '#)'                { ECP $

                                            unECP $2 >>= \ $2 ->

                                            mkSumOrTuplePV (noAnnSrcSpan $ comb2 $1 $>) Unboxed (Tuple [Right $2])

         | '(#' tup_exprs '#)'           { ECP $

                                            $2 >>= \ $2 ->

                                            mkSumOrTuplePV (noAnnSrcSpan $ comb2 $1 $>) Unboxed $2

         | '[' list ']'      { ECP $ $2 (comb2 $1 $>) (glR $1,glR $3) }

         | '_'               { ECP $ mkHsWildCardPV (getLoc $1) }

 -- Annotations for parenthesised elements, such as tuples, lists

 -- ---------------------------------------------------------------------

 data AnnParen

   = AnnParens       (EpToken "(")  (EpToken ")")  -- ^ '(', ')'

   | AnnParensHash   (EpToken "(#") (EpToken "#)") -- ^ '(#', '#)'

   deriving Data

 -- ---------------------------------------------------------------------

 instance Outputable AnnParen where

   ppr (AnnParens       o c) = text "AnnParens" <+> ppr o <+> ppr c

   ppr (AnnParensHash   o c) = text "AnnParensHash" <+> ppr o <+> ppr c

 instance Outputable AnnListItem where

   ppr (AnnListItem ts) = text "AnnListItem" <+> ppr ts

   -- With NoListTuplePuns, contexts are parsed as data constructors, which causes failure

   -- downstream.

   -- This converts them just like when they are parsed as types in the punned case.

   check (opi,cpi,csi) (L _lp1 (HsParTy (o,c) ty))

     = check (o:opi, c:cpi, csi) ty

   -- No need for anns, returning original

   where

     check :: ([EpToken "("],[EpToken ")"],EpAnnComments)

         -> LHsExpr GhcPs -> PV (LocatedC [LHsExpr GhcPs])

              -- Neither unboxed tuples (#e1,e2#) nor tuple sections (e1,,e2,) can be a context

     check (opi, cpi, csi) (L _ (HsPar (open_tok, close_tok) expr))

       = check (opi ++ [open_tok], close_tok : cpi, csi) expr

     check (oparens,cparens,cs) (L _ (HsVar _ (L (EpAnn _ (NameAnnOnly (NameParens open closed) []) _) name)))

   mkHsBangPatPV :: SrcSpan -> LocatedA b -> EpToken "!" -> PV (LocatedA b)

   -- | Disambiguate tuple sections and unboxed sums

   mkSumOrTuplePV

   -- | Disambiguate "type t" (embedded type)

   mkHsEmbTyPV :: SrcSpan -> EpToken "type" -> LHsType GhcPs -> PV (LocatedA b)

   -- | Disambiguate modifiers (%a)

       addError $ mkPlainErrorMsgEnvelope span $ PsErrIllegalBangPattern e

 mkSumOrTupleExpr :: SrcSpanAnnA -> Boxity -> SumOrTuple (HsExpr GhcPs)

                  -> PV (LHsExpr GhcPs)

 -- Tuple

 -- Sum

 -- mkSumOrTupleExpr l Unboxed (Sum alt arity e) =

 --     return $ L l (ExplicitSum noExtField alt arity e)

     !cs <- getCommentsFor (locA l)

     return $ L (EpAnn anc anIn (csIn Semi.<> cs)) (ExplicitSum an alt arity e)

 mkSumOrTupleExpr l Boxed a@Sum{} _ =

     addFatalError $ mkPlainErrorMsgEnvelope (locA l) $ PsErrUnsupportedBoxedSumExpr a

 mkSumOrTuplePat

   -> PV (LocatedA (PatBuilder GhcPs))

 -- Tuple

       HsExplicitTupleTy annsKeyword NotPromoted args

     annParen = AnnParens parOpen parClose

 -- | Decide whether to parse tuple con syntax @(,)@ in a type as a

 -- type or data constructor, based on the extension @ListTuplePuns@.

       HsExplicitListTy annsKeyword NotPromoted [t]

     annsKeyword = (NoEpTok, brkOpen, brkClose)

 parseError :: HsExpr GhcPs

 parseError = HsHole HoleError

 import GHC.Internal.Show (appPrec)

 import GHC.Internal.Text.ParserCombinators.ReadPrec (ReadPrec, readPrec_to_S, readS_to_Prec, pfail)

 import GHC.Internal.Text.Read.Lex (Lexeme(..))

 import GHC.Internal.Text.Show (showListWith)

 import Prelude

 import GHC.Internal.Data.Monoid (Sum(..), All(..), Any(..), Product(..))

 import GHC.Internal.Data.Type.Equality (TestEquality(..), (:~:)(..))

 import GHC.Generics (Generic, Generic1)

 import Prelude

 infixr 9 `Compose`

 import GHC.Internal.Base hiding ( foldr, mapM, sequence )

 import GHC.Internal.Classes

 import GHC.Internal.Err

 import GHC.Internal.Enum

 import GHC.Internal.Num

 import GHC.Internal.Prim (seq)

      readMaybe

      ) where

 import Text.ParserCombinators.ReadPrec

         GHC.Internal.System.Posix.Types

         GHC.Internal.Text.ParserCombinators.ReadP

         GHC.Internal.Text.ParserCombinators.ReadPrec

         GHC.Internal.Text.Read.Lex

         GHC.Internal.Text.Show

         GHC.Internal.Type.Reflection

 import qualified GHC.Internal.IO.Encoding.Iconv as Iconv

 #else

 import qualified GHC.Internal.IO.Encoding.CodePage as CodePage

 #endif

 import qualified GHC.Internal.IO.Encoding.Latin1 as Latin1

 import qualified GHC.Internal.IO.Encoding.UTF8   as UTF8

     _ | isAscii -> return (Latin1.mkAscii cfm)

     _ | isLatin1 -> return (Latin1.mkLatin1_checked cfm)

 #if defined(mingw32_HOST_OS)

     _ -> unknownEncodingErr (enc ++ codingFailureModeSuffix cfm)

 #else

     -- Otherwise, handle other encoding needs via iconv.

   >>> AnnList ()

   <<< ((EpToken "'"),(EpToken "["),(EpToken "]"))

 X(ExplicitTuple) mismatch

 X(Hole) match = HoleKind

 Extension fields @GhcRn

 # Interface stability testing

 core libraries do not inadvertently change. They use the `utils/dump-decls`

 utility to dump all exported declarations of all exposed modules for the

 following packages:

 Consequently, updating its output can be a bit tricky. There are two ways by

 which one can do this:

    similar enough that one can often apply the same patch of one file to the

    others.  For instance:

    ```

    In the case of conflicts, increasing the fuzz factor (using `-F`) can be

    quite effective.

    which contains the output produced by the job's failing tests. Simply

    files into this directory.

             (EpaComments

              []))

            (HsListTy

              (EpTok

               (EpaSpan { DumpParsedAst.hs:9:16 }))

              (EpTok

               (EpaComments

                []))

              (HsListTy

                (EpTok

                 (EpaSpan { DumpParsedAst.hs:10:27 }))

                (EpTok

                 (EpaComments

                  []))

                (HsListTy

                  (EpTok

                   (EpaSpan { DumpRenamedAst.hs:12:27 }))

                  (EpTok

               (EpaComments

                []))

              (HsListTy

                (EpTok

                 (EpaSpan { DumpRenamedAst.hs:11:16 }))

                (EpTok

                (EpaComments

                 []))

               (HsListTy

                 (EpTok

                  (EpaSpan { DumpRenamedAst.hs:31:12 }))

                 (EpTok

                  (EpaComments

                   []))

                 (HsListTy

                   (EpTok

                    (EpaSpan { DumpRenamedAst.hs:32:10 }))

                   (EpTok

         (EpaComments

          []))

        (HsListTy

          (EpTok

           (EpaSpan { KindSigs.hs:19:12 }))

          (EpTok

         (EpaComments

          []))

        (HsExplicitTupleTy

          (EpTok

           (EpaSpan { KindSigs.hs:28:16 }))

         (IsPromoted)

         [(L

           (EpAnn

              (EpaComments

               []))

             (HsListTy

               (EpTok

                (EpaSpan { KindSigs.hs:28:34 }))

               (EpTok

              (EpaComments

               []))

             (HsListTy

               (EpTok

                (EpaSpan { T20452.hs:8:57 }))

               (EpTok

              (EpaComments

               []))

             (HsListTy

               (EpTok

                (EpaSpan { T20452.hs:9:57 }))

               (EpTok

                   (GHC.Internal.Types.Int, GHC.Internal.Types.Int)

 pattern x_1 :+_0 y_2 = (x_1, y_2)

 pattern A_0 :: GHC.Internal.Types.Int -> GHC.Internal.Base.String

                        A_0 0 = "hi"

                        A_0 1 = "bye"

         words :: String -> [String]

           (imported from ‘Prelude’

            (and originally defined in ‘GHC.Internal.Data.OldList’))

         repeat :: forall a. a -> [a]

           with repeat @String

           (imported from ‘Prelude’

            (and originally defined in ‘GHC.Internal.List’))

         mempty :: forall a. Monoid a => a

           with mempty @(String -> [String])

           (imported from ‘Prelude’

       In an equation for ‘x’: x = (_ f) :: Int

     • Relevant bindings include x :: Int (bound at T21130.hs:10:1)

       Valid hole fits include

         head :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> a

           with head @Int

           (imported from ‘Prelude’

           with last @Int

           (imported from ‘Prelude’

            (and originally defined in ‘GHC.Internal.List’))

 T21130.hs:10:8: error: [GHC-39999]

     • Ambiguous type variable ‘t0’ arising from a use of ‘f’

 markParenO (AnnParensHash o c) = do

   o' <- markEpToken o

   return (AnnParensHash o' c)

 markParenC :: (Monad m, Monoid w) => AnnParen -> EP w m AnnParen

 markParenC (AnnParens o c) = do

 markParenC (AnnParensHash o c) = do

   c' <- markEpToken c

   return (AnnParensHash o c')

 -- ---------------------------------------------------------------------

 -- Bare bones Optics

 -- -------------------------------------

 -- data AnnExplicitSum

 --   = AnnExplicitSum {

 --       aesBarsBefore :: [EpToken "|"],

 --       } deriving Data

 laesBarsBefore :: Lens AnnExplicitSum [EpToken "|"]

 laesBarsBefore k parent = fmap (\new -> parent { aesBarsBefore = new })

 laesBarsAfter k parent = fmap (\new -> parent { aesBarsAfter = new })

                                (k (aesBarsAfter parent))

 -- -------------------------------------

 -- data AnnFieldLabel

 --   = AnnFieldLabel {

 -- ---------------------------------------------------------------------

 -- data EpAnnSumPat = EpAnnSumPat

 --       , sumPatVbarsBefore :: [EpToken "|"]

 --       , sumPatVbarsAfter  :: [EpToken "|"]

 --       } deriving Data

 lsumPatParens k parent = fmap (\new -> parent { sumPatParens = new })

                               (k (sumPatParens parent))

     expr' <- markAnnotated expr

     return (SectionR an op' expr')