-- generated by calls in arg

     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

                            , eaql_wanted   = wanted

                            , eaql_encl     = arg_influences_enclosing_call

                            , eaql_res_rho  = app_res_rho })

 mk_origin :: SrcSpan       -- SrcSpan of the function

        }

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

 *                                                                      *

                  Folding over instantiation variables

 -- Se Note [Typechecking by expansion: overview]

 tcExpr e@(HsVar _ v_rn) res_ty

   = do { (v_tc, sigma_ty) <- tcInferId v_rn

        ; tcWrapResult e v_tc sigma_ty res_ty }

 tcExpr e@(ExprWithTySig _ e_rn e_ty) res_ty

 tcExpr (HsIf x pred b1 b2) res_ty

   = do { pred'    <- tcCheckMonoExpr pred boolTy

        ; tcEmitBindingUsage (supUE u1 u2)

        ; return (HsIf x pred' b1' b2') }

     go (HsAppType _ (L l fun) ty) lspan args = go fun (locA l) (mkETypeArg lspan ty    : args)

     go (HsApp _ (L l fun) arg)    lspan args = go fun (locA l) (mkEValArg  lspan arg   : args)

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

     go e@(HsUntypedSplice splice_res splice) _ args

       = do { fun <- getUntypedSpliceBody splice_res

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

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

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

     -- See Note [Desugar OpApp in the typechecker]

     go e@(OpApp _ arg1 (L l op) arg2) _ args

 Note [Looking through ExpandedThingRn]

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

 When creating an application chain in splitHsApps, we must deal with

      ExpandedThingRn f1 (f `HsApp` e1) `HsApp` e2 `HsApp` e3

           -> MatchGroup GhcRn (LocatedA (body GhcRn))

           -> TcM (MatchGroup GhcTc (LocatedA (body GhcTc)))

                                           , mg_ext = origin })

   | null matches  -- Deal with case e of {}

     -- when in inference mode, so we must do it ourselves,

     -- here, using expTypeToType

   = do { tcEmitBindingUsage bottomUE

            [ExpForAllPatTy tvb] -> failWithTc $ TcRnEmptyCase ctxt (EmptyCaseForall tvb)

            []                   -> panic "tcMatches: no arguments in EmptyCase"

            _t1:(_t2:_ts)        -> panic "tcMatches: multiple arguments in EmptyCase"

        ; return (MG { mg_alts = L l []

                     , mg_ext = MatchGroupTc [pat_ty] rhs_ty origin

                     }) }

   | otherwise

        ; tcEmitBindingUsage $ supUEs usages

        ; pat_tys  <- mapM readScaledExpType (filter_out_forall_pat_tys pat_tys)

        ; traceTc "tcMatches" (ppr matches' $$ ppr pat_tys $$ ppr rhs_ty)

        ; return (MG { mg_alts   = L l matches'

                     , mg_ext    = MatchGroupTc pat_tys rhs_ty origin

   mkCheckExpType, newInferExpType, newInferExpTypeFRR,

   runInfer, runInferRho, runInferSigma, runInferKind, runInferRhoFRR, runInferSigmaFRR,

   readExpType, readExpType_maybe, readScaledExpType,

   checkingExpType_maybe, checkingExpType,

   inferResultToType, ensureMonoType, promoteTcType,

                             ; let conc_orig = ConcreteFRR $ FixedRuntimeRepOrigin tau frr

                             ; return tau }

 {- Note [inferResultToType]

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

 expTypeToType and inferResultType convert an InferResult to a monotype.

   | IIF_ShallowRho  -- Trying to infer a shallow RhoType (no foralls or => at the top)

                     -- Top-instantiate (only, regardless of DeepSubsumption) before filling the hole

   | IIF_DeepRho     -- Trying to infer a possibly-deep RhoType (depending on DeepSubsumption)

                     -- If DeepSubsumption is off, same as IIF_ShallowRho

                     -- If DeepSubsumption is on, instantiate deeply before filling the hole

 type ExpSigmaType = ExpType

 type ExpRhoType   = ExpType

 1. What if it is under a GADT or existential pattern match?

    - GADTs: a unification variable (and Infer's hole is similar) is untouchable

    - Existentials: be careful about skolem-escape

 2. What if it is filled in more than once?  E.g. multiple branches of a case

      case e of

         T1 -> e1

         T2 -> e2

 * The RHS of a existential or GADT alternative must always be a

   monotype, regardless of the number of alternatives.

        We use choice (2) in that Section.

        (GHC 8.10 and earlier used choice (1).)

 Then, before filling the hole use promoteTcType to promote the type

 to the outer ir_lvl.  promoteTcType does this

 only unify with monotypes); and catches skolem-escapes because the

 alpha is untouchable until the equality floats out.

 (FIR1) There is one wrinkle.  Suppose we have

              case e of

                 T1 -> e1 :: (forall a. a->a) -> Int

     So if we check G2 second, we still want to emit a constraint that restricts

     the RHS to be a monotype. This is done by ensureMonoType, and it works

     by simply generating a constraint (alpha ~ ty), where alpha is a fresh

 Note [Instantiation of InferResult]

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

   but /not/ deeply instantiate (#26331). See Note [View patterns and polymorphism]

   in GHC.Tc.Gen.Pat.  This the only place we use IIF_ShallowRho.

 Answer: to accept the following program (T26225b) with -XDeepSubsumption, we

 need to deeply instantiate when inferring in checkResultTy: