Prepare test sources for Scala 3.4.0.

Avoid deprecated features, except for places where we specifically
test the shape of those deprecated features, in which case we use
`@nowarn`.

tasty-query/shared/src/test/scala/tastyquery/PositionSuite.scala

@@ -106,8 +106,8 @@ class PositionSuite extends RestrictedUnpicklingSuite {
           |    case _ => -x
           |  }""".stripMargin,
         """xs match
-          |    case List(elems: _*) => 0
-          |    case _               => 1""".stripMargin
+          |    case List(elems*) => 0
+          |    case _            => 1""".stripMargin
       )
     )
 
@@ -132,8 +132,8 @@ class PositionSuite extends RestrictedUnpicklingSuite {
         "case 3 | 4 | 5 if x < 5 => 0",
         "case _ if (x % 2 == 0) => x / 2",
         "case _ => -x",
-        "case List(elems: _*) => 0",
-        "case _               => 1"
+        "case List(elems*) => 0",
+        "case _            => 1"
       )
     )
   }

test-sources/src/main/scala/simple_trees/AccessModifiers.scala

@@ -1,5 +1,8 @@
 package simple_trees
 
+import scala.annotation.nowarn
+
+@nowarn("msg=The \\[this\\] qualifier will be deprecated")
 class AccessModifiers(
   localParam: Int,
   private[this] val privateThisParam: Int,

test-sources/src/main/scala/simple_trees/AnyMethods.scala

@@ -21,6 +21,6 @@ class AnyMethods:
   def testTypeCast(bag: Bag { val m: Int }): Any = bag.m // bag.selectDynamic("m").$asInstanceOf$[Int]
 
   def testGetClassAny(x: Any): Any = x.getClass()
-  def testGetClassProduct(x: Product): Class[_ <: Product] = x.getClass()
+  def testGetClassProduct(x: Product): Class[? <: Product] = x.getClass()
   def testGetClassInt(x: Int): Class[Int] = x.getClass() // nonsensical, but what can we do?
 end AnyMethods

test-sources/src/main/scala/simple_trees/Match.scala

@@ -11,6 +11,6 @@ class Match {
   }
 
   def g(xs: Seq[Int]): Int = xs match
-    case List(elems: _*) => 0
-    case _               => 1
+    case List(elems*) => 0
+    case _            => 1
 }

test-sources/src/main/scala/simple_trees/RecursiveMatchType.scala

@@ -7,8 +7,11 @@ type RecursiveMatchType[A <: Tuple] <: Tuple = A match
 object RecursiveMatchType:
   inline def rec[A <: Tuple](a: A): RecursiveMatchType[A] =
     inline a match
-      case b: (hd *: tl) => b.head *: rec(b.tail)
+      case b: (hd *: tl) => headOf(b) *: rec(tailOf(b))
       case _: EmptyTuple => EmptyTuple
+
+  def headOf[H, T <: Tuple](t: H *: T): H = t.head
+  def tailOf[H, T <: Tuple](t: H *: T): T = t.tail
 end RecursiveMatchType
 
 // must be in a separate TASTy file to trigger issue #401

test-sources/src/main/scala/simple_trees/RefinedTypeTree.scala

@@ -41,11 +41,11 @@ class RefinedTypeTree {
 
   def polyTypeRefinement(c: C { type Poly[X] = List[(X, X)] }) = c
 
-  // With an additional 'with'
+  // With an additional '&'
 
   trait AndTypeA
   trait AndTypeB extends AndTypeA
 
-  def andType(): AndTypeA with AndTypeB { def foo: String } =
+  def andType(): (AndTypeA & AndTypeB) { def foo: String } =
     new AndTypeA with AndTypeB { def foo: String = toString }
 }

test-sources/src/main/scala/simple_trees/TypeRefIn.scala

@@ -3,19 +3,19 @@ package simple_trees
 class TypeRefIn {
   def withArray[U](arr: Array[U]): Unit = ()
 
-  def withArrayOfSubtype[T](arr: Array[_ <: T]): Unit = withArray(arr)
+  def withArrayOfSubtype[T](arr: Array[? <: T]): Unit = withArray(arr)
 
   def withArrayAnyRef[U <: AnyRef](arr: Array[U]): Unit = ()
 
-  def withArrayOfSubtypeAnyRef[T <: AnyRef](arr: Array[_ <: T]): Unit = withArrayAnyRef(arr)
+  def withArrayOfSubtypeAnyRef[T <: AnyRef](arr: Array[? <: T]): Unit = withArrayAnyRef(arr)
 
   def withArrayAnyVal[U <: AnyVal](arr: Array[U]): Unit = ()
 
-  def withArrayOfSubtypeAnyVal[T <: AnyVal](arr: Array[_ <: T]): Unit = withArrayAnyVal(arr)
+  def withArrayOfSubtypeAnyVal[T <: AnyVal](arr: Array[? <: T]): Unit = withArrayAnyVal(arr)
 
   def withArrayList[U <: List[?]](arr: Array[U]): Unit = ()
 
-  def withArrayOfSubtypeList[T <: List[?]](arr: Array[_ <: T]): Unit = withArrayList(arr)
+  def withArrayOfSubtypeList[T <: List[?]](arr: Array[? <: T]): Unit = withArrayList(arr)
 
   def withArrayExactAny(array: Array[Any]): Unit = ()
 
@@ -25,5 +25,5 @@ class TypeRefIn {
 
   def withListOfSubtypeOfInt[T <: Int](x: List[T]): Unit = ()
 
-  def withListOfSubtypeOfSubtypeOfInt[T <: Int](x: List[_ <: T]): Unit = withListOfSubtypeOfInt(x)
+  def withListOfSubtypeOfSubtypeOfInt[T <: Int](x: List[? <: T]): Unit = withListOfSubtypeOfInt(x)
 }

test-sources/src/main/scala/simple_trees/Uninitialized.scala

@@ -1,10 +1,14 @@
 package simple_trees
 
+import scala.annotation.nowarn
+
 import scala.compiletime.uninitialized as renamedUninitialized
 
 abstract class Uninitialized:
   var uninitializedRHS: Product = scala.compiletime.uninitialized
   var renamedUninitializedRHS: String = renamedUninitialized
+
+  @nowarn("msg=uninitialized")
   var wildcardRHS: Int = _
 
   var abstractVar: Int // confidence check: an abstract var is marked Deferred

test-sources/src/main/scala/simple_trees/ValueClass.scala

@@ -1,5 +1,5 @@
 package simple_trees
 
-final class ValueClass(val it: List[_]) extends AnyVal {
+final class ValueClass(val it: List[?]) extends AnyVal {
   def myLength: Int = it.size
 }

test-sources/src/main/scala/simple_trees/WildcardTypeApplication.scala

@@ -2,4 +2,4 @@ package simple_trees
 
 class GenericWithTypeBound[T <: AnyKind]
 
-class WildcardTypeApplication(anyList: List[_]) extends GenericWithTypeBound[_]
+class WildcardTypeApplication(anyList: List[?]) extends GenericWithTypeBound[?]