Avoid embedding SelectionProtos in Conversions

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

@@ -1122,17 +1122,29 @@ trait Implicits:
             adapt(generated, pt.widenExpr, locked)
         else {
           def untpdGenerated = untpd.TypedSplice(generated)
-          def producesConversion(info: Type): Boolean = info match
-            case info: PolyType => producesConversion(info.resType)
-            case info: MethodType if info.isImplicitMethod => producesConversion(info.resType)
-            case _ => info.derivesFrom(defn.ConversionClass)
+          def conversionResultType(info: Type): Type = info match
+            case info: PolyType => conversionResultType(info.resType)
+            case info: MethodType if info.isImplicitMethod => conversionResultType(info.resType)
+            case _ if info.derivesFrom(defn.ConversionClass) => pt match
+              case selProto: SelectionProto =>
+                info.baseType(defn.ConversionClass) match
+                  case AppliedType(_, List(_, restpe)) if selProto.isMatchedBy(restpe) =>
+                    // if we embed the SelectionProto as the Conversion result type
+                    // it might end up within a GADT cast type
+                    // so instead replace it with the targeted conversion type, if it matches
+                    // see tests/pos/i15867.scala.
+                    restpe
+                  case _ => pt
+              case _ => pt
+            case _ => NoType
           def tryConversion(using Context) = {
+            val restpeConv = if ref.symbol.is(Given) then conversionResultType(ref.widenTermRefExpr) else NoType
             val untpdConv =
-              if ref.symbol.is(Given) && producesConversion(ref.symbol.info) then
+              if restpeConv.exists then
                 untpd.Select(
                   untpd.TypedSplice(
                     adapt(generated,
-                      defn.ConversionClass.typeRef.appliedTo(argument.tpe, pt),
+                      defn.ConversionClass.typeRef.appliedTo(argument.tpe, restpeConv),
                       locked)),
                   nme.apply)
               else untpdGenerated

compiler/test/dotc/pos-test-pickling.blacklist

@@ -94,6 +94,7 @@ i4176-gadt.scala
 
 # GADT difference
 i13974a.scala
+i15867.scala
 
 java-inherited-type1
 

tests/pos/i15867.scala

@@ -0,0 +1,19 @@
+enum SUB[-A, +B]:
+  case Refl[S]() extends SUB[S, S]
+
+class Pow(self: Int):
+  def **(other: Int): Int = math.pow(self, other).toInt
+
+given fromList[T]: Conversion[List[T], Pow] = ???
+
+given fromInt: Conversion[Int, Pow] = Pow(_)
+
+def foo[T](t1: T, ev: T SUB List[Int]) =
+  ev match { case SUB.Refl() =>
+    t1 ** 2   // error
+  }
+
+def baz[T](t2: T, ev: T SUB Int) =
+  ev match { case SUB.Refl() =>
+    t2 ** 2   // works
+  }

tests/pos/i15867.specs2.scala

@@ -0,0 +1,9 @@
+class Foo:
+  given Conversion[String, Data] with
+    def apply(str: String): Data = new Data(str)
+
+  class Data(str: String):
+    def |(str: String) = new Data(this.str + str)
+
+class Bar extends Foo:
+  "str" | "ing"