Prevent fallback to normal function when comparing dependent functions

A dependent function is represented as a refinement type with a normal applied
function type as parent. When capture checking two dependent function types, the
parents should be ignored. But there was a case where this did not happen:
If the left hand side is a sinletontype with a capturing type over a dependent function
type, and the original method type comparisons fail, then the parent type of the
left hand type was tried as a fallback. This commit adds a test that prevents
the fallback.

Author: odersky

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

@@ -856,10 +856,10 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
             else
               // The singletonOK branch is because we sometimes have a larger capture set in a singleton
               // than in its underlying type. An example is `f: () -> () ->{x} T`, which might be
-              // the type of a closure. In that case the capture set of `f.type` is `{x}` but the
-              // capture set of the underlying type is `{}`. So without the `singletonOK` test, a singleton
-              // might not be a subtype of its underlying type. Examples where this arises is
-              // capt-capibility.scala and function-combinators.scala
+              // the type of a closure (in one of the variants we are considering). In that case the
+              // capture set of `f.type` is `{x}` but the capture set of the underlying type is `{}`.
+              // So without the `singletonOK` test, a singleton might not be a subtype of its underlying type.
+              // Eamples where this arises is capt-capibility.scala and function-combinators.scala
               val singletonOK = tp1 match
                 case tp1: SingletonType
                 if subCaptures(tp1.underlying.captureSet, refs2, CaptureSet.VarState.Separate).isOK =>
@@ -1013,6 +1013,11 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
 
         comparePaths || isSubType(tp1widened, tp2, approx.addLow)
       case tp1: RefinedType =>
+        if isCaptureCheckingOrSetup then
+          tp2.stripCapturing match
+            case defn.RefinedFunctionOf(_) => // was already handled in thirdTry
+              return false
+            case _ =>
         isNewSubType(tp1.parent)
       case tp1: RecType =>
         isNewSubType(tp1.parent)

tests/neg-custom-args/captures/i15923b.check

@@ -0,0 +1,14 @@
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i15923b.scala:8:21 ---------------------------------------
+8 |  val leak = withCap(f) // error
+  |                     ^
+  |Found:    (x$0: Cap^) -> Id[box Cap^{x$0}]
+  |Required: (lcap: Cap^) => box Id[box Cap^?]^?
+  |
+  |where:    => refers to a fresh root capability created in value leak when checking argument to parameter op of method withCap
+  |          ^  refers to the universal root capability
+  |
+  |
+  |Note that reference lcap.type
+  |cannot be included in outer capture set ?
+  |
+  | longer explanation available when compiling with `-explain`

tests/neg-custom-args/captures/i15923b.scala

@@ -0,0 +1,9 @@
+import language.experimental.captureChecking
+trait Cap
+case class Id[X](x: X)
+def mkId[X](x: X): Id[X] = Id(x)
+def withCap[X](op: (lcap: Cap^) => X): X = ???
+def bar() =
+  val f = (lcap: Cap^) => mkId(lcap)
+  val leak = withCap(f) // error
+  val leaked = leak.x