Alternative approach to PolyFunction apply erasure

The previous approach did not handle situations where the qualifier was
not directly an AndType, but a type whose underlying type is an
AndType like in example2 and example3 (this commit also minimizes the original
example further).

Author: smarter

compiler/src/dotty/tools/dotc/core/TypeErasure.scala

@@ -524,6 +524,15 @@ object TypeErasure {
     case tp: OrType  => hasStableErasure(tp.tp1) && hasStableErasure(tp.tp2)
     case _ => false
   }
+
+  /** The erasure of `PolyFunction { def apply: $applyInfo }` */
+  def erasePolyFunctionApply(applyInfo: Type)(using Context): Type =
+    assert(applyInfo.isInstanceOf[PolyType])
+    val res = applyInfo.resultType
+    val paramss = res.paramNamess
+    assert(paramss.length == 1)
+    erasure(defn.FunctionType(paramss.head.length,
+      isContextual = res.isImplicitMethod, isErased = res.isErasedMethod))
 }
 
 import TypeErasure._
@@ -597,11 +606,7 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
     case ExprType(rt) =>
       defn.FunctionType(0)
     case RefinedType(parent, nme.apply, refinedInfo) if parent.typeSymbol eq defn.PolyFunctionClass =>
-      assert(refinedInfo.isInstanceOf[PolyType])
-      val res = refinedInfo.resultType
-      val paramss = res.paramNamess
-      assert(paramss.length == 1)
-      this(defn.FunctionType(paramss.head.length, isContextual = res.isImplicitMethod, isErased = res.isErasedMethod))
+      erasePolyFunctionApply(refinedInfo)
     case tp: TypeProxy =>
       this(tp.underlying)
     case tp @ AndType(tp1, tp2) =>

compiler/src/dotty/tools/dotc/transform/Erasure.scala

@@ -668,18 +668,16 @@ object Erasure {
         if !sym.exists && tree.name == nme.apply then
           // PolyFunction apply Selects will not have a symbol, so deduce the owner
           // from the typed tree of the erasure of the original qualifier's PolyFunction type.
-          // Need to sidestep information loss in the erasure of AndTypes, see pos/i13950.scala.
-          val polyFunctionQualType = inContext(preErasureCtx) {
-            def narrowToPolyFun(tp: Type)(using Context): Type =
-              if tp.derivesFrom(defn.PolyFunctionClass) then
-                tp match
-                  case AndType(tp1, tp2) => narrowToPolyFun(tp1).orElse(narrowToPolyFun(tp2))
-                  case _ => tp
-              else NoType
-            narrowToPolyFun(tree.qualifier.typeOpt.widen)
+          // We cannot simply call `erasure` on the qualifier because its erasure might be
+          // `Object` due to how we erase intersections (see pos/i13950.scala).
+          // Instead, we manually lookup the type of `apply` in the qualifier.
+          inContext(preErasureCtx) {
+            val qualTp = tree.qualifier.typeOpt.widen
+            if qualTp.derivesFrom(defn.PolyFunctionClass) then
+              erasePolyFunctionApply(qualTp.select(nme.apply).widen).classSymbol
+            else
+              NoSymbol
           }
-          val owner = erasure(polyFunctionQualType).typeSymbol
-          if defn.isFunctionClass(owner) then owner else NoSymbol
         else
           val owner = sym.maybeOwner
           if defn.specialErasure.contains(owner) then

tests/pos/i13950.scala

@@ -0,0 +1,11 @@
+def example(x: Any & ([V] => V => Int)) =
+  x[Int](1)
+def example2(x: (Any & ([V] => V => Int)) @unchecked) =
+  x[Int](1)
+def example3[S <: Any & ([V] => V => Int)](x: S) =
+  x[Int](1)
+
+@main def Test =
+  example([A] => (x: A) => 1)
+  example2([A] => (x: A) => 1)
+  example3([A] => (x: A) => 1)