Finalize work on @SInCE and -scala-release:

* Add missing @SInCE annotations to definitions
* Add missing checks for @SInCE
* Add more tests

Author: prolativ

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

@@ -0,0 +1,21 @@
+package dotty.tools.dotc.config
+
+import dotty.tools.tasty.TastyVersion
+
+enum ScalaRelease(val majorVersion: Int, val minorVersion: Int) extends Ordered[ScalaRelease]:
+  case Release3_0 extends ScalaRelease(3, 0)
+  case Release3_1 extends ScalaRelease(3, 1)
+
+  def show = s"$majorVersion.$minorVersion"
+
+  def compare(that: ScalaRelease) =
+    val ord = summon[Ordering[(Int, Int)]]
+    ord.compare((majorVersion, minorVersion), (that.majorVersion, that.minorVersion))
+
+object ScalaRelease:
+  def latest = Release3_1
+
+  def parse(name: String) = name match
+    case "3.0" => Some(Release3_0)
+    case "3.1" => Some(Release3_1)
+    case _ => None

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

@@ -26,6 +26,9 @@ object ScalaSettings:
       (minTargetVersion to maxVersion).toList.map(_.toString)
     else List(minTargetVersion).map(_.toString)
 
+  def supportedScalaReleaseVersions: List[String] =
+    ScalaRelease.values.toList.map(_.show)
+
   def defaultClasspath: String = sys.env.getOrElse("CLASSPATH", ".")
 
   def defaultPageWidth: Int = {
@@ -101,7 +104,7 @@ 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[ScalaVersion] = VersionSetting("-scala-release", "Emit TASTy files that can be consumed by specified version of the compiler.")
+  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"))

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

@@ -24,7 +24,7 @@ import io.{AbstractFile, NoAbstractFile, PlainFile, Path}
 import scala.io.Codec
 import collection.mutable
 import printing._
-import config.{JavaPlatform, SJSPlatform, Platform, ScalaSettings}
+import config.{JavaPlatform, SJSPlatform, Platform, ScalaSettings, ScalaRelease}
 import classfile.ReusableDataReader
 import StdNames.nme
 
@@ -38,8 +38,8 @@ import xsbti.AnalysisCallback
 import plugins._
 import java.util.concurrent.atomic.AtomicInteger
 import java.nio.file.InvalidPathException
-import dotty.tools.tasty.TastyFormat
-import dotty.tools.dotc.config.{ NoScalaVersion, SpecificScalaVersion, AnyScalaVersion }
+import dotty.tools.tasty.{ TastyFormat, TastyVersion }
+import dotty.tools.dotc.config.{ NoScalaVersion, SpecificScalaVersion, AnyScalaVersion, ScalaBuild }
 
 object Contexts {
 
@@ -484,13 +484,20 @@ object Contexts {
     def importContext(imp: Import[?], sym: Symbol): FreshContext =
       fresh.setImportInfo(ImportInfo(sym, imp.selectors, imp.expr))
 
-    def tastyVersion: (Int, Int, Int) =
-      base.settings.scalaRelease.value match
-        case NoScalaVersion =>
-          import TastyFormat.*
-          (MajorVersion, MinorVersion, ExperimentalVersion)
-        case SpecificScalaVersion(maj, min, _, _) => (maj.toInt + 25, min.toInt, 0)
-        case AnyScalaVersion => (28, 0, 0) // 3.0
+    def scalaRelease: ScalaRelease =
+      val releaseName = base.settings.scalaRelease.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
+        // (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
+        TastyVersion.compilerVersion
 
     /** Is the debug option set? */
     def debug: Boolean = base.settings.Ydebug.value

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

@@ -3,7 +3,7 @@ package dotc
 package core
 package classfile
 
-import dotty.tools.tasty.{ TastyReader, TastyHeaderUnpickler }
+import dotty.tools.tasty.{ TastyFormat, TastyReader, TastyHeaderUnpickler, TastyVersion }
 
 import Contexts._, Symbols._, Types._, Names._, StdNames._, NameOps._, Scopes._, Decorators._
 import SymDenotations._, unpickleScala2.Scala2Unpickler._, Constants._, Annotations._, util.Spans._
@@ -884,7 +884,7 @@ class ClassfileParser(
       }
 
       def unpickleTASTY(bytes: Array[Byte]): Some[Embedded]  = {
-        val unpickler = new tasty.DottyUnpickler(bytes)
+        val unpickler = new tasty.DottyUnpickler(bytes, ctx.tastyVersion)
         unpickler.enter(roots = Set(classRoot, moduleRoot, moduleRoot.sourceModule))(using ctx.withSource(util.NoSource))
         Some(unpickler)
       }
@@ -950,9 +950,23 @@ class ClassfileParser(
           if (tastyBytes.nonEmpty) {
             val reader = new TastyReader(bytes, 0, 16)
             val expectedUUID = new UUID(reader.readUncompressedLong(), reader.readUncompressedLong())
-            val tastyUUID = new TastyHeaderUnpickler(tastyBytes).readHeader()
+            val tastyHeader = new TastyHeaderUnpickler(tastyBytes).readFullHeader()
+            val fileTastyVersion = TastyVersion(tastyHeader.majorVersion, tastyHeader.minorVersion, tastyHeader.experimentalVersion)
+            val tastyUUID = tastyHeader.uuid
             if (expectedUUID != tastyUUID)
               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}
+              """.stripMargin)
+
             return unpickleTASTY(tastyBytes)
           }
         }

compiler/src/dotty/tools/dotc/core/tasty/DottyUnpickler.scala

@@ -10,7 +10,7 @@ import classfile.ClassfileParser
 import Names.SimpleName
 import TreeUnpickler.UnpickleMode
 
-import dotty.tools.tasty.TastyReader
+import dotty.tools.tasty.{ TastyReader, TastyVersion }
 import dotty.tools.tasty.TastyFormat.{ASTsSection, PositionsSection, CommentsSection}
 
 object DottyUnpickler {
@@ -39,7 +39,7 @@ object DottyUnpickler {
  *  @param bytes         the bytearray containing the Tasty file from which we unpickle
  *  @param mode          the tasty file contains package (TopLevel), an expression (Term) or a type (TypeTree)
  */
-class DottyUnpickler(bytes: Array[Byte], mode: UnpickleMode = UnpickleMode.TopLevel) extends ClassfileParser.Embedded with tpd.TreeProvider {
+class DottyUnpickler(bytes: Array[Byte], maximalTastyVersion: TastyVersion, mode: UnpickleMode = UnpickleMode.TopLevel) extends ClassfileParser.Embedded with tpd.TreeProvider {
   import tpd._
   import DottyUnpickler._
 

compiler/src/dotty/tools/dotc/core/tasty/TastyPickler.scala

@@ -36,14 +36,14 @@ class TastyPickler(val rootCls: ClassSymbol) {
     def lengthWithLength(buf: TastyBuffer) =
       buf.length + natSize(buf.length)
 
-    val (majorVersion, minorVersion, experimentalVersion) = ctx.tastyVersion
-
     nameBuffer.assemble()
     sections.foreach(_._2.assemble())
 
     val nameBufferHash = TastyHash.pjwHash64(nameBuffer.bytes)
     val treeSectionHash +: otherSectionHashes = sections.map(x => TastyHash.pjwHash64(x._2.bytes))
 
+    val tastyVersion = ctx.tastyVersion
+
     // Hash of name table and tree
     val uuidLow: Long = nameBufferHash ^ treeSectionHash
     // Hash of positions, comments and any additional section
@@ -52,9 +52,9 @@ class TastyPickler(val rootCls: ClassSymbol) {
     val headerBuffer = {
       val buf = new TastyBuffer(header.length + TastyPickler.versionStringBytes.length + 32)
       for (ch <- header) buf.writeByte(ch.toByte)
-      buf.writeNat(majorVersion)
-      buf.writeNat(minorVersion)
-      buf.writeNat(experimentalVersion)
+      buf.writeNat(tastyVersion.major)
+      buf.writeNat(tastyVersion.minor)
+      buf.writeNat(tastyVersion.experimental)
       buf.writeNat(TastyPickler.versionStringBytes.length)
       buf.writeBytes(TastyPickler.versionStringBytes, TastyPickler.versionStringBytes.length)
       buf.writeUncompressedLong(uuidLow)

compiler/src/dotty/tools/dotc/quoted/PickledQuotes.scala

@@ -193,7 +193,7 @@ object PickledQuotes {
         quotePickling.println(s"**** unpickling quote from TASTY\n${TastyPrinter.showContents(bytes, ctx.settings.color.value == "never")}")
 
         val mode = if (isType) UnpickleMode.TypeTree else UnpickleMode.Term
-        val unpickler = new DottyUnpickler(bytes, mode)
+        val unpickler = new DottyUnpickler(bytes, ctx.tastyVersion, mode)
         unpickler.enter(Set.empty)
 
         val tree = unpickler.tree

compiler/src/dotty/tools/dotc/transform/Pickler.scala

@@ -125,7 +125,7 @@ class Pickler extends Phase {
     ctx.initialize()
     val unpicklers =
       for ((cls, pickler) <- picklers) yield {
-        val unpickler = new DottyUnpickler(pickler.assembleParts())
+        val unpickler = new DottyUnpickler(pickler.assembleParts(), ctx.tastyVersion)
         unpickler.enter(roots = Set.empty)
         cls -> unpickler
       }

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

@@ -15,7 +15,7 @@ import ast._
 import MegaPhase._
 import config.Printers.{checks, noPrinter}
 import scala.util.{Try, Failure, Success}
-import config.{ScalaVersion, NoScalaVersion}
+import config.{ScalaVersion, NoScalaVersion, ScalaRelease}
 import Decorators._
 import OverridingPairs.isOverridingPair
 import typer.ErrorReporting._
@@ -976,14 +976,14 @@ object RefChecks {
       annot <- sym.getAnnotation(defn.SinceAnnot)
       version <- annot.argumentConstantString(0)
     do
-      val releaseVersion = ctx.settings.scalaRelease.value
-      ScalaVersion.parse(version) match
-        case Success(symVersion) if symVersion > ctx.settings.scalaRelease.value =>
+      val releaseVersion = ctx.scalaRelease
+      ScalaRelease.parse(version) match
+        case Some(symVersion) if symVersion > releaseVersion =>
           report.error(
-            i"$sym was added in Scala $version, therefore it cannot be used in the code targeting Scala ${releaseVersion.unparse}",
+            i"$sym was added in Scala $version, therefore it cannot be used in the code targeting Scala ${releaseVersion.show}",
             pos)
-        case Failure(ex) =>
-          report.warning(i"$sym has an unparsable version number: ${ex.getMessage}", pos)
+        case None =>
+          report.warning(i"$sym has an unparsable release name: '${version}'", pos)
         case _ =>
 
   private def checkSinceAnnotInSignature(sym: Symbol, pos: SrcPos)(using Context) =
@@ -1320,6 +1320,7 @@ class RefChecks extends MiniPhase { thisPhase =>
     checkImplicitNotFoundAnnotation.template(cls.classDenot)
     checkExperimentalInheritance(cls)
     checkExperimentalAnnots(cls)
+    checkSinceAnnot(cls, cls.srcPos)
     tree
   }
   catch {
@@ -1371,9 +1372,11 @@ class RefChecks extends MiniPhase { thisPhase =>
       case TypeRef(_, sym: Symbol)  =>
         checkDeprecated(sym, tree.srcPos)
         checkExperimental(sym, tree.srcPos)
+        checkSinceAnnot(sym, tree.srcPos)
       case TermRef(_, sym: Symbol)  =>
         checkDeprecated(sym, tree.srcPos)
         checkExperimental(sym, tree.srcPos)
+        checkSinceAnnot(sym, tree.srcPos)
       case _ =>
     }
     tree

compiler/test/dotty/tools/dotc/core/tasty/CommentPicklingTest.scala

@@ -114,7 +114,7 @@ class CommentPicklingTest {
       implicit val ctx: Context = setup(args, initCtx).map(_._2).getOrElse(initCtx)
       ctx.initialize()
       val trees = files.flatMap { f =>
-        val unpickler = new DottyUnpickler(f.toByteArray())
+        val unpickler = new DottyUnpickler(f.toByteArray(), ctx.tastyVersion)
         unpickler.enter(roots = Set.empty)
         unpickler.rootTrees(using ctx)
       }