Ignore double-flip occurrences for freezing

Author: Linyxus

compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala

@@ -813,6 +813,10 @@ class CheckCaptures extends Recheck, SymTransformer:
       val arg :: Nil = tree.args: @unchecked
       def imm = new TypeMap:
         def apply(t: Type) = t match
+          case t if variance <= 0 =>
+            // Skip double-flip occurrences of mutable types.
+            // Example: tests/neg-custom-args/captures/freeze-double-flip.scala.
+            t
           case t @ CapturingType(parent, refs) =>
             // If the capturing type is boxed, we skip it. Since it could capture
             // existing values of a mutable type without charging anything to the

tests/neg-custom-args/captures/freeze-double-flip.check

@@ -0,0 +1,13 @@
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/freeze-double-flip.scala:16:48 ---------------------------
+16 |  val reallybad: Ref^ -> Ref^{} = x => magic(x)(x => x)  // error
+   |                                                ^^^^^^
+   |Found:    (x: Ref^'s1) ->'s2 Ref^{x.rd}
+   |Required: Ref^ => Ref^{cap.rd}
+   |
+   |Note that capability x.rd is not included in capture set {cap.rd}.
+   |
+   |where:    =>  refers to a fresh root capability created in anonymous function of type (x: Ref^): Ref^{} when checking argument to parameter x$0 of method apply
+   |          ^   refers to the universal root capability
+   |          cap is a fresh root capability created in anonymous function of type (x: Ref^): Ref^{} when checking argument to parameter x$0 of method apply
+   |
+   | longer explanation available when compiling with `-explain`

tests/neg-custom-args/captures/freeze-double-flip.scala

@@ -0,0 +1,16 @@
+import language.experimental.captureChecking
+import language.experimental.separationChecking
+import caps.{Mutable, freeze}
+
+// A mutable ref and its immutable version
+class Ref extends Mutable:
+  private var data: Int = 0
+  def get: Int = data
+  update def set(x: Int): Unit = data = x
+def allocRef(): Ref^ = Ref()
+type IRef = Ref^{}
+
+def test1(): Unit =
+  val magic = freeze:
+    (x: Ref^) => (op: Ref^ => IRef) => op(x)
+  val reallybad: Ref^ -> Ref^{} = x => magic(x)(x => x)  // error