Splitting Gigantic EqualsNode into few Smaller Ones

distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso

@@ -108,22 +108,7 @@ type Any
                  a = 7 * 21
                  a == 147
     == : Any -> Boolean
-    == self that =
-        # If there is No_Such_Conversion, then `self` and `that` are probably
-        # host or polyglot values, so we just compare them with the default comparator.
-        eq_self = Comparable.from self
-        eq_that = Comparable.from that
-        similar_type = Meta.is_same_object eq_self eq_that
-        case similar_type of
-            False -> False
-            True ->
-                case Meta.is_same_object eq_self Default_Comparator of
-                    # Shortcut for objects with Default_Comparator, because of the performance.
-                    True -> Comparable.equals_builtin self that
-                    False ->
-                        case eq_self.compare self that of
-                            Ordering.Equal -> True
-                            _ -> False
+    == self that = Comparable.equals_builtin self that
 
     ## ALIAS Inequality
 

distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso

@@ -128,9 +128,9 @@ type Comparable
        A custom comparator is any comparator that is different than the
        default ones.
     has_custom_comparator : Atom -> Boolean
-    has_custom_comparator atom =
-        comp = Comparable.from atom
-        (comp.is_a Default_Comparator).not
+    has_custom_comparator atom = case Comparable.from atom of
+        _ : Default_Comparator -> Nothing
+        c -> c
 
 ## PRIVATE
    Default implementation of a _comparator_.

engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsAtomNode.java

