Add since annotations to all symbols added in 3.1

Author: Kordyjan

library/src/scala/CanEqual.scala

@@ -1,6 +1,6 @@
 package scala
 
-import annotation.implicitNotFound
+import annotation.{ implicitNotFound, since }
 import scala.collection.{Seq, Set}
 
 /** A marker trait indicating that values of type `L` can be compared to values of type `R`. */
@@ -29,14 +29,18 @@ object CanEqual {
   // The next 6 definitions can go into the companion objects of their corresponding
   // classes. For now they are here in order not to have to touch the
   // source code of these classes
+  @since("3.1")
   given canEqualSeqs[T, U](using eq: CanEqual[T, U]): CanEqual[Seq[T], Seq[U]] = derived
   given canEqualSeq[T](using eq: CanEqual[T, T]): CanEqual[Seq[T], Seq[T]] = derived // for `case Nil` in pattern matching
 
   given canEqualSet[T, U](using eq: CanEqual[T, U]): CanEqual[Set[T], Set[U]] = derived
 
+  @since("3.1")
   given canEqualOptions[T, U](using eq: CanEqual[T, U]): CanEqual[Option[T], Option[U]] = derived
+  @since("3.1")
   given canEqualOption[T](using eq: CanEqual[T, T]): CanEqual[Option[T], Option[T]] = derived // for `case None` in pattern matching
 
+  @since("3.1")
   given canEqualEither[L1, R1, L2, R2](
     using eqL: CanEqual[L1, L2], eqR: CanEqual[R1, R2]
   ): CanEqual[Either[L1, R1], Either[L2, R2]] = derived

library/src/scala/Selectable.scala

@@ -1,6 +1,6 @@
 package scala
 
-import scala.annotation.experimental
+import scala.annotation.since
 
 /** A marker trait for objects that support structural selection via
  *  `selectDynamic` and `applyDynamic`
@@ -49,5 +49,6 @@ object Selectable:
    *  the additional restriction that the signatures of the refinement and
    *  the definition that implements the refinment must match.
    */
+  @since("3.1")
   trait WithoutPreciseParameterTypes extends Selectable
 end Selectable

library/src/scala/Tuple.scala

@@ -1,6 +1,6 @@
 package scala
 
-import annotation.{experimental, showAsInfix}
+import annotation.{experimental, showAsInfix, since}
 import compiletime._
 import compiletime.ops.int._
 
@@ -260,7 +260,9 @@ object Tuple {
   def fromProductTyped[P <: Product](p: P)(using m: scala.deriving.Mirror.ProductOf[P]): m.MirroredElemTypes =
     runtime.Tuples.fromProduct(p).asInstanceOf[m.MirroredElemTypes]
 
+  @since("3.1")
   given canEqualEmptyTuple: CanEqual[EmptyTuple, EmptyTuple] = CanEqual.derived
+  @since("3.1")
   given canEqualTuple[H1, T1 <: Tuple, H2, T2 <: Tuple](
     using eqHead: CanEqual[H1, H2], eqTail: CanEqual[T1, T2]
   ): CanEqual[H1 *: T1, H2 *: T2] = CanEqual.derived

library/src/scala/annotation/experimental.scala

@@ -5,4 +5,5 @@ package scala.annotation
  *  @see [[https://dotty.epfl.ch/docs/reference/other-new-features/experimental-defs]]
  *  @syntax markdown
  */
+@since("3.1")
 class experimental extends StaticAnnotation

library/src/scala/annotation/internal/ErasedParam.scala

@@ -2,4 +2,5 @@ package scala.annotation
 package internal
 
 /** An annotation produced by Namer to indicate an erased parameter */
+@since("3.1")
 final class ErasedParam() extends Annotation

library/src/scala/annotation/internal/ProvisionalSuperClass.scala

@@ -2,5 +2,6 @@ package scala.annotation
 package internal
 
 /** An annotation to record a provisional super class */
+@since("3.1")
 class ProvisionalSuperClass extends StaticAnnotation
 

library/src/scala/quoted/Quotes.scala

@@ -68,6 +68,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
      *  Emits an error and aborts if the expression does not represent a value or possibly contains side effects.
      *  Otherwise returns the value.
      */
+    @since("3.1")
     def valueOrAbort(using FromExpr[T]): T
 
   end extension
@@ -794,15 +795,18 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     end IdentMethods
 
     /** Pattern representing a `_` wildcard. */
+    @since("3.1")
     type Wildcard <: Ident
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `Wildcard` */
+    @since("3.1")
     given WildcardTypeTest: TypeTest[Tree, Wildcard]
 
     /** Module object of `type Wildcard`  */
     val Wildcard: WildcardModule
 
     /** Methods of the module object `val Wildcard` */
+    @since("3.1")
     trait WildcardModule { this: Wildcard.type =>
       /** Create a tree representing a `_` wildcard. */
       def apply(): Wildcard
@@ -1605,15 +1609,19 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     end WhileMethods
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `TypedOrTest` */
+    @since("3.1")
     given TypedOrTestTypeTest: TypeTest[Tree, TypedOrTest]
 
     /** Tree representing a type ascription or type test pattern `x: T` in the source code. */
+    @since("3.1")
     type TypedOrTest <: Tree
 
     /** Module object of `type TypedOrTest`  */
+    @since("3.1")
     val TypedOrTest: TypedOrTestModule
 
     /** Methods of the module object `val TypedOrTest` */
+    @since("3.1")
     trait TypedOrTestModule { this: TypedOrTest.type =>
 
       /** Create a type ascription `<x: Tree>: <tpt: TypeTree>` */
@@ -1626,9 +1634,11 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `TypedOrTest` available without any imports */
+    @since("3.1")
     given TypedOrTestMethods: TypedOrTestMethods
 
     /** Extension methods of `TypedOrTest` */
+    @since("3.1")
     trait TypedOrTestMethods:
       extension (self: TypedOrTest)
         def tree: Tree
@@ -2156,6 +2166,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     /** Methods of the module object `val Unapply` */
     trait UnapplyModule { this: Unapply.type =>
       /** Create an `Unapply` tree representing a pattern `<fun>(<patterns*>)(using <implicits*>)` */
+      @since("3.1")
       def apply(fun: Term, implicits: List[Term], patterns: List[Tree]): Unapply
       /** Copy an `Unapply` tree representing a pattern `<fun>(<patterns*>)(using <implicits*>)` */
       def copy(original: Tree)(fun: Term, implicits: List[Term], patterns: List[Tree]): Unapply
@@ -2269,6 +2280,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
         /** Is this a given parameter clause `(using X1, ..., Xn)` or `(using x1: X1, ..., xn: Xn)` */
         def isGiven: Boolean
         /** Is this a erased parameter clause `(erased x1: X1, ..., xn: Xn)` */
+        @since("3.1")
         def isErased: Boolean
     end TermParamClauseMethods
 
@@ -2554,6 +2566,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
          *
          * @return true if the dealiased type of `self` is `TupleN[T1, T2, ..., Tn]`
          */
+        @since("3.1")
         def isTupleN: Boolean
 
         /** The type <this . sym>, reduced if possible */
@@ -3703,6 +3716,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
         def memberFields: List[Symbol]
 
         /** Get all non-private fields declared or inherited */
+        @since("3.1")
         def fieldMembers: List[Symbol]
 
         /** Get non-private named methods defined directly inside the class */

library/src/scala/quoted/Type.scala

@@ -1,6 +1,6 @@
 package scala.quoted
 
-import scala.annotation.{compileTimeOnly, experimental}
+import scala.annotation.{compileTimeOnly, experimental, since}
 
 /** Type (or type constructor) `T` needed contextually when using `T` in a quoted expression `'{... T ...}` */
 abstract class Type[T <: AnyKind] private[scala]:
@@ -68,6 +68,7 @@ object Type:
    *  ```
    *  @syntax markdown
    */
+  @since("3.1")
   def valueOfTuple[T <: Tuple](using Type[T])(using Quotes): Option[T] =
     valueOfTuple(quotes.reflect.TypeRepr.of[T]).asInstanceOf[Option[T]]