Pre compute suggestion db during build time

engine/language-server/src/main/scala/org/enso/languageserver/search/SuggestionsHandler.scala

@@ -111,6 +111,10 @@ final class SuggestionsHandler(
       .subscribe(self, classOf[Api.ExpressionUpdates])
     context.system.eventStream
       .subscribe(self, classOf[Api.SuggestionsDatabaseModuleUpdateNotification])
+    context.system.eventStream.subscribe(
+      self,
+      classOf[Api.SuggestionsDatabaseSuggestionsLoadedNotification]
+    )
     context.system.eventStream
       .subscribe(self, classOf[Api.LibraryLoaded])
     context.system.eventStream.subscribe(self, classOf[ProjectNameChangedEvent])
@@ -204,6 +208,9 @@ final class SuggestionsHandler(
         initialized(projectName, graph, clients - client.clientId, state)
       )
 
+    case msg: Api.SuggestionsDatabaseSuggestionsLoadedNotification =>
+      applyLoadedSuggestions(msg.suggestions)
+
     case msg: Api.SuggestionsDatabaseModuleUpdateNotification
         if state.isSuggestionUpdatesRunning =>
       state.suggestionUpdatesQueue.enqueue(msg)
@@ -517,6 +524,48 @@ final class SuggestionsHandler(
     }
   }
 
+  /** Handle the suggestions of the loaded library.
+    *
+    * Adds the new suggestions to the suggestions database and sends the
+    * appropriate notification to the client.
+    *
+    * @param suggestions the loaded suggestions
+    * @return the API suggestions database update notification
+    */
+  private def applyLoadedSuggestions(
+    suggestions: Vector[Suggestion]
+  ): Future[SuggestionsDatabaseUpdateNotification] = {
+    for {
+      treeResults <- suggestionsRepo.applyTree(
+        suggestions.map(Api.SuggestionUpdate(_, Api.SuggestionAction.Add()))
+      )
+      version <- suggestionsRepo.currentVersion
+    } yield {
+      val treeUpdates = treeResults.flatMap {
+        case QueryResult(ids, Api.SuggestionUpdate(suggestion, action)) =>
+          val verb = action.getClass.getSimpleName
+          action match {
+            case Api.SuggestionAction.Add() =>
+              if (ids.isEmpty) {
+                logger.error("Cannot {} [{}].", verb, suggestion)
+              }
+              ids.map(
+                SuggestionsDatabaseUpdate.Add(
+                  _,
+                  generateDocumentation(suggestion)
+                )
+              )
+            case action =>
+              logger.error(
+                s"Invalid action during suggestions loading [$action]."
+              )
+              Seq()
+          }
+      }
+      SuggestionsDatabaseUpdateNotification(version, treeUpdates)
+    }
+  }
+
   /** Handle the suggestions database update.
     *
     * Function applies notification updates on the suggestions database and

engine/polyglot-api/src/main/scala/org/enso/polyglot/runtime/Runtime.scala

@@ -205,6 +205,10 @@ object Runtime {
         value = classOf[Api.SuggestionsDatabaseModuleUpdateNotification],
         name  = "suggestionsDatabaseModuleUpdateNotification"
       ),
+      new JsonSubTypes.Type(
+        value = classOf[Api.SuggestionsDatabaseSuggestionsLoadedNotification],
+        name  = "suggestionsDatabaseSuggestionsLoadedNotification"
+      ),
       new JsonSubTypes.Type(
         value = classOf[Api.AnalyzeModuleInScopeJobFinished],
         name  = "analyzeModuleInScopeJobFinished"
@@ -260,6 +264,10 @@ object Runtime {
       new JsonSubTypes.Type(
         value = classOf[Api.LockReleaseFailed],
         name  = "lockReleaseFailed"
+      ),
+      new JsonSubTypes.Type(
+        value = classOf[Api.DeserializeLibrarySuggestions],
+        name  = "deserializeLibrarySuggestions"
       )
     )
   )
@@ -1506,6 +1514,22 @@ object Runtime {
         ")"
     }
 
+    /** A notification about the suggestions of the loaded library.
+      *
+      * @param suggestions the loaded suggestions
+      */
+    final case class SuggestionsDatabaseSuggestionsLoadedNotification(
+      suggestions: Vector[Suggestion]
+    ) extends ApiNotification
+        with ToLogString {
+
+      /** @inheritdoc */
+      override def toLogString(shouldMask: Boolean): String =
+        "SuggestionsDatabaseSuggestionsLoadedNotification(" +
+        s"suggestions=${suggestions.map(_.toLogString(shouldMask))}" +
+        ")"
+    }
+
     /** A notification about the finished background analyze job. */
     final case class AnalyzeModuleInScopeJobFinished() extends ApiNotification
 
