pprErrCtxtMsg :: ErrCtxtMsg -> SDoc

 pprErrCtxtMsg = \case

   ExprCtxt expr

     -> hang (text "In the expression:")

        2 (ppr (stripParensHsExpr expr))

   ThetaCtxt ctxt theta ->

 tcApp rn_expr exp_res_ty

   = do { -- Step 1: Split the application chain

          (fun@(rn_fun, fun_loc), rn_args) <- splitHsApps rn_expr

        ; traceTc "tcApp {" $

                 , text "rn_fun:" <+> ppr rn_fun

                 , text "fun_loc:" <+> ppr fun_loc

                 , text "rn_args:" <+> ppr rn_args ]

   -- qlMonoHsWrapper: see Note [Monomorphise instantiation variables]

 tcValArg _     _ _ (EWrap ew)          = return (EWrap ew)

                             , ea_arg    = larg@(L arg_loc arg)

                             , ea_arg_ty = sc_arg_ty })

   = addArgCtxt pos fun larg $

               DoQL -> liftZonkM $ zonkScaledTcType sc_arg_ty

               NoQL -> return sc_arg_ty

        ; traceTc "tcValArg {" $

               , text "sigma_type" <+> ppr (mkCheckExpType exp_arg_ty)

               , text "arg:" <+> ppr larg

               ]

                  tcPolyExpr arg (mkCheckExpType exp_arg_ty)

        ; traceTc "tcValArg" $ vcat [ ppr arg'

                                    , text "}" ]

                          , ea_arg = L arg_loc arg'

                          , ea_arg_ty = noExtField }) }

 tcValArg _ pos fun (EValArgQL {

                         eaql_wanted   = wanted

                       , eaql_arg_ty   = sc_arg_ty

                       , eaql_larg     = larg@(L arg_loc rn_expr)

                       , eaql_tc_fun   = tc_head

        ; traceTc "tcEValArgQL }" $

            vcat [ text "app_res_rho:" <+> ppr app_res_rho ]

                          , ea_arg    = L arg_loc (mkHsWrap wrap arg')

                          , ea_arg_ty = noExtField }) }

 addArgCtxt :: Int -> HsExpr GhcRn -> LHsExpr GhcRn

            -> TcM a -> TcM a

 -- There are 2 cases:

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

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

 addArgCtxt arg_no fun (L arg_loc arg) thing_inside

                                     , text "arg: " <+> ppr arg

                                     , text "arg_loc" <+> ppr arg_loc])

        ; if in_generated_code

                    thing_inside

          else do setSrcSpanA arg_loc                    $

                    addErrCtxt (FunAppCtxt (FunAppCtxtExpr fun arg) arg_no) $

                    thing_inside }

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

 *                                                                      *

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

        res_ty

   = assert (notNull rbnds) $

     do  { -- Expand the record update. See Note [Record Updates].

         ; (ds_expr, ds_res_ty, err_msg)

             <- expandRecordUpd record_expr possible_parents rbnds res_ty

         ; addErrCtxt err_msg $

           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.

 mkEValArg :: SrcSpan -> LHsExpr GhcRn -> HsExprArg 'TcpRn

 mkEValArg src_loc e = EValArg { ea_arg = e, ea_loc_span = src_loc

 mkETypeArg :: SrcSpan -> LHsWcType GhcRn -> HsExprArg 'TcpRn

 mkETypeArg src_loc hs_ty =

     go :: HsExpr GhcRn -> SrcSpan -> [HsExprArg 'TcpRn]

        -> TcM ((HsExpr GhcRn, SrcSpan), [HsExprArg 'TcpRn])

     -- Modify the SrcSpan as we walk inwards, so it describes the next argument

     -- See Note [Looking through Template Haskell splices in splitHsApps]

     go e@(HsUntypedSplice splice_res splice) _ args

       = do { fun <- getUntypedSpliceBody splice_res

       where

             HsUntypedSpliceExpr _ (L l _) -> locA l -- l :: SrcAnn AnnListItem

             HsQuasiQuote _ _ (L l _)      -> locA l -- l :: SrcAnn NoEpAnns

             (XUntypedSplice (HsImplicitLiftSplice _ _ _ (L l _))) -> locA l

                     -- and its hard to say exactly what that is

                : EWrap (EExpand e)

                : args )

       -- look through PopErrCtxt (cf. T17594f) we do not want to lose the opportunity of calling tcEValArgQL

       -- unlike HsPar, it is okay to forget about the PopErrCtxts as it does not persist over in GhcTc land

 -- | Rebuild an application: takes a type-checked application head

    --    f x = _

    -- when we don't want to say "In the expression: _",

    -- because it is mentioned in the error message itself

       _ -> addErrCtxt (ExprCtxt e) thing_inside -- no op in generated code

   , setLclCtxtSrcCodeOrigin

   , lclEnvInGeneratedCode

   , setLclCtxtInGenCode

   , addLclEnvErrCtxt

 setLclCtxtInGenCode :: TcLclCtxt -> TcLclCtxt

 setLclCtxtInGenCode lclCtxt = lclCtxt { tcl_in_gen_code = True }

 -- See Note [ErrCtxt Stack Manipulation]

 setLclCtxtSrcCodeOrigin :: SrcCodeOrigin -> TcLclCtxt -> TcLclCtxt

 setLclCtxtSrcCodeOrigin o lclCtxt

   -- * Error management

   getSrcCodeOrigin,

   getSrcSpanM, setSrcSpan, setSrcSpanA, addLocM,

   wrapLocM, wrapLocFstM, wrapLocFstMA, wrapLocSndM, wrapLocSndMA, wrapLocM_,

   wrapLocMA_,wrapLocMA,

   getErrsVar, setErrsVar,

   = updLclCtxt setLclCtxtInGenCode thing_inside

 getSrcCodeOrigin :: TcRn (Maybe SrcCodeOrigin)

 -- | Mark the inner computation as being done inside generated code.

 --

   updLclCtxt setLclCtxtInGenCode $

   updLclCtxt (setLclCtxtSrcCodeOrigin sco) thing_inside

 setSrcSpanA :: EpAnn ann -> TcRn a -> TcRn a

 setSrcSpanA l = setSrcSpan (locA l)

 DoExpansion1.hs:19:21: warning: [GHC-39999] [-Wdeferred-type-errors (in -Wdefault)]

     • No instance for ‘Num String’ arising from the literal ‘1’

     • In the first argument of ‘putStrLn’, namely ‘1’

       In the expression:

         do putStrLn 1

            putStrLn "r2"

 DoExpansion1.hs:25:21: warning: [GHC-39999] [-Wdeferred-type-errors (in -Wdefault)]

     • No instance for ‘Num String’ arising from the literal ‘2’

     • In the first argument of ‘putStrLn’, namely ‘2’

       In the expression:

         do putStrLn "r1"

            putStrLn 2

     • The function ‘getVal’ is applied to two visible arguments,

         but its type ‘Int -> IO String’ has only one

       In the expression: getVal 3 4

 DoExpansion2.hs:39:19: warning: [GHC-83865] [-Wdeferred-type-errors (in -Wdefault)]

     • Couldn't match type ‘[Char]’ with ‘Int’