update syn, encase, glam and hexasphere

benches/Cargo.toml

@@ -7,7 +7,7 @@ publish = false
 license = "MIT OR Apache-2.0"
 
 [dev-dependencies]
-glam = "0.23"
+glam = "0.24"
 rand = "0.8"
 rand_chacha = "0.3"
 criterion = { version = "0.3", features = ["html_reports"] }

crates/bevy_derive/Cargo.toml

@@ -15,4 +15,4 @@ proc-macro = true
 bevy_macro_utils = { path = "../bevy_macro_utils", version = "0.11.0-dev" }
 
 quote = "1.0"
-syn = { version = "1.0", features = ["full"] }
+syn = { version = "2.0", features = ["full"] }

crates/bevy_ecs/macros/Cargo.toml

@@ -11,6 +11,6 @@ proc-macro = true
 [dependencies]
 bevy_macro_utils = { path = "../../bevy_macro_utils", version = "0.11.0-dev" }
 
-syn = "1.0"
+syn = "2.0"
 quote = "1.0"
 proc-macro2 = "1.0"

crates/bevy_ecs/macros/src/component.rs

@@ -1,8 +1,7 @@
-use bevy_macro_utils::{get_lit_str, Symbol};
 use proc_macro::TokenStream;
 use proc_macro2::{Span, TokenStream as TokenStream2};
-use quote::{quote, ToTokens};
-use syn::{parse_macro_input, parse_quote, DeriveInput, Error, Ident, Path, Result};
+use quote::quote;
+use syn::{parse_macro_input, parse_quote, DeriveInput, Ident, LitStr, Path, Result};
 
 pub fn derive_resource(input: TokenStream) -> TokenStream {
     let mut ast = parse_macro_input!(input as DeriveInput);
@@ -48,8 +47,8 @@ pub fn derive_component(input: TokenStream) -> TokenStream {
     })
 }
 
