Move inlining to a separate phase which processes a Parser

- Add function call to cxx-qt-build and cxx-qt-macro
- Inlining now happens after parsing and before structuring

Author: BenFordTytherington

crates/cxx-qt-build/src/lib.rs

@@ -43,8 +43,8 @@ use std::{
 };
 
 use cxx_qt_gen::{
-    parse_qt_file, write_cpp, write_rust, CppFragment, CxxQtItem, GeneratedCppBlocks, GeneratedOpt,
-    GeneratedRustBlocks, Parser,
+    parse_qt_file, qualify_self_types, write_cpp, write_rust, CppFragment, CxxQtItem,
+    GeneratedCppBlocks, GeneratedOpt, GeneratedRustBlocks, Parser,
 };
 
 // TODO: we need to eventually support having multiple modules defined in a single file. This
@@ -132,7 +132,10 @@ impl GeneratedCpp {
                     }
                     found_bridge = true;
 
-                    let parser = Parser::from(m.clone())
+                    let mut parser = Parser::from(m.clone())
+                        .map_err(GeneratedError::from)
+                        .map_err(to_diagnostic)?;
+                    qualify_self_types(&mut parser)
                         .map_err(GeneratedError::from)
                         .map_err(to_diagnostic)?;
                     let generated_cpp = GeneratedCppBlocks::from(&parser, &cxx_qt_opt)

crates/cxx-qt-gen/src/lib.rs

@@ -21,6 +21,7 @@ pub use generator::{
     GeneratedOpt,
 };
 pub use parser::Parser;
+pub use preprocessor::self_inlining::qualify_self_types;
 pub use syntax::{parse_qt_file, CxxQtFile, CxxQtItem};
 pub use writer::{cpp::write_cpp, rust::write_rust};
 
