anchor.diff:                  | None -> ()
                   | Some _ -> raise_error (Errors.Fatal_TypeWithinPatternsAllowedOnVariablesOnly, "Type ascriptions within patterns are cannot be associated with a tactic") orig.prange
           in
  -        let loc, env', binder, p, imp = aux loc env p in
  +        let loc, env', binder, p, annots, imp = aux loc env p in
           let annot_pat_var p t =
               match p.v with
               | Pat_var x -> {p with v=Pat_var({x with sort=t})}
  
positive.code:             | None -> mk_pattern PatWild p.prange
              | Some (_, p) -> p) in
          let app = mk_pattern (PatApp(mk_pattern (PatName (lid_of_ids (record.typename.ns @ [record.constrname]))) p.prange, args)) p.prange in
          let env, e, b, p, _ = aux loc env app in
          let p = match p.v with
              | Pat_cons(fv, args) -> pos <| Pat_cons(({fv with fv_qual=Some (Record_ctor (record.typename, record.fields |> List.map fst))}), args)
              | _ -> p in
          env, e, b, p, false
    and aux loc env p = aux' false loc env p
    in
    let aux_maybe_or env (p:pattern) =
  
negative.code: module EMB = FStar.Syntax.Embeddings
  module SS = FStar.Syntax.Subst
  
  type annotated_pat = Syntax.pat * list<(bv * Syntax.typ)>
  
  let desugar_disjunctive_pattern annotated_pats when_opt branch =
      annotated_pats |> List.map (fun (pat, annots) ->
          let branch = List.fold_left (fun br (bv, ty) ->
                          let lb = U.mk_letbinding (Inl bv) [] ty C.effect_Tot_lid (S.bv_to_name bv) [] br.pos in
                          let branch = SS.close [S.mk_binder bv] branch in
                          mk (Tm_let ((false, [lb]), branch)) None br.pos) branch annots in
          U.branch(pat, when_opt, branch)
      )
  
  let trans_qual r maybe_effect_id = function
    | AST.Private ->       S.Private
  