Unify build tool integrations with Metals

.gitignore

@@ -1,6 +1,7 @@
 .idea/
 bin/.coursier
 bin/.scalafmt*
+.vscode/
 
 # Required because these are the proxies for the sourcedeps
 .bridge/
@@ -33,4 +34,4 @@ node_modules/
 package-lock.json
 .metals/
 *.lock
-benchmark-bridge/corpus/
+benchmark-bridge/corpus/

backend/src/main/scala/bloop/BloopComponentsLock.scala

@@ -5,6 +5,10 @@ import java.util.concurrent.Callable
 
 import xsbti.GlobalLock
 
-object BloopComponentsLock extends GlobalLock {
+sealed trait ComponentLock extends GlobalLock {
   override def apply[T](file: File, callable: Callable[T]): T = synchronized { callable.call() }
 }
+
+object BloopComponentsLock extends ComponentLock
+
+object SemanticDBCacheLock extends ComponentLock

backend/src/main/scala/bloop/CompilerCache.scala

@@ -85,8 +85,7 @@ final class CompilerCache(
           Some(Paths.getCacheDirectory("bridge-cache").toFile),
           DependencyResolution.getEngine(userResolvers),
           bridgeSources,
-          retrieveDir.toFile,
-          logger
+          retrieveDir.toFile
         )
     }
   }

backend/src/main/scala/bloop/DependencyResolution.scala

@@ -5,6 +5,8 @@ import bloop.io.AbsolutePath
 
 import sbt.librarymanagement._
 import sbt.librarymanagement.ivy._
