Move parser to store some things together based on extern block

- QObjects, and invokables are now 2D Vecs, kept in their original block
- Adds some helper methods for iterating like they are still flat

Author: BenFordTytherington

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

@@ -103,8 +103,7 @@ impl GeneratedRustBlocks {
 // Generate a type declaration for `QObject` if necessary
 fn add_qobject_import(cxx_qt_data: &ParsedCxxQtData) -> Option<GeneratedRustFragment> {
     let includes = cxx_qt_data
-        .qobjects
-        .iter()
+        .qobjects()
         .any(|obj| obj.has_qobject_macro && obj.base_class.is_none());
     if includes
         || cxx_qt_data

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

@@ -79,8 +79,7 @@ impl<'a> Structures<'a> {
     /// Returns an error, if any references could not be resolved.
     pub fn new(cxxqtdata: &'a ParsedCxxQtData) -> Result<Self> {
         let mut qobjects: Vec<_> = cxxqtdata
-            .qobjects
-            .iter()
+            .qobjects()
             .map(StructuredQObject::from_qobject)
             .collect();
 
@@ -92,19 +91,19 @@ impl<'a> Structures<'a> {
         }
 
         // Associate each method parsed with its appropriate qobject
-        for method in &cxxqtdata.methods {
+        for method in cxxqtdata.methods() {
             let qobject = find_qobject(&mut qobjects, &method.qobject_ident)?;
             qobject.methods.push(method);
         }
 
         // Associate each inherited method parsed with its appropriate qobject
-        for inherited_method in &cxxqtdata.inherited_methods {
+        for inherited_method in cxxqtdata.inherited_methods() {
             let qobject = find_qobject(&mut qobjects, &inherited_method.qobject_ident)?;
             qobject.inherited_methods.push(inherited_method);
         }
 
         // Associate each signal parsed with its appropriate qobject
-        for signal in &cxxqtdata.signals {
+        for signal in cxxqtdata.signals() {
             let qobject = find_qobject(&mut qobjects, &signal.qobject_ident)?;
             qobject.signals.push(signal);
         }

crates/cxx-qt-gen/src/naming/name.rs

@@ -17,7 +17,7 @@ use syn::{spanned::Spanned, Attribute, Error, Ident, Path, Result};
 /// Naming in CXX can be rather complex.
 /// The following Rules apply:
 /// - If only a cxx_name **or** a rust_name is given, the identifier of the type/function will be
-///     used for part that wasn't specified explicitly.
+///   used for part that wasn't specified explicitly.
 /// - If **both** attributes are present, the identifier itself is not used!
 /// - The `rust_name` is always used to refer to the type within the bridge!.
 #[derive(Clone, Debug, PartialEq, Eq)]

crates/cxx-qt-gen/src/naming/type_names.rs

@@ -161,7 +161,7 @@ impl TypeNames {
         module_ident: &Ident,
     ) -> Result<()> {
         // Find and register the QObjects in the bridge
-        for qobject in cxx_qt_data.qobjects.iter() {
+        for qobject in cxx_qt_data.qobjects() {
             self.populate_qobject(qobject)?;
         }
 

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

@@ -25,19 +25,16 @@ use syn::{
 };
 
 pub struct ParsedCxxQtData {
-    /// Map of the QObjects defined in the module that will be used for code generation
-    //
-    // We have to use a BTreeMap here, instead of a HashMap, to keep the order of QObjects stable.
-    // Otherwise, the output order would be different, depending on the environment, which makes it hard to test/debug.
-    pub qobjects: Vec<ParsedQObject>,
+    /// List of QObjects defined in the module, separated by block
+    pub qobjects: Vec<Vec<ParsedQObject>>,
     /// List of QEnums defined in the module, that aren't associated with a QObject
     pub qenums: Vec<ParsedQEnum>,
-    /// List of methods and Q_INVOKABLES found
-    pub methods: Vec<ParsedMethod>,
-    /// List of the Q_SIGNALS found
-    pub signals: Vec<ParsedSignal>,
-    /// List of the inherited methods found
-    pub inherited_methods: Vec<ParsedInheritedMethod>,
+    /// List of methods and Q_INVOKABLES found, separated by block
+    pub methods: Vec<Vec<ParsedMethod>>,
+    /// List of the Q_SIGNALS found, separated by block
+    pub signals: Vec<Vec<ParsedSignal>>,
+    /// List of the inherited methods found, separated by block
+    pub inherited_methods: Vec<Vec<ParsedInheritedMethod>>,
     /// List of QNamespace declarations
     pub qnamespaces: Vec<ParsedQNamespace>,
     /// Blocks of extern "C++Qt"
@@ -50,6 +47,11 @@ pub struct ParsedCxxQtData {
     pub module_ident: Ident,
 }
 
+/// Used to get a flat iterator view into a 2D Vector
+fn flat_view<T>(v: &[Vec<T>]) -> impl Iterator<Item = &T> {
+    v.iter().flat_map(|v| v.iter())
+}
+
 impl ParsedCxxQtData {
     /// Create a ParsedCxxQtData from a given module and namespace
     pub fn new(module_ident: Ident, namespace: Option<String>) -> Self {
@@ -67,6 +69,26 @@ impl ParsedCxxQtData {
         }
     }
 
+    /// Iterator wrapper for methods
+    pub fn methods(&self) -> impl Iterator<Item = &ParsedMethod> {
+        flat_view(&self.methods)
+    }
+
+    /// Iterator wrapper for signals
+    pub fn signals(&self) -> impl Iterator<Item = &ParsedSignal> {
+        flat_view(&self.signals)
+    }
+
+    /// Iterator wrapper for inherited methods
+    pub fn inherited_methods(&self) -> impl Iterator<Item = &ParsedInheritedMethod> {
+        flat_view(&self.inherited_methods)
+    }
+
+    /// Iterator wrapper for QObjects
+    pub fn qobjects(&self) -> impl Iterator<Item = &ParsedQObject> {
+        flat_view(&self.qobjects)
+    }
+
     /// Determine if the given [syn::Item] is a CXX-Qt related item
     /// If it is then add the [syn::Item] into qobjects BTreeMap
     /// Otherwise return the [syn::Item] to pass through to CXX
@@ -224,10 +246,10 @@ impl ParsedCxxQtData {
         try_inline_self_invokables(inline_self, &inline_ident, &mut signals)?;
         try_inline_self_invokables(inline_self, &inline_ident, &mut inherited)?;
 
-        self.qobjects.extend(qobjects);
-        self.methods.extend(methods);
-        self.signals.extend(signals);
-        self.inherited_methods.extend(inherited);
+        self.qobjects.push(qobjects);
+        self.methods.push(methods);
+        self.signals.push(signals);
+        self.inherited_methods.push(inherited);
 
         Ok(())
     }
@@ -247,8 +269,7 @@ impl ParsedCxxQtData {
 
     #[cfg(test)]
     fn find_object(&self, id: &Ident) -> Option<&ParsedQObject> {
-        self.qobjects
-            .iter()
+        self.qobjects()
             .find(|obj| obj.name.rust_unqualified() == id)
     }
 }
@@ -265,8 +286,9 @@ mod tests {
     /// Creates a ParsedCxxQtData with a QObject definition already found
     pub fn create_parsed_cxx_qt_data() -> ParsedCxxQtData {
         let mut cxx_qt_data = ParsedCxxQtData::new(format_ident!("ffi"), None);
-        cxx_qt_data.qobjects.push(create_parsed_qobject());
-        cxx_qt_data.qobjects.push(create_parsed_qobject());
+        cxx_qt_data
+            .qobjects
+            .push(vec![create_parsed_qobject(), create_parsed_qobject()]);
         cxx_qt_data
     }
 
@@ -376,9 +398,9 @@ mod tests {
         let result = cxx_qt_data.parse_cxx_qt_item(item).unwrap();
         assert!(result.is_none());
 
-        assert_eq!(cxx_qt_data.methods.len(), 2);
-        assert!(cxx_qt_data.methods[0].is_qinvokable);
-        assert!(!cxx_qt_data.methods[1].is_qinvokable)
+        assert_eq!(cxx_qt_data.methods().collect::<Vec<_>>().len(), 2);
+        assert!(cxx_qt_data.methods[0][0].is_qinvokable);
+        assert!(!cxx_qt_data.methods[0][1].is_qinvokable)
     }
 
     #[test]
@@ -406,7 +428,7 @@ mod tests {
         };
         cxx_qt_data.parse_cxx_qt_item(item).unwrap();
         assert_eq!(cxx_qt_data.methods.len(), 1);
-        assert_eq!(cxx_qt_data.methods[0].name.cxx_unqualified(), "fooBar");
+        assert_eq!(cxx_qt_data.methods[0][0].name.cxx_unqualified(), "fooBar");
     }
 
     #[test]
@@ -421,9 +443,10 @@ mod tests {
             }
         };
         cxx_qt_data.parse_cxx_qt_item(item).unwrap();
-        assert_eq!(cxx_qt_data.methods.len(), 1);
-        assert_eq!(cxx_qt_data.methods[0].name.cxx_unqualified(), "foo_bar");
-        assert_eq!(cxx_qt_data.methods[0].name.rust_unqualified(), "foo_bar");
+        let methods = &cxx_qt_data.methods[0];
+        assert_eq!(methods.len(), 1);
+        assert_eq!(methods[0].name.cxx_unqualified(), "foo_bar");
+        assert_eq!(methods[0].name.rust_unqualified(), "foo_bar");
     }
 
     #[test]
@@ -438,8 +461,8 @@ mod tests {
             }
         };
         cxx_qt_data.parse_cxx_qt_item(item).unwrap();
-        assert_eq!(cxx_qt_data.methods.len(), 1);
-        assert_eq!(cxx_qt_data.methods[0].name.cxx_unqualified(), "renamed");
+        assert_eq!(cxx_qt_data.methods[0].len(), 1);
+        assert_eq!(cxx_qt_data.methods[0][0].name.cxx_unqualified(), "renamed");
     }
 
     #[test]
@@ -611,7 +634,7 @@ mod tests {
             }
         };
         cxxqtdata.parse_cxx_qt_item(block).unwrap();
-        let signals = &cxxqtdata.signals;
+        let signals = &cxxqtdata.signals().collect::<Vec<_>>();
         assert_eq!(signals.len(), 2);
         assert!(signals[0].mutable);
         assert!(signals[1].mutable);
@@ -641,7 +664,7 @@ mod tests {
         };
         cxxqtdata.parse_cxx_qt_item(block).unwrap();
 
-        let signals = &cxxqtdata.signals;
+        let signals = &cxxqtdata.signals().collect::<Vec<_>>();
         assert_eq!(signals.len(), 1);
         assert!(signals[0].mutable);
         assert!(!signals[0].safe);
@@ -716,7 +739,7 @@ mod tests {
         };
 
         parsed_cxxqtdata.parse_cxx_qt_item(extern_rust_qt).unwrap();
-        assert_eq!(parsed_cxxqtdata.qobjects.len(), 2);
+        assert_eq!(parsed_cxxqtdata.qobjects().collect::<Vec<_>>().len(), 2);
 
         assert!(parsed_cxxqtdata
             .find_object(&format_ident!("MyObject"))
@@ -741,7 +764,7 @@ mod tests {
         };
 
         parsed_cxxqtdata.parse_cxx_qt_item(extern_rust_qt).unwrap();
-        assert_eq!(parsed_cxxqtdata.qobjects.len(), 2);
+        assert_eq!(parsed_cxxqtdata.qobjects().collect::<Vec<_>>().len(), 2);
         assert_eq!(
             parsed_cxxqtdata
                 .find_object(&format_ident!("MyObject"))

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

@@ -395,7 +395,7 @@ mod tests {
         assert_eq!(parser.passthrough_module.module_ident, "ffi");
         assert_eq!(parser.passthrough_module.vis, Visibility::Inherited);
         assert_eq!(parser.cxx_qt_data.namespace, Some("cxx_qt".to_owned()));
-        assert_eq!(parser.cxx_qt_data.qobjects.len(), 1);
+        assert_eq!(parser.cxx_qt_data.qobjects().collect::<Vec<_>>().len(), 1);
         assert_eq!(parser.type_names.num_types(), 19);
         assert_eq!(
             parser
@@ -441,7 +441,7 @@ mod tests {
         assert_eq!(parser.passthrough_module.module_ident, "ffi");
         assert_eq!(parser.passthrough_module.vis, Visibility::Inherited);
         assert_eq!(parser.cxx_qt_data.namespace, None);
-        assert_eq!(parser.cxx_qt_data.qobjects.len(), 1);
+        assert_eq!(parser.cxx_qt_data.qobjects().collect::<Vec<_>>().len(), 1);
     }
 
     #[test]