Fix build break in generated code when custom structs lack an equality operator

Author: AArnott

src/ImmutableObjectGraph.Generation.Tests/TestSources/ImmutableWithComplexStructField.cs

@@ -17,5 +17,15 @@ internal SomeStructWithMultipleFields(int field1, int field2)
         internal int Field1 { get; }
 
         internal int Field2 { get; }
+
+        ////public static bool operator ==(SomeStructWithMultipleFields one, SomeStructWithMultipleFields two)
+        ////{
+        ////    return one.Field1 == two.Field1 && one.Field2 == two.Field2;
+        ////}
+
+        ////public static bool operator !=(SomeStructWithMultipleFields one, SomeStructWithMultipleFields two)
+        ////{
+        ////    return !(one == two);
+        ////}
     }
 }

src/ImmutableObjectGraph.Generation/CodeGen.cs

@@ -210,6 +210,29 @@ private static IdentifierNameSyntax GetGenerationalMethodName(IdentifierNameSynt
             return SyntaxFactory.IdentifierName(baseName.Identifier.ValueText + generation.ToString(CultureInfo.InvariantCulture));
         }
 
+        /// <summary>
+        /// Checks whether a type defines equality operators for itself.
+        /// </summary>
+        /// <param name="symbol">The type to check.</param>
+        /// <returns><c>true</c> if the == and != operators are defined on the type.</returns>
+        private static bool HasEqualityOperators(ITypeSymbol symbol)
+        {
+            Requires.NotNull(symbol, nameof(symbol));
+
+            // Reference types inherit their equality operators from System.Object.
+            if (symbol.IsReferenceType)
+            {
+                return true;
+            }
+
+            var equalityOperators = from method in symbol.GetMembers().OfType<IMethodSymbol>()
+                                    where method.MethodKind == MethodKind.BuiltinOperator || method.MethodKind == MethodKind.UserDefinedOperator
+                                    where method.Parameters.Length == 2 && method.Parameters.All(p => p.Type == symbol)
+                                    where method.Name == "op_Equality"
+                                    select method;
+            return equalityOperators.Any();
+        }
+
         private void ReportDiagnostic(string id, SyntaxNode blamedSyntax, params string[] formattingArgs)
         {
             Requires.NotNull(blamedSyntax, nameof(blamedSyntax));
@@ -533,18 +556,20 @@ private IEnumerable<MethodDeclarationSyntax> CreateWithCoreMethods()
         private MemberDeclarationSyntax CreateWithFactoryMethod()
         {
             // (field.IsDefined && field.Value != this.field)
-            Func<IdentifierNameSyntax, IdentifierNameSyntax, ExpressionSyntax> isChangedByNames = (propertyName, fieldName) =>
-                SyntaxFactory.ParenthesizedExpression(
-                    SyntaxFactory.BinaryExpression(
-                        SyntaxKind.LogicalAndExpression,
-                        Syntax.OptionalIsDefined(fieldName),
+            Func<IdentifierNameSyntax, IdentifierNameSyntax, ITypeSymbol, ExpressionSyntax> isChangedByNames = (propertyName, fieldName, fieldType) =>
+                fieldType == null || HasEqualityOperators(fieldType) ?
+                    (ExpressionSyntax)SyntaxFactory.ParenthesizedExpression(
                         SyntaxFactory.BinaryExpression(
-                            SyntaxKind.NotEqualsExpression,
-                            Syntax.OptionalValue(fieldName),
-                            Syntax.ThisDot(propertyName))));
-            Func<MetaField, ExpressionSyntax> isChanged = v => isChangedByNames(v.NameAsProperty, v.NameAsField);
+                            SyntaxKind.LogicalAndExpression,
+                            Syntax.OptionalIsDefined(fieldName),
+                            SyntaxFactory.BinaryExpression(
+                                SyntaxKind.NotEqualsExpression,
+                                Syntax.OptionalValue(fieldName),
+                                Syntax.ThisDot(propertyName)))) :
+                    Syntax.OptionalIsDefined(fieldName);
+            Func<MetaField, ExpressionSyntax> isChanged = v => isChangedByNames(v.NameAsProperty, v.NameAsField, v.Symbol.Type);
             var anyChangesExpression =
-                new ExpressionSyntax[] { isChangedByNames(IdentityPropertyName, IdentityParameterName) }.Concat(
+                new ExpressionSyntax[] { isChangedByNames(IdentityPropertyName, IdentityParameterName, null) }.Concat(
                     this.applyToMetaType.AllFields.Select(isChanged))
                     .ChainBinaryExpressions(SyntaxKind.LogicalOrExpression);