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)

   -- | Validate infixexp LHS to reject unwanted {-# SCC ... #-} pragmas

       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

   >>> AnnList ()

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

 X(ExplicitTuple) mismatch

 X(Hole) mismatch

   >>> HoleKind

   <<< EpToken "_"

             (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

 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')

     args' <- mapM markAnnotated args

     debugM $ "ExplicitTuple done"

   exact (ExplicitSum an alt arity expr) = do

     an1 <- markLensFun an0 laesBarsBefore (\locs -> mapM markEpToken locs)

     expr' <- markAnnotated expr

     an2 <- markLensFun an1 laesBarsAfter (\locs -> mapM markEpToken locs)

     return (ExplicitSum an3 alt arity expr')

   exact (HsCase an e alts) = do

     (mult', ty1') <- markMultAnnOf mult (markAnnotated ty1)

     ty2' <- markAnnotated ty2

     return (HsFunTy an mult' ty1' ty2')

   exact (HsTupleTy an con tys) = do

     an0 <- markOpeningParen an

     tys' <- markAnnotated tys

     tys' <- markAnnotated tys

     c' <- markEpToken c

     return (HsExplicitListTy (sq',o',c') prom tys')

     sq' <- if (isPromoted prom)

               then markEpToken sq

               else return sq

     tys' <- markAnnotated tys

   exact (HsTyLit an lit) = do

     lit' <- withPpr lit

     return (HsTyLit an lit')

     (an', pats') <- markAnnList' an (markAnnotated pats)

     return (ListPat an' pats')

     pats' <- markAnnotated pats

   exact (SumPat an pat alt arity) = do

     an1 <- markLensFun an0 lsumPatVbarsBefore (\locs -> mapM markEpToken locs)

     pat' <- markAnnotated pat

     an2 <- markLensFun an1 lsumPatVbarsAfter (\locs -> mapM markEpToken locs)

     return (SumPat an3 pat' alt arity)

   exact (OrPat an pats) = do