Generate return-old-value overload of operator++/operator-- only if the type is copyable

Author: hsutter

docs/cpp2/common.md

@@ -220,7 +220,7 @@ Postfix notation lets the code read fluidly left-to-right, in the same order in
 
 > Note: The `...` pack expansion syntax is also supported. The above `...` and `..=` are the Cpp2 range operators, which overlap in syntax.
 
-> Note: Because `++` and `--` always have in-place update semantics, we never need to remember "use prefix `++`/`--` unless you need a copy of the old value." If you do need a copy of the old value, just take the copy before calling `++`/`--`. When you write a type that overloads `operator++` or `operator--`, cppfront generates both Cpp1 overloads (in-place-update and copy-old-value) for that function to support natural use of the type from Cpp1 code.
+> Note: Because `++` and `--` always have in-place update semantics, we never need to remember "use prefix `++`/`--` unless you need a copy of the old value." If you do need a copy of the old value, just take the copy before calling `++`/`--`. When you write a copyable type that overloads `operator++` or `operator--`, cppfront generates also the copy-old-value overload of that function to support natural use of the type from Cpp1 code.
 
 
 ### <a id="binary-operators"></a> Binary operators

regression-tests/test-results/version

@@ -1,5 +1,5 @@
 
-cppfront compiler v0.7.2   Build 9731:1430
+cppfront compiler v0.7.2   Build 9731:1814
 Copyright(c) Herb Sutter   All rights reserved
 
 SPDX-License-Identifier: CC-BY-NC-ND-4.0

source/build.info

@@ -1 +1 @@
-"9731:1430"
+"9731:1814"

source/sema.h

@@ -2068,13 +2068,7 @@ class sema
 
         //  An increment/decrement function must have a single 'inout' parameter,
         //  and if it's a member flag it if we know the type is not copyable
-        if (
-            n.my_decl
-            && (
-                n.my_decl->has_name("operator++")
-                || n.my_decl->has_name("operator--")
-                )
-            )
+        if (n.is_increment_or_decrement())
         {
             if (
                 (*n.parameters).ssize() != 1
@@ -2095,18 +2089,6 @@ class sema
                 );
                 return false;
             }
-
-            if (
-                n.my_decl->parent_declaration
-                && n.my_decl->parent_declaration->cannot_be_a_copy_constructible_type()
-                )
-            {
-                errors.emplace_back(
-                    n.position(),
-                    "a user-defined " + n.my_decl->name()->to_string() + " in type scope must be a member of a copyable type"
-                );
-                return false;
-            }
         }
 
         return true;

source/to_cpp1.h

@@ -6589,12 +6589,18 @@ class cppfront
                     printer.print_cpp2( suffix2, n.position() );
 
                     //  If this is ++ or --, also generate a Cpp1 postfix version of the operator
+                    //  (as long as we don't know for sure this isn't a copyable type)
                     if (func->is_increment_or_decrement())
                     {
                         if (generating_postfix_inc_dec_from) {
                             assert (generating_postfix_inc_dec_from == &n);
                         }
-                        else {
+                        else if (
+                                !n.parent_declaration
+                                || !n.parent_declaration->is_type()
+                                || !n.parent_declaration->cannot_be_a_copy_constructible_type()
+                                )
+                        {
                             need_to_generate_postfix_inc_dec = true;
                         }
                     }