Constructor trait

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

@@ -0,0 +1,135 @@
+// SPDX-FileCopyrightText: 2023 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
+// SPDX-FileContributor: Leon Matthes <leon.matthes@kdab.com>
+//
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+use super::qobject::GeneratedCppQObjectBlocks;
+use crate::{
+    generator::cpp::{types::CppType, GeneratedCppQObject},
+    parser::{constructor::Constructor, cxxqtdata::ParsedCxxMappings},
+    CppFragment,
+};
+
+use indoc::formatdoc;
+use syn::{Result, Type};
+
+fn default_constructor(
+    qobject: &GeneratedCppQObject,
+    initializers: String,
+) -> GeneratedCppQObjectBlocks {
+    GeneratedCppQObjectBlocks {
+        methods: vec![CppFragment::Pair {
+            header: format!(
+                "explicit {class_name}(QObject* parent = nullptr);",
+                class_name = qobject.ident
+            ),
+            source: formatdoc!(
+                r#"
+            {class_name}::{class_name}(QObject* parent)
+              : {base_class}(parent)
+              , m_rustObj({namespace_internals}::createRs())
+              {initializers}
+            {{
+            }}
+            "#,
+                class_name = qobject.ident,
+                base_class = qobject.base_class,
+                namespace_internals = qobject.namespace_internals,
+            ),
+        }],
+        ..Default::default()
+    }
+}
+
+fn argument_names(arguments: &[Type]) -> Vec<String> {
+    arguments
+        .iter()
+        .enumerate()
+        .map(|(index, _)| format!("arg{index}"))
+        .collect()
+}
+
+fn expand_arguments(arguments: &[Type], cxx_mappings: &ParsedCxxMappings) -> Result<String> {
+    Ok(arguments
+        .iter()
+        .zip(argument_names(arguments).into_iter())
+        .map(|(ty, name)| {
+            CppType::from(ty, cxx_mappings).map(|ty| format!("{ty} {name}", ty = ty.as_cxx_ty()))
+        })
+        .collect::<Result<Vec<_>>>()?
+        .join(", "))
+}
+
+pub fn generate(
+    qobject: &GeneratedCppQObject,
+    constructors: &Vec<Constructor>,
+    member_initializers: &[String],
+    cxx_mappings: &ParsedCxxMappings,
+) -> Result<GeneratedCppQObjectBlocks> {
+    let initializers = member_initializers
+        .iter()
+        .map(|initializer| format!(", {initializer}"))
+        .collect::<Vec<_>>()
+        .join("\n");
+
+    if constructors.is_empty() {
+        return Ok(default_constructor(qobject, initializers));
+    }
+
+    let mut generated = GeneratedCppQObjectBlocks::default();
+
+    let class_name = qobject.ident.as_str();
+    let namespace_internals = &qobject.namespace_internals;
+    let base_class = &qobject.base_class;
+    for (index, constructor) in constructors.iter().enumerate() {
+        let argument_list = expand_arguments(&constructor.arguments, cxx_mappings)?;
+        let constructor_argument_names = argument_names(&constructor.arguments);
+
+        generated.methods.push(CppFragment::Pair {
+            header: format!("explicit {class_name}({argument_list});"),
+            source: formatdoc! {
+                r#"
+                {class_name}::{class_name}({argument_list})
+                    : {class_name}({namespace_internals}::routeArguments{index}({move_arguments}))
+                    {{ }}
+                "#,
+                move_arguments = constructor_argument_names.iter().map(|arg| format!("std::move({arg})")).collect::<Vec<_>>().join(", "),
+            },
+        });
+
+        let base_args = if let Some(base_args) = &constructor.base_arguments {
+            argument_names(base_args)
+                .into_iter()
+                .map(|arg| format!("std::move(args.baseArguments.{arg})"))
+                .collect::<Vec<_>>()
+                .join(", ")
+        } else {
+            "".to_string()
+        };
+        // For each constructor defined in CXX-Qt we need a pair of one public and one private
+        // constructor.
+        // The reason for this is that CXX-Qt needs to be able to route the list of raw arguments
+        // provided in C++ to a Plain-Old-Data type that contains the arguments already routed
+        // through Rust.
+        // This second constructor which takes the routed arguments is private, so that only CXX-Qt
+        // can use it.
+        generated.private_methods.push(CppFragment::Pair {
+            header: format!(
+                "explicit {class_name}({namespace_internals}::CxxQtConstructorArguments{index}&& args);"
+            ),
+            source: formatdoc! {
+                r#"
+                {class_name}::{class_name}({namespace_internals}::CxxQtConstructorArguments{index}&& args)
+                    : {base_class}({base_args})
+                    , m_rustObj({namespace_internals}::newRs{index}(std::move(args.newArguments)))
+                    {initializers}
+                    {{
+                        {namespace_internals}::initialize{index}(*this, std::move(args.initializeArguments));
+                    }}
+                "#,
+            },
+        })
+    }
+
+    Ok(generated)
+}

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

@@ -3,6 +3,7 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
+mod constructor;
 pub mod fragment;
 pub mod inherit;
 pub mod invokable;

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