@@ -1628,6 +1652,16 @@ object Runtime {
       */
     final case class LockReleaseFailed(errorMessage: String) extends ApiResponse
 
+    /** A request to deserialize the library suggestions.
+      *
+      * Does not have a companion response message. The response will be
+      * delivered asynchronously as a notification.
+      *
+      * @param libraryName the name of the loaded library.
+      */
+    final case class DeserializeLibrarySuggestions(libraryName: LibraryName)
+        extends ApiRequest
+
     private lazy val mapper = {
       val factory = new CBORFactory()
       val mapper  = new ObjectMapper(factory) with ClassTagExtensions

engine/runtime/src/main/java/org/enso/compiler/SuggestionsCache.java

@@ -69,7 +69,7 @@ protected Optional<Metadata> metadataFromBytes(byte[] bytes) {
   @Override
   protected Optional<String> computeDigest(CachedSuggestions entry, TruffleLogger logger) {
     var digest = messageDigest();
-    entry.getSuggestions().getSuggestions().forEach(suggestion -> {
+    entry.getSuggestions().forEach(suggestion -> {
       ByteBuffer bytes = ByteBuffer.allocate(Integer.BYTES).putInt(suggestion.hashCode());
       digest.update(bytes);
     });
@@ -107,7 +107,7 @@ protected Optional<Roots> getCacheRoots(EnsoContext context) {
 
   @Override
   protected Object extractObjectToSerialize(CachedSuggestions entry) {
-    return entry.getSuggestions();
+    return entry.getSuggestionsObjectToSerialize();
   }
 
   // Suggestions class is not a record because of a Frgaal bug leading to invalid compilation error.
@@ -125,7 +125,7 @@ public List<Suggestion> getSuggestions() {
   }
 
   // CachedSuggestions class is not a record because of a Frgaal bug leading to invalid compilation error.
-  final static class CachedSuggestions {
+  public final static class CachedSuggestions {
 
     private final LibraryName libraryName;
     private final Suggestions suggestions;
@@ -139,9 +139,13 @@ public LibraryName getLibraryName() {
       return libraryName;
     }
 
-    public Suggestions getSuggestions() {
+    public Suggestions getSuggestionsObjectToSerialize() {
       return suggestions;
     }
+
+    public List<Suggestion> getSuggestions() {
+      return suggestions.getSuggestions();
+    }
   }
 
   record Metadata(

engine/runtime/src/main/java/org/enso/interpreter/service/ExecutionService.java

@@ -4,8 +4,6 @@
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.TruffleLogger;
 import com.oracle.truffle.api.instrumentation.EventBinding;
-import com.oracle.truffle.api.instrumentation.ExecutionEventListener;
-import com.oracle.truffle.api.instrumentation.ExecutionEventNode;
 import com.oracle.truffle.api.instrumentation.ExecutionEventNodeFactory;
 import com.oracle.truffle.api.interop.ArityException;
 import com.oracle.truffle.api.interop.InteropLibrary;

engine/runtime/src/main/scala/org/enso/compiler/Compiler.scala

@@ -138,6 +138,10 @@ class Compiler(
     }
   }
 
+  /** @return the serialization manager instance. */
+  def getSerializationManager: SerializationManager =
+    serializationManager
+
   /** Processes the provided language sources, registering any bindings in the
     * given scope.
     *

engine/runtime/src/main/scala/org/enso/compiler/SerializationManager.scala

@@ -262,6 +262,33 @@ class SerializationManager(compiler: Compiler) {
     }
   }
 
+  def deserializeSuggestions(
+    libraryName: LibraryName
+  ): Option[SuggestionsCache.CachedSuggestions] = {
+    if (isWaitingForSerialization(libraryName)) {
+      abort(libraryName)
+      None
+    } else {
+      while (isSerializingLibrary(libraryName)) {
+        Thread.sleep(100)
+      }
+      new SuggestionsCache(libraryName).load(compiler.context).toScala match {
+        case result @ Some(_: SuggestionsCache.CachedSuggestions) =>
+          logger.log(
+            Level.FINE,
+            s"Restored suggestions for library [$libraryName]."
+          )
+          result
+        case _ =>
+          logger.log(
+            Level.FINEST,
+            s"Unable to load suggestions for library [$libraryName]."
+          )
+          None
+      }
+    }
+  }
+
   def deserializeLibraryBindings(
     libraryName: LibraryName
   ): Option[ImportExportCache.CachedBindings] = {

engine/runtime/src/main/scala/org/enso/interpreter/instrument/Handler.scala

@@ -17,9 +17,7 @@ import org.graalvm.polyglot.io.MessageEndpoint
 import java.nio.ByteBuffer
 import scala.concurrent.Future
 
-/** A message endpoint implementation used by the
-  * [[org.enso.interpreter.instrument.RuntimeServerInstrument]].
-  */
+/** A message endpoint implementation. */
 class Endpoint(handler: Handler)
     extends MessageEndpoint
     with RuntimeServerConnectionEndpoint {
@@ -47,6 +45,15 @@ class Endpoint(handler: Handler)
   def sendToClient(msg: Api.Response): Unit =
     client.sendBinary(Api.serialize(msg))
 
+  /** Sends a notification to the runtime.
+    *
+    * Can be used to start a command processing in the background.
+    *
+    * @param msg the message to send.
+    */
+  def sendToSelf(msg: Api.Request): Unit =
+    client.sendBinary(Api.serialize(msg))
+
   /** Sends a request to the connected client and expects a reply. */
   override def sendRequest(msg: ApiRequest): Future[ApiResponse] =
     reverseRequestEndpoint.sendRequest(msg)

engine/runtime/src/main/scala/org/enso/interpreter/instrument/NotificationHandler.scala

@@ -115,14 +115,21 @@ object NotificationHandler {
       libraryName: LibraryName,
       libraryVersion: LibraryVersion,
       location: Path
-    ): Unit = sendMessage(
-      Api.LibraryLoaded(
-        namespace = libraryName.namespace,
-        name      = libraryName.name,
-        version   = libraryVersion.toString,
-        location  = location.toFile
+    ): Unit = {
+      sendMessage(
+        Api.LibraryLoaded(
+          namespace = libraryName.namespace,
+          name      = libraryName.name,
+          version   = libraryVersion.toString,
+          location  = location.toFile
+        )
       )
-    )
+      endpoint.sendToSelf(
+        Api.Request(
+          Api.DeserializeLibrarySuggestions(libraryName)
+        )
+      )
+    }
 
     /** @inheritdoc */
     override def trackProgress(message: String, task: TaskProgress[_]): Unit = {

engine/runtime/src/main/scala/org/enso/interpreter/instrument/command/CommandFactory.scala

@@ -59,6 +59,9 @@ object CommandFactory {
       case _: Api.GetTypeGraphRequest =>
         new GetTypeGraphCommand(request.requestId)
 
+      case payload: Api.DeserializeLibrarySuggestions =>
+        new DeserializeLibrarySuggestionsCmd(request.requestId, payload)
+
       case Api.ShutDownRuntimeServer() =>
         throw new IllegalArgumentException(
           "ShutDownRuntimeServer request is not convertible to command object"

engine/runtime/src/main/scala/org/enso/interpreter/instrument/command/DeserializeLibrarySuggestionsCmd.scala

@@ -0,0 +1,26 @@
+package org.enso.interpreter.instrument.command
+
+import org.enso.interpreter.instrument.execution.RuntimeContext
+import org.enso.interpreter.instrument.job.DeserializeLibrarySuggestionsJob
+import org.enso.polyglot.runtime.Runtime.Api
+
+import scala.concurrent.{ExecutionContext, Future}
+
+/** A command that initiates the deserialization of suggestions.
+  *
+  * @param maybeRequestId an option with request id
+  */
+class DeserializeLibrarySuggestionsCmd(
+  maybeRequestId: Option[Api.RequestId],
+  request: Api.DeserializeLibrarySuggestions
+) extends Command(maybeRequestId) {
+
+  /** @inheritdoc */
+  override def execute(implicit
+    ctx: RuntimeContext,
+    ec: ExecutionContext
+  ): Future[Unit] =
+    ctx.jobProcessor.run(
+      new DeserializeLibrarySuggestionsJob(request.libraryName)
+    )
+}

engine/runtime/src/main/scala/org/enso/interpreter/instrument/job/DeserializeLibrarySuggestionsJob.scala

@@ -0,0 +1,37 @@
+package org.enso.interpreter.instrument.job
+
+import org.enso.editions.LibraryName
+import org.enso.interpreter.instrument.execution.RuntimeContext
+import org.enso.polyglot.runtime.Runtime.Api
+
+import scala.jdk.CollectionConverters._
+
+/** A job responsible for deserializing suggestions of loaded library.
+  *
+  * @param libraryName the name of loaded library
+  */
+final class DeserializeLibrarySuggestionsJob(
+  libraryName: LibraryName
+) extends Job[Unit](
+      List(),
+      isCancellable         = false,
+      mayInterruptIfRunning = false
+    ) {
+
+  /** @inheritdoc */
+  override def run(implicit ctx: RuntimeContext): Unit = {
+    val serializationManager =
+      ctx.executionService.getContext.getCompiler.getSerializationManager
+    serializationManager
+      .deserializeSuggestions(libraryName)
+      .foreach { cachedSuggestions =>
+        ctx.endpoint.sendToClient(
+          Api.Response(
+            Api.SuggestionsDatabaseSuggestionsLoadedNotification(
+              cachedSuggestions.getSuggestions.asScala.toVector
+            )
+          )
+        )
+      }
+  }
+}