Several changes to var handling

 - Mutable variables are no longer tracked
 - Variable definitions with `*` capability are allowed
 - But variable dereferences are not allowed if they capture `*`

Author: odersky

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

@@ -89,7 +89,7 @@ object CheckCaptures:
       elem.tpe match
         case ref: CaptureRef =>
           if !ref.canBeTracked then
-            report.error(em"$elem cannot be tracked since it is not a parameter or a local variable", elem.srcPos)
+            report.error(em"$elem cannot be tracked since it is not a parameter or local value", elem.srcPos)
         case tpe =>
           report.error(em"$elem: $tpe is not a legal element of a capture set", elem.srcPos)
 
@@ -560,8 +560,6 @@ class CheckCaptures extends Recheck, SymTransformer:
           tpe
         case _: Try =>
           tpe
-        case _: ValDef if tree.symbol.is(Mutable) =>
-          tree.symbol.info
         case _ =>
           NoType
       def checkNotUniversal(tp: Type): Unit = tp.widenDealias match
@@ -746,7 +744,7 @@ class CheckCaptures extends Recheck, SymTransformer:
             val criticalSet =          // the set which is not allowed to have `*`
               if covariant then cs1    // can't box with `*`
               else expected.captureSet // can't unbox with `*`
-            if criticalSet.isUniversal then
+            if criticalSet.isUniversal && expected.isValueType then
               // We can't box/unbox the universal capability. Leave `actual` as it is
               // so we get an error in checkConforms. This tends to give better error
               // messages than disallowing the root capability in `criticalSet`.

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

@@ -2790,7 +2790,7 @@ object Types {
       ((prefix eq NoPrefix)
       || symbol.is(ParamAccessor) && (prefix eq symbol.owner.thisType)
       || isRootCapability
-      ) && !symbol.is(Method)
+      ) && !symbol.isOneOf(UnstableValueFlags)
 
     override def isRootCapability(using Context): Boolean =
       name == nme.CAPTURE_ROOT && symbol == defn.captureRoot

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -272,6 +272,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case tp: LazyRef if !printDebug =>
         try toText(tp.ref)
         catch case ex: Throwable => "..."
+      case AnySelectionProto =>
+        "a type that can be selected or applied"
       case tp: SelectionProto =>
         "?{ " ~ toText(tp.name) ~
            (Str(" ") provided !tp.name.toSimpleName.last.isLetterOrDigit) ~

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

@@ -147,7 +147,7 @@ abstract class Recheck extends Phase, SymTransformer:
 
     def recheckSelect(tree: Select, pt: Type)(using Context): Type =
       val Select(qual, name) = tree
-      recheckSelection(tree, recheck(qual).widenIfUnstable, name, pt)
+      recheckSelection(tree, recheck(qual, AnySelectionProto).widenIfUnstable, name, pt)
 
     def recheckSelection(tree: Select, qualType: Type, name: Name,
         sharpen: Denotation => Denotation)(using Context): Type =

tests/disabled/neg-custom-args/captures/capt-wf.scala

@@ -17,3 +17,5 @@ def test: Unit =
   val y = f(C()) // ok
   val y2 = f2(C()) // ok
   ()
+  var x11 = f
+  val x12: {x11} Any = x11

tests/neg-custom-args/captures/capt-wf2.scala

@@ -0,0 +1,5 @@
+@annotation.capability class C
+
+def test(c: C) =
+  var x: {c} Any = ???
+  val y: {x} Any = x  // error

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

@@ -8,11 +8,11 @@
    |  ^^^^^^^^
    |  The expression's type box {*} () -> Unit is not allowed to capture the root capability `*`.
    |  This usually means that a capability persists longer than its allowed lifetime.
