Only apply the restriction to given searches of value types

Author: odersky

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

@@ -1582,6 +1582,7 @@ trait Implicits:
             else candSucceedsGiven(sym.owner)
 
           ctx.isTyper
+          && pt.isValueType
           && !candSym.isOneOf(TermParamOrAccessor | Synthetic)
           && candSym.span.exists
           && candSucceedsGiven(ctx.owner)
@@ -1592,12 +1593,13 @@ trait Implicits:
         def checkResolutionChange(result: SearchResult) = result match
           case result: SearchSuccess
           if (eligible ne preEligible) && !sourceVersion.isAtLeast(SourceVersion.`future`) =>
+            val newSym = result.ref.symbol
             searchImplicit(preEligible.diff(eligible), contextual) match
-              case prevResult: SearchSuccess =>
+              case prevResult: SearchSuccess if prevResult.ref.symbol != newSym =>
                 report.error(
                   em"""Warning: result of implicit search for $pt will change.
-                      |current result: ${prevResult.ref.symbol.showLocated}
-                      |result with -source future: ${result.ref.symbol.showLocated}""",
+                      |Current result: ${prevResult.ref.symbol.showLocated}
+                      |Result with -source future: ${newSym.showLocated}""",
                   srcPos
                 )
               case _ =>

tests/neg/i15474.check

@@ -1,6 +1,6 @@
--- Error: tests/neg/i15474.scala:16:56 ---------------------------------------------------------------------------------
-16 |    given Ordering[Price] = summon[Ordering[BigDecimal]] // error
-   |                                                        ^
-   |                                        Warning: result of implicit search for Ordering[BigDecimal] will change.
-   |                                        current result: given instance given_Ordering_Price in object Price
-   |                                        result with -source future: object BigDecimal in object Ordering
+-- Error: tests/neg/i15474.scala:7:56 ----------------------------------------------------------------------------------
+7 |    given Ordering[Price] = summon[Ordering[BigDecimal]] // error
+  |                                                        ^
+  |                                          Warning: result of implicit search for Ordering[BigDecimal] will change.
+  |                                          Current result: given instance given_Ordering_Price in object Price
+  |                                          Result with -source future: object BigDecimal in object Ordering

tests/neg/i15474.scala

@@ -1,14 +1,5 @@
 //> using options -Xfatal-warnings
 
-import scala.language.implicitConversions
-
-object Test1:
-  given c: Conversion[ String, Int ] with
-    def apply(from: String): Int = from.toInt   // was error, now avoided
-
-object Test2:
-  given c: Conversion[ String, Int ] = _.toInt   // now avoided, was loop not detected, could be used as a fallback to avoid the warning.
-
 object Prices {
   opaque type Price = BigDecimal
 

tests/neg/i15474b.check

@@ -0,0 +1,5 @@
+-- Error: tests/neg/i15474b.scala:7:40 ---------------------------------------------------------------------------------
+7 |    def apply(from: String): Int = from.toInt   // error
+  |                                   ^^^^^^^^^^
+  |                                   Infinite loop in function body
+  |                                   Test1.c.apply(from).toInt

tests/neg/i15474b.scala

@@ -0,0 +1,11 @@
+//> using options -Xfatal-warnings
+
+import scala.language.implicitConversions
+
+object Test1:
+  given c: Conversion[ String, Int ] with
+    def apply(from: String): Int = from.toInt   // error
+
+object Test2:
+  given c: Conversion[ String, Int ] = _.toInt   // loop not detected, could be used as a fallback to avoid the warning.
+

tests/neg/i6716.check

@@ -2,5 +2,5 @@
 12 |  given Monad[Bar] = summon[Monad[Foo]] // error
    |                                       ^
    |                                       Warning: result of implicit search for Monad[Foo] will change.
-   |                                       current result: given instance given_Monad_Bar in object Bar
-   |                                       result with -source future: object given_Monad_Foo in object Foo
+   |                                       Current result: given instance given_Monad_Bar in object Bar
+   |                                       Result with -source future: object given_Monad_Foo in object Foo

tests/pos/i15474.scala

@@ -1,14 +1,8 @@
 //> using options -Xfatal-warnings
+
 import scala.language.implicitConversions
 import language.future
 
-object Test1:
-  given c: Conversion[ String, Int ] with
-    def apply(from: String): Int = from.toInt   // was error, now avoided
-
-object Test2:
-  given c: Conversion[ String, Int ] = _.toInt   // now avoided, was loop not detected, could be used as a fallback to avoid the warning.
-
 object Prices {
   opaque type Price = BigDecimal