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

 data 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

   = WrapExpr        -- Type and evidence application and abstractions

       HsWrapper (HsExpr GhcTc)

   | ExpandedThingTc                         -- See Note [Rebindable syntax and XXExprGhcRn]

                                             -- See Note [Expanding HsDo with XXExprGhcRn] in `GHC.Tc.Gen.Do`

   | ConLikeTc

       -- ^ A 'ConLike', either a data constructor or pattern synonym

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

                              -- Note [Record selectors in the AST]

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

 *                                                                      *

             Pretty-printing expressions

 hsExprType (HsForAll x _ _) = dataConCantHappen x

 hsExprType (HsFunArr x _ _ _) = dataConCantHappen x

 hsExprType (XExpr (WrapExpr wrap e)) = hsWrapperType wrap $ hsExprType e

 hsExprType (XExpr (ConLikeTc con)) = conLikeType con

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

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

 --     needs to see source types

 import GHC.Tc.Utils.TcType

 import GHC.Tc.Types.Evidence

 import GHC.Tc.Utils.Monad

 import GHC.Tc.Instance.Class (lookupHasFieldLabel)

       WrapExpr {}   -> dsApp e

       ConLikeTc {}  -> dsApp e

       -- Hpc Support

       HsTick tickish e -> do

     exp (XExpr (WrapExpr h e)) (XExpr (WrapExpr h' e')) =

       wrap h h' && exp e e'

     exp (XExpr (ExpandedThingTc _ x)) (XExpr (ExpandedThingTc _ x'))

     exp (HsVar _ i) (HsVar _ i') = i == i'

     exp (HsIPVar _ i) (HsIPVar _ i') =

       -- the instance for IPName derives using the id, so follow the HsVar case

   | ExprCtxt e <- o

   = do { rebindable_on <- lift $ xoptM LangExt.RebindableSyntax

        ; if rebindable_on  -- See Note [Quotation and rebindable syntax]

          else repE e }

   | otherwise

   = notHandled (ThExpressionForm e)

 isCallSite HsAppType{} = True

 isCallSite HsCase{}    = True

 isCallSite (XExpr (ExpandedThingTc _ e))

 -- NB: OpApp, SectionL, SectionR are all expanded out

 isCallSite _           = False

                     ListComp -> Just $ BinBox QualBinBox

                     _        -> Nothing

 addTickHsExpanded o e = liftM (XExpr . ExpandedThingTc o) $ case o of

   -- We always want statements to get a tick, so we can step over each one.

   -- To avoid duplicates we blacklist SrcSpans we already inserted here.

   StmtErrCtxt _ (L pos _) -> do_tick_black pos

   _                    -> skip

   where

     do_tick_black pos = do

       d <- getDensity

       case d of

          TickForBreakPoints -> tick_it_black pos

          _                  -> skip

     tick_it_black pos =

                              (withBlackListed (locA pos) $

 addTickTupArg :: HsTupArg GhcTc -> TM (HsTupArg GhcTc)

 addTickTupArg (Present x e)  = do { e' <- addTickLHsExpr e

         HsPragE _ _ e -> computeLType e

         XExpr (ExpandedThingTc thing e)

           | ExprCtxt (HsGetField{}) <- thing -- for record-dot-syntax

         XExpr (HsTick _ e) -> computeLType e

         XExpr (HsBinTick _ _ e) -> computeLType e

         e -> Just (hsExprType e)

             -> [ toHie $ L mspan a

                , toHie (L mspan w) ]

           ExpandedThingTc _ e

           ConLikeTc con

             -> [ toHie $ C Use $ L mspan $ conLikeName con ]

           HsTick _ expr

         genSimpleFunBind, genFunBind,

         genHsLamDoExp, genHsCaseAltDoExp, genSimpleMatch, genHsLet,

         mkRnSyntaxExpr,

         newLocalBndrRn, newLocalBndrsRn,

 import GHC.Hs

 import GHC.Types.Name.Reader

 import GHC.Tc.Errors.Types

 import GHC.Tc.Utils.Monad

 import GHC.Types.Name

 import GHC.Types.Name.Set

   = wrapGenSpan $

     Match { m_ext = noExtField, m_ctxt = ctxt, m_pats = noLocA pats

           , m_grhss = unguardedGRHSs generatedSrcSpan rhs noAnn }

 import GHC.Prelude

 import GHC.Rename.Env   ( irrefutableConLikeRn )

 import GHC.Tc.Utils.Monad

 -- See `checkLastStmt` and `Syntax.Expr.StmtLR.LastStmt`

    | NoSyntaxExprRn <- ret_expr

    -- Last statement is just body if we are not in ListComp context. See Syntax.Expr.LastStmt

    | SyntaxExprRn ret <- ret_expr  -- We have unfortunately lost the location on the return function :(

    --

 mkExpandedPatRn :: LPat GhcRn -> HsExpr GhcRn -> HsExpr GhcRn

 mkExpandedPatRn pat e = XExpr $ ExpandedThingRn

                                    { xrn_orig = StmtErrCtxtPat pat

 import GHC.Tc.Gen.App

 import GHC.Tc.Gen.Head

 import GHC.Tc.Gen.Bind        ( tcLocalBinds )

 import GHC.Tc.Gen.HsType

 import GHC.Tc.Gen.Arrow

 import Control.Monad

 import qualified Data.List.NonEmpty as NE

 {-

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

 *                                                                      *

        ; res_ty <- readExpType res_ty

        ; return (HsMultiIf res_ty alts') }

   = tcDoStmts do_or_lc stmts res_ty

 tcExpr (HsProc x pat cmd) res_ty

   like "In the expression: x+y" or "In the record update: r { x=2 }"

 * Now, when

   gets a located expression, it does 2 things:

     * Calls `addLExprCtxt` to perform error context management

     * Calls `tcExpr` to typecheck the expression.

    = mkExpandedTc o <$> -- necessary for hpc ticks

          -- Need to call tcExpr and not tcApp

          -- as e can be let statement which tcApp cannot gracefully handle

 -- For record selection, same as HsVar case

 tcXExpr xe res_ty = tcApp (XExpr xe) res_ty

     field_strs = conLikeImplBangs con_like

     fl `elemField` flds = any (\ fl' -> flSelector fl == fl') flds

 import GHC.Hs

 import GHC.Hs.Syn.Type

 import GHC.Tc.Gen.HsType

 import GHC.Tc.Gen.Bind( chooseInferredQuantifiers )

 import GHC.Tc.Gen.Sig( tcUserTypeSig, tcInstSig )

       ExprWithTySig _ e hs_ty     -> Just <$> with_get_ds (tcExprWithSig e hs_ty)

       HsOverLit _ lit             -> Just <$> with_get_ds (tcInferOverLit lit)

       XExpr (HsRecSelRn f)        -> Just <$> with_get_ds (tcInferRecSelId f)

                                               -- We do not want to instantiate the type of the head as there may be

                                               -- visible type applications in the argument.

                                               -- c.f. T19167

                                                  tcExprSigma False (errCtxtCtOrigin o) e

                                               )

       _                           -> return Nothing

 import GHC.Prelude

 import {-# SOURCE #-}   GHC.Tc.Gen.Expr( tcSyntaxOp, tcInferRho, tcInferRhoFRRNC

                                        , tcCheckMonoExpr, tcCheckMonoExprNC

                                        , tcCheckPolyExpr, tcPolyLExpr )

 import GHC.Tc.Utils.Monad

 import GHC.Tc.Utils.Env

 import GHC.Tc.Gen.Pat

 import GHC.Tc.Gen.Head( tcCheckId )

 import GHC.Tc.Utils.TcMType

 import GHC.Tc.Utils.TcType

         ; res_ty <- readExpType res_ty

         ; return (HsDo res_ty MonadComp (L l stmts')) }

 tcBody :: LHsExpr GhcRn -> ExpRhoType -> TcM (LHsExpr GhcTc)

 tcBody body res_ty

   | not (isGeneratedSrcSpan lspan)

   = setSrcSpan lspan $ add_expr_ctxt e thing_inside

   | otherwise   -- no op in generated code

     where

        add_expr_ctxt :: HsExpr GhcRn -> TcRn a -> TcRn a

        add_expr_ctxt e thing_inside

              -- error context. So here we flip the ErrCtxt state to expanded if the expression is expanded.

              -- c.f. RecordDotSyntaxFail9

              ExprWithTySig _ (L _ e') _

              -- Flip error ctxt into expansion mode

              _ -> addErrCtxt (ExprCtxt e) thing_inside

 import GHC.Types.Var.Env

 import GHC.Types.Basic

 import GHC.Types.Unique.Set (nonDetEltsUniqSet)

 import GHC.Utils.Misc

 import GHC.Utils.Outputable as Outputable

     go app_head

      | XExpr (ConLikeTc (RealDataCon {})) <- app_head

      = Deep TopSub

      = go f

      | XExpr (WrapExpr _ f) <- app_head

      = go f

        return (XExpr (WrapExpr new_co_fn new_expr))

 zonkExpr (XExpr (ExpandedThingTc thing e))

        return $ XExpr (ExpandedThingTc thing e')

 zonkExpr e@(XExpr (ConLikeTc {}))