Use CommonAttrs everywhere

Author: BenFordTytherington

crates/cxx-qt-gen/bat

@@ -72,8 +72,10 @@ impl GeneratedCppBlocks {
                 .iter()
                 .filter_map(|qobject| {
                     // Skip if the cfg attributes are not resolved to true
-                    match try_eval_attributes(opt.cfg_evaluator.as_ref(), &qobject.declaration.common_attrs.cfgs)
-                    {
+                    match try_eval_attributes(
+                        opt.cfg_evaluator.as_ref(),
+                        &qobject.declaration.common_attrs.cfgs,
+                    ) {
                         Ok(true) => {
                             Some(GeneratedCppQObject::from(qobject, &parser.type_names, opt))
                         }

crates/cxx-qt-gen/src/generator/cpp/mod.rs

@@ -7,10 +7,9 @@ use crate::{
     generator::rust::{fragment::GeneratedRustFragment, signals::generate_rust_signal},
     naming::TypeNames,
     parser::externcxxqt::ParsedExternCxxQt,
-    syntax::path::path_compare_str,
 };
 use quote::quote;
-use syn::{parse_quote, Attribute, Item, Result};
+use syn::{parse_quote, Item, Result};
 
 impl GeneratedRustFragment {
     pub fn from_extern_cxx_qt(
@@ -60,19 +59,9 @@ impl GeneratedRustFragment {
                     #[cxx_name = #cxx_name]
                 }
             };
-            // TODO! Can we make extract_docs return references, and then use here?
-            let cfgs: Vec<&Attribute> = obj
-                .declaration
-                .attrs
-                .iter()
-                .filter(|attr| path_compare_str(attr.meta.path(), &["cfg"]))
-                .collect();
-            let docs: Vec<&Attribute> = obj
-                .declaration
-                .attrs
-                .iter()
-                .filter(|attr| path_compare_str(attr.meta.path(), &["doc"]))
-                .collect();
+            // TODO: (cfg everywhere) Can we make extract_docs return references, and then use here?
+            let cfgs = obj.common_attrs.cfgs.iter().collect::<Vec<_>>();
+            let docs = obj.common_attrs.docs.iter().collect::<Vec<_>>();
             qobject_items.push(parse_quote! {
                 #namespace
                 #cxx_name

crates/cxx-qt-gen/src/generator/rust/externcxxqt.rs

@@ -3,6 +3,7 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 use crate::generator::structuring::StructuredQObject;
+use crate::parser::CommonAttrs;
 use crate::{
     generator::{
         naming::{namespace::NamespaceName, qobject::QObjectNames},
@@ -15,7 +16,7 @@ use crate::{
     naming::TypeNames,
 };
 use quote::quote;
-use syn::{parse_quote, Attribute, Result};
+use syn::{parse_quote, Result};
 
 impl GeneratedRustFragment {
     pub fn from_qobject(
@@ -28,7 +29,7 @@ impl GeneratedRustFragment {
         let namespace_idents = NamespaceName::from(qobject);
 
         let mut generated = vec![
-            generate_qobject_definitions(&qobject_names, &qobject.common_attrs.cfgs, &qobject.common_attrs.docs)?,
+            generate_qobject_definitions(&qobject_names, &qobject.common_attrs)?,
             generate_rust_properties(
                 &qobject.properties,
                 &qobject_names,
@@ -87,9 +88,11 @@ impl GeneratedRustFragment {
 /// Generate the C++ and Rust CXX definitions for the QObject
 fn generate_qobject_definitions(
     qobject_idents: &QObjectNames,
-    cfgs: &[Attribute],
-    docs: &[Attribute],
+    common_attrs: &CommonAttrs,
 ) -> Result<GeneratedRustFragment> {
+    let docs = &common_attrs.docs;
+    let cfgs = &common_attrs.cfgs;
+
     let cpp_class_name_rust = &qobject_idents.name.rust_unqualified();
     let cpp_class_name_cpp = &qobject_idents.name.cxx_unqualified();
 

crates/cxx-qt-gen/src/generator/rust/qobject.rs

@@ -3,6 +3,7 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
+use crate::parser::CommonAttrs;
 use crate::{
     parser::{
         externqobject::ParsedExternQObject, require_attributes, signals::ParsedSignal,
@@ -11,10 +12,8 @@ use crate::{
     syntax::{attribute::attribute_get_path, expr::expr_to_string},
 };
 use syn::{
-    spanned::Spanned, Error, ForeignItem, ForeignItemFn, Ident, ItemForeignMod, Result,
-    Token,
+    spanned::Spanned, Error, ForeignItem, ForeignItemFn, Ident, ItemForeignMod, Result, Token,
 };
-use crate::parser::CommonAttrs;
 
 /// Representation of an extern "C++Qt" block
 #[derive(Default)]
@@ -39,10 +38,10 @@ impl ParsedExternCxxQt {
         module_ident: &Ident,
         parent_namespace: Option<&str>,
     ) -> Result<Self> {
-        // TODO: support cfg on foreign mod blocks
+        // TODO: (cfg everywhere) support cfg on foreign mod blocks
         let (attrs, common_attrs) = require_attributes(
             &foreign_mod.attrs,
-            &["namespace", "doc", "auto_cxx_name", "auto_rust_name"],
+            &["doc", "namespace", "auto_cxx_name", "auto_rust_name"],
         )?;
 
         let auto_case = CaseConversion::from_attrs(&attrs)?;
@@ -72,7 +71,7 @@ impl ParsedExternCxxQt {
                 ForeignItem::Type(foreign_ty) => {
                     // Test that there is a #[qobject] attribute on any type
                     //
-                    // TODO: what happens to any docs here?
+                    // TODO: (cfg everywhere) what happens to any docs here?
                     if attribute_get_path(&foreign_ty.attrs, &["qobject"]).is_some() {
                         let extern_ty =
                             ParsedExternQObject::parse(foreign_ty, module_ident, parent_namespace)?;

crates/cxx-qt-gen/src/parser/externcxxqt.rs

@@ -3,7 +3,7 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 use crate::naming::Name;
-use crate::parser::{parse_base_type, require_attributes, CaseConversion};
+use crate::parser::{parse_base_type, require_attributes, CaseConversion, CommonAttrs};
 use syn::{ForeignItemType, Ident, Result};
 
 /// A representation of a QObject to be generated in an extern C++ block
@@ -14,15 +14,17 @@ pub struct ParsedExternQObject {
     pub declaration: ForeignItemType,
     /// The base class of the struct
     pub base_class: Option<Ident>,
+    /// Common attrs for this object
+    pub common_attrs: CommonAttrs,
 }
 
 impl ParsedExternQObject {
     const ALLOWED_ATTRS: [&'static str; 7] = [
+        "cfg",
+        "doc",
         "cxx_name",
         "rust_name",
         "namespace",
-        "cfg",
-        "doc",
         "qobject",
         "base",
     ];
@@ -32,7 +34,8 @@ impl ParsedExternQObject {
         module_ident: &Ident,
         parent_namespace: Option<&str>,
     ) -> Result<ParsedExternQObject> {
-        let (attributes, _common_attrs) = require_attributes(&ty.attrs, &Self::ALLOWED_ATTRS)?;
+        // TODO: (cfg everywhere) should these have docs kept with them in the generated code?
+        let (attributes, common_attrs) = require_attributes(&ty.attrs, &Self::ALLOWED_ATTRS)?;
 
         let base_class = parse_base_type(&attributes)?;
 
@@ -46,6 +49,7 @@ impl ParsedExternQObject {
             )?,
             declaration: ty,
             base_class,
+            common_attrs,
         })
     }
 }

crates/cxx-qt-gen/src/parser/externqobject.rs

@@ -37,7 +37,7 @@ impl ParsedExternRustQt {
         module_ident: &Ident,
         parent_namespace: Option<&str>,
     ) -> Result<Self> {
-        // TODO: support cfg on foreign mod blocks
+        // TODO: (cfg everywhere) support cfg on foreign mod blocks
         let (attrs, _common_attrs) = require_attributes(
             &foreign_mod.attrs,
             &["namespace", "auto_cxx_name", "auto_rust_name"],

crates/cxx-qt-gen/src/parser/externrustqt.rs

@@ -19,20 +19,20 @@ pub struct ParsedInheritedMethod {
 
 impl ParsedInheritedMethod {
     const ALLOWED_ATTRS: [&'static str; 6] = [
+        "cfg",
+        "doc",
         "cxx_name",
         "rust_name",
         "qinvokable",
-        "doc",
         "inherit",
-        "cfg",
     ];
 
     pub fn parse(method: ForeignItemFn, auto_case: CaseConversion) -> Result<Self> {
         let (_attrs, common_attrs) = require_attributes(&method.attrs, &Self::ALLOWED_ATTRS)?;
 
         Ok(Self {
             method_fields: MethodFields::parse(method, auto_case)?,
-            common_attrs
+            common_attrs,
         })
     }
 

crates/cxx-qt-gen/src/parser/inherit.rs

@@ -104,7 +104,6 @@ pub fn extract_cfgs(attrs: &[Attribute]) -> Vec<Attribute> {
 /// Iterate the attributes of the method to extract Doc attributes (doc comments are parsed as this)
 pub fn extract_docs(attrs: &[Attribute]) -> Vec<Attribute> {
     extract_attr(attrs, "doc")
-
 }
 
 /// Splits a path by :: separators e.g. "cxx_qt::bridge" becomes ["cxx_qt", "bridge"]
@@ -139,8 +138,7 @@ pub fn require_attributes<'a>(
             .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 {
+        } else {
             return Err(Error::new(
                 attr.span(),
                 format!(

crates/cxx-qt-gen/src/parser/mod.rs

@@ -3,15 +3,15 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
+use crate::parser::CommonAttrs;
 use crate::{
     naming::Name,
-    parser::{property::ParsedQProperty, require_attributes, parse_base_type, CaseConversion},
+    parser::{parse_base_type, property::ParsedQProperty, require_attributes, CaseConversion},
     syntax::{expr::expr_to_string, foreignmod::ForeignTypeIdentAlias, path::path_compare_str},
 };
 #[cfg(test)]
 use quote::format_ident;
 use syn::{Attribute, Error, Ident, Meta, Result};
-use crate::parser::CommonAttrs;
 
 /// Metadata for registering QML element
 #[derive(Clone, Debug, Default, Eq, PartialEq)]
@@ -47,11 +47,11 @@ pub struct ParsedQObject {
 
 impl ParsedQObject {
     const ALLOWED_ATTRS: [&'static str; 11] = [
+        "cfg",
+        "doc",
         "cxx_name",
         "rust_name",
         "namespace",
-        "cfg",
-        "doc",
         "qobject",
         "base",
         "qml_element",
@@ -76,7 +76,7 @@ impl ParsedQObject {
             common_attrs: CommonAttrs {
                 docs: vec![],
                 cfgs: vec![],
-            }
+            },
         }
     }
 
@@ -87,7 +87,8 @@ impl ParsedQObject {
         module: &Ident,
         auto_case: CaseConversion,
     ) -> Result<Self> {
-        let (attributes, common_attrs) = require_attributes(&declaration.attrs, &Self::ALLOWED_ATTRS)?;
+        let (attributes, common_attrs) =
+            require_attributes(&declaration.attrs, &Self::ALLOWED_ATTRS)?;
 
         let has_qobject_macro = attributes.contains_key("qobject");
 
@@ -125,7 +126,7 @@ impl ParsedQObject {
             properties,
             qml_metadata,
             has_qobject_macro,
-            common_attrs
+            common_attrs,
         })
     }