anchor.diff:              | 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) =
       let loc = [] in
       match p.pat with
         | PatOr [] -> failwith "impossible"
         | PatOr (p::ps) ->
  -        let loc, env, var, p, _ = aux loc env p in
  +        let loc, env, var, p, _ = aux' true loc env p in
           let loc, env, ps = List.fold_left (fun (loc, env, ps) p ->
  -          let loc, env, _, p, _ = aux loc env p in
  +          let loc, env, _, p, _ = aux' true loc env p in
             loc, env, p::ps) (loc, env, []) ps in
           let pats = (p::List.rev ps) in
           env, var, pats
         | _ ->
  -        let loc, env, vars, pat, b = aux loc env p in
  +        let loc, env, vars, pat, b = aux' true loc env p in
           env, vars, [pat]
     in
     let env, b, pats = aux_maybe_or env p in
  
positive.code:         let e, x = push_bv_maybe_mut e x in
          (x::l), e, x
    in
    let rec aux (loc:lenv_t) env (p:pattern) =
      let pos q = Syntax.withinfo q p.prange in
      let pos_r r q = Syntax.withinfo q r in
      match p.pat with
        | PatOr _ -> failwith "impossible"
  
  
negative.code:             match p.v with
              | Pat_var x -> {p with v=Pat_var({x with sort=t})}
              | Pat_wild x -> {p with v=Pat_wild({x with sort=t})}
              | _ when top -> p
              | _  -> raise (Error("Type ascriptions within patterns are only allowed on variables", orig.prange))
          in
          let p, binder = match binder with
              | LetBinder _ -> failwith "impossible"
  