Rename mut to update

Rename the `mut` soft modifier to `update`.

Reasons:

 - `update` is more descriptive than `mut`
 - `update` corresponds to the terminology "update method"
 - 3 letter modifiers are problematic for visual layout

Author: odersky

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

@@ -206,7 +206,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
     case class Var()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Mutable)
 
-    case class Mut()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Mutable)
+    case class Update()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Mutable)
 
     case class Implicit()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Implicit)
 

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

@@ -553,7 +553,6 @@ object StdNames {
     val maybeCapability: N      = "maybeCapability"
     val mirror : N              = "mirror"
     val moduleClass : N         = "moduleClass"
-    val mut: N                  = "mut"
     val name: N                 = "name"
     val nameDollar: N           = "$name"
     val ne: N                   = "ne"

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -3291,7 +3291,7 @@ object Parsers {
           case nme.infix => Mod.Infix()
           case nme.tracked => Mod.Tracked()
           case nme.erased if in.erasedEnabled => Mod.Erased()
-          case nme.mut if Feature.ccEnabled => Mod.Mut()
+          case nme.update if Feature.ccEnabled => Mod.Update()
         }
     }
 
@@ -4708,7 +4708,7 @@ object Parsers {
           Nil
         tree match
           case tree: MemberDef
-          if !(tree.mods.flags & ModifierFlags).isEmpty && !tree.mods.isMutableVar => // vars are OK, mut defs are not
+          if !(tree.mods.flags & ModifierFlags).isEmpty && !tree.mods.isMutableVar => // vars are OK, update defs are not
             fail(em"refinement cannot be ${(tree.mods.flags & ModifierFlags).flagStrings().mkString("`", "`, `", "`")}")
           case tree: DefDef if tree.termParamss.nestedExists(!_.rhs.isEmpty) =>
             fail(em"refinement cannot have default arguments")

compiler/src/dotty/tools/dotc/parsing/Scanners.scala

@@ -1228,7 +1228,7 @@ object Scanners {
       && (softModifierNames.contains(name)
         || name == nme.erased && erasedEnabled
         || name == nme.tracked && trackedEnabled
-        || name == nme.mut && Feature.ccEnabled)
+        || name == nme.update && Feature.ccEnabled)
 
     def isSoftModifierInModifierPosition: Boolean =
       isSoftModifier && inModifierPosition()

compiler/src/dotty/tools/dotc/parsing/Tokens.scala

@@ -299,7 +299,7 @@ object Tokens extends TokensCommon {
 
   final val closingParens = BitSet(RPAREN, RBRACKET, RBRACE)
 
-  final val softModifierNames = Set(nme.inline, nme.into, nme.opaque, nme.open, nme.transparent, nme.infix)
+  final val softModifierNames = Set(nme.inline, nme.into, nme.opaque, nme.open, nme.transparent, nme.infix, nme.update)
 
   def showTokenDetailed(token: Int): String = debugString(token)
 

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

@@ -4,7 +4,7 @@ import caps.*
 class Ref[T](init: T) extends Mutable:
   private var value: T = init
   def get: T = value
-  mut def set(newValue: T): Unit = value = newValue
+  update def set(newValue: T): Unit = value = newValue
 
 // a library function that assumes that a and b MUST BE separate
 def swap[T](a: Ref[Int]^, b: Ref[Int]^): Unit = ???

tests/neg-custom-args/captures/linear-buffer-2.scala

@@ -2,7 +2,7 @@ import caps.{cap, consume, Mutable}
 import language.experimental.captureChecking
 
 class Buffer[T] extends Mutable:
-  @consume mut def append(x: T): Buffer[T]^ = this // ok
+  @consume update def append(x: T): Buffer[T]^ = this // ok
 
 def app[T](@consume buf: Buffer[T]^, elem: T): Buffer[T]^ =
   buf.append(elem)

tests/neg-custom-args/captures/linear-buffer.check

@@ -1,6 +1,6 @@
--- Error: tests/neg-custom-args/captures/linear-buffer.scala:5:24 ------------------------------------------------------
-5 |  mut def append(x: T): BadBuffer[T]^ = this // error
-  |                        ^^^^^^^^^^^^^
+-- Error: tests/neg-custom-args/captures/linear-buffer.scala:5:27 ------------------------------------------------------
+5 |  update def append(x: T): BadBuffer[T]^ = this // error
+  |                           ^^^^^^^^^^^^^
   |      Separation failure: method append's result type BadBuffer[T]^ hides non-local this of class class BadBuffer.
   |      The access must be in a @consume method to allow this.
 -- Error: tests/neg-custom-args/captures/linear-buffer.scala:7:13 ------------------------------------------------------

tests/neg-custom-args/captures/linear-buffer.scala

@@ -2,13 +2,13 @@ import caps.{cap, consume, Mutable}
 import language.experimental.captureChecking
 
 class BadBuffer[T] extends Mutable:
-  mut def append(x: T): BadBuffer[T]^ = this // error
+  update def append(x: T): BadBuffer[T]^ = this // error
   def foo =
     def bar: BadBuffer[T]^ = this // error
     bar
 
 class Buffer[T] extends Mutable:
-  @consume mut def append(x: T): Buffer[T]^ = this // ok
+  @consume update def append(x: T): Buffer[T]^ = this // ok
 
 def app[T](@consume buf: Buffer[T]^, elem: T): Buffer[T]^ =
   buf.append(elem)

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

@@ -1,8 +1,8 @@
--- Error: tests/neg-custom-args/captures/mut-outside-mutable.scala:5:10 ------------------------------------------------
-5 |  mut def foreach(op: T => Unit): Unit // error
-  |          ^
-  |          Update methods can only be used as members of classes extending the `Mutable` trait
--- Error: tests/neg-custom-args/captures/mut-outside-mutable.scala:9:12 ------------------------------------------------
-9 |    mut def baz() = 1 // error
-  |            ^
-  |            Update methods can only be used as members of classes extending the `Mutable` trait
+-- 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
+-- 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

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

@@ -2,9 +2,9 @@ import caps.Mutable
 
 trait IterableOnce[T]:
   def iterator: Iterator[T]^{this}
-  mut def foreach(op: T => Unit): Unit // error
+  update def foreach(op: T => Unit): Unit // error
 
 trait Foo extends Mutable:
   def bar =
-    mut def baz() = 1 // error
+    update def baz() = 1 // error
     baz()

tests/neg-custom-args/captures/mut-override.scala

@@ -2,18 +2,18 @@ import caps.Mutable
 
 trait IterableOnce[T] extends Mutable:
   def iterator: Iterator[T]^{this}
-  mut def foreach(op: T => Unit): Unit
+  update def foreach(op: T => Unit): Unit
 
 trait Iterator[T] extends IterableOnce[T]:
   def iterator = this
   def hasNext: Boolean
-  mut def next(): T
-  mut def foreach(op: T => Unit): Unit = ???
-  override mut def toString = ???   // error
+  update def next(): T
+  update def foreach(op: T => Unit): Unit = ???
+  override update def toString = ???   // error
 
 trait Iterable[T] extends IterableOnce[T]:
   def iterator: Iterator[T] = ???
   def foreach(op: T => Unit) = iterator.foreach(op)
 
 trait BadIterator[T] extends Iterator[T]:
-  override mut def hasNext: Boolean  // error
+  override update def hasNext: Boolean  // error

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

@@ -4,7 +4,7 @@ import caps.cap
 class Ref(init: Int) extends Mutable:
   private var current = init
   def get: Int = current
-  mut def put(x: Int): Unit = current = x
+  update def put(x: Int): Unit = current = x
 
 def Test(c: Object^) =
   val a: Ref^ = Ref(1)

tests/neg-custom-args/captures/sep-box.scala

@@ -21,7 +21,7 @@ object NIL extends LIST[Nothing]:
 class Ref extends Mutable:
   var x = 0
   def get: Int = x
-  mut def put(y: Int): Unit = x = y
+  update def put(y: Int): Unit = x = y
 
 class Box[+X](val value: X)
 

tests/neg-custom-args/captures/sep-consume.scala

@@ -4,7 +4,7 @@ import caps.*
 class Ref extends Mutable:
   private var _data = 0
   def get: Int = _data
-  mut def put(x: Int): Unit = _data = x
+  update def put(x: Int): Unit = _data = x
 
 case class Pair[+A, +B](fst: A, snd: B)
 

tests/neg-custom-args/captures/sep-counter.scala

@@ -4,7 +4,7 @@ import caps.cap
 class Ref extends Mutable:
   var x = 0
   def get: Int = x
-  mut def put(y: Int): Unit = x = y
+  update def put(y: Int): Unit = x = y
 
 class Pair[+X, +Y](val fst: X, val snd: Y)
 

tests/neg-custom-args/captures/sep-curried.scala

@@ -4,7 +4,7 @@ import caps.*
 class Ref[T](init: T) extends Mutable:
   private var value: T = init
   def get: T = value
-  mut def set(newValue: T): Unit = value = newValue
+  update def set(newValue: T): Unit = value = newValue
 
 // a library function that assumes that a and b MUST BE separate
 def swap[T](a: Ref[Int]^, b: Ref[Int]^): Unit = ???

tests/neg-custom-args/captures/sep-list.scala

@@ -21,7 +21,7 @@ object NIL extends LIST[Nothing]:
 class Ref extends Mutable:
   var x = 0
   def get: Int = x
-  mut def put(y: Int): Unit = x = y
+  update def put(y: Int): Unit = x = y
 
 def listFresh(n: Int): LIST[Ref^] =
   if n == 0 then NIL

tests/neg-custom-args/captures/sep-pairs-2.scala

@@ -4,7 +4,7 @@ import caps.cap
 class Ref extends Mutable:
   var x = 0
   def get: Int = x
-  mut def put(y: Int): Unit = x = y
+  update def put(y: Int): Unit = x = y
 
 class Pair[+X, +Y](val fst: X, val snd: Y)
 

tests/neg-custom-args/captures/sep-pairs.scala

@@ -4,7 +4,7 @@ import caps.cap
 class Ref extends Mutable:
   var x = 0
   def get: Int = x
-  mut def put(y: Int): Unit = x = y
+  update def put(y: Int): Unit = x = y
 
 class Pair[+X, +Y](val fst: X, val snd: Y)
 

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

@@ -8,7 +8,7 @@ trait Rdr[T]:
 class Ref[T](init: T) extends Rdr[T], Mutable:
   private var current = init
   def get: T = current
-  mut def put(x: T): Unit = current = x
+  update def put(x: T): Unit = current = x
 
 def Test(c: Object^): Unit =
   val a: Ref[Int]^ = Ref(1)
@@ -39,7 +39,7 @@ def Test(c: Object^): Unit =
   class Matrix(nrows: Int, ncols: Int) extends IMatrix, Mutable:
     val arr = Array.fill(nrows, ncols)(0.0)
     def apply(i: Int, j: Int): Double = arr(i)(j)
-    mut def update(i: Int, j: Int, x: Double): Unit = arr(i)(j) = x
+    update def update(i: Int, j: Int, x: Double): Unit = arr(i)(j) = x
 
   def mul(x: IMatrix^{cap.rd}, y: IMatrix^{cap.rd}, z: Matrix^): Matrix^ = ???
 

tests/neg-custom-args/captures/update-call.scala

@@ -2,18 +2,18 @@ import caps.Mutable
 
 trait IterableOnce[T] extends Mutable:
   def iterator: Iterator[T]^{this}
-  mut def foreach(op: T => Unit): Unit
+  update def foreach(op: T => Unit): Unit
 
 trait Iterator[T] extends IterableOnce[T]:
   def iterator = this
   def hasNext: Boolean
-  mut def next(): T
-  mut def foreach(op: T => Unit): Unit = ???
-  override mut def toString = ???   // error
+  update def next(): T
+  update def foreach(op: T => Unit): Unit = ???
+  override update def toString = ???   // error
 
 trait Iterable[T] extends IterableOnce[T]:
   def iterator: Iterator[T] = ???
   def foreach(op: T => Unit) = iterator.foreach(op)
 
 trait BadIterator[T] extends Iterator[T]:
-  override mut def hasNext: Boolean  // error
+  override update def hasNext: Boolean  // error

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

@@ -2,4 +2,4 @@ import caps.Mutable
 class Ref(init: Int) extends Mutable:
   private var current = init
   def get: Int = current
-  mut def put(x: Int): Unit = current = x
+  update def put(x: Int): Unit = current = x

tests/pos-custom-args/captures/sep-pairs.scala

@@ -4,7 +4,7 @@ import caps.{cap, consume, use}
 class Ref extends Mutable:
   var x = 0
   def get: Int = x
-  mut def put(y: Int): Unit = x = y
+  update def put(y: Int): Unit = x = y
 
 case class Pair[+A, +B](fst: A, snd: B)