unboxedSumEOcc, condEOcc, multiIfEOcc, letEOcc, caseEOcc, doEOcc, mdoEOcc,

   compEOcc, staticEOcc, unboundVarEOcc, labelEOcc, implicitParamVarEOcc,

   getFieldEOcc, projectionEOcc, typeEOcc, forallEOcc, forallVisEOcc,

 varEOcc              = mkVarOcc "varE"

 conEOcc              = mkVarOcc "conE"

 litEOcc              = mkVarOcc "litE"

 forallEOcc           = mkVarOcc "forallE"

 forallVisEOcc        = mkVarOcc "forallVisE"

 constrainedEOcc      = mkVarOcc "constrainedE"

 -- type FieldExp = ...

 fieldExpOcc :: KnownOcc

 ********************************************************************* -}

 data XXExprGhcPs

 -- See Note [Rebindable syntax and XXExprGhcRn]

   | HsRecSelRn  (FieldOcc GhcRn)   -- ^ Variable pointing to record selector

                            -- See Note [Non-overloaded record field selectors] and

                            -- Note [Record selectors in the AST]

 data XXExprGhcTc

   | HsRecSelTc  (FieldOcc GhcTc) -- ^ Variable pointing to record selector

                              -- See Note [Non-overloaded record field selectors] and

                              -- Note [Record selectors in the AST]

 {- *********************************************************************

 *                                                                      *

   GhcTc -> ppr x

 instance Outputable XXExprGhcPs where

 ppr_hse :: forall p. (IsPass p) => HsExpansion (GhcPass p) -> SDoc

 ppr_hse hse

 instance Outputable XXExprGhcRn where

   ppr (HsRecSelRn f)        = pprPrefixOcc f

   ppr (ExpandedThingRn hse) = ppr_hse hse

 instance Outputable XXExprGhcTc where

             ppr exp, text ")"]

   ppr (HsRecSelTc f)      = pprPrefixOcc f

 ppr_infix_expr :: forall p. (OutputableBndrId p) => HsExpr (GhcPass p) -> Maybe SDoc

 ppr_infix_expr (HsVar _ (L _ v))    = Just (pprInfixOcc v)

 ppr_infix_expr (HsHole x) = Just $ pprInfixOcc $ case (ghcPass @p, x) of

 ppr_infix_expr _ = Nothing

 ppr_infix_expr_ps :: XXExprGhcPs -> Maybe SDoc

 ppr_infix_expr_rn :: XXExprGhcRn -> Maybe SDoc

 ppr_infix_expr_rn (ExpandedThingRn (HSE thing _)) = ppr_infix_hs_expansion thing

 ppr_infix_expr_rn (HsRecSelRn f)            = Just (pprInfixOcc f)

 ppr_infix_expr_tc :: XXExprGhcTc -> Maybe SDoc

 ppr_infix_expr_tc (WrapExpr _ e)    = ppr_infix_expr e

 ppr_infix_expr_tc (HsTick {})                = Nothing

 ppr_infix_expr_tc (HsBinTick {})             = Nothing

 ppr_infix_expr_tc (HsRecSelTc f)            = Just (pprInfixOcc f)

 ppr_infix_hs_expansion :: HsCtxt -> Maybe SDoc

 ppr_infix_hs_expansion (ExprCtxt e) = ppr_infix_expr e

                      GhcRn -> go_x_rn x

     go_x_ps :: XXExprGhcPs -> Bool

     go_x_tc :: XXExprGhcTc -> Bool

     go_x_tc (WrapExpr _ e)                   = hsExprNeedsParens prec e

     go_x_tc (HsTick _ (L _ e))               = hsExprNeedsParens prec e

     go_x_tc (HsBinTick _ _ (L _ e))          = hsExprNeedsParens prec e

     go_x_tc (HsRecSelTc{})                   = False

     go_x_rn :: XXExprGhcRn -> Bool

     go_x_rn (ExpandedThingRn (HSE thing _))  = hsExpandedNeedsParens thing

     go_x_rn (HsRecSelRn{})               = False

     hsExpandedNeedsParens :: HsCtxt -> Bool

     hsExpandedNeedsParens (ExprCtxt e) = hsExprNeedsParens prec e

     go_x_tc (HsTick {})               = False

     go_x_tc (HsBinTick {})            = False

     go_x_tc (HsRecSelTc{})            = True

     go_x_rn :: XXExprGhcRn -> Bool

     go_x_rn (ExpandedThingRn (HSE thing _))   = isAtomicExpandedThingRn thing

     go_x_rn (HsRecSelRn{})              = True

     isAtomicExpandedThingRn :: HsCtxt -> Bool

     isAtomicExpandedThingRn (ExprCtxt e) = isAtomicHsExpr e

 type instance XVarBr  GhcPs       = EpaLocation

 type instance XXQuote GhcPs       = DataConCantHappen

 type instance XPatBr  GhcRn       = NoExtField

 type instance XDecBrL GhcRn       = NoExtField

 type instance XDecBrG GhcRn       = NoExtField

 hsExprType (XExpr (HsTick _ e)) = lhsExprType e

 hsExprType (XExpr (HsBinTick _ _ e)) = lhsExprType e

 hsExprType (XExpr (HsRecSelTc (FieldOcc _ id))) = idType (unLoc id)

 arithSeqInfoType :: ArithSeqInfo GhcTc -> Type

 arithSeqInfoType asi = mkListTy $ case asi of

       ConLikeTc {}  -> dsApp e

       ExpandedThingTc (HSE _ e) -> dsLExpr e

       -- Hpc Support

       HsTick tickish e -> do

 -- Template Haskell stuff

 -- See Note [The life cycle of a TH quotation]

 dsExpr (HsUntypedBracket bracket_tc _) = dsBracket bracket_tc

 dsExpr (HsTypedSplice   _   s) = pprPanic "dsExpr:typed splice" (pprTypedSplice Nothing s)

 dsExpr (HsUntypedSplice ext _) = dataConCantHappen ext

   | otherwise

   = notHandled (ThExpressionForm e)

 repE (XExpr (HsRecSelRn (FieldOcc _ (L _ x)))) = repE (mkHsVar (noLocA x))

 repE e@(HsPragE _ (HsPragSCC {}) _) = notHandled (ThCostCentres e)

 repE e@(HsTypedBracket{})   = notHandled (ThExpressionForm e)

 repE e@(HsUntypedBracket{}) = notHandled (ThExpressionForm e)

 repMDoE :: Maybe HsModuleName -> Core [(M TH.Stmt)] -> MetaM (Core (M TH.Exp))

 repMDoE = repDoBlock mdoEOcc

 repDoBlock :: KnownOcc -> Maybe HsModuleName -> Core [(M TH.Stmt)] -> MetaM (Core (M TH.Exp))

 repDoBlock doName maybeModName (MkC ss) = do

     MkC coreModName <- coreModNameM

         liftM (XExpr . HsBinTick t0 t1) (addTickLHsExprNever e)

 addTickHsExpr e@(XExpr (HsRecSelTc (FieldOcc _ id)))   = do freeVar (unLoc id); return e

 addTickHsExpr (HsDo srcloc cxt (L l stmts))

   = do { (stmts', _) <- addTickLStmts' forQual stmts (return ())

           HsBinTick _ _ expr

             -> [ toHie expr

                ]

           HsRecSelTc fld

             -> [ toHie $ RFC RecFieldOcc Nothing (L mspan fld)

                ]

       _ -> False

     oneType = noLocA $ HsVar noExtField $ noLocA $ noUserRdr oneDataConName

   =  do { traceRn "XExpr ReSynBinds" (text "module:" <+> ppr m)

         }

 {-

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

 -- XExpr

 -- Expansions are idempotent, XExprs do not expand again

 tcExpand (XExpr (ExpandedThingRn hse))

   = return $ Just hse

 tcExprNoExpand (HsTypedSplice ext splice)   res_ty = tcTypedSplice ext splice res_ty

 tcExprNoExpand e@(HsTypedBracket _ext body) res_ty = tcTypedBracket e body res_ty

 tcExprNoExpand e@(HsUntypedBracket ps body) res_ty = tcUntypedBracket e body ps res_ty

 {-

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

        ; ps' <- readMutVar ps_var

        ; codeco <- tcLookupKnownOccId unsafeCodeCoerceOcc

        ; bracket_ty <- mkAppTy m_var <$> tcMetaKnownOccTy expTyConOcc

                                     , hsb_wrap  = Just wrapper, hsb_splices = ps' }

              -- The tc_expr is stored here so that the expression can be used in HIE files.

              brack_expr = HsTypedBracket brack_tc tc_expr

 exprCtOrigin (HsGetField _ _ f)   = GetFieldOrigin (fmap (mkFastStringShortText . field_label) $ dfoLabel (unLoc f))

 exprCtOrigin (XExpr (ExpandedThingRn (HSE o _))) = hsCtxtCtOrigin o

 exprCtOrigin (XExpr (HsRecSelRn f))  = OccurrenceOfRecSel $ L (getLoc $ foLabel f) (foExt f)

 hsCtxtCtOrigin :: HsCtxt -> CtOrigin

 hsCtxtCtOrigin (ExprCtxt (ExprWithTySig _ (L _ e) _)) = exprCtOrigin e

   = do { v' <- zonkIdOcc v

        ; return (XExpr (HsRecSelTc (FieldOcc occ (L l v')))) }

 zonkExpr (RecordUpd x _ _)  = dataConCantHappen x

 zonkExpr (HsGetField x _ _) = dataConCantHappen x

 zonkExpr (HsProjection x _) = dataConCantHappen x

                       mkHsForAllVisTele noAnn tvs'

          ; return $ HsForAll noExtField tele body' }

     cvt (ReSynBindsE m e) = do { e' <- cvt e

 {- | #16895 Ensure an infix expression's operator is a variable/constructor.

 Consider this example:

 constrainedE :: Quote m => [m Exp] -> m Exp -> m Exp

 constrainedE ctx body = ConstrainedE <$> sequenceA ctx <*> body

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

 -- *   Dec