Add language server feature to handle decompile requests

Author: Tobias Bordenca

language-server/src/dotty/tools/languageserver/DottyLanguageServer.scala

@@ -26,11 +26,13 @@ import reporting._, reporting.diagnostic.{Message, MessageContainer, messages}
 import typer.Typer
 import util.{Set => _, _}
 import interactive._, interactive.InteractiveDriver._
+import decompiler.IDEDecompilerDriver
 import Interactive.Include
 import config.Printers.interactiv
 
 import languageserver.config.ProjectConfig
-import languageserver.worksheet.{Worksheet, WorksheetClient, WorksheetService}
+import languageserver.worksheet.{Worksheet, WorksheetService}
+import languageserver.decompiler.{TastyDecompilerService}
 
 import lsp4j.services._
 
@@ -43,7 +45,7 @@ import lsp4j.services._
  *  - This implementation is based on the LSP4J library: https://github.com/eclipse/lsp4j
  */
 class DottyLanguageServer extends LanguageServer
-    with TextDocumentService with WorkspaceService with WorksheetService { thisServer =>
+    with TextDocumentService with WorkspaceService with WorksheetService with TastyDecompilerService { thisServer =>
   import ast.tpd._
 
   import DottyLanguageServer._
@@ -128,6 +130,25 @@ class DottyLanguageServer extends LanguageServer
     drivers(configFor(uri))
   }
 
+    /** The driver instance responsible for decompiling `uri` in `classPath` */
+  def decompilerDriverFor(uri: URI, classPath: String): IDEDecompilerDriver = thisServer.synchronized {
+    val config = configFor(uri)
+    val defaultFlags = List("-color:never")
+
+    implicit class updateDeco(ss: List[String]) {
+      def update(pathKind: String, pathInfo: String) = {
+        val idx = ss.indexOf(pathKind)
+        val ss1 = if (idx >= 0) ss.take(idx) ++ ss.drop(idx + 2) else ss
+        ss1 ++ List(pathKind, pathInfo)
+      }
+    }
+    val settings =
+      defaultFlags ++
+      config.compilerArguments.toList
+        .update("-classpath", (classPath +: config.dependencyClasspath).mkString(File.pathSeparator))
+    new IDEDecompilerDriver(settings)
+  }
+
   /** A mapping from project `p` to the set of projects that transitively depend on `p`. */
   def dependentProjects: Map[ProjectConfig, Set[ProjectConfig]] = thisServer.synchronized {
     if (myDependentProjects == null) {
@@ -184,7 +205,8 @@ class DottyLanguageServer extends LanguageServer
     rootUri = params.getRootUri
     assert(rootUri != null)
 
-    class DottyServerCapabilities(val worksheetRunProvider: Boolean = true) extends lsp4j.ServerCapabilities
+    class DottyServerCapabilities(val worksheetRunProvider: Boolean = true,
+                                  val tastyDecompiler: Boolean = true) extends lsp4j.ServerCapabilities
 
     val c = new DottyServerCapabilities
     c.setTextDocumentSync(TextDocumentSyncKind.Full)

language-server/src/dotty/tools/languageserver/decompiler/TastyDecompilerMessages.scala

@@ -0,0 +1,23 @@
+package dotty.tools.languageserver.decompiler
+
+import org.eclipse.lsp4j.TextDocumentIdentifier
+
+// All case classes in this file should have zero-parameters secondary
+// constructors to allow Gson to reflectively create instances on
+// deserialization without relying on sun.misc.Unsafe.
+
+/** The parameter for the `tasty/decompile` request. */
+case class TastyDecompileParams(textDocument: TextDocumentIdentifier) {
+  def this() = this(null)
+}
+
+/** The response to a `tasty/decompile` request. */
+case class TastyDecompileResult(tastyTree: String = null, scala: String = null, error: Int = 0) {
+  def this() = this(null, null, 0)
+}
+
+object TastyDecompileResult {
+  val ErrorTastyVersion = 1
+  val ErrorClassNotFound = 2
+  val ErrorOther = -1
+}

language-server/src/dotty/tools/languageserver/decompiler/TastyDecompilerService.scala

@@ -0,0 +1,42 @@
+package dotty.tools
+package languageserver
+package decompiler
+
+import java.net.URI
+import java.nio.file._
+import java.util.concurrent.CompletableFuture
+
+import dotc.core.tasty.TastyUnpickler.UnpickleException
+import dotc.fromtasty.TastyFileUtil
+
+import org.eclipse.lsp4j.jsonrpc.services._
+
+
+@JsonSegment("tasty")
+trait TastyDecompilerService {
+  thisServer: DottyLanguageServer =>
+
+  @JsonRequest
+  def decompile(params: TastyDecompileParams): CompletableFuture[TastyDecompileResult] =
+    computeAsync(synchronize = false, fun = { cancelChecker =>
+      val uri = new URI(params.textDocument.getUri)
+      try {
+        TastyFileUtil.getClassName(Paths.get(uri)) match {
+          case Some((classPath, className)) =>
+            val driver = thisServer.decompilerDriverFor(uri, classPath)
+
+            val (tree, source) = driver.run(className)
+
+            TastyDecompileResult(tree, source)
+          case _ =>
+            TastyDecompileResult(error = TastyDecompileResult.ErrorClassNotFound)
+        }
+      } catch {
+        case _: UnpickleException =>
+          TastyDecompileResult(error = TastyDecompileResult.ErrorTastyVersion)
+        case t: Throwable =>
+          t.printStackTrace()
+          TastyDecompileResult(error = TastyDecompileResult.ErrorOther)
+      }
+    })
+}