feat(reflect): add @rule_of_zero

Author: JohelEGP

source/reflect.h2

@@ -84,7 +84,7 @@ compiler_services: @polymorphic_base @copyable type =
 
         //  First split this string into source_lines
         //
-        (copy newline_pos := source.find('\n')) 
+        (copy newline_pos := source.find('\n'))
         if  source.ssize() > 1
             && newline_pos != source.npos
         {
@@ -281,7 +281,7 @@ declaration: @polymorphic_base @copyable type =
     parent_is_alias      : (this) -> bool = n*.parent_is_alias();
     parent_is_polymorphic: (this) -> bool = n*.parent_is_polymorphic();
 
-    mark_for_removal_from_enclosing_type: (inout this) 
+    mark_for_removal_from_enclosing_type: (inout this)
         [[pre Type: parent_is_type()]]              // this precondition should be sufficient ...
     = {
         test := n*.type_member_mark_for_removal();
@@ -400,7 +400,7 @@ type_declaration: @copyable type =
         [[assert: n*.is_type()]]
     }
 
-    reserve_names: (this, name: std::string_view, forward etc...) = 
+    reserve_names: (this, name: std::string_view, forward etc...) =
     {                           // etc is not declared ':string_view' for compatibility with GCC 10.x
         for get_members()
         do  (m) {
@@ -752,7 +752,7 @@ basic_value: (inout t: meta::type_declaration) =
 //-----------------------------------------------------------------------
 //
 //     "A 'value' is a totally ordered basic_value..."
-// 
+//
 //          -- P0707R4, section 3
 //
 //  value - a value type that is totally ordered
@@ -778,6 +778,40 @@ partially_ordered_value: (inout t: meta::type_declaration) =
 }
 
 
+//-----------------------------------------------------------------------
+//
+//     C.20: If you can avoid defining default operations, do
+//
+//     ##### Reason
+//
+//     It's the simplest and gives the cleanest semantics.
+//
+//     ...
+//
+//     This is known as "the rule of zero".
+//
+//          -- C++ Core Guidelines
+//             C.20: If you can avoid defining any default operations, do
+//             <https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rc-zero>
+//
+//-----------------------------------------------------------------------
+//
+//  rule_of_zero
+//
+//  a type without declared copy/move/destructor functions
+//
+rule_of_zero: (inout t: meta::type_declaration) =
+{
+    for t.get_member_functions() do (inout mf)
+    {
+        t.require( !mf.is_constructor_with_that()
+                   && !mf.is_assignment_with_that()
+                   && !mf.is_destructor(),
+                   "the rule of zero requires no copy/move/destructor functions");
+    }
+    t.disable_member_function_generation();
+}
+
 //-----------------------------------------------------------------------
 //
 //     "By definition, a `struct` is a `class` in which members
@@ -817,7 +851,7 @@ struct: (inout t: meta::type_declaration) =
                        "a struct may not have a user-defined operator=");
         }
     }
-    t.disable_member_function_generation();
+    t.rule_of_zero();
 }
 
 
@@ -904,7 +938,7 @@ basic_enum: (
     }
 
     //  Compute the default underlying type, if it wasn't explicitly specified
