cxx-qt-gen: remove qobject:: from parameters in methods in a bridge

Related to KDAB#559
ahayzen-kdab · Jul 18, 2023 · 654af1d · 654af1d
1 parent 8d2abcb
commit 654af1d
Show file tree

Hide file tree

Showing 34 changed files with 182 additions and 175 deletions.
diff --git a/crates/cxx-qt-gen/src/generator/cpp/inherit.rs b/crates/cxx-qt-gen/src/generator/cpp/inherit.rs
@@ -82,7 +82,7 @@ mod tests {
     fn test_immutable() {
         let generated = generate_from_foreign(
             parse_quote! {
-                fn test(self: &qobject::T, a: B, b: C);
+                fn test(self: &T, a: B, b: C);
             },
             Some("TestBaseClass"),
         )
@@ -104,7 +104,7 @@ mod tests {
     fn test_mutable() {
         let generated = generate_from_foreign(
             parse_quote! {
-                fn test(self: Pin<&mut qobject::T>);
+                fn test(self: Pin<&mut T>);
             },
             Some("TestBaseClass"),
         )
@@ -126,7 +126,7 @@ mod tests {
     fn test_default_base_class() {
         let generated = generate_from_foreign(
             parse_quote! {
-                fn test(self: &qobject::T);
+                fn test(self: &T);
             },
             None,
         )

diff --git a/crates/cxx-qt-gen/src/generator/cpp/invokable.rs b/crates/cxx-qt-gen/src/generator/cpp/invokable.rs
@@ -161,15 +161,15 @@ mod tests {
     fn test_generate_cpp_invokables() {
         let invokables = vec![
             ParsedQInvokable {
-                method: parse_quote! { fn void_invokable(self: &qobject::MyObject); },
+                method: parse_quote! { fn void_invokable(self: &MyObject); },
                 qobject_ident: format_ident!("MyObject"),
                 mutable: false,
                 safe: true,
                 parameters: vec![],
                 specifiers: HashSet::new(),
             },
             ParsedQInvokable {
-                method: parse_quote! { fn trivial_invokable(self: &qobject::MyObject, param: i32) -> i32; },
+                method: parse_quote! { fn trivial_invokable(self: &MyObject, param: i32) -> i32; },
                 qobject_ident: format_ident!("MyObject"),
                 mutable: false,
                 safe: true,
@@ -180,7 +180,7 @@ mod tests {
                 specifiers: HashSet::new(),
             },
             ParsedQInvokable {
-                method: parse_quote! { fn opaque_invokable(self: Pin<&mut qobject::MyObject>, param: &QColor) -> UniquePtr<QColor>; },
+                method: parse_quote! { fn opaque_invokable(self: Pin<&mut MyObject>, param: &QColor) -> UniquePtr<QColor>; },
                 qobject_ident: format_ident!("MyObject"),
                 mutable: true,
                 safe: true,
@@ -191,7 +191,7 @@ mod tests {
                 specifiers: HashSet::new(),
             },
             ParsedQInvokable {
-                method: parse_quote! { fn specifiers_invokable(self: &qobject::MyObject, param: i32) -> i32; },
+                method: parse_quote! { fn specifiers_invokable(self: &MyObject, param: i32) -> i32; },
                 qobject_ident: format_ident!("MyObject"),
                 mutable: false,
                 safe: true,
@@ -306,7 +306,7 @@ mod tests {
     #[test]
     fn test_generate_cpp_invokables_mapped_cxx_name() {
         let invokables = vec![ParsedQInvokable {
-            method: parse_quote! { fn trivial_invokable(self: &qobject::MyObject, param: A) -> B; },
+            method: parse_quote! { fn trivial_invokable(self: &MyObject, param: A) -> B; },
             qobject_ident: format_ident!("MyObject"),
             mutable: false,
             safe: true,

diff --git a/crates/cxx-qt-gen/src/generator/naming/invokable.rs b/crates/cxx-qt-gen/src/generator/naming/invokable.rs
@@ -52,7 +52,7 @@ mod tests {
     fn test_from_impl_method() {
         let parsed = ParsedQInvokable {
             method: parse_quote! {
-                fn my_invokable(self: &qobject::MyObject);
+                fn my_invokable(self: &MyObject);
             },
             qobject_ident: format_ident!("MyObject"),
             mutable: false,

diff --git a/crates/cxx-qt-gen/src/generator/rust/inherit.rs b/crates/cxx-qt-gen/src/generator/rust/inherit.rs
@@ -80,7 +80,7 @@ mod tests {
     fn test_mutable() {
         let generated = generate_from_foreign(
             parse_quote! {
-                fn test(self: Pin<&mut qobject::MyObject>, a: B, b: C);
+                fn test(self: Pin<&mut MyObject>, a: B, b: C);
             },
             Safety::Safe,
         )
@@ -104,7 +104,7 @@ mod tests {
     fn test_immutable() {
         let generated = generate_from_foreign(
             parse_quote! {
-                fn test(self: &qobject::MyObject, a: B, b: C);
+                fn test(self: &MyObject, a: B, b: C);
             },
             Safety::Safe,
         )
@@ -128,7 +128,7 @@ mod tests {
     fn test_unsafe() {
         let generated = generate_from_foreign(
             parse_quote! {
-                unsafe fn test(self: &qobject::MyObject);
+                unsafe fn test(self: &MyObject);
             },
             Safety::Unsafe,
         )

diff --git a/crates/cxx-qt-gen/src/generator/rust/invokable.rs b/crates/cxx-qt-gen/src/generator/rust/invokable.rs
@@ -118,15 +118,15 @@ mod tests {
     fn test_generate_rust_invokables() {
         let invokables = vec![
             ParsedQInvokable {
-                method: parse_quote! { fn void_invokable(self: &qobject::MyObject); },
+                method: parse_quote! { fn void_invokable(self: &MyObject); },
                 qobject_ident: format_ident!("MyObject"),
                 mutable: false,
                 safe: true,
                 parameters: vec![],
                 specifiers: HashSet::new(),
             },
             ParsedQInvokable {
-                method: parse_quote! { fn trivial_invokable(self: &qobject::MyObject, param: i32) -> i32; },
+                method: parse_quote! { fn trivial_invokable(self: &MyObject, param: i32) -> i32; },
                 qobject_ident: format_ident!("MyObject"),
                 mutable: false,
                 safe: true,
@@ -137,7 +137,7 @@ mod tests {
                 specifiers: HashSet::new(),
             },
             ParsedQInvokable {
-                method: parse_quote! { fn opaque_invokable(self: Pin<&mut qobject::MyObject>, param: &QColor) -> UniquePtr<QColor>; },
+                method: parse_quote! { fn opaque_invokable(self: Pin<&mut MyObject>, param: &QColor) -> UniquePtr<QColor>; },
                 qobject_ident: format_ident!("MyObject"),
                 mutable: true,
                 safe: true,
@@ -148,7 +148,7 @@ mod tests {
                 specifiers: HashSet::new(),
             },
             ParsedQInvokable {
-                method: parse_quote! { unsafe fn unsafe_invokable(self: &qobject::MyObject, param: *mut T) -> *mut T; },
+                method: parse_quote! { unsafe fn unsafe_invokable(self: &MyObject, param: *mut T) -> *mut T; },
                 qobject_ident: format_ident!("MyObject"),
                 mutable: false,
                 safe: false,

diff --git a/crates/cxx-qt-gen/src/parser/cxxqtdata.rs b/crates/cxx-qt-gen/src/parser/cxxqtdata.rs
@@ -442,7 +442,7 @@ mod tests {
         let item: Item = parse_quote! {
             unsafe extern "RustQt" {
                 #[qinvokable]
-                fn invokable(self: &qobject::MyObject);
+                fn invokable(self: &MyObject);
 
                 fn cpp_context();
             }
@@ -466,7 +466,7 @@ mod tests {
         let item: Item = parse_quote! {
             unsafe extern "RustQt" {
                 #[qinvokable]
-                fn invokable(self: &qobject::MyObject::Bad);
+                fn invokable(self: &MyObject::Bad);
             }
         };
         let result = cxx_qt_data.parse_cxx_qt_item(item);
@@ -743,17 +743,17 @@ mod tests {
         let unsafe_block: Item = parse_quote! {
             unsafe extern "RustQt" {
                 #[inherit]
-                fn test(self: &qobject::MyObject);
+                fn test(self: &MyObject);
 
                 #[inherit]
-                fn with_args(self: &qobject::MyObject, arg: i32);
+                fn with_args(self: &MyObject, arg: i32);
             }
         };
         let safe_block: Item = parse_quote! {
             extern "RustQt" {
                 #[cxx_name="withRename"]
                 #[inherit]
-                unsafe fn with_rename(self: Pin<&mut qobject::MyObject>, arg: i32);
+                unsafe fn with_rename(self: Pin<&mut MyObject>, arg: i32);
             }
         };
 
@@ -783,12 +783,12 @@ mod tests {
         let block: Item = parse_quote! {
             unsafe extern "RustQt" {
                 #[qsignal]
-                fn ready(self: Pin<&mut qobject::MyObject>);
+                fn ready(self: Pin<&mut MyObject>);
 
                 #[cxx_name="cppDataChanged"]
                 #[inherit]
                 #[qsignal]
-                fn data_changed(self: Pin<&mut qobject::MyObject>, data: i32);
+                fn data_changed(self: Pin<&mut MyObject>, data: i32);
             }
         };
         cxxqtdata.parse_cxx_qt_item(block).unwrap();
@@ -828,7 +828,7 @@ mod tests {
         let block: Item = parse_quote! {
             unsafe extern "RustQt" {
                 #[qsignal]
-                fn ready(self: Pin<&mut qobject::UnknownObj>);
+                fn ready(self: Pin<&mut UnknownObj>);
             }
         };
         assert!(cxxqtdata.parse_cxx_qt_item(block).is_err());
@@ -840,7 +840,7 @@ mod tests {
         let block: Item = parse_quote! {
             extern "RustQt" {
                 #[qsignal]
-                unsafe fn unsafe_signal(self: Pin<&mut qobject::MyObject>, arg: *mut T);
+                unsafe fn unsafe_signal(self: Pin<&mut MyObject>, arg: *mut T);
             }
         };
         cxxqtdata.parse_cxx_qt_item(block).unwrap();

diff --git a/crates/cxx-qt-gen/src/parser/inherit.rs b/crates/cxx-qt-gen/src/parser/inherit.rs
@@ -90,16 +90,9 @@ mod tests {
         assert_parse_error(parse_quote! {
             fn test(&self);
         });
-        // Missing qobject::
-        assert_parse_error(parse_quote! {
-            fn test(self: &T);
-        });
         assert_parse_error(parse_quote! {
             fn test(self: &mut T);
         });
-        assert_parse_error(parse_quote! {
-            fn test(self: Pin<&mut T>);
-        });
         // Pointer types
         assert_parse_error(parse_quote! {
             fn test(self: *const T);
@@ -116,20 +109,40 @@ mod tests {
         });
         // Attributes
         assert_parse_error(parse_quote! {
-            fn test(#[test] self: &qobject::T);
+            fn test(#[test] self: &T);
         });
         // Missing "unsafe"
         let function: ForeignItemFn = parse_quote! {
-            fn test(self: &qobject::T);
+            fn test(self: &T);
         };
         assert!(ParsedInheritedMethod::parse(function, Safety::Unsafe).is_err());
     }
 
+    #[test]
+    fn test_parse_ok() {
+        // T by ref
+        assert!(ParsedInheritedMethod::parse(
+            parse_quote! {
+                fn test(self: &T);
+            },
+            Safety::Safe
+        )
+        .is_ok());
+        // T by Pin
+        assert!(ParsedInheritedMethod::parse(
+            parse_quote! {
+                fn test(self: Pin<&mut T>);
+            },
+            Safety::Safe
+        )
+        .is_ok());
+    }
+
     #[test]
     fn test_parse_safe() {
         let function: ForeignItemFn = parse_quote! {
             #[cxx_name="testFunction"]
-            fn test(self: Pin<&mut qobject::T>, a: i32, b: &str);
+            fn test(self: Pin<&mut T>, a: i32, b: &str);
         };
 
         let parsed = ParsedInheritedMethod::parse(function, Safety::Safe).unwrap();

diff --git a/crates/cxx-qt-gen/src/parser/mod.rs b/crates/cxx-qt-gen/src/parser/mod.rs
@@ -167,7 +167,7 @@ mod tests {
 
                 unsafe extern "RustQt" {
                     #[qsignal]
-                    fn ready(self: Pin<&mut qobject::MyObject>);
+                    fn ready(self: Pin<&mut MyObject>);
                 }
             }
         };
@@ -194,7 +194,7 @@ mod tests {
 
                 unsafe extern "RustQt" {
                     #[qsignal]
-                    fn ready(self: Pin<&mut qobject::MyObject>);
+                    fn ready(self: Pin<&mut MyObject>);
                 }
 
                 extern "Rust" {
@@ -225,7 +225,7 @@ mod tests {
 
                 unsafe extern "RustQt" {
                     #[qsignal]
-                    fn ready(self: Pin<&mut qobject::UnknownObject>);
+                    fn ready(self: Pin<&mut UnknownObject>);
                 }
             }
         };

diff --git a/crates/cxx-qt-gen/src/parser/signals.rs b/crates/cxx-qt-gen/src/parser/signals.rs
@@ -112,7 +112,7 @@ mod tests {
     #[test]
     fn test_parse_signal() {
         let method: ForeignItemFn = parse_quote! {
-            fn ready(self: Pin<&mut qobject::MyObject>);
+            fn ready(self: Pin<&mut MyObject>);
         };
         let signal = ParsedSignal::parse(method.clone(), Safety::Safe).unwrap();
         assert_eq!(signal.method, method);
@@ -134,12 +134,12 @@ mod tests {
     fn test_parse_signal_cxx_name() {
         let method: ForeignItemFn = parse_quote! {
             #[cxx_name = "cppReady"]
-            fn ready(self: Pin<&mut qobject::MyObject>);
+            fn ready(self: Pin<&mut MyObject>);
         };
         let signal = ParsedSignal::parse(method, Safety::Safe).unwrap();
 
         let expected_method: ForeignItemFn = parse_quote! {
-            fn ready(self: Pin<&mut qobject::MyObject>);
+            fn ready(self: Pin<&mut MyObject>);
         };
         assert_eq!(signal.method, expected_method);
         assert_eq!(signal.qobject_ident, format_ident!("MyObject"));
@@ -160,12 +160,12 @@ mod tests {
     fn test_parse_signal_inherit() {
         let method: ForeignItemFn = parse_quote! {
             #[inherit]
-            fn ready(self: Pin<&mut qobject::MyObject>);
+            fn ready(self: Pin<&mut MyObject>);
         };
         let signal = ParsedSignal::parse(method, Safety::Safe).unwrap();
 
         let expected_method: ForeignItemFn = parse_quote! {
-            fn ready(self: Pin<&mut qobject::MyObject>);
+            fn ready(self: Pin<&mut MyObject>);
         };
         assert_eq!(signal.method, expected_method);
         assert_eq!(signal.qobject_ident, format_ident!("MyObject"));
@@ -185,7 +185,7 @@ mod tests {
     #[test]
     fn test_parse_signal_mutable_err() {
         let method: ForeignItemFn = parse_quote! {
-            fn ready(self: &qobject::MyObject);
+            fn ready(self: &MyObject);
         };
         // Can't be immutable
         assert!(ParsedSignal::parse(method, Safety::Safe).is_err());
@@ -194,7 +194,7 @@ mod tests {
     #[test]
     fn test_parse_signal_parameters() {
         let method: ForeignItemFn = parse_quote! {
-            fn ready(self: Pin<&mut qobject::MyObject>, x: f64, y: f64);
+            fn ready(self: Pin<&mut MyObject>, x: f64, y: f64);
         };
         let signal = ParsedSignal::parse(method.clone(), Safety::Safe).unwrap();
         assert_eq!(signal.method, method);
@@ -237,7 +237,7 @@ mod tests {
     #[test]
     fn test_parse_signal_unsafe() {
         let method: ForeignItemFn = parse_quote! {
-            unsafe fn ready(self: Pin<&mut qobject::MyObject>);
+            unsafe fn ready(self: Pin<&mut MyObject>);
         };
         let signal = ParsedSignal::parse(method.clone(), Safety::Unsafe).unwrap();
         assert_eq!(signal.method, method);
@@ -258,7 +258,7 @@ mod tests {
     #[test]
     fn test_parse_signal_unsafe_error() {
         let method: ForeignItemFn = parse_quote! {
-            fn ready(self: Pin<&mut qobject::MyObject>);
+            fn ready(self: Pin<&mut MyObject>);
         };
         // Can't be safe on the block and the method
         assert!(ParsedSignal::parse(method, Safety::Unsafe).is_err());

diff --git a/crates/cxx-qt-gen/src/syntax/foreignmod.rs b/crates/cxx-qt-gen/src/syntax/foreignmod.rs
@@ -234,10 +234,10 @@ mod tests {
     #[test]
     fn test_foreign_fn_self() {
         let foreign_fn: ForeignItemFn = parse_quote! {
-            fn foo(self: &qobject::T, a: A) -> B;
+            fn foo(self: &T, a: A) -> B;
         };
         let result = self_type_from_foreign_fn(&foreign_fn.sig).unwrap();
-        assert_eq!(result.ty.to_token_stream().to_string(), "& qobject :: T");
+        assert_eq!(result.ty.to_token_stream().to_string(), "& T");
     }
 
     #[test]