Add groups export.

- Check for string literal, instead of any expression; Return the key with proper span in the errors.

Author: Yarwin

godot-macros/src/class/data_models/fields.rs

@@ -31,16 +31,6 @@ pub struct Fields {
     pub errors: Vec<venial::Error>,
 }
 
-impl Fields {
-    /// Remove surrounding quotes to display declared "group name" in editor as `group name` instead of `"group name"`.
-    /// Should be called after parsing all the fields to avoid unnecessary operations.
-    pub fn format_groups(&mut self) {
-        self.groups
-            .iter_mut()
-            .for_each(|g| *g = g.trim_matches('"').to_string());
-    }
-}
-
 /// Fetches data for all named fields for a struct.
 ///
 /// Errors if `class` is a tuple struct.

godot-macros/src/class/data_models/group_export.rs

@@ -7,6 +7,7 @@
 
 use crate::class::data_models::fields::Fields;
 use crate::util::KvParser;
+use crate::ParseResult;
 use std::cmp::Ordering;
 
 /// Points to index of a given group name in [Fields.groups](field@Fields::groups).
@@ -24,28 +25,42 @@ impl FieldGroup {
         expr: &'static str,
         parser: &mut KvParser,
         groups: &mut Vec<String>,
-    ) -> Option<GroupIdentifier> {
-        let group = parser.handle_expr(expr).unwrap_or(None)?.to_string();
+    ) -> ParseResult<Option<GroupIdentifier>> {
+        let Some(group) = parser.handle_string(expr)? else {
+            return Ok(None);
+        };
 
         if let Some(group_index) = groups
             .iter()
             .position(|existing_group| existing_group == &group)
         {
-            Some(group_index)
+            Ok(Some(group_index))
         } else {
             groups.push(group);
-            Some(groups.len() - 1)
+            Ok(Some(groups.len() - 1))
         }
     }
 
-    pub(crate) fn new_from_kv(parser: &mut KvParser, groups: &mut Vec<String>) -> Self {
-        Self {
-            group_name_index: Self::parse_group("group", parser, groups),
-            subgroup_name_index: Self::parse_group("subgroup", parser, groups),
-        }
+    pub(crate) fn new_from_kv(
+        parser: &mut KvParser,
+        groups: &mut Vec<String>,
+    ) -> ParseResult<Self> {
+        Ok(Self {
+            group_name_index: Self::parse_group("group", parser, groups)?,
+            subgroup_name_index: Self::parse_group("subgroup", parser, groups)?,
+        })
     }
 }
 
+/// Remove surrounding quotes to display declared "group name" in editor as `group name` instead of `"group name"`.
+/// Should be called after parsing all the fields to avoid unnecessary operations.
+pub(crate) fn format_groups(groups: Vec<String>) -> Vec<String> {
+    groups
+        .into_iter()
+        .map(|g| g.trim_matches('"').to_string())
+        .collect()
+}
+
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Ordering
 
@@ -189,6 +204,4 @@ pub(crate) fn sort_fields_by_group(fields: &mut Fields) {
             OrderingStage::Group,
         )
     });
-
-    fields.format_groups();
 }

godot-macros/src/class/derive_godot_class.rs

@@ -6,7 +6,7 @@
  */
 
 use crate::class::data_models::fields::{named_fields, Fields};