+import coursier.core.Repository
+import coursier.error.CoursierError
 
 object DependencyResolution {
   private final val BloopResolvers =
@@ -15,72 +17,65 @@ object DependencyResolution {
     IvyDependencyResolution(configuration)
   }
 
-  import java.io.File
-  import coursier.util.{Gather, Task}
-  import coursier.cache.{Cache, ArtifactError}
-  import coursier.{
-    Dependency,
-    Fetch,
-    MavenRepository,
-    Module,
-    Repository,
-    Resolution,
-    LocalRepositories,
-    ResolutionProcess
+  /**
+   * Resolve the specified module and get all the files. By default, the local ivy
+   * repository and Maven Central are included in resolution. This resolution throws
+   * in case there is an error.
+   *
+   * @param organization           The module's organization.
+   * @param module                 The module's name.
+   * @param version                The module's version.
+   * @param logger                 A logger that receives messages about resolution.
+   * @param additionalRepositories Additional repositories to include in resolition.
+   * @return All the resolved files.
+   */
+  def resolve(
+      organization: String,
+      module: String,
+      version: String,
+      logger: Logger,
+      additionalRepos: Seq[Repository] = Nil
+  )(implicit ec: scala.concurrent.ExecutionContext): Array[AbsolutePath] = {
+    resolveWithErrors(organization, module, version, logger, additionalRepos) match {
+      case Right(paths) => paths
+      case Left(error) => throw error
+    }
   }
 
   /**
    * Resolve the specified module and get all the files. By default, the local ivy
-   * repository and Maven Central are included in resolution.
+   * repository and Maven Central are included in resolution. This resolution is
+   * pure and returns either some errors or some resolved jars.
    *
    * @param organization           The module's organization.
    * @param module                 The module's name.
    * @param version                The module's version.
    * @param logger                 A logger that receives messages about resolution.
    * @param additionalRepositories Additional repositories to include in resolition.
-   * @return All the files that compose the module and that could be found.
+   * @return Either a coursier error or all the resolved files.
    */
-  def resolve(
+  def resolveWithErrors(
       organization: String,
       module: String,
       version: String,
       logger: Logger,
       additionalRepositories: Seq[Repository] = Nil
-  )(implicit ec: scala.concurrent.ExecutionContext): Array[AbsolutePath] = {
-    logger.debug(s"Resolving $organization:$module:$version")(DebugFilter.Compilation)
+  )(implicit ec: scala.concurrent.ExecutionContext): Either[CoursierError, Array[AbsolutePath]] = {
+    import coursier._
+    logger.debug(s"Resolving $organization:$module:$version")(DebugFilter.All)
     val org = coursier.Organization(organization)
     val moduleName = coursier.ModuleName(module)
     val dependency = Dependency(Module(org, moduleName), version)
-    val start = Resolution(List(dependency))
-    val repositories = {
-      val baseRepositories = Seq(
-        LocalRepositories.ivy2Local,
-        MavenRepository("https://repo1.maven.org/maven2"),
-        MavenRepository("https://dl.bintray.com/scalacenter/releases")
-      )
-      baseRepositories ++ additionalRepositories
-    }
-    val fetch = ResolutionProcess.fetch(repositories, Cache.default.fetch)
-    val resolution = start.process.run(fetch).unsafeRun()
-    val localArtifacts: Seq[(Boolean, Either[ArtifactError, File])] = {
-      Gather[Task]
-        .gather(resolution.artifacts().map { artifact =>
-          Cache.default.file(artifact).run.map(artifact.optional -> _)
-        })
-        .unsafeRun()(ec)
+    var fetch = Fetch()
+      .addDependencies(dependency)
+      .addRepositories(Repositories.bintray("scalacenter", "releases"))
+    for (repository <- additionalRepositories) {
+      fetch.addRepositories(repository)
     }
 
-    val fileErrors = localArtifacts.collect {
-      case (isOptional, Left(error)) if !isOptional || !error.notFound => error
-    }
-    if (fileErrors.isEmpty) {
-      localArtifacts.collect { case (_, Right(f)) => AbsolutePath(f.toPath) }.toArray
-    } else {
-      val moduleInfo = s"$organization:$module:$version"
-      val prettyFileErrors = fileErrors.map(_.describe).mkString(System.lineSeparator)
-      sys.error(
-        s"Resolution of module $moduleInfo failed with:${System.lineSeparator}${prettyFileErrors}"
-      )
+    try Right(fetch.run().map(f => AbsolutePath(f.toPath)).toArray)
+    catch {
+      case error: CoursierError => Left(error)
     }
   }
 }

backend/src/main/scala/sbt/internal/inc/ZincComponentManager.scala

@@ -29,10 +29,8 @@ import xsbti.ArtifactInfo.SbtOrganization
 class ZincComponentManager(
     globalLock: GlobalLock,
     provider: ComponentProvider,
-    secondaryCacheDir: Option[File],
-    log0: Logger,
+    secondaryCacheDir: Option[File]
 ) {
-  val log = new FullLogger(log0)
 
   /** Get all of the files for component 'id', throwing an exception if no files exist for the component. */
   def files(id: String)(ifMissing: IfMissing): Iterable[File] = {

backend/src/main/scala/sbt/internal/inc/ZincLmUtil.scala

@@ -30,12 +30,11 @@ object ZincLmUtil {
       secondaryCacheDir: Option[File],
       dependencyResolution: DependencyResolution,
       compilerBridgeSource: ModuleID,
-      scalaJarsTarget: File,
-      log: Logger
+      scalaJarsTarget: File
   ): AnalyzingCompiler = {
     val compilerBridgeProvider = ZincComponentCompiler.interfaceProvider(
       compilerBridgeSource,
-      new ZincComponentManager(globalLock, componentProvider, secondaryCacheDir, log),
+      new ZincComponentManager(globalLock, componentProvider, secondaryCacheDir),
       dependencyResolution,
       scalaJarsTarget
     )

config/src/main/scala/bloop/config/Config.scala

@@ -216,6 +216,7 @@ object Config {
   case class Project(
       name: String,
       directory: Path,
+      workspaceDir: Option[Path],
       sources: List[Path],
       dependencies: List[String],
       classpath: List[Path],
@@ -232,7 +233,7 @@ object Config {
 
   object Project {
     // FORMAT: OFF
-    private[bloop] val empty: Project = Project("", emptyPath, List(), List(), List(), emptyPath, emptyPath, None, None, None, None, None, None, None)
+    private[bloop] val empty: Project = Project("", emptyPath, None, List(), List(), List(), emptyPath, emptyPath, None, None, None, None, None, None, None)
     // FORMAT: ON
 
     def analysisFileName(projectName: String) = s"$projectName-analysis.bin"
@@ -271,6 +272,7 @@ object Config {
       val project = Project(
         "dummy-project",
         workingDirectory,
+        Some(workingDirectory),
         List(sourceFile),
         List("dummy-2"),
         List(scalaLibraryJar),
@@ -286,7 +288,8 @@ object Config {
             List(),
             Some(outAnalysisFile),
             Some(CompileSetup.empty)
-          )),
+          )
+        ),
         Some(Java(List("-version"))),
         Some(Sbt("1.1.0", Nil)),
         Some(Test(List(), TestOptions(Nil, Nil))),

frontend/src/it/scala/bloop/CommunityBuild.scala

@@ -7,7 +7,7 @@ import scala.concurrent.Await
 import scala.concurrent.duration.Duration
 import bloop.cli.{Commands, ExitStatus}
 import bloop.config.Config
-import bloop.data.{Origin, Project}
+import bloop.data.{Origin, Project, LoadedProject}
 import bloop.engine.{
   Action,
   Build,
@@ -111,19 +111,20 @@ abstract class CommunityBuild(val buildpressHomeDir: AbsolutePath) {
       val logger = BloopLogger.default("community-build-logger")
       val initialState = loadStateForBuild(buildBaseDir.resolve(".bloop"), logger)
       val blacklistedProjects = readBlacklistFile(buildBaseDir.resolve("blacklist.buildpress"))
-      val allProjectsInBuild =
-        initialState.build.projects.filterNot(p => blacklistedProjects.contains(p.name))
+      val allProjectsInBuild = initialState.build.loadedProjects
+        .filterNot(lp => blacklistedProjects.contains(lp.project.name))
 
       val rootProjectName = "bloop-test-root"
       val dummyExistingBaseDir = buildBaseDir.resolve("project")
       val dummyClassesDir = dummyExistingBaseDir.resolve("target")
-      val origin = Origin(buildBaseDir, FileTime.fromMillis(0), scala.util.Random.nextInt())
+      val origin = Origin(buildBaseDir, FileTime.fromMillis(0), 0L, scala.util.Random.nextInt())
       val analysisOut = dummyClassesDir.resolve(Config.Project.analysisFileName(rootProjectName))
       val rootProject = Project(
         name = rootProjectName,
         baseDirectory = dummyExistingBaseDir,
-        dependencies = allProjectsInBuild.map(_.name),
-        scalaInstance = allProjectsInBuild.head.scalaInstance,
+        workspaceDirectory = Some(buildBaseDir),
+        dependencies = allProjectsInBuild.map(_.project.name),
+        scalaInstance = allProjectsInBuild.head.project.scalaInstance,
         rawClasspath = Nil,
         resources = Nil,
         compileSetup = Config.CompileSetup.empty,
@@ -141,8 +142,8 @@ abstract class CommunityBuild(val buildpressHomeDir: AbsolutePath) {
         origin = origin
       )
 
-      val newProjects = rootProject :: allProjectsInBuild
-      val state = initialState.copy(build = initialState.build.copy(projects = newProjects))
+      val newLoaded = LoadedProject.RawProject(rootProject) :: allProjectsInBuild
+      val state = initialState.copy(build = initialState.build.copy(loadedProjects = newLoaded))
       val allReachable = Dag.dfs(state.build.getDagFor(rootProject))
       val reachable = allReachable.filter(_ != rootProject)
       val cleanAction = Run(Commands.Clean(reachable.map(_.name)), Exit(ExitStatus.Ok))

frontend/src/main/scala/bloop/Bloop.scala

@@ -35,8 +35,8 @@ object Bloop extends CaseApp[CliOptions] {
     )
     logger.warn("Please refer to our documentation for more information.")
     val client = ClientInfo.CliClientInfo("bloop-single-app", () => true)
-    val projects = BuildLoader.loadSynchronously(configDirectory, logger)
-    val build = Build(configDirectory, projects)
+    val loadedProjects = BuildLoader.loadSynchronously(configDirectory, logger)
+    val build = Build(configDirectory, loadedProjects)
     val state = State(build, client, NoPool, options.common, logger)
     run(state, options)
   }
@@ -71,7 +71,7 @@ object Bloop extends CaseApp[CliOptions] {
         run(waitForState(action, Interpreter.execute(action, Task.now(state))), options)
 
       case Array("clean") =>
-        val allProjects = state.build.projects.map(_.name)
+        val allProjects = state.build.loadedProjects.map(_.project.name)
         val action = Run(Commands.Clean(allProjects), Exit(ExitStatus.Ok))
         run(waitForState(action, Interpreter.execute(action, Task.now(state))), options)
 

frontend/src/main/scala/bloop/bsp/BloopBspDefinitions.scala

@@ -1,15 +1,23 @@
 package bloop.bsp
 
-import io.circe._
-import io.circe.derivation._
 import ch.epfl.scala.bsp.Uri
 
 object BloopBspDefinitions {
   final case class BloopExtraBuildParams(
-      clientClassesRootDir: Option[Uri]
+      clientClassesRootDir: Option[Uri],
+      semanticdbVersion: Option[String],
+      supportedScalaVersions: List[String]
   )
 
   object BloopExtraBuildParams {
+    val empty = BloopExtraBuildParams(
+      clientClassesRootDir = None,
+      semanticdbVersion = None,
+      supportedScalaVersions = Nil
+    )
+
+    import io.circe.{RootEncoder, Decoder}
+    import io.circe.derivation._
     val encoder: RootEncoder[BloopExtraBuildParams] = deriveEncoder
     val decoder: Decoder[BloopExtraBuildParams] = deriveDecoder
   }