3% speedup with LazyMap and MetadataStorage

engine/runtime-compiler/src/main/java/org/enso/compiler/pass/analyse/PassPersistance.java

@@ -3,10 +3,21 @@
 import java.io.IOException;
 import org.enso.compiler.pass.analyse.AliasAnalysis.Graph;
 import org.enso.compiler.pass.resolve.DocumentationComments;
+import org.enso.compiler.pass.resolve.DocumentationComments$;
+import org.enso.compiler.pass.resolve.ExpressionAnnotations$;
 import org.enso.compiler.pass.resolve.FullyQualifiedNames;
+import org.enso.compiler.pass.resolve.GenericAnnotations$;
+import org.enso.compiler.pass.resolve.GlobalNames$;
 import org.enso.compiler.pass.resolve.IgnoredBindings;
+import org.enso.compiler.pass.resolve.IgnoredBindings$;
+import org.enso.compiler.pass.resolve.MethodCalls$;
+import org.enso.compiler.pass.resolve.MethodDefinitions$;
 import org.enso.compiler.pass.resolve.ModuleAnnotations;
+import org.enso.compiler.pass.resolve.ModuleAnnotations$;
+import org.enso.compiler.pass.resolve.Patterns$;
+import org.enso.compiler.pass.resolve.TypeNames$;
 import org.enso.compiler.pass.resolve.TypeSignatures;
+import org.enso.compiler.pass.resolve.TypeSignatures$;
 import org.enso.persist.Persistable;
 import org.enso.persist.Persistance;
 import org.openide.util.lookup.ServiceProvider;
@@ -30,6 +41,23 @@
 @Persistable(clazz = FullyQualifiedNames.FQNResolution.class, id = 1128)
 @Persistable(clazz = FullyQualifiedNames.ResolvedLibrary.class, id = 1129)
 @Persistable(clazz = FullyQualifiedNames.ResolvedModule.class, id = 1130)
