Merge branch 'main' into cust

Author: juntyr

rust-cuda-derive/Cargo.toml

@@ -12,7 +12,7 @@ rust-version = "1.81" # nightly
 proc-macro = true
 
 [dependencies]
-syn = { version = "1.0", features = ["full", "fold"] }
-quote = "1.0"
-proc-macro2 = "1.0"
-proc-macro-error = "1.0"
+proc-macro2 = { version = "1.0", default-features = false }
+proc-macro-error2 = { version = "2.0", default-features = false, features = ["syn-error"] }
+quote = { version = "1.0", default-features = false }
+syn = { version = "2.0", default-features = false, features = ["full", "fold"] }

rust-cuda-derive/src/lib.rs

@@ -48,7 +48,7 @@
 extern crate proc_macro;
 
 #[macro_use]
-extern crate proc_macro_error;
+extern crate proc_macro_error2;
 
 use proc_macro::TokenStream;
 

rust-cuda-derive/src/rust_to_cuda/field_ty.rs

@@ -23,77 +23,70 @@ pub fn swap_field_type_and_filter_attrs(
 
     // Remove all attributes from the fields in the Cuda representation
     field.attrs.retain(|attr| {
-        if attr.path.is_ident("cuda") {
-            if let Ok(syn::Meta::List(list)) = attr.parse_meta() {
-                for meta in &list.nested {
-                    match meta {
-                        syn::NestedMeta::Meta(syn::Meta::Path(path)) if path.is_ident("ignore") => {
-                            r2c_ignore = true;
-                        },
-                        syn::NestedMeta::Meta(syn::Meta::Path(path)) if path.is_ident("embed") => {
-                            if cuda_repr_field_ty.is_none() {
-                                cuda_repr_field_ty = Some(CudaReprFieldTy::RustToCuda {
-                                    field_ty: Box::new(field_ty.clone()),
-                                });
+        if attr.path().is_ident("cuda") {
+            if let Err(err) = attr.parse_nested_meta(|meta| {
+                if meta.path.is_ident("ignore") {
+                    r2c_ignore = true;
+                    return Ok(());
+                }
+
+                if meta.path.is_ident("embed") {
+                    if cuda_repr_field_ty.is_some() {
+                        emit_error!(
+                            attr.span(),
+                            "[rust-cuda]: Duplicate #[cuda(embed)] field attribute."
+                        );
+                        return Ok(());
+                    }
+
+                    if let Ok(meta) = meta.value() {
+                        match meta.parse::<syn::LitStr>().and_then(|s| syn::parse_str(&s.value())) {
+                            Ok(proxy_ty) => {
+                                let old_field_ty = Box::new(field_ty.clone());
                                 field_ty = parse_quote! {
                                     #crate_path::utils::ffi::DeviceAccessible<
-                                        <#field_ty as #crate_path::lend::RustToCuda>::CudaRepresentation
+                                        <#proxy_ty as #crate_path::lend::RustToCuda>::CudaRepresentation
                                     >
                                 };
-                            } else {
-                                emit_error!(
-                                    attr.span(),
-                                    "[rust-cuda]: Duplicate #[cuda(embed)] field attribute."
-                                );
-                            }
-                        },
-                        syn::NestedMeta::Meta(syn::Meta::NameValue(syn::MetaNameValue {
-                            path,
-                            lit: syn::Lit::Str(s),
-                            ..
-                        })) if path.is_ident("embed") => {
-                            if cuda_repr_field_ty.is_none() {
-                                match syn::parse_str(&s.value()) {
-                                    Ok(proxy_ty) => {
-                                        let old_field_ty = Box::new(field_ty.clone());
-                                        field_ty = parse_quote! {
-                                            #crate_path::utils::ffi::DeviceAccessible<
-                                                <#proxy_ty as #crate_path::lend::RustToCuda>::CudaRepresentation
-                                            >
-                                        };
-                                        cuda_repr_field_ty = Some(CudaReprFieldTy::RustToCudaProxy {
-                                            proxy_ty: Box::new(proxy_ty),
-                                            field_ty: old_field_ty,
-                                        });
-                                    },
-                                    Err(err) => emit_error!(
-                                        s.span(),
-                                        "[rust-cuda]: Invalid #[cuda(embed = \
-                                        \"<proxy-type>\")] field attribute: {}.",
-                                        err
-                                    ),
-                                }
-                            } else {
-                                emit_error!(
-                                    attr.span(),
-                                    "[rust-cuda]: Duplicate #[cuda(embed)] field attribute."
-                                );
-                            }
-                        },
-                        _ => {
-                            emit_error!(
+                                cuda_repr_field_ty = Some(CudaReprFieldTy::RustToCudaProxy {
+                                    proxy_ty: Box::new(proxy_ty),
+                                    field_ty: old_field_ty,
+                                });
+                            },
+                            Err(err) => emit_error!(
                                 meta.span(),
-                                "[rust-cuda]: Expected #[cuda(ignore)] / #[cuda(embed)] / \
-                                #[cuda(embed = \"<proxy-type>\")] field attribute"
-                            );
+                                "[rust-cuda]: Invalid #[cuda(embed = \
+                                \"<proxy-type>\")] field attribute: {}.",
+                                err
+                            ),
                         }
+                    } else {
+                        cuda_repr_field_ty = Some(CudaReprFieldTy::RustToCuda {
+                            field_ty: Box::new(field_ty.clone()),
+                        });
+                        field_ty = parse_quote! {
+                            #crate_path::utils::ffi::DeviceAccessible<
+                                <#field_ty as #crate_path::lend::RustToCuda>::CudaRepresentation
+                            >
+                        };
                     }
+
+                    return Ok(());
                 }
-            } else {
+
+                emit_error!(
+                    meta.path.span(),
+                    "[rust-cuda]: Expected #[cuda(ignore)] / #[cuda(embed)] / \
+                    #[cuda(embed = \"<proxy-type>\")] field attribute"
+                );
+
+                Ok(())
+            }) {
                 emit_error!(
                     attr.span(),
                     "[rust-cuda]: Expected #[cuda(ignore)] / #[cuda(embed)] / \
-                    #[cuda(embed = \"<proxy-type>\")] field attribute."
+                    #[cuda(embed = \"<proxy-type>\")] field attribute: {}",
+                    err
                 );
             }