Create ParsedAttribute struct and module, and move attributes into there

BenFordTytherington · BenFordTytherington · commit aa718f6a1005 · 2025-07-02T15:03:06.000+01:00
diff --git a/crates/cxx-qt-gen/src/parser/attribute.rs b/crates/cxx-qt-gen/src/parser/attribute.rs
@@ -0,0 +1,78 @@
+// SPDX-FileCopyrightText: 2025 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
+// SPDX-FileContributor: Ben Ford <ben.ford@kdab.com>
+//
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+use crate::{parser, syntax::path::path_compare_str};
+use std::collections::BTreeMap;
+use syn::{spanned::Spanned, Attribute, Error, Result};
+
+pub struct ParsedAttribute<'a> {
+    pub cxx_qt_attrs: BTreeMap<&'a str, &'a Attribute>,
+    pub passthrough_attrs: BTreeMap<&'a str, &'a Attribute>,
+}
+
+/// Iterate the attributes of the method to extract cfg attributes
+pub fn extract_cfgs(attrs: &[Attribute]) -> Vec<Attribute> {
+    attrs
+        .iter()
+        .filter(|attr| path_compare_str(attr.meta.path(), &["cfg"]))
+        .cloned()
+        .collect()
+}
+
+/// Iterate the attributes of the method to extract Doc attributes (doc comments are parsed as this)
+pub fn extract_docs(attrs: &[Attribute]) -> Vec<Attribute> {
+    attrs
+        .iter()
+        .filter(|attr| path_compare_str(attr.meta.path(), &["doc"]))
+        .cloned()
+        .collect()
+}
+
+impl<'a> ParsedAttribute<'a> {
+    /// Collects a Map of all attributes found from the allowed list
+    /// Will error if an attribute which is not in the allowed list is found
+    pub fn require_attributes(
+        attrs: &'a [Attribute],
+        allowed: &'a [&str],
+    ) -> Result<ParsedAttribute<'a>> {
+        let mut output = BTreeMap::default();
+        for attr in attrs {
+            let index = allowed
+                .iter()
+                .position(|string| path_compare_str(attr.meta.path(), &parser::split_path(string)));
+            if let Some(index) = index {
+                output.insert(allowed[index], attr); // TODO: Doesn't error on duplicates
+            } else {
+                return Err(Error::new(
+                    attr.span(),
+                    format!(
+                        "Unsupported attribute! The only attributes allowed on this item are\n{}",
+                        allowed.join(", ")
+                    ),
+                ));
+            }
+        }
+        Ok(Self {
+            cxx_qt_attrs: output,
+            passthrough_attrs: Default::default(),
+        })
+    }
+
+    // Wrapper methods for the internal BTreeMaps
+    // TODO: Refactor usage to use more specialised methods / rename
+
+    /// Search in first the CXX-Qt, and then passthrough attributes by key
+    pub fn get(&self, key: &str) -> Option<&Attribute> {
+        self.cxx_qt_attrs
+            .get(key)
+            .or(self.passthrough_attrs.get(key))
+            .map(|attr| &**attr)
+    }
+
+    /// Check if CXX-Qt or passthrough attributes contains a particular key
+    pub fn contains_key(&self, key: &str) -> bool {
+        self.cxx_qt_attrs.contains_key(key) || self.passthrough_attrs.contains_key(key)
+    }
+}
diff --git a/crates/cxx-qt-gen/src/parser/externcxxqt.rs b/crates/cxx-qt-gen/src/parser/externcxxqt.rs
@@ -3,11 +3,9 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
+use crate::parser::attribute::ParsedAttribute;
 use crate::{
-    parser::{
-        externqobject::ParsedExternQObject, require_attributes, signals::ParsedSignal,
-        CaseConversion,
-    },
+    parser::{externqobject::ParsedExternQObject, signals::ParsedSignal, CaseConversion},
     syntax::{attribute::attribute_get_path, expr::expr_to_string},
 };
 use syn::{
@@ -36,12 +34,12 @@ impl ParsedExternCxxQt {
         parent_namespace: Option<&str>,
     ) -> Result<Self> {
         // TODO: support cfg on foreign mod blocks
-        let attrs = require_attributes(
+        let attrs = ParsedAttribute::require_attributes(
             &foreign_mod.attrs,
             &["namespace", "auto_cxx_name", "auto_rust_name"],
         )?;
 
-        let auto_case = CaseConversion::from_attrs(&attrs)?;
+        let auto_case = CaseConversion::from_attrs(&attrs.cxx_qt_attrs)?;
 
         let namespace = attrs
             .get("namespace")
diff --git a/crates/cxx-qt-gen/src/parser/externqobject.rs b/crates/cxx-qt-gen/src/parser/externqobject.rs
@@ -3,7 +3,8 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 use crate::naming::Name;
-use crate::parser::{parse_base_type, require_attributes, CaseConversion};
+use crate::parser::attribute::ParsedAttribute;
+use crate::parser::{parse_base_type, CaseConversion};
 use syn::{ForeignItemType, Ident, Result};
 
 /// A representation of a QObject to be generated in an extern C++ block
@@ -32,9 +33,9 @@ impl ParsedExternQObject {
         module_ident: &Ident,
         parent_namespace: Option<&str>,
     ) -> Result<ParsedExternQObject> {
-        let attributes = require_attributes(&ty.attrs, &Self::ALLOWED_ATTRS)?;
+        let attrs = ParsedAttribute::require_attributes(&ty.attrs, &Self::ALLOWED_ATTRS)?;
 
-        let base_class = parse_base_type(&attributes)?;
+        let base_class = parse_base_type(&attrs.cxx_qt_attrs)?;
 
         Ok(Self {
             name: Name::from_ident_and_attrs(
diff --git a/crates/cxx-qt-gen/src/parser/externrustqt.rs b/crates/cxx-qt-gen/src/parser/externrustqt.rs
@@ -4,11 +4,12 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
 use crate::naming::cpp::err_unsupported_item;
+use crate::parser::attribute::ParsedAttribute;
 use crate::parser::inherit::ParsedInheritedMethod;
 use crate::parser::method::ParsedMethod;
 use crate::parser::qobject::ParsedQObject;
 use crate::parser::signals::ParsedSignal;
-use crate::parser::{require_attributes, CaseConversion};
+use crate::parser::CaseConversion;
 use crate::syntax::attribute::attribute_get_path;
 use crate::syntax::expr::expr_to_string;
 use crate::syntax::foreignmod::ForeignTypeIdentAlias;
@@ -38,12 +39,12 @@ impl ParsedExternRustQt {
         parent_namespace: Option<&str>,
     ) -> Result<Self> {
         // TODO: support cfg on foreign mod blocks
-        let attrs = require_attributes(
+        let attrs = ParsedAttribute::require_attributes(
             &foreign_mod.attrs,
             &["namespace", "auto_cxx_name", "auto_rust_name"],
         )?;
 
-        let auto_case = CaseConversion::from_attrs(&attrs)?;
+        let auto_case = CaseConversion::from_attrs(&attrs.cxx_qt_attrs)?;
 
         let mut extern_rustqt_block = Self {
             unsafety: foreign_mod.unsafety,
diff --git a/crates/cxx-qt-gen/src/parser/inherit.rs b/crates/cxx-qt-gen/src/parser/inherit.rs
@@ -3,9 +3,8 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
-use crate::parser::{
-    extract_cfgs, extract_docs, method::MethodFields, require_attributes, CaseConversion,
-};
+use crate::parser::attribute::{extract_cfgs, extract_docs, ParsedAttribute};
+use crate::parser::{method::MethodFields, CaseConversion};
 use core::ops::Deref;
 use quote::format_ident;
 use std::ops::DerefMut;
@@ -32,7 +31,7 @@ impl ParsedInheritedMethod {
     ];
 
     pub fn parse(method: ForeignItemFn, auto_case: CaseConversion) -> Result<Self> {
-        require_attributes(&method.attrs, &Self::ALLOWED_ATTRS)?;
+        ParsedAttribute::require_attributes(&method.attrs, &Self::ALLOWED_ATTRS)?;
         let docs = extract_docs(&method.attrs);
         let cfgs = extract_cfgs(&method.attrs);
 
diff --git a/crates/cxx-qt-gen/src/parser/method.rs b/crates/cxx-qt-gen/src/parser/method.rs
@@ -2,10 +2,11 @@
 // SPDX-FileContributor: Andrew Hayzen <andrew.hayzen@kdab.com>
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
+use crate::parser::attribute::{extract_cfgs, ParsedAttribute};
 use crate::parser::CaseConversion;
 use crate::{
     naming::Name,
-    parser::{extract_cfgs, parameter::ParsedFunctionParameter, require_attributes},
+    parser::parameter::ParsedFunctionParameter,
     syntax::{foreignmod, types},
 };
 use core::ops::Deref;
@@ -121,13 +122,14 @@ impl ParsedMethod {
         unsafe_block: bool,
     ) -> Result<Self> {
         let fields = MethodFields::parse(method, auto_case)?;
-        let attrs = require_attributes(&fields.method.attrs, &Self::ALLOWED_ATTRS)?;
+        let attrs =
+            ParsedAttribute::require_attributes(&fields.method.attrs, &Self::ALLOWED_ATTRS)?;
         let cfgs = extract_cfgs(&fields.method.attrs);
 
         // Determine if the method is invokable
         let is_qinvokable = attrs.contains_key("qinvokable");
         let is_pure = attrs.contains_key("cxx_pure");
-        let specifiers = ParsedQInvokableSpecifiers::from_attrs(attrs);
+        let specifiers = ParsedQInvokableSpecifiers::from_attrs(attrs.cxx_qt_attrs);
 
         Ok(Self {
             method_fields: fields,
diff --git a/crates/cxx-qt-gen/src/parser/mod.rs b/crates/cxx-qt-gen/src/parser/mod.rs
@@ -3,6 +3,7 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
+pub mod attribute;
 pub mod constructor;
 pub mod cxxqtdata;
 pub mod externcxxqt;
@@ -18,10 +19,8 @@ pub mod qobject;
 pub mod signals;
 pub mod trait_impl;
 
-use crate::{
-    naming::TypeNames,
-    syntax::{expr::expr_to_string, path::path_compare_str},
-};
+use crate::parser::attribute::ParsedAttribute;
+use crate::{naming::TypeNames, syntax::expr::expr_to_string};
 use convert_case::Case;
 use cxxqtdata::ParsedCxxQtData;
 use std::collections::BTreeMap;
@@ -87,24 +86,6 @@ impl CaseConversion {
     }
 }
 
-/// Iterate the attributes of the method to extract cfg attributes
-pub fn extract_cfgs(attrs: &[Attribute]) -> Vec<Attribute> {
-    attrs
-        .iter()
-        .filter(|attr| path_compare_str(attr.meta.path(), &["cfg"]))
-        .cloned()
-        .collect()
-}
-
-/// Iterate the attributes of the method to extract Doc attributes (doc comments are parsed as this)
-pub fn extract_docs(attrs: &[Attribute]) -> Vec<Attribute> {
-    attrs
-        .iter()
-        .filter(|attr| path_compare_str(attr.meta.path(), &["doc"]))
-        .cloned()
-        .collect()
-}
-
 /// Splits a path by :: separators e.g. "cxx_qt::bridge" becomes ["cxx_qt", "bridge"]
 fn split_path(path_str: &str) -> Vec<&str> {
     let path = if path_str.contains("::") {
@@ -115,32 +96,6 @@ fn split_path(path_str: &str) -> Vec<&str> {
     path
 }
 
-/// Collects a Map of all attributes found from the allowed list
-/// Will error if an attribute which is not in the allowed list is found
-pub fn require_attributes<'a>(
-    attrs: &'a [Attribute],
-    allowed: &'a [&str],
-) -> Result<BTreeMap<&'a str, &'a Attribute>> {
-    let mut output = BTreeMap::default();
-    for attr in attrs {
-        let index = allowed
-            .iter()
-            .position(|string| path_compare_str(attr.meta.path(), &split_path(string)));
-        if let Some(index) = index {
-            output.insert(allowed[index], attr); // Doesn't error on duplicates
-        } else {
-            return Err(Error::new(
-                attr.span(),
-                format!(
-                    "Unsupported attribute! The only attributes allowed on this item are\n{}",
-                    allowed.join(", ")
-                ),
-            ));
-        }
-    }
-    Ok(output)
-}
-
 // Extract base identifier from attribute
 pub fn parse_base_type(attributes: &BTreeMap<&str, &Attribute>) -> Result<Option<Ident>> {
     attributes
@@ -174,7 +129,7 @@ impl PassthroughMod {
 
         Self {
             items,
-            docs: extract_docs(&module.attrs),
+            docs: attribute::extract_docs(&module.attrs),
             module_ident: module.ident,
             vis: module.vis,
         }
@@ -196,7 +151,7 @@ pub struct Parser {
 
 impl Parser {
     fn parse_mod_attributes(module: &mut ItemMod) -> Result<Option<String>> {
-        let attrs = require_attributes(&module.attrs, &["doc", "cxx_qt::bridge"])?;
+        let attrs = ParsedAttribute::require_attributes(&module.attrs, &["doc", "cxx_qt::bridge"])?;
         let mut namespace = None;
 
         // Check for the cxx_qt::bridge attribute
diff --git a/crates/cxx-qt-gen/src/parser/qenum.rs b/crates/cxx-qt-gen/src/parser/qenum.rs
@@ -3,8 +3,9 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
-use crate::parser::{extract_cfgs, extract_docs, CaseConversion};
-use crate::{naming::Name, parser::require_attributes, syntax::path::path_compare_str};
+use crate::parser::attribute::{extract_cfgs, extract_docs, ParsedAttribute};
+use crate::parser::CaseConversion;
+use crate::{naming::Name, syntax::path::path_compare_str};
 use quote::ToTokens;
 use syn::{Attribute, Ident, ItemEnum, Result, Variant};
 
@@ -60,7 +61,7 @@ impl ParsedQEnum {
         parent_namespace: Option<&str>,
         module: &Ident,
     ) -> Result<Self> {
-        require_attributes(&qenum.attrs, &Self::ALLOWED_ATTRS)?;
+        ParsedAttribute::require_attributes(&qenum.attrs, &Self::ALLOWED_ATTRS)?;
         let cfgs = extract_cfgs(&qenum.attrs);
         let docs = extract_docs(&qenum.attrs);
 
diff --git a/crates/cxx-qt-gen/src/parser/qnamespace.rs b/crates/cxx-qt-gen/src/parser/qnamespace.rs
@@ -3,7 +3,7 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
-use crate::parser::require_attributes;
+use crate::parser::attribute::ParsedAttribute;
 use syn::{ItemMacro, LitStr, Result};
 
 pub struct ParsedQNamespace {
@@ -15,7 +15,7 @@ pub struct ParsedQNamespace {
 
 impl ParsedQNamespace {
     pub fn parse(mac: ItemMacro) -> Result<Self> {
-        let attrs = require_attributes(&mac.attrs, &["qml_element"])?;
+        let attrs = ParsedAttribute::require_attributes(&mac.attrs, &["qml_element"])?;
         let namespace_literal: LitStr = syn::parse2(mac.mac.tokens)?;
         let namespace = namespace_literal.value();
         if namespace.contains(char::is_whitespace) {
diff --git a/crates/cxx-qt-gen/src/parser/qobject.rs b/crates/cxx-qt-gen/src/parser/qobject.rs
@@ -5,12 +5,13 @@
 
 use crate::{
     naming::Name,
-    parser::{extract_cfgs, property::ParsedQProperty, require_attributes},
+    parser::property::ParsedQProperty,
     syntax::{expr::expr_to_string, foreignmod::ForeignTypeIdentAlias, path::path_compare_str},
 };
 #[cfg(test)]
 use quote::format_ident;
 
+use crate::parser::attribute::{extract_cfgs, ParsedAttribute};
 use crate::parser::{parse_base_type, CaseConversion};
 use syn::{Attribute, Error, Ident, Meta, Result};
 
@@ -85,13 +86,14 @@ impl ParsedQObject {
         module: &Ident,
         auto_case: CaseConversion,
     ) -> Result<Self> {
-        let attributes = require_attributes(&declaration.attrs, &Self::ALLOWED_ATTRS)?;
+        let attributes =
+            ParsedAttribute::require_attributes(&declaration.attrs, &Self::ALLOWED_ATTRS)?;
         // TODO: handle docs through to generation
         let cfgs = extract_cfgs(&declaration.attrs);
 
         let has_qobject_macro = attributes.contains_key("qobject");
 
-        let base_class = parse_base_type(&attributes)?;
+        let base_class = parse_base_type(&attributes.cxx_qt_attrs)?;
 
         // Ensure that if there is no qobject macro that a base class is specificed
         if !has_qobject_macro && base_class.is_none() {
@@ -130,7 +132,7 @@ impl ParsedQObject {
     }
 
     fn parse_qml_metadata(name: &Name, attrs: &[Attribute]) -> Result<Option<QmlElementMetadata>> {
-        let attributes = require_attributes(attrs, &Self::ALLOWED_ATTRS)?;
+        let attributes = ParsedAttribute::require_attributes(attrs, &Self::ALLOWED_ATTRS)?;
         if let Some(attr) = attributes.get("qml_element") {
             // Extract the name of the qml_element from macro, else use the c++ name
             // This will use the name provided by cxx_name if that attr was present
diff --git a/crates/cxx-qt-gen/src/parser/signals.rs b/crates/cxx-qt-gen/src/parser/signals.rs
