type HsMatchContextRn = HsMatchContext (LIdP GhcRn)

 type HsStmtContextRn = HsStmtContext (LIdP GhcRn)

         OpName(..),

         hsOuterTyVarNames, hsOuterExplicitBndrs, mapHsOuterImplicit,

         mkHsOuterImplicit, mkHsOuterExplicit,

 import Language.Haskell.Syntax.Type

 import Language.Haskell.Syntax.Extension

 import GHC.Core.DataCon ( SrcStrictness(..), SrcUnpackedness(..)

 type instance XBndrVar (GhcPass p) = NoExtField

 type instance XBndrWildCard GhcTc = NoExtField

 type instance XXBndrVar (GhcPass p) = DataConCantHappen

 type instance XTyLit           (GhcPass _) = NoExtField

 type instance XWildCardTy      GhcTc = NoExtField

 type instance XXType           GhcPs = HsTypeGhcPsExt

 ************************************************************************

 -}

 mkHsOpTy :: (Anno (IdOccGhcP p) ~ EpAnn a)

          => PromotionFlag

          -> LHsType (GhcPass p) -> LIdOccP (GhcPass p)

         | tyvarop                       { sL1a $1 (HsTyVar noAnn NotPromoted $1) }

         | SIMPLEQUOTE qconop            { sLLa $1 $> (HsTyVar (epTok $1) IsPromoted $2) }

         | SIMPLEQUOTE varop             { sLLa $1 $> (HsTyVar (epTok $1) IsPromoted $2) }

 atype :: { LHsType GhcPs }

         : ntgtycon                       {% amsA' (sL1 $1 (HsTyVar noAnn NotPromoted $1)) }      -- Not including unit tuples

         -- See Note [%shift: atype -> tyvar]

         | tyvar %shift                   {% amsA' (sL1 $1 (HsTyVar noAnn NotPromoted $1)) }      -- (See Note [Unit tuples])

         | '*'                            {% do { warnStarIsType (getLoc $1)

                                                ; return $ sL1a $1 (HsStarTy (epUniTok $1)) } }

 tyvar_wc :: { Located (HsBndrVar GhcPs) }

         : tyvar                         { sL1 $1 (HsBndrVar noExtField $1) }

 fds :: { Located (EpToken "|",[LHsFunDep GhcPs]) }

         : {- empty -}                   { noLoc (NoEpTok,[]) }

         | hole_op               { mkHsInfixHolePV $1 }

 hole_op :: { LocatedN RdrName }   -- used in sections

                                            (NameAnn (NameBackquotes (epTok $1) (epTok $3)) (glR $2) []) }

 qvarop :: { LocatedN RdrName }

   mkHsQualLitPV (L (EpAnn l an csIn) a) = do

     !cs <- getCommentsFor (locA l)

     return $ L (EpAnn l an (cs Semi.<> csIn)) (HsQualLit noExtField a)

   mkHsTySigPV l@(EpAnn anc an csIn) a sig anns = do

     !cs <- getCommentsFor (locA l)

     return $ L (EpAnn anc an (csIn Semi.<> cs)) (ExprWithTySig anns a (hsTypeToHsSigWcType sig))

     rn_ty env (HsQualTy { hst_ctxt = L cx hs_ctxt

                         , hst_body = hs_ty })

       | Just (hs_ctxt1, hs_ctxt_last) <- snocView hs_ctxt

       = do { (hs_ctxt1', fvs1) <- mapFvRn (rn_top_constraint env) hs_ctxt1

            ; setSrcSpanA lx $ checkExtraConstraintWildCard env hs_ctxt1

            ; (hs_ty', fvs2) <- rnLHsTyKi env hs_ty

            ; return (HsQualTy { hst_xqual = noExtField

                               , hst_ctxt = L cx hs_ctxt'

   addErr $

     TcRnWithHsDocContext (rtke_ctxt env) $

       TcRnIllegalRecordSyntax ty

 rnHsTyKi env ty@(HsExplicitListTy _ ip tys)

   = do { checkDataKinds env ty

        ; (tys', fvs) <- mapFvRn (rnLHsTyKi env) tys

        ; return (HsExplicitTupleTy noExtField ip tys', fvs) }

   = do { checkAnonWildCard env

 {-

 Note [Strict level checks with ExplicitLevelImports]

     get_bndr_loc (L l tvb) =

       combineSrcSpans

         (case hsBndrVar tvb of

           HsBndrVar _ ln   -> getLocA ln)

         (case hsBndrKind tvb of

           HsBndrNoKind _ -> noSrcSpan

   = do { tv_nm  <- newTyVarNameRn mb_assoc lrdr

        ; bindLocalNamesFV [tv_nm] $

          thing_inside (HsBndrVar noExtField (L lv tv_nm)) }

 rnHsBndrKind :: HsDocContext -> HsBndrKind GhcPs -> RnM (HsBndrKind GhcRn, FreeNames)

 rnHsBndrKind _ (HsBndrNoKind _) = return (HsBndrNoKind noExtField, emptyFNs)

   check_data_kinds tyLit

   pure (HsTyLit src (convertLit lit))

 rn_ty_pat (HsKindSig an ty ki) = do

   ctxt <- askDocContext

            ; return (L l (HsSpliceTy splice_result' splice)) }

     go (L l (HsStar x))

       = return (L l (HsStarTy x))

       | startsWithUnderscore occ =

           -- See Note [Wildcards in the T2T translation]

           do { wildcards_enabled <- xoptM LangExt.NamedWildCards

   go_bvar (HsTyVar _ _ tv)

     | isTyVarName (getName tv)

     = Just (HsBndrVar noExtField (fmap getName tv))

   go_bvar _ = Nothing

 {- Note [Type patterns: binders and unifiers]

      ; return b }

   where b = noLocA (HsTyVar noAnn NotPromoted $ fmap noUserRdr lname)

 pat_to_type (WildPat _) = return b

 pat_to_type (SigPat _ pat sig_ty)

   = do { t <- pat_to_type (unLoc pat)

        ; let { !(HsPS x_hsps k) = sig_ty

              -> mk_apps (HsTyLit noExtField (cvtTyLit lit)) tys'

            WildCardT

            InfixT t1 s t2

              -> do { s'  <- tconName s

 X(ExplicitTuple) mismatch

   >>> ((EpaLocation' [GenLocated (EpaLocation' NoComments) EpaComment]),(EpaLocation' [GenLocated (EpaLocation' NoComments) EpaComment]))

   <<< ((EpToken "'"),(EpToken "("),(EpToken ")"))

 Extension fields @GhcRn

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

   <<< HsUntypedSpliceResult (GenLocated (EpAnn AnnListItem) (HsType (GhcPass 'Renamed)))

 X(ExplicitList) match = NoExtField

 X(ExplicitTuple) match = NoExtField

 Extension fields @GhcTc

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

 	$(CHECK_PPR)   $(LIBDIR) PprLetIn.hs

 	$(CHECK_EXACT) $(LIBDIR) PprLetIn.hs

 .PHONY: CaseAltComments

 CaseAltComments:

 	$(CHECK_PPR)   $(LIBDIR) CaseAltComments.hs

 test('AnnotationNoListTuplePuns', [ignore_stderr, req_ppr_deps], makefile_test, ['AnnotationNoListTuplePuns'])

 test('Test24533', [ignore_stderr, req_ppr_deps], makefile_test, ['Test24533'])

 test('PprLetIn', [ignore_stderr, req_ppr_deps], makefile_test, ['PprLetIn'])

 test('CaseAltComments', [ignore_stderr, req_ppr_deps], makefile_test, ['CaseAltComments'])

 test('MatchPatComments', [ignore_stderr, req_ppr_deps], makefile_test, ['MatchPatComments'])

 test('Test24748', [ignore_stderr, req_ppr_deps], makefile_test, ['Test24748'])

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

 instance ExactPrint (HsExpr GhcPs) where

   getAnnotationEntry _ = NoEntryVal

   setAnnotationAnchor a _ _ _s = a

       then markAnnotated n

       else return n

     return (HsVar x n')

   exact x@(HsOverLabel src l) = do

     printStringAdvanceA "#" >> return ()

     case src of

   exact (HsBndrVar x n) = do

     n' <- markAnnotated n

     return (HsBndrVar x n')

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

   exact (HsTyLit an lit) = do

     lit' <- withPpr lit

     return (HsTyLit an lit')

   exact x = error $ "missing match for HsType:" ++ showAst x

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

         tv, tvk :: HsType GhcRn

         tv = case bvar of

           HsBndrVar _ n -> HsTyVar noAnn NotPromoted (fmap noUserRdr n)

         tvk = case bkind of

           HsBndrNoKind _   -> tv

           HsBndrKind _ lty -> HsKindSig noAnn (reL tv) lty

             cvt' :: HsBndrVar GhcRn -> HsType GhcRn

             cvt' (HsBndrVar _ nm)   = HsTyVar noAnn NotPromoted (fmap noUserRdr nm)

             -- \| Convert a LHsTyVarBndr to an equivalent LHsType.

             hsLTyVarBndrToType :: LHsTyVarBndr flag GhcRn -> LHsType GhcRn

 lHsQTyVarsToTypes :: LHsQTyVars GhcRn -> [LHsTypeArg GhcRn]

 lHsQTyVarsToTypes tvs =

   ]

 hsQTvExplicitBinders :: LHsQTyVars DocNameI -> [LHsTyVarBndr (HsBndrVis DocNameI) DocNameI]