Make overload pruning based on result types less aggressive

compiler/src/dotty/tools/dotc/inlines/Inlines.scala

@@ -49,7 +49,13 @@ object Inlines:
 
   /** Can a call to method `meth` be inlined? */
   def isInlineable(meth: Symbol)(using Context): Boolean =
-    meth.is(Inline) && meth.hasAnnotation(defn.BodyAnnot) && !inInlineMethod
+    meth.is(Inline)
+    && (meth.hasAnnotation(defn.BodyAnnot)
+        // Ensure `isInlineable` works with temporary symbols created during
+        // overloading resolution by `Applications#resolveMapped`.
+        // Testcase: tests/pos/i21410c.scala
+        || meth.hasAnnotation(defn.MappedAlternativeAnnot))
+    && !inInlineMethod
 
   /** Should call be inlined in this context? */
   def needsInlining(tree: Tree)(using Context): Boolean = tree match {

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

@@ -2076,16 +2076,27 @@ trait Applications extends Compatibility {
   def resolveOverloaded(alts: List[TermRef], pt: Type)(using Context): List[TermRef] =
     record("resolveOverloaded")
 
-    /** Is `alt` a method or polytype whose result type after the first value parameter
+    /** Is `alt` a method or polytype whose approximated result type after the first value parameter
      *  section conforms to the expected type `resultType`? If `resultType`
      *  is a `IgnoredProto`, pick the underlying type instead.
+     *
+     *  Using an approximated result types is necessary to avoid false negatives
+     *  due to incomplete type inference such as in tests/pos/i21410.scala and tests/pos/i21410b.scala.
      */
     def resultConforms(altSym: Symbol, altType: Type, resultType: Type)(using Context): Boolean =
       resultType.revealIgnored match {
         case resultType: ValueType =>
           altType.widen match {
-            case tp: PolyType => resultConforms(altSym, instantiateWithTypeVars(tp), resultType)
-            case tp: MethodType => constrainResult(altSym, tp.resultType, resultType)
+            case tp: PolyType => resultConforms(altSym, tp.resultType, resultType)
+            case tp: MethodType =>
+              val wildRes = wildApprox(tp.resultType)
+
+              class ResultApprox extends AvoidWildcardsMap:
+                // Avoid false negatives by approximating to a lower bound
+                variance = -1
+
+              val approx = ResultApprox()(wildRes)
+              constrainResult(altSym, approx, resultType)
             case _ => true
           }
         case _ => true

tests/pos/i21410.scala

@@ -0,0 +1,12 @@
+class A
+object Test:
+  type F[X] <: Any = X match
+    case A => Int
+
+  def foo[T](x: String): T = ???
+  def foo[U](x: U): F[U] = ???
+
+  val x1 = foo(A())
+  val y: Int = x1
+
+  val x2: Int = foo(A()) // error

tests/pos/i21410b.scala

@@ -0,0 +1,10 @@
+object Test:
+  def foo[T](x: Option[T]): T = ???
+  def foo[T <: Tuple](x: T): Tuple.Map[T, List] = ???
+
+  val tup: (Int, String) = (1, "")
+
+  val x = foo(tup)
+  val y: (List[Int], List[String]) = x
+
+  val x2: (List[Int], List[String]) = foo(tup) // error

tests/pos/i21410c.scala

@@ -0,0 +1,11 @@
+class AppliedPIso[A, B]()
+case class User(age: Int)
+
+object Test:
+  extension [From, To](from: From)
+    def focus(): AppliedPIso[From, From] = ???
+    transparent inline def focus(inline lambda: (From => To)): Any = ???
+
+
+  val u = User(1)
+  val ap: AppliedPIso[User, User] = u.focus(_.age) // error