cxx-qt-gen: add tests for qml_singleton and qml_uncreatable

Related to #25

Author: ahayzen-kdab

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

@@ -37,11 +37,11 @@ impl GeneratedCppQObjectBlocks {
                 "Q_CLASSINFO(\"QML.Element\", \"{}\")",
                 qml_metadata.name
             ));
-            // TODO untested
+
             if qml_metadata.uncreatable {
                 qml_specifiers.push("Q_CLASSINFO(\"QML.Creatable\", \"false\")".to_owned());
             }
-            // TODO untested
+
             if qml_metadata.singleton {
                 qml_specifiers.push("QML_SINGLETON".to_owned());
             }
@@ -142,6 +142,7 @@ mod tests {
         assert_eq!(cpp.cxx_qt_thread_ident, "MyObjectCxxQtThread");
         assert_eq!(cpp.namespace_internals, "cxx_qt_my_object");
         assert_eq!(cpp.base_class, "QObject");
+        assert_eq!(cpp.blocks.metaobjects.len(), 0);
     }
 
     #[test]
@@ -162,5 +163,83 @@ mod tests {
         .unwrap();
         assert_eq!(cpp.namespace_internals, "cxx_qt::cxx_qt_my_object");
         assert_eq!(cpp.base_class, "QStringListModel");
+        assert_eq!(cpp.blocks.metaobjects.len(), 0);
+    }
+
+    #[test]
+    fn test_generated_cpp_qobject_named() {
+        let module: ItemMod = tokens_to_syn(quote! {
+            #[cxx_qt::bridge(namespace = "cxx_qt")]
+            mod ffi {
+                #[cxx_qt::qobject(qml_uri = "com.kdab", qml_version = "1.0", qml_name = "MyQmlElement")]
+                struct MyNamedObject;
+            }
+        });
+        let parser = Parser::from(module).unwrap();
+
+        let cpp = GeneratedCppQObject::from(
+            parser.cxx_qt_data.qobjects.values().next().unwrap(),
+            &ParsedCxxMappings::default(),
+        )
+        .unwrap();
+        assert_eq!(cpp.ident, "MyNamedObject");
+        assert_eq!(cpp.blocks.metaobjects.len(), 1);
+        assert_eq!(
+            cpp.blocks.metaobjects[0],
+            "Q_CLASSINFO(\"QML.Element\", \"MyQmlElement\")"
+        );
+    }
+
+    #[test]
+    fn test_generated_cpp_qobject_singleton() {
+        let module: ItemMod = tokens_to_syn(quote! {
+            #[cxx_qt::bridge(namespace = "cxx_qt")]
+            mod ffi {
+                #[cxx_qt::qobject(qml_uri = "com.kdab", qml_version = "1.0", qml_singleton)]
+                struct MyObject;
+            }
+        });
+        let parser = Parser::from(module).unwrap();
+
+        let cpp = GeneratedCppQObject::from(
+            parser.cxx_qt_data.qobjects.values().next().unwrap(),
+            &ParsedCxxMappings::default(),
+        )
+        .unwrap();
+        assert_eq!(cpp.ident, "MyObject");
+        assert_eq!(cpp.blocks.metaobjects.len(), 2);
+        assert_eq!(
+            cpp.blocks.metaobjects[0],
+            "Q_CLASSINFO(\"QML.Element\", \"MyObject\")"
+        );
+        assert_eq!(cpp.blocks.metaobjects[1], "QML_SINGLETON");
+    }
+
+    #[test]
+    fn test_generated_cpp_qobject_uncreatable() {
+        let module: ItemMod = tokens_to_syn(quote! {
+            #[cxx_qt::bridge(namespace = "cxx_qt")]
+            mod ffi {
+                #[cxx_qt::qobject(qml_uri = "com.kdab", qml_version = "1.0", qml_uncreatable)]
+                struct MyObject;
+            }
+        });
+        let parser = Parser::from(module).unwrap();
+
+        let cpp = GeneratedCppQObject::from(
+            parser.cxx_qt_data.qobjects.values().next().unwrap(),
+            &ParsedCxxMappings::default(),
+        )
+        .unwrap();
+        assert_eq!(cpp.ident, "MyObject");
+        assert_eq!(cpp.blocks.metaobjects.len(), 2);
+        assert_eq!(
+            cpp.blocks.metaobjects[0],
+            "Q_CLASSINFO(\"QML.Element\", \"MyObject\")"
+        );
+        assert_eq!(
+            cpp.blocks.metaobjects[1],
+            "Q_CLASSINFO(\"QML.Creatable\", \"false\")"
+        );
     }
 }

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