+@Persistable(clazz = AliasAnalysis$.class, id = 1201)
+@Persistable(clazz = BindingAnalysis$.class, id = 1202)
+@Persistable(clazz = CachePreferenceAnalysis$.class, id = 1203)
+@Persistable(clazz = DataflowAnalysis$.class, id = 1204)
+@Persistable(clazz = GlobalNames$.class, id = 1205)
+@Persistable(clazz = IgnoredBindings$.class, id = 1206)
+@Persistable(clazz = Patterns$.class, id = 1207)
+@Persistable(clazz = TailCall$.class, id = 1208)
+@Persistable(clazz = TypeNames$.class, id = 1209)
+@Persistable(clazz = TypeSignatures$.class, id = 1210)
+@Persistable(clazz = DocumentationComments$.class, id = 1211)
+@Persistable(clazz = ModuleAnnotations$.class, id = 1212)
+@Persistable(clazz = GatherDiagnostics$.class, id = 1213)
+@Persistable(clazz = MethodCalls$.class, id = 1214)
+@Persistable(clazz = MethodDefinitions$.class, id = 1215)
+@Persistable(clazz = GenericAnnotations$.class, id = 1216)
+@Persistable(clazz = ExpressionAnnotations$.class, id = 1217)
 public final class PassPersistance {
   private PassPersistance() {}
 

engine/runtime-compiler/src/main/scala/org/enso/compiler/phase/ImportResolver.scala

@@ -20,6 +20,7 @@ import org.enso.compiler.pass.analyse.BindingAnalysis
 import org.enso.editions.LibraryName
 import org.enso.polyglot.CompilationStage
 import scala.collection.mutable
+import java.io.IOException
 
 /** Runs imports resolution. Starts from a given module and then recursively
   * collects all modules that are reachable from it.
@@ -47,11 +48,27 @@ class ImportResolver(compiler: Compiler) {
 
     def analyzeModule(current: Module): List[Module] = {
       val context = compiler.context
-      val ir      = context.getIr(current)
-      val currentLocal = ir.unsafeGetMetadata(
-        BindingAnalysis,
-        "Non-parsed module used in ImportResolver"
-      )
+      val (ir, currentLocal) =
+        try {
+          val ir = context.getIr(current)
+          val currentLocal = ir.unsafeGetMetadata(
+            BindingAnalysis,
+            "Non-parsed module used in ImportResolver"
+          )
+          (ir, currentLocal)
+        } catch {
+          case _: IOException =>
+            context.updateModule(
+              current,
+              u => {
+                u.ir(null)
+                u.compilationStage(CompilationStage.INITIAL)
+                u.invalidateCache()
+              }
+            )
+            compiler.ensureParsed(current)
+            return analyzeModule(current)
+        }
       // put the list of resolved imports in the module metadata
       if (
         context

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

@@ -0,0 +1,85 @@
+package org.enso.compiler.core.ir;
+
+import java.io.IOException;
+import java.util.AbstractMap;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
+import org.enso.persist.Persistance;
+import org.enso.persist.Persistance.Reference;
+
+
+final class IrLazyMap<K, V> extends AbstractMap<K, V> {
+  private final Map<K, Entry<K, V>> delegate;
+
+  @SuppressWarnings("unchecked")
+  IrLazyMap(Persistance.Input in) throws IOException {
+    var map = new LinkedHashMap<K, Entry<K, V>>();
+    var n = in.readInt();
+    for (var i = 0; i < n; i++) {
+      var key = (K) in.readObject();
+      var ref = (Reference<V>) in.readReference(Object.class);
+      var en = new En<>(key, ref);
+      map.put(key, en);
+    }
+    this.delegate = map;
+  }
+
+  @Override
+  public Set<Entry<K, V>> entrySet() {
+    return new LinkedHashSet<>(this.delegate.values());
+  }
+
+  @Override
+  public V get(Object key) {
+    var entry = this.delegate.get(key);
+    return entry == null ? null : entry.getValue();
+  }
+
+  private static final class En<K, V> implements Entry<K, V> {
+    private final K key;
+    private final Reference<V> ref;
+
+    En(K key, Reference<V> ref) {
+      this.key = key;
+      this.ref = ref;
+    }
+
+    @Override
+    public K getKey() {
+      return key;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public V getValue() {
+      return (V) ref.get(Object.class);
+    }
+
+    @Override
+    public V setValue(V value) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public int hashCode() {
+      int hash = 7;
+      hash = 29 * hash + Objects.hashCode(this.key);
+      return hash;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+      if (this == obj) {
+        return true;
+      }
+      if (obj instanceof En<?, ?> other) {
+        return Objects.equals(this.key, other.key);
+      }
+      return false;
+    }
+  }
+}

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

@@ -1,7 +1,6 @@
 package org.enso.compiler.core.ir;
 
 import java.io.IOException;
-import java.util.HashMap;
 import java.util.Map;
 import java.util.UUID;
 import org.enso.compiler.core.ir.expression.Application;
@@ -230,14 +229,9 @@ protected void writeObject(scala.collection.immutable.Map map, Output out) throw
     @SuppressWarnings("unchecked")
     protected scala.collection.immutable.Map readObject(Input in)
         throws IOException, ClassNotFoundException {
-      var size = in.readInt();
-      var map = scala.collection.immutable.Map$.MODULE$.empty();
-      for (var i = 0; i < size; i++) {
-        var key = in.readObject();
-        var value = in.readObject();
-        map = map.$plus(new Tuple2(key, value));
-      }
-      return map;
+      var map = new IrLazyMap(in);
+      var immutableMap = new IrLazyImMap(map);
+      return immutableMap;
     }
   }
 
@@ -309,13 +303,13 @@ protected scala.collection.immutable.Set readObject(Input in)
   }
 
   @ServiceProvider(service = Persistance.class)
-  public static final class PersistMap extends Persistance<HashMap> {
+  public static final class PersistMap extends Persistance<Map> {
     public PersistMap() {
-      super(HashMap.class, true, 4440);
+      super(Map.class, true, 4440);
     }
 
     @Override
-    protected void writeObject(HashMap m, Output out) throws IOException {
+    protected void writeObject(Map m, Output out) throws IOException {
       var size = m.size();
       out.writeInt(size);
       var it = m.entrySet().iterator();
@@ -328,15 +322,8 @@ protected void writeObject(HashMap m, Output out) throws IOException {
 
     @Override
     @SuppressWarnings("unchecked")
-    protected HashMap readObject(Input in) throws IOException, ClassNotFoundException {
-      var size = in.readInt();
-      var map = new HashMap<Object, Object>();
-      for (var i = 0; i < size; i++) {
-        var key = in.readObject();
-        var value = in.readObject();
-        map.put(key, value);
-      }
-      return map;
+    protected Map readObject(Input in) throws IOException, ClassNotFoundException {
+      return new IrLazyMap(in);
     }
   }
 
@@ -370,7 +357,7 @@ protected Seq readObject(Input in) throws IOException, ClassNotFoundException {
   @ServiceProvider(service = Persistance.class)
   public static final class PersistMetadataStorage extends Persistance<MetadataStorage> {
     public PersistMetadataStorage() {
-      super(MetadataStorage.class, false, 301);
+      super(MetadataStorage.class, false, 381);
     }
 
     @Override
@@ -379,7 +366,7 @@ protected void writeObject(MetadataStorage obj, Output out) throws IOException {
       var map =
           obj.map(
               (processingPass, data) -> {
-                var t = new Tuple2<>(processingPass.getClass().getName(), data);
+                var t = new Tuple2<>(processingPass, data);
                 return t;
               });
       out.writeInline(scala.collection.immutable.Map.class, map);
@@ -388,19 +375,8 @@ protected void writeObject(MetadataStorage obj, Output out) throws IOException {
     @Override
     @SuppressWarnings("unchecked")
     protected MetadataStorage readObject(Input in) throws IOException, ClassNotFoundException {
-      var storage = new MetadataStorage(nil());
       var map = in.readInline(scala.collection.immutable.Map.class);
-      var it = map.iterator();
-      while (it.hasNext()) {
-        var obj = (Tuple2<String, ProcessingPass.Metadata>) it.next();
-        try {
-          var pass = (ProcessingPass) Class.forName(obj._1()).getField("MODULE$").get(null);
-          var data = obj._2();
-          storage.update(pass, data);
-        } catch (ReflectiveOperationException ex) {
-          throw new IOException(ex);
-        }
-      }
+      var storage = new MetadataStorage(map);
       return storage;
     }
   }

engine/runtime-parser/src/main/scala/org/enso/compiler/core/ir/IrLazyImMap.scala

@@ -0,0 +1,37 @@
+package org.enso.compiler.core.ir
+
+import scala.collection.immutable.StrictOptimizedMapOps
+import scala.collection.immutable.Map
+import scala.collection.Iterator
+
+final private class IrLazyImMap[K, V](
+  val underlying: java.util.Map[K, V]
+) extends Map[K, V]
+    with StrictOptimizedMapOps[K, V, Map, Map[K, V]] {
+  def removed(key: K) =
+    new scala.jdk.CollectionConverters.MapHasAsScala(underlying).asScala.toMap
+      .removed(key)
+
+  def updated[V1 >: V](key: K, value: V1) =
+    new scala.jdk.CollectionConverters.MapHasAsScala(underlying).asScala.toMap
+      .updated(key, value)
+
+  def get(key: K) = Option(underlying.get(key))
+
+  def iterator = new Iterator[(K, V)]() {
+    val keys             = underlying.entrySet().iterator()
+    def hasNext: Boolean = keys.hasNext()
+    def next(): (K, V) = {
+      val entry = keys.next()
+      (entry.getKey, entry.getValue)
+    }
+  }
+
+  override def size = underlying.size
+
+  // Has to override the `contains` method because the underlying implementation
+  // calls `get(key)`
+  override def contains(key: K): Boolean = {
+    underlying.containsKey(key)
+  }
+}

engine/runtime-parser/src/main/scala/org/enso/compiler/core/ir/MetadataStorage.scala

@@ -12,11 +12,15 @@ import org.enso.compiler.core.CompilerStub
   */
 //noinspection DuplicatedCode
 final class MetadataStorage(
-  startingMeta: Seq[MetadataPair[_]] = Seq()
-) extends Serializable {
-  private var metadata: Map[ProcessingPass, Any] = Map(
-    startingMeta.map(_.asPair.asInstanceOf[(ProcessingPass, Any)]): _*
-  )
+  private var metadata: Map[ProcessingPass, Any]
+) {
+  def this(startingMeta: Seq[MetadataPair[_]] = Seq()) = {
+    this(
+      Map(
+        startingMeta.map(_.asPair.asInstanceOf[(ProcessingPass, Any)]): _*
+      )
+    )
+  }
 
   /** Adds a metadata pair to the node metadata.
     *