Fix comparison of dependent function types

Dependent function types are expressed as refinements over regular function types.
These refinements need to be compared with the standard arrow rule for function
subtyping. But comparison of method refinements so far demanded equal parameter
types.

The solution is tricky since refined types lead to selections via reflection
still cannot tolerate differing parameter types since reflexive method dispatch
uses precise parameter types. That's why we apply standard arrow rule only
for refinements where the refined method exists in the underlying class.

Fixes #12211

Author: odersky

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

@@ -1698,8 +1698,6 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
    */
   protected def hasMatchingMember(name: Name, tp1: Type, tp2: RefinedType): Boolean =
     trace(i"hasMatchingMember($tp1 . $name :? ${tp2.refinedInfo}), mbr: ${tp1.member(name).info}", subtyping) {
-      val rinfo2 = tp2.refinedInfo
-
       // If the member is an abstract type and the prefix is a path, compare the member itself
       // instead of its bounds. This case is needed situations like:
       //
@@ -1725,8 +1723,28 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
         case _ => false
       }
 
+      // A relaxed version of isSubType, which compares method types
+      // under the standard arrow rule which is contravarient in the parameter types,
+      // but only if `tp2.refinedName` is also defined in the underlying class of tp2.
+      // The reason for the "but only" retriction is that if `tp2.refinedName`
+      // is not otherwise defined, we will have to resort to reflection to invoke
+      // the member. And reflection needs to know exact parameter types. The relaxation is
+      // needed to correctly compare dependent function types.
+      // See {pos,neg}/i12211.scala as test cases.
+      def isSubInfo(info1: Type, info2: Type): Boolean =
+        info2 match
+          case info2: MethodType
+          if tp2.underlyingClassRef(refinementOK = true).member(tp2.refinedName).exists =>
+            info1 match
+              case info1: MethodType =>
+                matchingMethodParams(info1, info2, precise = false)
+                && isSubInfo(info1.resultType, info2.resultType.subst(info2, info1))
+              case _ => isSubType(info1, info2)
+          case _ => isSubType(info1, info2)
+
       def qualifies(m: SingleDenotation) =
-        isSubType(m.info.widenExpr, rinfo2.widenExpr) || matchAbstractTypeMember(m.info)
+        isSubInfo(m.info.widenExpr, tp2.refinedInfo.widenExpr)
+        || matchAbstractTypeMember(m.info)
 
       tp1.member(name) match { // inlined hasAltWith for performance
         case mbr: SingleDenotation => qualifies(mbr)
@@ -1841,15 +1859,20 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
   }
 
   /** Do the parameter types of `tp1` and `tp2` match in a way that allows `tp1`
-   *  to override `tp2` ? This is the case if they're pairwise `=:=`.
+   *  to override `tp2` ? Two modes: precise or not.
+   *  If `precise` is set (which is the default) this is the case if they're pairwise `=:=`.
+   *  Otherwise parameters in `tp2` must be subtypes of corresponding parameters in `tp1`.
    */
-  def matchingMethodParams(tp1: MethodType, tp2: MethodType): Boolean = {
+  def matchingMethodParams(tp1: MethodType, tp2: MethodType, precise: Boolean = true): Boolean = {
     def loop(formals1: List[Type], formals2: List[Type]): Boolean = formals1 match {
       case formal1 :: rest1 =>
         formals2 match {
           case formal2 :: rest2 =>
             val formal2a = if (tp2.isParamDependent) formal2.subst(tp2, tp1) else formal2
-            isSameTypeWhenFrozen(formal1, formal2a) && loop(rest1, rest2)
+            val paramsMatch =
+              if precise then isSameTypeWhenFrozen(formal1, formal2a)
+              else isSubTypeWhenFrozen(formal2a, formal1)
+            paramsMatch && loop(rest1, rest2)
           case nil =>
             false
         }

tests/neg/i12211.scala

@@ -0,0 +1,9 @@
+
+import reflect.Selectable.*
+
+val x: { def f(x: Any): String } = new { def f(x: Any) = x.toString }
+val y: { def f(x: String): String } = x  // error: type mismatch (no arrow rule since `f` is not defined in parent)
+
+@main def Test =
+  println(y.f("abc"))
+

tests/pos/i12211.scala

@@ -0,0 +1,21 @@
+
+def fst0[A, B[_]](a: A)(b: B[a.type]): a.type = a
+
+def fst[A, B[_]]: (a: A) => (b: B[a.type]) => a.type =
+  (a: A) => (b: B[a.type]) => a
+
+def snd[A, B[_]]: (a: A) => () => (b: B[a.type]) => b.type =
+  (a: A) => () => (b: B[a.type]) => b
+
+def fst1[A, B[_]]: (a: A) => (b: B[a.type]) => a.type = fst0
+
+def test1[A, B[_]]: (a: A) => () => (b: B[a.type]) => Any =
+  snd[A, B]
+
+def test2[A, B[_]]: (a: A) => (b: B[a.type]) => A = fst[A, B]
+
+class AA
+class BB[T]
+
+def test3: (a: AA) => (b: BB[a.type]) => BB[?] =
+  (a: AA) => (b: BB[a.type]) => b