Reworks for forward compat:

* Make -scala-release an experimental setting
* Add better checks of of TASTy version
* Validate names of releases inside since annotations
* Extend Vulpix to check actual counts and possitions of errors from other compilers

Author: prolativ

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -104,7 +104,6 @@ trait CommonScalaSettings:
   val silentWarnings: Setting[Boolean] = BooleanSetting("-nowarn", "Silence all warnings.", aliases = List("--no-warnings"))
 
   val release: Setting[String] = ChoiceSetting("-release", "release", "Compile code with classes specific to the given version of the Java platform available on the classpath and emit bytecode for this version.", ScalaSettings.supportedReleaseVersions, "", aliases = List("--release"))
-  val scalaRelease: Setting[String] = ChoiceSetting("-scala-release", "release", "Emit TASTy files that can be consumed by specified version of the compiler.", ScalaSettings.supportedScalaReleaseVersions, "", aliases = List("--scala-release"))
   val deprecation: Setting[Boolean] = BooleanSetting("-deprecation", "Emit warning and location for usages of deprecated APIs.", aliases = List("--deprecation"))
   val feature: Setting[Boolean] = BooleanSetting("-feature", "Emit warning and location for usages of features that should be imported explicitly.", aliases = List("--feature"))
   val explain: Setting[Boolean] = BooleanSetting("-explain", "Explain errors in more detail.", aliases = List("--explain"))
@@ -311,6 +310,7 @@ private sealed trait YSettings:
   val YexplicitNulls: Setting[Boolean] = BooleanSetting("-Yexplicit-nulls", "Make reference types non-nullable. Nullable types can be expressed with unions: e.g. String|Null.")
   val YcheckInit: Setting[Boolean] = BooleanSetting("-Ysafe-init", "Ensure safe initialization of objects")
   val YrequireTargetName: Setting[Boolean] = BooleanSetting("-Yrequire-targetName", "Warn if an operator is defined without a @targetName annotation")
+  val YscalaRelease: Setting[String] = ChoiceSetting("-Yscala-release", "release", "Emit TASTy files that can be consumed by specified version of the compiler.", ScalaSettings.supportedScalaReleaseVersions, "", aliases = List("--Yscala-release"))
 
   /** Area-specific debug output */
   val YexplainLowlevel: Setting[Boolean] = BooleanSetting("-Yexplain-lowlevel", "When explaining type errors, show types at a lower level.")

compiler/src/dotty/tools/dotc/core/Contexts.scala