@@ -0,0 +1,141 @@
+package org.enso.interpreter.node.expression.builtin.meta;
+
+import com.oracle.truffle.api.CompilerAsserts;
+import com.oracle.truffle.api.CompilerDirectives;
+import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
+import com.oracle.truffle.api.dsl.Cached;
+import com.oracle.truffle.api.dsl.GenerateUncached;
+import com.oracle.truffle.api.dsl.Specialization;
+import com.oracle.truffle.api.library.CachedLibrary;
+import com.oracle.truffle.api.nodes.ExplodeLoop;
+import com.oracle.truffle.api.nodes.Node;
+import com.oracle.truffle.api.profiles.ConditionProfile;
+import java.util.Arrays;
+import org.enso.interpreter.node.callable.InvokeCallableNode.ArgumentsExecutionMode;
+import org.enso.interpreter.node.callable.InvokeCallableNode.DefaultsExecutionMode;
+import org.enso.interpreter.node.callable.dispatch.InvokeFunctionNode;
+import org.enso.interpreter.node.expression.builtin.ordering.HasCustomComparatorNode;
+import org.enso.interpreter.runtime.EnsoContext;
+import org.enso.interpreter.runtime.callable.argument.CallArgumentInfo;
+import org.enso.interpreter.runtime.callable.atom.Atom;
+import org.enso.interpreter.runtime.callable.atom.AtomConstructor;
+import org.enso.interpreter.runtime.callable.atom.StructsLibrary;
+import org.enso.interpreter.runtime.callable.function.Function;
+import org.enso.interpreter.runtime.data.Type;
+import org.enso.interpreter.runtime.state.State;
+
+@GenerateUncached
+public abstract class EqualsAtomNode extends Node {
+
+  public static EqualsAtomNode build() {
+    return EqualsAtomNodeGen.create();
+  }
+
+  public abstract boolean execute(Atom left, Atom right);
+
+  static EqualsNode[] createEqualsNodes(int size) {
+    EqualsNode[] nodes = new EqualsNode[size];
+    Arrays.fill(nodes, EqualsNode.build());
+    return nodes;
+  }
+
+  @Specialization(
+      guards = {
+        "selfCtorCached == self.getConstructor()",
+        "customComparatorNode.execute(self) == null"
+      },
+      limit = "10")
+  @ExplodeLoop
+  boolean equalsAtoms(
+      Atom self,
+      Atom other,
+      @Cached("self.getConstructor()") AtomConstructor selfCtorCached,
+      @Cached(value = "selfCtorCached.getFields().length", allowUncached = true)
+          int fieldsLenCached,
+      @Cached(value = "createEqualsNodes(fieldsLenCached)", allowUncached = true)
+          EqualsNode[] fieldEqualsNodes,
+      @Cached HasCustomComparatorNode customComparatorNode,
+      @Cached ConditionProfile constructorsNotEqualProfile,
+      @CachedLibrary(limit = "5") StructsLibrary structsLib) {
+    if (constructorsNotEqualProfile.profile(self.getConstructor() != other.getConstructor())) {
+      return false;
+    }
+    var selfFields = structsLib.getFields(self);
+    var otherFields = structsLib.getFields(other);
+    assert selfFields.length == otherFields.length
+        : "Constructors are same, atoms should have the same number of fields";
+
+    CompilerAsserts.partialEvaluationConstant(fieldsLenCached);
+    for (int i = 0; i < fieldsLenCached; i++) {
+      boolean fieldsAreEqual = fieldEqualsNodes[i].execute(selfFields[i], otherFields[i]);
+      if (!fieldsAreEqual) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  @Specialization(
+      guards = {
+        "selfCtorCached == self.getConstructor()",
+        "cachedComparator != null",
+      },
+      limit = "10")
+  boolean equalsAtoms(
+      Atom self,
+      Atom other,
+      @Cached("self.getConstructor()") AtomConstructor selfCtorCached,
+      @Cached HasCustomComparatorNode customComparatorNode,
+      @Cached(value = "customComparatorNode.execute(self)") Type cachedComparator,
+      @Cached(value = "findCompareMethod(cachedComparator)", allowUncached = true)
+          Function compareFn,
+      @Cached(value = "invokeCompareNode(compareFn)") InvokeFunctionNode invokeNode) {
+    var otherComparator = customComparatorNode.execute(other);
+    if (cachedComparator != otherComparator) {
+      return false;
+    }
+    var ctx = EnsoContext.get(this);
+    var args = new Object[] {cachedComparator, self, other};
+    var result = invokeNode.execute(compareFn, null, State.create(ctx), args);
+    return ctx.getBuiltins().ordering().newEqual() == result;
+  }
+
+  @CompilerDirectives.TruffleBoundary
+  @Specialization(replaces = "equalsAtoms")
+  boolean equalsAtomsUncached(Atom self, Atom other) {
+    if (self.getConstructor() != other.getConstructor()) {
+      return false;
+    }
+    Object[] selfFields = StructsLibrary.getUncached().getFields(self);
+    Object[] otherFields = StructsLibrary.getUncached().getFields(other);
+    if (selfFields.length != otherFields.length) {
+      return false;
+    }
+    for (int i = 0; i < selfFields.length; i++) {
+      boolean areFieldsSame = EqualsNodeGen.getUncached().execute(selfFields[i], otherFields[i]);
+      if (!areFieldsSame) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  @TruffleBoundary
+  static Function findCompareMethod(Type comparator) {
+    var fn = comparator.getDefinitionScope().getMethods().get(comparator).get("compare");
+    if (fn == null) {
+      throw new AssertionError("No compare function for " + comparator);
+    }
+    return fn;
+  }
+
+  static InvokeFunctionNode invokeCompareNode(Function compareFn) {
+    CallArgumentInfo[] argsInfo = new CallArgumentInfo[compareFn.getSchema().getArgumentsCount()];
+    for (int i = 0; i < argsInfo.length; i++) {
+      var argDef = compareFn.getSchema().getArgumentInfos()[i];
+      argsInfo[i] = new CallArgumentInfo(argDef.getName());
+    }
+    return InvokeFunctionNode.build(
+        argsInfo, DefaultsExecutionMode.EXECUTE, ArgumentsExecutionMode.EXECUTE);
+  }
+}