@@ -5,7 +5,7 @@
 
 use crate::generator::{
     cpp::{
-        fragment::CppFragment, inherit, invokable::generate_cpp_invokables,
+        constructor, fragment::CppFragment, inherit, invokable::generate_cpp_invokables,
         property::generate_cpp_properties, signal::generate_cpp_signals, threading,
     },
     naming::{namespace::NamespaceName, qobject::QObjectName},
@@ -21,8 +21,10 @@ pub struct GeneratedCppQObjectBlocks {
     pub metaobjects: Vec<String>,
     /// List of public methods for the QObject
     pub methods: Vec<CppFragment>,
+    /// List of private methods for the QObject
+    pub private_methods: Vec<CppFragment>,
     /// List of members for the QObject
-    pub members: Vec<CppFragment>,
+    pub members: Vec<String>,
     /// List of deconstructor source
     pub deconstructors: Vec<String>,
 }
@@ -32,6 +34,7 @@ impl GeneratedCppQObjectBlocks {
         self.forward_declares.append(&mut other.forward_declares);
         self.metaobjects.append(&mut other.metaobjects);
         self.methods.append(&mut other.methods);
+        self.private_methods.append(&mut other.private_methods);
         self.members.append(&mut other.members);
         self.deconstructors.append(&mut other.deconstructors);
     }
@@ -128,12 +131,23 @@ impl GeneratedCppQObject {
             cxx_mappings,
         )?);
 
+        let mut member_initializers = if qobject.locking {
+            vec!["m_rustObjMutex(::std::make_shared<::std::recursive_mutex>())".to_string()]
+        } else {
+            vec![]
+        };
         // If this type has threading enabled then add generation
         if qobject.threading {
-            generated
-                .blocks
-                .append(&mut threading::generate(&qobject_idents)?);
+            let (initializer, mut blocks) = threading::generate(&qobject_idents)?;
+            generated.blocks.append(&mut blocks);
+            member_initializers.push(initializer);
         }
+        generated.blocks.append(&mut constructor::generate(
+            &generated,
+            &qobject.constructors,
+            &member_initializers,
+            cxx_mappings,
+        )?);
 
         Ok(generated)
     }

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

@@ -10,7 +10,7 @@ use crate::generator::{
 use indoc::formatdoc;
 use syn::Result;
 
-pub fn generate(qobject_idents: &QObjectName) -> Result<GeneratedCppQObjectBlocks> {
+pub fn generate(qobject_idents: &QObjectName) -> Result<(String, GeneratedCppQObjectBlocks)> {
     let mut result = GeneratedCppQObjectBlocks::default();
 
     let ident = &qobject_idents.cpp_class.cpp;
@@ -27,10 +27,9 @@ pub fn generate(qobject_idents: &QObjectName) -> Result<GeneratedCppQObjectBlock
         static_assert(sizeof({cxx_qt_thread_ident}) == sizeof(::std::size_t[4]), "unexpected size");
         "#
     }));
-    result.members.push(CppFragment::Pair {
-        header: format!("::std::shared_ptr<::rust::cxxqtlib1::CxxQtGuardedPointer<{ident}>> m_cxxQtThreadObj;"),
-        source: format!(", m_cxxQtThreadObj(::std::make_shared<::rust::cxxqtlib1::CxxQtGuardedPointer<{ident}>>(this))"),
-    });
+    result.members.push(format!(
+        "::std::shared_ptr<::rust::cxxqtlib1::CxxQtGuardedPointer<{ident}>> m_cxxQtThreadObj;"
+    ));
     result.methods.push(CppFragment::Pair {
         header: format!("{cxx_qt_thread_ident} qtThread() const;"),
         source: formatdoc! {
@@ -50,7 +49,9 @@ pub fn generate(qobject_idents: &QObjectName) -> Result<GeneratedCppQObjectBlock
         "#
     });
 
-    Ok(result)
+    let member_initializer = format!("m_cxxQtThreadObj(::std::make_shared<::rust::cxxqtlib1::CxxQtGuardedPointer<{ident}>>(this))");
+
+    Ok((member_initializer, result))
 }
 
 #[cfg(test)]
@@ -65,7 +66,7 @@ mod tests {
     fn test_generate_cpp_threading() {
         let qobject_idents = create_qobjectname();
 
-        let generated = generate(&qobject_idents).unwrap();
+        let (initializer, generated) = generate(&qobject_idents).unwrap();
 
         // forward declares
         assert_eq!(generated.forward_declares.len(), 1);
@@ -77,19 +78,13 @@ mod tests {
 
         // members
         assert_eq!(generated.members.len(), 1);
-
-        let (header, source) = if let CppFragment::Pair { header, source } = &generated.members[0] {
-            (header, source)
-        } else {
-            panic!("Expected pair")
-        };
         assert_str_eq!(
-            header,
+            &generated.members[0],
             "::std::shared_ptr<::rust::cxxqtlib1::CxxQtGuardedPointer<MyObject>> m_cxxQtThreadObj;"
         );
         assert_str_eq!(
-            source,
-            ", m_cxxQtThreadObj(::std::make_shared<::rust::cxxqtlib1::CxxQtGuardedPointer<MyObject>>(this))"
+            initializer,
+            "m_cxxQtThreadObj(::std::make_shared<::rust::cxxqtlib1::CxxQtGuardedPointer<MyObject>>(this))"
         );
 
         // methods