@@ -485,15 +485,15 @@ object Contexts {
       fresh.setImportInfo(ImportInfo(sym, imp.selectors, imp.expr))
 
     def scalaRelease: ScalaRelease =
-      val releaseName = base.settings.scalaRelease.value
+      val releaseName = base.settings.YscalaRelease.value
       if releaseName.nonEmpty then ScalaRelease.parse(releaseName).get else ScalaRelease.latest
 
     def tastyVersion: TastyVersion =
       import math.Ordered.orderingToOrdered
       val latestRelease = ScalaRelease.latest
       val specifiedRelease = scalaRelease
-      if ((specifiedRelease.majorVersion, specifiedRelease.minorVersion) < (latestRelease.majorVersion, latestRelease.majorVersion)) then
-        // This is needed to make -scala-release a no-op when set to the latest release for unstable versions of the compiler
+      if ((specifiedRelease.majorVersion, specifiedRelease.minorVersion) < (latestRelease.majorVersion, latestRelease.minorVersion)) then
+        // This is needed to make -Yscala-release a no-op when set to the latest release for unstable versions of the compiler
         // (which might have the tasty format version numbers set to higher values before they're decreased during a release)
         TastyVersion.fromStableScalaRelease(specifiedRelease.majorVersion, specifiedRelease.minorVersion)
       else

compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -957,16 +957,23 @@ class ClassfileParser(
               report.warning(s"$classfile is out of sync with its TASTy file. Loaded TASTy file. Try cleaning the project to fix this issue", NoSourcePosition)
 
             val tastyFilePath = classfile.path.stripSuffix(".class") + ".tasty"
-            val isTastyCompatible =
-              TastyFormat.isVersionCompatible(fileVersion = fileTastyVersion, compilerVersion = ctx.tastyVersion) ||
-              classRoot.symbol.showFullName.startsWith("scala.") // References to stdlib are considered safe because we check the values of @since annotations
-
-            if !isTastyCompatible then
-              report.error(s"""The class ${classRoot.symbol.showFullName} cannot be loaded from file ${tastyFilePath} because its TASTy format version is too high
-                |highest allowed: ${ctx.tastyVersion.show}
-                |found:           ${fileTastyVersion.show}
+
+            def reportWrongTasty(reason: String, highestAllowed: TastyVersion) =
+              report.error(s"""The class ${classRoot.symbol.showFullName} cannot be loaded from file ${tastyFilePath} because $reason:
+                              |highest allowed: ${highestAllowed.show}
+                              |found:           ${fileTastyVersion.show}
               """.stripMargin)
 
+            val isTastyReadable = TastyFormat.isVersionCompatible(fileVersion = fileTastyVersion, compilerVersion = TastyVersion.compilerVersion)
+            if !isTastyReadable then
+              reportWrongTasty("its TASTy format cannot be read by the compiler", TastyVersion.compilerVersion)
+            else
+              val isTastyCompatible =
+                TastyFormat.isVersionCompatible(fileVersion = fileTastyVersion, compilerVersion = ctx.tastyVersion) ||
+                classRoot.symbol.showFullName.startsWith("scala.") // References to stdlib are considered safe because we check the values of @since annotations
+              if !isTastyCompatible then
+                reportWrongTasty(s"its TASTy format is not compatible with the one of the targeted Scala release (${ctx.scalaRelease.show})", ctx.tastyVersion)
+
             return unpickleTASTY(tastyBytes)
           }
         }

compiler/src/dotty/tools/dotc/typer/RefChecks.scala

@@ -974,16 +974,15 @@ object RefChecks {
   private def checkSinceAnnot(sym: Symbol, pos: SrcPos)(using Context): Unit =
     for
       annot <- sym.getAnnotation(defn.SinceAnnot)
-      version <- annot.argumentConstantString(0)
+      releaseName <- annot.argumentConstantString(0)
     do
-      val releaseVersion = ctx.scalaRelease
-      ScalaRelease.parse(version) match
-        case Some(symVersion) if symVersion > releaseVersion =>
+      ScalaRelease.parse(releaseName) match
+        case Some(release) if release > ctx.scalaRelease =>
           report.error(
-            i"$sym was added in Scala $version, therefore it cannot be used in the code targeting Scala ${releaseVersion.show}",
+            i"$sym was added in Scala release ${releaseName.show}, therefore it cannot be used in the code targeting Scala ${ctx.scalaRelease.show}",
             pos)
         case None =>
-          report.warning(i"$sym has an unparsable release name: '${version}'", pos)
+          report.error(i"$sym has an unparsable release name: '${releaseName}'", annot.tree.srcPos)
         case _ =>
 
   private def checkSinceAnnotInSignature(sym: Symbol, pos: SrcPos)(using Context) =
@@ -1281,6 +1280,7 @@ class RefChecks extends MiniPhase { thisPhase =>
     checkDeprecatedOvers(tree)
     checkExperimentalAnnots(tree.symbol)
     checkExperimentalSignature(tree.symbol, tree)
+    checkSinceAnnot(tree.symbol, tree.srcPos)
     checkSinceAnnotInSignature(tree.symbol, tree)
     val sym = tree.symbol
     if (sym.exists && sym.owner.isTerm) {
@@ -1320,7 +1320,6 @@ class RefChecks extends MiniPhase { thisPhase =>
     checkImplicitNotFoundAnnotation.template(cls.classDenot)
     checkExperimentalInheritance(cls)
     checkExperimentalAnnots(cls)
-    checkSinceAnnot(cls, cls.srcPos)
     tree
   }
   catch {
@@ -1384,6 +1383,7 @@ class RefChecks extends MiniPhase { thisPhase =>
 
   override def transformTypeDef(tree: TypeDef)(using Context): TypeDef = {
     checkExperimentalAnnots(tree.symbol)
+    checkSinceAnnot(tree.symbol, tree.srcPos)
     tree
   }
 }

compiler/test/dotty/tools/vulpix/ParallelTesting.scala

@@ -2,7 +2,7 @@ package dotty
 package tools
 package vulpix
 
-import java.io.{File => JFile, IOException}
+import java.io.{File => JFile, IOException, PrintStream, ByteArrayOutputStream}
 import java.lang.System.{lineSeparator => EOL}
 import java.net.URL
 import java.nio.file.StandardCopyOption.REPLACE_EXISTING
@@ -13,7 +13,7 @@ import java.util.{HashMap, Timer, TimerTask}
 import java.util.concurrent.{TimeUnit, TimeoutException, Executors => JExecutors}
 
 import scala.collection.mutable
-import scala.io.Source
+import scala.io.{Codec, Source}
 import scala.util.{Random, Try, Failure => TryFailure, Success => TrySuccess, Using}
 import scala.util.control.NonFatal
 import scala.util.matching.Regex
@@ -27,7 +27,7 @@ import dotc.interfaces.Diagnostic.ERROR
 import dotc.reporting.{Reporter, TestReporter}
 import dotc.reporting.Diagnostic
 import dotc.config.Config
-import dotc.util.DiffUtil
+import dotc.util.{DiffUtil, SourceFile, SourcePosition, Spans}
 import io.AbstractFile
 import dotty.tools.vulpix.TestConfiguration.defaultOptions
 
@@ -215,7 +215,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
 
         case testSource @ SeparateCompilationSource(_, dir, flags, outDir) =>
           testSource.compilationGroups.map { (group, files) =>
-            val flags1 = if group.release.isEmpty then flags else flags.and(s"-scala-release:${group.release}")
+            val flags1 = if group.release.isEmpty then flags else flags.and("-Yscala-release", group.release)
             if group.compiler.isEmpty then
               compile(files, flags1, suppressErrors, outDir)
             else
@@ -504,6 +504,21 @@ trait ParallelTesting extends RunnerOrchestration { self =>
       reporter
     }
 
+    private def parseErrors(errorsText: String, compilerVersion: String) =
+      val errorPattern = """.*Error: (.*\.scala):(\d+):(\d+).*""".r
+      errorsText.linesIterator.toSeq.collect {
+        case errorPattern(filePath, line, column) =>
+          val lineNum = line.toInt
+          val columnNum = column.toInt
+          val abstractFile = AbstractFile.getFile(filePath)
+          val sourceFile = SourceFile(abstractFile, Codec.UTF8)
+          val offset = sourceFile.lineToOffset(lineNum - 1) + columnNum - 1
+          val span = Spans.Span(offset)
+          val sourcePos = SourcePosition(sourceFile, span)
+
+          Diagnostic.Error(s"Compilation of $filePath with Scala $compilerVersion failed at line: $line, column: $column. Full error output:\n\n$errorsText\n", sourcePos)
+      }
+
     protected def compileWithOtherCompiler(compiler: String, files: Array[JFile], flags: TestFlags, targetDir: JFile): TestReporter =
       val compilerDir = getCompiler(compiler).toString
 
@@ -517,14 +532,18 @@ trait ParallelTesting extends RunnerOrchestration { self =>
         .withClasspath(targetDir.getPath)
         .and("-d", targetDir.getPath)
 
-      val reporter = TestReporter.reporter(realStdout, ERROR)
+      val dummyStream = new PrintStream(new ByteArrayOutputStream())
+      val reporter = TestReporter.reporter(dummyStream, ERROR)
 
       val command = Array(compilerDir + "/bin/scalac") ++ flags1.all ++ files.map(_.getPath)
       val process = Runtime.getRuntime.exec(command)
-      val output = Source.fromInputStream(process.getErrorStream).mkString
+      val errorsText = Source.fromInputStream(process.getErrorStream).mkString
       if process.waitFor() != 0 then
-        echo(s"\nCompilation using Scala $compiler failed: \n$output")
-        fail()
+        val diagnostics = parseErrors(errorsText, compiler)
+        diagnostics.foreach { diag =>
+          val context = (new ContextBase).initialCtx
+          reporter.report(diag)(using context)
+        }
 
       reporter
 

tasty/src/dotty/tools/tasty/TastyVersion.scala

@@ -1,7 +1,7 @@
 package dotty.tools.tasty
 
 case class TastyVersion(major: Int, minor: Int, experimental: Int) {
-  def show = s"$major.$minor-$experimental"
+  def show = "" + major + "." + minor + "-" + experimental
 }
 
 object TastyVersion {

tests/neg/forwardCompat-illegalReferences/Test_r3.0.scala

@@ -24,4 +24,8 @@ def useQuotes(using Quotes) =
 
   class Box(w: Wildcard) // error
 
+  // The inferred result type also gets reported even though it's not written explicitly
   def castToWildcard(x: Any) = x.asInstanceOf[Wildcard] // error // error
+
+  // 2 errors reported because at the stage of compilation when this is checked (already after some code transformations) the illegal type is referred to more than once
+  val selectable: Any = new Selectable.WithoutPreciseParameterTypes {} // error // error

tests/neg/forwardCompat-invalidSince.scala

@@ -0,0 +1,21 @@
+package scala.test
+
+import annotation.since
+
+@since("") // error
+val x = 1
+
+@since("1.2.3.4") // error
+val y = "abc"
+
+@since("xyz") // error
+class Foo
+
+@since("-3") // error
+trait Bar
+
+@since("3.0.2") // error
+type Baz = Int
+
+@since("3.0 ") // error
+given String = ""

tests/neg/forwardCompat-nestedSumMirror/Lib_1_r3.0.scala

@@ -0,0 +1,8 @@
+// Adapted from i11050
+
+sealed trait TreeValue
+
+sealed trait SubLevel extends TreeValue
+
+case class Leaf1(value: String) extends TreeValue
+case class Leaf2(value: Int)    extends SubLevel

tests/neg/forwardCompat-nestedSumMirror/Test_2_c3.0.2.scala

@@ -0,0 +1,5 @@
+import scala.deriving._
+
+object Test:
+  def main(args: Array[String]): Unit =
+    println(summon[Mirror.Of[TreeValue]]) // error