Delay priority change until 3.7

Warnings from 3.6, change in 3.7. This is one version later than
originally planned.

Author: odersky

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

@@ -12,6 +12,7 @@ enum SourceVersion:
   case `3.4-migration`, `3.4`
   case `3.5-migration`, `3.5`
   case `3.6-migration`, `3.6`
+  case `3.7-migration`, `3.7`
   // !!! Keep in sync with scala.runtime.stdlibPatches.language !!!
   case `future-migration`, `future`
 

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

@@ -1753,7 +1753,7 @@ trait Applications extends Compatibility {
                       // and in mode Scala3-migration when we compare with the old Scala 2 rules.
 
     case Intermediate // Intermediate rules: better means specialize, but map all type arguments downwards
-                      // These are enabled for 3.0-3.4, or if OldImplicitResolution
+                      // These are enabled for 3.0-3.5, or if OldImplicitResolution
                       // is specified, and also for all comparisons between old-style implicits,
 
     case New          // New rules: better means generalize, givens (and extensions) always beat implicits
@@ -1789,7 +1789,7 @@ trait Applications extends Compatibility {
       val oldResolution = ctx.mode.is(Mode.OldImplicitResolution)
       if !preferGeneral || Feature.migrateTo3 && oldResolution then
         CompareScheme.Old
-      else if Feature.sourceVersion.isAtMost(SourceVersion.`3.4`)
+      else if Feature.sourceVersion.isAtMost(SourceVersion.`3.5`)
         || oldResolution
         || alt1.symbol.is(Implicit) && alt2.symbol.is(Implicit)
       then CompareScheme.Intermediate
@@ -1855,7 +1855,7 @@ trait Applications extends Compatibility {
      *     available in 3.0-migration if mode `Mode.OldImplicitResolution` is turned on as well.
      *     It is used to highlight differences between Scala 2 and 3 behavior.
      *
-     *   - In Scala 3.0-3.5, the behavior is as follows: `T <:p U` iff there is an impliit conversion
+     *   - In Scala 3.0-3.6, the behavior is as follows: `T <:p U` iff there is an implicit conversion
      *     from `T` to `U`, or
      *
      *        flip(T) <: flip(U)
@@ -1870,14 +1870,14 @@ trait Applications extends Compatibility {
      *     of parameters are not affected. So `T <: U` would imply `Set[Cmp[U]] <:p Set[Cmp[T]]`,
      *     as usual, because `Set` is non-variant.
      *
-     *   - From Scala 3.6, `T <:p U` means `T <: U` or `T` convertible to `U`
+     *   - From Scala 3.7, `T <:p U` means `T <: U` or `T` convertible to `U`
      *     for overloading resolution (when `preferGeneral is false), and the opposite relation
      *     `U <: T` or `U convertible to `T` for implicit disambiguation between givens
-     *     (when `preferGeneral` is true). For old-style implicit values, the 3.4 behavior is kept.
+     *     (when `preferGeneral` is true). For old-style implicit values, the 3.5 behavior is kept.
      *     If one of the alternatives is an implicit and the other is a given (or an extension), the implicit loses.
      *
-     *   - In Scala 3.5 and Scala 3.6-migration, we issue a warning if the result under
-     *     Scala 3.6 differ wrt to the old behavior up to 3.5.
+     *   - In Scala 3.6 and Scala 3.7-migration, we issue a warning if the result under
+     *     Scala 3.7 differs wrt to the old behavior up to 3.6.
      *
      *  Also and only for given resolution: If a compared type refers to a given or its module class, use
      *  the intersection of its parent classes instead.

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

@@ -1305,26 +1305,26 @@ trait Implicits:
     /** Search a list of eligible implicit references */
     private def searchImplicit(eligible: List[Candidate], contextual: Boolean): SearchResult =
 
-      // A map that associates a priority change warning (between -source 3.4 and 3.6)
+      // A map that associates a priority change warning (between -source 3.6 and 3.7)
       // with the candidate refs mentioned in the warning. We report the associated
       // message if one of the critical candidates is part of the result of the implicit search.
       val priorityChangeWarnings = mutable.ListBuffer[(/*critical:*/ List[TermRef], Message)]()
 
       def isWarnPriorityChangeVersion(sv: SourceVersion): Boolean =
-        sv.stable == SourceVersion.`3.5` || sv == SourceVersion.`3.6-migration`
+        sv.stable == SourceVersion.`3.6` || sv == SourceVersion.`3.7-migration`
 
       /** Compare `alt1` with `alt2` to determine which one should be chosen.
        *
        *  @return  a number > 0   if `alt1` is preferred over `alt2`
        *           a number < 0   if `alt2` is preferred over `alt1`
        *           0              if neither alternative is preferred over the other
        *  The behavior depends on the source version
-       *      before 3.5: compare with preferGeneral = false
-       *             3.5: compare twice with preferGeneral = false and true, warning if result is different,
+       *      before 3.6: compare with preferGeneral = false
+       *             3.6: compare twice with preferGeneral = false and true, warning if result is different,
        *                  return old result with preferGeneral = false
-       *   3.6-migration: compare twice with preferGeneral = false and true, warning if result is different,
+       *   3.7-migration: compare twice with preferGeneral = false and true, warning if result is different,
        *                  return new result with preferGeneral = true
-       *  3.6 and higher: compare with preferGeneral = true
+       *  3.7 and higher: compare with preferGeneral = true
        *
        *  @param disambiguate      The call is used to disambiguate two successes, not for ranking.
        *                           When ranking, we are always filtering out either > 0 or <= 0 results.
@@ -1348,15 +1348,15 @@ trait Implicits:
                 case -1 => "the second alternative"
                 case  1 => "the first alternative"
                 case _  => "none - it's ambiguous"
-              if sv.stable == SourceVersion.`3.5` then
+              if sv.stable == SourceVersion.`3.6` then
                 warn(
                   em"""Given search preference for $pt between alternatives
                       |  ${alt1.ref}
                       |and
                       |  ${alt2.ref}
                       |will change.
                       |Current choice           : ${choice(prev)}
-                      |New choice from Scala 3.6: ${choice(cmp)}""")
+                      |New choice from Scala 3.7: ${choice(cmp)}""")
                 prev
               else
                 warn(
@@ -1366,7 +1366,7 @@ trait Implicits:
                       |  ${alt2.ref}
                       |has changed.
                       |Previous choice          : ${choice(prev)}
-                      |New choice from Scala 3.6: ${choice(cmp)}""")
+                      |New choice from Scala 3.7: ${choice(cmp)}""")
                 cmp
             else cmp max prev
               // When ranking, we keep the better of cmp and prev, which ends up retaining a candidate

library/src/scala/runtime/stdLibPatches/language.scala

@@ -300,6 +300,21 @@ object language:
   @compileTimeOnly("`3.6` can only be used at compile time in import statements")
   object `3.6`
 
+  /** Set source version to 3.7-migration.
+    *
+    * @see [[https://docs.scala-lang.org/scala3/guides/migration/compatibility-intro.html]]
+    */
+  @compileTimeOnly("`3.7-migration` can only be used at compile time in import statements")
+  object `3.7-migration`
+
+  /** Set source version to 3.7
+    *
+    * @see [[https://docs.scala-lang.org/scala3/guides/migration/compatibility-intro.html]]
+    */
+  @compileTimeOnly("`3.7` can only be used at compile time in import statements")
+  object `3.7`
+
+
   // !!! Keep in sync with dotty.tools.dotc.config.SourceVersion !!!
   // Also add tests in `tests/pos/source-import-3-x.scala` and `tests/pos/source-import-3-x-migration.scala`
 

tests/neg/given-triangle.check

@@ -9,4 +9,4 @@
    |  (given_B : B)
    |will change.
    |Current choice           : the second alternative
-   |New choice from Scala 3.6: the first alternative
+   |New choice from Scala 3.7: the first alternative

tests/neg/given-triangle.scala

@@ -1,4 +1,4 @@
-//> using options -source 3.5
+//> using options -source 3.6
 class A
 class B extends A
 class C extends A

tests/neg/i15264.scala

@@ -1,4 +1,4 @@
-import language.`3.6`
+import language.`3.7`
 object priority:
     // lower number = higher priority
     class Prio0 extends Prio1

tests/neg/i21212.check

@@ -1,4 +1,4 @@
--- [E172] Type Error: tests/neg/i21212.scala:8:52 ----------------------------------------------------------------------
-8 |  def test2(using a2: A)(implicit b2: B) = summon[A] // error: ambiguous
+-- [E172] Type Error: tests/neg/i21212.scala:9:52 ----------------------------------------------------------------------
+9 |  def test2(using a2: A)(implicit b2: B) = summon[A] // error: ambiguous
   |                                                    ^
   |Ambiguous given instances: both parameter b2 and parameter a2 match type Minimization.A of parameter x of method summon in object Predef

tests/neg/i21212.scala

@@ -1,4 +1,5 @@
-//> using options -source:3.6
+//> using options -source 3.7
+
 object Minimization:
 
   trait A

tests/neg/i21303/Test.scala

@@ -1,4 +1,4 @@
-//> using options -source 3.6-migration
+//> using options -source 3.7-migration
 import scala.deriving.Mirror
 import scala.compiletime.*
 import scala.reflect.ClassTag