anchor.diff:   *)
   (********************************************************************************************************************)
   and tc_eqn scrutinee env ret_opt branch
  -        : (pat * option<term> * term)                                                             (* checked branch *)
  -        * term       (* the guard condition for taking this branch, used by the caller for the exhaustiveness check *)
  -        * lident                                                                 (* effect label of the lcomp below *)
  -        * list<cflag>                                                                       (* flags for each lcomp *)
  -        * (bool -> lcomp)                     (* computation type of the branch, with or without a "return" equation *)
  -        * guard_t                                                                      (* well-formedness condition *)
  -        * bool                                                      (* true if the pattern matches an erasable type *)
  +        : (pat * option<term> * term)  (* checked branch *)
  +        * term                         (* the guard condition for taking this branch,
  +                                          used by the caller for the exhaustiveness check *)
  +        * lident                       (* effect label of the branch lcomp *)
  +        * option<list<cflag> >         (* flags for the branch lcomp,
  +                                          None if typechecked with a returns comp annotation *)
  +        * option<(bool -> lcomp)>       (* computation type of the branch, with or without a "return" equation,
  +                                          None if typechecked with a returns comp annotation *)
  +        * guard_t                      (* guard for well-typedness of the branch *)
  +        * bool                         (* true if the pattern matches an erasable type *)
           =
     let pattern, when_clause, branch_exp = SS.open_branch branch in
     let cpat, _, cbr = branch in
  
positive.code: 
  (********************************************************************************************************************)
  (* Type-checking a pattern-matching branch                                                                          *)
  (* the pattern, when_clause and branch are closed                                                                   *)
  (* scrutinee is the logical name of the expression being matched; it is not in scope in the branch                  *)
  (*           but it is in scope for the VC of the branch                                                            *)
  (* env does not contain scrutinee, or any of the pattern-bound variables                                            *)
  (* the returned terms are well-formed in an environment extended with the scrutinee only                            *)
  
  
negative.code:     let e, cres, g_expected_type =
        match ret_opt with
        | None -> e, cres, Env.trivial_guard
        | _ -> comp_check_expected_typ env e cres in
  
      if debug env Options.Extreme
      then BU.print2 "(%s) Typechecked Tm_match, comp type = %s\n"
  