Delay roll-out of new prioritization scheme:

Now:

  3.5: old scheme but warn if there are changes in the future
  3.6-migration: new scheme, warn if prioritization has changed
  3.6: new scheme, no warning

Author: odersky

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

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

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

@@ -1795,7 +1795,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.4, the behavior is as follows: `T <:p U` iff there is an impliit conversion
+     *   - In Scala 3.0-3.5, the behavior is as follows: `T <:p U` iff there is an impliit conversion
      *     from `T` to `U`, or
      *
      *        flip(T) <: flip(U)
@@ -1810,15 +1810,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.5, `T <:p U` means `T <: U` or `T` convertible to `U`
+     *   - From Scala 3.6, `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.
      *     If one of the alternatives is a given and the other is an implicit, the given wins.
      *
-     *   - In Scala 3.5-migration, use the 3.5 scheme normally, and the 3.4 scheme if
-     *     `Mode.OldImplicitResolution` is on. This is used to highlight differences in the
-     *     two resolution schemes.
+     *   - 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.
      *
      *  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.
@@ -1844,8 +1843,8 @@ trait Applications extends Compatibility {
             || !alt1isGiven && !alt2isGiven
         then
           // Intermediate rules: better means specialize, but map all type arguments downwards
-          // These are enabled for 3.0-3.4, and for all comparisons between old-style implicits,
-          // and in 3.5-migration when we compare with previous rules.
+          // These are enabled for 3.0-3.5, and for all comparisons between old-style implicits,
+          // and in 3.5 amd 3.6-migration when we compare with previous rules.
           val flip = new TypeMap:
             def apply(t: Type) = t match
               case t @ AppliedType(tycon, args) =>

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

@@ -1293,25 +1293,43 @@ trait Implicits:
        *  @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,
+       *                  return old result with preferGeneral = false
+       *   3.6-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
+       *
        */
       def compareAlternatives(alt1: RefAndLevel, alt2: RefAndLevel): Int =
         def comp(using Context) = explore(compare(alt1.ref, alt2.ref, preferGeneral = true))
         if alt1.ref eq alt2.ref then 0
         else if alt1.level != alt2.level then alt1.level - alt2.level
         else
-          val cmp = comp(using searchContext())
-          if Feature.sourceVersion == SourceVersion.`3.5-migration` then
+          var cmp = comp(using searchContext())
+          val sv = Feature.sourceVersion
+          if sv == SourceVersion.`3.5` || sv == SourceVersion.`3.6-migration` then
             val prev = comp(using searchContext().addMode(Mode.OldImplicitResolution))
             if cmp != prev then
               def choice(c: Int) = c match
                 case -1 => "the second alternative"
                 case  1 => "the first alternative"
                 case _  => "none - it's ambiguous"
-              report.warning(
-                em"""Change in given search preference for $pt between alternatives ${alt1.ref} and ${alt2.ref}
-                    |Previous choice: ${choice(prev)}
-                    |New choice     : ${choice(cmp)}""", srcPos)
-          cmp
+              if sv == SourceVersion.`3.5` then
+                report.warning(
+                  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)}""", srcPos)
+                prev
+              else
+                report.warning(
+                  em"""Change in given search preference for $pt between alternatives ${alt1.ref} and ${alt2.ref}
+                      |Previous choice          : ${choice(prev)}
+                      |New choice from Scala 3.6: ${choice(cmp)}""", srcPos)
+                cmp
+            else cmp
+          else cmp
       end compareAlternatives
 
       /** If `alt1` is also a search success, try to disambiguate as follows:

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

@@ -260,6 +260,20 @@ object language:
   @compileTimeOnly("`3.5` can only be used at compile time in import statements")
   object `3.5`
 
+  /** Set source version to 3.6-migration.
+    *
+    * @see [[https://docs.scala-lang.org/scala3/guides/migration/compatibility-intro.html]]
+    */
+  @compileTimeOnly("`3.6-migration` can only be used at compile time in import statements")
+  object `3.6-migration`
+
+  /** Set source version to 3.6
+    *
+    * @see [[https://docs.scala-lang.org/scala3/guides/migration/compatibility-intro.html]]
+    */
+  @compileTimeOnly("`3.6` can only be used at compile time in import statements")
+  object `3.6`
+
   // !!! 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/i15264.scala

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

tests/run/implicit-specifity.scala

@@ -1,4 +1,4 @@
-import language.`3.5`
+import language.`3.6`
 
 case class Show[T](val i: Int)
 object Show {

tests/run/implied-priority.scala

@@ -1,6 +1,6 @@
 /* These tests show various mechanisms available for implicit prioritization.
  */
-import language.`3.5`
+import language.`3.6`
 
 class E[T](val str: String)  // The type for which we infer terms below
 

tests/warn/given-triangle.check

@@ -2,5 +2,5 @@
 16 |@main def Test = f  // warn
    |                  ^
    |                  Change in given search preference for A between alternatives (given_A : A) and (given_B : B)
-   |                  Previous choice: the second alternative
-   |                  New choice     : the first alternative
+   |                  Previous choice          : the second alternative
+   |                  New choice from Scala 3.6: the first alternative

tests/warn/given-triangle.scala

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