Cleanups

Author: odersky

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

@@ -277,7 +277,6 @@ class CheckCaptures extends Recheck, SymTransformer:
                     traverseChildren(tp)
 
         checker.traverse(tpe)
-        //println(i"check $tpe = ${checker.seenRefs}")
         if checker.seenRefs.size == 2
             && checker.seenRefs(true) >= 0
             && checker.seenRefs(false) <= 0
@@ -286,30 +285,8 @@ class CheckCaptures extends Recheck, SymTransformer:
                 em"""Reach capability ${showRef(checker.seenReach.nn)} and universal capability cap cannot both
                     |appear in the type $tpe of this expression""",
                 pos)
-
     end checkReachCapsIsolated
 
-    // Uses 4-space indent as a trial
-    def checkReachCapsOnlyCovariant(tpe: Type, pos: SrcPos)(using Context): Unit =
-        val checker = new TypeTraverser:
-            def traverse(tp: Type) =
-                tp match
-                case CapturingType(parent, refs) =>
-                    traverse(parent)
-                    if variance <= 0 then
-                        for ref <- refs.elems do
-                            if ref.isReach then
-                                val prefix = if variance == 0 then "in" else "contra"
-                                report.error(
-                                    em"""Reach capability ${showRef(ref)} is not allowed to appear in ${prefix}variant position
-                                        |in argument type $tpe""",
-                                    pos
-                                )
-                case _ =>
-                    traverseChildren(tp)
-        checker.traverse(tpe)
-    end checkReachCapsOnlyCovariant
-
     /** The current environment */
     private val rootEnv: Env = inContext(ictx):
       Env(defn.RootClass, EnvKind.Regular, CaptureSet.empty, null)
@@ -514,12 +491,6 @@ class CheckCaptures extends Recheck, SymTransformer:
           case appType => appType
     end recheckApply
 
-    // Uses 4-space indent as a trial
-    override def recheckArg(arg: Tree, pt: Type)(using Context) =
-        val argType = recheck(arg, pt)
-        //checkReachCapsOnlyCovariant(argType.widen, arg.srcPos)
-        argType
-
     private def isDistinct(xs: List[Type]): Boolean = xs match
       case x :: xs1 => xs1.isEmpty || !xs1.contains(x) && isDistinct(xs1)
       case Nil => true

compiler/src/dotty/tools/dotc/transform/Recheck.scala

@@ -311,7 +311,7 @@ abstract class Recheck extends Phase, SymTransformer:
             else fntpe.paramInfos
           def recheckArgs(args: List[Tree], formals: List[Type], prefs: List[ParamRef]): List[Type] = args match
             case arg :: args1 =>
-              val argType = recheckArg(arg, normalizeByName(formals.head))
+              val argType = recheck(arg, normalizeByName(formals.head))
               val formals1 =
                 if fntpe.isParamDependent
                 then formals.tail.map(_.substParam(prefs.head, argType))
@@ -326,9 +326,6 @@ abstract class Recheck extends Phase, SymTransformer:
         case tp =>
           assert(false, i"unexpected type of ${tree.fun}: $tp")
 
-    def recheckArg(arg: Tree, pt: Type)(using Context): Type =
-      recheck(arg, normalizeByName(pt))
-
     def recheckTypeApply(tree: TypeApply, pt: Type)(using Context): Type =
       val funtpe = recheck(tree.fun)
       tree.fun.rememberType(funtpe) // remember type to support later bounds checks

tests/neg/unsound-reach-3.scala

@@ -0,0 +1,21 @@
+import language.experimental.captureChecking
+trait File:
+  def close(): Unit
+
+def withFile[R](path: String)(op: File^ => R): R = ???
+
+trait Foo[+X]:
+  def use(x: File^): X
+class Bar extends Foo[File^]:
+  def use(x: File^): File^ = x
+
+def bad(): Unit =
+  val backdoor: Foo[File^] = new Bar
+  val boom: Foo[File^{backdoor*}] = backdoor
+
+  var escaped: File^{backdoor*} = null
+  withFile("hello.txt"): f =>
+    escaped = boom.use(f) // error
+      // boom.use: (x: File^) -> File^{backdoor*}, it is a selection so reach capabilities are allowed
+      // f: File^, so there is no reach capabilities
+