Add support for new QProperty flags (Reset, Constant, Required, Final)

Author: BenFordTytherington

CHANGELOG.md

@@ -27,6 +27,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Serde support for `QString` (requires "serde" feature on cxx-qt-lib)
 - A new QuickControls module, which exposes `QQuickStyle`. This module is enabled by default and is behind the `qt_quickcontrols` feature.
 - Add support for specifying read write and notify in qproperty macro, including support for custom user defined functions
+- Add support for the constant, required, reset and final flags in the qproperty macro
 
 ### Changed
 

book/src/bridge/extern_rustqt.md

@@ -132,22 +132,41 @@ Where `<Property>` is the name of the property.
 These setters and getters assure that the changed signal is emitted every time the property is edited.
 
 It is also possible to specify custom getters, setters and notify signals, using flags passed like so:
-`#[qproperty(TYPE, NAME, read = myGetter, write = mySetter, notify = myOnChanged)]`
+`#[qproperty(TYPE, NAME, READ = myGetter, WRITE = mySetter, NOTIFY = myOnChanged)]`
+> Note: the key for the flags use all capitals like in the Qt version of qproperty
 
 > Note: currently the rust name must be in camel case or specified like `#[cxx_name = "my_getter"]` if not
 
 It is also possible to use any combination of custom functions or omit them entirely, but if flags are specified, read must be included as all properties need to be able to be read.
 
-Using the read flag will cause CXX-Qt to generate a getter function with an automatic name based off the property. e.g. `#[qproperty(i32, num, read)]` will have a getter function generated called get_num in Rust, and getNum in C++.
+Using the read flag will cause CXX-Qt to generate a getter function with an automatic name based off the property. e.g. `#[qproperty(i32, num, READ)]` will have a getter function generated called get_num in Rust, and getNum in C++.
 
 If a custom function is specified, an implementation both in qobject::MyObject and and export in the bridge is expected.
 
 ### Examples
 
-- `#[qproperty(TYPE, NAME, read)]` A read only prop
-- `#[qproperty(TYPE, NAME, read = myGetter, write, notify)]` custom getter provided but will generate setter and on-changed
-- `#[qproperty(TYPE, NAME)]` is syntactic sugar for `#[qproperty(TYPE, NAME, read, write, notify)]`
-- `#[qproperty(TYPE, NAME, write)]` is an error as read was not explicitly passed
+- `#[qproperty(TYPE, NAME, READ)]` A read only property
+- `#[qproperty(TYPE, NAME, READ = myGetter, WRITE, NOTIFY)]` custom getter provided, but will generate setter and on-changed
+- `#[qproperty(TYPE, NAME)]` is shorthand for `#[qproperty(TYPE, NAME, READ, WRITE, NOTIFY)]`
+- `#[qproperty(TYPE, NAME, WRITE)]` is an error as read was not explicitly passed
+
+### Available Flags
+
+- `READ` or `READ = my_getter`
+  - Specifies that the property should be readable (*always required if flags are passed*), with optional user defined getter
+- `WRITE` or `WRITE = my_setter`
+  - Specifies that the property should be writeable, with optional user defined setter
+- `NOTIFY` or `NOTIFY = my_on_changed`
+  - Specifies that the property should emit a notify signal on change, with optional user defined signal name
+- `CONSTANT`
+  - Specifies that the property should be constant (implication is that the getter returns the same value every time for that particular instance)
+  - __`CONSTANT` is not available for properties which use `WRITE` or `NOTIFY` and will not compile__
+- `REQUIRED`
+  - Specifies that the property must be set by a user of the class, useful in QML as the class cannot be instantiated unless the property has been set
+- `FINAL`
+  - Specifies that the property will not be overriden by a derived class
+- `RESET = my_reset`
+  - Specifies a function to reset the property to a default value, user function __must__ be provided or it will not compile
 
 ## Methods
 

book/src/getting-started/2-our-first-cxx-qt-module.md

@@ -176,6 +176,8 @@ Also, we can't move the `QObject`, which is why it is behind a Rust [`Pin`](http
 
 CXX-Qt will generate getters and setters for all properties of our `struct`.
 That's where the `number()` and `set_number()` functions used by `increment_number()` come from.