-pub const COMPONENT: Symbol = Symbol("component");
-pub const STORAGE: Symbol = Symbol("storage");
+pub const COMPONENT: &str = "component";
+pub const STORAGE: &str = "storage";
 
 struct Attrs {
     storage: StorageTy,
@@ -66,48 +65,27 @@ const TABLE: &str = "Table";
 const SPARSE_SET: &str = "SparseSet";
 
 fn parse_component_attr(ast: &DeriveInput) -> Result<Attrs> {
-    let meta_items = bevy_macro_utils::parse_attrs(ast, COMPONENT)?;
-
     let mut attrs = Attrs {
         storage: StorageTy::Table,
     };
 
-    for meta in meta_items {
-        use syn::{
-            Meta::NameValue,
-            NestedMeta::{Lit, Meta},
-        };
-        match meta {
-            Meta(NameValue(m)) if m.path == STORAGE => {
-                attrs.storage = match get_lit_str(STORAGE, &m.lit)?.value().as_str() {
-                    TABLE => StorageTy::Table,
-                    SPARSE_SET => StorageTy::SparseSet,
+    for meta in ast.attrs.iter().filter(|a| a.path().is_ident(COMPONENT)) {
+        meta.parse_nested_meta(|nested| {
+            if nested.path.is_ident(STORAGE) {
+                attrs.storage = match nested.value()?.parse::<LitStr>()?.value() {
+                    s if s == TABLE => StorageTy::Table,
+                    s if s == SPARSE_SET => StorageTy::SparseSet,
                     s => {
-                        return Err(Error::new_spanned(
-                            m.lit,
-                            format!(
-                                "Invalid storage type `{s}`, expected '{TABLE}' or '{SPARSE_SET}'.",
-                            ),
-                        ))
+                        return Err(nested.error(format!(
+                            "Invalid storage type `{s}`, expected '{TABLE}' or '{SPARSE_SET}'.",
+                        )));
                     }
                 };
+                Ok(())
+            } else {
+                Err(nested.error("Unsuported attribute"))
             }
-            Meta(meta_item) => {
-                return Err(Error::new_spanned(
-                    meta_item.path(),
-                    format!(
-                        "unknown component attribute `{}`",
-                        meta_item.path().into_token_stream()
-                    ),
-                ));
-            }
-            Lit(lit) => {
-                return Err(Error::new_spanned(
-                    lit,
-                    "unexpected literal in component attribute",
-                ))
-            }
-        }
+        })?;
     }
 
     Ok(attrs)

crates/bevy_ecs/macros/src/fetch.rs

@@ -6,15 +6,15 @@ use syn::{
     parse::{Parse, ParseStream},
     parse_macro_input, parse_quote,
     punctuated::Punctuated,
-    Attribute, Data, DataStruct, DeriveInput, Field, Index,
+    Attribute, Data, DataStruct, DeriveInput, Field, Index, Meta, Token,
 };
 
 use crate::bevy_ecs_path;
 
 #[derive(Default)]
 struct FetchStructAttributes {
     pub is_mutable: bool,
-    pub derive_args: Punctuated<syn::NestedMeta, syn::token::Comma>,
+    pub derive_args: Punctuated<syn::Meta, syn::token::Comma>,
 }
 
 static MUTABLE_ATTRIBUTE_NAME: &str = "mutable";
@@ -35,15 +35,15 @@ pub fn derive_world_query_impl(input: TokenStream) -> TokenStream {
     let mut fetch_struct_attributes = FetchStructAttributes::default();
     for attr in &ast.attrs {
         if !attr
-            .path
+            .path()
             .get_ident()
             .map_or(false, |ident| ident == WORLD_QUERY_ATTRIBUTE_NAME)
         {
             continue;
         }
 
         attr.parse_args_with(|input: ParseStream| {
-            let meta = input.parse_terminated::<syn::Meta, syn::token::Comma>(syn::Meta::parse)?;
+            let meta = input.parse_terminated(syn::Meta::parse, Token![,])?;
             for meta in meta {
                 let ident = meta.path().get_ident().unwrap_or_else(|| {
                     panic!(
@@ -61,9 +61,10 @@ pub fn derive_world_query_impl(input: TokenStream) -> TokenStream {
                     }
                 } else if ident == DERIVE_ATTRIBUTE_NAME {
                     if let syn::Meta::List(meta_list) = meta {
-                        fetch_struct_attributes
-                            .derive_args
-                            .extend(meta_list.nested.iter().cloned());
+                        meta_list.parse_nested_meta(|meta| {
+                            fetch_struct_attributes.derive_args.push(Meta::Path(meta.path));
+                            Ok(())
+                        })?;
                     } else {
                         panic!(
                             "Expected a structured list within the `{DERIVE_ATTRIBUTE_NAME}` attribute",
@@ -463,7 +464,7 @@ fn read_world_query_field_info(field: &Field) -> syn::Result<WorldQueryFieldInfo
     let mut attrs = Vec::new();
     for attr in &field.attrs {
         if attr
-            .path
+            .path()
             .get_ident()
             .map_or(false, |ident| ident == WORLD_QUERY_ATTRIBUTE_NAME)
         {

crates/bevy_ecs/macros/src/lib.rs

@@ -14,7 +14,7 @@ use proc_macro2::Span;
 use quote::{format_ident, quote};
 use syn::{
     parse_macro_input, parse_quote, punctuated::Punctuated, spanned::Spanned, ConstParam,
-    DeriveInput, GenericParam, Ident, Index, Meta, MetaList, NestedMeta, Token, TypeParam,
+    DeriveInput, GenericParam, Ident, Index, Token, TypeParam,
 };
 
 enum BundleFieldKind {
@@ -37,29 +37,18 @@ pub fn derive_bundle(input: TokenStream) -> TokenStream {
 
     let mut field_kind = Vec::with_capacity(named_fields.len());
 
-    'field_loop: for field in named_fields.iter() {
-        for attr in &field.attrs {
-            if attr.path.is_ident(BUNDLE_ATTRIBUTE_NAME) {
-                if let Ok(Meta::List(MetaList { nested, .. })) = attr.parse_meta() {
-                    if let Some(&NestedMeta::Meta(Meta::Path(ref path))) = nested.first() {
-                        if path.is_ident(BUNDLE_ATTRIBUTE_IGNORE_NAME) {
-                            field_kind.push(BundleFieldKind::Ignore);
-                            continue 'field_loop;
-                        }
-
-                        return syn::Error::new(
-                            path.span(),
-                            format!(
-                                "Invalid bundle attribute. Use `{BUNDLE_ATTRIBUTE_IGNORE_NAME}`"
-                            ),
-                        )
-                        .into_compile_error()
-                        .into();
-                    }
-
-                    return syn::Error::new(attr.span(), format!("Invalid bundle attribute. Use `#[{BUNDLE_ATTRIBUTE_NAME}({BUNDLE_ATTRIBUTE_IGNORE_NAME})]`")).into_compile_error().into();
+    for field in named_fields.iter() {
+        for attr in field
+            .attrs
+            .iter()
+            .filter(|a| a.path().is_ident(BUNDLE_ATTRIBUTE_NAME))
+        {
+            let _ = attr.parse_nested_meta(|meta| {
+                if meta.path.is_ident(BUNDLE_ATTRIBUTE_IGNORE_NAME) {
+                    field_kind.push(BundleFieldKind::Ignore);
                 }
-            }
+                Ok(())
+            });
         }
 
         field_kind.push(BundleFieldKind::Component);

crates/bevy_encase_derive/Cargo.toml

@@ -13,4 +13,4 @@ proc-macro = true
 
 [dependencies]
 bevy_macro_utils = { path = "../bevy_macro_utils", version = "0.11.0-dev" }
-encase_derive_impl = "0.5.0"
+encase_derive_impl = "0.6.1"

crates/bevy_macro_utils/Cargo.toml

@@ -10,6 +10,6 @@ keywords = ["bevy"]
 
 [dependencies]
 toml_edit = "0.19"
-syn = "1.0"
+syn = "2.0"
 quote = "1.0"
 rustc-hash = "1.0"

crates/bevy_macro_utils/src/attrs.rs

@@ -1,41 +1,32 @@
-use syn::DeriveInput;
+use syn::{Expr, ExprLit, Lit};
 
 use crate::symbol::Symbol;
 
-pub fn parse_attrs(ast: &DeriveInput, attr_name: Symbol) -> syn::Result<Vec<syn::NestedMeta>> {
-    let mut list = Vec::new();
-    for attr in ast.attrs.iter().filter(|a| a.path == attr_name) {
-        match attr.parse_meta()? {
-            syn::Meta::List(meta) => list.extend(meta.nested.into_iter()),
-            other => {
-                return Err(syn::Error::new_spanned(
-                    other,
-                    format!("expected #[{attr_name}(...)]"),
-                ))
-            }
-        }
-    }
-    Ok(list)
-}
-
-pub fn get_lit_str(attr_name: Symbol, lit: &syn::Lit) -> syn::Result<&syn::LitStr> {
-    if let syn::Lit::Str(lit) = lit {
+pub fn get_lit_str(attr_name: Symbol, value: &Expr) -> syn::Result<&syn::LitStr> {
+    if let Expr::Lit(ExprLit {
+        lit: Lit::Str(lit), ..
+    }) = &value
+    {
         Ok(lit)
     } else {
         Err(syn::Error::new_spanned(
-            lit,
+            value,
             format!("expected {attr_name} attribute to be a string: `{attr_name} = \"...\"`"),
         ))
     }
 }
 
-pub fn get_lit_bool(attr_name: Symbol, lit: &syn::Lit) -> syn::Result<bool> {
-    if let syn::Lit::Bool(lit) = lit {
+pub fn get_lit_bool(attr_name: Symbol, value: &Expr) -> syn::Result<bool> {
+    if let Expr::Lit(ExprLit {
+        lit: Lit::Bool(lit),
+        ..
+    }) = &value
+    {
         Ok(lit.value())
     } else {
         Err(syn::Error::new_spanned(
-            lit,
+            value,
             format!("expected {attr_name} attribute to be a bool value, `true` or `false`: `{attr_name} = ...`"),
-        ))
+        ))?
     }
 }

crates/bevy_macro_utils/src/lib.rs

@@ -214,7 +214,7 @@ pub fn derive_label(
 ) -> TokenStream {
     // return true if the variant specified is an `ignore_fields` attribute
     fn is_ignore(attr: &syn::Attribute, attr_name: &str) -> bool {
-        if attr.path.get_ident().as_ref().unwrap() != &attr_name {
+        if attr.path().get_ident().as_ref().unwrap() != &attr_name {
             return false;
         }
 

crates/bevy_math/Cargo.toml

@@ -9,7 +9,7 @@ license = "MIT OR Apache-2.0"
 keywords = ["bevy"]
 
 [dependencies]
-glam = { version = "0.23", features = ["bytemuck"] }
+glam = { version = "0.24", features = ["bytemuck"] }
 serde = { version = "1", features = ["derive"], optional = true }
 
 [features]

crates/bevy_mikktspace/Cargo.toml

@@ -11,7 +11,7 @@ license = "Zlib AND (MIT OR Apache-2.0)"
 keywords = ["bevy", "3D", "graphics", "algorithm", "tangent"]
 
 [dependencies]
-glam = "0.23"
+glam = "0.24"
 
 [[example]]
 name = "generate"

crates/bevy_reflect/Cargo.toml

@@ -31,7 +31,7 @@ thiserror = "1.0"
 once_cell = "1.11"
 serde = "1"
 smallvec = { version = "1.6", features = ["serde", "union", "const_generics"], optional = true }
-glam = { version = "0.23", features = ["serde"], optional = true }
+glam = { version = "0.24", features = ["serde"], optional = true }
 
 [dev-dependencies]
 ron = "0.8.0"

crates/bevy_reflect/bevy_reflect_derive/Cargo.toml

@@ -19,7 +19,7 @@ documentation = []
 [dependencies]
 bevy_macro_utils = { path = "../../bevy_macro_utils", version = "0.11.0-dev" }
 
-syn = { version = "1.0", features = ["full"] }
+syn = { version = "2.0", features = ["full"] }
 proc-macro2 = "1.0"
 quote = "1.0"
 uuid = { version = "1.1", features = ["v4"] }