Upgrade to Scala 3.8.1.

Major changes:

* Add support for the special erasure of `scala.caps.Pure`.
* Add the magic type aliases `scala.ImpureXYZFunctionN`,
  because apparently references to them are in TASTy, so
  they are de facto standard.

More benign changes:

* Switch `-Xfatal-warnings` to `-Werror`, as the former is
  not supported anymore.
* Disable `-source:future` for now, as it wants to enforce
  a bunch of syntax that we are not using yet.
* Address warnings from changes to `-Yexplicit-nulls`.
* Adjust tests to "cosmetic" changes to the inferred trees
  and their types.

Co-authored-by: Matt Dziuban <mrdziuban@gmail.com>

Author: sjrd

build.sbt

@@ -3,7 +3,7 @@ import sbt.internal.util.ManagedLogger
 
 import org.scalajs.jsenv.nodejs.NodeJSEnv
 
-val usedScalaCompiler = "3.7.1"
+val usedScalaCompiler = "3.8.1"
 val usedTastyRelease = usedScalaCompiler
 val scala2Version = "2.13.18"
 
@@ -50,10 +50,10 @@ val commonSettings = Seq(
 
 val strictCompileSettings = Seq(
   scalacOptions ++= Seq(
-    "-Xfatal-warnings",
     "-Yexplicit-nulls",
+    "-Werror",
     "-Wsafe-init",
-    "-source:future",
+    // "-source:future",
   ),
 )
 
@@ -69,7 +69,7 @@ lazy val scala2TestSources = crossProject(JSPlatform, JVMPlatform)
   .settings(
     scalaVersion := scala2Version,
     publish / skip := true,
-    scalacOptions += "-Xfatal-warnings",
+    scalacOptions += "-Werror",
     libraryDependencies += "org.scala-lang" % "scala-reflect" % scalaVersion.value % "provided",
   )
 
@@ -79,7 +79,7 @@ lazy val testSources = crossProject(JSPlatform, JVMPlatform)
   .settings(commonSettings)
   .settings(
     publish / skip := true,
-    scalacOptions += "-Xfatal-warnings",
+    scalacOptions += "-Werror",
     javacOptions += "-parameters",
   )
   .dependsOn(scala2TestSources)
@@ -126,10 +126,13 @@ lazy val tastyQuery =
       mimaBinaryIssueFilters ++= {
         import com.typesafe.tools.mima.core.*
         Seq(
+          // Scala 3.8.x generates fewer static initializers, but that is never an issue
+          ProblemFilters.exclude[DirectMissingMethodProblem]("*.<clinit>"),
         )
       },
 
-      tastyMiMaPreviousArtifacts := mimaPreviousArtifacts.value,
+      // Temporarily disabled until we have a published version of tasty-query that can handle 3.8.x.
+      // tastyMiMaPreviousArtifacts := mimaPreviousArtifacts.value,
       tastyMiMaTastyQueryVersionOverride := Some("1.6.0"),
       tastyMiMaConfig ~= { prev =>
         import tastymima.intf._

tasty-query/js/src/test/scala/tastyquery/testutil/nodejs/NodeJSTestPlatform.scala

@@ -26,10 +26,10 @@ object NodeJSTestPlatform:
     classpath
 
   lazy val scala3ClasspathIndex: Int =
-    classpathEntries.indexWhere(_.contains("scala3-library_3").nn)
+    classpathEntries.indexWhere(_.contains("scala-library-3"))
 
   def readResourceCodeFile(relPath: String): String =
-    val path = getEnvVar(ResourceCodeEnvVar).nn + "/" + relPath
+    val path = getEnvVar(ResourceCodeEnvVar) + "/" + relPath
     NodeFS.readFileSync(path, "utf-8")
 
   private object NodeFS:

tasty-query/jvm/src/main/scala/tastyquery/jdk/ClasspathLoaders.scala

@@ -21,7 +21,7 @@ object ClasspathLoaders {
     case Tasty extends FileKind("tasty")
 
     def appliesTo(path: Path): Boolean =
-      path.getFileName().nn.toString().nn.endsWith("." + ext)
+      path.getFileName().nn.toString().endsWith("." + ext)
   end FileKind
 
   private object FileKind:

tasty-query/jvm/src/test/scala/tastyquery/testutil/jdk/JavaTestPlatform.scala

@@ -27,7 +27,7 @@ object JavaTestPlatform {
     ClasspathLoaders.read(classpathPaths)
 
   lazy val scala3ClasspathIndex: Int =
-    classpathEntries.indexWhere(_.contains("scala3-library_3").nn)
+    classpathEntries.indexWhere(_.contains("scala-library-3"))
 
   def loadClasspath(): Future[Classpath] =
     Future(classpath)

tasty-query/shared/src/main/scala/tastyquery/Definitions.scala

@@ -32,6 +32,7 @@ final class Definitions private[tastyquery] (
   private val javaPackage = RootPackage.getPackageDeclOrCreate(nme.javaPackageName)
   val javaLangPackage = javaPackage.getPackageDeclOrCreate(nme.langPackageName)
   private[tastyquery] val javaLangInvokePackage = javaLangPackage.getPackageDeclOrCreate(termName("invoke"))
+  private val capsPackage = scalaPackage.getPackageDeclOrCreate(termName("caps"))
 
   private val scalaAnnotationPackage =
     scalaPackage.getPackageDeclOrCreate(termName("annotation"))
@@ -419,9 +420,37 @@ final class Definitions private[tastyquery] (
     cls
   end createContextFunctionNClass
 
+  /** Creates one of the `ImpureXYZFunctionN` classes.
+    *
+    * Despite capture checking being highly experimental, we find references to
+    * these type aliases in stable TASTy, so we have to define them.
+    *
+    * They are of the form:
+    *
+    * ```scala
+    * type ImpureXYZFunctionN[-T0,...,-T{N-1}, +R] = XYZFunctionN[T0,...,T{N-1}, R]^{any}
+    * ```
+    *
+    * although of course we don't introduce the `^{any}` part of it.
+    */
+  private def createImpureFunctionTypeAlias(targetClassName: TypeName, n: Int): TypeSymbol =
+    val name = typeName("Impure" + targetClassName.toString())
+    val targetClassRef = TypeRef(scalaPackage.packageRef, targetClassName)
+    val alias = TypeLambda(List.tabulate(n)(i => typeName("T$i")) :+ typeName("R"))(
+      paramInfosExp = tl => List.fill(n + 1)(NothingAnyBounds),
+      resultTypeExp = tl => AppliedType(targetClassRef, tl.paramRefs)
+    )
+    createSpecialTypeAlias(name, scalaPackage, EmptyFlagSet, alias)
+  end createImpureFunctionTypeAlias
+
   locally {
     for (n <- 0 to 22)
       createContextFunctionNClass(n)
+
+    for (n <- 0 to 22) {
+      createImpureFunctionTypeAlias(typeName(s"Function$n"), n)
+      createImpureFunctionTypeAlias(typeName(s"ContextFunction$n"), n)
+    }
   }
 
   // Derived symbols, found on the classpath
@@ -469,6 +498,8 @@ final class Definitions private[tastyquery] (
 
   lazy val ProductClass = scalaPackage.requiredClass("Product")
 
+  lazy val PureClass = capsPackage.requiredClass("Pure")
+
   lazy val ErasedNothingClass = scalaRuntimePackage.requiredClass("Nothing$")
   lazy val ErasedBoxedUnitClass = scalaRuntimePackage.requiredClass("BoxedUnit")
 

tasty-query/shared/src/main/scala/tastyquery/Erasure.scala

@@ -95,14 +95,23 @@ private[tastyquery] object Erasure:
           finishErase(preErase(tpe.first, keepUnit = false)),
           finishErase(preErase(tpe.second, keepUnit = false))
         )
+
       case tpe: AndType =>
-        summon[SourceLanguage] match
-          case SourceLanguage.Java =>
-            preErase(tpe.first, keepUnit = false)
-          case SourceLanguage.Scala2 =>
-            preErase(Scala2Erasure.eraseAndType(tpe), keepUnit = false)
-          case SourceLanguage.Scala3 =>
-            erasedGlb(preErase(tpe.first, keepUnit = false), preErase(tpe.second, keepUnit = false))
+        /* When erasing something that is `A & Pure` or `Pure & A`, we should take the erasure of A.
+         * This also work for [T <: Pure] `T & A` or `A & T`.
+         * The root problem is described here: https://github.com/scala/scala3/issues/24113
+         */
+        if tpe.first.dealias.classSymbol.contains(defn.PureClass) then preErase(tpe.second, keepUnit)
+        else if tpe.second.dealias.classSymbol.contains(defn.PureClass) then preErase(tpe.first, keepUnit)
+        else
+          summon[SourceLanguage] match
+            case SourceLanguage.Java =>
+              preErase(tpe.first, keepUnit = false)
+            case SourceLanguage.Scala2 =>
+              preErase(Scala2Erasure.eraseAndType(tpe), keepUnit = false)
+            case SourceLanguage.Scala3 =>
+              erasedGlb(preErase(tpe.first, keepUnit = false), preErase(tpe.second, keepUnit = false))
+
       case tpe: AnnotatedType =>
         preErase(tpe.typ, keepUnit)
       case tpe @ defn.PolyFunctionType(mt) =>

tasty-query/shared/src/main/scala/tastyquery/TypeOps.scala

@@ -65,7 +65,7 @@ private[tastyquery] object TypeOps:
                 toPrefix(pre.select(nme.PACKAGE), cls, thiscls)*/
                 else
                   pre.baseType(cls).flatMap(_.normalizedPrefix) match
-                    case Some(normalizedPrefix) => toPrefix(origTp, normalizedPrefix, cls.owner.nn, thiscls)
+                    case Some(normalizedPrefix) => toPrefix(origTp, normalizedPrefix, cls.owner, thiscls)
                     case None                   => origTp
               case _ =>
                 throw AssertionError(

tasty-query/shared/src/main/scala/tastyquery/Types.scala

@@ -1711,11 +1711,11 @@ object Types {
 
     def paramTypes: List[Type] =
       if !initialized then throw CyclicReferenceException(s"method [$paramNames]=>???")
-      myParamTypes.nn
+      myParamTypes
 
     def resultType: TypeOrMethodic =
       if !initialized then throw CyclicReferenceException(s"method [$paramNames]=>???")
-      myRes.nn
+      myRes
 
     private[tastyquery] def isResultDependent(using Context): Boolean =
       // TODO This should be made more efficient; we only need to traverse the type, not transform it
@@ -1830,11 +1830,11 @@ object Types {
 
     def paramTypeBounds: List[TypeBounds] =
       if !initialized then throw CyclicReferenceException(s"polymorphic method [$paramNames]=>???")
-      myBounds.nn
+      myBounds
 
     def resultType: TypeOrMethodic =
       if !initialized then throw CyclicReferenceException(s"polymorphic method [$paramNames]=>???")
-      myRes.nn
+      myRes
 
     def companion: LambdaTypeCompanion[TypeName, TypeBounds, TypeOrMethodic, PolyType] =
       PolyType
@@ -1937,11 +1937,11 @@ object Types {
 
     def paramTypeBounds: List[TypeBounds] =
       if !initialized then throw CyclicReferenceException(s"type lambda [$paramNames]=>???")
-      myBounds.nn
+      myBounds
 
     def resultType: Type =
       if !initialized then throw CyclicReferenceException(s"type lambda [$paramNames]=>???")
-      myRes.nn
+      myRes
 
     private[tastyquery] lazy val typeLambdaParams: List[TypeLambdaParam] =
       List.tabulate(paramNames.size)(num => TypeLambdaParam(this, num))
@@ -2194,15 +2194,15 @@ object Types {
 
     def paramTypeBounds: List[TypeBounds] =
       if !initialized then throw CyclicReferenceException(s"match [$paramNames]=>???")
-      myParamTypeBounds.nn
+      myParamTypeBounds
 
     def pattern: Type =
       if !initialized then throw CyclicReferenceException(s"match [$paramNames]=>???")
-      myPattern.nn
+      myPattern
 
     def result: Type =
       if !initialized then throw CyclicReferenceException(s"match [$paramNames]=>???")
-      myResult.nn
+      myResult
 
     /** The type `[params := this.paramRefs] tp`. */
     private def integrate(params: List[Symbol], tp: Type): Type =

tasty-query/shared/src/main/scala/tastyquery/reader/pickles/PickleReader.scala

@@ -243,7 +243,7 @@ private[pickles] class PickleReader {
               case Scala2Constructor | Scala2TraitConstructor =>
                 nme.Constructor
               case SimpleName(MangledDefaultGetterNameRegex(underlyingStr, indexStr)) =>
-                DefaultGetterName(termName(underlyingStr), indexStr.toInt - 1)
+                DefaultGetterName(termName(underlyingStr.nn), indexStr.nn.toInt - 1)
               case _ =>
                 name2
           else name2

tasty-query/shared/src/main/scala/tastyquery/reader/tasties/TastyFormat.scala

@@ -296,7 +296,7 @@ private[tasties] object TastyFormat:
     * compatibility, but remains backwards compatible, with all
     * preceeding `MinorVersion`.
     */
-  final val MinorVersion: Int = 7
+  final val MinorVersion: Int = 8
 
   /** Natural Number. The `ExperimentalVersion` allows for
     * experimentation with changes to TASTy without committing