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 = @Builtin_Method "Any.=="
 
     ## ALIAS Inequality
 

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

@@ -124,22 +124,14 @@ type Comparable
         ordering = Ordering.compare atom that
         if ordering.is_error then Nothing else ordering.to_sign
 
-    ## PRIVATE
-       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
-
 ## PRIVATE
    Default implementation of a _comparator_.
 @Builtin_Type
 type Default_Comparator
     ## PRIVATE
     compare : Any -> Any -> (Ordering|Nothing)
     compare x y =
-        case Comparable.equals_builtin x y of
+        case Any.== x y of
             True -> Ordering.Equal
             False ->
                 case Comparable.less_than_builtin x y of

engine/runtime/src/bench/java/org/enso/interpreter/bench/benchmarks/semantic/CurriedFunctionBenchmarks.java

@@ -44,8 +44,6 @@ public void initializeBenchmark(BenchmarkParams params) throws Exception {
 
     var benchmarkName = params.getBenchmark().replaceFirst(".*\\.", "");
     var code = """
-        import Standard.Base.Any.Any
-
         avg fn len =
             sum acc i = if i == len then acc else
                 sum (acc + fn i) i+1

engine/runtime/src/bench/java/org/enso/interpreter/bench/benchmarks/semantic/EqualsBenchmarks.java

@@ -71,7 +71,6 @@ public void initializeBenchmark(BenchmarkParams params) throws Exception {
     var benchmarkName = params.getBenchmark().replaceFirst(".*\\.", "");
     var codeBuilder = new StringBuilder("""
         import Standard.Base.Data.Range.Extensions
-        import Standard.Base.Any.Any
 
         type Node
             C1 f1

engine/runtime/src/bench/java/org/enso/interpreter/bench/benchmarks/semantic/VectorBenchmarks.java

@@ -48,7 +48,6 @@ public void initializeBenchmark(BenchmarkParams params) throws Exception {
     var code = """
         import Standard.Base.Data.Vector.Vector
         import Standard.Base.Data.Array_Proxy.Array_Proxy
-        import Standard.Base.Any.Any
 
         avg arr =
             sum acc i = if i == arr.length then acc else

engine/runtime/src/bench/scala/org/enso/interpreter/bench/fixtures/semantic/AtomFixtures.scala

@@ -7,7 +7,6 @@ class AtomFixtures extends DefaultInterpreterRunner {
 
   val millionElementList = eval(
     s"""import Standard.Base.Data.List.List
-       |import Standard.Base.Any.Any
        |
        |main =
        |    generator fn acc i end = if i == end then acc else @Tail_Call generator fn (fn acc i) i+1 end
@@ -17,7 +16,6 @@ class AtomFixtures extends DefaultInterpreterRunner {
 
   val generateListCode =
     """import Standard.Base.Data.List.List
-      |import Standard.Base.Any.Any
       |
       |main = length ->
       |    generator = acc -> i -> if i == 0 then acc else @Tail_Call generator (List.Cons i acc) (i - 1)
@@ -29,7 +27,6 @@ class AtomFixtures extends DefaultInterpreterRunner {
 
   val generateListQualifiedCode =
     """import Standard.Base.Data.List.List
-      |import Standard.Base.Any.Any
       |
       |main = length ->
       |    generator = acc -> i -> if i == 0 then acc else @Tail_Call generator (List.Cons i acc) (i - 1)

engine/runtime/src/bench/scala/org/enso/interpreter/bench/fixtures/semantic/CallableFixtures.scala

@@ -8,7 +8,6 @@ class CallableFixtures extends DefaultInterpreterRunner {
   val sumTCOfromCallCode =
     """
       |from Standard.Base.Data.Numbers import all
-      |import Standard.Base.Any.Any
       |
       |type Foo
       |
@@ -23,8 +22,7 @@ class CallableFixtures extends DefaultInterpreterRunner {
 
 
   val sumTCOmethodCallCode =
-    """import Standard.Base.Any.Any
-      |
+    """
       |summator = acc -> current ->
       |    if current == 0 then acc else @Tail_Call summator (acc + current) (current - 1)
       |
@@ -35,8 +33,7 @@ class CallableFixtures extends DefaultInterpreterRunner {
   val sumTCOmethodCall = getMain(sumTCOmethodCallCode)
 
   val sumTCOmethodCallWithNamedArgumentsCode =
-    """import Standard.Base.Any.Any
-      |
+    """
       |summator = acc -> current ->
       |    if current == 0 then acc else @Tail_Call summator (current = current - 1) (acc = acc + current)
       |
@@ -48,8 +45,7 @@ class CallableFixtures extends DefaultInterpreterRunner {
     getMain(sumTCOmethodCallWithNamedArgumentsCode)
 
   val sumTCOmethodCallWithDefaultedArgumentsCode =
-    """import Standard.Base.Any.Any
-      |
+    """
       |summator = (acc = 0) -> current ->
       |    if current == 0 then acc else @Tail_Call summator (current = current - 1) (acc = acc + current)
       |

engine/runtime/src/bench/scala/org/enso/interpreter/bench/fixtures/semantic/NamedDefaultedArgumentFixtures.scala

@@ -6,8 +6,7 @@ class NamedDefaultedArgumentFixtures extends DefaultInterpreterRunner {
   val hundredMillion: Long = 100000000
 
   val sumTCOWithNamedArgumentsCode =
-    """import Standard.Base.Any.Any
-      |
+    """
       |main = sumTo ->
       |    summator = acc -> current ->
       |        if current == 0 then acc else @Tail_Call summator (current = current - 1) (acc = acc + current)
@@ -18,8 +17,7 @@ class NamedDefaultedArgumentFixtures extends DefaultInterpreterRunner {
   val sumTCOWithNamedArguments = getMain(sumTCOWithNamedArgumentsCode)
 
   val sumTCOWithDefaultedArgumentsCode =
-    """import Standard.Base.Any.Any
-      |
+    """
       |main = sumTo ->
       |    summator = (acc = 0) -> current ->
       |        if current == 0 then acc else @Tail_Call summator (current = current - 1) (acc = acc + current)

engine/runtime/src/bench/scala/org/enso/interpreter/bench/fixtures/semantic/RecursionFixtures.scala

@@ -9,8 +9,7 @@ class RecursionFixtures extends DefaultInterpreterRunner {
   val hundred: Long        = 100
 
   val sumTCOCode =
-    """import Standard.Base.Any.Any
-      |
+    """
       |main = sumTo ->
       |    summator = acc -> current ->
       |        if current == 0 then acc else @Tail_Call summator acc+current current-1
@@ -21,8 +20,7 @@ class RecursionFixtures extends DefaultInterpreterRunner {
   val sumTCO = getMain(sumTCOCode)
 
   val sumTCOFoldLikeCode =
-    """import Standard.Base.Any.Any
-      |
+    """
       |main = sumTo ->
       |    summator = acc -> i -> f ->
       |        if i == 0 then acc else @Tail_Call summator (f acc i) (i - 1) f
@@ -32,8 +30,7 @@ class RecursionFixtures extends DefaultInterpreterRunner {
   val sumTCOFoldLike = getMain(sumTCOFoldLikeCode)
 
   val sumRecursiveCode =
-    """import Standard.Base.Any.Any
-      |
+    """
       |main = sumTo ->
       |    summator = i -> if i == 0 then 0 else i + summator (i - 1)
       |    res = summator sumTo
@@ -42,8 +39,7 @@ class RecursionFixtures extends DefaultInterpreterRunner {
   val sumRecursive = getMain(sumRecursiveCode)
 
   val oversaturatedRecursiveCallTCOCode =
-    """import Standard.Base.Any.Any
-      |
+    """
       |main = sumTo ->
       |    summator = acc -> i -> f ->
       |        if i == 0 then acc else @Tail_Call summator (f acc i) (i - 1) f

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.CustomComparatorNode;
+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 CustomComparatorNode 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 CustomComparatorNode 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);
+  }
+}