Merge pull request #468 from mkurz/sbt2

sbt 2 cross build

Author: mkurz

.github/workflows/build-test.yml

@@ -17,8 +17,9 @@ jobs:
     name: Tests
     uses: playframework/.github/.github/workflows/cmd.yml@v4
     with:
-      java: 21, 17, 11, 8
-      scala: 2.12.21
+      java: 25, 17, 11, 8
+      scala: 2.12.x, 3.x
+      exclude: '[{"java": "8", "scala": "3.x"}, {"java": "11", "scala": "3.x"}]'
       cmd: |
         sbt ++$MATRIX_SCALA test scripted
 

build.sbt

@@ -1,11 +1,28 @@
-lazy val root = (project in file("."))
+lazy val scala212 = "2.12.21"
+lazy val scala3 = "3.8.3"
+
+ThisBuild / crossScalaVersions := Seq(scala212, scala3)
+
+lazy val root = project.in(file("."))
   .enablePlugins(SbtPlugin)
   .settings(
     Seq(
       organization := "com.github.sbt",
       name := "sbt-eclipse",
-      scalacOptions ++= Seq("-unchecked", "-deprecation", "-target:jvm-1.8"),
-      scalaVersion := "2.12.21",
+      crossScalaVersions := Seq(scala212, scala3),
+      scalacOptions ++= {
+        CrossVersion.partialVersion(scalaVersion.value) match {
+          case Some((2, _)) => Seq("-unchecked", "-deprecation", "-Xsource:3", "-release:8")
+          case _            => Seq("-unchecked", "-deprecation")
+        }
+      },
+      scalaVersion := scala212,
+      ThisBuild / (pluginCrossBuild / sbtVersion) := {
+        scalaBinaryVersion.value match {
+          case "2.12" => "1.12.9"
+          case _      => "2.0.0-RC11"
+        }
+      },
       // Customise sbt-dynver's behaviour to make it work with tags which aren't v-prefixed
       ThisBuild / dynverVTagPrefix := false,
       // Sanity-check: assert that version comes from a tag (e.g. not a too-shallow clone)

project/build.properties

@@ -1 +1 @@
-sbt.version=1.12.6
+sbt.version=1.12.9

src/main/scala-2/com/typesafe/sbteclipse/core/CompileTaskCompat.scala

@@ -0,0 +1,9 @@
+package com.typesafe.sbteclipse.core
+
+import sbt.{Configuration, Def, Keys, Setting, Task}
+import xsbti.compile.CompileAnalysis
+
+private object CompileTaskCompat {
+  def compileSetting(scope: Configuration, task: Def.Initialize[Task[CompileAnalysis]]): Setting[?] =
+    (scope / Keys.compile) := task.value
+}

src/main/scala-3/com/typesafe/sbteclipse/core/CompileTaskCompat.scala

@@ -0,0 +1,10 @@
+package com.typesafe.sbteclipse.core
+
+import sbt._
+import sbt.{Configuration, Def, Keys, Setting, Task}
+import xsbti.compile.CompileAnalysis
+
+private object CompileTaskCompat {
+  def compileSetting(scope: Configuration, task: Def.Initialize[Task[CompileAnalysis]]): Setting[?] =
+    (scope / Keys.compile) := Def.uncached(task).value
+}

src/main/scala/com/typesafe/sbteclipse/core/Eclipse.scala

@@ -18,6 +18,7 @@
 
 package com.typesafe.sbteclipse.core
 
+import sbt._
 import EclipsePlugin.{
   EclipseClasspathEntry,
   EclipseTransformerFactory,
@@ -39,7 +40,6 @@ import sbt.{
   Configurations,
   EvaluateTask,
   File,
-  Inc,
   Incomplete,
   Keys,
   ModuleID,
@@ -52,8 +52,7 @@ import sbt.{
   State,
   TaskKey,
   ThisBuild,
-  UpdateReport,
-  Value
+  UpdateReport
 }
 import sbt.fileToRichFile
 import sbt.internal.BuildStructure
@@ -100,7 +99,9 @@ private object Eclipse extends EclipseSDTConfig {
     import EclipseExecutionEnvironment._
     import EclipseOpts._
     import sbt.complete.DefaultParsers._
-    val (head :: tail) = valueSeq map (_.toString)
+    val parsedValues = valueSeq.toList.map(_.toString)
+    val head = parsedValues.head
+    val tail = parsedValues.tail
     val executionEnvironments = tail.foldLeft(head: Parser[String])(_ | _)
     (Space ~> ExecutionEnvironment ~ ("=" ~> executionEnvironments)) map { case (k, v) => k -> withName(v) }
   }
@@ -109,7 +110,9 @@ private object Eclipse extends EclipseSDTConfig {
     import EclipseJDTMode._
     import EclipseOpts._
     import sbt.complete.DefaultParsers._
-    val (head :: tail) = valueSeq map (_.toString)
+    val parsedValues = valueSeq.toList.map(_.toString)
+    val head = parsedValues.head
+    val tail = parsedValues.tail
     val jdtModes = tail.foldLeft(head: Parser[String])(_ | _)
     (Space ~> JDTMode ~ ("=" ~> jdtModes)) map { case (k, v) => k -> withName(v) }
   }
@@ -160,7 +163,7 @@ private object Eclipse extends EclipseSDTConfig {
           builderAndNatures(projectFlavor(ref, state)),
           state))
     }
-    effects.toList.sequence[Validation, IO[String]].map((list: List[IO[String]]) => list.toStream.sequence.map(_.toList))
+    effects.toList.sequence[Validation, IO[String]].map((list: List[IO[String]]) => list.sequence.map(_.toList))
   }
 
   def removeExtendedConfigurations(configurations: Seq[Configuration]): Seq[Configuration] = {
@@ -230,8 +233,8 @@ private object Eclipse extends EclipseSDTConfig {
         projectDependencies,
         jreContainer,
         state)
-      _ <- saveXml(baseDirectory / ".project", new RuleTransformer(projectTransformers: _*)(projectXml(name, builderAndNatures, linkedSrcDirectories)))
-      _ <- saveXml(baseDirectory / ".classpath", new RuleTransformer(classpathTransformers: _*)(cp))
+      _ <- saveXml(baseDirectory / ".project", new RuleTransformer(projectTransformers*)(projectXml(name, builderAndNatures, linkedSrcDirectories)))
+      _ <- saveXml(baseDirectory / ".classpath", new RuleTransformer(classpathTransformers*)(cp))
       _ <- saveProperties(baseDirectory / ".settings" / "org.eclipse.core.resources.prefs", Seq(("encoding/<project>" -> "UTF-8")))
       _ <- saveProperties(baseDirectory / ".settings" / "org.scala-ide.sdt.core.prefs", scalacOptions ++: compileOrder.map { order => Seq(("compileorder" -> order)) }.getOrElse(Nil))
       _ <- handleJDTSettings(jdtMode, baseDirectory, jreContainer)
@@ -330,10 +333,10 @@ private object Eclipse extends EclipseSDTConfig {
           dir
       }
       val entries = srcEntries ++ linkEntries ++
-        (projectDependencies map EclipseClasspathEntry.Project) ++
+        (projectDependencies map EclipseClasspathEntry.Project.apply) ++
         (externalDependencies map libEntry(buildDirectory, baseDirectory, relativizeLibs, state)) ++
-        (Seq(jreContainer) map EclipseClasspathEntry.Con) ++
-        (Seq(classDirectory) map EclipseClasspathEntry.Output)
+        (Seq(jreContainer) map EclipseClasspathEntry.Con.apply) ++
+        (Seq(classDirectory) map EclipseClasspathEntry.Output.apply)
       <classpath>{ entries map (_.toXml) }</classpath>
     }
   }
