Merge commit '036583694'

Author: alexarchambault

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

@@ -1064,52 +1064,49 @@ final class BloopBspServices(
         projects: Seq[ProjectMapping],
         state: State
     ): BspResult[bsp.SourcesResult] = {
-      val sourcesItems = projects.iterator.map {
-        case (target, project) =>
-          def sourceItem(s: AbsolutePath, isGenerated: Boolean): bsp.SourceItem = {
-            import bsp.SourceItemKind._
-            val uri = s.underlying.toUri()
-            val (bspUri, kind) = if (s.exists) {
-              (uri, if (s.isFile) File else Directory)
-            } else {
-              val fileMatcher = FileSystems.getDefault.getPathMatcher("glob:*.{scala, java}")
-              if (fileMatcher.matches(s.underlying.getFileName)) (uri, File)
-              // If path doesn't exist and its name doesn't look like a file, assume it's a dir
-              else (new URI(uri.toString + "/"), Directory)
-            }
-            bsp.SourceItem(bsp.Uri(bspUri), kind, isGenerated)
-          }
+      def sourceItem(s: AbsolutePath, isGenerated: Boolean): bsp.SourceItem = {
+        import bsp.SourceItemKind._
+        val uri = s.underlying.toUri()
+        val (bspUri, kind) = if (s.exists) {
+          (uri, if (s.isFile) File else Directory)
+        } else {
+          val fileMatcher = FileSystems.getDefault.getPathMatcher("glob:*.{scala, java}")
+          if (fileMatcher.matches(s.underlying.getFileName)) (uri, File)
+          // If path doesn't exist and its name doesn't look like a file, assume it's a dir
+          else (new URI(uri.toString + "/"), Directory)
+        }
+        bsp.SourceItem(bsp.Uri(bspUri), kind, isGenerated)
+      }
 
-          val unmanagedSources = project.allUnmanagedSourceFilesAndDirectories.map { sources =>
-            sources.map(sourceItem(_, isGenerated = false))
-          }
+      val dag = Aggregate(projects.map(p => state.build.getDagFor(p._2)).toList)
 
-          val parentGenerators = Dag.dfs(state.build.getDagFor(project))
-          val managedSources = Task
-            .sequence {
-              parentGenerators.reverse.map { project =>
-                val generators = project.sourceGenerators
-                val tasks = generators.map(
-                  state.sourceGeneratorCache.update(_, state.logger, state.commonOptions)
-                )
-                Task.gatherUnordered(tasks)
-              }
-            }
-            .map {
-              // Take only the result of the last set of generators, since these are the generated
-              // sources of the project we're interested in.
-              _.lastOption.map(_.flatten.map(sourceItem(_, isGenerated = true))).getOrElse(Nil)
-            }
-            .executeOn(ioScheduler)
+      // Collect the projects' sources following the projects topological sorting, so that
+      // source generators that depend on other source generators' outputs can run correctly.
+      val collectSourcesTasks = Dag.topologicalSort(dag).map { project =>
+        val unmanagedSources = project.allUnmanagedSourceFilesAndDirectories.map { sources =>
+          sources.map(sourceItem(_, isGenerated = false))
+        }
+
+        val managedSources = {
+          val tasks = project.sourceGenerators
+            .map(state.sourceGeneratorCache.update(_, state.logger, state.commonOptions))
+          Task.gatherUnordered(tasks).map(_.flatten.map(sourceItem(_, isGenerated = true)))
+        }
 
-          val roots = project.sourceRoots.map(_.map(p => bsp.Uri(p.toBspUri)))
-          for {
-            unmanaged <- unmanagedSources
-            managed <- managedSources
-          } yield bsp.SourcesItem(target, unmanaged ++ managed, roots)
-      }.toList
+        for {
+          unmanaged <- unmanagedSources
+          managed <- managedSources
+        } yield (project, unmanaged ++ managed)
+      }
+
+      val projectToTarget = projects.map { case (target, project) => project -> target }.toMap
+      Task.sequence(collectSourcesTasks).map { results =>
+        val items = results.flatMap {
+          case (project, items) =>
+            val roots = project.sourceRoots.map(_.map(p => bsp.Uri(p.toBspUri)))
+            projectToTarget.get(project).map(bsp.SourcesItem(_, items, roots))
+        }
 
-      Task.sequence(sourcesItems).map { items =>
         (state, Right(bsp.SourcesResult(items)))
       }
     }

frontend/src/main/scala/bloop/engine/BuildLoader.scala

@@ -205,11 +205,9 @@ object BuildLoader {
   ): Option[AbsolutePath] = {
     val (scalaVersion, scalaSemanticdbSettings) = scalaSemanticdbVersionAndSettings
     // Recognize 2.12.8-abdcddd as supported if 2.12.8 exists in supported versions
-    val isUnsupportedVersion =
-      !scalaSemanticdbSettings.supportedScalaVersions.exists(scalaVersion.startsWith(_))
-    if (isUnsupportedVersion) {
-      if (!scalaVersion.startsWith("3."))
-        logger.debug(Feedback.skippedUnsupportedScalaMetals(scalaVersion))(DebugFilter.All)
+    val isSupportedVersion =
+      scalaSemanticdbSettings.supportedScalaVersions.exists(scalaVersion.startsWith(_))
+    if (scalaVersion.startsWith("3.")) {
       None
     } else {
       SemanticDBCache.fetchScalaPlugin(
@@ -220,9 +218,13 @@ object BuildLoader {
         case Right(path) =>
           logger.debug(Feedback.configuredMetalsScalaProjects(projects))(DebugFilter.All)
           Some(path)
-        case Left(cause) =>
+        case Left(cause) if isSupportedVersion =>
           logger.displayWarningToUser(Feedback.failedMetalsScalaConfiguration(scalaVersion, cause))
           None
+
+        // We try to download anyway, but don't print the exception
+        case _ =>
+          None
       }
     }
   }

frontend/src/main/scala/bloop/engine/Dag.scala

@@ -8,6 +8,7 @@ import bloop.data.Project
 import bloop.util.CacheHashCode
 
 import scalaz.Show
+import scala.collection.immutable.ListSet
 
 /**
  * A [[Dag]] is a Directed Acyclic Graph where each node contains a value of T
@@ -365,4 +366,16 @@ object Dag {
        |${edges.mkString("  ", "\n  ", "")}
        |}""".stripMargin
   }
+
+  def topologicalSort[T](dag: Dag[T]): List[T] = {
+    def inner(buf: ListSet[T], dag: Dag[T]): ListSet[T] = dag match {
+      case Leaf(value) =>
+        buf + value
+      case Parent(value, children) =>
+        children.foldLeft(buf)(inner(_, _)) + value
+      case Aggregate(dags) =>
+        dags.foldLeft(buf)(inner(_, _))
+    }
+    inner(ListSet.empty, dag).toList
+  }
 }

frontend/src/test/scala/bloop/DagSpec.scala

@@ -62,6 +62,17 @@ class DagSpec {
     case Leaf(f) => assert(f == p, s"$f is not $p")
   }
 
+  private def assertAppearsBefore[T](elems: List[T], ancestor: T, successor: T): Unit = {
+    Assert.assertTrue(
+      s"$ancestor doesnt appear before $successor in $elems",
+      elems.indexOf(ancestor) < elems.indexOf(successor)
+    )
+  }
+
+  private def assertAppearsBefore[T](elems: List[T], ancestor: T, successors: List[T]): Unit = {
+    successors.foreach(assertAppearsBefore(elems, ancestor, _))
+  }
+
   @Test def EmptyDAG(): Unit = {
     val dags = fromMap(Map())
     assert(dags.isEmpty)
@@ -269,4 +280,17 @@ class DagSpec {
     Assert.assertEquals("all case 8", Set(i, h), allInverseDeps(List(h)))
     Assert.assertEquals("all case 9", Set(i), allInverseDeps(List(i)))
   }
+
+  @Test
+  def TestTopologicalSort(): Unit = {
+    import ComplexDag._
+    val allProjects = List(a, b, c, d, e, f, g, h, i)
+    val dags = fromMap(allProjects.map(p => p.name -> p).toMap)
+    val sorted = Dag.topologicalSort(Aggregate(dags))
+    assertAppearsBefore(sorted, a, List(b, c, d, e))
+    assertAppearsBefore(sorted, c, List(d, e))
+    assertAppearsBefore(sorted, d, List(e))
+    assertAppearsBefore(sorted, f, List(g, h, i))
+    assertAppearsBefore(sorted, h, List(i))
+  }
 }