Deliver holes for literate Effekt files (#1035)

Previously, we only published holes for `.effekt` but not for
`effekt.md`. The reason for this is that for `*.md` files we construct a
new `MarkdownSource` in `compileSource` and we attach the annotations to
that, but we pass the old `StringSource` back to `afterCompilation`,
meaning we don't find the annotations.
This PR fixes this issue by passing the correct source to
`afterCompilation`.

Author: timsueberkrueb

effekt/jvm/src/main/scala/effekt/Driver.scala

@@ -35,64 +35,65 @@ trait Driver extends kiama.util.Compiler[EffektConfig, EffektError] { outer =>
    *
    * In LSP mode: invoked for each file opened in an editor
    */
-  override def compileSource(source: Source, config: EffektConfig): Unit = try {
-    val src = if (source.name.endsWith(".md")) { MarkdownSource(source) } else { source }
-
-    // remember that we have seen this source, this is used by LSP (kiama.util.Server)
-    sources(source.name) = src
-
-    implicit val C = context
-    C.setup(config)
-
-    def saveOutput(path: String, doc: String): Unit =
-      if (C.config.requiresCompilation()) {
-        val out = C.config.outputPath()
-        out.mkdirs
-        IO.createFile((out / path).unixPath, doc)
-      }
-
-    C.backend match {
+  override def compileSource(source: Source, config: EffektConfig): Unit = {
+      val src = if (source.name.endsWith(".md")) { MarkdownSource(source) } else { source }
+      try {
+        // remember that we have seen this source, this is used by LSP (kiama.util.Server)
+        sources(source.name) = src
+
+        implicit val C = context
+        C.setup(config)
+
+        def saveOutput(path: String, doc: String): Unit =
+          if (C.config.requiresCompilation()) {
+            val out = C.config.outputPath()
+            out.mkdirs
+            IO.createFile((out / path).unixPath, doc)
+          }
 
-      case Backend(name, compiler, runner) =>
-        // measure the total compilation time here
-        def compile() = C.timed("total", source.name) {
-          compiler.compile(src) map {
-            case (outputFiles, exec) =>
-              outputFiles.foreach {
-                case (filename, doc) =>
-                  saveOutput(filename, doc)
+        C.backend match {
+
+          case Backend(name, compiler, runner) =>
+            // measure the total compilation time here
+            def compile() = C.timed("total", source.name) {
+              compiler.compile(src) map {
+                case (outputFiles, exec) =>
+                  outputFiles.foreach {
+                    case (filename, doc) =>
+                      saveOutput(filename, doc)
+                  }
+                  exec
               }
-              exec
-          }
+            }
+
+            // we are in one of four exclusive modes: Documenter, LSPServer, Compile, Run
+            if (config.documenter()) { documenter(source, config)(context) }
+            else if (config.server()) { compiler.runFrontend(src) }
+            else if (config.interpret()) { compile() foreach runner.eval }
+            else if (config.build()) { compile() foreach runner.build }
+            else if (config.compile()) { compile() }
         }
-
-        // we are in one of four exclusive modes: Documenter, LSPServer, Compile, Run
-        if (config.documenter()) { documenter(source, config)(context) }
-        else if (config.server()) { compiler.runFrontend(src) }
-        else if (config.interpret()) { compile() foreach runner.eval }
-        else if (config.build()) { compile() foreach runner.build }
-        else if (config.compile()) { compile() }
-    }
-  } catch {
-    case FatalPhaseError(msg) => context.report(msg)
-    case e @ CompilerPanic(msg) =>
-      context.report(msg)
-      e.getStackTrace.foreach { line =>
-        context.info("  at " + line)
-      }
-    // when in server-mode, do not crash but report the error to avoid
-    // restarting the server.
-    case e if config.server() =>
-      context.info("Effekt Compiler Crash: " + e.getMessage)
-      e.getStackTrace.foreach { line =>
-        context.info("  at " + line)
+      } catch {
+        case FatalPhaseError(msg) => context.report(msg)
+        case e @ CompilerPanic(msg) =>
+          context.report(msg)
+          e.getStackTrace.foreach { line =>
+            context.info("  at " + line)
+          }
+        // when in server-mode, do not crash but report the error to avoid
+        // restarting the server.
+        case e if config.server() =>
+          context.info("Effekt Compiler Crash: " + e.getMessage)
+          e.getStackTrace.foreach { line =>
+            context.info("  at " + line)
+          }
+      } finally {
+        outputTimes(src, config)(context)
+        showIR(src, config)(context)
+        writeIRs(src, config)(context)
+        // This reports error messages
+        afterCompilation(src, config)(context)
       }
-  } finally {
-    outputTimes(source, config)(context)
-    showIR(source, config)(context)
-    writeIRs(source, config)(context)
-    // This reports error messages
-    afterCompilation(source, config)(context)
   }
 
   /**

effekt/jvm/src/test/scala/effekt/LSPTests.scala

@@ -1333,6 +1333,30 @@ class LSPTests extends FunSuite {
     }
   }
 
+  test("Server publishes holes for literate Effekt") {
+    withClientAndServer { (client, server) =>
+      val source = new TextDocumentItem("file://path/to/test.effekt.md", "literate effekt", 0,
+        raw"""# Some title
+             |```effekt
+             |def foo(x: Int): Bool = <>
+             |```
+             |""".stripMargin)
+
+      val initializeParams = new InitializeParams()
+      val initializationOptions = """{"showHoles": true}"""
+      initializeParams.setInitializationOptions(JsonParser.parseString(initializationOptions))
+      server.initialize(initializeParams).get()
+
+      val didOpenParams = new DidOpenTextDocumentParams()
+      didOpenParams.setTextDocument(source)
+      server.getTextDocumentService().didOpen(didOpenParams)
+
+      val receivedHoles = client.receivedHoles()
+      assertEquals(receivedHoles.length, 1)
+      assertEquals(receivedHoles.head.holes.length, 1)
+    }
+  }
+  
   test("Server publishes hole id for nested defs") {
     withClientAndServer { (client, server) =>
       val source =