`#[derive(BorshSchema)]` chokes on `PhantomData` in enums

[peer2f00l]

Background

I'm working on a smart contract that uses the #[near] macro from near-sdk, which is how I discovered this issue.

User Story

I have a type-parameterized enum that contains PhantomData which I wish to annotate with #[derive(BorshSchema)].

Sample code:

use std::marker::PhantomData;

use borsh::BorshSchema;

#[derive(BorshSchema)]
pub struct MyStruct<T> {
    item: PhantomData<T>,
}

#[derive(BorshSchema)]
pub enum MyEnum<T> {
    Item(PhantomData<T>),
}

MyStruct compiles without issue. I would expect MyEnum to compile fine as well, but I get the following compilation error:

error[E0401]: can't use generic parameters from outer item
  --> src/lib.rs:12:22
   |
11 | pub enum MyEnum<T> {
   |                 - type parameter from outer item
12 |     Item(PhantomData<T>),
   |                      ^ use of generic parameter from outer item

For more information about this error, try `rustc --explain E0401`.
error: could not compile `borsh-schema-test` (lib) due to 1 previous error

Interestingly enough, it compiles fine if I change PhantomData<T> to Vec<T> or apparently any other generic type. In fact, simply wrapping PhantomData<T> in a newtype struct is apparently sufficient, as this compiles fine:

#[derive(BorshSchema)]
pub enum MyEnum<T> {
    Item(MyPhantomData<T>),
}

#[derive(BorshSchema)]
pub struct MyPhantomData<T>(PhantomData<T>);

So, something weird is going on specifically with this enum-PhantomData pairing.

Acceptance Criteria

This code should compile:

#[derive(BorshSchema)]
pub enum MyEnum<T> {
    Item(PhantomData<T>),
}

Resources & Additional Notes

No response

Priority

🟢 P3 : Normal

[dj8yfo]

this will probably be handled by adding a PER VARIANT attribute to hint which generic parameters to use for derive of per-variant implicit struct, something very much akin to #180 (comment)

[dj8yfo]

a better fix for this probably would be to change generics::type_contains_some_param , used here

borsh-rs/borsh-derive/src/internals/schema/mod.rs

Lines 62 to 103 in a34f324

	fn filter_used_params(generics: &Generics, not_skipped_type_params: HashSet<Ident>) -> Generics {
	let new_params = generics
	.params
	.clone()
	.into_iter()
	.filter(|param| match param {
	GenericParam::Lifetime(..) | GenericParam::Const(..) => true,
	GenericParam::Type(ty_param) => not_skipped_type_params.contains(&ty_param.ident),
	})
	.collect();
	let mut where_clause = generics.where_clause.clone();
	where_clause = where_clause.map(|mut clause| {
	let new_predicates: Punctuated<WherePredicate, Comma> = clause
	.predicates
	.iter()
	.filter(|predicate| {
	#[cfg_attr(
	feature = "force_exhaustive_checks",
	deny(non_exhaustive_omitted_patterns)
	)]
	match predicate {
	WherePredicate::Lifetime(..) => true,
	WherePredicate::Type(predicate_type) => generics::type_contains_some_param(
	&predicate_type.bounded_ty,
	&not_skipped_type_params,
	),
	_ => true,
	}
	})
	.cloned()
	.collect();
	clause.predicates = new_predicates;
	clause
	});
	Generics {
	params: new_params,
	where_clause,
	..generics.clone()
	}
	}

, so that it accepts a bool flag whether to special-case treat PhantomData<T>