generate and use copy assignment operator when setting struct/class value properties

Author: Fabio Anderegg

src/Generator/AST/Utils.cs

@@ -36,9 +36,6 @@ public static bool CheckIgnoreMethod(Method method)
             if (method.IsDestructor)
                 return true;
 
-            if (method.OperatorKind == CXXOperatorKind.Equal)
-                return true;
-
             if (method.Access == AccessSpecifier.Private && !method.IsOverride && !method.IsExplicitlyGenerated)
                 return true;
 

src/Generator/Generators/CSharp/CSharpSources.cs

@@ -1009,8 +1009,34 @@ private bool GenerateFunctionSetter(Class @class, Property property)
 
         private void GenerateFieldSetter(Field field, Class @class, QualifiedType fieldType)
         {
+            if (field.Type.IsClass() && !field.Type.IsPointer())
+            {
+                if (field.Type.TryGetClass(out Class fieldClass))
+                {
+                    var caop = fieldClass.Methods.FirstOrDefault(m => m.OperatorKind == CXXOperatorKind.Equal);
+                    if (caop != null)
+                    {
+                        var fieldName = ((Class)field.Namespace).Layout.Fields.First(
+                            f => f.FieldPtr == field.OriginalPtr).Name;
+                        WriteLine($"var dest = new __IntPtr(&((__Internal*)__Instance)->{fieldName});");
+                        WriteLine($"var src = value.{Helpers.InstanceIdentifier};");
+
+                        var typeName = TypePrinter.PrintNative(fieldClass);
+                        if (IsInternalClassNested(fieldClass))
+                            typeName.RemoveNamespace();
+
+                        WriteLine($"{fieldClass}.__Internal.OperatorEqual(dest, src);");
+                        //UnindentAndWriteCloseBrace();
+
+                        return;
+                    }
+                }
+            }
+
+
             string returnVar;
             Type type = field.Type.Desugar();
+
             var arrayType = type as ArrayType;
             if (arrayType != null && @class.IsValueType)
             {
@@ -1492,6 +1518,11 @@ public void GenerateClassMethods(IList<Method> methods)
                     continue;
                 }
 
+                // We only use the copy assignment operator internally,
+                // so do not generate a public method wrapper for it
+                if (method.OperatorKind == CXXOperatorKind.Equal)
+                    continue;
+
                 GenerateMethod(method, @class);
             }
 

src/Generator/Passes/ValidateOperatorsPass.cs

@@ -55,6 +55,9 @@ private bool IsValidOperatorOverload(Method @operator)
                 // The conversion operators can be overloaded
                 case CXXOperatorKind.Conversion:
                 case CXXOperatorKind.ExplicitConversion:
+
+                // Copy assignment operator is used internally
+                case CXXOperatorKind.Equal:
                     return true;
 
                 // The comparison operators can be overloaded if their return type is bool
@@ -127,7 +130,6 @@ private bool IsValidOperatorOverload(Method @operator)
                 case CXXOperatorKind.PipePipe:
 
                 // These operators cannot be overloaded.
-                case CXXOperatorKind.Equal:
                 case CXXOperatorKind.Comma:
                 case CXXOperatorKind.ArrowStar:
                 case CXXOperatorKind.Arrow: