Generate Cpp1 postfix inc/dec from in terms of prefix

Author: hsutter

regression-tests/test-results/version

@@ -1,5 +1,5 @@
 
-cppfront compiler v0.3.0   Build 8C09:1607
+cppfront compiler v0.3.0   Build 8C10:1238
 Copyright(c) Herb Sutter   All rights reserved
 
 SPDX-License-Identifier: CC-BY-NC-ND-4.0

source/build.info

@@ -1 +1 @@
-"8C09:1607"
+"8C10:1238"

source/parse.h

@@ -2843,6 +2843,29 @@ struct declaration_node
         return false;
     }
 
+    auto is_not_a_copyable_type() const
+        -> bool
+    {
+        //  If we're not a type, we're not a copyable type
+        if (!is_type()) {
+            return true;
+        }
+
+        //  If we're letting Cpp1 generate SMFs, we're likely copyable
+        if (!member_function_generation) {
+            return false;
+        }
+
+        //  If we have a copy constructor, we're copyable
+        for (auto& decl : get_type_scope_declarations())
+        if  (decl->is_constructor_with_that())
+        {
+            return false;
+        }
+
+        return true;
+    }
+
     auto parent_is_function   () const -> bool
         { return  parent_declaration && parent_declaration->type.index() == a_function;  }
     auto parent_is_object     () const -> bool

source/sema.h

@@ -1526,25 +1526,39 @@ class sema
     auto check(function_type_node const& n)
         -> bool
     {
+        assert(n.parameters);
+
         //  An increment/decrement function must have a single parameter that is 'inout this'
+        //  and be a member of a copyable type (that defined a copy operator= or suppressed
+        //  member function generation to get the Cpp1 generated copy functions)
+        // 
+        //  Future: See if there's demand for non-member increment/decrement
         if (
-            (
-                n.my_decl->has_name("operator++")
-                || n.my_decl->has_name("operator--")
-            )
-            &&
-            (
-               (*n.parameters).ssize() != 1
-            || !(*n.parameters)[0]->has_name("this")
-            || (*n.parameters)[0]->direction() != passing_style::inout
-            )
+            n.my_decl->has_name("operator++")
+            || n.my_decl->has_name("operator--")
             )
         {
-            errors.emplace_back(
-                n.position(),
-                "a user-defined " + n.my_decl->name()->to_string() + " must have a single 'inout this' parameter"
-            );
-            return false;
+            if (
+               (*n.parameters).ssize() != 1
+                || !(*n.parameters)[0]->has_name("this")
+                || (*n.parameters)[0]->direction() != passing_style::inout
+                )
+            {
+                errors.emplace_back(
+                    n.position(),
+                    "a user-defined " + n.my_decl->name()->to_string() + " must have a single 'inout this' parameter"
+                );
+                return false;
+            }
+
+            if (n.my_decl->parent_declaration->is_not_a_copyable_type())
+            {
+                errors.emplace_back(
+                    n.position(),
+                    "a user-defined " + n.my_decl->name()->to_string() + " must be a member of a copyable type"
+                );
+                return false;
+            }
         }
 
         return true;

source/to_cpp1.h

@@ -4594,8 +4594,6 @@ class cppfront
     )
         -> void
     {   STACKINSTR
-        assert(n.parameters);
-
         if (!sema.check(n)) {
             return;
         }
@@ -6273,6 +6271,15 @@ class cppfront
                 else {
                     printer.print_cpp2( ";", n.position() );
                 }
+
+                //  If this is ++ or --, also generate a Cpp1 postfix version of the operator
+                if (func->is_increment_or_decrement()) {
+                    printer.print_cpp2(
+                        " public: auto " + n.name()->to_string() + "(int) { auto ret = *this; ++*this; return ret; }",
+                        n.position()
+                    );
+                }
+
                 //  Note: Not just early "return;" here because we may need to
                 //  recurse to emit the generated operator= declarations too,
                 //  so all the definition work goes into a big 'else' branch