anchor.diff:    let ty_bs = SS.subst_binders ty_usubst ty_bs in
     let ty_bs = SS.open_binders ty_bs in
   
  -  List.for_all (fun d -> ty_positive_in_datacon ty_lid d ty_bs (List.map (fun s -> U_name s) ty_us) unfolded_inductives env) (snd (datacons_of_typ env ty_lid))
  +  List.for_all (fun d ->
  +    ty_positive_in_datacon
  +      env
  +      ty_lid
  +      d
  +      ty_bs
  +      (List.map U_name ty_us)
  +      unfolded_inductives) (snd (datacons_of_typ env ty_lid))
   
   let name_strictly_positive_in_type env bv t =
     let fv_lid = lid_of_str "__fv_lid_for_positivity_checking__" in
     let fv = S.tconst fv_lid in
     let t = SS.subst [NT (bv, fv)] t in
  -  ty_strictly_positive_in_type fv_lid t (BU.mk_ref []) env
  +  ty_strictly_positive_in_type env fv_lid t (BU.mk_ref [])
   
   (* Special-casing the check for exceptions, the single open inductive type we handle. *)
   let check_exn_positivity (env:env_t) (data_ctor_lid:lid) : bool =
     //memo table, memoizes the Tm_app nodes for inductives that we have already unfolded
     let unfolded_inductives = BU.mk_ref [] in
  -  ty_positive_in_datacon C.exn_lid data_ctor_lid [] []  unfolded_inductives env
  +  ty_positive_in_datacon env C.exn_lid data_ctor_lid [] []  unfolded_inductives
  
positive.code:     let b, _ =
        List.fold_left (fun (r, env) b ->
          if not r then r, env  //if we have already found some binder that does not satisfy the condition, short circuit
          else ty_strictly_positive_in_type ty_lid b.binder_bv.sort unfolded env, push_binders env [b]  //push the binder in the environment, we do some normalization, so might be better to keep env good
        ) (true, env) dbs
      in
      b
    | Tm_app (_, _) ->
      debug_positivity env (fun () -> "Data constructor type is a Tm_app, so returning true");
      true  //if the data constructor type is a simple app, it must be t ..., and we already don't allow t (t ..), so nothing to check here
    | Tm_uinst (t, univs) ->
      debug_positivity env (fun () -> "Data constructor type is a Tm_uinst, so recursing in the base type");
      ty_strictly_positive_in_type ty_lid t unfolded env
    | _ -> failwith "Unexpected data constructor type when checking positivity"
  
  let check_positivity (env:env_t) (ty:sigelt) :bool =
    //memo table, memoizes the Tm_app nodes for inductives that we have already unfolded
  
negative.code: //some binder of some data constructor is an application of ilid to the args
  //ilid may not be an inductive, in which case we simply return false
  //us are the universes that the inductive ilid's data constructors can be instantiated with if needed, these us come from the application of ilid that called this function
  and ty_nested_positive_in_inductive env (ty_lid:lident) (ilid:lident) (us:universes) (args:args) (unfolded:unfolded_memo_t) : bool =
    debug_positivity env (fun () -> "Checking nested positivity in the inductive " ^ (string_of_lid ilid) ^ " applied to arguments: " ^ (Print.args_to_string args));
    let b, idatas = datacons_of_typ env ilid in
  
    (*
     * Two special cases:
     *   -- If ilid is marked with an escape hatch "assume_strictly_positive"
     *   -- If ilid's corresponding binder is marked "strictly_positive", note this is checked by F*
     *)
    if not b then begin
      if Env.fv_has_attr
           env
  