Bump TASTy version, add documentation and runtime test to ensure corr…

…ectness of set TASTY version

project/Build.scala

@@ -93,9 +93,10 @@ object Build {
 
   /** Version of the Scala compiler used to build the artifacts.
    *  Reference version should track the latest version pushed to Maven:
-   *  - In main branch it should be the last RC version (using experimental TASTy required for non-bootstrapped tests)
+   *  - In main branch it should be the last RC version
    *  - In release branch it should be the last stable release
-   *  3.6.0-RC1 was released as 3.6.0 - it's having and experimental TASTy version
+   * 
+   *  Warning: Change of this variable needs to consulted with `expectedTastyVersion` 
    */
   val referenceVersion = "3.6.3-RC1"
 
@@ -105,6 +106,8 @@ object Build {
    *
    *  Should only be referred from `dottyVersion` or settings/tasks requiring simplified version string,
    *  eg. `compatMode` or Windows native distribution version.
+   * 
+   *  Warning: Change of this variable might require updating `expectedTastyVersion` 
    */
   val developedVersion = "3.6.4"
 
@@ -116,6 +119,24 @@ object Build {
    *  During final, stable release is set exactly to `developedVersion`.
   */
   val baseVersion = s"$developedVersion-RC1"
+
+  /** The version of TASTY that should be emitted, checked in runtime test 
+   *  For defails on how TASTY version should be set see related discussions: 
+   *    - https://github.com/scala/scala3/issues/13447#issuecomment-912447107
+   *    - https://github.com/scala/scala3/issues/14306#issuecomment-1069333516
+   *    - https://github.com/scala/scala3/pull/19321
+   *   
+   *  Simplified rules, given 3.$minor.$patch = $developedVersion
+   *    - Major version is always 28
+   *    - TASTY minor version:
+   *      - in main (NIGHTLY): {if $patch == 0 then $minor else ${minor + 1}}
+   *      - in release branch is always equal to $minor
+   *    - TASTY experimental version:
+   *      - in main (NIGHTLY) is always experimental
+   *      - in release candidate branch is experimental if {patch == 0}
+   *      - in stable release is always non-experimetnal
+   */
+  val expectedTastyVersion = "28.7-experimental-1"
 
   /** Final version of Scala compiler, controlled by environment variables. */
   val dottyVersion = {
@@ -2424,6 +2445,10 @@ object Build {
       settings(disableDocSetting).
       settings(
         versionScheme := Some("semver-spec"),
+        Test / envVars ++= Map(
+          "EXPECTED_TASTY_VERSION" -> expectedTastyVersion,
+          "BASE_VERSION" -> baseVersion
+        ),
         if (mode == Bootstrapped) Def.settings(
           commonMiMaSettings,
           mimaForwardIssueFilters := MiMaFilters.TastyCore.ForwardsBreakingChanges,

tasty/src/dotty/tools/tasty/TastyFormat.scala

@@ -324,7 +324,7 @@ object TastyFormat {
    *  compatibility, but remains backwards compatible, with all
    *  preceding `MinorVersion`.
    */
-  final val MinorVersion: Int = 6
+  final val MinorVersion: Int = 7
 
   /** Natural Number. The `ExperimentalVersion` allows for
    *  experimentation with changes to TASTy without committing

tasty/test/dotty/tools/tasty/BuildTastyVersionTest.scala

@@ -0,0 +1,65 @@
+package dotty.tools.tasty
+
+import org.junit.Assert._
+import org.junit.Test
+
+import TastyBuffer._
+
+// Tests ensuring TASTY version emitted by compiler is matching expected TASTY version
+class BuildTastyVersionTest {
+
+  val CurrentTastyVersion = TastyVersion(TastyFormat.MajorVersion, TastyFormat.MinorVersion, TastyFormat.ExperimentalVersion)
+
+  // Needs to be defined in build Test/envVars
+  val ExpectedTastyVersionEnvVar = "EXPECTED_TASTY_VERSION"
+  val BaseVersionEnvVar = "BASE_VERSION"
+
+  @Test def testBuildTastyVersion(): Unit = {
+    val expectedVersion = sys.env.get(ExpectedTastyVersionEnvVar)
+      .getOrElse(fail(s"Env variable $ExpectedTastyVersionEnvVar not defined"))
+      .match {
+        case s"$major.$minor-experimental-$experimental" => TastyVersion(major.toInt, minor.toInt, experimental.toInt)
+        case s"$major.$minor" if minor.forall(_.isDigit) => TastyVersion(major.toInt, minor.toInt, 0)
+        case other => fail(s"Invalid TASTY version string: $other")
+      }
+    assertEquals(CurrentTastyVersion, expectedVersion)
+  }
+
+  // Tested only in nightly / release builds
+  // Protects from publishing artifacts with incorrect TASTY version
+  @Test def testReleasedTastyVersion(): Unit = {
+    lazy val (minor, patch, isRC) = sys.env.get(BaseVersionEnvVar)
+      .getOrElse(fail(s"Env variable $BaseVersionEnvVar not defined"))
+      .match {
+        case s"3.$minor.$patch-${_}" => (minor.toInt, patch.toInt, true)
+        case s"3.$minor.$patch"      => (minor.toInt, patch.toInt, false)
+        case other => fail(s"Invalid Scala base version string: $other")
+      }
+
+    if sys.env.get("NIGHTLYBUILD").contains("yes") then {
+      assertTrue(
+        "TASTY needs to be experimental in nightly builds",
+        CurrentTastyVersion.isExperimental
+      )
+      assertEquals(
+        CurrentTastyVersion.minor,
+        if patch == 0 then minor else (minor + 1)
+      )
+    } else if sys.env.get("RELEASEBUILD").contains("yes") then {
+      assertEquals(
+        "Minor versions of TASTY vesion and Scala version should match in stable release",
+        CurrentTastyVersion.minor, minor
+      )
+      if isRC then
+        assertEquals(
+          "TASTy should be experimental when releasing a new minor version RC",
+          CurrentTastyVersion.isExperimental, patch == 0
+        )  
+      else 
+        assertFalse(
+          "Stable version cannot use experimental TASTY", 
+          CurrentTastyVersion.isExperimental
+        )
+    }
+  }
+}