@@ -97,6 +97,24 @@ impl GeneratedRustQObject {
                 .append(&mut generate_rust_signals(signals_enum, &qobject_idents)?);
         }
 
+        // If this type is a singleton then we need to add an include
+        if let Some(qml_metadata) = &qobject.qml_metadata {
+            if qml_metadata.singleton {
+                let fragment = RustFragmentPair {
+                    cxx_bridge: vec![quote! {
+                        unsafe extern "C++" {
+                            include!(<QtQml/QQmlEngine>);
+                        }
+                    }],
+                    implementation: vec![],
+                };
+                generated
+                    .blocks
+                    .cxx_mod_contents
+                    .append(&mut fragment.cxx_bridge_as_items()?);
+            }
+        }
+
         Ok(generated)
     }
 }
@@ -164,7 +182,7 @@ mod tests {
     use super::*;
 
     use crate::parser::Parser;
-    use crate::tests::tokens_to_syn;
+    use crate::tests::{assert_tokens_eq, tokens_to_syn};
     use syn::ItemMod;
 
     #[test]
@@ -212,4 +230,46 @@ mod tests {
         assert_eq!(rust.namespace_internals, "cxx_qt::cxx_qt_my_object");
         assert_eq!(rust.rust_struct_ident, "MyObject");
     }
+
+    #[test]
+    fn test_generated_rust_qobject_blocks_singleton() {
+        let module: ItemMod = tokens_to_syn(quote! {
+            #[cxx_qt::bridge(namespace = "cxx_qt")]
+            mod ffi {
+                #[cxx_qt::qobject(qml_uri = "com.kdab", qml_version = "1.0", qml_singleton)]
+                struct MyObject;
+            }
+        });
+        let parser = Parser::from(module).unwrap();
+
+        let rust = GeneratedRustQObject::from(parser.cxx_qt_data.qobjects.values().next().unwrap())
+            .unwrap();
+        assert_eq!(rust.blocks.cxx_mod_contents.len(), 3);
+        assert_tokens_eq(
+            &rust.blocks.cxx_mod_contents[0],
+            quote! {
+                unsafe extern "C++" {
+                    #[cxx_name = "MyObject"]
+                    type MyObjectQt;
+                }
+            },
+        );
+        assert_tokens_eq(
+            &rust.blocks.cxx_mod_contents[1],
+            quote! {
+                extern "Rust" {
+                    #[cxx_name = "MyObjectRust"]
+                    type MyObject;
+                }
+            },
+        );
+        assert_tokens_eq(
+            &rust.blocks.cxx_mod_contents[2],
+            quote! {
+                unsafe extern "C++" {
+                    include!(<QtQml/QQmlEngine>);
+                }
+            },
+        );
+    }
 }

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

@@ -461,6 +461,46 @@ pub mod tests {
         );
     }
 
+    #[test]
+    fn test_qml_metadata_singleton() {
+        let item: ItemStruct = tokens_to_syn(quote! {
+            #[cxx_qt::qobject(qml_uri = "foo.bar", qml_version = "1", qml_singleton)]
+            struct MyObject;
+        });
+        let qobject = ParsedQObject::from_struct(&item, 0).unwrap();
+        assert_eq!(
+            qobject.qml_metadata,
+            Some(QmlElementMetadata {
+                uri: "foo.bar".to_owned(),
+                name: "MyObject".to_owned(),
+                version_major: 1,
+                version_minor: 0,
+                uncreatable: false,
+                singleton: true,
+            })
+        );
+    }
+
+    #[test]
+    fn test_qml_metadata_uncreatable() {
+        let item: ItemStruct = tokens_to_syn(quote! {
+            #[cxx_qt::qobject(qml_uri = "foo.bar", qml_version = "1", qml_uncreatable)]
+            struct MyObject;
+        });
+        let qobject = ParsedQObject::from_struct(&item, 0).unwrap();
+        assert_eq!(
+            qobject.qml_metadata,
+            Some(QmlElementMetadata {
+                uri: "foo.bar".to_owned(),
+                name: "MyObject".to_owned(),
+                version_major: 1,
+                version_minor: 0,
+                uncreatable: true,
+                singleton: false,
+            })
+        );
+    }
+
     #[test]
     fn test_qml_metadata_no_version() {
         let item: ItemStruct = tokens_to_syn(quote! {