Avoid AliasAnalysis for Hello_World.enso

engine/runtime-compiler/src/main/scala/org/enso/compiler/data/BindingsMap.scala

@@ -15,6 +15,7 @@ import org.enso.compiler.pass.analyse.BindingAnalysis
 import org.enso.compiler.pass.resolve.MethodDefinitions
 import org.enso.persist.Persistance.Reference
 import org.enso.pkg.QualifiedName
+import org.enso.editions.LibraryName
 
 import java.io.ObjectOutputStream
 import scala.annotation.unused
@@ -26,8 +27,8 @@ import scala.collection.mutable.ArrayBuffer
   * @param currentModule the module holding these bindings
   */
 case class BindingsMap(
-  definedEntities: List[DefinedEntity],
-  currentModule: ModuleReference
+  private val _definedEntities: List[DefinedEntity],
+  private var _currentModule: ModuleReference
 ) extends IRPass.IRMetadata {
   import BindingsMap._
 
@@ -37,11 +38,38 @@ case class BindingsMap(
 
   /** Other modules, imported by [[currentModule]].
     */
-  var resolvedImports: List[ResolvedImport] = List()
+  private var _resolvedImports: List[ResolvedImport] = List()
+
+  def definedEntities: List[DefinedEntity] = {
+    ensureConvertedToConcrete()
+    _definedEntities
+  }
+  def currentModule: ModuleReference = {
+    ensureConvertedToConcrete()
+    _currentModule
+  }
+  def resolvedImports: List[ResolvedImport] = {
+    ensureConvertedToConcrete()
+    _resolvedImports
+  }
+  def resolvedImports_(v: List[ResolvedImport]): Unit = {
+    _resolvedImports = v
+  }
+
+  /** Set to non-null after deserialization to signal that conversion to concrete values is needed */
+  private var pendingRepository: PackageRepository = null
 
   /** Symbols exported by [[currentModule]].
     */
-  var exportedSymbols: Map[String, List[ResolvedName]] = Map()
+  private var _exportedSymbols: Map[String, List[ResolvedName]] = Map()
+
+  def exportedSymbols: Map[String, List[ResolvedName]] = {
+    ensureConvertedToConcrete()
+    _exportedSymbols
+  }
+  def exportedSymbols_(v: Map[String, List[ResolvedName]]): Unit = {
+    _exportedSymbols = v
+  }
 
   /** @inheritdoc */
   override def prepareForSerialization(
@@ -54,18 +82,18 @@ case class BindingsMap(
   override def restoreFromSerialization(
     compiler: Compiler
   ): Option[BindingsMap] = {
-    val packageRepository = compiler.getPackageRepository
-    this.toConcrete(packageRepository.getModuleMap)
+    this.pendingRepository = compiler.getPackageRepository
+    Some(this)
   }
 
   /** Convert this [[BindingsMap]] instance to use abstract module references.
     *
     * @return `this` with module references converted to abstract
     */
   def toAbstract: BindingsMap = {
-    val copy = this.copy(currentModule = currentModule.toAbstract)
-    copy.resolvedImports = this.resolvedImports.map(_.toAbstract)
-    copy.exportedSymbols = this.exportedSymbols.map { case (key, value) =>
+    val copy = this.copy(_currentModule = _currentModule.toAbstract)
+    copy._resolvedImports = this._resolvedImports.map(_.toAbstract)
+    copy._exportedSymbols = this._exportedSymbols.map { case (key, value) =>
       key -> value.map(name => name.toAbstract)
     }
     copy
@@ -77,23 +105,55 @@ case class BindingsMap(
     *                  instances
     * @return `this` with module references converted to concrete
     */
-  def toConcrete(moduleMap: ModuleMap): Option[BindingsMap] = {
-    val newMap = this.currentModule.toConcrete(moduleMap).map { module =>
-      this.copy(currentModule = module)
+  private def ensureConvertedToConcrete(): Option[BindingsMap] = {
+    val r = pendingRepository
+    if (r != null) {
+      val res = toConcrete(r, r.getModuleMap).map { b =>
+        pendingRepository     = null
+        this._currentModule   = b._currentModule
+        this._exportedSymbols = b._exportedSymbols
+        this._resolvedImports = b._resolvedImports
+        this
+      }
+      res
+    } else {
+      Some(this)
     }
+  }
+
+  private def toConcrete(
+    r: PackageRepository,
+    moduleMap: ModuleMap
+  ): Option[BindingsMap] = {
+    val newMap = this._currentModule
+      .toConcrete(moduleMap)
+      .map { c =>
+        this._currentModule = c
+        c
+      }
+      .map { module =>
+        this.copy(_currentModule = module)
+      }
 
     val withImports: Option[BindingsMap] = newMap.flatMap { bindings =>
-      val newImports = this.resolvedImports.map(_.toConcrete(moduleMap))
+      val newImports = this._resolvedImports.map { imp =>
+        imp.targets.map { t =>
+          r.ensurePackageIsLoaded(
+            LibraryName(t.qualifiedName.path(0), t.qualifiedName.path(1))
+          )
+        }
+        imp.toConcrete(moduleMap)
+      }
       if (newImports.exists(_.isEmpty)) {
         None
       } else {
-        bindings.resolvedImports = newImports.map(_.get)
+        bindings._resolvedImports = newImports.map(_.get)
         Some(bindings)
       }
     }
 
     val withSymbols: Option[BindingsMap] = withImports.flatMap { bindings =>
-      val newSymbols = this.exportedSymbols.map { case (key, value) =>
+      val newSymbols = this._exportedSymbols.map { case (key, value) =>
         val newValue = value.map(_.toConcrete(moduleMap))
         if (newValue.exists(_.isEmpty)) {
           key -> None
@@ -105,7 +165,7 @@ case class BindingsMap(
       if (newSymbols.exists { case (_, v) => v.isEmpty }) {
         None
       } else {
-        bindings.exportedSymbols = newSymbols.map { case (k, v) =>
+        bindings._exportedSymbols = newSymbols.map { case (k, v) =>
           k -> v.get
         }
         Some(bindings)

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

@@ -11,6 +11,7 @@ import org.enso.common.CompilationStage
 
 import scala.collection.mutable
 import java.io.IOException
+import java.util.logging.Level
 
 /** Runs imports resolution. Starts from a given module and then recursively
   * collects all modules that are reachable from it.
@@ -46,7 +47,12 @@ final class ImportResolver(compiler: Compiler) extends ImportResolverForIR {
           )
           (ir, currentLocal)
         } catch {
-          case _: IOException =>
+          case ex: IOException =>
+            context.logSerializationManager(
+              Level.WARNING,
+              "Deserialization of " + module.getName() + " failed",
+              ex
+            )
             context.updateModule(
               current,
               u => {
@@ -83,8 +89,9 @@ final class ImportResolver(compiler: Compiler) extends ImportResolverForIR {
         val newImportIRs =
           importedModules.map(_._1) ++ syntheticImports.map(_._1)
 
-        currentLocal.resolvedImports =
+        currentLocal.resolvedImports_(
           resolvedImports ++ resolvedSyntheticImports
+        )
         val newIr = ir.copy(imports = newImportIRs)
         context.updateModule(
           current,

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

@@ -166,7 +166,7 @@ class ExportsResolution(private val context: CompilerContext) {
           .flatten
           .distinct
 
-      bindings.exportedSymbols = List(
+      val newSymbols = List(
         ownEntities,
         expSymbolsFromResolvedImps
       ).flatten.distinct
@@ -179,6 +179,7 @@ class ExportsResolution(private val context: CompilerContext) {
           }
           (symbolName, resolvedNames)
         }
+      bindings.exportedSymbols_(newSymbols)
     }
   }
 

engine/runtime/src/main/java/org/enso/interpreter/caches/ImportExportCache.java

@@ -237,8 +237,8 @@ protected BindingsMap readObject(Input in) throws IOException, ClassNotFoundExce
       var imp = in.readInline(scala.collection.immutable.List.class);
       var sym = in.readInline(scala.collection.immutable.Map.class);
       var map = new BindingsMap(de, cm);
-      map.resolvedImports_$eq(imp);
-      map.exportedSymbols_$eq(sym);
+      map.resolvedImports_(imp);
+      map.exportedSymbols_(sym);
       return map;
     }
   }