Pre compute suggestion db during build time

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

@@ -9,19 +9,20 @@ import java.util.logging.Level
 import com.fasterxml.jackson.databind.ObjectMapper
 import com.fasterxml.jackson.module.scala.ClassTagExtensions
 import com.fasterxml.jackson.module.scala.DefaultScalaModule
-import com.fasterxml.jackson.core.JsonFactory
+import java.nio.charset.StandardCharsets
 
 final class SuggestionsSerializationManager(logger: TruffleLogger) {
 
   /** The debug logging level. */
   private val debugLogLevel = Level.FINE
 
   private lazy val mapper = {
-    val factory = new JsonFactory()
-    val mapper  = new ObjectMapper(factory) with ClassTagExtensions
+    val mapper  = new ObjectMapper() with ClassTagExtensions
     mapper.registerModule(DefaultScalaModule)
   }
 
+  case class SuggetionWithVersion (version : Int, suggestions : Iterable[Suggestion])
+
   def serialize(
     suggestions: Iterable[Suggestion],
     pkg: Package[TruffleFile]
@@ -37,19 +38,29 @@ final class SuggestionsSerializationManager(logger: TruffleLogger) {
 
       r.createDirectories()
       f = r.resolve("suggestion.json")
-      val json = mapper.writeValueAsString(suggestions)
-      val w    = f.newBufferedWriter()
-      w.write(json)
+      val w    = f.newBufferedWriter(StandardCharsets.UTF_8)
+      w.write(toJson(suggestions))
       w.close()
     } finally {
       System.err.println("Out in " + f)
     }
-
   }
 
+  def toJson(suggestions: Iterable[Suggestion]): String = new String(mapper
+    .writerWithDefaultPrettyPrinter()
+    .writeValueAsBytes(new SuggetionWithVersion(5068, suggestions)))
+
   def deserialize(pkg: Package[TruffleFile]): Unit = {
     logger.log(debugLogLevel, "deserialize [{}]", pkg.config.name)
-    throw new UnsupportedOperationException("deserialize: " + pkg.root)
+    var f: TruffleFile = null
+    try {
+      val r: TruffleFile = pkg.root.resolve(pkg.config.name)
+      r.createDirectories()
+      f = r.resolve("suggestion.json")
+      new String(f.readAllBytes, StandardCharsets.UTF_8)
+    } finally {
+      System.err.println("Loaded from " + f)
+    }
   }
 
 }

engine/runtime/src/main/scala/org/enso/compiler/context/SuggestionDiff.scala

@@ -2,6 +2,10 @@ package org.enso.compiler.context
 import org.enso.polyglot.Suggestion
 import org.enso.polyglot.data.{These, Tree}
 import org.enso.polyglot.runtime.Runtime.Api
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.module.scala.ClassTagExtensions
+import com.fasterxml.jackson.module.scala.DefaultScalaModule
+import com.fasterxml.jackson.databind.ObjectReader
 
 object SuggestionDiff {
 
@@ -28,6 +32,20 @@ object SuggestionDiff {
           true
       }
 
+  case class SuggestionData(version : Int, suggestions : Iterable[Suggestion])
+
+  def deserialize(
+    json: String
+  ): Tree[Api.SuggestionUpdate] = {
+    val mapper  = new ObjectMapper() with ClassTagExtensions
+    mapper.registerModule(DefaultScalaModule)
+
+    val r : ObjectReader = mapper.readerFor[SuggestionData]
+    val o : SuggestionData = r.readValue[SuggestionData](json)
+    System.err.println("suggestions are here: " + o.suggestions)
+    Tree.empty
+  }
+
   /** Compare two suggestions for equality.
     *
     * It is used to find a matching suggestion when joining the previous and

engine/runtime/src/test/scala/org/enso/compiler/test/context/SuggestionDiffTest.scala

@@ -0,0 +1,96 @@
+package org.enso.compiler.test.context
+
+import org.enso.compiler.context.SuggestionBuilder
+import org.enso.compiler.context.SuggestionDiff
+import org.enso.compiler.core.IR
+import org.enso.interpreter.runtime
+import org.enso.interpreter.runtime.EnsoContext
+import org.enso.interpreter.test.InterpreterContext
+import org.enso.pkg.QualifiedName
+import org.enso.polyglot.{LanguageInfo, MethodNames, Suggestion}
+import org.enso.polyglot.data.Tree
+import org.scalatest.matchers.should.Matchers
+import org.scalatest.wordspec.AnyWordSpecLike
+
+class SuggestionDiffTest extends AnyWordSpecLike with Matchers {
+  private val ctx = new InterpreterContext()
+  private val langCtx = ctx.ctx
+    .getBindings(LanguageInfo.ID)
+    .invokeMember(MethodNames.TopScope.LEAK_CONTEXT)
+    .asHostObject[EnsoContext]()
+
+  implicit private class PreprocessModule(code: String) {
+
+    def preprocessModule(name: QualifiedName): IR.Module = {
+      val module = new runtime.Module(
+        name,
+        null,
+        code.stripMargin.linesIterator.mkString("\n")
+      )
+      langCtx.getCompiler.run(module)
+      module.getIr
+    }
+
+    def preprocessModule: IR.Module =
+      preprocessModule(Module)
+
+  }
+
+  private val Module = QualifiedName(List("Unnamed"), "Test")
+  private val ModuleNode = Tree.Node(
+    Suggestion.Module(
+      module        = Module.toString,
+      documentation = None
+    ),
+    Vector()
+  )
+
+  @annotation.nowarn
+  def endOfLine(line: Int, character: Int): Suggestion.Position =
+    Suggestion.Position(line + 1, 0)
+
+  "build method without explicit arguments" in {
+    val ssm = new org.enso.compiler.SuggestionsSerializationManager(null)
+
+    val expected = Tree.Root(
+      Vector(
+        ModuleNode,
+        Tree.Node(
+          Suggestion.Method(
+            externalId = None,
+            module     = "Unnamed.Test",
+            name       = "foo",
+            arguments = Seq(
+              Suggestion.Argument("self", "Unnamed.Test", false, false, None)
+            ),
+            selfType      = "Unnamed.Test",
+            returnType    = SuggestionBuilder.Any,
+            isStatic      = true,
+            documentation = None
+          ),
+          Vector()
+        )
+      )
+    )
+
+    val code   = """foo = 42"""
+    val module = code.preprocessModule
+    val t1 = build(code, module)
+
+    t1 shouldEqual expected
+
+    val data = t1.toVector
+    val json = ssm.toJson(data)
+
+    System.out.println(json)
+
+    val t2 = SuggestionDiff.deserialize(json);
+    t2 shouldEqual expected
+  }
+  private def build(
+    source: String,
+    ir: IR.Module,
+    module: QualifiedName = Module
+  ): Tree.Root[Suggestion] =
+    SuggestionBuilder(source).build(module, ir)
+}