anchor.diff:                       erasable || erasable_branch)
                   t_eqns
                   ([], Env.trivial_guard, false) in
  -
  +      
         (* note that bind_cases adds an exhaustiveness check *)
  -      
         match ret_or_res_typ with
  -      | Inr res_t -> TcUtil.bind_cases env res_t cases guard_x, g, erasable
  +      | Inr res_t ->
  +        //no return annotation, just bind_cases
  +        TcUtil.bind_cases env res_t cases guard_x, g, erasable
   
         | Inl (Inl t) ->  //a return annotation, with type
  -        //set the type in the lcomp of the branches
  +        //set the type in the lcomp of the branches, and then bind_cases
  +
           let cases = List.map
             (fun (f, eff_label, cflags, c) ->
                (f, eff_label, cflags, (fun b -> TcComm.set_result_typ_lc (c b) t))) cases in
  
positive.code:         TcUtil.bind_cases env t cases guard_x, g, erasable
  
        | Inl (Inr c) ->  //a return annotation, with computation type
          let g_exhaustiveness =
            List.fold_right
              (fun (f, _, _, _) g ->  //first substitute guard_x with scrutinee bv in f
               U.mk_disj (f |> SS.subst [NT (guard_x, e1)] |> U.b2t) g)
              cases U.t_false
            |> TcUtil.label Err.exhaustiveness_check (Env.get_range env)  //label
            |> (fun f -> Env.guard_of_guard_formula (NonTrivial f)) in
          TcComm.lcomp_of_comp c, Env.conj_guard g g_exhaustiveness, erasable in
  
      //combine with e1's computation type
  
negative.code:         raise_error (Errors.Fatal_UnexpectedTerm,
            "Tactic is not yet supported with match return") (Env.get_range env) in
  
      let guard_x, t_eqns =
        let guard_x =
          match ret_opt with
          | None -> S.new_bv (Some e1.pos) c1.res_typ
          | Some _ ->
            (match (e1 |> U.unascribe |> SS.compress).n with
             | Tm_name scrutinee_bv -> scrutinee_bv
             | _ ->
               raise_error (Errors.Fatal_UnexpectedTerm,
                 "The scrutinee must be a variable when a return annotation is supplied with a match") e1.pos) in
        guard_x,
        eqns |> List.map (tc_eqn guard_x env_branches ret_opt) in
  
      let c_branches, g_branches, erasable =
  