feat(reflect): add @cpp1_rule_of_zero

[JohelEGP]

Resolves #665.

Testing summary:

100% tests passed, 0 tests failed out of 818

Total Test time (real) =  64.88 sec

Acknowledgements:

• Tested thanks to https://github.com/modern-cmake/cppfront.
• Commit messages follow Conventional Commits 1.0.0.
• Comments and commit messages follow Semantic Line Breaks.

[JohelEGP]

Here's some use cases.

---

To name the idiom "rule of zero".
operator=: (out this, that) = { } has its semantics for std::semiregular types without this members.
Otherwise, you might be able to manually write out the correct subset of:

operator=: (out this, in that) = { }
operator=: (out this, move that) = { }
operator=: (inout this, in that) = { }
operator=: (inout this, move that) = { }

---

To write wrappers that behave like the wrapped types.
Some examples include simpler implementations of std::optional and std::pair.
If they wrap a std::unique_ptr<int>, they should become move-only.
If they wrap a std::mutex, they should become non-copyable non-movable.

[JohelEGP]

This is the diff on my use case
for the types I've wrapped so far:

Diff

diff --git a/sources/waarudo/sfml/sfml.cpp2 b/sources/waarudo/sfml/sfml.cpp2
index 007d3b0..9a462d3 100644
--- a/sources/waarudo/sfml/sfml.cpp2
+++ b/sources/waarudo/sfml/sfml.cpp2
@@ -31,27 +31,21 @@ sfml: namespace = {
     set_position: (inout this, point: jegp::ui::window_point<float>) = derived(this).setPosition(point.to_sfml());
   }
 
-  export sprite: type = {
+  export sprite: @rule_of_zero type = {
     this: sf::Sprite;
     this: transformable<sprite> = ();
 
-    operator=: (out this, that)                 = { }
     operator=: (out this, texture: sf::Texture) = sf::Sprite = (texture);
     operator=: (out this, texture: sf::Texture, rectangle: jegp::ui::window_rectangle<i32>) = //
       sf::Sprite = (texture, rectangle.to_sfml());
   }
 
-  export rectangle_shape: type = {
+  export rectangle_shape: @rule_of_zero type = {
     this: sf::RectangleShape             = ();
     this: transformable<rectangle_shape> = ();
 
-    operator=: (out this, size: jegp::ui::magnitude_t<float>) = sf::RectangleShape = (size.to_sfml());
-
     operator=: (out this) = { }
-    operator=: (out this, that)        = { }
-    operator=: (out this, move that)   = { }
-    operator=: (inout this, that)      = { }
-    operator=: (inout this, move that) = { }
+    operator=: (out this, size: jegp::ui::magnitude_t<float>) = sf::RectangleShape = (size.to_sfml());
   }
 
   render_target: @struct <Derived> type = {
@@ -82,17 +76,12 @@ sfml: namespace = {
     get_size: (this) -> jegp::ui::magnitude_t<i32> = sf::Vector2i(getSize()).from_sfml();
   }
 
-  export vertex: type = {
+  export vertex: @rule_of_zero type = {
     this: sf::Vertex = ();
 
+    operator=: (out this) = { }
     operator=: (out this, position: jegp::ui::window_point<float>, texture_position: canvas_point<float>) = //
       sf::Vertex = (position.to_sfml(), texture_position.to_sfml());
-
-    operator=: (out this) = { }
-    operator=: (out this, that)        = { }
-    operator=: (out this, move that)   = { }
-    operator=: (inout this, that)      = { }
-    operator=: (inout this, move that) = { }
   }
 
   export vertex_ptr: @basic_value <Const: bool> type = {
@@ -112,9 +101,10 @@ sfml: namespace = {
 
   export vertices_in_triangle :== 3;
 
-  export vertex_array: type = {
+  export vertex_array: @rule_of_zero type = {
     this: sf::VertexArray = ();
 
+    operator=: (out this) = { }
     operator=: (out this, type: sf::PrimitiveType, vertices: std::ptrdiff_t) = sf::VertexArray =
       (type, vertices as std::size_t);
 
@@ -122,24 +112,13 @@ sfml: namespace = {
       vertex_array(sf::PrimitiveType::Triangles, size * vertices_in_triangle);
 
     get_bounds: (this) -> jegp::ui::window_rectangle<float> = getBounds().from_sfml();
-
-    operator=: (out this) = { }
-    operator=: (out this, that)        = { }
-    operator=: (out this, move that)   = { }
-    operator=: (inout this, that)      = { }
-    operator=: (inout this, move that) = { }
   }
 
-  export view: type = {
+  export view: @rule_of_zero type = {
     this: sf::View = ();
 
-    operator=: (out this, zone_to_display: scene_rectangle<float>) = sf::View = to_sfml(zone_to_display);
-
     operator=: (out this) = { }
-    operator=: (out this, that)        = { }
-    operator=: (out this, move that)   = { }
-    operator=: (inout this, that)      = { }
-    operator=: (inout this, move that) = { }
+    operator=: (out this, zone_to_display: scene_rectangle<float>) = sf::View = to_sfml(zone_to_display);
   }
 
   to_sfml: <O, Number> (shape: jegp::ui::rectangle<O, Number>) -> sf::Rect<Number> =

[hsutter]

Nice. Does this need a minor rebase, and generation of reflect.h?

[JohelEGP]

Done.

[hsutter]

Looks ready to merge... just one last question about naming:

I renamed the function to cpp1_rule_of_zero because it seems to be about requesting the Cpp1 defaults, and the name refers to the Cpp1 idiom name about using those Cpp1 defaults, rather than Cpp2 semantics... is that a good naming change? Or do you think even without knowledge of Cpp1 default this makes sense on its own in the Cpp2 code you're writing, and if so is rule-of-zero still the best name in a Cpp2 context?

But apart from that naming question this is ready to merge, just let me know what you think of the name... thanks again.

[JohelEGP]

Yeah, cpp1_rule_of_zero is much better in my eyes.

The commit with the rename reverted the changes to reflect.h by commit 7fff368.

[hsutter]

Thanks! I'll regenerate reflect.h post-merge to re-sync...