Move implementation to SyntaxEqualityComparer

Author: tobias-tengler

src/HotChocolate/Core/src/Validation/Rules/FieldVisitor.cs

@@ -370,7 +370,7 @@ private static bool AreArgumentsIdentical(FieldNode fieldA, FieldNode fieldB)
 
                 if (BySyntax.Equals(argumentA.Name, argumentB.Name))
                 {
-                    if (AreValuesIdentical(argumentA.Value, argumentB.Value))
+                    if (BySyntax.Equals(argumentA.Value, argumentB.Value))
                     {
                         validPairs++;
                     }
@@ -383,61 +383,6 @@ private static bool AreArgumentsIdentical(FieldNode fieldA, FieldNode fieldB)
         return fieldA.Arguments.Count == validPairs;
     }
 
-    private static bool AreValuesIdentical(IValueNode valueA, IValueNode valueB)
-    {
-        var stack = new Stack<(IValueNode ValueA, IValueNode ValueB)>();
-        stack.Push((valueA, valueB));
-
-        while (stack.Count > 0)
-        {
-            var (currentA, currentB) = stack.Pop();
-
-            if (currentA is ListValueNode listA && currentB is ListValueNode listB)
-            {
-                if (listA.Items.Count != listB.Items.Count)
-                {
-                    return false;
-                }
-
-                for (var i = 0; i < listA.Items.Count; i++)
-                {
-                    stack.Push((listA.Items[i], listB.Items[i]));
-                }
-            }
-            else if (currentA is ObjectValueNode objectA && currentB is ObjectValueNode objectB)
-            {
-                if (objectA.Fields.Count != objectB.Fields.Count)
-                {
-                    return false;
-                }
-
-                if (objectA.Fields.Count == 0)
-                {
-                    continue;
-                }
-
-                var fieldDictB = objectB.Fields
-                    .ToDictionary(f => f.Name, f => f.Value, BySyntax);
-
-                foreach (var fieldA in objectA.Fields)
-                {
-                    if (!fieldDictB.TryGetValue(fieldA.Name, out var fieldBValue))
-                    {
-                        return false;
-                    }
-
-                    stack.Push((fieldA.Value, fieldBValue));
-                }
-            }
-            else if (!BySyntax.Equals(currentA, currentB))
-            {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
     private static bool SameResponseShape(IType typeA, IType typeB)
     {
         while (!typeA.IsNamedType() && !typeB.IsNamedType())

src/HotChocolate/Language/src/Language.SyntaxTree/SyntaxEqualityComparer.cs

@@ -357,7 +357,41 @@ private bool Equals(ObjectTypeExtensionNode x, ObjectTypeExtensionNode y)
             Equals(x.Fields, y.Fields);
 
     private bool Equals(ObjectValueNode x, ObjectValueNode y)
-        => Equals(x.Fields, y.Fields);
+    {
+        if (x.Fields.Count != y.Fields.Count)
+        {
+            return false;
+        }
+
+        if (x.Fields.Count == 0)
+        {
+            return true;
+        }
+
+        for (var i = 0; i < x.Fields.Count; i++)
+        {
+            var xField = x.Fields[i];
+            ObjectFieldNode? matchingField = null;
+
+            for (var j = 0; j < y.Fields.Count; j++)
+            {
+                var yField = y.Fields[j];
+
+                if (Equals(xField.Name, yField.Name))
+                {
+                    matchingField = yField;
+                    break;
+                }
+            }
+
+            if (matchingField is null || !Equals(xField.Value, matchingField.Value))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
 
     private bool Equals(OperationDefinitionNode x, OperationDefinitionNode y)
         => SyntaxComparer.BySyntax.Equals(x.Name, y.Name) &&