Empty attributes not parsing as expected

[lthoerner]

When deriving ExtractAttributes on an attribute struct with no fields, such as in the following examples:

#[derive(ExtractAttributes)]
#[deluxe(attributes(my_attribute_1)]
struct MyStruct1;

#[derive(ExtractAttributes)]
#[deluxe(attributes(my_attribute_2)]
struct MyStruct2();

#[derive(ExtractAttributes)]
#[deluxe(attributes(my_attribute_3)]
struct MyStruct3 {}

extract_attributes() does not work as it would be expected to. Instead of returning Err(_) it returns Ok(_) whether or not there is an attribute with the correct name on the type.

#[derive(MyTrait)]
#[my_attribute_1]
struct MyStructWithAttribute {
    my_field: MyType,
}

#[derive(MyTrait)]
struct MyStructWithoutAttribute {
    my_field: MyType,
}

// In the derive for `MyStructWithAttribute`:
let attribute: Option<MyAttribute> = extract_attributes(&mut ast); // Evaluates to Some(_)

// In the derive for `MyStructWithoutAttribute`:
let attribute: Option<MyAttribute> = extract_attributes(&mut ast); // Evaluates to Some(_)

The expected behavior would be that MyStructWithoutAttribute's derive would return an error.

[aaronc]

I'm running into this issue too. Would be great to see #25 get merged. Otherwise there's no way to use this crate to test for the presence of an attribute which is the behavior I'd expect. Looks like unfortunately this crate is sort of unmaintained (#19).

[lthoerner]

@aaronc For now you can rely on the fork by using a Git dependency.

deluxe = { version = "0.5.0", git = "https://github.com/lthoerner/deluxe" }

[tylerhawkes]

I'm running into this issue too. Would be great to see #25 get merged. Otherwise there's no way to use this crate to test for the presence of an attribute which is the behavior I'd expect. Looks like unfortunately this crate is sort of unmaintained (#19).

My workaround for this that I came up with is this:

pub struct ActuallyExists<'t, T: HasAttributes, A: ParseAttributes<'t, T>> {
  pub exists: bool,
  pub span: proc_macro2::Span,
  _marker: core::marker::PhantomData<fn() -> &'t (A, T)>,
}

impl<'t, T: HasAttributes, A: ParseAttributes<'t, T>> ParseAttributes<'t, T> for ActuallyExists<'t, T, A> {
  fn path_matches(path: &syn::Path) -> bool {
    A::path_matches(path)
  }

  fn parse_attributes(obj: &'t T) -> Result<Self> {
    if let Some(next) = ::deluxe::____private::parse_helpers::ref_tokens::<A, _>(obj).next() {
      Ok(Self {
        exists: true,
        span: next.2,
        _marker: core::marker::PhantomData,
      })
    } else {
      Ok(Self {
        exists: false,
        span: proc_macro2::Span::call_site(),
        _marker: core::marker::PhantomData,
      })
    }
  }
}

then you can call it like

let exists = ActuallyExists::<_, TypeWithParseAttributes>::parse_attributes(field)?;
if exists.exists {
  // Extract attributes in here
}

It's kind of hacky, but I agree that it would be better to have a blanket implementation on Option so that you could actually know if the attribute existed. This is a bug that exists from the way it is parsed.

[aaronc]

I'm using this small function to work around this:

fn maybe_extract_attribute<T, R>(t: &mut T) -> manyhow::Result<Option<R>>
where
    T: deluxe::HasAttributes,
    R: deluxe::ExtractAttributes<T>,
{
    let mut have_attr = false;
    for attr in t.attrs() {
        if R::path_matches(attr.meta.path()) {
            have_attr = true;
        }
    }
    if !have_attr {
        return Ok(None);
    }
    Ok(Some(R::extract_attributes(t)?))
}