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

@@ -4,10 +4,12 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
 use crate::parser::method::MethodFields;
+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 +43,113 @@ pub fn try_inline_self_invokables(
     Ok(())
 }
 
+/// 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<()> {
+    let data = &mut parser.cxx_qt_data;
+    for block in 0..data.qobjects.len() {
+        let methods = &mut data.methods[block];
+        let signals = &mut data.signals[block];
+        let inherited = &mut data.inherited_methods[block];
+        let qobjects = &data.qobjects[block];
+
+        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;
+
+                    #[qsignal]
+                    fn my_signal(self: Pin<&mut Self>);
+                }
 
-        let extern_cpp_qt: Item = parse_quote! {
-            unsafe extern "C++Qt" {
-                #[qobject]
-                type MyObject;
+                unsafe extern "C++Qt" {
+                    #[qobject]
+                    type MyOtherObject;
 
-                #[qsignal]
-                fn my_signal(self: Pin<&mut Self>);
+                    #[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);
+                mod ffi {
+                    extern "RustQt" {
+                        fn my_method(&self);
+                    }
                 }
             }
 
             {
-                extern "RustQt" {
-                    fn my_method(self: Pin<&mut Self>);
+                mod ffi {
+                    extern "RustQt" {
+                        fn my_method(self: Pin<&mut Self>);
+                    }
                 }
             }
             // More than 1 QObjects in block
             {
-                extern "RustQt" {
-                    #[qobject]
-                    type MyObject = super::T;
+                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

@@ -10,7 +10,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};
 
 /// A procedural macro which generates a QObject for a struct inside a module.
 ///
@@ -156,6 +156,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())