ScalaPresentationCompiler.scala

package scala.meta.internal.pc

import java.io.File
import java.nio.file.Path
import java.util
import java.util.Optional
import java.util.concurrent.ExecutorService
import java.util.concurrent.ScheduledExecutorService
import java.util.logging.Logger
import org.eclipse.lsp4j.CompletionItem
import org.eclipse.lsp4j.CompletionList
import org.eclipse.lsp4j.Hover
import org.eclipse.lsp4j.SignatureHelp
import scala.meta.internal.jdk.CollectionConverters._
import scala.concurrent.ExecutionContext
import scala.concurrent.ExecutionContextExecutor
import scala.meta.internal.metals.EmptyCancelToken
import scala.meta.internal.mtags.BuildInfo
import scala.meta.pc.OffsetParams
import scala.meta.pc.PresentationCompiler
import scala.meta.pc.SymbolSearch
import scala.reflect.io.VirtualDirectory
import scala.tools.nsc.Settings
import scala.tools.nsc.reporters.StoreReporter
import scala.meta.pc.PresentationCompilerConfig
import java.util.concurrent.CompletableFuture
import scala.meta.pc.DefinitionResult
import scala.collection.Seq

case class ScalaPresentationCompiler(
    buildTargetIdentifier: String = "",
    classpath: Seq[Path] = Nil,
    options: List[String] = Nil,
    search: SymbolSearch = EmptySymbolSearch,
    ec: ExecutionContextExecutor = ExecutionContext.global,
    sh: Option[ScheduledExecutorService] = None,
    config: PresentationCompilerConfig = PresentationCompilerConfigImpl()
) extends PresentationCompiler {
  val logger: Logger =
    Logger.getLogger(classOf[ScalaPresentationCompiler].getName)
  override def withSearch(search: SymbolSearch): PresentationCompiler =
    copy(search = search)
  override def withExecutorService(
      executorService: ExecutorService
  ): PresentationCompiler =
    copy(ec = ExecutionContext.fromExecutorService(executorService))
  override def withScheduledExecutorService(
      sh: ScheduledExecutorService
  ): PresentationCompiler =
    copy(sh = Some(sh))

  override def withConfiguration(
      config: PresentationCompilerConfig
  ): PresentationCompiler =
    copy(config = config)
  def this() = this(buildTargetIdentifier = "")

  val access = new CompilerAccess(config, sh, () => newCompiler())(ec)
  override def shutdown(): Unit = {
    access.shutdown()
  }

  override def restart(): Unit = {
    access.shutdownCurrentCompiler()
  }

  override def newInstance(
      buildTargetIdentifier: String,
      classpath: util.List[Path],
      options: util.List[String]
  ): PresentationCompiler = {
    copy(
      buildTargetIdentifier = buildTargetIdentifier,
      classpath = classpath.asScala,
      options = options.asScala.toList
    )
  }

  def emptyCompletion: CompletionList = {
    val items = new CompletionList(Nil.asJava)
    items.setIsIncomplete(true)
    items
  }
  override def complete(
      params: OffsetParams
  ): CompletableFuture[CompletionList] =
    access.withInterruptableCompiler(emptyCompletion, params.token) { global =>
      new CompletionProvider(global, params, config.isCompletionSnippetsEnabled)
        .completions()
    }

  // NOTE(olafur): hover and signature help use a "shared" compiler instance because
  // we don't typecheck any sources, we only poke into the symbol table.
  // If we used a shared compiler then we risk hitting `Thread.interrupt`,
  // which can close open `*-sources.jar` files containing Scaladoc/Javadoc strings.
  override def completionItemResolve(
      item: CompletionItem,
      symbol: String
  ): CompletableFuture[CompletionItem] = CompletableFuture.completedFuture {
    access.withSharedCompiler(item) { global =>
      new CompletionItemResolver(global).resolve(item, symbol)
    }
  }

  override def signatureHelp(
      params: OffsetParams
  ): CompletableFuture[SignatureHelp] =
    access.withNonInterruptableCompiler(
      new SignatureHelp(),
      params.token
    ) { global =>
      new SignatureHelpProvider(global).signatureHelp(params)
    }

  override def hover(
      params: OffsetParams
  ): CompletableFuture[Optional[Hover]] =
    access.withNonInterruptableCompiler(
      Optional.empty[Hover](),
      params.token
    ) { global =>
      Optional.ofNullable(new HoverProvider(global, params).hover().orNull)
    }

  def definition(params: OffsetParams): CompletableFuture[DefinitionResult] = {
    access.withNonInterruptableCompiler(
      DefinitionResultImpl.empty,
      params.token
    ) { global =>
      new PcDefinitionProvider(global, params).definition()
    }
  }

  override def semanticdbTextDocument(
      filename: String,
      code: String
  ): CompletableFuture[Array[Byte]] = {
    access.withInterruptableCompiler(
      Array.emptyByteArray,
      EmptyCancelToken
    ) { global =>
      new SemanticdbTextDocumentProvider(global)
        .textDocument(filename, code)
        .toByteArray
    }
  }

  def newCompiler(): MetalsGlobal = {
    val classpath = this.classpath.mkString(File.pathSeparator)
    val vd = new VirtualDirectory("(memory)", None)
    val settings = new Settings
    settings.Ymacroexpand.value = "discard"
    settings.outputDirs.setSingleOutput(vd)
    settings.classpath.value = classpath
    settings.YpresentationAnyThread.value = true
    if (!BuildInfo.scalaCompilerVersion.startsWith("2.11") &&
      BuildInfo.scalaCompilerVersion != "2.12.4") {
      settings.processArguments(
        List("-Ycache-plugin-class-loader:last-modified"),
        processAll = true
      )
    }
    if (classpath.isEmpty) {
      settings.usejavacp.value = true
    }
    val (isSuccess, unprocessed) =
      settings.processArguments(options, processAll = true)
    require(isSuccess, unprocessed)
    require(unprocessed.isEmpty, unprocessed)
    new MetalsGlobal(
      settings,
      new StoreReporter,
      search,
      buildTargetIdentifier,
      config
    )
  }

  // ================
  // Internal methods
  // ================

  override def diagnosticsForDebuggingPurposes(): util.List[String] = {
    access.reporter
      .asInstanceOf[StoreReporter]
      .infos
      .iterator
      .map { info =>
        new StringBuilder()
          .append(info.pos.source.file.path)
          .append(":")
          .append(info.pos.column)
          .append(" ")
          .append(info.msg)
          .append("\n")
          .append(info.pos.lineContent)
          .append("\n")
          .append(info.pos.lineCaret)
          .toString
      }
      .filterNot(_.contains("_CURSOR_"))
      .toList
      .asJava
  }
}