TypeNames: Return Result from namespace()

If the type isn't known, we shouldn't assume it to be valid.
So return an "Unknown type" error instead.

Author: LeonMatthesKDAB

crates/cxx-qt-gen/src/generator/cpp/externcxxqt.rs

@@ -58,14 +58,18 @@ mod tests {
                 type MyObject;
 
                 #[qsignal]
-                fn signal1(self: Pin<&mut ObjRust>);
+                fn signal1(self: Pin<&mut MyObject>);
 
                 #[qsignal]
-                fn signal2(self: Pin<&mut ObjRust>);
+                fn signal2(self: Pin<&mut MyObject>);
             }
         })
         .unwrap()];
-        let generated = generate(&blocks, &TypeNames::default()).unwrap();
+
+        // Unknown types
+        assert!(generate(&blocks, &TypeNames::default()).is_err());
+
+        let generated = generate(&blocks, &TypeNames::mock()).unwrap();
         assert_eq!(generated.len(), 2);
     }
 

crates/cxx-qt-gen/src/generator/cpp/property/mod.rs

@@ -82,7 +82,7 @@ mod tests {
         let qobject_idents = create_qobjectname();
 
         let generated =
-            generate_cpp_properties(&properties, &qobject_idents, &TypeNames::default()).unwrap();
+            generate_cpp_properties(&properties, &qobject_idents, &TypeNames::mock()).unwrap();
 
         // metaobjects
         assert_eq!(generated.metaobjects.len(), 2);
@@ -360,7 +360,7 @@ mod tests {
         }];
         let qobject_idents = create_qobjectname();
 
-        let mut type_names = TypeNames::default();
+        let mut type_names = TypeNames::mock();
         type_names.insert("A", None, Some("A1"), None);
 
         let generated = generate_cpp_properties(&properties, &qobject_idents, &type_names).unwrap();

crates/cxx-qt-gen/src/generator/cpp/signal.rs

