do { ((rn_fun_arg, fun_lspan_arg), rn_args) <- splitHsApps 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

   = return $ exprCtOrigin rn_fun

   | otherwise -- if the location is generated,

               -- the best we can do is to approximate by looking on top of the error message stack

        ; traceTc "mk_origin" (pprHsCtxt code_orig)

        }

     of the error context stack which contains the error message for

     the previous statement: eg. "In the stmt of a do block: e1".

     This popping is implicitly done when we push the error context message for the next statment.

     Sans the popping business for error context stack,

     if there were to be a type error in `e2`, we would get a spurious and confusing error message

 -- in the renamer. See Note [Overview of record dot syntax] in

 -- GHC.Hs.Expr. This is why we match on 'rupd_flds = Left rbnds' here

 -- and panic otherwise.

 tcExpr expr@(RecordUpd { rupd_expr = record_expr

                        , rupd_flds =

                            RegularRecUpdFields

     field_strs = conLikeImplBangs con_like

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

                                               -- visible type applications in the argument.

                                               -- c.f. T19167

                                               (\ (e, ds_flag, ty) -> (mkExpandedTc o (L loc e), ds_flag, ty)) <$>

                                               )

       _                           -> return Nothing

   , setLclEnvTypeEnv

   , modifyLclEnvTcLevel

   , lclEnvInGeneratedCode

   , addLclEnvErrCtxt

 In the current design, if the top of the ErrCtxtStack is an ExpansionCodeCtxt

 i.e. we are currently typechecking a compiler generated expression, and we encounter

 an XExpr, then we _replace_ the top of the stack with the new XExpr. Otherwise, we

 -}

 type ErrCtxtStack = [ErrCtxt]

 -- | Get the top of the error message stack

 data TcLclCtxt

   = TcLclCtxt {

 -- See Note [ErrCtxtStack Manipulation]

 addLclEnvErrCtxt :: ErrCtxt -> TcLclEnv -> TcLclEnv

 -- See Note [ErrCtxtStack Manipulation]

   -- never stack 2 statement error contexts on top of each other

   | StmtErrCtxt{} : ecs <- tcl_err_ctxt lclCtxt

   , StmtErrCtxt{} <- ec

   -- * CtOrigin

   CtOrigin(..), exprCtOrigin, lexprCtOrigin, matchesCtOrigin, grhssCtOrigin,

   invisibleOrigin_maybe, isVisibleOrigin, toInvisibleOrigin,

   pprCtOrigin, pprCtOriginBriefly, isGivenOrigin,

   defaultReprEqOrigins, isWantedSuperclassOrigin,

 exprCtOrigin (HsProjection _ p)   = RecordFieldProjectionOrigin (FieldLabelStrings $ fmap noLocA p)

 exprCtOrigin (RecordUpd{})        = RecordUpdOrigin

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

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

 -- | Extract a suitable CtOrigin from a MatchGroup

 matchesCtOrigin :: MatchGroup GhcRn (LHsExpr GhcRn) -> CtOrigin

   addDependentFiles, addDependentDirectories,

   -- * Error management

   getSrcSpanM, getRealSrcSpanM, setSrcSpan, setSrcSpanA, addLocM,

   inGeneratedCode,

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

 setSrcSpan _ thing_inside

   = thing_inside

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

 setSrcSpanA l = setSrcSpan (locA l)