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

 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 }

                                     , ppr arg

                                     , ppr arg_no])

        ; setSrcSpanA arg_loc $

        }

   | otherwise

   = do { traceTc "addArgCtxt" (vcat [text "generated Head"

        ; addLExprCtxt (locA arg_loc) arg $

           thing_inside

        }

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

 quickLookArg1 pos app_lspan (fun, fun_lspan) larg@(L arg_loc arg) sc_arg_ty@(Scaled _ orig_arg_rho)

   = addArgCtxt pos (fun, fun_lspan) larg $ -- Context needed for constraints

                            -- generated by calls in arg

        -- Step 1: get the type of the head of the argument

          -- tcCollectingUsage: the use of an Id at the head generates usage-info

          -- See the call to `tcEmitBindingUsage` in `check_local_id`.  So we must

          -- capture and save it in the `EValArgQL`.  See (QLA6) in

                            , eaql_res_rho  = app_res_rho }) }}}

 mk_origin :: SrcSpan       -- SrcSpan of the argument

           -> HsExpr GhcRn  -- The head of the expression application chain

           -> TcM CtOrigin

 import GHC.Prelude

 import GHC.Rename.Env   ( irrefutableConLikeRn )

 import GHC.Tc.Utils.Monad

   | otherwise

   = pprPanic "expand_do_stmts: The impossible happened, missing bind operator from renamer" (text "stmt" <+> ppr  stmt)

 -- See Note [BodyStmt] in Language.Haskell.Syntax.Expr

 -- See  Note [Expanding HsDo with XXExprGhcRn] Equation (1) below

 --              stmts ~~> stmts'

 --      e ; stmts ~~> (>>) e stmts'

   do expand_stmts_expr <- expand_do_stmts doFlavour lstmts

      let expansion = genHsExpApps then_op  -- (>>)

                      , expand_stmts_expr ]

      return $ L loc (mkExpandedStmt stmt doFlavour expansion)

 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

 {-

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

 *                                                                      *

 tcCheckMonoExpr   expr res_ty = tcMonoLExpr  expr (mkCheckExpType res_ty)

 tcCheckMonoExprNC expr res_ty = tcMonoLExprNC expr (mkCheckExpType res_ty)

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

 tcMonoLExpr, tcMonoLExprNC

     :: LHsExpr GhcRn     -- Expression to type check

     -> TcM (LHsExpr GhcTc)

 tcMonoLExpr (L loc expr) res_ty

          do  { expr' <- tcExpr expr res_ty

              ; return (L loc expr') }

        ; res_ty <- readExpType res_ty

        ; return (HsMultiIf res_ty alts') }

   = tcDoStmts do_or_lc stmts res_ty

 tcExpr (HsProc x pat cmd) res_ty

         ; (ds_expr, ds_res_ty, err_msg)

             <- expandRecordUpd record_expr possible_parents rbnds res_ty

           do { -- Typecheck the expanded expression.

                expr' <- tcExpr ds_expr (Check ds_res_ty)

                -- NB: it's important to use ds_res_ty and not res_ty here.

 Example: record updates.  The typechecker looks like this:

 with something like

 and we then typecheck the latter.

 See also Note [Handling overloaded and rebindable constructs]

                                        , xrn_expanded = ee } ))

   where `ee` is the expansion of the user written thing `ue`

      TcLclCtxt { tcl_loc      :: RealSrcSpan

                , tcl_err_ctxt :: [ErrCtxt]

                , ... }

   Note `tcl_loc` always points to a real place in the source code,

   The `tcl_err_ctxt` is a stack of contexts, each saying something

   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

                                               )

       _                           -> 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

   -- * Context management for the type checker

   getErrCtxt, setErrCtxt, addErrCtxt,

   popErrCtxt, getCtLocM, setCtLocM, mkCtLocEnv,

   -- * Diagnostic message generation (type checker)

 Note [Error contexts in generated code]

 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 - See Note [Rebindable syntax and XXExprGhcRn] in `GHC.Hs.Expr` for

 more discussion of this fancy footwork

 - See Note [ErrCtxtStack Manipulation] in `GHC.Tc.Types.LclEnv` for info about `ErrCtxtStack`

 -}

 addLExprCtxt :: SrcSpan -> HsExpr GhcRn -> TcRn a -> TcRn a

 addLExprCtxt lspan e thing_inside

   = setSrcSpan lspan $ add_expr_ctxt e thing_inside

     where

 getErrCtxt :: TcM [ErrCtxt]

 getErrCtxt = do { env <- getLclEnv; return (getLclEnvErrCtxt env) }

 {-# INLINE addErrCtxt #-}  -- Note [Inlining addErrCtxt]

 addErrCtxt ctxt = pushCtxt ctxt

 -- See Note [Rebindable syntax and XXExprGhcRn] in GHC.Hs.Expr

 pushCtxt :: ErrCtxt -> TcM a -> TcM a

 {-# INLINE pushCtxt #-} -- Note [Inlining addErrCtxt]

 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 {}))

 e/E.hs:(22,3)-(22,6): E.E -> GHC.Internal.Base.String

 e/E.hs:(25,3)-(25,10): GHC.Internal.Base.String -> GHC.Internal.Types.IO ()

 e/E.hs:(25,12)-(25,37): GHC.Internal.Base.String

 e/E.hs:(24,16)-(25,37): GHC.Internal.Types.IO ()

 e/E.hs:(19,9)-(19,9): E.E

 e/E.hs:(5,7)-(5,8): GHC.Internal.Bignum.Integer.Integer