Merge branch 'main' into wrapper-shorthand

Author: Leon Matthes

.github/workflows/github-cxx-qt-tests.yml

@@ -290,7 +290,7 @@ jobs:
           - name: Ubuntu 24.04 (gcc) Qt6
             os: ubuntu-24.04
             qt_version: 6
-            aqt_version: '6.9.0'
+            aqt_version: '6.9.3'
             aqt_arch: 'linux_gcc_64'
             aqt_host: 'linux'
             cores: 4
@@ -334,10 +334,10 @@ jobs:
           - name: macOS 14 (clang) Qt6
             os: macos-14
             qt_version: 6
-            aqt_version: '6.9.0'
+            aqt_version: '6.9.3'
             aqt_arch: 'clang_64'
             aqt_host: 'mac'
-            dyld_framework_path: /Users/runner/work/cxx-qt/Qt/6.9.0/macos/lib
+            dyld_framework_path: /Users/runner/work/cxx-qt/Qt/6.9.3/macos/lib
             # https://doc.qt.io/qt-6.7/macos.html#target-platforms
             macosx_deployment_target: '13.0'
             cores: 3
@@ -394,7 +394,7 @@ jobs:
           - name: Windows 2022 (MSVC2022) Qt6 Debug
             os: windows-2022
             qt_version: 6
-            aqt_version: '6.9.0'
+            aqt_version: '6.9.3'
             aqt_arch: 'win64_msvc2022_64'
             aqt_host: 'windows'
             cores: 4

CHANGELOG.md

@@ -35,7 +35,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Support for `QMessageLogContext` and sending log messages to the Qt message handler.
 - Serde support for further types: `QByteArray`, `QSet`, `QStringList`, `QVector`, `QUrl`
 - Added `QEventLoop` to cxx-qt-lib-extras.
-- Add `QScopedMetaObjectConnectionGuard`, which is `QMetaObjectConnectionGuard` with a scoped lifetime. `QMetaObjectConnectionGuard` is now a type alias for `QScopedMetaObjectConnectionGuard<'static>`.
 - Support for setting Qt log message patterns with `q_set_message_pattern` and formatting log messages ith `q_format_log_message`.
 - Implement `IntoIterator` for `&QHash`, `&QList`, `&QMap`, `&QSet`, and `&QVector`.
 - Add `QByteArray:from_base64_encoding` and `QByteArray::to_base64`.

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

@@ -10,8 +10,10 @@ use syn::Result;
 
 use crate::{
     generator::{cfg::try_eval_attributes, GeneratedOpt},
+    naming::Name,
     parser::qenum::ParsedQEnum,
     writer::cpp::namespaced,
+    CppFragment,
 };
 
 use super::{qobject::GeneratedCppQObjectBlocks, utils::Indent};
