Avoid spurious empty sets on MutableType in TypeComparer

Author: odersky

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

@@ -554,7 +554,10 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
               if tp1.isBoxedCapturing && !parent1.isBoxedCapturing
               then tp2.unboxed
               else tp2
-            recur(parent1, tp2a)
+            if parent1.captureSet.isAlwaysEmpty then
+              recur(parent1, tp2a.stripCapturing) // drop rhs capset to avoid possibe read-only adaptations
+            else
+              recur(parent1, tp2a)
           else thirdTry
         compareCapturing
       case tp1: AnnotatedType if !tp1.isRefining =>
@@ -862,8 +865,13 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
         def compareCapturing: Boolean =
           val refs1 = tp1.captureSet
           try
-            if refs1.isAlwaysEmpty then recur(tp1, parent2)
+            if refs1.isAlwaysEmpty
+              //&& !(parent2.derivesFromMutable && refs2.mutability == CaptureSet.Mutability.Mutable)
+            then//
+              recur(tp1, parent2)
             else
+              if false && refs1.isAlwaysEmpty then
+                throw AssertionError(i"NO FAST PATH FOR $tp1 <:< $tp2")
               // 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 one of the variants we are considering). In that case the
@@ -2811,7 +2819,10 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
       tp1.underlying & tp2
     case CapturingType(parent1, refs1) =>
       val jointRefs = refs1 ** tp2.captureSet
-      if jointRefs.isAlwaysEmpty then parent1 & tp2
+      if jointRefs.isAlwaysEmpty
+         && !parent1.derivesFromCapability
+         && !tp2.derivesFromCapability
+      then parent1 & tp2
       else if tp1.isBoxCompatibleWith(tp2) then
         tp1.derivedCapturingType(parent1 & tp2, jointRefs)
       else NoType

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

@@ -25,3 +25,18 @@
    |  Note that capability x is not included in capture set {}.
    |
    | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/leaky.scala:36:16 ----------------------------------------
+36 |  val t = withA(leak) // error
+   |                ^^^^
+   |Capability cap outlives its scope: it leaks into outer capture set 's1 which is owned by value t.
+   |The leakage occurred when trying to match the following types:
+   |
+   |Found:    (a: test.runnable.A^) ->'s2 test.runnable.Transform{val fun: Any => Any}^'s3
+   |Required: test.runnable.A^ =>² test.runnable.Transform{val fun: Any ->'s1 Any}^'s4
+   |
+   |where:    =>  refers to a root capability associated with the result type of (a: test.runnable.A^): test.runnable.Transform{val fun: Any => Any}^'s3
+   |          =>² refers to a fresh root capability created in value t when checking argument to parameter body of method withA
+   |          ^   refers to the universal root capability
+   |          cap is a root capability associated with the result type of (a: test.runnable.A^): test.runnable.Transform{val fun: Any ->'s1 Any}^'s4
+   |
+   | longer explanation available when compiling with `-explain`

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

@@ -33,5 +33,5 @@ def leak2(a: A): Transform^{} =
 def withA[T](body: A => T): T = body(A())
 
 @main def Main() =
-  val t = withA(leak)
+  val t = withA(leak) // error
   t.run()