Introduce transparent vars

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -226,7 +226,7 @@ object desugar {
           paramss = (setterParam :: Nil) :: Nil,
           tpt     = TypeTree(defn.UnitType),
           rhs     = setterRhs
-        ).withMods((vdef.mods | Accessor) &~ (CaseAccessor | GivenOrImplicit | Lazy))
+        ).withMods((vdef.mods | Accessor) &~ (CaseAccessor | GivenOrImplicit | Lazy | Transparent))
         .dropEndMarker() // the end marker should only appear on the getter definition
       Thicket(vdef1, setter)
     else vdef1

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

@@ -352,11 +352,14 @@ extension (tp: Type)
     case _ =>
       false
 
-  /** Is this a type extending `Mutable` that has update methods? */
+  /** Is this a type extending `Mutable` that has update methods
+   *  or non-private mutable fields?
+   */
   def isMutableType(using Context): Boolean =
     tp.derivesFrom(defn.Caps_Mutable)
-    && tp.membersBasedOnFlags(Mutable | Method, EmptyFlags)
-      .exists(_.hasAltWith(_.symbol.isUpdateMethod))
+    && tp.membersBasedOnFlags(Mutable, EmptyFlags).exists: mbr =>
+      if mbr.symbol.is(Method) then mbr.symbol.isUpdateMethod
+      else !mbr.symbol.is(Transparent)
 
   /** Is this a reference to caps.cap? Note this is _not_ the GlobalCap capability. */
   def isCapRef(using Context): Boolean = tp match

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

@@ -1004,7 +1004,8 @@ class CheckCaptures extends Recheck, SymTransformer:
       val lhsType = recheck(tree.lhs, LhsProto)
       recheck(tree.rhs, lhsType.widen)
       lhsType match
-        case lhsType @ TermRef(qualType, _) if qualType ne NoPrefix =>
+        case lhsType @ TermRef(qualType, _)
+        if (qualType ne NoPrefix) && !lhsType.symbol.is(Transparent) =>
           checkUpdate(qualType, tree.srcPos)(i"Cannot assign to field ${lhsType.name} of ${qualType.showRef}")
         case _ =>
       defn.UnitType

compiler/src/dotty/tools/dotc/typer/Checking.scala

@@ -630,8 +630,13 @@ object Checking {
     if sym.is(Transparent) then
       if sym.isType then
         if !sym.isExtensibleClass then fail(em"`transparent` can only be used for extensible classes and traits")
+      else if sym.isMutableVar && sym.owner.isClass && Feature.ccEnabled
+          || sym.isInlineMethod
+      then
+        () // ok
       else
-        if !sym.isInlineMethod then fail(em"`transparent` can only be used for inline methods")
+        def ccAdd = if Feature.ccEnabled then i" and mutable fields" else ""
+        fail(em"`transparent` can only be used for inline methods$ccAdd")
     if (!sym.isClass && sym.is(Abstract))
       fail(OnlyClassesCanBeAbstract(sym))
         // note: this is not covered by the next test since terms can be abstract (which is a dual-mode flag)
@@ -691,7 +696,7 @@ object Checking {
     if sym.isWrappedToplevelDef && !sym.isType && sym.flags.is(Infix, butNot = Extension) then
       fail(ModifierNotAllowedForDefinition(Flags.Infix, s"A top-level ${sym.showKind} cannot be infix."))
     if sym.isUpdateMethod && !sym.owner.derivesFrom(defn.Caps_Mutable) then
-      fail(em"Update methods can only be used as members of classes extending the `Mutable` trait")
+      fail(em"Update method ${sym.name} must be declared in a class extending the `Mutable` trait.")
     if sym.is(Erased) then checkErasedOK(sym)
     checkCombination(Final, Open)
     checkCombination(Sealed, Open)

tests/neg-custom-args/captures/mut-outside-mutable.check

@@ -1,8 +1,8 @@
 -- Error: tests/neg-custom-args/captures/mut-outside-mutable.scala:5:13 ------------------------------------------------
 5 |  update def foreach(op: T => Unit): Unit // error
   |             ^
-  |             Update methods can only be used as members of classes extending the `Mutable` trait
+  |             Update method foreach must be declared in a class extending the `Mutable` trait.
 -- Error: tests/neg-custom-args/captures/mut-outside-mutable.scala:9:15 ------------------------------------------------
 9 |    update def baz() = 1 // error
   |               ^
-  |               Update methods can only be used as members of classes extending the `Mutable` trait
+  |               Update method baz must be declared in a class extending the `Mutable` trait.

tests/pos-custom-args/captures/lazyref-mutvar.scala

@@ -0,0 +1,9 @@
+import compiletime.uninitialized
+class LazyRef[T](val mkElem: () => T):
+  transparent var elem: T = uninitialized
+  transparent var evaluated = false
+  def get: T =
+    if !evaluated then
+      elem = mkElem()
+      evaluated = true
+    elem

tests/pos-custom-args/captures/transparent-mutvars.scala

@@ -0,0 +1,36 @@
+class Ref[T](init: T) extends caps.Mutable:
+  transparent var fld: T = init
+  def hide(x: T) = this.fld = x // ok
+  update def hide2(x: T) = this.fld = x // ok
+
+  def sneakyHide(x: T) =
+    val self = this
+    self.fld = x  // ok
+
+    val self3 = () => this
+    self3().fld = x  // ok
+
+    def self5() = this
+    self5().fld = x  // ok
+
+class Ref2[T](init: T) extends caps.Mutable:
+  val x = Ref[T](init)
+  def set(x: T) = this.x.fld = x // ok
+  update def set2(x: T) = this.x.fld = x // ok
+
+def test =
+  val r = Ref(22)
+  r.fld = 33 // ok
+  val r1: Ref[Int] = Ref(22)
+  r1.fld = 33 // ok
+
+  val r2 = Ref2(22)
+  r2.x.fld = 33 // ok
+  val r3: Ref2[Int] = Ref2(22)
+  r3.x.fld = 33 // ok
+
+  val r4 = () => Ref2(22)
+  r4().x.fld = 33 // ok
+  val ref2: Ref2[Int] = Ref2(22)
+  val r6: () => Ref2[Int] = () => ref2
+  r6().x.fld = 33 // ok