@@ -22,7 +24,8 @@ fn generate_definition(qenum: &ParsedQEnum) -> String {
     let enum_values = qenum
         .variants
         .iter()
-        .map(ToString::to_string)
+        .enumerate()
+        .map(|(index, variant)| format!("{variant} = {index}"))
         .collect::<Vec<_>>()
         .join(",\n");
 
@@ -38,16 +41,14 @@ pub fn generate_declaration(
     includes: &mut BTreeSet<String>,
     opt: &GeneratedOpt,
 ) -> Result<String> {
+    let is_standalone = qenum.qobject.is_none();
     // Skip if the cfg attributes are not resolved to true
-    if !try_eval_attributes(opt.cfg_evaluator.as_ref(), &qenum.cfgs)? {
+    if !is_standalone || !try_eval_attributes(opt.cfg_evaluator.as_ref(), &qenum.cfgs)? {
         return Ok(String::new());
     }
 
-    let is_standalone = qenum.qobject.is_none();
-    if is_standalone {
-        // required for Q_NAMESPACE and Q_ENUM_NS if we're not on a QObject
-        includes.insert("#include <QtCore/QObject>".to_owned());
-    }
+    // required for Q_NAMESPACE and Q_ENUM_NS if we're not on a QObject
+    includes.insert("#include <QtCore/QObject>".to_owned());
 
     let enum_definition = generate_definition(qenum).indented(2);
     let enum_name = &qenum.name.cxx_unqualified();
@@ -56,19 +57,17 @@ pub fn generate_declaration(
         // The declaration must still include Q_NAMESPACE, as otherwise moc will complain.
         // This is redundant with `qnamespace!`, which is now only required if you want to specify
         // it as QML_ELEMENT.
-        &if is_standalone {
-            formatdoc! {r#"
+        &formatdoc! {r#"
                 Q_NAMESPACE
                 {enum_definition}
-                Q_ENUM_NS({enum_name}) "# }
-        } else {
-            enum_definition
+                Q_ENUM_NS({enum_name}) "#
         },
     ))
 }
 
 pub fn generate_on_qobject<'a>(
     qenums: impl Iterator<Item = &'a ParsedQEnum>,
+    qobject: &Name,
     opt: &GeneratedOpt,
 ) -> Result<GeneratedCppQObjectBlocks> {
     let mut generated = GeneratedCppQObjectBlocks::default();
@@ -79,26 +78,27 @@ pub fn generate_on_qobject<'a>(
             continue;
         }
 
-        let mut qualified_name = qenum.name.cxx_qualified();
         let enum_name = qenum.name.cxx_unqualified();
+        let mut qobject_name = qobject.cxx_qualified();
         // TODO: this is a workaround for cxx_qualified not returning a fully-qualified
         // identifier.
         // Once https://github.com/KDAB/cxx-qt/issues/619 is fixed, this can be removed.
-        if !qualified_name.starts_with("::") {
-            qualified_name.insert_str(0, "::");
+        if !qobject_name.starts_with("::") {
+            qobject_name.insert_str(0, "::");
         }
 
         generated.includes.insert("#include <cstdint>".to_owned());
         let enum_definition = generate_definition(qenum);
         generated.metaobjects.push(formatdoc! {r#"
-            #ifdef Q_MOC_RUN
             {enum_definition}
-              Q_ENUM({enum_name})
-            #else
-              using {enum_name} = {qualified_name};
-              Q_ENUM({enum_name})
-            #endif
-        "#, enum_definition = enum_definition.indented(2)});
+              Q_ENUM({enum_name})"#, enum_definition = enum_definition.indented(2)});
+
+        generated
+            .post_fragments
+            .push(CppFragment::Header(namespaced(
+                qenum.name.namespace().unwrap_or_default(),
+                &format!("using {enum_name} = {qobject_name}::{enum_name};",),
+            )));
     }
 
     Ok(generated)
@@ -132,7 +132,7 @@ mod tests {
         let opt = GeneratedOpt {
             cfg_evaluator: Box::new(CfgEvaluatorTest::default()),
         };
-        let generated = generate_on_qobject(qenums.iter(), &opt).unwrap();
+        let generated = generate_on_qobject(qenums.iter(), &Name::mock("MyObject"), &opt).unwrap();
 
         assert!(generated.methods.is_empty());
     }
@@ -151,26 +151,31 @@ mod tests {
         )
         .unwrap()];
 
-        let generated = generate_on_qobject(qenums.iter(), &GeneratedOpt::default()).unwrap();
+        let generated = generate_on_qobject(
+            qenums.iter(),
+            &Name::mock("MyObject"),
+            &GeneratedOpt::default(),
+        )
+        .unwrap();
         assert_eq!(generated.includes.len(), 1);
         assert!(generated.includes.contains("#include <cstdint>"));
         assert_eq!(generated.metaobjects.len(), 1);
         assert_str_eq!(
             indoc! {r#"
-                #ifdef Q_MOC_RUN
-                  enum class MyEnum : ::std::int32_t {
-                    A,
-                    B,
-                    C
-                  };
-                  Q_ENUM(MyEnum)
-                #else
-                  using MyEnum = ::MyEnum;
-                  Q_ENUM(MyEnum)
-                #endif
-            "#},
+              enum class MyEnum : ::std::int32_t {
+                A = 0,
+                B = 1,
+                C = 2
+              };
+              Q_ENUM(MyEnum)
+            "#}
+            .indented(2),
             generated.metaobjects[0],
         );
+        assert_eq!(
+            CppFragment::Header("using MyEnum = ::MyObject::MyEnum;".to_owned()),
+            generated.post_fragments[0]
+        );
         assert_eq!(generated.forward_declares.len(), 0);
     }
 }

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

@@ -34,6 +34,8 @@ pub struct GeneratedCppQObjectBlocks {
     pub forward_declares_namespaced: Vec<String>,
     /// List of fragments which are outside of the QObject namespace
     pub fragments: Vec<CppFragment>,
+    /// List of fragments which are outside of the QObject namespace and after the class
+    pub post_fragments: Vec<CppFragment>,
     /// Base class of the QObject
     pub base_classes: Vec<String>,
     /// List of Qt Meta Object items (eg Q_PROPERTY)
@@ -51,6 +53,7 @@ impl GeneratedCppQObjectBlocks {
         self.forward_declares_namespaced
             .append(&mut other.forward_declares_namespaced);
         self.fragments.append(&mut other.fragments);
+        self.post_fragments.append(&mut other.post_fragments);
         self.base_classes.append(&mut other.base_classes);
         self.metaobjects.append(&mut other.metaobjects);
         self.methods.append(&mut other.methods);
@@ -160,6 +163,7 @@ impl GeneratedCppQObject {
         )?);
         generated.blocks.append(&mut qenum::generate_on_qobject(
             structured_qobject.qenums.iter().cloned(),
+            &generated.name,
             opt,
         )?);
 

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

@@ -22,14 +22,12 @@ use crate::parser::cxxqtdata::ParsedCxxQtData;
 use crate::parser::{parameter::ParsedFunctionParameter, Parser};
 use proc_macro2::{Ident, TokenStream};
 use quote::quote;
-use syn::{parse_quote, Item, ItemMod, Path, Result};
+use syn::{parse_quote, ItemMod, Result};
 
 /// Representation of the generated Rust code for a QObject
 pub struct GeneratedRustBlocks {
     /// Module for the CXX bridge with passthrough items
     pub cxx_mod: ItemMod,
-    /// Any global extra items for the CXX bridge
-    pub cxx_mod_contents: Vec<Item>,
     /// Ident of the namespace of the QObject
     pub namespace: String,
     /// Rust fragments
@@ -93,9 +91,13 @@ impl GeneratedRustBlocks {
             #module
         };
 
+        let qenums = &parser.cxx_qt_data.qenums;
+        if !qenums.is_empty() {
+            fragments.extend(qenum::generate(qenums));
+        }
+
         Ok(GeneratedRustBlocks {
             cxx_mod,
-            cxx_mod_contents: qenum::generate_cxx_mod_contents(&parser.cxx_qt_data.qenums),
             namespace,
             fragments,
         })
@@ -211,7 +213,6 @@ mod tests {
 
         let rust = GeneratedRustBlocks::from(&parser).unwrap();
         assert!(rust.cxx_mod.content.is_none());
-        assert_eq!(rust.cxx_mod_contents.len(), 0);
         assert_eq!(rust.namespace, "");
         assert_eq!(rust.fragments.len(), 2);
     }
@@ -231,7 +232,6 @@ mod tests {
 
         let rust = GeneratedRustBlocks::from(&parser).unwrap();
         assert!(rust.cxx_mod.content.is_none());
-        assert_eq!(rust.cxx_mod_contents.len(), 0);
         assert_eq!(rust.namespace, "cxx_qt");
         assert_eq!(rust.fragments.len(), 2);
     }
@@ -251,7 +251,6 @@ mod tests {
 
         let rust = GeneratedRustBlocks::from(&parser).unwrap();
         assert!(rust.cxx_mod.content.is_none());
-        assert_eq!(rust.cxx_mod_contents.len(), 0);
         assert_eq!(rust.namespace, "");
         assert_eq!(rust.fragments.len(), 2);
     }