--- Error: tests/neg-custom-args/captures/usingLogFile.scala:31:6 -------------------------------------------------------
-31 |  var later3: () => Unit = () => ()  // error
-   |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |  The mutable variable's type box {*} () -> Unit is not allowed to capture the root capability `*`.
-   |  This usually means that a capability persists longer than its allowed lifetime.
+-- Error: tests/neg-custom-args/captures/usingLogFile.scala:33:2 -------------------------------------------------------
+33 |  later3() // error
+   |  ^^^^^^
+   |  box {*} () -> Unit cannot be box-converted to a type that can be selected or applied
+   |  since one of their capture sets contains the root capability `*`
 -- Error: tests/neg-custom-args/captures/usingLogFile.scala:37:9 -------------------------------------------------------
 37 |  later4.x() // error
    |  ^^^^^^^^

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

@@ -28,9 +28,9 @@ object Test2:
   private val later2 = usingLogFile { f => Cell(() => f.write(0)) }
   later2.x()  // error
 
-  var later3: () => Unit = () => ()  // error
+  var later3: () => Unit = () => ()
   usingLogFile { f => later3 = () => f.write(0) }
-  later3()
+  later3() // error
 
   var later4: Cell[() => Unit] = Cell(() => ())
   usingLogFile { f => later4 = Cell(() => f.write(0)) }

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

@@ -5,21 +5,28 @@
    |                        Required: () -> Unit
    |
    | longer explanation available when compiling with `-explain`
--- Error: tests/neg-custom-args/captures/vars.scala:13:6 ---------------------------------------------------------------
-13 |  var a: String => String = f // error
-   |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |  The mutable variable's type box {*} String -> String is not allowed to capture the root capability `*`.
-   |  This usually means that a capability persists longer than its allowed lifetime.
--- Error: tests/neg-custom-args/captures/vars.scala:15:4 ---------------------------------------------------------------
-15 |  b.head // error
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/vars.scala:15:10 -----------------------------------------
+15 |  val u = a  // error
+   |          ^
+   |          Found:    (a : box {*} String -> String)
+   |          Required: {*} (x$0: ? String) -> ? String
+   |
+   | longer explanation available when compiling with `-explain`
+-- Error: tests/neg-custom-args/captures/vars.scala:16:2 ---------------------------------------------------------------
+16 |  a("")  // error
+   |  ^
+   |  box {*} String -> String cannot be box-converted to a type that can be selected or applied
+   |  since one of their capture sets contains the root capability `*`
+-- Error: tests/neg-custom-args/captures/vars.scala:17:4 ---------------------------------------------------------------
+17 |  b.head // error
    |  ^^^^^^
    |  The expression's type box {*} String -> String is not allowed to capture the root capability `*`.
    |  This usually means that a capability persists longer than its allowed lifetime.
--- Error: tests/neg-custom-args/captures/vars.scala:30:8 ---------------------------------------------------------------
-30 |  local { cap3 => // error
+-- Error: tests/neg-custom-args/captures/vars.scala:32:8 ---------------------------------------------------------------
+32 |  local { cap3 => // error
    |  ^
    |  The expression's type box {*} (x$0: ? String) -> ? String is not allowed to capture the root capability `*`.
    |  This usually means that a capability persists longer than its allowed lifetime.
-31 |    def g(x: String): String = if cap3 == cap3 then "" else "a"
-32 |    g
-33 |  }
+33 |    def g(x: String): String = if cap3 == cap3 then "" else "a"
+34 |    g
+35 |  }

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

@@ -10,8 +10,10 @@ def test(cap1: Cap, cap2: Cap) =
   val z2 = () => { x = identity }
   val z2c: () -> Unit = z2  // error
 
-  var a: String => String = f // error
+  var a: String => String = f // was error, now OK
   var b: List[String => String] = Nil // was error, now OK
+  val u = a  // error
+  a("")  // error
   b.head // error
 
   def scope =

tests/pos-custom-args/captures/vars1.scala

@@ -0,0 +1,8 @@
+import caps.unsafeUnbox
+type ErrorHandler = (Int, String) => Unit
+
+var defaultIncompleteHandler: ErrorHandler = ???
+var incompleteHandler: ErrorHandler = defaultIncompleteHandler
+//val x = incompleteHandler.unsafeUnbox
+
+