Fixes to Persistance

build.sbt

@@ -1258,6 +1258,7 @@ lazy val `persistance` = (project in file("lib/java/persistance"))
     commands += WithDebugCommand.withDebug,
     frgaalJavaCompilerSetting,
     Compile / javacOptions := ((Compile / javacOptions).value),
+    inConfig(Compile)(truffleRunOptionsSettings),
     libraryDependencies ++= Seq(
       "org.slf4j"        % "slf4j-api"               % slf4jVersion,
       "org.netbeans.api" % "org-openide-util-lookup" % netbeansApiVersion,

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

@@ -1,6 +1,8 @@
 package org.enso.compiler.core.ir;
 
 import java.io.IOException;
+import java.util.AbstractList;
+import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.UUID;
@@ -192,33 +194,89 @@ protected Double readObject(Input in) throws IOException, ClassNotFoundException
     }
   }
 
+  /**
+   * The persistance for Scala List is needed, because some places expect the more general List type
+   * instead of Seq.
+   *
+   * <p>Because List is a subtype of Seq and can be deserialized using any of the two persistance
+   * implementations, we want to ensure that the format of both is compatible. Seq is generally
+   * preferred as it can be lazy.
+   */
   @ServiceProvider(service = Persistance.class)
   public static final class PersistScalaList extends Persistance<List> {
     public PersistScalaList() {
       super(List.class, true, 4432);
     }
 
+    private final PersistScalaSeq underlying = new PersistScalaSeq();
+
     @Override
     protected void writeObject(List list, Output out) throws IOException {
+      underlying.writeObject(list, out);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    protected List readObject(Input in) throws IOException, ClassNotFoundException {
+      // Algorithm that is aligned with `underlying`, but is not lazy.
+      var builder = List.newBuilder();
+      var size = in.readInt();
+      for (var i = 0; i < size; i++) {
+        var elem = in.readObject();
+        builder.addOne(elem);
+      }
+      return builder.result();
+    }
+  }
+
+  /**
+   * Persistance for Java List.
+   *
+   * <p>When reading back, the deserialization is done lazily.
+   */
+  @ServiceProvider(service = Persistance.class)
+  public static final class PersistJavaListLazy extends Persistance<java.util.List> {
+    public PersistJavaListLazy() {
+      super(java.util.List.class, true, 34011);
+    }
+
+    @Override
+    protected void writeObject(java.util.List list, Output out) throws IOException {
       var size = list.size();
       out.writeInt(size);
-      var l = list.reverse();
       for (var i = 0; i < size; i++) {
-        out.writeObject(l.head());
-        l = (List) l.tail();
+        out.writeObject(list.get(i));
       }
     }
 
     @Override
-    @SuppressWarnings("unchecked")
-    protected List readObject(Input in) throws IOException, ClassNotFoundException {
+    protected java.util.List readObject(Input in) throws IOException, ClassNotFoundException {
       var size = in.readInt();
-      List list = scala.collection.immutable.Nil$.MODULE$;
+      var references = new ArrayList<Reference<Object>>(size);
       for (var i = 0; i < size; i++) {
-        var elem = in.readObject();
-        list = scala.collection.immutable.$colon$colon$.MODULE$.apply(elem, list);
+        var elem = in.readReference(Object.class);
+        references.add(elem);
+      }
+
+      return new ListOfReferences(references);
+    }
+
+    private static class ListOfReferences extends AbstractList<Object> {
+      private final java.util.List<Reference<Object>> references;
+
+      public ListOfReferences(java.util.List<Reference<Object>> references) {
+        this.references = references;
+      }
+
+      @Override
+      public Object get(int index) {
+        return references.get(index).get(Object.class);
+      }
+
+      @Override
+      public int size() {
+        return references.size();
       }
-      return list;
     }
   }
 
@@ -351,11 +409,12 @@ public PersistScalaSeq() {
     }
 
     @Override
-    protected void writeObject(Seq list, Output out) throws IOException {
-      var size = list.size();
+    protected void writeObject(Seq seq, Output out) throws IOException {
+      var size = seq.size();
       out.writeInt(size);
-      for (var i = 0; i < size; i++) {
-        out.writeObject(list.apply(i));
+      var it = seq.iterator();
+      while (it.hasNext()) {
+        out.writeObject(it.next());
       }
     }
 

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

@@ -2,6 +2,7 @@ package org.enso.compiler.core.ir
 
 import org.enso.compiler.core.Implicits.{ShowPassData, ToStringHelper}
 import org.enso.compiler.core.{IR, Identifier}
+import org.enso.persist.Persistance
 
 import java.util.UUID
 
@@ -36,22 +37,24 @@ object Function {
     * better optimisation.
     *
     * @param arguments   the arguments to the lambda
-    * @param body        the body of the lambda
+    * @param bodyReference the body of the lambda, stored as a reference to ensure
+    *                     laziness of storage
     * @param location    the source location that the node corresponds to
     * @param canBeTCO    whether or not the function can be tail-call optimised
     * @param passData    the pass metadata associated with this node
     * @param diagnostics compiler diagnostics for this node
     */
   sealed case class Lambda(
     override val arguments: List[DefinitionArgument],
-    bodySeq: Seq[Expression],
+    bodyReference: Persistance.Reference[Expression],
     location: Option[IdentifiedLocation],
     override val canBeTCO: Boolean,
     passData: MetadataStorage,
     diagnostics: DiagnosticStorage
   ) extends Function
       with IRKind.Primitive
       with LazyId {
+
     def this(
       arguments: List[DefinitionArgument],
       body: Expression,
@@ -60,9 +63,17 @@ object Function {
       passData: MetadataStorage      = new MetadataStorage(),
       diagnostics: DiagnosticStorage = new DiagnosticStorage()
     ) = {
-      this(arguments, Seq(body), location, canBeTCO, passData, diagnostics)
+      this(
+        arguments,
+        Persistance.Reference.of(body, true),
+        location,
+        canBeTCO,
+        passData,
+        diagnostics
+      )
     }
-    override lazy val body = bodySeq.head
+
+    override lazy val body: Expression = bodyReference.get(classOf[Expression])
 
     /** Creates a copy of `this`.
       *
@@ -85,7 +96,14 @@ object Function {
       id: UUID @Identifier                 = id
     ): Lambda = {
       val res =
-        Lambda(arguments, Seq(body), location, canBeTCO, passData, diagnostics)
+        Lambda(
+          arguments,
+          Persistance.Reference.of(body, false),
+          location,
+          canBeTCO,
+          passData,
+          diagnostics
+        )
       res.id = id
       res
     }

engine/runtime-parser/src/main/scala/org/enso/compiler/core/ir/module/scope/definition/Method.scala

@@ -5,6 +5,7 @@ package definition
 
 import org.enso.compiler.core.Implicits.{ShowPassData, ToStringHelper}
 import org.enso.compiler.core.{IR, Identifier}
+import org.enso.persist.Persistance
 
 import java.util.UUID
 
@@ -41,14 +42,14 @@ object Method {
   /** The definition of a method for a given constructor.
     *
     * @param methodReference a reference to the method being defined
-    * @param body            the body of the method
+    * @param bodyReference   the body of the method
     * @param location        the source location that the node corresponds to
     * @param passData        the pass metadata associated with this node
     * @param diagnostics     compiler diagnostics for this node
     */
   sealed case class Explicit(
     override val methodReference: Name.MethodReference,
-    val bodySeq: Seq[Expression],
+    val bodyReference: Persistance.Reference[Expression],
     val isStatic: Boolean,
     val isStaticWrapperForInstanceMethod: Boolean,
     override val location: Option[IdentifiedLocation],
@@ -66,7 +67,7 @@ object Method {
     ) = {
       this(
         methodReference,
-        Seq(body),
+        Persistance.Reference.of(body, false),
         Explicit.computeIsStatic(body),
         Explicit.computeIsStaticWrapperForInstanceMethod(body),
         location,
@@ -75,7 +76,7 @@ object Method {
       );
     }
 
-    lazy val body = bodySeq.head
+    lazy val body: Expression = bodyReference.get(classOf[Expression])
 
     /** Creates a copy of `this`.
       *
@@ -100,7 +101,7 @@ object Method {
     ): Explicit = {
       val res = Explicit(
         methodReference,
-        List(body),
+        Persistance.Reference.of(body, false),
         isStatic,
         isStaticWrapperForInstanceMethod,
         location,