@@ -175,7 +176,8 @@ mod tests {
         expected_cpp_header: &str,
         expected_cpp_source: &str,
     ) {
-        let parser = Parser::from(syn::parse_str(input).unwrap()).unwrap();
+        let mut parser = Parser::from(syn::parse_str(input).unwrap()).unwrap();
+        qualify_self_types(&mut parser).unwrap();
 
         let mut cfg_evaluator = CfgEvaluatorTest::default();
         cfg_evaluator.cfgs.insert("crate", Some("cxx-qt-gen"));

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

@@ -7,7 +7,6 @@ use super::qnamespace::ParsedQNamespace;
 use super::trait_impl::TraitImpl;
 use crate::naming::cpp::err_unsupported_item;
 use crate::parser::CaseConversion;
-use crate::preprocessor::self_inlining::try_inline_self_invokables;
 use crate::{
     parser::{
         externcxxqt::ParsedExternCxxQt, inherit::ParsedInheritedMethod, method::ParsedMethod,
@@ -18,7 +17,6 @@ use crate::{
         path::path_compare_str,
     },
 };
-use quote::format_ident;
 use syn::{
     spanned::Spanned, Error, ForeignItem, Ident, Item, ItemEnum, ItemForeignMod, ItemImpl,
     ItemMacro, Meta, Result,
@@ -236,16 +234,6 @@ impl ParsedCxxQtData {
             }
         }
 
-        // If there is exaclty one qobject in the block, it can be inlined as a self type.
-        let inline_self = qobjects.len() == 1;
-        let inline_ident = qobjects
-            .last()
-            .map(|obj| format_ident!("{}", obj.declaration.ident_left));
-
-        try_inline_self_invokables(inline_self, &inline_ident, &mut methods)?;
-        try_inline_self_invokables(inline_self, &inline_ident, &mut signals)?;
-        try_inline_self_invokables(inline_self, &inline_ident, &mut inherited)?;
-
         self.qobjects.push(qobjects);
         self.methods.push(methods);
         self.signals.push(signals);

crates/cxx-qt-gen/src/preprocessor/self_inlining.rs

@@ -3,11 +3,17 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
-use crate::parser::method::MethodFields;
+use crate::parser::cxxqtdata::ParsedCxxQtData;
+use crate::parser::inherit::ParsedInheritedMethod;
+use crate::parser::method::{MethodFields, ParsedMethod};
+use crate::parser::qobject::ParsedQObject;
+use crate::parser::signals::ParsedSignal;
+use crate::Parser;
 use proc_macro2::Ident;
+use quote::format_ident;
 use std::ops::DerefMut;
 use syn::spanned::Spanned;
-use syn::Error;
+use syn::{Error, Result};
 
 /// Inline any `Self` types in the methods signatures with the Ident of a qobject passed in
 ///
@@ -41,86 +47,130 @@ pub fn try_inline_self_invokables(
     Ok(())
 }
 
+// Separates the parsed data by block and returns tuples of the components
+fn separate_blocks(
+    data: &mut ParsedCxxQtData,
+) -> Vec<(
+    &mut Vec<ParsedQObject>,
+    &mut Vec<ParsedMethod>,
+    &mut Vec<ParsedInheritedMethod>,
+    &mut Vec<ParsedSignal>,
+)> {
+    data.qobjects
+        .iter_mut()
+        .zip(data.methods.iter_mut())
+        .zip(data.inherited_methods.iter_mut())
+        .zip(data.signals.iter_mut())
+        .map(|(((qobject, method), inherited_method), signal)| {
+            (qobject, method, inherited_method, signal)
+        })
+        .collect()
+}
+
+/// For a given parser, attempt to inline the `Self` type used in any of the blocks with that blocks unique QObject
+pub fn qualify_self_types(parser: &mut Parser) -> Result<()> {
+    for (qobjects, methods, inherited, signals) in separate_blocks(&mut parser.cxx_qt_data) {
+        let inline_self = qobjects.len() == 1;
+        let inline_ident = qobjects
+            .last()
+            .map(|obj| format_ident!("{}", obj.declaration.ident_left));
+
+        try_inline_self_invokables(inline_self, &inline_ident, methods)?;
+        try_inline_self_invokables(inline_self, &inline_ident, signals)?;
+        try_inline_self_invokables(inline_self, &inline_ident, inherited)?;
+    }
+
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::parser::cxxqtdata::ParsedCxxQtData;
     use crate::parser::method::ParsedMethod;
     use crate::tests::assert_parse_errors;
-    use quote::format_ident;
-    use syn::{parse_quote, Item};
+    use syn::parse_quote;
 
     #[test]
     fn test_self_inlining_ref() {
-        let mut parsed_cxxqtdata = ParsedCxxQtData::new(format_ident!("ffi"), None);
-        let extern_rust_qt: Item = parse_quote! {
-            unsafe extern "RustQt" {
-                #[qobject]
-                type MyObject = super::T;
+        let module = parse_quote! {
+            #[cxx_qt::bridge]
+            mod ffi {
+                unsafe extern "RustQt" {
+                    #[qobject]
+                    type MyObject = super::T;
 
-                fn my_method(&self);
+                    fn my_method(&self);
 
-                #[inherit]
-                fn my_inherited_method(&self);
+                    #[inherit]
+                    fn my_inherited_method(&self);
+                }
             }
         };
-
-        parsed_cxxqtdata.parse_cxx_qt_item(extern_rust_qt).unwrap();
+        let mut parser = Parser::from(module).unwrap();
+        assert!(qualify_self_types(&mut parser).is_ok());
     }
 
     #[test]
     fn test_self_inlining_pin() {
-        let mut parsed_cxxqtdata = ParsedCxxQtData::new(format_ident!("ffi"), None);
-        let extern_rust_qt: Item = parse_quote! {
-            unsafe extern "RustQt" {
-                #[qobject]
-                type MyObject = super::T;
-
-                #[qsignal]
-                fn my_signal(self: Pin<&mut Self>);
-            }
-        };
+        let module = parse_quote! {
+            #[cxx_qt::bridge]
+            mod ffi {
+                unsafe extern "RustQt" {
+                    #[qobject]
+                    type MyObject = super::T;
 
-        let extern_cpp_qt: Item = parse_quote! {
-            unsafe extern "C++Qt" {
-                #[qobject]
-                type MyObject;
+                    #[qsignal]
+                    fn my_signal(self: Pin<&mut Self>);
+                }
 
-                #[qsignal]
-                fn my_signal(self: Pin<&mut Self>);
+                unsafe extern "C++Qt" {
+                    #[qobject]
+                    type MyOtherObject;
+
+                    #[qsignal]
+                    fn my_signal(self: Pin<&mut Self>);
+                }
             }
         };
-
-        parsed_cxxqtdata.parse_cxx_qt_item(extern_rust_qt).unwrap();
-        parsed_cxxqtdata.parse_cxx_qt_item(extern_cpp_qt).unwrap();
+        let mut parser = Parser::from(module).unwrap();
+        assert!(qualify_self_types(&mut parser).is_ok());
     }
 
     #[test]
     fn test_self_inlining_methods_invalid() {
         assert_parse_errors! {
-            |item| ParsedCxxQtData::new(format_ident!("ffi"), None).parse_cxx_qt_item(item) =>
+            |item| qualify_self_types(&mut Parser::from(item)?) =>
             // No QObject in block
             {
-                extern "RustQt" {
-                    fn my_method(&self);
+                #[cxx_qt::bridge]
+                mod ffi {
+                    extern "RustQt" {
+                        fn my_method(&self);
+                    }
                 }
             }
 
             {
-                extern "RustQt" {
-                    fn my_method(self: Pin<&mut Self>);
+                #[cxx_qt::bridge]
+                mod ffi {
+                    extern "RustQt" {
+                        fn my_method(self: Pin<&mut Self>);
+                    }
                 }
             }
             // More than 1 QObjects in block
             {
-                extern "RustQt" {
-                    #[qobject]
-                    type MyObject = super::T;
+                #[cxx_qt::bridge]
+                mod ffi {
+                    extern "RustQt" {
+                        #[qobject]
+                        type MyObject = super::T;
 
-                    #[qobject]
-                    type MyOtherObject = super::S;
+                        #[qobject]
+                        type MyOtherObject = super::S;
 
-                    fn my_method(&self);
+                        fn my_method(&self);
+                    }
                 }
             }
         }

crates/cxx-qt-macro/src/lib.rs

@@ -15,7 +15,7 @@
 use proc_macro::TokenStream;
 use syn::{parse_macro_input, ItemMod};
 
-use cxx_qt_gen::{write_rust, GeneratedRustBlocks, Parser};
+use cxx_qt_gen::{qualify_self_types, write_rust, GeneratedRustBlocks, Parser};
 
 #[proc_macro_attribute]
 pub fn bridge(args: TokenStream, input: TokenStream) -> TokenStream {
@@ -75,6 +75,10 @@ pub fn init_qml_module(args: TokenStream) -> TokenStream {
 // Take the module and C++ namespace and generate the rust code
 fn extract_and_generate(module: ItemMod) -> TokenStream {
     Parser::from(module)
+        .and_then(|mut parser| {
+            qualify_self_types(&mut parser)?;
+            Ok(parser)
+        })
         .and_then(|parser| GeneratedRustBlocks::from(&parser))
         .map(|generated_rust| write_rust(&generated_rust, None))
         .unwrap_or_else(|err| err.to_compile_error())