-    if underlying_type == "" 
+    if underlying_type == ""
     {
         t.require( !found_non_numeric,
             "if you write an enumerator with a non-numeric-literal value, you must specify the enumeration's underlying type");
@@ -987,7 +1021,7 @@ basic_enum: (
             to_string += "    if this == none { return \"(none)\"; }\n";
         }
 
-        for  enumerators  
+        for  enumerators
         do   (e) {
             if e.name != "_" {  // ignore unnamed values
                 if bitwise {
@@ -1019,7 +1053,7 @@ basic_enum: (
 //     value of its enumerators's type, and otherwise has only public
 //     member variables of its enumerator's type, all of which are
 //     naturally scoped because they are members of a type."
-// 
+//
 //          -- P0707R4, section 3
 //
 enum: (inout t: meta::type_declaration) =
@@ -1041,12 +1075,12 @@ enum: (inout t: meta::type_declaration) =
 
 //-----------------------------------------------------------------------
 //
-//     "flag_enum expresses an enumeration that stores values 
+//     "flag_enum expresses an enumeration that stores values
 //      corresponding to bitwise-or'd enumerators. The enumerators must
 //      be powers of two, and are automatically generated [...] A none
 //      value is provided [...] Operators | and & are provided to
 //      combine and extract values."
-// 
+//
 //          -- P0707R4, section 3
 //
 flag_enum: (inout t: meta::type_declaration) =
@@ -1079,10 +1113,10 @@ flag_enum: (inout t: meta::type_declaration) =
 //
 //          -- Stroustrup (The Design and Evolution of C++, 14.3.4.1)
 //
-//     "C++17 needs a type-safe union... The implications of the 
-//      consensus `variant` design are well understood and have been 
-//      explored over several LEWG discussions, over a thousand emails, 
-//      a joint LEWG/EWG session, and not to mention 12 years of 
+//     "C++17 needs a type-safe union... The implications of the
+//      consensus `variant` design are well understood and have been
+//      explored over several LEWG discussions, over a thousand emails,
+//      a joint LEWG/EWG session, and not to mention 12 years of
 //      experience with Boost and other libraries."
 //
 //          -- Axel Naumann, in P0088 (wg21.link/p0088),
@@ -1091,9 +1125,9 @@ flag_enum: (inout t: meta::type_declaration) =
 //-----------------------------------------------------------------------
 //
 //  union
-// 
+//
 //  a type that contains exactly one of a fixed set of values at a time
-// 
+//
 
 union: (inout t : meta::type_declaration)
 = {
@@ -1148,8 +1182,8 @@ union: (inout t : meta::type_declaration)
     (copy storage: std::string = "    _storage: std::aligned_storage_t<cpp2::max( ")
     {
         (copy comma: std::string = "")
-        for  alternatives  
-        next comma = ", "  
+        for  alternatives
+        next comma = ", "
         do   (e) {
             storage += comma + "sizeof((e.type)$)";
         }
@@ -1162,7 +1196,7 @@ union: (inout t : meta::type_declaration)
     t.add_member( "    _discriminator: (discriminator_type)$ = -1;\n");
 
     //  Add the alternatives: is_alternative, get_alternative, and set_alternative
-    for alternatives 
+    for alternatives
     do  (a)
     {
         t.add_member( "    is_(a.name)$: (this) -> bool = _discriminator == (a.value)$;\n");
@@ -1252,7 +1286,7 @@ apply_metafunctions: (
 
         args: std::vector<std::string> = ();
         for meta*.template_arguments()
-        do  (arg) 
+        do  (arg)
             args.push_back( arg.to_string() );
 
         rtype.set_metafunction_name( name, args );
@@ -1289,6 +1323,9 @@ apply_metafunctions: (
         else if name == "partially_ordered_value" {
             partially_ordered_value( rtype );
         }
+        else if name == "rule_of_zero" {
+            rule_of_zero( rtype );
+        }
         else if name == "struct" {
             cpp2_struct( rtype );
         }
@@ -1306,14 +1343,14 @@ apply_metafunctions: (
         }
         else {
             error( "unrecognized metafunction name: " + name );
-            error( "(temporary alpha limitation) currently the supported names are: interface, polymorphic_base, ordered, weakly_ordered, partially_ordered, copyable, basic_value, value, weakly_ordered_value, partially_ordered_value, struct, enum, flag_enum, union, print" );
+            error( "(temporary alpha limitation) currently the supported names are: interface, polymorphic_base, ordered, weakly_ordered, partially_ordered, copyable, basic_value, value, weakly_ordered_value, partially_ordered_value, rule_of_zero, struct, enum, flag_enum, union, print" );
             return false;
         }
 
         if (
-            !args.empty() 
+            !args.empty()
             && !rtype.arguments_were_used()
-            ) 
+            )
         {
             error( name + " did not use its template arguments - did you mean to write '" + name + " <" + args[0] + "> type' (with the spaces)?");
             return false;