-use crate::class::data_models::group_export::{sort_fields_by_group, FieldGroup};
+use crate::class::data_models::group_export::{format_groups, sort_fields_by_group, FieldGroup};
 use crate::class::{
     make_property_impl, make_virtual_callback, BeforeKind, Field, FieldCond, FieldDefault,
     FieldExport, FieldVar, SignatureInfo,
@@ -613,10 +613,10 @@ fn parse_fields(
             }
 
             // Deprecated #[init(default = expr)]
-            if let Some(default) = parser.handle_expr("default")? {
+            if let Some((key, default)) = parser.handle_expr_with_key("default")? {
                 if field.default_val.is_some() {
                     return bail!(
-                        parser.span(),
+                        key,
                         "Cannot use both `val` and `default` keys in #[init]; prefer using `val`"
                     );
                 }
@@ -666,7 +666,7 @@ fn parse_fields(
         if let Some(mut parser) = KvParser::parse(&named_field.attributes, "export")? {
             let export = FieldExport::new_from_kv(&mut parser)?;
             field.export = Some(export);
-            let group = FieldGroup::new_from_kv(&mut parser, &mut groups);
+            let group = FieldGroup::new_from_kv(&mut parser, &mut groups)?;
             field.group = Some(group);
             parser.finish()?;
         }
@@ -737,7 +737,7 @@ fn parse_fields(
     }
 
     Ok(Fields {
-        groups,
+        groups: format_groups(groups),
         all_fields,
         base_field,
         deprecations,

godot-macros/src/util/kv_parser.rs

@@ -5,13 +5,12 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
+use super::{bail, error, ident, is_punct, path_is_single, ListParser};
 use crate::ParseResult;
 use proc_macro2::{Delimiter, Ident, Literal, Spacing, Span, TokenStream, TokenTree};
 use quote::ToTokens;
 use std::collections::HashMap;
 
-use super::{bail, error, ident, is_punct, path_is_single, ListParser};
-
 pub(crate) type KvMap = HashMap<Ident, Option<KvValue>>;
 
 /// Struct to parse attributes like `#[attr(key, key2="value", key3=123)]` in a very user-friendly way.
@@ -156,36 +155,64 @@ impl KvParser {
     }
 
     /// Handles an optional key that can occur with arbitrary tokens as the value.
-    pub fn handle_expr(&mut self, key: &str) -> ParseResult<Option<TokenStream>> {
+    ///
+    /// Returns both the key (with the correct span pointing to the attribute) and the value.    
+    /// [KvParser.span](field@KvParser::span) always points to the top of derive macro (`#[derive(GodotClass)]`).
+    pub fn handle_expr_with_key(&mut self, key: &str) -> ParseResult<Option<(Ident, TokenStream)>> {
         match self.map.remove_entry(&ident(key)) {
             None => Ok(None),
             // The `key` that was removed from the map has the correct span.
             Some((key, value)) => match value {
                 None => bail!(key, "expected `{key}` to be followed by `= expression`"),
-                Some(value) => Ok(Some(value.expr()?)),
+                Some(value) => Ok(Some((key, value.expr()?))),
             },
         }
     }
 
-    pub fn handle_usize(&mut self, key: &str) -> ParseResult<Option<usize>> {
-        let Some(expr) = self.handle_expr(key)? else {
+    /// Shortcut for [KvParser::handle_expr_with_key] which returns only the value.
+    pub fn handle_expr(&mut self, key: &str) -> ParseResult<Option<TokenStream>> {
+        match self.handle_expr_with_key(key)? {
+            Some((_key, value)) => Ok(Some(value)),
+            None => Ok(None),
+        }
+    }
+
+    pub fn handle_literal(
+        &mut self,
+        key: &str,
+        expected_type: &str,
+    ) -> ParseResult<Option<Literal>> {
+        let Some((key, expr)) = self.handle_expr_with_key(key)? else {
             return Ok(None);
         };
 
         let mut tokens = expr.into_iter();
         let Some(TokenTree::Literal(lit)) = tokens.next() else {
             return bail!(
                 key,
-                "missing value for '{key}' (must be unsigned integer literal)"
+                "missing value for '{key}' (must be {expected_type} literal)"
             );
         };
 
         if let Some(surplus) = tokens.next() {
             return bail!(
                 key,
-                "value for '{key}' must be unsigned integer literal; found extra {surplus:?}"
+                "value for '{key}' must be {expected_type} literal; found extra {surplus:?}"
             );
         }
+        Ok(Some(lit))
+    }
+
+    /// Handles a string literal (`att = "str"`).
+    pub fn handle_string(&mut self, key: &str) -> ParseResult<Option<String>> {
+        self.handle_literal(key, "String")
+            .map(|possible_literal| possible_literal.map(|lit| lit.to_string()))
+    }
+
+    pub fn handle_usize(&mut self, key: &str) -> ParseResult<Option<usize>> {
+        let Some(lit) = self.handle_literal(key, "unsigned integer")? else {
+            return Ok(None);
+        };
 
         let Ok(int) = lit.to_string().parse() else {
             return bail!(
@@ -199,7 +226,7 @@ impl KvParser {
 
     #[allow(dead_code)]
     pub fn handle_bool(&mut self, key: &str) -> ParseResult<Option<bool>> {
-        let Some(expr) = self.handle_expr(key)? else {
+        let Some((key, expr)) = self.handle_expr_with_key(key)? else {
             return Ok(None);
         };