@@ -389,7 +392,7 @@ private object Eclipse extends EclipseSDTConfig {
         if (buildDirectory === baseDirectory) Some(".") else sbt.IO.relativize(buildDirectory, baseDirectory)
       val relativizedFile = sbt.IO.relativize(buildDirectory, file)
       val relativized = (relativizedBase |@| relativizedFile)((base, file) =>
-        s"${base split FileSepPattern map (part => if (part != ".") ".." else part) mkString FileSep}${FileSep}${file}")
+        s"${base.split(FileSepPattern).map(part => if (part != ".") ".." else part).mkString(FileSep)}${FileSep}${file}")
       if (relativizeLibs) relativized getOrElse file.getAbsolutePath else file.getAbsolutePath
     }
     EclipseClasspathEntry.Lib(path(lib.binary), lib.source map path, lib.javadoc map path)
@@ -484,7 +487,8 @@ private object Eclipse extends EclipseSDTConfig {
       dirs(ValueSet(), Keys.unmanagedSourceDirectories),
       dirs(ValueSet(), Keys.unmanagedResourceDirectories),
       dirs(ValueSet(ManagedSrc), Keys.managedSourceDirectories),
-      dirs(ValueSet(ManagedResources), Keys.managedResourceDirectories)) reduceLeft (_ +++ _)
+      dirs(ValueSet(ManagedResources), Keys.managedResourceDirectories)
+    ).sequence.map(_.flatten)
   }
 
   def scalacOptions(ref: ProjectRef, state: State): Validation[Seq[(String, String)]] = {
@@ -511,7 +515,7 @@ private object Eclipse extends EclipseSDTConfig {
     def moduleReports(key: TaskKey[UpdateReport]) =
       evalTask(key) map { updateReport =>
         for {
-          configurationReport <- (updateReport configuration configuration).toSeq
+          configurationReport <- updateReport.configuration(configuration).toSeq
           moduleReports <- configurationReport.modules
         } yield moduleReports
       }
@@ -528,14 +532,24 @@ private object Eclipse extends EclipseSDTConfig {
     def moduleFileToArtifactFile(binaries: Map[ModuleID, File], sources: Map[ModuleID, File], javadocs: Map[ModuleID, File]) =
       for ((moduleId, binaryFile) <- binaries)
         yield binaryFile -> Lib(binaryFile)(sources get moduleId)(javadocs get moduleId)
-    def libs(files: Seq[Attributed[File]], moduleFiles: Map[File, Lib]): Seq[Lib] = {
-      var result: Seq[Lib] = files.files map { file => moduleFiles.get(file).getOrElse(Lib(file)(None)(None)) }
+    def classpathFile(a: Attributed[?], conv: xsbti.FileConverter): File =
+      a.data match {
+        case file: File                => file
+        case ref: xsbti.VirtualFileRef => conv.toPath(ref).toFile
+      }
+
+    def libs(files: Seq[Attributed[?]], conv: xsbti.FileConverter, moduleFiles: Map[File, Lib]): Seq[Lib] = {
+      var result: Seq[Lib] = files.map { a =>
+        val file = classpathFile(a, conv)
+        moduleFiles.get(file).getOrElse(Lib(file)(None)(None))
+      }
       if (createSrc(ref, state)(configuration).contains(EclipseCreateSrc.ManagedClasses)) {
         result = result ++ managedClassDirectories(ref, state)(configuration).filter(_.exists).map(Lib(_)(None)(None))
       }
       result
     }
     val externalDependencyClasspath: Validation[sbt.Keys.Classpath] = evalTask(Keys.externalDependencyClasspath)
+    val fileConverter = settingValidation((ref / Keys.fileConverter), state)
     val moduleFiles: Validation[Map[File, Lib]] = {
       lazy val classifierModuleReports = moduleReports(Keys.updateClassifiers)
 
@@ -551,14 +565,14 @@ private object Eclipse extends EclipseSDTConfig {
 
       sources |+| javadoc match {
         case Some(_) => {
-          val binaryModuleToFile = moduleToFile(moduleReports(Keys.update))
+          val binaryModuleToFile = moduleToFile(moduleReports(Keys.update), (_, _) => true)
 
           (binaryModuleToFile |@| classifierModuleToFile(sources) |@| classifierModuleToFile(javadoc))(moduleFileToArtifactFile)
         }
         case None => Map[File, Lib]().success
       }
     }
-    val externalDependencies = (externalDependencyClasspath |@| moduleFiles)(libs)
+    val externalDependencies = (externalDependencyClasspath |@| fileConverter |@| moduleFiles)(libs)
     state.log.debug(
       s"External dependencies for configuration '${configuration}' and withSource '${withSource}' and withJavadoc '${withJavadoc}': ${externalDependencies}")
     externalDependencies
@@ -731,8 +745,8 @@ private object Eclipse extends EclipseSDTConfig {
     new File(normalizeName(file.getAbsolutePath))
 
   def normalizeName(filename: String): String = {
-    if (filename contains "..") {
-      val parts = (filename split "[\\/]+").toList
+    if (filename.contains("..")) {
+      val parts = (filename.split("[\\/]+")).toList
       def fix(parts: List[String], result: String): String = parts match {
         case Nil => result
         case a :: ".." :: rest => fix(rest, result)
@@ -751,7 +765,11 @@ private object Eclipse extends EclipseSDTConfig {
 
   def boolOpt(key: String): Parser[(String, Boolean)] = {
     import sbt.complete.DefaultParsers._
-    (Space ~> key ~ ("=" ~> ("true" | "false"))) map { case (k, v) => k -> v.toBoolean }
+    val parserValues = List("true", "false").map(s => s: Parser[String])
+    val head = parserValues.head
+    val tail = parserValues.tail
+    val bools = tail.foldLeft(head)(_ | _)
+    (Space ~> key ~ ("=" ~> bools)) map { case (k, v) => k -> v.toBoolean }
   }
 
   /**
@@ -773,8 +791,11 @@ private object Eclipse extends EclipseSDTConfig {
   def evaluateTask[A](key: TaskKey[A], ref: ProjectRef, state: State): Validation[A] = {
     val taskConfig = EvaluateTask.extractedTaskConfig(Project.extract(state), structure(state), state)
     EvaluateTask(structure(state), key, state, ref, taskConfig) match {
-      case Some((_, Value(a))) => a.success
-      case Some((_, Inc(inc))) => s"Error evaluating task '${key.key}': ${Incomplete.show(inc.tpe)}".failureNel
+      case Some((_, result)) =>
+        result.toEither.fold(
+          inc => s"Error evaluating task '${key.key}': ${Incomplete.show(inc.tpe)}".failureNel,
+          _.success
+        )
       case None => s"Undefined task '${key.key}' for '${ref.project}'!".failureNel
     }
   }