Bulk-edit mutable -> mut.

Author: graydon

doc/keywords.txt

@@ -8,7 +8,7 @@ else export
 f32 f64 fail false float fn for
 i16 i32 i64 i8 if import in int
 let log loop
-mod mutable
+mod mut
 native note
 obj  
 prove pure

doc/lib/codemirror-rust.js

@@ -218,14 +218,14 @@ CodeMirror.defineMode("rust", function() {
       if (content == "|") return cont(blockvars, poplex, pushlex("}", "block"), block);
       if (content == "||") return cont(poplex, pushlex("}", "block"), block);
     }
-    if (content == "mutable" || (content.match(/^\w+$/) && cx.stream.peek() == ":"
+    if (content == "mut" || (content.match(/^\w+$/) && cx.stream.peek() == ":"
                                  && !cx.stream.match("::", false)))
       return pass(record_of(expression));
     return pass(block);
   }
   function record_of(comb) {
     function ro(type) {
-      if (content == "mutable" || content == "with") {cx.marked = "keyword"; return cont(ro);}
+      if (content == "mut" || content == "with") {cx.marked = "keyword"; return cont(ro);}
       if (content.match(/^\w*$/)) {cx.marked = "variable"; return cont(ro);}
       if (type == ":") return cont(comb, ro);
       if (type == "}") return cont();
@@ -317,7 +317,7 @@ CodeMirror.defineMode("rust", function() {
   }
   function rtype(type) {
     if (type == "name") {cx.marked = "variable-3"; return cont(rtypemaybeparam); }
-    if (content == "mutable") {cx.marked = "keyword"; return cont(rtype);}
+    if (content == "mut") {cx.marked = "keyword"; return cont(rtype);}
     if (type == "atom") return cont(rtypemaybeparam);
     if (type == "op" || type == "obj") return cont(rtype);
     if (type == "fn") return cont(fntype);

doc/rust.md

@@ -217,7 +217,7 @@ else enum export
 fail false fn for
 if iface impl import
 let log loop
-mod mutable
+mod mut
 native
 pure
 resource ret
@@ -1527,13 +1527,13 @@ rec_expr : '{' ident ':' expr
 A _[record](#record-types) expression_ is one or more comma-separated
 name-value pairs enclosed by braces. A fieldname can be any identifier
 (including keywords), and is separated from its value expression by a
-colon. To indicate that a field is mutable, the `mutable` keyword is
+colon. To indicate that a field is mutable, the `mut` keyword is
 written before its name.
 
 ~~~~
 {x: 10f, y: 20f};
 {name: "Joe", age: 35u, score: 100_000};
-{ident: "X", mutable count: 0u};
+{ident: "X", mut count: 0u};
 ~~~~
 
 The order of the fields in a record expression is significant, and
@@ -1586,19 +1586,19 @@ expression on the left of the dot.
 ### Vector expressions
 
 ~~~~~~~~{.ebnf .gram}
-vec_expr : '[' "mutable" ? [ expr [ ',' expr ] * ] ? ']'
+vec_expr : '[' "mut" ? [ expr [ ',' expr ] * ] ? ']'
 ~~~~~~~~
 
 A _[vector](#vector-types) expression_ is written by enclosing zero or
 more comma-separated expressions of uniform type in square brackets.
-The keyword `mutable` can be written after the opening bracket to
+The keyword `mut` can be written after the opening bracket to
 indicate that the elements of the resulting vector may be mutated.
 When no mutability is specified, the vector is immutable.
 
 ~~~~
 [1, 2, 3, 4];
 ["a", "b", "c", "d"];
-[mutable 0u8, 0u8, 0u8, 0u8];
+[mut 0u8, 0u8, 0u8, 0u8];
 ~~~~
 
 ### Index expressions
@@ -1622,7 +1622,7 @@ task in a _failing state_.
 # task::run(builder) {||
 
 [1, 2, 3, 4][0];
-[mutable 'x', 'y'][1] = 'z';
+[mut 'x', 'y'][1] = 'z';
 ["a", "b"][10]; // fails
 
 # }
@@ -1904,11 +1904,11 @@ argument to a function to be copied and passed by value.
 An example of a copy expression:
 
 ~~~~
-fn mutate(vec: [mutable int]) {
+fn mutate(vec: [mut int]) {
    vec[0] = 10;
 }
 
-let v = [mutable 1,2,3];
+let v = [mut 1,2,3];
 
 mutate(copy v);   // Pass a copy
 

doc/tutorial.md

@@ -366,7 +366,7 @@ more detail later on (the `T`s here stand for any other type):
 `[T]`
   : Vector type.
 
-`[mutable T]`
+`[mut T]`
   : Mutable vector type.
 
 `(T1, T2)`
@@ -994,10 +994,10 @@ Fields that you want to mutate must be explicitly marked as such. For
 example...
 
 ~~~~
-type stack = {content: [int], mutable head: uint};
+type stack = {content: [int], mut head: uint};
 ~~~~
 
-With such a type, you can do `mystack.head += 1u`. If `mutable` were
+With such a type, you can do `mystack.head += 1u`. If `mut` were
 omitted from the type, such an assignment would result in a type
 error.
 
@@ -1240,12 +1240,12 @@ become the sole owner of the box.
 
 ### Mutability
 
-All pointer types have a mutable variant, written `@mutable TYPE` or
-`~mutable TYPE`. Given such a pointer, you can write to its contents
+All pointer types have a mutable variant, written `@mut TYPE` or
+`~mut TYPE`. Given such a pointer, you can write to its contents
 by combining the dereference operator with a mutating action.
 
 ~~~~
-fn increase_contents(pt: @mutable int) {
+fn increase_contents(pt: @mut int) {
     *pt += 1;
 }
 ~~~~
@@ -1268,9 +1268,9 @@ if myvec[1] { io::println("boom"); }
 ~~~~
 
 By default, vectors are immutable—you can not replace their elements.
-The type written as `[mutable TYPE]` is a vector with mutable
-elements. Mutable vector literals are written `[mutable]` (empty) or
-`[mutable 1, 2, 3]` (with elements).
+The type written as `[mut TYPE]` is a vector with mutable
+elements. Mutable vector literals are written `[mut]` (empty) or
+`[mut 1, 2, 3]` (with elements).
 
 The `+` operator means concatenation when applied to vector types.
 Growing a vector in Rust is not as inefficient as it looks :
@@ -1398,7 +1398,7 @@ to pessimistically assume a value will get mutated, even though it is
 not sure.
 
 ~~~~
-fn for_each(v: [mutable @int], iter: fn(@int)) {
+fn for_each(v: [mut @int], iter: fn(@int)) {
    for elt in v { iter(elt); }
 }
 ~~~~
@@ -1413,15 +1413,15 @@ reference count is considered cheap enough to not warn about it).
 ## The copy operator
 
 If the `for_each` function given above were to take a vector of
-`{mutable a: int}` instead of `@int`, it would not be able to
+`{mut a: int}` instead of `@int`, it would not be able to
 implicitly copy, since if the `iter` function changes a copy of a
 mutable record, the changes won't be visible in the record itself. If
 we *do* want to allow copies there, we have to explicitly allow it
 with the `copy` operator:
 
 ~~~~
-type mutrec = {mutable x: int};
-fn for_each(v: [mutable mutrec], iter: fn(mutrec)) {
+type mutrec = {mut x: int};
+fn for_each(v: [mut mutrec], iter: fn(mutrec)) {
    for elt in v { iter(copy elt); }
 }
 ~~~~
@@ -1529,7 +1529,7 @@ Generic `type` and `enum` declarations follow the same pattern:
 ~~~~
 type circular_buf<T> = {start: uint,
                         end: uint,
-                        buf: [mutable T]};
+                        buf: [mut T]};
 
 enum option<T> { some(T), none }
 ~~~~
@@ -2315,14 +2315,14 @@ microsecond-resolution timer.
 
 ~~~~
 use std;
-type timeval = {mutable tv_sec: uint,
-                mutable tv_usec: uint};
+type timeval = {mut tv_sec: uint,
+                mut tv_usec: uint};
 #[nolink]
 native mod libc {
     fn gettimeofday(tv: *timeval, tz: *()) -> i32;
 }
 fn unix_time_in_microseconds() -> u64 unsafe {
-    let x = {mutable tv_sec: 0u, mutable tv_usec: 0u};
+    let x = {mut tv_sec: 0u, mut tv_usec: 0u};
     libc::gettimeofday(ptr::addr_of(x), ptr::null());
     ret (x.tv_sec as u64) * 1000_000_u64 + (x.tv_usec as u64);
 }

src/cargo/cargo.rs

@@ -43,7 +43,7 @@ type source = {
     sig: option<str>,
     key: option<str>,
     keyfp: option<str>,
-    mutable packages: [package]
+    mut packages: [package]
 };
 
 type cargo = {
@@ -117,10 +117,10 @@ fn load_pkg(filename: str) -> option<pkg> {
     let handler = diagnostic::mk_handler(none);
     let sess = @{
         cm: cm,
-        mutable next_id: 1,
+        mut next_id: 1,
         span_diagnostic: diagnostic::mk_span_handler(handler, cm),
-        mutable chpos: 0u,
-        mutable byte_pos: 0u
+        mut chpos: 0u,
+        mut byte_pos: 0u
     };
     let c = parser::parse_crate_from_crate_file(filename, [], sess);
 
@@ -214,7 +214,7 @@ fn parse_source(name: str, j: json::json) -> source {
                 _ { none }
             };
             ret { name: name, url: url, sig: sig, key: key, keyfp: keyfp,
-                  mutable packages: [] };
+                  mut packages: [] };
         }
         _ { fail "Needed dict value in source."; }
     };

src/fuzzer/fuzzer.rs

@@ -119,7 +119,7 @@ fn safe_to_steal_ty(t: @ast::ty, tm: test_mode) -> bool {
 
 // Not type-parameterized: https://github.com/mozilla/rust/issues/898 (FIXED)
 fn stash_expr_if(c: fn@(@ast::expr, test_mode)->bool,
-                 es: @mutable [ast::expr],
+                 es: @mut [ast::expr],
                  e: @ast::expr,
                  tm: test_mode) {
     if c(e, tm) {
@@ -128,7 +128,7 @@ fn stash_expr_if(c: fn@(@ast::expr, test_mode)->bool,
 }
 
 fn stash_ty_if(c: fn@(@ast::ty, test_mode)->bool,
-               es: @mutable [ast::ty],
+               es: @mut [ast::ty],
                e: @ast::ty,
                tm: test_mode) {
     if c(e, tm) {
@@ -139,8 +139,8 @@ fn stash_ty_if(c: fn@(@ast::ty, test_mode)->bool,
 type stolen_stuff = {exprs: [ast::expr], tys: [ast::ty]};
 
 fn steal(crate: ast::crate, tm: test_mode) -> stolen_stuff {
-    let exprs = @mutable [];
-    let tys = @mutable [];
+    let exprs = @mut [];
+    let tys = @mut [];
     let v = visit::mk_simple_visitor(@{
         visit_expr: bind stash_expr_if(safe_to_steal_expr, exprs, _, tm),
         visit_ty: bind stash_ty_if(safe_to_steal_ty, tys, _, tm)
@@ -176,8 +176,8 @@ fn safe_to_replace_ty(t: ast::ty_, _tm: test_mode) -> bool {
 // Replace the |i|th expr (in fold order) of |crate| with |newexpr|.
 fn replace_expr_in_crate(crate: ast::crate, i: uint, newexpr: ast::expr, tm: test_mode) ->
    ast::crate {
-    let j: @mutable uint = @mutable 0u;
-    fn fold_expr_rep(j_: @mutable uint, i_: uint, newexpr_: ast::expr_,
+    let j: @mut uint = @mut 0u;
+    fn fold_expr_rep(j_: @mut uint, i_: uint, newexpr_: ast::expr_,
                      original: ast::expr_, fld: fold::ast_fold, tm_: test_mode) ->
        ast::expr_ {
         *j_ += 1u;
@@ -199,8 +199,8 @@ fn replace_expr_in_crate(crate: ast::crate, i: uint, newexpr: ast::expr, tm: tes
 // Replace the |i|th ty (in fold order) of |crate| with |newty|.
 fn replace_ty_in_crate(crate: ast::crate, i: uint, newty: ast::ty, tm: test_mode) ->
    ast::crate {
-    let j: @mutable uint = @mutable 0u;
-    fn fold_ty_rep(j_: @mutable uint, i_: uint, newty_: ast::ty_,
+    let j: @mut uint = @mut 0u;
+    fn fold_ty_rep(j_: @mut uint, i_: uint, newty_: ast::ty_,
                      original: ast::ty_, fld: fold::ast_fold, tm_: test_mode) ->
        ast::ty_ {
         *j_ += 1u;
@@ -403,10 +403,10 @@ fn parse_and_print(code: @str) -> str {
     let handler = diagnostic::mk_handler(none);
     let sess = @{
         cm: cm,
-        mutable next_id: 1,
+        mut next_id: 1,
         span_diagnostic: diagnostic::mk_span_handler(handler, cm),
-        mutable chpos: 0u,
-        mutable byte_pos: 0u
+        mut chpos: 0u,
+        mut byte_pos: 0u
     };
     write_file(filename, *code);
     let crate = parser::parse_crate_from_source_str(
@@ -422,8 +422,8 @@ fn parse_and_print(code: @str) -> str {
 }
 
 fn has_raw_pointers(c: ast::crate) -> bool {
-    let has_rp = @mutable false;
-    fn visit_ty(flag: @mutable bool, t: @ast::ty) {
+    let has_rp = @mut false;
+    fn visit_ty(flag: @mut bool, t: @ast::ty) {
         alt t.node {
           ast::ty_ptr(_) { *flag = true; }
           _ { }
@@ -549,10 +549,10 @@ fn check_variants(files: [str], cx: context) {
         let handler = diagnostic::mk_handler(none);
         let sess = @{
             cm: cm,
-            mutable next_id: 1,
+            mut next_id: 1,
             span_diagnostic: diagnostic::mk_span_handler(handler, cm),
-            mutable chpos: 0u,
-            mutable byte_pos: 0u
+            mut chpos: 0u,
+            mut byte_pos: 0u
         };
         let crate =
             parser::parse_crate_from_source_str(

src/fuzzer/rand_util.rs

@@ -12,7 +12,7 @@ fn choice<T: copy>(r : rand::rng, v : [T]) -> T { assert vec::len(v) != 0u; v[un
 fn unlikely(r : rand::rng, n : uint) -> bool { under(r, n) == 0u }
 
 // shuffle a vec in place
-fn shuffle<T>(r : rand::rng, &v : [mutable T]) {
+fn shuffle<T>(r : rand::rng, &v : [mut T]) {
     let i = vec::len(v);
     while i >= 2u {
         // Loop invariant: elements with index >= i have been locked in place.
@@ -73,7 +73,7 @@ fn main()
     log(error, choice(r, [10, 20, 30]));
     log(error, if unlikely(r, 5u) { "unlikely" } else { "likely" });
 
-    let a = [mutable 1, 2, 3];
+    let a = [mut 1, 2, 3];
     shuffle(r, a);
     log(error, a);
 

src/libcore/future.rs

@@ -24,7 +24,7 @@ export spawn;
 
 #[doc = "The future type"]
 enum future<A> = {
-    mutable v: either<@A, fn@() -> A>
+    mut v: either<@A, fn@() -> A>
 };
 
 #[doc = "Methods on the `future` type"]
@@ -52,7 +52,7 @@ fn from_value<A>(+val: A) -> future<A> {
     "];
 
     future({
-        mutable v: either::left(@val)
+        mut v: either::left(@val)
     })
 }
 
@@ -79,7 +79,7 @@ fn from_fn<A>(f: fn@() -> A) -> future<A> {
     "];
 
     future({
-        mutable v: either::right(f)
+        mut v: either::right(f)
     })
 }