anchor.diff:                        (envbody, [])
                   in
   
  -                let envbody, bs, g, c = check_actuals_against_formals env bs bs_expected in
  +                let envbody, bs, g, c, body = check_actuals_against_formals env bs bs_expected body in
                   let envbody, letrecs = mk_letrec_env envbody bs c in
                   let envbody = Env.set_expected_typ envbody (U.comp_result c) in
                   Some t, bs, letrecs, Some c, envbody, body, g
  
positive.code:     in //end check_binders
  
  
      let rec expected_function_typ env t0 body
          : (option<typ>        (* any remaining expected type to check against *)
          * binders             (* binders from the abstraction checked against the binders in the corresponding Typ_fun, if any *)
          * binders             (* let rec binders, suitably guarded with termination check, if any *)
  
negative.code:                           | Tm_arrow(bs_expected, c_expected) ->
                              let bs_expected, c_expected = SS.open_comp bs_expected c_expected in
                              let (env, bs', more, guard', subst) = check_binders env more_bs bs_expected in
                              handle_more (env, bs@bs', more, Rel.conj_guard guard guard', subst) c_expected body
                            | _ ->
                              let body = U.abs more_bs body None in
                              env, bs, guard, c, body
                          else let body = U.abs more_bs body None in
                               env, bs, guard, c, body
                        in
  
                        handle_more (check_binders env bs bs_expected) c_expected body
                  in
  
                  let mk_letrec_env envbody bs c =
  