Tweak isSubInfo for capture checking

- Keep the shortcut for function types in compareRefined
- Temper isSubInfo logic

Author: Linyxus

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

@@ -641,6 +641,14 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
         def compareRefined: Boolean =
           val tp1w = tp1.widen
 
+          if ctx.phase == Phases.checkCapturesPhase then
+            def compareInfo(info1: Type, info2: Type): Boolean =
+              isSubInfo(info1, info2, NoType)
+            if defn.isFunctionType(tp2) then
+              tp1w.widenDealias match
+                case tp1: RefinedType => return compareInfo(tp1.refinedInfo, tp2.refinedInfo)
+                case _ =>
+
           val skipped2 = skipMatching(tp1w, tp2)
           if (skipped2 eq tp2) || !Config.fastPathForRefinedSubtype then
             if containsAnd(tp1) then
@@ -1917,6 +1925,40 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
     case _ =>
       refines.map(RefinedType(tp, _, _): Type).reduce(AndType(_, _))
 
+  // A relaxed version of isSubType, which compares method types
+  // under the standard arrow rule which is contravariant in the parameter types,
+  // but under the condition that signatures might have to match (see sigsOK)
+  // This relaxed version is needed to correctly compare dependent function types.
+  // See pos/i12211.scala.
+  def isSubInfo(info1: Type, info2: Type, symInfo1: Type, sigsOK: ((Type, Type) => Boolean) | Null = null, fallbackFn: ((Type, Type) => Boolean) | Null = null): Boolean = trace(i"isSubInfo $info1 <:< $info2"):
+    def fallback =
+      if fallbackFn != null then fallbackFn(info1, info2)
+      else isSubType(info1, info2)
+    val isCCPhase = ctx.phase == Phases.checkCapturesPhase
+
+    (info1, info2) match
+      case (info1: PolyType, info2: PolyType) if ccEnabled =>  // See TODO about `ccEnabled` in `sigsOK`, this should also go under `relaxedSubtyping`.
+        comparingTypeLambdas(info1, info2):
+          info1.paramNames.hasSameLengthAs(info2.paramNames)
+          && isSubInfo(info1.resultType, info2.resultType.subst(info2, info1), symInfo1.resultType, sigsOK, fallbackFn)
+          // Signature checks are never necessary because polymorphic
+          // refinements are only allowed for the `apply` method of a
+          // PolyFunction.
+      case (info1: MethodType, info2: MethodType) =>
+        matchingMethodParams(info1, info2, precise = false)
+        && isSubInfo(info1.resultType, info2.resultType.subst(info2, info1), symInfo1.resultType, sigsOK, fallbackFn)
+        && (if sigsOK != null then sigsOK(symInfo1, info2) else true)
+      case _ => (info1.widenDealias, info2) match
+        case (CapturingType(parent1, _), info2: Type) if isCCPhase =>
+          val refs1 = info1.captureSet
+          subCaptures(refs1, info2.captureSet, frozenConstraint).isOK && sameBoxed(info1, info2, refs1)
+            && isSubInfo(parent1, info2, symInfo1, sigsOK, fallbackFn)
+        case (info1: Type, CapturingType(parent2, refs2)) if isCCPhase =>
+          val refs1 = info1.captureSet
+          (refs1.isAlwaysEmpty || subCaptures(refs1, refs2, frozenConstraint).isOK) && sameBoxed(info1, info2, refs1)
+            && isSubInfo(info1, parent2, symInfo1, sigsOK, fallbackFn)
+        case _ => fallback
+
   /** Can comparing this type on the left lead to an either? This is the case if
    *  the type is and AndType or contains embedded occurrences of AndTypes
    */
@@ -1984,43 +2026,10 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
         || symInfo.isInstanceOf[MethodType]
             && symInfo.signature.consistentParams(info2.signature)
 
-      def tp1IsSingleton: Boolean = tp1.isInstanceOf[SingletonType]
-
-      // A relaxed version of isSubType, which compares method types
-      // under the standard arrow rule which is contravariant in the parameter types,
-      // but under the condition that signatures might have to match (see sigsOK)
-      // This relaxed version is needed to correctly compare dependent function types.
-      // See pos/i12211.scala.
-      def isSubInfo(info1: Type, info2: Type, symInfo1: Type): Boolean =
-        def fallback = inFrozenGadtIf(tp1IsSingleton) { isSubType(info1, info2) }
-        info2 match
-          case info2: PolyType if ccEnabled => // See TODO about `ccEnabled` in `sigsOK`, this should also go under `relaxedSubtyping`.
-            info1 match
-              case info1: PolyType =>
-                comparingTypeLambdas(info1, info2):
-                  info1.paramNames.hasSameLengthAs(info2.paramNames)
-                  && isSubInfo(info1.resultType, info2.resultType.subst(info2, info1), symInfo1.resultType)
-                  // Signature checks are never necessary because polymorphic
-                  // refinements are only allowed for the `apply` method of a
-                  // PolyFunction.
-              case _  => fallback
-          case info2: MethodType =>
-            info1 match
-              case info1: MethodType =>
-                matchingMethodParams(info1, info2, precise = false)
-                && isSubInfo(info1.resultType, info2.resultType.subst(info2, info1), symInfo1.resultType)
-                && sigsOK(symInfo1, info2)
-              case _ => fallback
-          case info2 @ CapturingType(parent2, refs2) if ctx.phase == Phases.checkCapturesPhase =>
-            val refs1 = info1.captureSet
-            (refs1.isAlwaysEmpty || subCaptures(refs1, refs2, frozenConstraint).isOK) && sameBoxed(info1, info2, refs1)
-              && isSubInfo(info1, parent2, symInfo1)
-          case _ =>
-            info1 match
-              case info1 @ CapturingType(parent1, refs1) if ctx.phase == Phases.checkCapturesPhase =>
-                subCaptures(refs1, info2.captureSet, frozenConstraint).isOK && sameBoxed(info1, info2, refs1)
-                  && isSubInfo(parent1, info2, symInfo1)
-              case _ => fallback
+      def fallback = (info1: Type, info2: Type) =>
+        def tp1IsSingleton: Boolean = tp1.isInstanceOf[SingletonType]
+        inFrozenGadtIf(tp1IsSingleton):
+          isSubType(info1, info2)
 
       def qualifies(m: SingleDenotation): Boolean =
         val info2 = tp2.refinedInfo
@@ -2035,7 +2044,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
             // OK{ { def x(): T } <: { def x: T} // if x is Java defined
             ExprType(info1.resType)
           case info1 => info1
-        isSubInfo(info1, info2, m.symbol.info.orElse(info1))
+        isSubInfo(info1, info2, m.symbol.info.orElse(info1), sigsOK, fallback)
         || matchAbstractTypeMember(m.info)
         || (tp1.isStable && m.symbol.isStableMember && isSubType(TermRef(tp1, m.symbol), tp2.refinedInfo))