+See the [`QProperty` section](../bridge/extern_rustqt.md#properties) for details on user defined properties.
+
 For more details on what you can do with the `QObject` from Rust and what functions CXX-Qt will generate for you, take a look at the [`QObject` page](../concepts/generated_qobject.md).
 
 And that's it. We've defined our first `QObject` subclass in Rust. That wasn't so hard, was it?

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

@@ -4,9 +4,10 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
 use crate::generator::naming::property::QPropertyNames;
+use crate::parser::property::QPropertyFlags;
 
 /// Generate the metaobject line for a given property
-pub fn generate(idents: &QPropertyNames, cxx_ty: &str) -> String {
+pub fn generate(idents: &QPropertyNames, flags: &QPropertyFlags, cxx_ty: &str) -> String {
     let mut parts = vec![format!(
         "READ {ident_getter}",
         ident_getter = idents.getter.cxx_unqualified()
@@ -20,6 +21,22 @@ pub fn generate(idents: &QPropertyNames, cxx_ty: &str) -> String {
         parts.push(format!("NOTIFY {}", notify.cxx_unqualified()));
     }
 
+    if let Some(reset) = &idents.reset {
+        parts.push(format!("RESET {}", reset.cxx_unqualified()));
+    }
+
+    if flags.constant {
+        parts.push(String::from("CONSTANT"))
+    }
+
+    if flags.required {
+        parts.push(String::from("REQUIRED"))
+    }
+
+    if flags.is_final {
+        parts.push(String::from("FINAL"))
+    }
+
     format!(
         "Q_PROPERTY({ty} {ident} {meta_parts})",
         ty = cxx_ty,

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

@@ -31,7 +31,9 @@ pub fn generate_cpp_properties(
         let idents = QPropertyNames::from(property);
         let cxx_ty = syn_type_to_cpp_type(&property.ty, type_names)?;
 
-        generated.metaobjects.push(meta::generate(&idents, &cxx_ty));
+        generated
+            .metaobjects
+            .push(meta::generate(&idents, &property.flags, &cxx_ty));
 
         if let Some(getter) = getter::generate(&idents, &qobject_ident, &cxx_ty) {
             generated.methods.push(getter);
@@ -76,20 +78,25 @@ mod tests {
     use quote::format_ident;
     use syn::{parse_quote, ItemStruct};
 
-    #[test]
-    fn test_custom_setter() {
-        let mut input: ItemStruct = parse_quote! {
-            #[qproperty(i32, num, read, write = mySetter)]
-            struct MyStruct;
-        };
+    fn setup_generated(input: &mut ItemStruct) -> Result<GeneratedCppQObjectBlocks> {
         let property = ParsedQProperty::parse(input.attrs.remove(0)).unwrap();
 
         let properties = vec![property];
 
         let qobject_idents = create_qobjectname();
 
         let type_names = TypeNames::mock();
-        let generated = generate_cpp_properties(&properties, &qobject_idents, &type_names).unwrap();
+        generate_cpp_properties(&properties, &qobject_idents, &type_names)
+    }
+
+    #[test]
+    fn test_custom_setter() {
+        let mut input: ItemStruct = parse_quote! {
+            #[qproperty(i32, num, READ, WRITE = mySetter)]
+            struct MyStruct;
+        };
+
+        let generated = setup_generated(&mut input).unwrap();
 
         assert_eq!(generated.metaobjects.len(), 1);
         assert_str_eq!(
@@ -119,10 +126,39 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_reset() {
+        let mut input: ItemStruct = parse_quote! {
+            #[qproperty(i32, num, READ, WRITE = mySetter, RESET = my_resetter)]
+            struct MyStruct;
+        };
+
+        let generated = setup_generated(&mut input).unwrap();
+
+        assert_str_eq!(
+            generated.metaobjects[0],
+            "Q_PROPERTY(::std::int32_t num READ getNum WRITE mySetter RESET my_resetter)"
+        );
+    }
+
+    #[test]
+    fn test_constant_and_required() {
+        let mut input: ItemStruct = parse_quote! {
+            #[qproperty(i32, num, READ, CONSTANT, REQUIRED)]
+            struct MyStruct;
+        };
+        let generated = setup_generated(&mut input).unwrap();
+
+        assert_str_eq!(
+            generated.metaobjects[0],
+            "Q_PROPERTY(::std::int32_t num READ getNum CONSTANT REQUIRED)"
+        );
+    }
+
     #[test]
     fn test_generate_cpp_properties() {
         let mut input1: ItemStruct = parse_quote! {
-            #[qproperty(i32, trivial_property, read, write, notify)]
+            #[qproperty(i32, trivial_property, READ, WRITE, NOTIFY)]
             struct MyStruct;
         };
 

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

@@ -46,6 +46,7 @@ pub struct QPropertyNames {
     pub setter: Option<NameState>,
     pub setter_wrapper: Option<Name>,
     pub notify: Option<NameState>,
+    pub reset: Option<Name>,
 }
 
 impl From<&ParsedQProperty> for QPropertyNames {
@@ -79,12 +80,15 @@ impl From<&ParsedQProperty> for QPropertyNames {
             None
         };
 
+        let reset = flags.reset.as_ref().map(|ident| Name::new(ident.clone()));
+
         Self {
             getter_wrapper,
             getter,
             setter_wrapper,
             setter,
             notify,
+            reset,
             name: property_name,
         }
     }

crates/cxx-qt-gen/src/naming/type_names.rs

@@ -574,7 +574,6 @@ mod tests {
 
     #[test]
     fn test_cxx_items_cxx_name() {
-        // TODO
         let item: Item = parse_quote! {
             unsafe extern "C++" {
                 #[cxx_name = "B"]