cxx-qt-gen: move headers to cxx-qt crate

CHANGELOG.md

@@ -27,6 +27,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 
 - `VCPKG` is now set to off by default and packages are only built in release mode in the cache
+- Connection now return a `QMetaObjectConnectionGuard` and `QMetaObjectConnection` is a separate type
+- Internal `cxx-qt` headers have moved to the namespace `cxxqt1` and the folder `cxx-qt`
+- `cxx-qt-gen` now does not generate code requiring `cxx-qt-lib`, this allows for `cxx-qt-lib` to be optional
 
 ### Fixed
 

book/src/bridge/extern_rustqt.md

@@ -225,13 +225,14 @@ using the signal name `<property>Changed` with no parameters.
 {{#include ../../../examples/qml_features/rust/src/signals.rs:book_signals_connect}}
 ```
 
-Each connection returns a [`QMetaObject::Connection`](https://doc.qt.io/qt-6/qmetaobject-connection.html) which is used to manage the connection.
+Each connection returns a `QMetaObjectConnectionGuard` which is used to manage the [`QMetaObject::Connection`](https://doc.qt.io/qt-6/qmetaobject-connection.html) connection.
 
 Note that the `QMetaObjectConnection` returned by CXX-Qt behaves a bit different from the Qt C++ implementation.
 
-When the `QMetaObjectConnection` is dropped, it automatically disconnects the connection, similar to how a C++ `std::unique_ptr` or Rusts `Box` behaves.
-If you don't want to store the `QMetaObjectConnection`, call `release`, which will drop the object without disconnecting.
-In this case, it is no longer possible to disconnect later.
+When the `QMetaObjectConnectionGuard` is dropped, it automatically disconnects the connection, similar to how a C++ `std::unique_ptr` or Rusts `Box` behaves.
+If you don't want to store the `QMetaObjectConnectionGuard`, call `release`, which will drop the object without disconnecting and return the internal `QMetaObjecConnection`.
+
+> Note that the `QMetaObjectConnection` has a `disconnect` which can be called manually later
 
 ```rust,ignore,noplayground
 {{#include ../../../examples/qml_features/rust/src/signals.rs:book_signals_disconnect}}

crates/cxx-qt-build/Cargo.toml

@@ -16,6 +16,7 @@ repository.workspace = true
 cc.workspace = true
 convert_case.workspace = true
 cxx-gen.workspace = true
+cxx-qt.workspace = true
 cxx-qt-lib-headers.workspace = true
 cxx-qt-gen.workspace = true
 proc-macro2.workspace = true

crates/cxx-qt-build/src/lib.rs

@@ -445,7 +445,7 @@ impl CxxQtBuilder {
         qtbuild.cargo_link_libraries(&mut self.cc_builder);
 
         // Write cxx-qt-gen, cxx-qt-lib and cxx headers
-        cxx_qt_gen::write_headers(format!("{header_root}/cxx-qt-common"));
+        cxx_qt::write_headers(format!("{header_root}/cxx-qt"));
         cxx_qt_lib_headers::write_headers(format!("{header_root}/cxx-qt-lib"));
         std::fs::create_dir_all(format!("{header_root}/rust"))
             .expect("Could not create cxx header directory");
@@ -488,7 +488,7 @@ impl CxxQtBuilder {
         }
 
         for builder in [&mut self.cc_builder, &mut cc_builder_whole_archive] {
-            // Note, ensure our settings stay in sync across cxx-qt-build and cxx-qt-lib
+            // Note, ensure our settings stay in sync across cxx-qt, cxx-qt-build, and cxx-qt-lib
             builder.cpp(true);
             // MSVC
             builder.flag_if_supported("/std:c++17");

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

@@ -27,7 +27,7 @@ fn default_constructor(
                 r#"
             {class_name}::{class_name}(QObject* parent)
               : {base_class}(parent)
-              , ::rust::cxxqtlib1::CxxQtType<{rust_obj}>(::{namespace_internals}::createRs()){initializers}
+              , ::rust::cxxqt1::CxxQtType<{rust_obj}>(::{namespace_internals}::createRs()){initializers}
             {{ }}
             "#,
                 class_name = qobject.ident,
@@ -118,7 +118,7 @@ pub fn generate(
                 r#"
                 {class_name}::{class_name}(::{namespace_internals}::CxxQtConstructorArguments{index}&& args)
                   : {base_class}({base_args})
-                  , ::rust::cxxqtlib1::CxxQtType<{rust_obj}>(::{namespace_internals}::newRs{index}(::std::move(args.new_))){initializers}
+                  , ::rust::cxxqt1::CxxQtType<{rust_obj}>(::{namespace_internals}::newRs{index}(::std::move(args.new_))){initializers}
                 {{
                   ::{namespace_internals}::initialize{index}(*this, ::std::move(args.initialize));
                 }}
@@ -184,7 +184,7 @@ mod tests {
                     "
                     MyObject::MyObject(QObject* parent)
                       : BaseClass(parent)
-                      , ::rust::cxxqtlib1::CxxQtType<MyObjectRust>(::rust::createRs())
+                      , ::rust::cxxqt1::CxxQtType<MyObjectRust>(::rust::createRs())
                       , member1(1)
                       , member2{{ 2 }}
                     {{ }}
@@ -214,7 +214,7 @@ mod tests {
                     "
                     MyObject::MyObject(QObject* parent)
                       : BaseClass(parent)
-                      , ::rust::cxxqtlib1::CxxQtType<MyObjectRust>(::rust::createRs())
+                      , ::rust::cxxqt1::CxxQtType<MyObjectRust>(::rust::createRs())
                     {{ }}
                     "
                 ),
@@ -245,7 +245,7 @@ mod tests {
                     "
                     MyObject::MyObject(::rust::CxxQtConstructorArguments0&& args)
                       : BaseClass()
-                      , ::rust::cxxqtlib1::CxxQtType<MyObjectRust>(::rust::newRs0(::std::move(args.new_)))
+                      , ::rust::cxxqt1::CxxQtType<MyObjectRust>(::rust::newRs0(::std::move(args.new_)))
                     {{
                       ::rust::initialize0(*this, ::std::move(args.initialize));
                     }}
@@ -308,7 +308,7 @@ mod tests {
                     "
                     MyObject::MyObject(::rust::CxxQtConstructorArguments0&& args)
                       : BaseClass(::std::move(args.base.arg0), ::std::move(args.base.arg1))
-                      , ::rust::cxxqtlib1::CxxQtType<MyObjectRust>(::rust::newRs0(::std::move(args.new_)))
+                      , ::rust::cxxqt1::CxxQtType<MyObjectRust>(::rust::newRs0(::std::move(args.new_)))
                       , initializer
                     {{
                       ::rust::initialize0(*this, ::std::move(args.initialize));
@@ -378,7 +378,7 @@ mod tests {
                         "
                         MyObject::MyObject(::rust::CxxQtConstructorArguments0&& args)
                           : BaseClass()
-                          , ::rust::cxxqtlib1::CxxQtType<MyObjectRust>(::rust::newRs0(::std::move(args.new_)))
+                          , ::rust::cxxqt1::CxxQtType<MyObjectRust>(::rust::newRs0(::std::move(args.new_)))
                           , initializer
                         {{
                           ::rust::initialize0(*this, ::std::move(args.initialize));
@@ -393,7 +393,7 @@ mod tests {
                         "
                         MyObject::MyObject(::rust::CxxQtConstructorArguments1&& args)
                           : BaseClass(::std::move(args.base.arg0))
-                          , ::rust::cxxqtlib1::CxxQtType<MyObjectRust>(::rust::newRs1(::std::move(args.new_)))
+                          , ::rust::cxxqt1::CxxQtType<MyObjectRust>(::rust::newRs1(::std::move(args.new_)))
                           , initializer
                         {{
                           ::rust::initialize1(*this, ::std::move(args.initialize));

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

@@ -13,11 +13,11 @@ pub fn generate(qobject_idents: &QObjectName) -> Result<GeneratedCppQObjectBlock
 
     result
         .includes
-        .insert("#include <cxx-qt-common/cxxqt_type.h>".to_owned());
+        .insert("#include <cxx-qt/cxxqt_type.h>".to_owned());
 
     result
         .base_classes
-        .push(format!("::rust::cxxqtlib1::CxxQtType<{rust_ident}>"));
+        .push(format!("::rust::cxxqt1::CxxQtType<{rust_ident}>"));
 
     Ok(result)
 }
@@ -38,13 +38,13 @@ mod tests {
         assert_eq!(generated.includes.len(), 1);
         assert!(generated
             .includes
-            .contains("#include <cxx-qt-common/cxxqt_type.h>"));
+            .contains("#include <cxx-qt/cxxqt_type.h>"));
 
         // base class
         assert_eq!(generated.base_classes.len(), 1);
         assert_eq!(
             generated.base_classes[0],
-            "::rust::cxxqtlib1::CxxQtType<MyObjectRust>"
+            "::rust::cxxqt1::CxxQtType<MyObjectRust>"
         );
     }
 }

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

@@ -34,7 +34,7 @@ pub fn generate(
             // Ensure that we include MaybeLockGuard<T> that is used in multiple places
             block
                 .includes
-                .insert("#include <cxx-qt-common/cxxqt_maybelockguard.h>".to_owned());
+                .insert("#include <cxx-qt/cxxqt_maybelockguard.h>".to_owned());
             block.forward_declares = data.forward_declares;
             block.fragments = data.fragments;
             debug_assert!(data.methods.is_empty());

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

@@ -11,13 +11,13 @@ pub fn generate() -> Result<(String, GeneratedCppQObjectBlocks)> {
 
     result
         .includes
-        .insert("#include <cxx-qt-common/cxxqt_locking.h>".to_owned());
+        .insert("#include <cxx-qt/cxxqt_locking.h>".to_owned());
 
     result
         .base_classes
-        .push("::rust::cxxqtlib1::CxxQtLocking".to_owned());
+        .push("::rust::cxxqt1::CxxQtLocking".to_owned());
 
-    let class_initializer = "::rust::cxxqtlib1::CxxQtLocking()".to_owned();
+    let class_initializer = "::rust::cxxqt1::CxxQtLocking()".to_owned();
 
     Ok((class_initializer, result))
 }
@@ -31,16 +31,16 @@ mod tests {
         let (initializer, generated) = generate().unwrap();
 
         // initializer
-        assert_eq!(initializer, "::rust::cxxqtlib1::CxxQtLocking()");
+        assert_eq!(initializer, "::rust::cxxqt1::CxxQtLocking()");
 
         // includes
         assert_eq!(generated.includes.len(), 1);
         assert!(generated
             .includes
-            .contains("#include <cxx-qt-common/cxxqt_locking.h>"));
+            .contains("#include <cxx-qt/cxxqt_locking.h>"));
 
         // base class
         assert_eq!(generated.base_classes.len(), 1);
-        assert_eq!(generated.base_classes[0], "::rust::cxxqtlib1::CxxQtLocking");
+        assert_eq!(generated.base_classes[0], "::rust::cxxqt1::CxxQtLocking");
     }
 }

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

@@ -113,7 +113,7 @@ pub fn generate_cpp_methods(
                     {return_cxx_ty}
                     {qobject_ident}::{ident}({parameter_types}){is_const}
                     {{
-                        const ::rust::cxxqtlib1::MaybeLockGuard<{qobject_ident}> guard(*this);
+                        const ::rust::cxxqt1::MaybeLockGuard<{qobject_ident}> guard(*this);
                         {body};
                     }}
                     "#,
@@ -246,7 +246,7 @@ mod tests {
             void
             MyObject::voidInvokable() const
             {
-                const ::rust::cxxqtlib1::MaybeLockGuard<MyObject> guard(*this);
+                const ::rust::cxxqt1::MaybeLockGuard<MyObject> guard(*this);
                 voidInvokableWrapper();
             }
             "#}
@@ -267,7 +267,7 @@ mod tests {
             ::std::int32_t
             MyObject::trivialInvokable(::std::int32_t param) const
             {
-                const ::rust::cxxqtlib1::MaybeLockGuard<MyObject> guard(*this);
+                const ::rust::cxxqt1::MaybeLockGuard<MyObject> guard(*this);
                 return trivialInvokableWrapper(param);
             }
             "#}
@@ -288,7 +288,7 @@ mod tests {
             ::std::unique_ptr<QColor>
             MyObject::opaqueInvokable(QColor const& param)
             {
-                const ::rust::cxxqtlib1::MaybeLockGuard<MyObject> guard(*this);
+                const ::rust::cxxqt1::MaybeLockGuard<MyObject> guard(*this);
                 return opaqueInvokableWrapper(param);
             }
             "#}
@@ -309,7 +309,7 @@ mod tests {
             ::std::int32_t
             MyObject::specifiersInvokable(::std::int32_t param) const
             {
-                const ::rust::cxxqtlib1::MaybeLockGuard<MyObject> guard(*this);
+                const ::rust::cxxqt1::MaybeLockGuard<MyObject> guard(*this);
                 return specifiersInvokableWrapper(param);
             }
             "#}
@@ -327,7 +327,7 @@ mod tests {
             void
             MyObject::cppMethod() const
             {
-                const ::rust::cxxqtlib1::MaybeLockGuard<MyObject> guard(*this);
+                const ::rust::cxxqt1::MaybeLockGuard<MyObject> guard(*this);
                 cppMethodWrapper();
             }
             "#}
@@ -418,7 +418,7 @@ mod tests {
             B2
             MyObject::trivialInvokable(A1 param) const
             {
-                const ::rust::cxxqtlib1::MaybeLockGuard<MyObject> guard(*this);
+                const ::rust::cxxqt1::MaybeLockGuard<MyObject> guard(*this);
                 return trivialInvokableWrapper(param);
             }
             "#}

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

@@ -17,7 +17,7 @@ pub fn generate(idents: &QPropertyName, qobject_ident: &str, return_cxx_ty: &str
             {return_cxx_ty} const&
             {qobject_ident}::{ident_getter}() const
             {{
-                const ::rust::cxxqtlib1::MaybeLockGuard<{qobject_ident}> guard(*this);
+                const ::rust::cxxqt1::MaybeLockGuard<{qobject_ident}> guard(*this);
                 return {ident_getter_wrapper}();
             }}
             "#,