@@ -96,7 +96,7 @@ pub fn generate_cpp_signal(
 
     // Prepare the idents
     let idents = QSignalName::from(signal);
-    let idents_helper = QSignalHelperName::new(&idents, qobject_ident, type_names);
+    let idents_helper = QSignalHelperName::new(&idents, qobject_ident, type_names)?;
 
     let signal_ident = idents.name.cpp;
     let free_connect_ident_cpp = idents_helper.connect_name.cpp;
@@ -251,7 +251,7 @@ mod tests {
         let qobject_idents = create_qobjectname();
 
         let generated =
-            generate_cpp_signals(&signals, &qobject_idents, &TypeNames::default()).unwrap();
+            generate_cpp_signals(&signals, &qobject_idents, &TypeNames::mock()).unwrap();
 
         assert_eq!(generated.methods.len(), 1);
         let header = if let CppFragment::Header(header) = &generated.methods[0] {
@@ -349,7 +349,7 @@ mod tests {
         }];
         let qobject_idents = create_qobjectname();
 
-        let mut type_names = TypeNames::default();
+        let mut type_names = TypeNames::mock();
         type_names.insert("A", None, Some("A1"), None);
 
         let generated = generate_cpp_signals(&signals, &qobject_idents, &type_names).unwrap();
@@ -444,9 +444,8 @@ mod tests {
             private: false,
         }];
         let qobject_idents = create_qobjectname();
-
         let generated =
-            generate_cpp_signals(&signals, &qobject_idents, &TypeNames::default()).unwrap();
+            generate_cpp_signals(&signals, &qobject_idents, &TypeNames::mock()).unwrap();
 
         assert_eq!(generated.methods.len(), 0);
         assert_eq!(generated.fragments.len(), 1);
@@ -531,8 +530,9 @@ mod tests {
             private: false,
         };
 
-        let generated =
-            generate_cpp_signal(&signal, &signal.qobject_ident, &TypeNames::default()).unwrap();
+        let mut type_names = TypeNames::default();
+        type_names.insert("ObjRust", None, None, None);
+        let generated = generate_cpp_signal(&signal, &signal.qobject_ident, &type_names).unwrap();
 
         assert_eq!(generated.methods.len(), 0);
 

crates/cxx-qt-gen/src/generator/naming/signals.rs

@@ -6,7 +6,7 @@ use crate::parser::signals::ParsedSignal;
 use crate::{generator::naming::CombinedIdent, naming::TypeNames};
 use convert_case::{Case, Casing};
 use quote::format_ident;
-use syn::Ident;
+use syn::{Ident, Result};
 
 /// Names for parts of a Q_SIGNAL
 pub struct QSignalName {
@@ -52,7 +52,11 @@ pub struct QSignalHelperName {
 }
 
 impl QSignalHelperName {
-    pub fn new(idents: &QSignalName, qobject_ident: &Ident, type_names: &TypeNames) -> Self {
+    pub fn new(
+        idents: &QSignalName,
+        qobject_ident: &Ident,
+        type_names: &TypeNames,
+    ) -> Result<Self> {
         let signal_ident = &idents.name.cpp;
         let handler_alias = format_ident!("{qobject_ident}CxxQtSignalHandler{signal_ident}");
         let namespace = {
@@ -67,7 +71,7 @@ impl QSignalHelperName {
             //
             // See the comment on TypeNames::cxx_qualified for why fully qualifying is
             // unfortunately not possible.
-            let qobject_namespace = type_names.namespace(qobject_ident);
+            let qobject_namespace = type_names.namespace(qobject_ident)?;
             let namespace: Vec<_> = qobject_namespace
                 .into_iter()
                 .chain(vec!["rust::cxxqtgen1".to_owned()])
@@ -78,7 +82,7 @@ impl QSignalHelperName {
 
         // TODO: in the future we might improve the naming of the methods
         // to avoid collisions (maybe use a separator similar to how CXX uses $?)
-        Self {
+        Ok(Self {
             connect_name: CombinedIdent {
                 cpp: format_ident!("{}_{}", qobject_ident, idents.connect_name.cpp),
                 rust: format_ident!("{}_{}", qobject_ident, idents.connect_name.rust),
@@ -90,7 +94,7 @@ impl QSignalHelperName {
             struct_param: format_ident!("{qobject_ident}CxxQtSignalParams{signal_ident}"),
             namespace,
             handler_alias,
-        }
+        })
     }
 }
 

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

@@ -92,7 +92,7 @@ mod tests {
         let generated = generate_rust_properties(
             &properties,
             &qobject_idents,
-            &TypeNames::default(),
+            &TypeNames::mock(),
             &format_ident!("ffi"),
         )
         .unwrap();
@@ -116,7 +116,7 @@ mod tests {
         assert_tokens_eq(
             &generated.cxx_qt_mod_contents[0],
             parse_quote! {
-                impl MyObject {
+                impl qobject::MyObject {
                     #[doc = "Getter for the Q_PROPERTY "]
                     #[doc = "trivial_property"]
                     pub fn trivial_property(&self) -> &i32 {
@@ -139,7 +139,7 @@ mod tests {
         assert_tokens_eq(
             &generated.cxx_qt_mod_contents[1],
             parse_quote! {
-                impl MyObject {
+                impl qobject::MyObject {
                     #[doc = "Setter for the Q_PROPERTY "]
                     #[doc = "trivial_property"]
                     pub fn set_trivial_property(mut self: core::pin::Pin<&mut Self>, value: i32) {
@@ -169,7 +169,7 @@ mod tests {
         assert_tokens_eq(
             &generated.cxx_qt_mod_contents[2],
             parse_quote! {
-                impl MyObject {
+                impl qobject::MyObject {
                     #[doc = "Getter for the Q_PROPERTY "]
                     #[doc = "opaque_property"]
                     pub fn opaque_property(&self) -> &cxx::UniquePtr<QColor> {
@@ -192,7 +192,7 @@ mod tests {
         assert_tokens_eq(
             &generated.cxx_qt_mod_contents[3],
             parse_quote! {
-                impl MyObject {
+                impl qobject::MyObject {
                     #[doc = "Setter for the Q_PROPERTY "]
                     #[doc = "opaque_property"]
                     pub fn set_opaque_property(mut self: core::pin::Pin<&mut Self>, value: cxx::UniquePtr<QColor>) {
@@ -222,7 +222,7 @@ mod tests {
         assert_tokens_eq(
             &generated.cxx_qt_mod_contents[4],
             parse_quote! {
-                impl MyObject {
+                impl qobject::MyObject {
                     #[doc = "Getter for the Q_PROPERTY "]
                     #[doc = "unsafe_property"]
                     pub fn unsafe_property(&self) -> &*mut T {
@@ -245,7 +245,7 @@ mod tests {
         assert_tokens_eq(
             &generated.cxx_qt_mod_contents[5],
             parse_quote! {
-                impl MyObject {
+                impl qobject::MyObject {
                     #[doc = "Setter for the Q_PROPERTY "]
                     #[doc = "unsafe_property"]
                     pub fn set_unsafe_property(mut self: core::pin::Pin<&mut Self>, value: *mut T) {
@@ -307,11 +307,11 @@ mod tests {
         assert_tokens_eq(
             &generated.cxx_qt_mod_contents[6],
             parse_quote! {
-                impl MyObject {
+                impl qobject::MyObject {
                     #[doc = "Connect the given function pointer to the signal "]
                     #[doc = "trivialPropertyChanged"]
                     #[doc = ", so that when the signal is emitted the function pointer is executed."]
-                    pub fn connect_trivial_property_changed<F: FnMut(core::pin::Pin<&mut MyObject>, ) + 'static>(self: core::pin::Pin<&mut MyObject>, mut closure: F, conn_type: cxx_qt::ConnectionType) -> cxx_qt::QMetaObjectConnectionGuard
+                    pub fn connect_trivial_property_changed<F: FnMut(core::pin::Pin<&mut qobject::MyObject>, ) + 'static>(self: core::pin::Pin<&mut qobject::MyObject>, mut closure: F, conn_type: cxx_qt::ConnectionType) -> cxx_qt::QMetaObjectConnectionGuard
                     {
                         cxx_qt::QMetaObjectConnectionGuard::from(ffi::MyObject_connect_trivial_property_changed(
                             self,
@@ -325,13 +325,13 @@ mod tests {
         assert_tokens_eq(
             &generated.cxx_qt_mod_contents[7],
             parse_quote! {
-                impl MyObject {
+                impl qobject::MyObject {
                     #[doc = "Connect the given function pointer to the signal "]
                     #[doc = "trivialPropertyChanged"]
                     #[doc = ", so that when the signal is emitted the function pointer is executed."]
                     #[doc = "\n"]
                     #[doc = "Note that this method uses a AutoConnection connection type."]
-                    pub fn on_trivial_property_changed<F: FnMut(core::pin::Pin<&mut MyObject>, ) + 'static>(self: core::pin::Pin<&mut MyObject>, mut closure: F) -> cxx_qt::QMetaObjectConnectionGuard
+                    pub fn on_trivial_property_changed<F: FnMut(core::pin::Pin<&mut qobject::MyObject>, ) + 'static>(self: core::pin::Pin<&mut qobject::MyObject>, mut closure: F) -> cxx_qt::QMetaObjectConnectionGuard
                     {
                         cxx_qt::QMetaObjectConnectionGuard::from(ffi::MyObject_connect_trivial_property_changed(
                             self,
@@ -354,7 +354,7 @@ mod tests {
             parse_quote! {
                 impl cxx_qt::signalhandler::CxxQtSignalHandlerClosure for MyObjectCxxQtSignalClosuretrivialPropertyChanged {
                     type Id = cxx::type_id!("::rust::cxxqtgen1::MyObjectCxxQtSignalHandlertrivialPropertyChanged");
-                    type FnType = dyn FnMut(core::pin::Pin<&mut MyObject>, );
+                    type FnType = dyn FnMut(core::pin::Pin<&mut qobject::MyObject>, );
                 }
             },
         );
@@ -369,7 +369,7 @@ mod tests {
             parse_quote! {
                 fn call_MyObject_signal_handler_trivialPropertyChanged(
                     handler: &mut cxx_qt::signalhandler::CxxQtSignalHandler<MyObjectCxxQtSignalClosuretrivialPropertyChanged>,
-                    self_value: core::pin::Pin<&mut MyObject>,
+                    self_value: core::pin::Pin<&mut qobject::MyObject>,
                 ) {
                     handler.closure()(self_value, );
                 }
@@ -433,11 +433,11 @@ mod tests {
         assert_tokens_eq(
             &generated.cxx_qt_mod_contents[14],
             parse_quote! {
-                impl MyObject {
+                impl qobject::MyObject {
                     #[doc = "Connect the given function pointer to the signal "]
                     #[doc = "opaquePropertyChanged"]
                     #[doc = ", so that when the signal is emitted the function pointer is executed."]
-                    pub fn connect_opaque_property_changed<F: FnMut(core::pin::Pin<&mut MyObject>, ) + 'static>(self: core::pin::Pin<&mut MyObject>, mut closure: F, conn_type: cxx_qt::ConnectionType) -> cxx_qt::QMetaObjectConnectionGuard
+                    pub fn connect_opaque_property_changed<F: FnMut(core::pin::Pin<&mut qobject::MyObject>, ) + 'static>(self: core::pin::Pin<&mut qobject::MyObject>, mut closure: F, conn_type: cxx_qt::ConnectionType) -> cxx_qt::QMetaObjectConnectionGuard
                     {
                         cxx_qt::QMetaObjectConnectionGuard::from(ffi::MyObject_connect_opaque_property_changed(
                             self,
@@ -451,13 +451,13 @@ mod tests {
         assert_tokens_eq(
             &generated.cxx_qt_mod_contents[15],
             parse_quote! {
-                impl MyObject {
+                impl qobject::MyObject {
                     #[doc = "Connect the given function pointer to the signal "]
                     #[doc = "opaquePropertyChanged"]
                     #[doc = ", so that when the signal is emitted the function pointer is executed."]
                     #[doc = "\n"]
                     #[doc = "Note that this method uses a AutoConnection connection type."]
-                    pub fn on_opaque_property_changed<F: FnMut(core::pin::Pin<&mut MyObject>, ) + 'static>(self: core::pin::Pin<&mut MyObject>, mut closure: F) -> cxx_qt::QMetaObjectConnectionGuard
+                    pub fn on_opaque_property_changed<F: FnMut(core::pin::Pin<&mut qobject::MyObject>, ) + 'static>(self: core::pin::Pin<&mut qobject::MyObject>, mut closure: F) -> cxx_qt::QMetaObjectConnectionGuard
                     {
                         cxx_qt::QMetaObjectConnectionGuard::from(ffi::MyObject_connect_opaque_property_changed(
                             self,
@@ -480,7 +480,7 @@ mod tests {
             parse_quote! {
                 impl cxx_qt::signalhandler::CxxQtSignalHandlerClosure for MyObjectCxxQtSignalClosureopaquePropertyChanged {
                     type Id = cxx::type_id!("::rust::cxxqtgen1::MyObjectCxxQtSignalHandleropaquePropertyChanged");
-                    type FnType = dyn FnMut(core::pin::Pin<&mut MyObject>, );
+                    type FnType = dyn FnMut(core::pin::Pin<&mut qobject::MyObject>, );
                 }
             },
         );
@@ -495,7 +495,7 @@ mod tests {
             parse_quote! {
                 fn call_MyObject_signal_handler_opaquePropertyChanged(
                     handler: &mut cxx_qt::signalhandler::CxxQtSignalHandler<MyObjectCxxQtSignalClosureopaquePropertyChanged>,
-                    self_value: core::pin::Pin<&mut MyObject>,
+                    self_value: core::pin::Pin<&mut qobject::MyObject>,
                 ) {
                     handler.closure()(self_value, );
                 }
@@ -559,11 +559,11 @@ mod tests {
         assert_tokens_eq(
             &generated.cxx_qt_mod_contents[22],
             parse_quote! {
-                impl MyObject {
+                impl qobject::MyObject {
                     #[doc = "Connect the given function pointer to the signal "]
                     #[doc = "unsafePropertyChanged"]
                     #[doc = ", so that when the signal is emitted the function pointer is executed."]
-                    pub fn connect_unsafe_property_changed<F: FnMut(core::pin::Pin<&mut MyObject>, ) + 'static>(self: core::pin::Pin<&mut MyObject>, mut closure: F, conn_type: cxx_qt::ConnectionType) -> cxx_qt::QMetaObjectConnectionGuard
+                    pub fn connect_unsafe_property_changed<F: FnMut(core::pin::Pin<&mut qobject::MyObject>, ) + 'static>(self: core::pin::Pin<&mut qobject::MyObject>, mut closure: F, conn_type: cxx_qt::ConnectionType) -> cxx_qt::QMetaObjectConnectionGuard
                     {
                         cxx_qt::QMetaObjectConnectionGuard::from(ffi::MyObject_connect_unsafe_property_changed(
                             self,
@@ -577,13 +577,13 @@ mod tests {
         assert_tokens_eq(
             &generated.cxx_qt_mod_contents[23],
             parse_quote! {
-                impl MyObject {
+                impl qobject::MyObject {
                     #[doc = "Connect the given function pointer to the signal "]
                     #[doc = "unsafePropertyChanged"]
                     #[doc = ", so that when the signal is emitted the function pointer is executed."]
                     #[doc = "\n"]
                     #[doc = "Note that this method uses a AutoConnection connection type."]
-                    pub fn on_unsafe_property_changed<F: FnMut(core::pin::Pin<&mut MyObject>, ) + 'static>(self: core::pin::Pin<&mut MyObject>, mut closure: F) -> cxx_qt::QMetaObjectConnectionGuard
+                    pub fn on_unsafe_property_changed<F: FnMut(core::pin::Pin<&mut qobject::MyObject>, ) + 'static>(self: core::pin::Pin<&mut qobject::MyObject>, mut closure: F) -> cxx_qt::QMetaObjectConnectionGuard
                     {
                         cxx_qt::QMetaObjectConnectionGuard::from(ffi::MyObject_connect_unsafe_property_changed(
                             self,
@@ -606,7 +606,7 @@ mod tests {
             parse_quote! {
                 impl cxx_qt::signalhandler::CxxQtSignalHandlerClosure for MyObjectCxxQtSignalClosureunsafePropertyChanged {
                     type Id = cxx::type_id!("::rust::cxxqtgen1::MyObjectCxxQtSignalHandlerunsafePropertyChanged");
-                    type FnType = dyn FnMut(core::pin::Pin<&mut MyObject>, );
+                    type FnType = dyn FnMut(core::pin::Pin<&mut qobject::MyObject>, );
                 }
             },
         );
@@ -621,7 +621,7 @@ mod tests {
             parse_quote! {
                 fn call_MyObject_signal_handler_unsafePropertyChanged(
                     handler: &mut cxx_qt::signalhandler::CxxQtSignalHandler<MyObjectCxxQtSignalClosureunsafePropertyChanged>,
-                    self_value: core::pin::Pin<&mut MyObject>,
+                    self_value: core::pin::Pin<&mut qobject::MyObject>,
                 ) {
                     handler.closure()(self_value, );
                 }