type instance XLet           GhcRn = NoExtField

 type instance XLet           GhcTc = NoExtField

 type instance XDo            GhcRn = NoExtField

 type instance XDo            GhcTc = Type

 type instance XExplicitList  GhcPs = (EpToken "[", EpToken "]")

 type instance XExplicitList  GhcRn = NoExtField

 type instance XExplicitList  GhcTc = Type

 type instance XCmdLet     GhcRn = NoExtField

 type instance XCmdLet     GhcTc = NoExtField

 type instance XCmdDo      GhcRn = NoExtField

 type instance XCmdDo      GhcTc = Type

 mkHsFractional :: FractionalLit GhcPs -> HsOverLit GhcPs

 mkHsIsString   :: SourceText -> HText -> HsOverLit GhcPs

 mkHsDo         :: HsDoFlavour -> LocatedA [ExprLStmt GhcPs] -> HsExpr GhcPs

 mkHsComp       :: HsDoFlavour -> [ExprLStmt GhcPs] -> LHsExpr GhcPs

                -> HsExpr GhcPs

                -> HsExpr GhcPs

 mkNPat      :: LocatedAn NoEpAnns (HsOverLit GhcPs) -> Maybe (SyntaxExpr GhcPs) -> EpToken "-"

                                       return $ ECP $

                                         $2 >>= \ $2 ->

                                         mkHsDoPV (comb2 $1 $2)

                                                  (fmap mkModuleNameFS (getDO $1))

         | MDO stmtlist             {% hintQualifiedDo $1 >> runPV $2 >>= \ $2 ->

                                        fmap ecpFromExp $

                                        amsA' (L (comb2 $1 $2)

         | 'proc' aexp '->' exp

                        {% (checkPattern <=< runPV) (unECP $2) >>= \ p ->

                            runPV (unECP $4) >>= \ $4@cmd ->

              { \loc (ao,ac) ->

                 checkMonadComp >>= \ ctxt ->

                 unECP $1 >>= \ $1 -> do { t <- addTrailingVbarA $1 (epTok $2)

                     >>= ecpFromExp' } }

 lexps :: { forall b. DisambECP b => PV [LocatedA b] }

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

 -- Statement sequences

         : '{'           stmts '}'       { $2 >>= \ $2 ->

         |     vocurly   stmts close     { $2 >>= \ $2 ->

 --      do { ;; s ; s ; ; s ;; }

 -- The last Stmt should be an expression, but that's hard to enforce

 stmt  :: { forall b. DisambECP b => PV (LStmt GhcPs (LocatedA b)) }

         : qual                          { $1 }

         | 'rec' stmtlist                {  $2 >>= \ $2 ->

                                                                         (stmtlistStmts $2)) }

 qual  :: { forall b. DisambECP b => PV (LStmt GhcPs (LocatedA b)) }

   !cs <- getPriorCommentsFor (getLocA la)

   return (L (addCommentsToEpAnn l cs) a)

 listAsAnchorM :: [LocatedAn t a] -> Maybe EpaLocation

 listAsAnchorM [] = Nothing

 listAsAnchorM (L l _:_) =

 stmtlistStmts (L la (_,L l stmts))

   = L ((noAnnSrcSpan l) {comments = comments la}) stmts

 stmtlistAnns (L _ (an,_)) = an

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

       } deriving (Data,Eq)

 data AnnListBrackets

   | ListNone

   deriving (Data,Eq)

 instance Outputable AnnListBrackets where

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

   ppr ListNone         = text "ListNone"

 instance Outputable AnnCType where

         mkRdrGetField, mkRdrProjection, Fbind, -- RecordDot

         mkHsOpApp,

         mkHsIntegral, mkHsFractional, mkHsIsString,

         mkRoleAnnotDecl,

         mkClassDecl,

         mkTyData, mkDataFamInst,

             addFatalError $ mkPlainErrorMsgEnvelope loc_role $

               (PsErrIllegalRoleName role nearby)

 -- | Converts a list of 'LHsTyVarBndr's annotated with their 'Specificity' to

 -- binders without annotations. Only accepts specified variables, and errors if

 -- any of the provided binders has an 'InferredSpec' annotation.

          -> PV (LocatedA b)

   -- | Disambiguate "do { ... }" (do notation)

   mkHsDoPV ::

     PV (LocatedA b)

   -- | Disambiguate "( ... )" (parentheses)

   mkHsParPV :: SrcSpan -> EpToken "(" -> LocatedA b -> EpToken ")" -> PV (LocatedA b)

     checkDoAndIfThenElse PsErrSemiColonsInCondCmd c semi1 a semi2 b

     !cs <- getCommentsFor l

     return $ L (EpAnn (spanAsAnchor l) noAnn cs) (mkHsCmdIf c a b anns)

     !cs <- getCommentsFor l

   mkHsParPV l lpar c rpar = do

     !cs <- getCommentsFor l

     return $ L (EpAnn (spanAsAnchor l) noAnn cs) (HsCmdPar (lpar, rpar) c)

     checkDoAndIfThenElse PsErrSemiColonsInCondExpr c semi1 a semi2 b

     !cs <- getCommentsFor l

     return $ L (EpAnn (spanAsAnchor l) noAnn cs) (mkHsIf c a b anns)

     !cs <- getCommentsFor l

   mkHsParPV l lpar e rpar = do

     !cs <- getCommentsFor l

     return $ L (EpAnn (spanAsAnchor l) noAnn cs) (HsPar (lpar, rpar) e)

     !cs <- getCommentsFor (locA l)

     return $ L (addCommentsToEpAnn l cs) (PatBuilderAppType p at (mkHsTyPat t))

   mkHsIfPV l _ _ _ _ _ _ = addFatalError $ mkPlainErrorMsgEnvelope l PsErrIfThenElseInPat

   mkHsParPV l lpar p rpar   = return $ L (noAnnSrcSpan l) (PatBuilderPar lpar p rpar)

   mkHsVarPV v@(getLoc -> l) = return $ L (l2l l) (PatBuilderVar v)

   mkHsLitPV lit@(L l a) = do

                      { DumpParsedAstComments.hs:14:7-8 }))]))

                 (HsDo

                  ((,)

                   (EpaSpan { DumpParsedAstComments.hs:14:7-8 }))

                  (DoExpr

                   (Nothing))

                   []))

                 (HsDo

                  ((,)

                   (EpaSpan { DumpSemis.hs:10:7-8 }))

                  (DoExpr

                   (Nothing))

                         []))

                       (HsDo

                        ((,)

                         (EpaSpan { DumpSemis.hs:11:3-4 }))

                        (DoExpr

                         (Nothing))

                   []))

                 (HsDo

                  ((,)

                   (EpaSpan { DumpSemis.hs:15:7-8 }))

                  (DoExpr

                   (Nothing))

                   []))

                 (HsDo

                  ((,)

                   (EpaSpan { DumpSemis.hs:22:7-8 }))

                  (DoExpr

                   (Nothing))

                               []))

                             (HsDo

                              ((,)

                               (EpaSpan { Test20297.hs:11:19-20 }))

                              (DoExpr

                               (Nothing))

                               []))

                             (HsDo

                              ((,)

                               (EpaSpan { Test20297.ppr.hs:9:17-18 }))

                              (DoExpr

                               (Nothing))

     ListBraces o c -> do

       o' <- markEpToken o

       return (set l (ListBraces o' c) a)

     ListNone -> return (set l ListNone a)

 markLensBracketsC :: (Monad m, Monoid w)

     ListBraces o c -> do

       c' <- markEpToken c

       return (set l (ListBraces o c') a)

     ListNone -> return (set l ListNone a)

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

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

 markAnnList :: (Monad m, Monoid w)

   => EpAnn AnnList -> EP w m a -> EP w m (EpAnn AnnList, a)

 markAnnList ann action = do

       e' <- markAnnotated e

       return (HsLet (tkLet',tkIn') binds' e')

     debugM $ "HsDo"

   exact (ExplicitList (o,c) es) = do

     debugM $ "ExplicitList start"

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

 exactDo :: (Monad m, Monoid w, ExactPrint (LocatedAn an a))

 exactDo (an,l) (DoExpr m)    stmts = exactMdo l m "do" >>=

                                    \l0 -> markMaybeDodgyStmts (an,l0) stmts

 exactDo (an,l) GhciStmtCtxt  stmts = printStringAtAA l "do" >>=

       n = (moduleNameString module_name) ++ "." ++ kw

 markMaybeDodgyStmts :: (Monad m, Monoid w, ExactPrint (LocatedAn an a))

 markMaybeDodgyStmts (an,l) stmts =

   if notDodgy stmts

     then do

 notDodgy :: GenLocated (EpAnn ann) a -> Bool

 notDodgy (L (EpAnn anc _ _) _) = notDodgyE anc

   exact (HsCmdDo (an0,loc) es) = do

     debugM $ "HsCmdDo"

     loc' <- printStringAtAA loc "do"

     return (HsCmdDo (an1,loc') es')

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

 annListBracketsLocs :: AnnListBrackets -> (EpaLocation,EpaLocation)

 annListBracketsLocs (ListBraces o c) = (getEpTokenLoc o,    getEpTokenLoc c)

 annListBracketsLocs ListNone         = (noAnn,              noAnn)

 data SplitWhere = Before | After