Integrate ParsedAttrbiutes struct, containing a map of all attributes

Author: BenFordTytherington

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

@@ -4,12 +4,14 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
 use crate::{parser, syntax::path::path_compare_str};
+use std::collections::btree_map::Entry;
 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>,
+#[derive(Clone)]
+pub struct ParsedAttributes {
+    pub cxx_qt_attrs: BTreeMap<String, Vec<Attribute>>,
+    pub passthrough_attrs: Vec<Attribute>,
 }
 
 /// Iterate the attributes of the method to extract cfg attributes
@@ -30,20 +32,28 @@ pub fn extract_docs(attrs: &[Attribute]) -> Vec<Attribute> {
         .collect()
 }
 
-impl<'a> ParsedAttribute<'a> {
+impl<'a> ParsedAttributes {
     /// 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],
+        mut attrs: Vec<Attribute>,
         allowed: &'a [&str],
-    ) -> Result<ParsedAttribute<'a>> {
-        let mut output = BTreeMap::default();
-        for attr in attrs {
+    ) -> Result<ParsedAttributes> {
+        let mut output = BTreeMap::<String, Vec<Attribute>>::default();
+        for attr in attrs.drain(..) {
             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
+                // TODO: ATTR Doesn't error on duplicates / distinguish allowed and disallowed duplicates
+                match output.entry(allowed[index].into()) {
+                    Entry::Occupied(mut entry) => {
+                        entry.get_mut().push(attr);
+                    }
+                    Entry::Vacant(entry) => {
+                        entry.insert(vec![attr]);
+                    }
+                }
             } else {
                 return Err(Error::new(
                     attr.span(),
@@ -56,23 +66,54 @@ impl<'a> ParsedAttribute<'a> {
         }
         Ok(Self {
             cxx_qt_attrs: output,
-            passthrough_attrs: Default::default(),
+            passthrough_attrs: Default::default(), // TODO: ATTR Pass the actual docs, cfgs, etc... here
         })
     }
 
+    // TODO: ATTR Can this return references instead?
+    pub fn extract_docs(&self) -> Vec<Attribute> {
+        self.cxx_qt_attrs
+            .values()
+            .flatten()
+            .filter(|attr| path_compare_str(attr.meta.path(), &["doc"]))
+            .map(|attr| (*attr).clone())
+            .collect()
+    }
+
+    // TODO: ATTR Can this return references instead
+    pub fn extract_cfgs(&self) -> Vec<Attribute> {
+        self.cxx_qt_attrs
+            .values()
+            .flatten()
+            .filter(|attr| path_compare_str(attr.meta.path(), &["cfg"]))
+            .map(|attr| (*attr).clone())
+            .collect()
+    }
+
+    /// Returns all the attributes stored within the struct
+    pub fn all_attrs(&self) -> Vec<&Attribute> {
+        self.cxx_qt_attrs.values().flatten().collect()
+    }
+
+    /// Returns all the attributes stored within the struct (CLONE) WIP
+    pub fn clone_attrs(&self) -> Vec<Attribute> {
+        self.cxx_qt_attrs
+            .values()
+            .flatten()
+            .cloned()
+            .collect::<Vec<_>>()
+    }
+
     // 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)
+    pub fn get(&self, key: &str) -> Option<&Vec<Attribute>> {
+        self.cxx_qt_attrs.get(key) // TODO: Check passthrough here too
     }
 
     /// 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)
+        self.cxx_qt_attrs.contains_key(key) // TODO: Check in passthrough too
     }
 }

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

@@ -3,7 +3,7 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
-use crate::parser::attribute::ParsedAttribute;
+use crate::parser::attribute::ParsedAttributes;
 use crate::{
     parser::{externqobject::ParsedExternQObject, signals::ParsedSignal, CaseConversion},
     syntax::{attribute::attribute_get_path, expr::expr_to_string},
@@ -34,16 +34,18 @@ impl ParsedExternCxxQt {
         parent_namespace: Option<&str>,
     ) -> Result<Self> {
         // TODO: support cfg on foreign mod blocks
-        let attrs = ParsedAttribute::require_attributes(
-            &foreign_mod.attrs,
+        let attrs = ParsedAttributes::require_attributes(
+            foreign_mod.attrs,
             &["namespace", "auto_cxx_name", "auto_rust_name"],
         )?;
 
         let auto_case = CaseConversion::from_attrs(&attrs.cxx_qt_attrs)?;
 
         let namespace = attrs
             .get("namespace")
-            .map(|attr| -> Result<String> {
+            .map(|attrs| -> Result<String> {
+                // TODO: ATTR won't error on duplicate
+                let attr = attrs.first().expect("NO NAMESPACE!!"); // TODO: ATTR this needs to be proper
                 expr_to_string(&attr.meta.require_name_value()?.value)
             })
             .transpose()?;

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

@@ -3,7 +3,7 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 use crate::naming::Name;
-use crate::parser::attribute::ParsedAttribute;
+use crate::parser::attribute::ParsedAttributes;
 use crate::parser::{parse_base_type, CaseConversion};
 use syn::{ForeignItemType, Ident, Result};
 
@@ -33,14 +33,15 @@ impl ParsedExternQObject {
         module_ident: &Ident,
         parent_namespace: Option<&str>,
     ) -> Result<ParsedExternQObject> {
-        let attrs = ParsedAttribute::require_attributes(&ty.attrs, &Self::ALLOWED_ATTRS)?;
+        // TODO: ATTR Can this be done without clone
+        let attrs = ParsedAttributes::require_attributes(ty.attrs.clone(), &Self::ALLOWED_ATTRS)?;
 
         let base_class = parse_base_type(&attrs.cxx_qt_attrs)?;
 
         Ok(Self {
             name: Name::from_ident_and_attrs(
                 &ty.ident,
-                &ty.attrs,
+                &attrs.clone_attrs(),
                 parent_namespace,
                 Some(module_ident),
                 CaseConversion::none(),

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

@@ -4,7 +4,7 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
 use crate::naming::cpp::err_unsupported_item;
-use crate::parser::attribute::ParsedAttribute;
+use crate::parser::attribute::ParsedAttributes;
 use crate::parser::inherit::ParsedInheritedMethod;
 use crate::parser::method::ParsedMethod;
 use crate::parser::qobject::ParsedQObject;
@@ -39,8 +39,8 @@ impl ParsedExternRustQt {
         parent_namespace: Option<&str>,
     ) -> Result<Self> {
         // TODO: support cfg on foreign mod blocks
-        let attrs = ParsedAttribute::require_attributes(
-            &foreign_mod.attrs,
+        let attrs = ParsedAttributes::require_attributes(
+            foreign_mod.attrs,
             &["namespace", "auto_cxx_name", "auto_rust_name"],
         )?;
 
@@ -51,9 +51,19 @@ impl ParsedExternRustQt {
             ..Default::default()
         };
 
+        // TODO: ATTR This needs to be proper
         let namespace = attrs
             .get("namespace")
-            .map(|attr| expr_to_string(&attr.meta.require_name_value()?.value))
+            .map(|attrs| {
+                expr_to_string(
+                    &attrs
+                        .first()
+                        .expect("NO NAMESPACE!!")
+                        .meta
+                        .require_name_value()?
+                        .value,
+                )
+            })
             .transpose()?
             .or_else(|| parent_namespace.map(String::from));
 

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

@@ -3,7 +3,6 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
-use crate::parser::attribute::{extract_cfgs, extract_docs, ParsedAttribute};
 use crate::parser::{method::MethodFields, CaseConversion};
 use core::ops::Deref;
 use quote::format_ident;
@@ -31,12 +30,12 @@ impl ParsedInheritedMethod {
     ];
 
     pub fn parse(method: ForeignItemFn, auto_case: CaseConversion) -> Result<Self> {
-        ParsedAttribute::require_attributes(&method.attrs, &Self::ALLOWED_ATTRS)?;
-        let docs = extract_docs(&method.attrs);
-        let cfgs = extract_cfgs(&method.attrs);
+        let method_fields = MethodFields::parse(method, auto_case, &Self::ALLOWED_ATTRS)?;
 
+        let docs = method_fields.attrs.extract_docs();
+        let cfgs = method_fields.attrs.extract_cfgs();
         Ok(Self {
-            method_fields: MethodFields::parse(method, auto_case)?,
+            method_fields,
             docs,
             cfgs,
         })

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

@@ -2,7 +2,7 @@
 // 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::attribute::{extract_cfgs, ParsedAttributes};
 use crate::parser::CaseConversion;
 use crate::{
     naming::Name,
@@ -34,7 +34,7 @@ impl ParsedQInvokableSpecifiers {
         }
     }
 
-    fn from_attrs(attrs: BTreeMap<&str, &Attribute>) -> HashSet<ParsedQInvokableSpecifiers> {
+    fn from_attrs(attrs: BTreeMap<String, Vec<Attribute>>) -> HashSet<ParsedQInvokableSpecifiers> {
         let mut output = HashSet::new();
         for specifier in [
             ParsedQInvokableSpecifiers::Final,
@@ -121,15 +121,14 @@ impl ParsedMethod {
         auto_case: CaseConversion,
         unsafe_block: bool,
     ) -> Result<Self> {
-        let fields = MethodFields::parse(method, auto_case)?;
-        let attrs =
-            ParsedAttribute::require_attributes(&fields.method.attrs, &Self::ALLOWED_ATTRS)?;
+        let fields = MethodFields::parse(method, auto_case, &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.cxx_qt_attrs);
+        let is_qinvokable = fields.attrs.contains_key("qinvokable");
+        let is_pure = fields.attrs.contains_key("cxx_pure");
+        // TODO: Can this be done without clone
+        let specifiers = ParsedQInvokableSpecifiers::from_attrs(fields.attrs.cxx_qt_attrs.clone());
 
         Ok(Self {
             method_fields: fields,
@@ -166,18 +165,30 @@ pub struct MethodFields {
     pub parameters: Vec<ParsedFunctionParameter>,
     pub safe: bool,
     pub name: Name,
+    pub attrs: ParsedAttributes,
 }
 
 impl MethodFields {
-    pub fn parse(method: ForeignItemFn, auto_case: CaseConversion) -> Result<Self> {
+    pub fn parse(
+        method: ForeignItemFn,
+        auto_case: CaseConversion,
+        allowed: &[&str],
+    ) -> Result<Self> {
+        // TODO: Remove this clone?
+        let attrs = ParsedAttributes::require_attributes(method.attrs.clone(), allowed)?;
         let self_receiver = foreignmod::self_type_from_foreign_fn(&method.sig)?;
         let (qobject_ident, mutability) = types::extract_qobject_ident(&self_receiver.ty)?;
         let mutable = mutability.is_some();
 
         let parameters = ParsedFunctionParameter::parse_all_ignoring_receiver(&method.sig)?;
         let safe = method.sig.unsafety.is_none();
-        let name =
-            Name::from_ident_and_attrs(&method.sig.ident, &method.attrs, None, None, auto_case)?;
+        let name = Name::from_ident_and_attrs(
+            &method.sig.ident,
+            &attrs.clone_attrs(),
+            None,
+            None,
+            auto_case,
+        )?;
 
         Ok(MethodFields {
             method,
@@ -186,6 +197,7 @@ impl MethodFields {
             parameters,
             safe,
             name,
+            attrs,
         })
     }