Actual: String

     • In the first argument of ‘Pair’, namely ‘"yes"’

 -}

 -- CAUTION: Any changes to tcApp should be reflected in tcExprSigma

 tcApp :: HsExpr GhcRn

          -- See (TCAPP1) and (TCAPP2) in

          -- Note [tcApp: typechecking applications]

        ; case do_ql of

             NoQL -> do { traceTc "tcApp:NoQL" (ppr rn_fun $$ ppr app_res_rho)

                          -- Step 4.1: subsumption check against expected result type

                          -- See Note [Unify with expected type before typechecking arguments]

                                                    app_res_rho exp_res_ty

                          -- Step 4.2: typecheck the  arguments

                        ; tc_args <- tcValArgs NoQL (rn_fun, fun_lspan) inst_args

                        ; app_res_rho <- liftZonkM $ zonkTcType app_res_rho

                          -- Step 5.4: subsumption check against the expected type

                                                     app_res_rho exp_res_ty

                          -- Step 5.5: wrap up

                        ; finishApp tc_head tc_args app_res_rho res_wrap } }

 -- | Connect up the inferred type of an application with the expected type.

 -- This is usually just a unification, but with deep subsumption there is more to do.

               -> (HsExpr GhcTc, SrcSpan)  -- Head

               -> [HsExprArg p]            -- Arguments, just error messages

               -> TcRhoType  -- Inferred type of the application; zonked to

                             --   expose foralls, but maybe not /deeply/ instantiated

               -> ExpRhoType -- Expected type; this is deeply skolemised

               -> TcM HsWrapper

 -- Unify with expected type from the context

 -- See Note [Unify with expected type before typechecking arguments]

 --

 -- Match up app_res_rho: the result type of rn_expr

 --     with res_ty:  the expected result type

  = perhaps_add_res_ty_ctxt $

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

                , text "app_res_rho:" <+> ppr app_res_rho

                , text "res_ty:"  <+> ppr res_ty

                   ; tc_args <- tcValArgs DoQL (rn_fun, snd tc_head) inst_args

                   ; app_res_rho <- liftZonkM $ zonkTcType app_res_rho

                                               app_res_rho (mkCheckExpType exp_arg_rho)

                   ; finishApp tc_head tc_args app_res_rho res_wrap }

          tcInferRho, tcInferRhoNC,

          tcMonoLExpr, tcMonoLExprNC,

          tcInferRhoFRR, tcInferRhoFRRNC,

          tcSyntaxOp, tcSyntaxOpGen, SyntaxOpType(..), synKnownType,

          tcCheckId,

          ) where

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

 -- These versions take an ExpType

 tcPolyLExpr, tcPolyLExprNC :: LHsExpr GhcRn -> ExpSigmaType

 tcPolyLExpr (L loc expr) res_ty

   = addLExprCtxt (locA loc) expr $  -- Note [Error contexts in generated code]

                     -- and its hard to say exactly what that is

                : EWrap (EExpand e)

                : args )

     go e lspan args = pure ((e, lspan), args)

 add_expr_ctxt :: HsExpr GhcRn -> TcRn a -> TcRn a

 add_expr_ctxt e thing_inside

   = case e of

    -- The HsHole special case addresses situations like

    --    f x = _

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

    -- because it is mentioned in the error message itself

    -- We don't want to say 'In the expression (e)',

    -- we just want to say 'In the expression, 'e'

    -- which will be handeled by the recursive call in thing_inside

       ExprWithTySig _ (L _ e') _

         | XExpr (ExpandedThingRn o _) <- e' -> addExpansionErrCtxt o (ExprCtxt e)