Use IR.STRUCTURE_COMPARATOR to compare two IR objects

engine/runtime-parser/src/main/java/org/enso/compiler/core/IR.java

@@ -1,5 +1,6 @@
 package org.enso.compiler.core;
 
+import java.util.Comparator;
 import java.util.UUID;
 import java.util.function.Consumer;
 import java.util.function.Function;
@@ -28,6 +29,23 @@
  * <p>See also: Note [IR Equality and hashing]
  */
 public interface IR {
+  /**
+   * Compares IR structure, but not metadata neither diagnostics. A special comparator used by
+   * <em>Persistance API</em> to perform some rare consistency checks.
+   */
+  public static final Comparator<IR> STRUCTURE_COMPARATOR =
+      (aIr, bIr) -> {
+        if (aIr == bIr) {
+          return 0;
+        }
+        var aCopy = aIr.duplicate(true, false, false, true);
+        var bCopy = bIr.duplicate(true, false, false, true);
+
+        if (aCopy.equals(bCopy)) {
+          return 0;
+        }
+        return System.identityHashCode(aIr) - System.identityHashCode(bIr);
+      };
 
   /**
    * Storage for metadata that the node has been tagged with as the result of various compiler

engine/runtime-parser/src/test/java/org/enso/compiler/core/IrPersistanceTest.java

@@ -13,6 +13,7 @@
 import org.enso.compiler.core.ir.Location;
 import org.enso.compiler.core.ir.MetadataStorage;
 import org.enso.compiler.core.ir.Module;
+import org.enso.compiler.core.ir.Name;
 import org.enso.persist.Persistable;
 import org.enso.persist.Persistance;
 import org.junit.Before;
@@ -413,6 +414,17 @@ public void writeReplaceReference() throws Exception {
     assertEquals("Multiplied on write", 15, (int) plain.get(IntegerSupply.class).supply().get());
   }
 
+  @Test
+  public void nameLiteral() throws Exception {
+    var loc = new IdentifiedLocation(new Location(5, 19), null);
+    var in =
+        new Name.Literal("anyName", true, Option.apply(loc), Option.empty(), new MetadataStorage());
+
+    var out = serde(Name.Literal.class, in, 50);
+    assertEquals("They are structuraly equal", 0, IR.STRUCTURE_COMPARATOR.compare(in, out));
+    assertNotEquals("But not .equals (currently)", in, out);
+  }
+
   private static <T> T serde(Class<T> clazz, T l, int expectedSize) throws IOException {
     return serde(clazz, l, expectedSize, null);
   }

lib/java/persistance/src/main/java/org/enso/persist/PerInputImpl.java

@@ -7,6 +7,7 @@
 import java.io.DataInputStream;
 import java.io.IOException;
 import java.nio.ByteBuffer;
+import java.util.Comparator;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
@@ -219,7 +220,7 @@ static Object readIndirect(InputCache cache, PerMap map, Input in) throws IOExce
     res = cache.resolveObject(res);
     var prev = cache.putObjectAt(at, res);
     if (prev != null) {
-      var bothObjectsAreTheSame = Objects.equals(res, prev);
+      var bothObjectsAreTheSame = gentlyEquals(res, prev);
       var sb = new StringBuilder();
       sb.append("Adding at ").append(at).append(" object:\n  ");
       dumpObject(sb, res);
@@ -236,6 +237,29 @@ static Object readIndirect(InputCache cache, PerMap map, Input in) throws IOExce
     return res;
   }
 
+  private static Class<?> irClass;
+  private static Comparator STRUCTURE_COMPARATOR;
+
+  @SuppressWarnings("unchecked")
+  private static boolean gentlyEquals(Object o1, Object o2) {
+    if (Objects.equals(o1, o2)) {
+      return true;
+    }
+    try {
+      if (STRUCTURE_COMPARATOR == null) {
+        irClass = Class.forName("org.enso.compiler.core.IR");
+        var comparatorField = irClass.getField("STRUCTURE_COMPARATOR");
+        STRUCTURE_COMPARATOR = (java.util.Comparator) comparatorField.get(null);
+      }
+      if (irClass.isInstance(o1) && irClass.isInstance(o2)) {
+        return STRUCTURE_COMPARATOR.compare(o1, o2) == 0;
+      }
+    } catch (ReflectiveOperationException ex) {
+      PerUtils.LOG.warn("Cannot compare " + o1.getClass(), ex);
+    }
+    return false;
+  }
+
   private static void dumpObject(StringBuilder sb, Object obj) {
     sb.append(obj.getClass().getName())
         .append("@")