vcat [ text "rn_expr:" <+> ppr rn_expr

                 , text "rn_fun:" <+> ppr rn_fun

                 , text "fun_loc:" <+> ppr fun_loc

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

        -- Step 2: Infer the type of `fun`, the head of the application

        ; let tc_head = (tc_fun, fun_loc)

        -- Step 3: Instantiate the function type (taking a quick look at args)

        ; do_ql <- wantQuickLook rn_fun

        ; traceTc "tcApp:inferAppHead" $

          vcat [ text "tc_fun:" <+> ppr tc_fun

               , text "fun_sigma:" <+> ppr fun_sigma

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

        ; (inst_args, app_res_rho)

               <- tcInstFun do_ql True fun_orig (tc_fun, rn_fun, fun_loc) fun_sigma rn_args

     -- Rule IARG from Fig 4 of the QL paper:

     go1 pos acc fun_ty

         (EValArg { ea_arg = arg, ea_ctxt = ctxt } : rest_args)

                         | otherwise = ExpectedFunTyArg (HsExprTcThing tc_fun) (unLoc arg)

            ; (wrap, arg_ty, res_ty) <-

                 -- NB: matchActualFunTy does the rep-poly check.

 import GHC.Hs ( HsExpr )

 import GHC.Tc.Types  ( TcM )

 import GHC.Tc.Utils.TcType ( TcSigmaType )

 import GHC.Hs.Extension ( GhcRn, GhcTc )

 import GHC.Prelude (Bool)

 tcPolyLExpr, tcPolyLExprNC :: LHsExpr GhcRn -> ExpSigmaType

                            -> TcM (LHsExpr GhcTc)

     do { expr' <- tcPolyExpr expr res_ty

        ; return (L loc expr') }

          addExprCtxt e $

          tcExpr e res_ty

    = mkExpandedTc o <$> -- necessary for breakpoints

       do setInGeneratedCode o $

            tcExpr e res_ty

                 -- in full generality; see #1537

           ((rhs_ty, rhs', pat_mult, pat', new_res_ty, thing), bind_op')

                 \ [rhs_ty, pat_ty, new_res_ty] [rhs_mult,fun_mult,pat_mult] ->

                 do { rhs' <-tcScalingUsage rhs_mult $ tcCheckMonoExprNC rhs rhs_ty

                    ; (pat', thing) <- tcScalingUsage fun_mult $ tcCheckPat (StmtCtxt ctxt) pat (Scaled pat_mult pat_ty) $

   = do  {       -- Deal with rebindable syntax;

                 --   (>>) :: rhs_ty -> new_res_ty -> res_ty

         ; ((rhs', rhs_ty, new_res_ty, thing), then_op')

                \ [rhs_ty, new_res_ty] [rhs_mult,fun_mult] ->

                do { rhs' <- tcScalingUsage rhs_mult $ tcCheckMonoExprNC rhs rhs_ty

                   ; thing <- tcScalingUsage fun_mult $ thing_inside (mkCheckExpType new_res_ty)

                              -- Unify the types of the "final" Ids (which may

                              -- be polymorphic) with those of "knot-tied" Ids

                       ; (_, ret_op')

                                         inner_res_ty $ \_ _ -> return ()

                       ; return (ret_op', tup_rets) }

         ; ((_, mfix_op'), mfix_res_ty)

             <- tcInfer $ \ exp_ty ->

                           [synKnownType (mkVisFunTyMany tup_ty stmts_ty)] exp_ty $

                \ _ _ -> return ()

         ; ((thing, new_res_ty), bind_op')

                           [ synKnownType mfix_res_ty

                           , SynFun (synKnownType tup_ty) SynRho ]

                           res_ty $

             Nothing -> (, Nothing) <$> tc_app_stmts res_ty

             Just join_op ->

               second Just <$>

                \ [rhs_ty] [rhs_mult] -> tcScalingUsage rhs_mult $ tc_app_stmts (mkCheckExpType rhs_ty))

         ; return (XStmtLR $ ApplicativeStmt body_ty pairs' mb_join', thing) }

     goOps _ [] = return []

     goOps t_left ((op,t_i,exp_ty) : ops)

       = do { (_, op')

                              [synKnownType t_left, synKnownType exp_ty] t_i $

                    \ _ _ -> return ()

            ; t_i <- readExpType t_i

                           -- See Note [Inferring the instance context]

                           -- in GHC.Tc.Deriv.Infer

   | DefaultOrigin       -- Typechecking a default decl

   | DoPatOrigin (LPat GhcRn) -- Arising from a failable pattern in

                              -- a do expression

   | MCompOrigin         -- Arising from a monad comprehension

 exprCtOrigin (HsIf {})           = IfThenElseOrigin

 exprCtOrigin (HsMultiIf _ rhs)   = lGRHSCtOrigin rhs

 exprCtOrigin (HsLet _ _ e)       = lexprCtOrigin e

 exprCtOrigin (RecordCon {})      = Shouldn'tHappenOrigin "record construction"

 exprCtOrigin (RecordUpd {})      = RecordUpdOrigin

 exprCtOrigin (ExprWithTySig {})  = ExprSigOrigin

 hsThingCtOrigin :: HsThingRn -> CtOrigin

 hsThingCtOrigin (OrigExpr e) = exprCtOrigin e

 hsThingCtOrigin (OrigPat p) = DoPatOrigin p

 srcCodeCtxtCtOrigin :: HsExpr GhcRn -> SrcCodeCtxt -> CtOrigin

 pprCtO DerivClauseOrigin     = text "the 'deriving' clause of a data type declaration"

 pprCtO StandAloneDerivOrigin = text "a 'deriving' declaration"

 pprCtO DefaultOrigin         = text "a 'default' declaration"

 pprCtO MCompOrigin           = text "a statement in a monad comprehension"

 pprCtO ProcOrigin            = text "a proc expression"

 pprCtO ArrowCmdOrigin        = text "an arrow command"