diff --git a/doc/keywords.txt b/doc/keywords.txt
index 7300c7c5eee..2b4a389e2f8 100644
--- a/doc/keywords.txt
+++ b/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
diff --git a/doc/lib/codemirror-rust.js b/doc/lib/codemirror-rust.js
index fb2f1c5a91a..626351e236c 100644
--- a/doc/lib/codemirror-rust.js
+++ b/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);
diff --git a/doc/rust.md b/doc/rust.md
index 74cb1344620..224f4c099f6 100644
--- a/doc/rust.md
+++ b/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
diff --git a/doc/tutorial.md b/doc/tutorial.md
index e264458af73..d2a9e0cecc3 100644
--- a/doc/tutorial.md
+++ b/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);
}
diff --git a/src/cargo/cargo.rs b/src/cargo/cargo.rs
index 478b8f449e0..51edc90589a 100644
--- a/src/cargo/cargo.rs
+++ b/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."; }
};
diff --git a/src/fuzzer/fuzzer.rs b/src/fuzzer/fuzzer.rs
index f3ea25ef2d5..bbac28ec844 100644
--- a/src/fuzzer/fuzzer.rs
+++ b/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(
diff --git a/src/fuzzer/rand_util.rs b/src/fuzzer/rand_util.rs
index 6e518363125..a20e7651627 100644
--- a/src/fuzzer/rand_util.rs
+++ b/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);
diff --git a/src/libcore/future.rs b/src/libcore/future.rs
index 702da24a75f..ba11138d9ae 100644
--- a/src/libcore/future.rs
+++ b/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)
})
}
diff --git a/src/libcore/io.rs b/src/libcore/io.rs
index 292ef86641d..4525fade3b8 100644
--- a/src/libcore/io.rs
+++ b/src/libcore/io.rs
@@ -174,10 +174,10 @@ fn convert_whence(whence: seek_style) -> i32 {
impl of reader for *libc::FILE {
fn read_bytes(len: uint) -> [u8] unsafe {
- let mut buf : [mutable u8] = [mutable];
+ let mut buf : [mut u8] = [mut];
vec::reserve(buf, len);
vec::as_mut_buf(buf) {|b|
- let read = libc::fread(b as *mutable c_void, 1u,
+ let read = libc::fread(b as *mut c_void, 1u,
len, self);
vec::unsafe::set_len(buf, read);
}
@@ -237,7 +237,7 @@ fn file_reader(path: str) -> result<reader, str> {
// Byte buffer readers
// TODO: const u8, but this fails with rustboot.
-type byte_buf = {buf: [u8], mutable pos: uint, len: uint};
+type byte_buf = {buf: [u8], mut pos: uint, len: uint};
impl of reader for byte_buf {
fn read_bytes(len: uint) -> [u8] {
@@ -268,7 +268,7 @@ fn bytes_reader(bytes: [u8]) -> reader {
}
fn bytes_reader_between(bytes: [u8], start: uint, end: uint) -> reader {
- {buf: bytes, mutable pos: start, len: end} as reader
+ {buf: bytes, mut pos: start, len: end} as reader
}
fn with_bytes_reader<t>(bytes: [u8], f: fn(reader) -> t) -> t {
@@ -514,14 +514,14 @@ fn stderr() -> writer { fd_writer(libc::STDERR_FILENO as c_int, false) }
fn print(s: str) { stdout().write_str(s); }
fn println(s: str) { stdout().write_line(s); }
-type mem_buffer = @{mutable buf: [mutable u8],
- mutable pos: uint};
+type mem_buffer = @{mut buf: [mut u8],
+ mut pos: uint};
impl of writer for mem_buffer {
fn write(v: [const u8]) {
// Fast path.
if self.pos == vec::len(self.buf) {
- for b: u8 in v { self.buf += [mutable b]; }
+ for b: u8 in v { self.buf += [mut b]; }
self.pos += vec::len(v);
ret;
}
@@ -531,7 +531,7 @@ impl of writer for mem_buffer {
while vpos < vlen {
let b = v[vpos];
if self.pos == vec::len(self.buf) {
- self.buf += [mutable b];
+ self.buf += [mut b];
} else { self.buf[self.pos] = b; }
self.pos += 1u;
vpos += 1u;
@@ -547,7 +547,7 @@ impl of writer for mem_buffer {
}
fn mem_buffer() -> mem_buffer {
- @{mutable buf: [mutable], mutable pos: 0u}
+ @{mut buf: [mut], mut pos: 0u}
}
fn mem_buffer_writer(b: mem_buffer) -> writer { b as writer }
fn mem_buffer_buf(b: mem_buffer) -> [u8] { vec::from_mut(b.buf) }
diff --git a/src/libcore/libc.rs b/src/libcore/libc.rs
index 912ab3a7429..9b04de10f48 100644
--- a/src/libcore/libc.rs
+++ b/src/libcore/libc.rs
@@ -346,17 +346,17 @@ mod types {
type LPCWSTR = *WCHAR;
type LPCSTR = *CHAR;
- type LPWSTR = *mutable WCHAR;
- type LPSTR = *mutable CHAR;
+ type LPWSTR = *mut WCHAR;
+ type LPSTR = *mut CHAR;
// Not really, but opaque to us.
type LPSECURITY_ATTRIBUTES = LPVOID;
- type LPVOID = *mutable c_void;
- type LPWORD = *mutable WORD;
+ type LPVOID = *mut c_void;
+ type LPWORD = *mut WORD;
type LRESULT = LONG_PTR;
- type PBOOL = *mutable BOOL;
+ type PBOOL = *mut BOOL;
type WCHAR = wchar_t;
type WORD = u16;
}
@@ -757,7 +757,7 @@ mod funcs {
fn setbuf(stream: *FILE, buf: *c_char);
// Omitted: printf and scanf variants.
fn fgetc(stream: *FILE) -> c_int;
- fn fgets(buf: *mutable c_char, n: c_int,
+ fn fgets(buf: *mut c_char, n: c_int,
stream: *FILE) -> *c_char;
fn fputc(c: c_int, stream: *FILE) -> c_int;
fn fputs(s: *c_char, stream: *FILE) -> *c_char;
@@ -769,7 +769,7 @@ mod funcs {
// Omitted: putc, putchar (might be macros).
fn puts(s: *c_char) -> c_int;
fn ungetc(c: c_int, stream: *FILE) -> c_int;
- fn fread(ptr: *mutable c_void, size: size_t,
+ fn fread(ptr: *mut c_void, size: size_t,
nobj: size_t, stream: *FILE) -> size_t;
fn fwrite(ptr: *c_void, size: size_t,
nobj: size_t, stream: *FILE) -> size_t;
@@ -933,11 +933,11 @@ mod funcs {
fn lseek(fd: c_int, offset: c_long, origin: c_int) -> c_long;
#[link_name = "_pipe"]
- fn pipe(fds: *mutable c_int, psize: c_uint,
+ fn pipe(fds: *mut c_int, psize: c_uint,
textmode: c_int) -> c_int;
#[link_name = "_read"]
- fn read(fd: c_int, buf: *mutable c_void, count: c_uint) -> c_int;
+ fn read(fd: c_int, buf: *mut c_void, count: c_uint) -> c_int;
#[link_name = "_rmdir"]
fn rmdir(path: *c_char) -> c_int;
@@ -1013,7 +1013,7 @@ mod funcs {
fn getegid() -> gid_t;
fn geteuid() -> uid_t;
fn getgid() -> gid_t ;
- fn getgroups(ngroups_max: c_int, groups: *mutable gid_t) -> c_int;
+ fn getgroups(ngroups_max: c_int, groups: *mut gid_t) -> c_int;
fn getlogin() -> *c_char;
fn getopt(argc: c_int, argv: **c_char, optstr: *c_char) -> c_int;
fn getpgrp() -> pid_t;
@@ -1025,8 +1025,8 @@ mod funcs {
fn lseek(fd: c_int, offset: off_t, whence: c_int) -> off_t;
fn pathconf(path: *c_char, name: c_int) -> c_long;
fn pause() -> c_int;
- fn pipe(fds: *mutable c_int) -> c_int;
- fn read(fd: c_int, buf: *mutable c_void,
+ fn pipe(fds: *mut c_int) -> c_int;
+ fn read(fd: c_int, buf: *mut c_void,
count: size_t) -> ssize_t;
fn rmdir(path: *c_char) -> c_int;
fn setgid(gid: gid_t) -> c_int;
@@ -1050,7 +1050,7 @@ mod funcs {
#[nolink]
#[abi = "cdecl"]
native mod unistd {
- fn readlink(path: *c_char, buf: *mutable c_char,
+ fn readlink(path: *c_char, buf: *mut c_char,
bufsz: size_t) -> ssize_t;
fn fsync(fd: c_int) -> c_int;
@@ -1067,7 +1067,7 @@ mod funcs {
#[nolink]
#[abi = "cdecl"]
native mod wait {
- fn waitpid(pid: pid_t, status: *mutable c_int,
+ fn waitpid(pid: pid_t, status: *mut c_int,
options: c_int) -> pid_t;
}
}
@@ -1096,15 +1096,15 @@ mod funcs {
native mod bsd44 {
fn sysctl(name: *c_int, namelen: c_uint,
- oldp: *mutable c_void, oldlenp: *mutable size_t,
+ oldp: *mut c_void, oldlenp: *mut size_t,
newp: *c_void, newlen: size_t) -> c_int;
fn sysctlbyname(name: *c_char,
- oldp: *mutable c_void, oldlenp: *mutable size_t,
+ oldp: *mut c_void, oldlenp: *mut size_t,
newp: *c_void, newlen: size_t) -> c_int;
- fn sysctlnametomib(name: *c_char, mibp: *mutable c_int,
- sizep: *mutable size_t) -> c_int;
+ fn sysctlnametomib(name: *c_char, mibp: *mut c_int,
+ sizep: *mut size_t) -> c_int;
}
@@ -1118,8 +1118,8 @@ mod funcs {
#[nolink]
#[abi = "cdecl"]
native mod extra {
- fn _NSGetExecutablePath(buf: *mutable c_char,
- bufsize: *mutable u32) -> c_int;
+ fn _NSGetExecutablePath(buf: *mut c_char,
+ bufsize: *mut u32) -> c_int;
}
#[cfg(target_os = "freebsd")]
diff --git a/src/libcore/option.rs b/src/libcore/option.rs
index f2aebc12d33..748683121d5 100644
--- a/src/libcore/option.rs
+++ b/src/libcore/option.rs
@@ -109,10 +109,10 @@ fn test_unwrap_str() {
#[test]
fn test_unwrap_resource() {
- resource r(i: @mutable int) {
+ resource r(i: @mut int) {
*i += 1;
}
- let i = @mutable 0;
+ let i = @mut 0;
{
let x = r(i);
let opt = some(x);
diff --git a/src/libcore/os.rs b/src/libcore/os.rs
index b9e290a9bb9..c69da22aa6f 100644
--- a/src/libcore/os.rs
+++ b/src/libcore/os.rs
@@ -61,7 +61,7 @@ fn as_c_charp<T>(s: str, f: fn(*c_char) -> T) -> T {
str::as_c_str(s) {|b| f(b as *c_char) }
}
-fn fill_charp_buf(f: fn(*mutable c_char, size_t) -> bool)
+fn fill_charp_buf(f: fn(*mut c_char, size_t) -> bool)
-> option<str> {
let buf = vec::to_mut(vec::from_elem(tmpbuf_sz, 0u8 as c_char));
vec::as_mut_buf(buf) { |b|
@@ -77,7 +77,7 @@ fn fill_charp_buf(f: fn(*mutable c_char, size_t) -> bool)
mod win32 {
import dword = libc::types::os::arch::extra::DWORD;
- fn fill_utf16_buf_and_decode(f: fn(*mutable u16, dword) -> dword)
+ fn fill_utf16_buf_and_decode(f: fn(*mut u16, dword) -> dword)
-> option<str> {
// FIXME: remove these when export globs work properly.
@@ -241,8 +241,8 @@ fn waitpid(pid: pid_t) -> c_int {
#[cfg(target_os = "freebsd")]
#[cfg(target_os = "macos")]
fn pipe() -> {in: c_int, out: c_int} {
- let fds = {mutable in: 0 as c_int,
- mutable out: 0 as c_int };
+ let fds = {mut in: 0 as c_int,
+ mut out: 0 as c_int };
assert (libc::pipe(ptr::mut_addr_of(fds.in)) == (0 as c_int));
ret {in: fds.in, out: fds.out};
}
@@ -258,8 +258,8 @@ fn pipe() -> {in: c_int, out: c_int} {
// understand. Here we explicitly make the pipe non-inheritable, which
// means to pass it to a subprocess they need to be duplicated first, as
// in rust_run_program.
- let fds = { mutable in: 0 as c_int,
- mutable out: 0 as c_int };
+ let fds = { mut in: 0 as c_int,
+ mut out: 0 as c_int };
let res = libc::pipe(ptr::mut_addr_of(fds.in),
1024 as c_uint,
(O_BINARY | O_NOINHERIT) as c_int);
@@ -294,7 +294,7 @@ fn self_exe_path() -> option<path> {
KERN_PROC as c_int,
KERN_PROC_PATHNAME as c_int, -1 as c_int];
sysctl(vec::unsafe::to_ptr(mib), vec::len(mib) as c_uint,
- buf as *mutable c_void, ptr::mut_addr_of(sz),
+ buf as *mut c_void, ptr::mut_addr_of(sz),
ptr::null(), 0u as size_t) == (0 as c_int)
}
}
diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs
index cf8f21969f5..a7bcfe5c9a8 100644
--- a/src/libcore/ptr.rs
+++ b/src/libcore/ptr.rs
@@ -28,9 +28,9 @@ native mod rusti {
#[inline(always)]
fn addr_of<T>(val: T) -> *T { rusti::addr_of(val) }
-#[doc = "Get an unsafe mutable pointer to a value"]
+#[doc = "Get an unsafe mut pointer to a value"]
#[inline(always)]
-fn mut_addr_of<T>(val: T) -> *mutable T unsafe {
+fn mut_addr_of<T>(val: T) -> *mut T unsafe {
unsafe::reinterpret_cast(rusti::addr_of(val))
}
@@ -40,10 +40,10 @@ fn offset<T>(ptr: *T, count: uint) -> *T unsafe {
(ptr as uint + count * sys::size_of::<T>()) as *T
}
-#[doc = "Calculate the offset from a mutable pointer"]
+#[doc = "Calculate the offset from a mut pointer"]
#[inline(always)]
-fn mut_offset<T>(ptr: *mutable T, count: uint) -> *mutable T {
- (ptr as uint + count * sys::size_of::<T>()) as *mutable T
+fn mut_offset<T>(ptr: *mut T, count: uint) -> *mut T {
+ (ptr as uint + count * sys::size_of::<T>()) as *mut T
}
@@ -77,16 +77,16 @@ unsafe fn memmove<T>(dst: *T, src: *T, count: uint) {
#[test]
fn test() unsafe {
- type pair = {mutable fst: int, mutable snd: int};
- let p = {mutable fst: 10, mutable snd: 20};
- let pptr: *mutable pair = mut_addr_of(p);
- let iptr: *mutable int = unsafe::reinterpret_cast(pptr);
+ type pair = {mut fst: int, mut snd: int};
+ let p = {mut fst: 10, mut snd: 20};
+ let pptr: *mut pair = mut_addr_of(p);
+ let iptr: *mut int = unsafe::reinterpret_cast(pptr);
assert (*iptr == 10);;
*iptr = 30;
assert (*iptr == 30);
assert (p.fst == 30);;
- *pptr = {mutable fst: 50, mutable snd: 60};
+ *pptr = {mut fst: 50, mut snd: 60};
assert (*iptr == 50);
assert (p.fst == 50);
assert (p.snd == 60);
diff --git a/src/libcore/run.rs b/src/libcore/run.rs
index 912b4419f51..e0812b2117d 100644
--- a/src/libcore/run.rs
+++ b/src/libcore/run.rs
@@ -198,10 +198,10 @@ fn start_program(prog: str, args: [str]) -> program {
libc::close(pipe_err.out);
type prog_repr = {pid: pid_t,
- mutable in_fd: c_int,
+ mut in_fd: c_int,
out_file: *libc::FILE,
err_file: *libc::FILE,
- mutable finished: bool};
+ mut finished: bool};
fn close_repr_input(r: prog_repr) {
let invalid_fd = -1i32;
@@ -233,10 +233,10 @@ fn start_program(prog: str, args: [str]) -> program {
fn destroy() { destroy_repr(*self); }
}
let repr = {pid: pid,
- mutable in_fd: pipe_input.out,
+ mut in_fd: pipe_input.out,
out_file: os::fdopen(pipe_output.in),
err_file: os::fdopen(pipe_err.in),
- mutable finished: false};
+ mut finished: false};
ret prog_res(repr) as program;
}
diff --git a/src/libcore/task.rs b/src/libcore/task.rs
index c6dfd326e03..dcd784fb2a3 100644
--- a/src/libcore/task.rs
+++ b/src/libcore/task.rs
@@ -157,8 +157,8 @@ Provides detailed control over the properties and behavior of new tasks.
// the run function move them in.
enum task_builder {
task_builder_({
- mutable opts: task_opts,
- mutable gen_body: fn@(+fn~()) -> fn~(),
+ mut opts: task_opts,
+ mut gen_body: fn@(+fn~()) -> fn~(),
can_not_copy: option<comm::port<()>>
})
}
@@ -187,8 +187,8 @@ fn task_builder() -> task_builder {
let body_identity = fn@(+body: fn~()) -> fn~() { body };
task_builder_({
- mutable opts: default_task_opts(),
- mutable gen_body: body_identity,
+ mut opts: default_task_opts(),
+ mut gen_body: body_identity,
can_not_copy: none
})
}
diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs
index c0bd70c270c..0f19a6c64ff 100644
--- a/src/libcore/vec.rs
+++ b/src/libcore/vec.rs
@@ -150,15 +150,15 @@ fn from_elem<T: copy>(n_elts: uint, t: T) -> [T] {
ret v;
}
-#[doc = "Produces a mutable vector from an immutable vector."]
-fn to_mut<T>(+v: [T]) -> [mutable T] unsafe {
+#[doc = "Produces a mut vector from an immutable vector."]
+fn to_mut<T>(+v: [T]) -> [mut T] unsafe {
let r = ::unsafe::reinterpret_cast(v);
::unsafe::forget(v);
r
}
-#[doc = "Produces an immutable vector from a mutable vector."]
-fn from_mut<T>(+v: [mutable T]) -> [T] unsafe {
+#[doc = "Produces an immutable vector from a mut vector."]
+fn from_mut<T>(+v: [mut T]) -> [T] unsafe {
let r = ::unsafe::reinterpret_cast(v);
::unsafe::forget(v);
r
@@ -396,7 +396,7 @@ Sets the element at position `index` to `val`. If `index` is past the end
of the vector, expands the vector by replicating `initval` to fill the
intervening space.
"]
-fn grow_set<T: copy>(&v: [mutable T], index: uint, initval: T, val: T) {
+fn grow_set<T: copy>(&v: [mut T], index: uint, initval: T, val: T) {
if index >= len(v) { grow(v, index - len(v) + 1u, initval); }
v[index] = val;
}
@@ -729,12 +729,12 @@ Swaps two elements in a vector
* a - The index of the first element
* b - The index of the second element
"]
-fn swap<T>(v: [mutable T], a: uint, b: uint) {
+fn swap<T>(v: [mut T], a: uint, b: uint) {
v[a] <-> v[b];
}
#[doc = "Reverse the order of elements in a vector, in place"]
-fn reverse<T>(v: [mutable T]) {
+fn reverse<T>(v: [mut T]) {
let mut i: uint = 0u;
let ln = len::<T>(v);
while i < ln / 2u { v[i] <-> v[ln - i - 1u]; i += 1u; }
@@ -890,8 +890,8 @@ fn as_buf<E,T>(v: [const E], f: fn(*E) -> T) -> T unsafe {
let buf = unsafe::to_ptr(v); f(buf)
}
-fn as_mut_buf<E,T>(v: [mutable E], f: fn(*mutable E) -> T) -> T unsafe {
- let buf = unsafe::to_ptr(v) as *mutable E; f(buf)
+fn as_mut_buf<E,T>(v: [mut E], f: fn(*mut E) -> T) -> T unsafe {
+ let buf = unsafe::to_ptr(v) as *mut E; f(buf)
}
#[doc = "An extension implementation providing a `len` method"]
@@ -905,7 +905,7 @@ impl vec_len<T> for [const T] {
mod unsafe {
// FIXME: This should have crate visibility
#[doc = "The internal representation of a vector"]
- type vec_repr = {mutable fill: uint, mutable alloc: uint, data: u8};
+ type vec_repr = {mut fill: uint, mut alloc: uint, data: u8};
#[doc = "
Constructs a vector from an unsafe pointer to a buffer
@@ -1212,7 +1212,7 @@ mod tests {
#[test]
fn test_grow_set() {
- let mut v = [mutable 1, 2, 3];
+ let mut v = [mut 1, 2, 3];
grow_set(v, 4u, 4, 5);
assert (len(v) == 5u);
assert (v[0] == 1);
@@ -1619,7 +1619,7 @@ mod tests {
#[test]
fn reverse_and_reversed() {
- let v: [mutable int] = [mutable 10, 20];
+ let v: [mut int] = [mut 10, 20];
assert (v[0] == 10);
assert (v[1] == 20);
reverse(v);
@@ -1634,13 +1634,13 @@ mod tests {
let v4 = reversed::<int>([]);
assert (v4 == []);
- let v3: [mutable int] = [mutable];
+ let v3: [mut int] = [mut];
reverse::<int>(v3);
}
#[test]
fn reversed_mut() {
- let v2 = reversed::<int>([mutable 10, 20]);
+ let v2 = reversed::<int>([mut 10, 20]);
assert (v2[0] == 20);
assert (v2[1] == 10);
}
diff --git a/src/libstd/bitv.rs b/src/libstd/bitv.rs
index 371f45cb7a9..37df940f6fb 100644
--- a/src/libstd/bitv.rs
+++ b/src/libstd/bitv.rs
@@ -22,7 +22,7 @@ export eq_vec;
// for the case where nbits <= 32.
#[doc = "The bitvector type"]
-type bitv = @{storage: [mutable uint], nbits: uint};
+type bitv = @{storage: [mut uint], nbits: uint};
const uint_bits: uint = 32u + (1u << 32u >> 27u);
diff --git a/src/libstd/c_vec.rs b/src/libstd/c_vec.rs
index 28ee44690ee..ce89f323cdc 100644
--- a/src/libstd/c_vec.rs
+++ b/src/libstd/c_vec.rs
@@ -4,7 +4,7 @@ Library to interface with chunks of memory allocated in C.
It is often desirable to safely interface with memory allocated from C,
encapsulating the unsafety into allocation and destruction time. Indeed,
allocating memory externally is currently the only way to give Rust shared
-mutable state with C programs that keep their own references; vectors are
+mut state with C programs that keep their own references; vectors are
unsuitable because they could be reallocated or moved at any time, and
importing C memory into a vector takes a one-time snapshot of the memory.
@@ -38,7 +38,7 @@ Wrapped in a enum for opacity; FIXME #818 when it is possible to have
truly opaque types, this should be revisited.
"]
enum c_vec<T> {
- c_vec_({ base: *mutable T, len: uint, rsrc: @dtor_res})
+ c_vec_({ base: *mut T, len: uint, rsrc: @dtor_res})
}
resource dtor_res(dtor: option<fn@()>) {
@@ -60,7 +60,7 @@ Create a `c_vec` from a native buffer with a given length.
* base - A native pointer to a buffer
* len - The number of elements in the buffer
"]
-unsafe fn c_vec<T>(base: *mutable T, len: uint) -> c_vec<T> {
+unsafe fn c_vec<T>(base: *mut T, len: uint) -> c_vec<T> {
ret c_vec_({
base: base,
len: len,
@@ -79,7 +79,7 @@ and a function to run upon destruction.
* dtor - A function to run when the value is destructed, useful
for freeing the buffer, etc.
"]
-unsafe fn c_vec_with_dtor<T>(base: *mutable T, len: uint, dtor: fn@())
+unsafe fn c_vec_with_dtor<T>(base: *mut T, len: uint, dtor: fn@())
-> c_vec<T> {
ret c_vec_({
base: base,
@@ -122,7 +122,7 @@ fn len<T>(t: c_vec<T>) -> uint {
}
#[doc = "Returns a pointer to the first element of the vector"]
-unsafe fn ptr<T>(t: c_vec<T>) -> *mutable T {
+unsafe fn ptr<T>(t: c_vec<T>) -> *mut T {
ret (*t).base;
}
@@ -135,7 +135,7 @@ mod tests {
assert mem as int != 0;
- ret unsafe { c_vec_with_dtor(mem as *mutable u8, n,
+ ret unsafe { c_vec_with_dtor(mem as *mut u8, n,
bind free(mem)) };
}
diff --git a/src/libstd/deque.rs b/src/libstd/deque.rs
index 749cefc5ba6..8a894a4b8f3 100644
--- a/src/libstd/deque.rs
+++ b/src/libstd/deque.rs
@@ -23,30 +23,30 @@ fn create<T: copy>() -> t<T> {
* Grow is only called on full elts, so nelts is also len(elts), unlike
* elsewhere.
*/
- fn grow<T: copy>(nelts: uint, lo: uint, elts: [mutable cell<T>]) ->
- [mutable cell<T>] {
+ fn grow<T: copy>(nelts: uint, lo: uint, elts: [mut cell<T>]) ->
+ [mut cell<T>] {
assert (nelts == vec::len(elts));
- let mut rv = [mutable];
+ let mut rv = [mut];
let mut i = 0u;
let nalloc = uint::next_power_of_two(nelts + 1u);
while i < nalloc {
if i < nelts {
- rv += [mutable elts[(lo + i) % nelts]];
- } else { rv += [mutable none]; }
+ rv += [mut elts[(lo + i) % nelts]];
+ } else { rv += [mut none]; }
i += 1u;
}
ret rv;
}
- fn get<T: copy>(elts: [mutable cell<T>], i: uint) -> T {
+ fn get<T: copy>(elts: [mut cell<T>], i: uint) -> T {
ret alt elts[i] { some(t) { t } _ { fail } };
}
- type repr<T> = {mutable nelts: uint,
- mutable lo: uint,
- mutable hi: uint,
- mutable elts: [mutable cell<T>]};
+ type repr<T> = {mut nelts: uint,
+ mut lo: uint,
+ mut hi: uint,
+ mut elts: [mut cell<T>]};
impl <T: copy> of t<T> for repr<T> {
fn size() -> uint { ret self.nelts; }
@@ -102,10 +102,10 @@ fn create<T: copy>() -> t<T> {
}
let repr: repr<T> = {
- mutable nelts: 0u,
- mutable lo: 0u,
- mutable hi: 0u,
- mutable elts: vec::to_mut(vec::from_elem(initial_capacity, none))
+ mut nelts: 0u,
+ mut lo: 0u,
+ mut hi: 0u,
+ mut elts: vec::to_mut(vec::from_elem(initial_capacity, none))
};
repr as t::<T>
}
diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs
index 40c44da8b45..91a9c244011 100644
--- a/src/libstd/ebml.rs
+++ b/src/libstd/ebml.rs
@@ -149,7 +149,7 @@ fn doc_as_i32(d: doc) -> i32 { doc_as_u32(d) as i32 }
fn doc_as_i64(d: doc) -> i64 { doc_as_u64(d) as i64 }
// ebml writing
-type writer = {writer: io::writer, mutable size_positions: [uint]};
+type writer = {writer: io::writer, mut size_positions: [uint]};
fn write_sized_vuint(w: io::writer, n: uint, size: uint) {
let buf: [u8] = alt size {
@@ -178,7 +178,7 @@ fn write_vuint(w: io::writer, n: uint) {
fn writer(w: io::writer) -> writer {
let size_positions: [uint] = [];
- ret {writer: w, mutable size_positions: size_positions};
+ ret {writer: w, mut size_positions: size_positions};
}
// TODO: Provide a function to write the standard ebml header.
@@ -361,11 +361,11 @@ impl serializer of serialization::serializer for ebml::writer {
fn emit_tup_elt(_idx: uint, f: fn()) { f() }
}
-type ebml_deserializer = {mutable parent: ebml::doc,
- mutable pos: uint};
+type ebml_deserializer = {mut parent: ebml::doc,
+ mut pos: uint};
fn ebml_deserializer(d: ebml::doc) -> ebml_deserializer {
- {mutable parent: d, mutable pos: d.start}
+ {mut parent: d, mut pos: d.start}
}
impl deserializer of serialization::deserializer for ebml_deserializer {
diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs
index 91f9c499ce1..3d921fb4d9d 100644
--- a/src/libstd/getopts.rs
+++ b/src/libstd/getopts.rs
@@ -114,7 +114,7 @@ enum optval { val(str), given, }
The result of checking command line arguments. Contains a vector
of matches and a vector of free strings.
"]
-type match = {opts: [opt], vals: [mutable [optval]], free: [str]};
+type match = {opts: [opt], vals: [mut [optval]], free: [str]};
fn is_arg(arg: str) -> bool {
ret str::len(arg) > 1u && arg[0] == '-' as u8;
diff --git a/src/libstd/json.rs b/src/libstd/json.rs
index 8f7765c4e02..b9931ba3f86 100644
--- a/src/libstd/json.rs
+++ b/src/libstd/json.rs
@@ -109,9 +109,9 @@ fn to_str(j: json) -> str {
type parser = {
rdr: io::reader,
- mutable ch: char,
- mutable line: uint,
- mutable col: uint,
+ mut ch: char,
+ mut line: uint,
+ mut col: uint,
};
impl parser for parser {
@@ -458,9 +458,9 @@ impl parser for parser {
fn from_reader(rdr: io::reader) -> result<json, error> {
let parser = {
rdr: rdr,
- mutable ch: rdr.read_char(),
- mutable line: 1u,
- mutable col: 1u,
+ mut ch: rdr.read_char(),
+ mut line: 1u,
+ mut col: 1u,
};
parser.parse()
diff --git a/src/libstd/list.rs b/src/libstd/list.rs
index ca3905dd246..bf2f51cf82d 100644
--- a/src/libstd/list.rs
+++ b/src/libstd/list.rs
@@ -164,7 +164,7 @@ mod tests {
#[test]
fn test_from_vec_mut() {
- let l = from_vec([mutable 0, 1, 2]);
+ let l = from_vec([mut 0, 1, 2]);
assert (head(l) == 0);
diff --git a/src/libstd/map.rs b/src/libstd/map.rs
index 5722789e64a..a35b51be900 100644
--- a/src/libstd/map.rs
+++ b/src/libstd/map.rs
@@ -71,8 +71,8 @@ mod chained {
type entry<K, V> = {
hash: uint,
key: K,
- mutable value: V,
- mutable next: chain<K, V>
+ mut value: V,
+ mut next: chain<K, V>
};
enum chain<K, V> {
@@ -81,8 +81,8 @@ mod chained {
}
type t<K, V> = @{
- mutable count: uint,
- mutable chains: [mutable chain<K,V>],
+ mut count: uint,
+ mut chains: [mut chain<K,V>],
hasher: hashfn<K>,
eqer: eqfn<K>
};
@@ -152,8 +152,8 @@ mod chained {
tbl.chains[idx] = present(@{
hash: hash,
key: k,
- mutable value: v,
- mutable next: old_chain});
+ mut value: v,
+ mut next: old_chain});
ret true;
}
found_first(_, entry) {
@@ -203,7 +203,7 @@ mod chained {
}
}
- fn chains<K: copy, V: copy>(nchains: uint) -> [mutable chain<K,V>] {
+ fn chains<K: copy, V: copy>(nchains: uint) -> [mut chain<K,V>] {
ret vec::to_mut(vec::from_elem(nchains, absent));
}
@@ -286,8 +286,8 @@ mod chained {
fn mk<K: copy, V: copy>(hasher: hashfn<K>, eqer: eqfn<K>) -> t<K,V> {
let initial_capacity: uint = 32u; // 2^5
- let slf: t<K, V> = @{mutable count: 0u,
- mutable chains: chains(initial_capacity),
+ let slf: t<K, V> = @{mut count: 0u,
+ mut chains: chains(initial_capacity),
hasher: hasher,
eqer: eqer};
slf
diff --git a/src/libstd/rope.rs b/src/libstd/rope.rs
index 2452188db24..735d273faa3 100644
--- a/src/libstd/rope.rs
+++ b/src/libstd/rope.rs
@@ -154,7 +154,7 @@ rope remains balanced. However, this function does not take any further
measure to ensure that the result is balanced.
"]
fn concat(v: [rope]) -> rope {
- //Copy `v` into a mutable vector
+ //Copy `v` into a mut vector
let mut len = vec::len(v);
if len == 0u { ret node::empty; }
let ropes = vec::to_mut(vec::from_elem(len, v[0]));
@@ -752,7 +752,7 @@ mod node {
* forest - The forest. This vector is progressively rewritten during
execution and should be discarded as meaningless afterwards.
"]
- fn tree_from_forest_destructive(forest: [mutable @node]) -> @node {
+ fn tree_from_forest_destructive(forest: [mut @node]) -> @node {
let mut i = 0u;
let mut len = vec::len(forest);
while len > 1u {
@@ -861,12 +861,12 @@ mod node {
fn bal(node: @node) -> option<@node> {
if height(node) < hint_max_node_height { ret option::none; }
//1. Gather all leaves as a forest
- let mut forest = [mutable];
+ let mut forest = [mut];
let it = leaf_iterator::start(node);
loop {
alt (leaf_iterator::next(it)) {
option::none { break; }
- option::some(x) { forest += [mutable @leaf(x)]; }
+ option::some(x) { forest += [mut @leaf(x)]; }
}
}
//2. Rebuild tree from forest
@@ -1117,20 +1117,20 @@ mod node {
mod leaf_iterator {
type t = {
- stack: [mutable @node],
- mutable stackpos: int
+ stack: [mut @node],
+ mut stackpos: int
};
fn empty() -> t {
- let stack : [mutable @node] = [mutable];
- ret {stack: stack, mutable stackpos: -1}
+ let stack : [mut @node] = [mut];
+ ret {stack: stack, mut stackpos: -1}
}
fn start(node: @node) -> t {
let stack = vec::to_mut(vec::from_elem(height(node)+1u, node));
ret {
stack: stack,
- mutable stackpos: 0
+ mut stackpos: 0
}
}
@@ -1157,23 +1157,23 @@ mod node {
mod char_iterator {
type t = {
leaf_iterator: leaf_iterator::t,
- mutable leaf: option<leaf>,
- mutable leaf_byte_pos: uint
+ mut leaf: option<leaf>,
+ mut leaf_byte_pos: uint
};
fn start(node: @node) -> t {
ret {
leaf_iterator: leaf_iterator::start(node),
- mutable leaf: option::none,
- mutable leaf_byte_pos: 0u
+ mut leaf: option::none,
+ mut leaf_byte_pos: 0u
}
}
fn empty() -> t {
ret {
leaf_iterator: leaf_iterator::empty(),
- mutable leaf: option::none,
- mutable leaf_byte_pos: 0u
+ mut leaf: option::none,
+ mut leaf_byte_pos: 0u
}
}
@@ -1242,8 +1242,8 @@ mod tests {
alt(r) {
node::empty { ret "" }
node::content(x) {
- let str = @mutable "";
- fn aux(str: @mutable str, node: @node::node) unsafe {
+ let str = @mut "";
+ fn aux(str: @mut str, node: @node::node) unsafe {
alt(*node) {
node::leaf(x) {
*str += str::slice(
@@ -1280,7 +1280,7 @@ mod tests {
#[test]
fn of_string2() {
- let buf = @ mutable "1234567890";
+ let buf = @ mut "1234567890";
let mut i = 0;
while i < 10 { *buf = *buf + *buf; i+=1;}
let sample = @*buf;
@@ -1313,7 +1313,7 @@ mod tests {
#[test]
fn iter1() {
- let buf = @ mutable "1234567890";
+ let buf = @ mut "1234567890";
let mut i = 0;
while i < 10 { *buf = *buf + *buf; i+=1;}
let sample = @*buf;
@@ -1334,7 +1334,7 @@ mod tests {
#[test]
fn bal1() {
let init = @ "1234567890";
- let buf = @ mutable * init;
+ let buf = @ mut * init;
let mut i = 0;
while i < 8 { *buf = *buf + *buf; i+=1;}
let sample = @*buf;
diff --git a/src/libstd/sha1.rs b/src/libstd/sha1.rs
index 4d5aabf705d..8e5f0cb122a 100644
--- a/src/libstd/sha1.rs
+++ b/src/libstd/sha1.rs
@@ -52,13 +52,13 @@ const k3: u32 = 0xCA62C1D6u32;
#[doc = "Construct a `sha` object"]
fn sha1() -> sha1 {
type sha1state =
- {h: [mutable u32],
- mutable len_low: u32,
- mutable len_high: u32,
- msg_block: [mutable u8],
- mutable msg_block_idx: uint,
- mutable computed: bool,
- work_buf: [mutable u32]};
+ {h: [mut u32],
+ mut len_low: u32,
+ mut len_high: u32,
+ msg_block: [mut u8],
+ mut msg_block_idx: uint,
+ mut computed: bool,
+ work_buf: [mut u32]};
fn add_input(st: sha1state, msg: [u8]) {
// FIXME: Should be typestate precondition
@@ -244,11 +244,11 @@ fn sha1() -> sha1 {
}
let st = {
h: vec::to_mut(vec::from_elem(digest_buf_len, 0u32)),
- mutable len_low: 0u32,
- mutable len_high: 0u32,
+ mut len_low: 0u32,
+ mut len_high: 0u32,
msg_block: vec::to_mut(vec::from_elem(msg_block_len, 0u8)),
- mutable msg_block_idx: 0u,
- mutable computed: false,
+ mut msg_block_idx: 0u,
+ mut computed: false,
work_buf: vec::to_mut(vec::from_elem(work_buf_len, 0u32))
};
let sh = st as sha1;
diff --git a/src/libstd/smallintmap.rs b/src/libstd/smallintmap.rs
index d58e0519387..a088cd52f68 100644
--- a/src/libstd/smallintmap.rs
+++ b/src/libstd/smallintmap.rs
@@ -7,12 +7,12 @@ import core::option::{some, none};
// FIXME: Should not be @; there's a bug somewhere in rustc that requires this
// to be.
-type smallintmap<T: copy> = @{mutable v: [mutable option<T>]};
+type smallintmap<T: copy> = @{mut v: [mut option<T>]};
#[doc = "Create a smallintmap"]
fn mk<T: copy>() -> smallintmap<T> {
- let v: [mutable option<T>] = [mutable];
- ret @{mutable v: v};
+ let v: [mut option<T>] = [mut];
+ ret @{mut v: v};
}
#[doc = "
diff --git a/src/libstd/sort.rs b/src/libstd/sort.rs
index 461dd1bab3a..8385158e93a 100644
--- a/src/libstd/sort.rs
+++ b/src/libstd/sort.rs
@@ -51,7 +51,7 @@ fn merge_sort<T: copy>(le: le<T>, v: [const T]) -> [T] {
}
}
-fn part<T: copy>(compare_func: le<T>, arr: [mutable T], left: uint,
+fn part<T: copy>(compare_func: le<T>, arr: [mut T], left: uint,
right: uint, pivot: uint) -> uint {
let pivot_value = arr[pivot];
arr[pivot] <-> arr[right];
@@ -68,7 +68,7 @@ fn part<T: copy>(compare_func: le<T>, arr: [mutable T], left: uint,
ret storage_index;
}
-fn qsort<T: copy>(compare_func: le<T>, arr: [mutable T], left: uint,
+fn qsort<T: copy>(compare_func: le<T>, arr: [mut T], left: uint,
right: uint) {
if right > left {
let pivot = (left + right) / 2u;
@@ -82,18 +82,18 @@ fn qsort<T: copy>(compare_func: le<T>, arr: [mutable T], left: uint,
}
#[doc = "
-Quicksort. Sorts a mutable vector in place.
+Quicksort. Sorts a mut vector in place.
Has worst case O(n^2) performance, average case O(n log n).
This is an unstable sort.
"]
-fn quick_sort<T: copy>(compare_func: le<T>, arr: [mutable T]) {
+fn quick_sort<T: copy>(compare_func: le<T>, arr: [mut T]) {
if len::<T>(arr) == 0u { ret; }
qsort::<T>(compare_func, arr, 0u, len::<T>(arr) - 1u);
}
fn qsort3<T: copy>(compare_func_lt: le<T>, compare_func_eq: le<T>,
- arr: [mutable T], left: int, right: int) {
+ arr: [mut T], left: int, right: int) {
if right <= left { ret; }
let v: T = arr[right];
let mut i: int = left - 1;
@@ -142,7 +142,7 @@ fn qsort3<T: copy>(compare_func_lt: le<T>, compare_func_eq: le<T>,
// FIXME: This should take lt and eq types
#[doc = "
-Fancy quicksort. Sorts a mutable vector in place.
+Fancy quicksort. Sorts a mut vector in place.
Based on algorithm presented by [Sedgewick and Bentley]
(http://www.cs.princeton.edu/~rs/talks/QuicksortIsOptimal.pdf).
@@ -152,7 +152,7 @@ According to these slides this is the algorithm of choice for
This is an unstable sort.
"]
fn quick_sort3<T: copy>(compare_func_lt: le<T>, compare_func_eq: le<T>,
- arr: [mutable T]) {
+ arr: [mut T]) {
if len::<T>(arr) == 0u { ret; }
qsort3::<T>(compare_func_lt, compare_func_eq, arr, 0,
(len::<T>(arr) as int) - 1);
@@ -160,7 +160,7 @@ fn quick_sort3<T: copy>(compare_func_lt: le<T>, compare_func_eq: le<T>,
#[cfg(test)]
mod test_qsort3 {
- fn check_sort(v1: [mutable int], v2: [mutable int]) {
+ fn check_sort(v1: [mut int], v2: [mut int]) {
let len = vec::len::<int>(v1);
fn lt(&&a: int, &&b: int) -> bool { ret a < b; }
fn equal(&&a: int, &&b: int) -> bool { ret a == b; }
@@ -178,24 +178,24 @@ mod test_qsort3 {
#[test]
fn test() {
{
- let v1 = [mutable 3, 7, 4, 5, 2, 9, 5, 8];
- let v2 = [mutable 2, 3, 4, 5, 5, 7, 8, 9];
+ let v1 = [mut 3, 7, 4, 5, 2, 9, 5, 8];
+ let v2 = [mut 2, 3, 4, 5, 5, 7, 8, 9];
check_sort(v1, v2);
}
{
- let v1 = [mutable 1, 1, 1];
- let v2 = [mutable 1, 1, 1];
+ let v1 = [mut 1, 1, 1];
+ let v2 = [mut 1, 1, 1];
check_sort(v1, v2);
}
{
- let v1: [mutable int] = [mutable];
- let v2: [mutable int] = [mutable];
+ let v1: [mut int] = [mut];
+ let v2: [mut int] = [mut];
check_sort(v1, v2);
}
- { let v1 = [mutable 9]; let v2 = [mutable 9]; check_sort(v1, v2); }
+ { let v1 = [mut 9]; let v2 = [mut 9]; check_sort(v1, v2); }
{
- let v1 = [mutable 9, 3, 3, 3, 9];
- let v2 = [mutable 3, 3, 3, 9, 9];
+ let v1 = [mut 9, 3, 3, 3, 9];
+ let v2 = [mut 3, 3, 3, 9, 9];
check_sort(v1, v2);
}
}
@@ -203,7 +203,7 @@ mod test_qsort3 {
#[cfg(test)]
mod test_qsort {
- fn check_sort(v1: [mutable int], v2: [mutable int]) {
+ fn check_sort(v1: [mut int], v2: [mut int]) {
let len = vec::len::<int>(v1);
fn leual(&&a: int, &&b: int) -> bool { ret a <= b; }
let f = leual;
@@ -219,24 +219,24 @@ mod test_qsort {
#[test]
fn test() {
{
- let v1 = [mutable 3, 7, 4, 5, 2, 9, 5, 8];
- let v2 = [mutable 2, 3, 4, 5, 5, 7, 8, 9];
+ let v1 = [mut 3, 7, 4, 5, 2, 9, 5, 8];
+ let v2 = [mut 2, 3, 4, 5, 5, 7, 8, 9];
check_sort(v1, v2);
}
{
- let v1 = [mutable 1, 1, 1];
- let v2 = [mutable 1, 1, 1];
+ let v1 = [mut 1, 1, 1];
+ let v2 = [mut 1, 1, 1];
check_sort(v1, v2);
}
{
- let v1: [mutable int] = [mutable];
- let v2: [mutable int] = [mutable];
+ let v1: [mut int] = [mut];
+ let v2: [mut int] = [mut];
check_sort(v1, v2);
}
- { let v1 = [mutable 9]; let v2 = [mutable 9]; check_sort(v1, v2); }
+ { let v1 = [mut 9]; let v2 = [mut 9]; check_sort(v1, v2); }
{
- let v1 = [mutable 9, 3, 3, 3, 9];
- let v2 = [mutable 3, 3, 3, 9, 9];
+ let v1 = [mut 9, 3, 3, 3, 9];
+ let v2 = [mut 3, 3, 3, 9, 9];
check_sort(v1, v2);
}
}
@@ -244,7 +244,7 @@ mod test_qsort {
// Regression test for #750
#[test]
fn test_simple() {
- let names = [mutable 2, 1, 3];
+ let names = [mut 2, 1, 3];
let expected = [1, 2, 3];
@@ -294,7 +294,7 @@ mod tests {
#[test]
fn test_merge_sort_mutable() {
fn le(&&a: int, &&b: int) -> bool { ret a <= b; }
- let v1 = [mutable 3, 2, 1];
+ let v1 = [mut 3, 2, 1];
let v2 = merge_sort(le, v1);
assert v2 == [1, 2, 3];
}
diff --git a/src/libstd/test.rs b/src/libstd/test.rs
index 271fac730ab..5847dea1e4e 100644
--- a/src/libstd/test.rs
+++ b/src/libstd/test.rs
@@ -88,11 +88,11 @@ enum test_result { tr_ok, tr_failed, tr_ignored, }
type console_test_state =
@{out: io::writer,
use_color: bool,
- mutable total: uint,
- mutable passed: uint,
- mutable failed: uint,
- mutable ignored: uint,
- mutable failures: [test_desc]};
+ mut total: uint,
+ mut passed: uint,
+ mut failed: uint,
+ mut ignored: uint,
+ mut failures: [test_desc]};
// A simple console test runner
fn run_tests_console(opts: test_opts,
@@ -131,11 +131,11 @@ fn run_tests_console(opts: test_opts,
let st =
@{out: io::stdout(),
use_color: use_color(),
- mutable total: 0u,
- mutable passed: 0u,
- mutable failed: 0u,
- mutable ignored: 0u,
- mutable failures: []};
+ mut total: 0u,
+ mut passed: 0u,
+ mut failed: 0u,
+ mut ignored: 0u,
+ mut failures: []};
run_tests(opts, tests, bind callback(_, st));
@@ -210,11 +210,11 @@ fn should_sort_failures_before_printing_them() {
let st =
@{out: writer,
use_color: false,
- mutable total: 0u,
- mutable passed: 0u,
- mutable failed: 0u,
- mutable ignored: 0u,
- mutable failures: [test_b, test_a]};
+ mut total: 0u,
+ mut passed: 0u,
+ mut failed: 0u,
+ mut ignored: 0u,
+ mut failures: [test_b, test_a]};
print_failures(st);
diff --git a/src/libstd/treemap.rs b/src/libstd/treemap.rs
index 54e38483a97..ebf532ab19d 100644
--- a/src/libstd/treemap.rs
+++ b/src/libstd/treemap.rs
@@ -15,17 +15,17 @@ export insert;
export find;
export traverse;
-type treemap<K, V> = @mutable tree_node<K, V>;
+type treemap<K, V> = @mut tree_node<K, V>;
enum tree_node<K, V> { empty, node(@K, @V, treemap<K, V>, treemap<K, V>) }
#[doc = "Create a treemap"]
-fn treemap<K, V>() -> treemap<K, V> { @mutable empty }
+fn treemap<K, V>() -> treemap<K, V> { @mut empty }
#[doc = "Insert a value into the map"]
fn insert<K: copy, V: copy>(m: treemap<K, V>, k: K, v: V) {
alt m {
- @empty { *m = node(@k, @v, @mutable empty, @mutable empty); }
+ @empty { *m = node(@k, @v, @mut empty, @mut empty); }
@node(@kk, _, _, _) {
// We have to name left and right individually, because
@@ -114,8 +114,8 @@ mod tests {
insert(m, 2, ());
insert(m, 1, ());
- let n = @mutable 0;
- fn t(n: @mutable int, &&k: int, &&_v: ()) {
+ let n = @mut 0;
+ fn t(n: @mut int, &&k: int, &&_v: ()) {
assert (*n == k); *n += 1;
}
traverse(m, bind t(n, _, _));
diff --git a/src/libstd/ufind.rs b/src/libstd/ufind.rs
index 53bdabfc203..555c0a0f212 100644
--- a/src/libstd/ufind.rs
+++ b/src/libstd/ufind.rs
@@ -8,13 +8,13 @@ import option::{some, none};
// than the node itself.
type node = option<uint>;
-type ufind = {mutable nodes: [mutable node]};
+type ufind = {mut nodes: [mut node]};
-fn make() -> ufind { ret {mutable nodes: [mutable]}; }
+fn make() -> ufind { ret {mut nodes: [mut]}; }
fn make_set(ufnd: ufind) -> uint {
let idx = vec::len(ufnd.nodes);
- ufnd.nodes += [mutable none::<uint>];
+ ufnd.nodes += [mut none::<uint>];
ret idx;
}
diff --git a/src/rustc/driver/diagnostic.rs b/src/rustc/driver/diagnostic.rs
index cb4d59e70a1..d76d0447b11 100644
--- a/src/rustc/driver/diagnostic.rs
+++ b/src/rustc/driver/diagnostic.rs
@@ -37,7 +37,7 @@ iface handler {
}
type handler_t = @{
- mutable err_count: uint,
+ mut err_count: uint,
_emit: emitter
};
@@ -127,7 +127,7 @@ fn mk_handler(emitter: option<emitter>) -> handler {
};
@{
- mutable err_count: 0u,
+ mut err_count: 0u,
_emit: emit
} as handler
}
diff --git a/src/rustc/driver/driver.rs b/src/rustc/driver/driver.rs
index a71c5dcb0ca..349c29a6f85 100644
--- a/src/rustc/driver/driver.rs
+++ b/src/rustc/driver/driver.rs
@@ -479,17 +479,17 @@ fn build_session_(
cstore: cstore,
parse_sess: @{
cm: codemap,
- mutable next_id: 1,
+ mut next_id: 1,
span_diagnostic: span_diagnostic_handler,
- mutable chpos: 0u,
- mutable byte_pos: 0u
+ mut chpos: 0u,
+ mut byte_pos: 0u
},
codemap: codemap,
// For a library crate, this is always none
- mutable main_fn: none,
+ mut main_fn: none,
span_diagnostic: span_diagnostic_handler,
filesearch: filesearch,
- mutable building_library: false,
+ mut building_library: false,
working_dir: os::getcwd()}
}
diff --git a/src/rustc/driver/session.rs b/src/rustc/driver/session.rs
index 79f9a44aaa0..d604db38e15 100644
--- a/src/rustc/driver/session.rs
+++ b/src/rustc/driver/session.rs
@@ -56,10 +56,10 @@ type session = @{targ_cfg: @config,
parse_sess: parse_sess,
codemap: codemap::codemap,
// For a library crate, this is always none
- mutable main_fn: option<(node_id, codemap::span)>,
+ mut main_fn: option<(node_id, codemap::span)>,
span_diagnostic: diagnostic::span_handler,
filesearch: filesearch::filesearch,
- mutable building_library: bool,
+ mut building_library: bool,
working_dir: str};
impl session for session {
diff --git a/src/rustc/front/attr.rs b/src/rustc/front/attr.rs
index 599da3811d1..0230baefdc1 100644
--- a/src/rustc/front/attr.rs
+++ b/src/rustc/front/attr.rs
@@ -198,8 +198,8 @@ fn sort_meta_items(items: [@ast::meta_item]) -> [@ast::meta_item] {
}
// This is sort of stupid here, converting to a vec of mutables and back
- let mut v: [mutable @ast::meta_item] = [mutable];
- for mi: @ast::meta_item in items { v += [mutable mi]; }
+ let mut v: [mut @ast::meta_item] = [mut];
+ for mi: @ast::meta_item in items { v += [mut mi]; }
std::sort::quick_sort(lteq, v);
diff --git a/src/rustc/front/test.rs b/src/rustc/front/test.rs
index 4af7e77bd87..d39936c10cc 100644
--- a/src/rustc/front/test.rs
+++ b/src/rustc/front/test.rs
@@ -19,8 +19,8 @@ type test = {span: span, path: [ast::ident], ignore: bool, should_fail: bool};
type test_ctxt =
@{sess: session::session,
crate: @ast::crate,
- mutable path: [ast::ident],
- mutable testfns: [test]};
+ mut path: [ast::ident],
+ mut testfns: [test]};
// Traverse the crate, collecting all the test functions, eliding any
// existing main functions, and synthesizing a main test harness
@@ -39,8 +39,8 @@ fn generate_test_harness(sess: session::session,
let cx: test_ctxt =
@{sess: sess,
crate: crate,
- mutable path: [],
- mutable testfns: []};
+ mut path: [],
+ mut testfns: []};
let precursor =
{fold_crate: fold::wrap(bind fold_crate(cx, _, _)),
diff --git a/src/rustc/metadata/astencode.rs b/src/rustc/metadata/astencode.rs
index 42f24b79851..51c97ef261e 100644
--- a/src/rustc/metadata/astencode.rs
+++ b/src/rustc/metadata/astencode.rs
@@ -234,8 +234,8 @@ fn visit_ids(item: ast::inlined_item, vfn: fn@(ast::node_id)) {
}
fn compute_id_range(item: ast::inlined_item) -> id_range {
- let min = @mutable int::max_value;
- let max = @mutable int::min_value;
+ let min = @mut int::max_value;
+ let max = @mut int::min_value;
visit_ids(item) {|id|
*min = int::min(*min, id);
*max = int::max(*max, id + 1);
@@ -684,7 +684,7 @@ fn encode_side_tables_for_ii(ecx: @e::encode_ctxt,
ebml_w.wr_tag(c::tag_table as uint) {||
visit_ids(ii, fn@(id: ast::node_id) {
// Note: this will cause a copy of ebml_w, which is bad as
- // it has mutable fields. But I believe it's harmless since
+ // it has mut fields. But I believe it's harmless since
// we generate balanced EBML.
encode_side_tables_for_id(ecx, ebml_w, id)
});
@@ -943,10 +943,10 @@ fn new_parse_sess() -> parser::parse_sess {
let handler = diagnostic::mk_handler(option::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
};
ret sess;
}
diff --git a/src/rustc/metadata/creader.rs b/src/rustc/metadata/creader.rs
index 92599591240..fa74efbc19c 100644
--- a/src/rustc/metadata/creader.rs
+++ b/src/rustc/metadata/creader.rs
@@ -21,7 +21,7 @@ export list_file_metadata;
fn read_crates(sess: session::session, crate: ast::crate) {
let e = @{sess: sess,
crate_cache: std::map::str_hash::<int>(),
- mutable next_crate_num: 1};
+ mut next_crate_num: 1};
let v =
visit::mk_simple_visitor(@{visit_view_item:
bind visit_view_item(e, _),
@@ -32,7 +32,7 @@ fn read_crates(sess: session::session, crate: ast::crate) {
type env = @{sess: session::session,
crate_cache: hashmap<str, int>,
- mutable next_crate_num: ast::crate_num};
+ mut next_crate_num: ast::crate_num};
fn visit_view_item(e: env, i: @ast::view_item) {
alt i.node {
diff --git a/src/rustc/metadata/cstore.rs b/src/rustc/metadata/cstore.rs
index 89e5343f6e4..36f2c28e74f 100644
--- a/src/rustc/metadata/cstore.rs
+++ b/src/rustc/metadata/cstore.rs
@@ -53,9 +53,9 @@ type cstore_private =
@{metas: map::hashmap<ast::crate_num, crate_metadata>,
use_crate_map: use_crate_map,
mod_path_map: mod_path_map,
- mutable used_crate_files: [str],
- mutable used_libraries: [str],
- mutable used_link_args: [str]};
+ mut used_crate_files: [str],
+ mut used_libraries: [str],
+ mut used_link_args: [str]};
// Map from node_id's of local use statements to crate numbers
type use_crate_map = map::hashmap<ast::node_id, ast::crate_num>;
@@ -70,9 +70,9 @@ fn mk_cstore() -> cstore {
ret private(@{metas: meta_cache,
use_crate_map: crate_map,
mod_path_map: mod_path_map,
- mutable used_crate_files: [],
- mutable used_libraries: [],
- mutable used_link_args: []});
+ mut used_crate_files: [],
+ mut used_libraries: [],
+ mut used_link_args: []});
}
fn get_crate_data(cstore: cstore, cnum: ast::crate_num) -> crate_metadata {
diff --git a/src/rustc/metadata/encoder.rs b/src/rustc/metadata/encoder.rs
index 37d7cb60078..a573d0214dc 100644
--- a/src/rustc/metadata/encoder.rs
+++ b/src/rustc/metadata/encoder.rs
@@ -283,7 +283,7 @@ fn encode_parent_item(ebml_w: ebml::writer, id: def_id) {
fn encode_enum_variant_info(ecx: @encode_ctxt, ebml_w: ebml::writer,
id: node_id, variants: [variant],
- path: ast_map::path, index: @mutable [entry<int>],
+ path: ast_map::path, index: @mut [entry<int>],
ty_params: [ty_param]) {
let mut disr_val = 0;
let mut i = 0;
@@ -362,9 +362,9 @@ fn encode_privacy(ebml_w: ebml::writer, privacy: privacy) {
fn encode_info_for_class(ecx: @encode_ctxt, ebml_w: ebml::writer,
id: node_id, path: ast_map::path,
items: [@class_item],
- global_index: @mutable[entry<int>])
+ global_index: @mut[entry<int>])
-> [entry<int>] {
- let index = @mutable [];
+ let index = @mut [];
let tcx = ecx.ccx.tcx;
for ci in items {
/* We encode both private and public fields -- need to include
@@ -466,14 +466,14 @@ fn should_inline(attrs: [attribute]) -> bool {
fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
- index: @mutable [entry<int>], path: ast_map::path) {
+ index: @mut [entry<int>], path: ast_map::path) {
let tcx = ecx.ccx.tcx;
let must_write = alt item.node { item_enum(_, _) { true } _ { false } };
if !must_write && !ecx.ccx.reachable.contains_key(item.id) { ret; }
fn add_to_index_(item: @item, ebml_w: ebml::writer,
- index: @mutable [entry<int>]) {
+ index: @mut [entry<int>]) {
*index += [{val: item.id, pos: ebml_w.writer.tell()}];
}
let add_to_index = bind add_to_index_(item, ebml_w, index);
@@ -678,7 +678,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
fn encode_info_for_native_item(ecx: @encode_ctxt, ebml_w: ebml::writer,
nitem: @native_item,
- index: @mutable [entry<int>],
+ index: @mut [entry<int>],
path: ast_map::path, abi: native_abi) {
if !ecx.ccx.reachable.contains_key(nitem.id) { ret; }
*index += [{val: nitem.id, pos: ebml_w.writer.tell()}];
@@ -704,7 +704,7 @@ fn encode_info_for_native_item(ecx: @encode_ctxt, ebml_w: ebml::writer,
fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: ebml::writer,
crate: @crate) -> [entry<int>] {
- let index = @mutable [];
+ let index = @mut [];
ebml_w.start_tag(tag_items_data);
*index += [{val: crate_node_id, pos: ebml_w.writer.tell()}];
encode_info_for_mod(ecx, ebml_w, crate.node.module,
@@ -752,15 +752,15 @@ fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: ebml::writer,
fn create_index<T: copy>(index: [entry<T>], hash_fn: fn@(T) -> uint) ->
[@[entry<T>]] {
- let mut buckets: [@mutable [entry<T>]] = [];
- uint::range(0u, 256u) {|_i| buckets += [@mutable []]; };
+ let mut buckets: [@mut [entry<T>]] = [];
+ uint::range(0u, 256u) {|_i| buckets += [@mut []]; };
for elt: entry<T> in index {
let h = hash_fn(elt.val);
*buckets[h % 256u] += [elt];
}
let mut buckets_frozen = [];
- for bucket: @mutable [entry<T>] in buckets {
+ for bucket: @mut [entry<T>] in buckets {
buckets_frozen += [@*bucket];
}
ret buckets_frozen;
@@ -901,9 +901,9 @@ fn encode_crate_deps(ebml_w: ebml::writer, cstore: cstore::cstore) {
type numname = {crate: crate_num, ident: str};
// Pull the cnums and names out of cstore
- let mut pairs: [mutable numname] = [mutable];
+ let mut pairs: [mut numname] = [mut];
cstore::iter_crate_data(cstore) {|key, val|
- pairs += [mutable {crate: key, ident: val.name}];
+ pairs += [mut {crate: key, ident: val.name}];
};
// Sort by cnum
@@ -919,7 +919,7 @@ fn encode_crate_deps(ebml_w: ebml::writer, cstore: cstore::cstore) {
// Return just the names
fn name(kv: numname) -> str { kv.ident }
- // mutable -> immutable hack for vec::map
+ // mut -> immutable hack for vec::map
let immpairs = vec::slice(pairs, 0u, vec::len(pairs));
ret vec::map(immpairs, name);
}
diff --git a/src/rustc/metadata/tydecode.rs b/src/rustc/metadata/tydecode.rs
index 3a925fdcb5e..920a4d71a46 100644
--- a/src/rustc/metadata/tydecode.rs
+++ b/src/rustc/metadata/tydecode.rs
@@ -17,7 +17,7 @@ export parse_bounds_data;
// Callback to translate defs to strs or back:
type conv_did = fn(ast::def_id) -> ast::def_id;
-type pstate = {data: @[u8], crate: int, mutable pos: uint, tcx: ty::ctxt};
+type pstate = {data: @[u8], crate: int, mut pos: uint, tcx: ty::ctxt};
fn peek(st: @pstate) -> char {
st.data[st.pos] as char
@@ -52,7 +52,7 @@ fn parse_ident_(st: @pstate, is_last: fn@(char) -> bool) ->
fn parse_ty_data(data: @[u8], crate_num: int, pos: uint, tcx: ty::ctxt,
conv: conv_did) -> ty::t {
- let st = @{data: data, crate: crate_num, mutable pos: pos, tcx: tcx};
+ let st = @{data: data, crate: crate_num, mut pos: pos, tcx: tcx};
parse_ty(st, conv)
}
@@ -416,7 +416,7 @@ fn parse_def_id(buf: [u8]) -> ast::def_id {
fn parse_bounds_data(data: @[u8], start: uint,
crate_num: int, tcx: ty::ctxt, conv: conv_did)
-> @[ty::param_bound] {
- let st = @{data: data, crate: crate_num, mutable pos: start, tcx: tcx};
+ let st = @{data: data, crate: crate_num, mut pos: start, tcx: tcx};
parse_bounds(st, conv)
}
diff --git a/src/rustc/middle/alias.rs b/src/rustc/middle/alias.rs
index fd6e7eb3ff2..32e5ef91524 100644
--- a/src/rustc/middle/alias.rs
+++ b/src/rustc/middle/alias.rs
@@ -30,11 +30,11 @@ type binding = @{node_id: node_id,
root_var: option<node_id>,
local_id: uint,
unsafe_tys: [unsafe_ty],
- mutable copied: copied};
+ mut copied: copied};
// FIXME it may be worthwhile to use a linked list of bindings instead
type scope = {bs: [binding],
- invalid: @mutable list<@invalid>};
+ invalid: @mut list<@invalid>};
fn mk_binding(cx: ctx, id: node_id, span: span, root_var: option<node_id>,
unsafe_tys: [unsafe_ty]) -> binding {
@@ -45,7 +45,7 @@ fn mk_binding(cx: ctx, id: node_id, span: span, root_var: option<node_id>,
ret @{node_id: id, span: span, root_var: root_var,
local_id: local_id_of_node(cx, id),
unsafe_tys: unsafe_tys,
- mutable copied: not_copied};
+ mut copied: not_copied};
}
enum local_info { local(uint), }
@@ -56,7 +56,7 @@ type ref_map = std::map::hashmap<node_id, node_id>;
type ctx = {tcx: ty::ctxt,
copy_map: copy_map,
ref_map: ref_map,
- mutable silent: bool};
+ mut silent: bool};
fn check_crate(tcx: ty::ctxt, crate: @ast::crate) -> (copy_map, ref_map) {
// Stores information about function arguments that's otherwise not easily
@@ -64,12 +64,12 @@ fn check_crate(tcx: ty::ctxt, crate: @ast::crate) -> (copy_map, ref_map) {
let cx = @{tcx: tcx,
copy_map: std::map::int_hash(),
ref_map: std::map::int_hash(),
- mutable silent: false};
+ mut silent: false};
let v = @{visit_fn: bind visit_fn(cx, _, _, _, _, _, _, _),
visit_expr: bind visit_expr(cx, _, _, _),
visit_block: bind visit_block(cx, _, _, _)
with *visit::default_visitor::<scope>()};
- let sc = {bs: [], invalid: @mutable list::nil};
+ let sc = {bs: [], invalid: @mut list::nil};
visit::visit_crate(*crate, sc, visit::mk_vt(v));
tcx.sess.abort_if_errors();
ret (cx.copy_map, cx.ref_map);
@@ -89,7 +89,7 @@ fn visit_fn(cx: @ctx, _fk: visit::fn_kind, decl: ast::fn_decl,
check_loop(*cx, sc) {|| v.visit_block(body, sc, v);}
}
ast::proto_box | ast::proto_uniq | ast::proto_bare {
- let sc = {bs: [], invalid: @mutable list::nil};
+ let sc = {bs: [], invalid: @mut list::nil};
v.visit_block(body, sc, v);
}
}
@@ -242,7 +242,7 @@ fn check_call(cx: ctx, sc: scope, f: @ast::expr, args: [@ast::expr])
root_var: root_var,
local_id: 0u,
unsafe_tys: unsafe_set(root.mutbl),
- mutable copied: arg_copied}];
+ mut copied: arg_copied}];
i += 1u;
}
let f_may_close =
@@ -291,7 +291,7 @@ fn check_call(cx: ctx, sc: scope, f: @ast::expr, args: [@ast::expr])
}
j += 1u;
}
- // Ensure we're not passing a root by mutable alias.
+ // Ensure we're not passing a root by mut alias.
for {node: node, arg: arg} in mut_roots {
let mut i = 0u;
@@ -301,7 +301,7 @@ fn check_call(cx: ctx, sc: scope, f: @ast::expr, args: [@ast::expr])
some(root) {
if node == root && cant_copy(cx, b) {
err(cx, args[arg].span,
- "passing a mutable reference to a \
+ "passing a mut reference to a \
variable that roots another reference");
break;
}
@@ -327,7 +327,7 @@ fn check_alt(cx: ctx, input: @ast::expr, arms: [ast::arm], sc: scope,
let pat_id_map = pat_util::pat_id_map(cx.tcx.def_map, a.pats[0]);
type info = {
id: node_id,
- mutable unsafe_tys: [unsafe_ty],
+ mut unsafe_tys: [unsafe_ty],
span: span};
let mut binding_info: [info] = [];
for pat in a.pats {
@@ -338,7 +338,7 @@ fn check_alt(cx: ctx, input: @ast::expr, arms: [ast::arm], sc: scope,
none {
binding_info += [
{id: canon_id,
- mutable unsafe_tys: unsafe_set(proot.mutbl),
+ mut unsafe_tys: unsafe_set(proot.mutbl),
span: proot.span}];
}
}
@@ -359,7 +359,7 @@ fn check_for(cx: ctx, local: @ast::local, seq: @ast::expr, blk: ast::blk,
sc: scope, v: vt<scope>) {
let root = expr_root(cx, seq, false);
- // If this is a mutable vector, don't allow it to be touched.
+ // If this is a mut vector, don't allow it to be touched.
let seq_t = ty::expr_ty(cx.tcx, seq);
let mut cur_mutbl = root.mutbl;
alt ty::get(seq_t).struct {
@@ -522,7 +522,7 @@ fn ty_can_unsafely_include(cx: ctx, needle: unsafe_ty, haystack: ty::t,
ty::ty_fn(_) | ty::ty_iface(_, _) { ret true; }
// A type param may include everything, but can only be
// treated as opaque downstream, and is thus safe unless we
- // saw mutable fields, in which case the whole thing can be
+ // saw mut fields, in which case the whole thing can be
// overwritten.
ty::ty_param(_, _) { ret mutbl; }
_ { ret false; }
diff --git a/src/rustc/middle/ast_map.rs b/src/rustc/middle/ast_map.rs
index d2186a27ee8..3b9a868776b 100644
--- a/src/rustc/middle/ast_map.rs
+++ b/src/rustc/middle/ast_map.rs
@@ -40,8 +40,8 @@ enum ast_node {
}
type map = std::map::hashmap<node_id, ast_node>;
-type ctx = {map: map, mutable path: path,
- mutable local_id: uint, sess: session};
+type ctx = {map: map, mut path: path,
+ mut local_id: uint, sess: session};
type vt = visit::vt<ctx>;
fn extend(cx: ctx, elt: str) -> @path {
@@ -63,8 +63,8 @@ fn mk_ast_map_visitor() -> vt {
fn map_crate(sess: session, c: crate) -> map {
let cx = {map: std::map::int_hash(),
- mutable path: [],
- mutable local_id: 0u,
+ mut path: [],
+ mut local_id: 0u,
sess: sess};
visit::visit_crate(c, cx, mk_ast_map_visitor());
ret cx.map;
@@ -81,8 +81,8 @@ fn map_decoded_item(sess: session, map: map, path: path, ii: inlined_item) {
// even if we did I think it only needs an ordering between local
// variables that are simultaneously in scope).
let cx = {map: map,
- mutable path: path,
- mutable local_id: 0u,
+ mut path: path,
+ mut local_id: 0u,
sess: sess};
let v = mk_ast_map_visitor();
diff --git a/src/rustc/middle/block_use.rs b/src/rustc/middle/block_use.rs
index 6646e1612c8..c0719e47ad3 100644
--- a/src/rustc/middle/block_use.rs
+++ b/src/rustc/middle/block_use.rs
@@ -2,10 +2,10 @@ import syntax::visit;
import syntax::ast::*;
import driver::session::session;
-type ctx = {tcx: ty::ctxt, mutable allow_block: bool};
+type ctx = {tcx: ty::ctxt, mut allow_block: bool};
fn check_crate(tcx: ty::ctxt, crate: @crate) {
- let cx = {tcx: tcx, mutable allow_block: false};
+ let cx = {tcx: tcx, mut allow_block: false};
let v = visit::mk_vt(@{visit_expr: visit_expr
with *visit::default_visitor()});
visit::visit_crate(*crate, cx, v);
diff --git a/src/rustc/middle/check_alt.rs b/src/rustc/middle/check_alt.rs
index 1a97b276afe..eacb5fef32c 100644
--- a/src/rustc/middle/check_alt.rs
+++ b/src/rustc/middle/check_alt.rs
@@ -101,8 +101,8 @@ fn check_exhaustive(tcx: ty::ctxt, sp: span, pats: [@pat]) {
vec::iter(cols) {|col| check_exhaustive(tcx, sp, col); }
}
ty::ty_rec(fs) {
- let cols = vec::from_elem(fs.len(), {mutable wild: false,
- mutable pats: []});
+ let cols = vec::from_elem(fs.len(), {mut wild: false,
+ mut pats: []});
for p in pats {
alt raw_pat(p).node {
pat_rec(sub, _) {
@@ -156,7 +156,7 @@ fn check_exhaustive_enum(tcx: ty::ctxt, enum_id: def_id, sp: span,
pats: [@pat]) {
let variants = enum_variants(tcx, enum_id);
let columns_by_variant = vec::map(*variants, {|v|
- {mutable seen: false,
+ {mut seen: false,
cols: vec::to_mut(vec::from_elem(v.args.len(), []))}
});
diff --git a/src/rustc/middle/freevars.rs b/src/rustc/middle/freevars.rs
index ad0f053884a..727cbac4f23 100644
--- a/src/rustc/middle/freevars.rs
+++ b/src/rustc/middle/freevars.rs
@@ -34,7 +34,7 @@ type freevar_map = hashmap<ast::node_id, freevar_info>;
fn collect_freevars(def_map: resolve::def_map, blk: ast::blk)
-> freevar_info {
let seen = int_hash();
- let refs = @mutable [];
+ let refs = @mut [];
fn ignore_item(_i: @ast::item, &&_depth: int, _v: visit::vt<int>) { }
diff --git a/src/rustc/middle/infer.rs b/src/rustc/middle/infer.rs
index c0692e7c4a5..71419128eb1 100644
--- a/src/rustc/middle/infer.rs
+++ b/src/rustc/middle/infer.rs
@@ -424,8 +424,8 @@ impl unify_methods for infer_ctxt {
alt b.mutbl {
ast::m_mutbl {
- // If supertype is mutable, subtype must match exactly
- // (i.e., invariant if mutable):
+ // If supertype is mut, subtype must match exactly
+ // (i.e., invariant if mut):
self.eq_tys(a.ty, b.ty)
}
ast::m_imm | ast::m_const {
@@ -751,7 +751,7 @@ impl resolve_methods for infer_ctxt {
}
}
- fn subst_vars(unresolved: @mutable option<int>,
+ fn subst_vars(unresolved: @mut option<int>,
vars_seen: std::list::list<int>,
vid: int) -> ty::t {
// Should really return a fixup_result instead of a t, but fold_ty
@@ -785,7 +785,7 @@ impl resolve_methods for infer_ctxt {
}
fn fixup_vars(typ: ty::t) -> fres<ty::t> {
- let unresolved = @mutable none::<int>;
+ let unresolved = @mut none::<int>;
let rty =
ty::fold_ty(self.tcx,
ty::fm_var(
@@ -802,7 +802,7 @@ impl resolve_methods for infer_ctxt {
}
}
- fn subst_regions(unresolved: @mutable option<int>,
+ fn subst_regions(unresolved: @mut option<int>,
regions_seen: std::list::list<int>,
rid: int) -> ty::region {
// Should really return a fixup_result instead of a t, but fold_ty
@@ -826,7 +826,7 @@ impl resolve_methods for infer_ctxt {
}
fn fixup_regions(typ: ty::t) -> fres<ty::t> {
- let unresolved = @mutable none::<int>;
+ let unresolved = @mut none::<int>;
let rty = ty::fold_ty(self.tcx, ty::fm_rptr({ |region, _under_rptr|
alt region {
ty::re_var(rid) {
@@ -1346,8 +1346,8 @@ impl of combine for glb {
mt_to_str(tcx, b));
alt (a.mutbl, b.mutbl) {
- // If one side or both is mutable, then the GLB must use
- // the precise type from the mutable side.
+ // If one side or both is mut, then the GLB must use
+ // the precise type from the mut side.
(ast::m_mutbl, ast::m_const) {
self.infcx().tys(a.ty, b.ty).then {||
ok({ty: a.ty, mutbl: ast::m_mutbl})
diff --git a/src/rustc/middle/last_use.rs b/src/rustc/middle/last_use.rs
index d4849abfb27..aaa452a89c2 100644
--- a/src/rustc/middle/last_use.rs
+++ b/src/rustc/middle/last_use.rs
@@ -38,7 +38,7 @@ enum block_type { func, lp, }
enum use { var_use(node_id), close_over(node_id), }
type set = [{def: node_id, uses: list<use>}];
-type bl = @{type: block_type, mutable second: bool, mutable exits: [set]};
+type bl = @{type: block_type, mut second: bool, mut exits: [set]};
enum use_id { path(node_id), close(node_id, node_id) }
fn hash_use_id(id: use_id) -> uint {
@@ -51,8 +51,8 @@ type ctx = {last_uses: std::map::hashmap<use_id, bool>,
ref_map: alias::ref_map,
tcx: ty::ctxt,
// The current set of local last uses
- mutable current: set,
- mutable blocks: list<bl>};
+ mut current: set,
+ mut blocks: list<bl>};
fn find_last_uses(c: @crate, def_map: resolve::def_map,
ref_map: alias::ref_map, tcx: ty::ctxt)
@@ -66,8 +66,8 @@ fn find_last_uses(c: @crate, def_map: resolve::def_map,
def_map: def_map,
ref_map: ref_map,
tcx: tcx,
- mutable current: [],
- mutable blocks: nil};
+ mut current: [],
+ mut blocks: nil};
visit::visit_crate(*c, cx, v);
let mini_table = std::map::int_hash();
cx.last_uses.items {|key, val|
@@ -268,7 +268,7 @@ fn visit_fn(fk: visit::fn_kind, decl: fn_decl, body: blk,
}
fn visit_block(tp: block_type, cx: ctx, visit: fn()) {
- let local = @{type: tp, mutable second: false, mutable exits: []};
+ let local = @{type: tp, mut second: false, mut exits: []};
cx.blocks = cons(local, @cx.blocks);
visit();
local.second = true;
diff --git a/src/rustc/middle/mutbl.rs b/src/rustc/middle/mutbl.rs
index 0c40305f14a..092afcdbedd 100644
--- a/src/rustc/middle/mutbl.rs
+++ b/src/rustc/middle/mutbl.rs
@@ -131,7 +131,7 @@ fn mk_err(cx: @ctx, span: syntax::codemap::span, msg: msg, name: str) {
cx.tcx.sess.span_err(span, alt msg {
msg_assign { "assigning to " + name }
msg_move_out { "moving out of " + name }
- msg_mutbl_ref { "passing " + name + " by mutable reference" }
+ msg_mutbl_ref { "passing " + name + " by mut reference" }
});
}
@@ -254,7 +254,7 @@ fn check_bind(cx: @ctx, f: @expr, args: [option<@expr>]) {
alt arg {
some(expr) {
let o_msg = alt ty::resolved_mode(cx.tcx, arg_ts[i].mode) {
- by_mutbl_ref { some("by mutable reference") }
+ by_mutbl_ref { some("by mut reference") }
by_move { some("by move") }
_ { none }
};
diff --git a/src/rustc/middle/resolve.rs b/src/rustc/middle/resolve.rs
index 9e9c28daf6a..712ccbf02af 100644
--- a/src/rustc/middle/resolve.rs
+++ b/src/rustc/middle/resolve.rs
@@ -35,7 +35,7 @@ enum scope {
scope_fn_expr(ast::fn_decl, node_id, [ast::ty_param]),
scope_native_item(@ast::native_item),
scope_loop(@ast::local), // there's only 1 decl per loop.
- scope_block(ast::blk, @mutable uint, @mutable uint),
+ scope_block(ast::blk, @mut uint, @mut uint),
scope_arm(ast::arm),
scope_method(node_id, [ast::ty_param]),
}
@@ -104,8 +104,8 @@ type glob_imp_def = {def: def, path: @ast::view_path};
type indexed_mod = {
m: option<ast::_mod>,
index: mod_index,
- mutable glob_imports: [glob_imp_def],
- mutable globbed_exports: [ident],
+ mut glob_imports: [glob_imp_def],
+ mut globbed_exports: [ident],
glob_imported_names: hashmap<str, glob_import_state>,
path: str
};
@@ -127,19 +127,19 @@ type env =
def_map: def_map,
ast_map: ast_map::map,
imports: hashmap<node_id, import_state>,
- mutable exp_map: exp_map,
+ mut exp_map: exp_map,
mod_map: hashmap<node_id, @indexed_mod>,
block_map: hashmap<node_id, [glob_imp_def]>,
ext_map: ext_map,
impl_map: impl_map,
impl_cache: impl_cache,
ext_cache: ext_hash,
- used_imports: {mutable track: bool,
- mutable data: [node_id]},
- mutable reported: [{ident: str, sc: scope}],
- mutable ignored_imports: [node_id],
- mutable current_tp: option<uint>,
- mutable resolve_unexported: bool,
+ used_imports: {mut track: bool,
+ mut data: [node_id]},
+ mut reported: [{ident: str, sc: scope}],
+ mut ignored_imports: [node_id],
+ mut current_tp: option<uint>,
+ mut resolve_unexported: bool,
sess: session};
@@ -171,18 +171,18 @@ fn create_env(sess: session, amap: ast_map::map) -> @env {
def_map: int_hash(),
ast_map: amap,
imports: int_hash(),
- mutable exp_map: int_hash(),
+ mut exp_map: int_hash(),
mod_map: int_hash(),
block_map: int_hash(),
ext_map: new_def_hash(),
impl_map: int_hash(),
impl_cache: new_def_hash(),
ext_cache: new_ext_hash(),
- used_imports: {mutable track: false, mutable data: []},
- mutable reported: [],
- mutable ignored_imports: [],
- mutable current_tp: none,
- mutable resolve_unexported: false,
+ used_imports: {mut track: false, mut data: []},
+ mut reported: [],
+ mut ignored_imports: [],
+ mut current_tp: none,
+ mut resolve_unexported: false,
sess: sess}
}
@@ -268,8 +268,8 @@ fn map_crate(e: @env, c: @ast::crate) {
e.mod_map.insert(i.id,
@{m: some(md),
index: index_mod(md),
- mutable glob_imports: [],
- mutable globbed_exports: [],
+ mut glob_imports: [],
+ mut globbed_exports: [],
glob_imported_names: str_hash(),
path: path_from_scope(sc, i.ident)});
}
@@ -277,8 +277,8 @@ fn map_crate(e: @env, c: @ast::crate) {
e.mod_map.insert(i.id,
@{m: none::<ast::_mod>,
index: index_nmod(nmd),
- mutable glob_imports: [],
- mutable globbed_exports: [],
+ mut glob_imports: [],
+ mut globbed_exports: [],
glob_imported_names: str_hash(),
path: path_from_scope(sc, i.ident)});
}
@@ -336,8 +336,8 @@ fn map_crate(e: @env, c: @ast::crate) {
e.mod_map.insert(ast::crate_node_id,
@{m: some(c.node.module),
index: index_mod(c.node.module),
- mutable glob_imports: [],
- mutable globbed_exports: [],
+ mut glob_imports: [],
+ mut globbed_exports: [],
glob_imported_names: str_hash(),
path: ""});
@@ -580,7 +580,7 @@ fn visit_fn_with_scope(e: @env, fk: visit::fn_kind, decl: ast::fn_decl,
}
fn visit_block_with_scope(b: ast::blk, sc: scopes, v: vt<scopes>) {
- let pos = @mutable 0u, loc = @mutable 0u;
+ let pos = @mut 0u, loc = @mut 0u;
let block_sc = cons(scope_block(b, pos, loc), @sc);
for vi in b.node.view_items { v.visit_view_item(vi, block_sc, v); }
for stmt in b.node.stmts {
@@ -594,7 +594,7 @@ fn visit_block_with_scope(b: ast::blk, sc: scopes, v: vt<scopes>) {
fn visit_decl_with_scope(d: @decl, sc: scopes, v: vt<scopes>) {
let loc_pos = alt list::head(sc) {
scope_block(_, _, pos) { pos }
- _ { @mutable 0u }
+ _ { @mut 0u }
};
alt d.node {
decl_local(locs) {
@@ -1894,11 +1894,11 @@ fn check_ty(e: @env, ty: @ast::ty, &&x: (), v: vt<()>) {
visit::visit_ty(ty, x, v);
}
-type checker = @{mutable seen: [ident], kind: str, sess: session};
+type checker = @{mut seen: [ident], kind: str, sess: session};
fn checker(e: env, kind: str) -> checker {
let seen: [ident] = [];
- ret @{mutable seen: seen, kind: kind, sess: e.sess};
+ ret @{mut seen: seen, kind: kind, sess: e.sess};
}
fn check_name(ch: checker, sp: span, name: ident) {
diff --git a/src/rustc/middle/trans/alt.rs b/src/rustc/middle/trans/alt.rs
index 8b8ee1fe81b..35294910923 100644
--- a/src/rustc/middle/trans/alt.rs
+++ b/src/rustc/middle/trans/alt.rs
@@ -640,9 +640,9 @@ fn trans_alt_inner(scope_cx: block, expr: @ast::expr, arms: [ast::arm],
let mk_fail = alt mode {
ast::alt_check {
// Cached fail-on-fallthrough block
- let fail_cx = @mutable none;
+ let fail_cx = @mut none;
fn mk_fail(bcx: block, sp: span,
- done: @mutable option<BasicBlockRef>) -> BasicBlockRef {
+ done: @mut option<BasicBlockRef>) -> BasicBlockRef {
alt *done { some(bb) { ret bb; } _ { } }
let fail_cx = sub_block(bcx, "case_fallthrough");
trans_fail(fail_cx, some(sp), "non-exhaustive match failure");;
diff --git a/src/rustc/middle/trans/base.rs b/src/rustc/middle/trans/base.rs
index 35a73a0a530..808a500814e 100644
--- a/src/rustc/middle/trans/base.rs
+++ b/src/rustc/middle/trans/base.rs
@@ -56,7 +56,7 @@ import std::smallintmap;
// destination of a computation's value.
enum dest {
- by_val(@mutable ValueRef),
+ by_val(@mut ValueRef),
save_in(ValueRef),
ignore,
}
@@ -69,8 +69,8 @@ fn dest_str(ccx: @crate_ctxt, d: dest) -> str {
}
}
-fn empty_dest_cell() -> @mutable ValueRef {
- ret @mutable llvm::LLVMGetUndef(T_nil());
+fn empty_dest_cell() -> @mut ValueRef {
+ ret @mut llvm::LLVMGetUndef(T_nil());
}
fn dup_for_join(dest: dest) -> dest {
@@ -454,9 +454,9 @@ fn declare_tydesc(ccx: @crate_ctxt, t: ty::t) -> @tydesc_info {
tydesc: gvar,
size: llsize,
align: llalign,
- mutable take_glue: none,
- mutable drop_glue: none,
- mutable free_glue: none};
+ mut take_glue: none,
+ mut drop_glue: none,
+ mut free_glue: none};
log(debug, "--- declare_tydesc " + ty_to_str(ccx.tcx, t));
ret info;
}
@@ -3516,11 +3516,11 @@ fn new_block(cx: fn_ctxt, parent: block_parent, kind: block_kind,
llvm::LLVMAppendBasicBlock(cx.llfn, buf)
});
let bcx = @{llbb: llbb,
- mutable terminated: false,
- mutable unreachable: false,
+ mut terminated: false,
+ mut unreachable: false,
parent: parent,
kind: kind,
- mutable block_span: block_span,
+ mut block_span: block_span,
fcx: cx};
alt parent {
parent_some(cx) {
@@ -3532,8 +3532,8 @@ fn new_block(cx: fn_ctxt, parent: block_parent, kind: block_kind,
}
fn simple_block_scope() -> block_kind {
- block_scope({is_loop: none, mutable cleanups: [],
- mutable cleanup_paths: [], mutable landing_pad: none})
+ block_scope({is_loop: none, mut cleanups: [],
+ mut cleanup_paths: [], mut landing_pad: none})
}
// Use this when you're at the top block of a function or the like.
@@ -3552,9 +3552,9 @@ fn loop_scope_block(bcx: block, _cont: loop_cont,
-> block {
ret new_block(bcx.fcx, parent_some(bcx), block_scope({
is_loop: some({cnt: _cont, brk: _break}),
- mutable cleanups: [],
- mutable cleanup_paths: [],
- mutable landing_pad: none
+ mut cleanups: [],
+ mut cleanup_paths: [],
+ mut landing_pad: none
}), n, some(sp));
}
@@ -3566,11 +3566,11 @@ fn sub_block(bcx: block, n: str) -> block {
fn raw_block(fcx: fn_ctxt, llbb: BasicBlockRef) -> block {
ret @{llbb: llbb,
- mutable terminated: false,
- mutable unreachable: false,
+ mut terminated: false,
+ mut unreachable: false,
parent: parent_none,
kind: block_non_scope,
- mutable block_span: none,
+ mut block_span: none,
fcx: fcx};
}
@@ -3775,11 +3775,11 @@ fn new_fn_ctxt_w_id(ccx: @crate_ctxt, path: path,
ret @{llfn: llfndecl,
llenv: llvm::LLVMGetParam(llfndecl, 1u as c_uint),
llretptr: llvm::LLVMGetParam(llfndecl, 0u as c_uint),
- mutable llstaticallocas: llbbs.sa,
- mutable llloadenv: llbbs.ca,
- mutable llreturn: llbbs.rt,
- mutable llself: none,
- mutable personality: none,
+ mut llstaticallocas: llbbs.sa,
+ mut llloadenv: llbbs.ca,
+ mut llreturn: llbbs.rt,
+ mut llself: none,
+ mut personality: none,
llargs: int_hash::<local_val>(),
lllocals: int_hash::<local_val>(),
llupvars: int_hash::<ValueRef>(),
@@ -4766,7 +4766,7 @@ fn trans_crate(sess: session::session, crate: @ast::crate, tcx: ty::ctxt,
exp_map: emap,
reachable: reachable,
item_symbols: int_hash::<str>(),
- mutable main_fn: none::<ValueRef>,
+ mut main_fn: none::<ValueRef>,
link_meta: link_meta,
enum_sizes: ty::new_ty_hash(),
discrims: ast_util::new_def_id_hash::<ValueRef>(),
@@ -4786,13 +4786,13 @@ fn trans_crate(sess: session::session, crate: @ast::crate, tcx: ty::ctxt,
tcx: tcx,
maps: maps,
stats:
- {mutable n_static_tydescs: 0u,
- mutable n_glues_created: 0u,
- mutable n_null_glues: 0u,
- mutable n_real_glues: 0u,
- llvm_insn_ctxt: @mutable [],
+ {mut n_static_tydescs: 0u,
+ mut n_glues_created: 0u,
+ mut n_null_glues: 0u,
+ mut n_real_glues: 0u,
+ llvm_insn_ctxt: @mut [],
llvm_insns: str_hash(),
- fn_times: @mutable []},
+ fn_times: @mut []},
upcalls:
upcall::declare_upcalls(targ_cfg, tn, tydesc_type,
llmod),
@@ -4806,7 +4806,7 @@ fn trans_crate(sess: session::session, crate: @ast::crate, tcx: ty::ctxt,
crate_map: crate_map,
dbg_cx: dbg_cx,
class_ctors: int_hash::<int>(),
- mutable do_not_commit_warning_issued: false};
+ mut do_not_commit_warning_issued: false};
{
diff --git a/src/rustc/middle/trans/common.rs b/src/rustc/middle/trans/common.rs
index 80c1895ed54..f68495b7561 100644
--- a/src/rustc/middle/trans/common.rs
+++ b/src/rustc/middle/trans/common.rs
@@ -22,7 +22,7 @@ import ast_map::path;
type namegen = fn@(str) -> str;
fn new_namegen() -> namegen {
- let i = @mutable 0;
+ let i = @mut 0;
ret fn@(prefix: str) -> str { *i += 1; prefix + int::str(*i) };
}
@@ -31,9 +31,9 @@ type tydesc_info =
tydesc: ValueRef,
size: ValueRef,
align: ValueRef,
- mutable take_glue: option<ValueRef>,
- mutable drop_glue: option<ValueRef>,
- mutable free_glue: option<ValueRef>};
+ mut take_glue: option<ValueRef>,
+ mut drop_glue: option<ValueRef>,
+ mut free_glue: option<ValueRef>};
/*
* A note on nomenclature of linking: "upcall", "extern" and "native".
@@ -52,13 +52,13 @@ type tydesc_info =
*/
type stats =
- {mutable n_static_tydescs: uint,
- mutable n_glues_created: uint,
- mutable n_null_glues: uint,
- mutable n_real_glues: uint,
- llvm_insn_ctxt: @mutable [str],
+ {mut n_static_tydescs: uint,
+ mut n_glues_created: uint,
+ mut n_null_glues: uint,
+ mut n_real_glues: uint,
+ llvm_insn_ctxt: @mut [str],
llvm_insns: hashmap<str, uint>,
- fn_times: @mutable [{ident: str, time: int}]};
+ fn_times: @mut [{ident: str, time: int}]};
resource BuilderRef_res(B: BuilderRef) { llvm::LLVMDisposeBuilder(B); }
@@ -85,7 +85,7 @@ type crate_ctxt = {
exp_map: resolve::exp_map,
reachable: reachable::map,
item_symbols: hashmap<ast::node_id, str>,
- mutable main_fn: option<ValueRef>,
+ mut main_fn: option<ValueRef>,
link_meta: link::link_meta,
enum_sizes: hashmap<ty::t, uint>,
discrims: hashmap<ast::def_id, ValueRef>,
@@ -122,7 +122,7 @@ type crate_ctxt = {
// Mapping from class constructors to parent class --
// used in base::trans_closure
class_ctors: hashmap<ast::node_id, ast::node_id>,
- mutable do_not_commit_warning_issued: bool};
+ mut do_not_commit_warning_issued: bool};
// Types used for llself.
type val_self_pair = {v: ValueRef, t: ty::t};
@@ -152,19 +152,19 @@ type fn_ctxt = @{
// the function, due to LLVM's quirks.
// A block for all the function's static allocas, so that LLVM
// will coalesce them into a single alloca call.
- mutable llstaticallocas: BasicBlockRef,
+ mut llstaticallocas: BasicBlockRef,
// A block containing code that copies incoming arguments to space
// already allocated by code in one of the llallocas blocks.
// (LLVM requires that arguments be copied to local allocas before
// allowing most any operation to be performed on them.)
- mutable llloadenv: BasicBlockRef,
- mutable llreturn: BasicBlockRef,
+ mut llloadenv: BasicBlockRef,
+ mut llreturn: BasicBlockRef,
// The 'self' value currently in use in this function, if there
// is one.
- mutable llself: option<val_self_pair>,
+ mut llself: option<val_self_pair>,
// The a value alloca'd for calls to upcalls.rust_personality. Used when
// outputting the resume instruction.
- mutable personality: option<ValueRef>,
+ mut personality: option<ValueRef>,
// Maps arguments to allocas created for them in llallocas.
llargs: hashmap<ast::node_id, local_val>,
@@ -294,12 +294,12 @@ type scope_info = {
// A list of functions that must be run at when leaving this
// block, cleaning up any variables that were introduced in the
// block.
- mutable cleanups: [cleanup],
+ mut cleanups: [cleanup],
// Existing cleanup paths that may be reused, indexed by destination and
// cleared when the set of cleanups changes.
- mutable cleanup_paths: [cleanup_path],
+ mut cleanup_paths: [cleanup_path],
// Unwinding landing pad. Also cleared when cleanups change.
- mutable landing_pad: option<BasicBlockRef>,
+ mut landing_pad: option<BasicBlockRef>,
};
// Basic block context. We create a block context for each basic block
@@ -314,14 +314,14 @@ type block = @{
// instructions into that block by way of this block context.
// The block pointing to this one in the function's digraph.
llbb: BasicBlockRef,
- mutable terminated: bool,
- mutable unreachable: bool,
+ mut terminated: bool,
+ mut unreachable: bool,
parent: block_parent,
// The 'kind' of basic block this is.
kind: block_kind,
// The source span where the block came from, if it is a block that
// actually appears in the source code.
- mutable block_span: option<span>,
+ mut block_span: option<span>,
// The function context for the function to which this block is
// attached.
fcx: fn_ctxt
diff --git a/src/rustc/middle/trans/debuginfo.rs b/src/rustc/middle/trans/debuginfo.rs
index 0896f9000f1..cbca8f63a52 100644
--- a/src/rustc/middle/trans/debuginfo.rs
+++ b/src/rustc/middle/trans/debuginfo.rs
@@ -366,8 +366,8 @@ type struct_ctxt = {
file: ValueRef,
name: str,
line: int,
- mutable members: [ValueRef],
- mutable total_size: int,
+ mut members: [ValueRef],
+ mut total_size: int,
align: int
};
@@ -382,8 +382,8 @@ fn create_structure(file: @metadata<file_md>, name: str, line: int)
let cx = @{file: file.node,
name: name,
line: line,
- mutable members: [],
- mutable total_size: 0,
+ mut members: [],
+ mut total_size: 0,
align: 64 //XXX different alignment per arch?
};
ret cx;
diff --git a/src/rustc/middle/trans/shape.rs b/src/rustc/middle/trans/shape.rs
index bcf73ca9774..a81caf11b36 100644
--- a/src/rustc/middle/trans/shape.rs
+++ b/src/rustc/middle/trans/shape.rs
@@ -23,10 +23,10 @@ import ty_ctxt = middle::ty::ctxt;
type res_info = {did: ast::def_id, tps: [ty::t]};
type ctxt =
- {mutable next_tag_id: u16,
+ {mut next_tag_id: u16,
pad: u16,
tag_id_to_index: hashmap<ast::def_id, u16>,
- mutable tag_order: [ast::def_id],
+ mut tag_order: [ast::def_id],
resources: interner::interner<res_info>,
llshapetablesty: TypeRef,
llshapetables: ValueRef};
@@ -126,8 +126,8 @@ fn largest_variants(ccx: @crate_ctxt, tag_id: ast::def_id) -> [uint] {
}
// Initialize the candidate set to contain all variants.
- let mut candidates = [mutable];
- for variant in *variants { candidates += [mutable true]; }
+ let mut candidates = [mut];
+ for variant in *variants { candidates += [mut true]; }
// Do a pairwise comparison among all variants still in the candidate set.
// Throw out any variant that we know has size and alignment at least as
@@ -269,10 +269,10 @@ fn mk_ctxt(llmod: ModuleRef) -> ctxt {
lib::llvm::llvm::LLVMAddGlobal(llmod, llshapetablesty, buf)
});
- ret {mutable next_tag_id: 0u16,
+ ret {mut next_tag_id: 0u16,
pad: 0u16,
tag_id_to_index: common::new_def_hash(),
- mutable tag_order: [],
+ mut tag_order: [],
resources: interner::mk(hash_res_info, {|a, b| a == b}),
llshapetablesty: llshapetablesty,
llshapetables: llshapetables};
diff --git a/src/rustc/middle/trans/type_use.rs b/src/rustc/middle/trans/type_use.rs
index f347d4e3320..61b09f0e01c 100644
--- a/src/rustc/middle/trans/type_use.rs
+++ b/src/rustc/middle/trans/type_use.rs
@@ -29,7 +29,7 @@ const use_repr: uint = 1u; // Dependency on size/alignment and take/drop glue
const use_tydesc: uint = 2u; // Takes the tydesc, or compares
type ctx = {ccx: @crate_ctxt,
- uses: [mutable type_uses]};
+ uses: [mut type_uses]};
fn type_uses_for(ccx: @crate_ctxt, fn_id: def_id, n_tps: uint)
-> [type_uses] {
diff --git a/src/rustc/middle/tstate/annotate.rs b/src/rustc/middle/tstate/annotate.rs
index d4271693112..3693f22d6e2 100644
--- a/src/rustc/middle/tstate/annotate.rs
+++ b/src/rustc/middle/tstate/annotate.rs
@@ -7,11 +7,11 @@ import aux::{num_constraints, get_fn_info, crate_ctxt, add_node};
import ann::empty_ann;
import pat_util::pat_binding_ids;
-fn collect_ids_expr(e: @expr, rs: @mutable [node_id]) { *rs += [e.id]; }
+fn collect_ids_expr(e: @expr, rs: @mut [node_id]) { *rs += [e.id]; }
-fn collect_ids_block(b: blk, rs: @mutable [node_id]) { *rs += [b.node.id]; }
+fn collect_ids_block(b: blk, rs: @mut [node_id]) { *rs += [b.node.id]; }
-fn collect_ids_stmt(s: @stmt, rs: @mutable [node_id]) {
+fn collect_ids_stmt(s: @stmt, rs: @mut [node_id]) {
alt s.node {
stmt_decl(_, id) | stmt_expr(_, id) | stmt_semi(_, id) {
log(debug, "node_id " + int::str(id));
@@ -22,11 +22,11 @@ fn collect_ids_stmt(s: @stmt, rs: @mutable [node_id]) {
}
}
-fn collect_ids_local(tcx: ty::ctxt, l: @local, rs: @mutable [node_id]) {
+fn collect_ids_local(tcx: ty::ctxt, l: @local, rs: @mut [node_id]) {
*rs += pat_binding_ids(tcx.def_map, l.node.pat);
}
-fn node_ids_in_fn(tcx: ty::ctxt, body: blk, rs: @mutable [node_id]) {
+fn node_ids_in_fn(tcx: ty::ctxt, body: blk, rs: @mut [node_id]) {
let collect_ids =
visit::mk_simple_visitor(@{visit_expr: bind collect_ids_expr(_, rs),
visit_block: bind collect_ids_block(_, rs),
@@ -45,7 +45,7 @@ fn init_vecs(ccx: crate_ctxt, node_ids: [node_id], len: uint) {
}
fn visit_fn(ccx: crate_ctxt, num_constraints: uint, body: blk) {
- let node_ids: @mutable [node_id] = @mutable [];
+ let node_ids: @mut [node_id] = @mut [];
node_ids_in_fn(ccx.tcx, body, node_ids);
let node_id_vec = *node_ids;
init_vecs(ccx, node_id_vec, num_constraints);
diff --git a/src/rustc/middle/tstate/auxiliary.rs b/src/rustc/middle/tstate/auxiliary.rs
index c973d15b40d..c568d1f0cfe 100644
--- a/src/rustc/middle/tstate/auxiliary.rs
+++ b/src/rustc/middle/tstate/auxiliary.rs
@@ -200,9 +200,9 @@ type constr_arg_use = spanned<constr_arg_general_<inst>>;
enum constraint {
cinit(uint, span, ident),
- // FIXME: really only want it to be mutable during collect_locals.
+ // FIXME: really only want it to be mut during collect_locals.
// freeze it after that.
- cpred(@path, @mutable [pred_args]),
+ cpred(@path, @mut [pred_args]),
}
// An ninit variant has a node_id because it refers to a local var.
@@ -261,7 +261,7 @@ type fn_info =
cf: ret_style,
i_return: tsconstr,
i_diverge: tsconstr,
- used_vars: @mutable [node_id]};
+ used_vars: @mut [node_id]};
fn tsconstr_to_def_id(t: tsconstr) -> def_id {
alt t { ninit(id, _) { local_def(id) } npred(_, id, _) { id } }
@@ -275,7 +275,7 @@ fn tsconstr_to_node_id(t: tsconstr) -> node_id {
}
/* mapping from node ID to typestate annotation */
-type node_ann_table = @mutable [mutable ts_ann];
+type node_ann_table = @mut [mut ts_ann];
/* mapping from function name to fn_info map */
@@ -483,8 +483,8 @@ fn pure_exp(ccx: crate_ctxt, id: node_id, p: prestate) -> bool {
fn num_constraints(m: fn_info) -> uint { ret m.num_constraints; }
fn new_crate_ctxt(cx: ty::ctxt) -> crate_ctxt {
- let na: [mutable ts_ann] = [mutable];
- ret {tcx: cx, node_anns: @mutable na, fm: int_hash::<fn_info>()};
+ let na: [mut ts_ann] = [mut];
+ ret {tcx: cx, node_anns: @mut na, fm: int_hash::<fn_info>()};
}
/* Use e's type to determine whether it returns.
@@ -549,7 +549,7 @@ fn constraints(fcx: fn_ctxt) -> [norm_constraint] {
// FIXME
// Would rather take an immutable vec as an argument,
// should freeze it at some earlier point.
-fn match_args(fcx: fn_ctxt, occs: @mutable [pred_args],
+fn match_args(fcx: fn_ctxt, occs: @mut [pred_args],
occ: [@constr_arg_use]) -> uint {
#debug("match_args: looking at %s",
constr_args_to_str(fn@(i: inst) -> str { ret i.ident; }, occ));
@@ -995,7 +995,7 @@ fn args_mention<T>(args: [@constr_arg_use],
fn use_var(fcx: fn_ctxt, v: node_id) { *fcx.enclosing.used_vars += [v]; }
// FIXME: This should be a function in vec::.
-fn vec_contains(v: @mutable [node_id], i: node_id) -> bool {
+fn vec_contains(v: @mut [node_id], i: node_id) -> bool {
for d: node_id in *v { if d == i { ret true; } }
ret false;
}
diff --git a/src/rustc/middle/tstate/collect_locals.rs b/src/rustc/middle/tstate/collect_locals.rs
index c0532c8222f..90099df6492 100644
--- a/src/rustc/middle/tstate/collect_locals.rs
+++ b/src/rustc/middle/tstate/collect_locals.rs
@@ -10,7 +10,7 @@ import driver::session::session;
import aux::*;
import std::map::hashmap;
-type ctxt = {cs: @mutable [sp_constr], tcx: ty::ctxt};
+type ctxt = {cs: @mut [sp_constr], tcx: ty::ctxt};
fn collect_local(loc: @local, cx: ctxt, v: visit::vt<ctxt>) {
pat_bindings(cx.tcx.def_map, loc.node.pat) {|p_id, _s, id|
@@ -46,7 +46,7 @@ fn find_locals(tcx: ty::ctxt,
f_body: blk,
sp: span,
id: node_id) -> ctxt {
- let cx: ctxt = {cs: @mutable [], tcx: tcx};
+ let cx: ctxt = {cs: @mut [], tcx: tcx};
let visitor = visit::default_visitor::<ctxt>();
let visitor =
@{visit_local: collect_local,
@@ -78,8 +78,8 @@ fn add_constraint(tcx: ty::ctxt, c: sp_constr, next: uint, tbl: constr_map) ->
}
}
none {
- let rslt: @mutable [pred_args] =
- @mutable [respan(c.span, {args: args, bit_num: next})];
+ let rslt: @mut [pred_args] =
+ @mut [respan(c.span, {args: args, bit_num: next})];
tbl.insert(d_id, cpred(p, rslt));
}
}
@@ -141,7 +141,7 @@ fn mk_fn_info(ccx: crate_ctxt,
next = add_constraint(cx.tcx, respan(f_sp, diverges_constr), next,
res_map);
- let v: @mutable [node_id] = @mutable [];
+ let v: @mut [node_id] = @mut [];
let rslt =
{constrs: res_map,
num_constraints: next,
diff --git a/src/rustc/middle/ty.rs b/src/rustc/middle/ty.rs
index deeef4f6826..a2796c94244 100644
--- a/src/rustc/middle/ty.rs
+++ b/src/rustc/middle/ty.rs
@@ -186,7 +186,7 @@ enum borrowing {
type ctxt =
@{interner: hashmap<intern_key, t_box>,
- mutable next_id: uint,
+ mut next_id: uint,
sess: session::session,
def_map: resolve::def_map,
region_map: @middle::region::region_map,
@@ -373,7 +373,7 @@ fn mk_ctxt(s: session::session, dm: resolve::def_map, amap: ast_map::map,
option::maybe(k.o_def_id, 0u, ast_util::hash_def_id)
}, {|&&a, &&b| a == b});
@{interner: interner,
- mutable next_id: 0u,
+ mut next_id: 0u,
sess: s,
def_map: dm,
region_map: region_map,
@@ -1027,7 +1027,7 @@ fn type_structurally_contains(cx: ctxt, ty: t, test: fn(sty) -> bool) ->
}
// Returns true for noncopyable types and types where a copy of a value can be
-// distinguished from the value itself. I.e. types with mutable content that's
+// distinguished from the value itself. I.e. types with mut content that's
// not shared through a pointer.
fn type_allows_implicit_copy(cx: ctxt, ty: t) -> bool {
ret !type_structurally_contains(cx, ty, {|sty|
@@ -2064,7 +2064,7 @@ fn class_field_tys(items: [@class_item]) -> [field_ty] {
fn class_items_as_fields(cx:ctxt, did: ast::def_id) -> [field] {
let mut rslt = [];
for f in lookup_class_fields(cx, did) {
- // consider all instance vars mutable, because the
+ // consider all instance vars mut, because the
// constructor may mutate all vars
rslt += [{ident: f.ident, mt: {ty: lookup_field_type(cx, did, f.id),
mutbl: m_mutbl}}];
diff --git a/src/rustc/middle/typeck.rs b/src/rustc/middle/typeck.rs
index 8ef8841754c..3fb2c67509a 100644
--- a/src/rustc/middle/typeck.rs
+++ b/src/rustc/middle/typeck.rs
@@ -51,7 +51,7 @@ type ty_table = hashmap<ast::def_id, ty::t>;
// Used for typechecking the methods of an impl
enum self_info { self_impl(ty::t) }
-type crate_ctxt = {mutable self_infos: [self_info],
+type crate_ctxt = {mut self_infos: [self_info],
impl_map: resolve::impl_map,
method_map: method_map,
vtable_map: vtable_map,
@@ -75,7 +75,7 @@ type fn_ctxt =
proto: ast::proto,
infcx: infer::infer_ctxt,
locals: hashmap<ast::node_id, int>,
- next_var_id: @mutable int,
+ next_var_id: @mut int,
ccx: @crate_ctxt};
@@ -1244,13 +1244,13 @@ mod demand {
ty_param_substs_0: [ty::t]) ->
ty_param_substs_and_ty {
- let mut ty_param_substs: [mutable ty::t] = [mutable];
+ let mut ty_param_substs: [mut ty::t] = [mut];
let mut ty_param_subst_var_ids: [int] = [];
for ty_param_subst: ty::t in ty_param_substs_0 {
// Generate a type variable and unify it with the type parameter
// substitution. We will then pull out these type variables.
let t_0 = next_ty_var(fcx);
- ty_param_substs += [mutable t_0];
+ ty_param_substs += [mut t_0];
ty_param_subst_var_ids += [ty::ty_var_id(t_0)];
simple(fcx, sp, ty_param_subst, t_0);
}
@@ -1383,7 +1383,7 @@ mod writeback {
type wb_ctxt =
// As soon as we hit an error we have to stop resolving
// the entire function
- {fcx: @fn_ctxt, mutable success: bool};
+ {fcx: @fn_ctxt, mut success: bool};
type wb_vt = visit::vt<wb_ctxt>;
fn visit_stmt(s: @ast::stmt, wbcx: wb_ctxt, v: wb_vt) {
@@ -1461,7 +1461,7 @@ mod writeback {
}
fn resolve_type_vars_in_expr(fcx: @fn_ctxt, e: @ast::expr) -> bool {
- let wbcx = {fcx: fcx, mutable success: true};
+ let wbcx = {fcx: fcx, mut success: true};
let visit =
visit::mk_vt(@{visit_item: visit_item,
visit_stmt: visit_stmt,
@@ -1475,7 +1475,7 @@ mod writeback {
}
fn resolve_type_vars_in_block(fcx: @fn_ctxt, blk: ast::blk) -> bool {
- let wbcx = {fcx: fcx, mutable success: true};
+ let wbcx = {fcx: fcx, mut success: true};
let visit =
visit::mk_vt(@{visit_item: visit_item,
visit_stmt: visit_stmt,
@@ -1536,7 +1536,7 @@ fn check_intrinsic_type(tcx: ty::ctxt, it: @ast::native_item) {
type gather_result =
{infcx: infer::infer_ctxt,
locals: hashmap<ast::node_id, int>,
- next_var_id: @mutable int};
+ next_var_id: @mut int};
// Used only as a helper for check_fn.
fn gather_locals(ccx: @crate_ctxt,
@@ -1548,7 +1548,7 @@ fn gather_locals(ccx: @crate_ctxt,
none {
{infcx: infer::new_infer_ctxt(ccx.tcx),
locals: int_hash::<int>(),
- nvi: @mutable 0}
+ nvi: @mut 0}
}
some(fcx) {
{infcx: fcx.infcx,
@@ -2544,7 +2544,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier,
// const versions of the vectors in L and R. Next, let T be a
// fresh type variable where TL <: T and TR <: T. Then the result
// type is a fresh type variable T1 where T1 <: [const T]. This
- // allows the result to be either a mutable or immutable vector,
+ // allows the result to be either a mut or immutable vector,
// depending on external demands.
let const_vec_t =
ty::mk_vec(tcx, {ty: next_ty_var(fcx),
@@ -3370,7 +3370,7 @@ fn check_const(ccx: @crate_ctxt, _sp: span, e: @ast::expr, id: ast::node_id) {
proto: ast::proto_box,
infcx: infer::new_infer_ctxt(ccx.tcx),
locals: int_hash::<int>(),
- next_var_id: @mutable 0,
+ next_var_id: @mut 0,
ccx: ccx};
check_expr(fcx, e);
let cty = expr_ty(fcx.ccx.tcx, e);
@@ -3389,7 +3389,7 @@ fn check_enum_variants(ccx: @crate_ctxt, sp: span, vs: [ast::variant],
proto: ast::proto_box,
infcx: infer::new_infer_ctxt(ccx.tcx),
locals: int_hash::<int>(),
- next_var_id: @mutable 0,
+ next_var_id: @mut 0,
ccx: ccx};
let mut disr_vals: [int] = [];
let mut disr_val = 0;
@@ -3950,7 +3950,7 @@ fn check_crate(tcx: ty::ctxt, impl_map: resolve::impl_map,
crate: @ast::crate) -> (method_map, vtable_map) {
collect::collect_item_types(tcx, crate);
- let ccx = @{mutable self_infos: [],
+ let ccx = @{mut self_infos: [],
impl_map: impl_map,
method_map: std::map::int_hash(),
vtable_map: std::map::int_hash(),
diff --git a/src/rustc/syntax/ast.rs b/src/rustc/syntax/ast.rs
index 1f0b40925bc..217977e9658 100644
--- a/src/rustc/syntax/ast.rs
+++ b/src/rustc/syntax/ast.rs
@@ -86,7 +86,7 @@ enum def {
// first def_id is for parent class
def_class_field(def_id, def_id),
// No purity allowed for now, I guess
- // (simpler this way, b/c presumably methods read mutable state)
+ // (simpler this way, b/c presumably methods read mut state)
def_class_method(def_id, def_id),
def_region(node_id)
}
diff --git a/src/rustc/syntax/codemap.rs b/src/rustc/syntax/codemap.rs
index c242b142bcc..a1a117201fb 100644
--- a/src/rustc/syntax/codemap.rs
+++ b/src/rustc/syntax/codemap.rs
@@ -16,13 +16,13 @@ enum file_substr {
type filemap =
@{name: filename, substr: file_substr, src: @str,
- start_pos: file_pos, mutable lines: [file_pos]};
+ start_pos: file_pos, mut lines: [file_pos]};
-type codemap = @{mutable files: [filemap]};
+type codemap = @{mut files: [filemap]};
type loc = {file: filemap, line: uint, col: uint};
-fn new_codemap() -> codemap { @{mutable files: [] } }
+fn new_codemap() -> codemap { @{mut files: [] } }
fn new_filemap_w_substr(filename: filename, substr: file_substr,
src: @str,
@@ -30,7 +30,7 @@ fn new_filemap_w_substr(filename: filename, substr: file_substr,
-> filemap {
ret @{name: filename, substr: substr, src: src,
start_pos: {ch: start_pos_ch, byte: start_pos_byte},
- mutable lines: [{ch: start_pos_ch, byte: start_pos_byte}]};
+ mut lines: [{ch: start_pos_ch, byte: start_pos_byte}]};
}
fn new_filemap(filename: filename, src: @str,
diff --git a/src/rustc/syntax/ext/base.rs b/src/rustc/syntax/ext/base.rs
index 01da22e38a1..86f13822c6e 100644
--- a/src/rustc/syntax/ext/base.rs
+++ b/src/rustc/syntax/ext/base.rs
@@ -67,7 +67,7 @@ fn mk_ctxt(session: driver::session::session,
type ctxt_repr = {session: driver::session::session,
parse_sess: parser::parse_sess,
cfg: ast::crate_cfg,
- mutable backtrace: expn_info};
+ mut backtrace: expn_info};
impl of ext_ctxt for ctxt_repr {
fn session() -> driver::session::session { self.session }
fn codemap() -> codemap { self.parse_sess.cm }
@@ -122,7 +122,7 @@ fn mk_ctxt(session: driver::session::session,
session: session,
parse_sess: parse_sess,
cfg: cfg,
- mutable backtrace: none
+ mut backtrace: none
};
ret imp as ext_ctxt
}
diff --git a/src/rustc/syntax/ext/qquote.rs b/src/rustc/syntax/ext/qquote.rs
index ce65d460f30..50d70ffa8d0 100644
--- a/src/rustc/syntax/ext/qquote.rs
+++ b/src/rustc/syntax/ext/qquote.rs
@@ -13,7 +13,7 @@ import io::*;
import codemap::span;
type aq_ctxt = @{lo: uint,
- mutable gather: [{lo: uint, hi: uint,
+ mut gather: [{lo: uint, hi: uint,
e: @ast::expr,
constr: str}]};
enum fragment {
@@ -99,7 +99,7 @@ fn gather_anti_quotes<N: qq_helper>(lo: uint, node: N) -> aq_ctxt
let v = @{visit_expr: visit_aq_expr,
visit_ty: visit_aq_ty
with *default_visitor()};
- let cx = @{lo:lo, mutable gather: []};
+ let cx = @{lo:lo, mut gather: []};
node.visit(cx, mk_vt(v));
// FIXME: Maybe this is an overkill (merge_sort), it might be better
// to just keep the gather array in sorted order ...
diff --git a/src/rustc/syntax/ext/simplext.rs b/src/rustc/syntax/ext/simplext.rs
index 2223c5f0fd6..dfc7d5314fc 100644
--- a/src/rustc/syntax/ext/simplext.rs
+++ b/src/rustc/syntax/ext/simplext.rs
@@ -136,7 +136,7 @@ fn compose_sels(s1: selector, s2: selector) -> selector {
type binders =
{real_binders: hashmap<ident, selector>,
- mutable literal_ast_matchers: [selector]};
+ mut literal_ast_matchers: [selector]};
type bindings = hashmap<ident, arb_depth<matchable>>;
fn acumm_bindings(_cx: ext_ctxt, _b_dest: bindings, _b_src: bindings) { }
@@ -148,7 +148,7 @@ fn acumm_bindings(_cx: ext_ctxt, _b_dest: bindings, _b_src: bindings) { }
fn pattern_to_selectors(cx: ext_ctxt, e: @expr) -> binders {
let res: binders =
{real_binders: str_hash::<selector>(),
- mutable literal_ast_matchers: []};
+ mut literal_ast_matchers: []};
//this oughta return binders instead, but macro args are a sequence of
//expressions, rather than a single expression
fn trivial_selector(m: matchable) -> match_result { ret some(leaf(m)); }
@@ -183,7 +183,7 @@ fn use_selectors_to_bind(b: binders, e: @expr) -> option<bindings> {
/* use the bindings on the body to generate the expanded code */
fn transcribe(cx: ext_ctxt, b: bindings, body: @expr) -> @expr {
- let idx_path: @mutable [uint] = @mutable [];
+ let idx_path: @mut [uint] = @mut [];
fn new_id(_old: node_id, cx: ext_ctxt) -> node_id { ret cx.next_id(); }
fn new_span(cx: ext_ctxt, sp: span) -> span {
/* this discards information in the case of macro-defining macros */
@@ -208,7 +208,7 @@ fn transcribe(cx: ext_ctxt, b: bindings, body: @expr) -> @expr {
/* helper: descend into a matcher */
-fn follow(m: arb_depth<matchable>, idx_path: @mutable [uint]) ->
+fn follow(m: arb_depth<matchable>, idx_path: @mut [uint]) ->
arb_depth<matchable> {
let mut res: arb_depth<matchable> = m;
for idx: uint in *idx_path {
@@ -221,7 +221,7 @@ fn follow(m: arb_depth<matchable>, idx_path: @mutable [uint]) ->
}
fn follow_for_trans(cx: ext_ctxt, mmaybe: option<arb_depth<matchable>>,
- idx_path: @mutable [uint]) -> option<matchable> {
+ idx_path: @mut [uint]) -> option<matchable> {
alt mmaybe {
none { ret none }
some(m) {
@@ -258,7 +258,7 @@ fn free_vars(b: bindings, e: @expr, it: fn(ident)) {
/* handle sequences (anywhere in the AST) of exprs, either real or ...ed */
-fn transcribe_exprs(cx: ext_ctxt, b: bindings, idx_path: @mutable [uint],
+fn transcribe_exprs(cx: ext_ctxt, b: bindings, idx_path: @mut [uint],
recur: fn@(&&@expr) -> @expr, exprs: [@expr]) -> [@expr] {
alt elts_to_ell(cx, exprs) {
{pre: pre, rep: repeat_me_maybe, post: post} {
@@ -320,7 +320,7 @@ fn transcribe_exprs(cx: ext_ctxt, b: bindings, idx_path: @mutable [uint],
// substitute, in a position that's required to be an ident
-fn transcribe_ident(cx: ext_ctxt, b: bindings, idx_path: @mutable [uint],
+fn transcribe_ident(cx: ext_ctxt, b: bindings, idx_path: @mut [uint],
&&i: ident, _fld: ast_fold) -> ident {
ret alt follow_for_trans(cx, b.find(i), idx_path) {
some(match_ident(a_id)) { a_id.node }
@@ -330,7 +330,7 @@ fn transcribe_ident(cx: ext_ctxt, b: bindings, idx_path: @mutable [uint],
}
-fn transcribe_path(cx: ext_ctxt, b: bindings, idx_path: @mutable [uint],
+fn transcribe_path(cx: ext_ctxt, b: bindings, idx_path: @mut [uint],
p: path_, s:span, _fld: ast_fold) -> (path_, span) {
// Don't substitute into qualified names.
if vec::len(p.types) > 0u || vec::len(p.idents) != 1u { ret (p, s); }
@@ -345,7 +345,7 @@ fn transcribe_path(cx: ext_ctxt, b: bindings, idx_path: @mutable [uint],
}
-fn transcribe_expr(cx: ext_ctxt, b: bindings, idx_path: @mutable [uint],
+fn transcribe_expr(cx: ext_ctxt, b: bindings, idx_path: @mut [uint],
e: ast::expr_, s: span, fld: ast_fold,
orig: fn@(ast::expr_, span, ast_fold)->(ast::expr_, span))
-> (ast::expr_, span)
@@ -373,7 +373,7 @@ fn transcribe_expr(cx: ext_ctxt, b: bindings, idx_path: @mutable [uint],
}
}
-fn transcribe_type(cx: ext_ctxt, b: bindings, idx_path: @mutable [uint],
+fn transcribe_type(cx: ext_ctxt, b: bindings, idx_path: @mut [uint],
t: ast::ty_, s: span, fld: ast_fold,
orig: fn@(ast::ty_, span, ast_fold) -> (ast::ty_, span))
-> (ast::ty_, span)
@@ -399,7 +399,7 @@ fn transcribe_type(cx: ext_ctxt, b: bindings, idx_path: @mutable [uint],
/* for parsing reasons, syntax variables bound to blocks must be used like
`{v}` */
-fn transcribe_block(cx: ext_ctxt, b: bindings, idx_path: @mutable [uint],
+fn transcribe_block(cx: ext_ctxt, b: bindings, idx_path: @mut [uint],
blk: blk_, s: span, fld: ast_fold,
orig: fn@(blk_, span, ast_fold) -> (blk_, span))
-> (blk_, span)
diff --git a/src/rustc/syntax/fold.rs b/src/rustc/syntax/fold.rs
index ad649b28190..4630b99eda6 100644
--- a/src/rustc/syntax/fold.rs
+++ b/src/rustc/syntax/fold.rs
@@ -15,7 +15,7 @@ export noop_fold_block;
export wrap;
export fold_ty_param;
-type ast_fold = @mutable a_f;
+type ast_fold = @mut a_f;
// We may eventually want to be able to fold over type parameters, too
@@ -602,9 +602,9 @@ fn default_ast_fold() -> @ast_fold_precursor {
fn make_fold(afp: ast_fold_precursor) -> ast_fold {
// FIXME: Have to bind all the bare functions into shared functions
- // because @mutable is invariant with respect to its contents
+ // because @mut is invariant with respect to its contents
let result: ast_fold =
- @mutable {fold_crate: bind nf_crate_dummy(_),
+ @mut {fold_crate: bind nf_crate_dummy(_),
fold_crate_directive: bind nf_crate_directive_dummy(_),
fold_view_item: bind nf_view_item_dummy(_),
fold_native_item: bind nf_native_item_dummy(_),
diff --git a/src/rustc/syntax/parse/lexer.rs b/src/rustc/syntax/parse/lexer.rs
index 9b4387135d1..5613b736d06 100644
--- a/src/rustc/syntax/parse/lexer.rs
+++ b/src/rustc/syntax/parse/lexer.rs
@@ -8,11 +8,11 @@ type reader = @{
span_diagnostic: diagnostic::span_handler,
src: @str,
len: uint,
- mutable col: uint,
- mutable pos: uint,
- mutable curr: char,
- mutable chpos: uint,
- mutable strs: [str],
+ mut col: uint,
+ mut pos: uint,
+ mut curr: char,
+ mut chpos: uint,
+ mut strs: [str],
filemap: codemap::filemap,
interner: @interner::interner<str>
};
@@ -63,8 +63,8 @@ fn new_reader(cm: codemap::codemap,
let r = @{cm: cm,
span_diagnostic: span_diagnostic,
src: filemap.src, len: str::len(*filemap.src),
- mutable col: 0u, mutable pos: 0u, mutable curr: -1 as char,
- mutable chpos: filemap.start_pos.ch, mutable strs: [],
+ mut col: 0u, mut pos: 0u, mut curr: -1 as char,
+ mut chpos: filemap.start_pos.ch, mut strs: [],
filemap: filemap, interner: itr};
if r.pos < r.len {
let next = str::char_range_at(*r.src, r.pos);
diff --git a/src/rustc/syntax/parse/parser.rs b/src/rustc/syntax/parse/parser.rs
index b35b68ea5e2..78d8d2b6133 100644
--- a/src/rustc/syntax/parse/parser.rs
+++ b/src/rustc/syntax/parse/parser.rs
@@ -21,11 +21,11 @@ enum file_type { CRATE_FILE, SOURCE_FILE, }
type parse_sess = @{
cm: codemap::codemap,
- mutable next_id: node_id,
+ mut next_id: node_id,
span_diagnostic: diagnostic::span_handler,
// these two must be kept up to date
- mutable chpos: uint,
- mutable byte_pos: uint
+ mut chpos: uint,
+ mut byte_pos: uint
};
fn next_node_id(sess: parse_sess) -> node_id {
@@ -40,11 +40,11 @@ type parser = @{
sess: parse_sess,
cfg: ast::crate_cfg,
file_type: file_type,
- mutable token: token::token,
- mutable span: span,
- mutable last_span: span,
- mutable buffer: [{tok: token::token, span: span}],
- mutable restriction: restriction,
+ mut token: token::token,
+ mut span: span,
+ mut last_span: span,
+ mut buffer: [{tok: token::token, span: span}],
+ mut restriction: restriction,
reader: reader,
precs: @[op_spec],
bad_expr_words: hashmap<str, ()>
@@ -130,11 +130,11 @@ fn new_parser(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader,
@{sess: sess,
cfg: cfg,
file_type: ftype,
- mutable token: tok0.tok,
- mutable span: span0,
- mutable last_span: span0,
- mutable buffer: [],
- mutable restriction: UNRESTRICTED,
+ mut token: tok0.tok,
+ mut span: span0,
+ mut last_span: span0,
+ mut buffer: [],
+ mut restriction: UNRESTRICTED,
reader: rdr,
precs: prec_table(),
bad_expr_words: bad_expr_word_table()}
@@ -149,7 +149,7 @@ fn bad_expr_word_table() -> hashmap<str, ()> {
"class", "const", "cont", "copy", "crust", "do", "else",
"enum", "export", "fail", "fn", "for", "if", "iface",
"impl", "import", "let", "log", "loop", "mod", "mut",
- "mutable", "native", "pure", "resource", "ret", "trait",
+ "mut", "native", "pure", "resource", "ret", "trait",
"type", "unchecked", "unsafe", "while", "new"] {
words.insert(word, ());
}
@@ -735,7 +735,7 @@ fn parse_path_and_ty_param_substs(p: parser, colons: bool) -> @ast::path {
}
fn parse_mutability(p: parser) -> ast::mutability {
- if eat_word(p, "mutable") {
+ if eat_word(p, "mut") {
ast::m_mutbl
} else if eat_word(p, "mut") {
ast::m_mutbl
@@ -831,7 +831,7 @@ fn parse_bottom_expr(p: parser) -> pexpr {
ret mk_pexpr(p, lo, hi, ast::expr_tup(es));
} else if p.token == token::LBRACE {
p.bump();
- if is_word(p, "mut") || is_word(p, "mutable") ||
+ if is_word(p, "mut") ||
is_plain_ident(p) && p.look_ahead(1u) == token::COLON {
let mut fields = [parse_field(p, token::COLON)];
let mut base = none;
@@ -1660,7 +1660,7 @@ fn parse_let(p: parser) -> @ast::decl {
fn parse_instance_var(p:parser) -> (ast::class_member, codemap::span) {
let mut is_mutbl = ast::class_immutable;
let lo = p.span.lo;
- if eat_word(p, "mut") || eat_word(p, "mutable") {
+ if eat_word(p, "mut") {
is_mutbl = ast::class_mutable;
}
if !is_plain_ident(p) {
diff --git a/src/rustc/syntax/print/pp.rs b/src/rustc/syntax/print/pp.rs
index bb71268870d..f116bab4fe4 100644
--- a/src/rustc/syntax/print/pp.rs
+++ b/src/rustc/syntax/print/pp.rs
@@ -70,7 +70,7 @@ fn tok_str(t: token) -> str {
}
}
-fn buf_str(toks: [mutable token], szs: [mutable int], left: uint, right: uint,
+fn buf_str(toks: [mut token], szs: [mut int], left: uint, right: uint,
lim: uint) -> str {
let n = vec::len(toks);
assert (n == vec::len(szs));
@@ -99,26 +99,26 @@ fn mk_printer(out: io::writer, linewidth: uint) -> printer {
// fall behind.
let n: uint = 3u * linewidth;
#debug("mk_printer %u", linewidth);
- let token: [mutable token] = vec::to_mut(vec::from_elem(n, EOF));
- let size: [mutable int] = vec::to_mut(vec::from_elem(n, 0));
- let scan_stack: [mutable uint] = vec::to_mut(vec::from_elem(n, 0u));
+ let token: [mut token] = vec::to_mut(vec::from_elem(n, EOF));
+ let size: [mut int] = vec::to_mut(vec::from_elem(n, 0));
+ let scan_stack: [mut uint] = vec::to_mut(vec::from_elem(n, 0u));
let print_stack: [print_stack_elt] = [];
@{out: out,
buf_len: n,
- mutable margin: linewidth as int,
- mutable space: linewidth as int,
- mutable left: 0u,
- mutable right: 0u,
- mutable token: token,
- mutable size: size,
- mutable left_total: 0,
- mutable right_total: 0,
- mutable scan_stack: scan_stack,
- mutable scan_stack_empty: true,
- mutable top: 0u,
- mutable bottom: 0u,
- mutable print_stack: print_stack,
- mutable pending_indentation: 0}
+ mut margin: linewidth as int,
+ mut space: linewidth as int,
+ mut left: 0u,
+ mut right: 0u,
+ mut token: token,
+ mut size: size,
+ mut left_total: 0,
+ mut right_total: 0,
+ mut scan_stack: scan_stack,
+ mut scan_stack_empty: true,
+ mut top: 0u,
+ mut bottom: 0u,
+ mut print_stack: print_stack,
+ mut pending_indentation: 0}
}
@@ -202,28 +202,28 @@ fn mk_printer(out: io::writer, linewidth: uint) -> printer {
type printer = @{
out: io::writer,
buf_len: uint,
- mutable margin: int, // width of lines we're constrained to
- mutable space: int, // number of spaces left on line
- mutable left: uint, // index of left side of input stream
- mutable right: uint, // index of right side of input stream
- mutable token: [mutable token], // ring-buffr stream goes through
- mutable size: [mutable int], // ring-buffer of calculated sizes
- mutable left_total: int, // running size of stream "...left"
- mutable right_total: int, // running size of stream "...right"
+ mut margin: int, // width of lines we're constrained to
+ mut space: int, // number of spaces left on line
+ mut left: uint, // index of left side of input stream
+ mut right: uint, // index of right side of input stream
+ mut token: [mut token], // ring-buffr stream goes through
+ mut size: [mut int], // ring-buffer of calculated sizes
+ mut left_total: int, // running size of stream "...left"
+ mut right_total: int, // running size of stream "...right"
// pseudo-stack, really a ring too. Holds the
// primary-ring-buffers index of the BEGIN that started the
// current block, possibly with the most recent BREAK after that
// BEGIN (if there is any) on top of it. Stuff is flushed off the
// bottom as it becomes irrelevant due to the primary ring-buffer
// advancing.
- mutable scan_stack: [mutable uint],
- mutable scan_stack_empty: bool, // top==bottom disambiguator
- mutable top: uint, // index of top of scan_stack
- mutable bottom: uint, // index of bottom of scan_stack
+ mut scan_stack: [mut uint],
+ mut scan_stack_empty: bool, // top==bottom disambiguator
+ mut top: uint, // index of top of scan_stack
+ mut bottom: uint, // index of bottom of scan_stack
// stack of blocks-in-progress being flushed by print
- mutable print_stack: [print_stack_elt],
+ mut print_stack: [print_stack_elt],
// buffered indentation to avoid writing trailing whitespace
- mutable pending_indentation: int
+ mut pending_indentation: int
};
impl printer for printer {
diff --git a/src/rustc/syntax/print/pprust.rs b/src/rustc/syntax/print/pprust.rs
index 76f9f8527f4..071441fe8e8 100644
--- a/src/rustc/syntax/print/pprust.rs
+++ b/src/rustc/syntax/print/pprust.rs
@@ -24,9 +24,9 @@ type ps =
cm: option<codemap>,
comments: option<[lexer::cmnt]>,
literals: option<[lexer::lit]>,
- mutable cur_cmnt: uint,
- mutable cur_lit: uint,
- mutable boxes: [pp::breaks],
+ mut cur_cmnt: uint,
+ mut cur_lit: uint,
+ mut boxes: [pp::breaks],
ann: pp_ann};
fn ibox(s: ps, u: uint) { s.boxes += [pp::inconsistent]; pp::ibox(s.s, u); }
@@ -39,9 +39,9 @@ fn rust_printer(writer: io::writer) -> ps {
cm: none::<codemap>,
comments: none::<[lexer::cmnt]>,
literals: none::<[lexer::lit]>,
- mutable cur_cmnt: 0u,
- mutable cur_lit: 0u,
- mutable boxes: boxes,
+ mut cur_cmnt: 0u,
+ mut cur_lit: 0u,
+ mut boxes: boxes,
ann: no_ann()};
}
@@ -64,9 +64,9 @@ fn print_crate(cm: codemap, span_diagnostic: diagnostic::span_handler,
cm: some(cm),
comments: some(r.cmnts),
literals: some(r.lits),
- mutable cur_cmnt: 0u,
- mutable cur_lit: 0u,
- mutable boxes: boxes,
+ mut cur_cmnt: 0u,
+ mut cur_lit: 0u,
+ mut boxes: boxes,
ann: ann};
print_crate_(s, crate);
}
@@ -518,7 +518,7 @@ fn print_item(s: ps, &&item: @ast::item) {
ast::instance_var(nm, t, mt, _) {
word_nbsp(s, "let");
alt mt {
- ast::class_mutable { word_nbsp(s, "mutable"); }
+ ast::class_mutable { word_nbsp(s, "mut"); }
_ {}
}
word(s.s, nm);
@@ -818,7 +818,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
ibox(s, indent_unit);
word(s.s, "[");
if mutbl == ast::m_mutbl {
- word(s.s, "mutable");
+ word(s.s, "mut");
if vec::len(exprs) > 0u { nbsp(s); }
}
commasep_exprs(s, inconsistent, exprs);
@@ -828,7 +828,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
ast::expr_rec(fields, wth) {
fn print_field(s: ps, field: ast::field) {
ibox(s, indent_unit);
- if field.node.mutbl == ast::m_mutbl { word_nbsp(s, "mutable"); }
+ if field.node.mutbl == ast::m_mutbl { word_nbsp(s, "mut"); }
word(s.s, field.node.ident);
word_space(s, ":");
print_expr(s, field.node.expr);
@@ -1135,7 +1135,7 @@ fn print_decl(s: ps, decl: @ast::decl) {
ibox(s, indent_unit);
word_nbsp(s, "let");
- // if any are mutable, all are mutable
+ // if any are mut, all are mut
if vec::any(locs) {|l| l.node.is_mutbl } {
assert vec::all(locs) {|l| l.node.is_mutbl };
word_nbsp(s, "mut");
@@ -1493,7 +1493,7 @@ fn print_op_maybe_parens(s: ps, expr: @ast::expr, outer_prec: int) {
fn print_mutability(s: ps, mutbl: ast::mutability) {
alt mutbl {
- ast::m_mutbl { word_nbsp(s, "mutable"); }
+ ast::m_mutbl { word_nbsp(s, "mut"); }
ast::m_const { word_nbsp(s, "const"); }
ast::m_imm {/* nothing */ }
}
diff --git a/src/rustc/syntax/util/interner.rs b/src/rustc/syntax/util/interner.rs
index 65f52b2fc46..99a032aae94 100644
--- a/src/rustc/syntax/util/interner.rs
+++ b/src/rustc/syntax/util/interner.rs
@@ -6,13 +6,13 @@ import std::map::{hashmap, hashfn, eqfn};
type interner<T> =
{map: hashmap<T, uint>,
- mutable vect: [T],
+ mut vect: [T],
hasher: hashfn<T>,
eqer: eqfn<T>};
fn mk<T: copy>(hasher: hashfn<T>, eqer: eqfn<T>) -> interner<T> {
let m = map::hashmap::<T, uint>(hasher, eqer);
- ret {map: m, mutable vect: [], hasher: hasher, eqer: eqer};
+ ret {map: m, mut vect: [], hasher: hasher, eqer: eqer};
}
fn intern<T: copy>(itr: interner<T>, val: T) -> uint {
diff --git a/src/rustc/util/common.rs b/src/rustc/util/common.rs
index 93c328ef2ab..1a6b7b0ccf9 100644
--- a/src/rustc/util/common.rs
+++ b/src/rustc/util/common.rs
@@ -68,8 +68,8 @@ fn log_stmt_err(st: ast::stmt) {
}
fn has_nonlocal_exits(b: ast::blk) -> bool {
- let has_exits = @mutable false;
- fn visit_expr(flag: @mutable bool, e: @ast::expr) {
+ let has_exits = @mut false;
+ fn visit_expr(flag: @mut bool, e: @ast::expr) {
alt e.node {
ast::expr_break { *flag = true; }
ast::expr_cont { *flag = true; }
@@ -85,8 +85,8 @@ fn has_nonlocal_exits(b: ast::blk) -> bool {
/* FIXME: copy/paste, yuck */
fn may_break(b: ast::blk) -> bool {
- let has_exits = @mutable false;
- fn visit_expr(flag: @mutable bool, e: @ast::expr) {
+ let has_exits = @mut false;
+ fn visit_expr(flag: @mut bool, e: @ast::expr) {
alt e.node {
ast::expr_break { *flag = true; }
_ { }
diff --git a/src/rustdoc/astsrv.rs b/src/rustdoc/astsrv.rs
index 83044447ec6..9bed75107fb 100644
--- a/src/rustdoc/astsrv.rs
+++ b/src/rustdoc/astsrv.rs
@@ -104,7 +104,7 @@ fn exec<T:send>(
}
fn build_ctxt(sess: session::session, ast: @ast::crate,
- ignore_errors: @mutable bool) -> ctxt {
+ ignore_errors: @mut bool) -> ctxt {
import rustc::front::config;
@@ -125,7 +125,7 @@ fn build_ctxt(sess: session::session, ast: @ast::crate,
// FIXME: this whole structure should not be duplicated here. makes it
// painful to add or remove options.
-fn build_session() -> (session::session, @mutable bool) {
+fn build_session() -> (session::session, @mut bool) {
let sopts: @session::options = @{
crate_type: session::lib_crate,
static: false,
@@ -163,7 +163,7 @@ fn build_session() -> (session::session, @mutable bool) {
type error_handlers = {
emitter: diagnostic::emitter,
span_handler: diagnostic::span_handler,
- ignore_errors: @mutable bool
+ ignore_errors: @mut bool
};
// Build a custom error handler that will allow us to ignore non-fatal
@@ -174,7 +174,7 @@ fn build_error_handlers(
type diagnostic_handler = {
inner: diagnostic::handler,
- ignore_errors: @mutable bool
+ ignore_errors: @mut bool
};
impl of diagnostic::handler for diagnostic_handler {
@@ -197,7 +197,7 @@ fn build_error_handlers(
}
}
- let ignore_errors = @mutable false;
+ let ignore_errors = @mut false;
let emitter = fn@(cmsp: option<(codemap::codemap, codemap::span)>,
msg: str, lvl: diagnostic::level) {
if !(*ignore_errors) {
diff --git a/src/rustdoc/attr_parser.rs b/src/rustdoc/attr_parser.rs
index 4e53151bf9a..d410e3d3ab8 100644
--- a/src/rustdoc/attr_parser.rs
+++ b/src/rustdoc/attr_parser.rs
@@ -29,10 +29,10 @@ mod test {
let handler = diagnostic::mk_handler(none);
let parse_sess = @{
cm: cm,
- mutable next_id: 0,
+ mut next_id: 0,
span_diagnostic: diagnostic::mk_span_handler(handler, cm),
- mutable chpos: 0u,
- mutable byte_pos: 0u
+ mut chpos: 0u,
+ mut byte_pos: 0u
};
let parser = parser::new_parser_from_source_str(
parse_sess, [], "-", codemap::fss_none, @source);
diff --git a/src/rustdoc/parse.rs b/src/rustdoc/parse.rs
index c8b13d92769..a52b3271886 100644
--- a/src/rustdoc/parse.rs
+++ b/src/rustdoc/parse.rs
@@ -14,10 +14,10 @@ fn new_parse_sess() -> parser::parse_sess {
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
};
ret sess;
}
diff --git a/src/rustdoc/path_pass.rs b/src/rustdoc/path_pass.rs
index 9aa88774822..e92845712a2 100644
--- a/src/rustdoc/path_pass.rs
+++ b/src/rustdoc/path_pass.rs
@@ -11,13 +11,13 @@ fn mk_pass() -> pass {
type ctxt = {
srv: astsrv::srv,
- mutable path: [str]
+ mut path: [str]
};
fn run(srv: astsrv::srv, doc: doc::doc) -> doc::doc {
let ctxt = {
srv: srv,
- mutable path: []
+ mut path: []
};
let fold = fold::fold({
fold_item: fold_item,
diff --git a/src/rustdoc/rustdoc b/src/rustdoc/rustdoc
new file mode 100755
index 00000000000..11f7119c95d
Binary files /dev/null and b/src/rustdoc/rustdoc differ
diff --git a/src/test/auxiliary/cci_class.rs b/src/test/auxiliary/cci_class.rs
index a3984503fae..cda361c1be9 100644
--- a/src/test/auxiliary/cci_class.rs
+++ b/src/test/auxiliary/cci_class.rs
@@ -2,7 +2,7 @@ mod kitties {
class cat {
priv {
- let mutable meows : uint;
+ let mut meows : uint;
}
let how_hungry : int;
diff --git a/src/test/auxiliary/cci_class_2.rs b/src/test/auxiliary/cci_class_2.rs
index 50a5bf1e624..0bb398839d1 100644
--- a/src/test/auxiliary/cci_class_2.rs
+++ b/src/test/auxiliary/cci_class_2.rs
@@ -2,7 +2,7 @@ mod kitties {
class cat {
priv {
- let mutable meows : uint;
+ let mut meows : uint;
}
let how_hungry : int;
diff --git a/src/test/auxiliary/cci_class_3.rs b/src/test/auxiliary/cci_class_3.rs
index a09a5e66a96..a30233c8135 100644
--- a/src/test/auxiliary/cci_class_3.rs
+++ b/src/test/auxiliary/cci_class_3.rs
@@ -2,7 +2,7 @@ mod kitties {
class cat {
priv {
- let mutable meows : uint;
+ let mut meows : uint;
}
let how_hungry : int;
diff --git a/src/test/auxiliary/cci_class_4.rs b/src/test/auxiliary/cci_class_4.rs
index 838157ac010..4bebf081e23 100644
--- a/src/test/auxiliary/cci_class_4.rs
+++ b/src/test/auxiliary/cci_class_4.rs
@@ -2,7 +2,7 @@ mod kitties {
class cat {
priv {
- let mutable meows : uint;
+ let mut meows : uint;
fn meow() {
#error("Meow");
meows += 1u;
diff --git a/src/test/auxiliary/cci_class_5.rs b/src/test/auxiliary/cci_class_5.rs
index a2995bf2986..6dc4d76cf52 100644
--- a/src/test/auxiliary/cci_class_5.rs
+++ b/src/test/auxiliary/cci_class_5.rs
@@ -2,7 +2,7 @@ mod kitties {
class cat {
priv {
- let mutable meows : uint;
+ let mut meows : uint;
fn nap() { uint::range(1u, 10000u) {|_i|}}
}
diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs
index 37e5776c2b1..9ce1561d4d0 100644
--- a/src/test/bench/shootout-fasta.rs
+++ b/src/test/bench/shootout-fasta.rs
@@ -13,7 +13,7 @@ import str;
fn LINE_LENGTH() -> uint { ret 60u; }
-type myrandom = @{mutable last: u32};
+type myrandom = @{mut last: u32};
fn myrandom_next(r: myrandom, mx: u32) -> u32 {
r.last = (r.last * 3877u32 + 29573u32) % 139968u32;
@@ -44,7 +44,7 @@ fn select_random(r: u32, genelist: [aminoacids]) -> char {
fn make_random_fasta(id: str, desc: str, genelist: [aminoacids], n: int) {
log(debug, ">" + id + " " + desc);
- let rng = @{mutable last: std::rand::rng().next()};
+ let rng = @{mut last: std::rand::rng().next()};
let mut op: str = "";
uint::range(0u, n as uint) {|_i|
str::push_char(op, select_random(myrandom_next(rng, 100u32),
diff --git a/src/test/bench/shootout-nbody.rs b/src/test/bench/shootout-nbody.rs
index cc40dfa0b4f..bf493d579e1 100644
--- a/src/test/bench/shootout-nbody.rs
+++ b/src/test/bench/shootout-nbody.rs
@@ -136,61 +136,61 @@ mod Body {
const DAYS_PER_YEAR: float = 365.24;
type props =
- {mutable x: float,
- mutable y: float,
- mutable z: float,
- mutable vx: float,
- mutable vy: float,
- mutable vz: float,
+ {mut x: float,
+ mut y: float,
+ mut z: float,
+ mut vx: float,
+ mut vy: float,
+ mut vz: float,
mass: float};
fn jupiter() -> Body::props {
- ret {mutable x: 4.84143144246472090e+00,
- mutable y: -1.16032004402742839e+00,
- mutable z: -1.03622044471123109e-01,
- mutable vx: 1.66007664274403694e-03 * DAYS_PER_YEAR,
- mutable vy: 7.69901118419740425e-03 * DAYS_PER_YEAR,
- mutable vz: -6.90460016972063023e-05 * DAYS_PER_YEAR,
+ ret {mut x: 4.84143144246472090e+00,
+ mut y: -1.16032004402742839e+00,
+ mut z: -1.03622044471123109e-01,
+ mut vx: 1.66007664274403694e-03 * DAYS_PER_YEAR,
+ mut vy: 7.69901118419740425e-03 * DAYS_PER_YEAR,
+ mut vz: -6.90460016972063023e-05 * DAYS_PER_YEAR,
mass: 9.54791938424326609e-04 * SOLAR_MASS};
}
fn saturn() -> Body::props {
- ret {mutable x: 8.34336671824457987e+00,
- mutable y: 4.12479856412430479e+00,
- mutable z: -4.03523417114321381e-01,
- mutable vx: -2.76742510726862411e-03 * DAYS_PER_YEAR,
- mutable vy: 4.99852801234917238e-03 * DAYS_PER_YEAR,
- mutable vz: 2.30417297573763929e-05 * DAYS_PER_YEAR,
+ ret {mut x: 8.34336671824457987e+00,
+ mut y: 4.12479856412430479e+00,
+ mut z: -4.03523417114321381e-01,
+ mut vx: -2.76742510726862411e-03 * DAYS_PER_YEAR,
+ mut vy: 4.99852801234917238e-03 * DAYS_PER_YEAR,
+ mut vz: 2.30417297573763929e-05 * DAYS_PER_YEAR,
mass: 2.85885980666130812e-04 * SOLAR_MASS};
}
fn uranus() -> Body::props {
- ret {mutable x: 1.28943695621391310e+01,
- mutable y: -1.51111514016986312e+01,
- mutable z: -2.23307578892655734e-01,
- mutable vx: 2.96460137564761618e-03 * DAYS_PER_YEAR,
- mutable vy: 2.37847173959480950e-03 * DAYS_PER_YEAR,
- mutable vz: -2.96589568540237556e-05 * DAYS_PER_YEAR,
+ ret {mut x: 1.28943695621391310e+01,
+ mut y: -1.51111514016986312e+01,
+ mut z: -2.23307578892655734e-01,
+ mut vx: 2.96460137564761618e-03 * DAYS_PER_YEAR,
+ mut vy: 2.37847173959480950e-03 * DAYS_PER_YEAR,
+ mut vz: -2.96589568540237556e-05 * DAYS_PER_YEAR,
mass: 4.36624404335156298e-05 * SOLAR_MASS};
}
fn neptune() -> Body::props {
- ret {mutable x: 1.53796971148509165e+01,
- mutable y: -2.59193146099879641e+01,
- mutable z: 1.79258772950371181e-01,
- mutable vx: 2.68067772490389322e-03 * DAYS_PER_YEAR,
- mutable vy: 1.62824170038242295e-03 * DAYS_PER_YEAR,
- mutable vz: -9.51592254519715870e-05 * DAYS_PER_YEAR,
+ ret {mut x: 1.53796971148509165e+01,
+ mut y: -2.59193146099879641e+01,
+ mut z: 1.79258772950371181e-01,
+ mut vx: 2.68067772490389322e-03 * DAYS_PER_YEAR,
+ mut vy: 1.62824170038242295e-03 * DAYS_PER_YEAR,
+ mut vz: -9.51592254519715870e-05 * DAYS_PER_YEAR,
mass: 5.15138902046611451e-05 * SOLAR_MASS};
}
fn sun() -> Body::props {
- ret {mutable x: 0.0,
- mutable y: 0.0,
- mutable z: 0.0,
- mutable vx: 0.0,
- mutable vy: 0.0,
- mutable vz: 0.0,
+ ret {mut x: 0.0,
+ mut y: 0.0,
+ mut z: 0.0,
+ mut vx: 0.0,
+ mut vy: 0.0,
+ mut vz: 0.0,
mass: SOLAR_MASS};
}
diff --git a/src/test/bench/shootout-spectralnorm.rs b/src/test/bench/shootout-spectralnorm.rs
index d1bd69fee07..b9a0b80ebf9 100644
--- a/src/test/bench/shootout-spectralnorm.rs
+++ b/src/test/bench/shootout-spectralnorm.rs
@@ -6,7 +6,7 @@ fn eval_A(i: uint, j: uint) -> float {
1.0/(((i+j)*(i+j+1u)/2u+i+1u) as float)
}
-fn eval_A_times_u(u: [const float], Au: [mutable float]) {
+fn eval_A_times_u(u: [const float], Au: [mut float]) {
let N = vec::len(u);
let mut i = 0u;
while i < N {
@@ -20,7 +20,7 @@ fn eval_A_times_u(u: [const float], Au: [mutable float]) {
}
}
-fn eval_At_times_u(u: [const float], Au: [mutable float]) {
+fn eval_At_times_u(u: [const float], Au: [mut float]) {
let N = vec::len(u);
let mut i = 0u;
while i < N {
@@ -34,7 +34,7 @@ fn eval_At_times_u(u: [const float], Au: [mutable float]) {
}
}
-fn eval_AtA_times_u(u: [const float], AtAu: [mutable float]) {
+fn eval_AtA_times_u(u: [const float], AtAu: [mut float]) {
let v = vec::to_mut(vec::from_elem(vec::len(u), 0.0));
eval_A_times_u(u, v);
eval_At_times_u(v, AtAu);
diff --git a/src/test/bench/sudoku.rs b/src/test/bench/sudoku.rs
index cf6951b23a6..974c8136751 100644
--- a/src/test/bench/sudoku.rs
+++ b/src/test/bench/sudoku.rs
@@ -22,7 +22,7 @@ import io::{writer_util, reader_util};
export grid_t, read_grid, solve_grid, write_grid;
// internal type of sudoku grids
-type grid = [[mutable u8]];
+type grid = [[mut u8]];
// exported type of sudoku grids
enum grid_t { grid_ctor(grid), }
diff --git a/src/test/bench/task-perf-word-count.rs b/src/test/bench/task-perf-word-count.rs
index 60cc0c03d4d..20ffd613240 100644
--- a/src/test/bench/task-perf-word-count.rs
+++ b/src/test/bench/task-perf-word-count.rs
@@ -103,10 +103,10 @@ mod map_reduce {
send(out, chan(p));
- let state = @{mutable ref_count: 0, mutable is_done: false};
+ let state = @{mut ref_count: 0, mut is_done: false};
- fn get(p: port<reduce_proto>, state: @{mutable ref_count: int,
- mutable is_done: bool})
+ fn get(p: port<reduce_proto>, state: @{mut ref_count: int,
+ mut is_done: bool})
-> option<int> {
while !state.is_done || state.ref_count > 0 {
alt recv(p) {
diff --git a/src/test/compile-fail/assign-to-method.rs b/src/test/compile-fail/assign-to-method.rs
index 8a213b08497..aea25979d9b 100644
--- a/src/test/compile-fail/assign-to-method.rs
+++ b/src/test/compile-fail/assign-to-method.rs
@@ -1,7 +1,7 @@
// error-pattern:assigning to immutable field
class cat {
priv {
- let mutable meows : uint;
+ let mut meows : uint;
}
let how_hungry : int;
diff --git a/src/test/compile-fail/mutable-huh-variance-box.rs b/src/test/compile-fail/mutable-huh-variance-box.rs
index 1715acc5859..db38c4ad289 100644
--- a/src/test/compile-fail/mutable-huh-variance-box.rs
+++ b/src/test/compile-fail/mutable-huh-variance-box.rs
@@ -1,10 +1,10 @@
// error-pattern: mismatched types
fn main() {
- let v = @mutable [0];
+ let v = @mut [0];
- fn f(&&v: @mutable [const int]) {
- *v = [mutable 3]
+ fn f(&&v: @mut [const int]) {
+ *v = [mut 3]
}
f(v);
diff --git a/src/test/compile-fail/mutable-huh-variance-deep.rs b/src/test/compile-fail/mutable-huh-variance-deep.rs
index 072a1f04c8b..7de97e59173 100644
--- a/src/test/compile-fail/mutable-huh-variance-deep.rs
+++ b/src/test/compile-fail/mutable-huh-variance-deep.rs
@@ -1,9 +1,9 @@
// error-pattern: mismatched types
fn main() {
- let v = [mutable @mutable ~mutable [0]];
+ let v = [mut @mut ~mut [0]];
- fn f(&&v: [mutable @mutable ~mutable [const int]]) {
+ fn f(&&v: [mut @mut ~mut [const int]]) {
}
f(v);
diff --git a/src/test/compile-fail/mutable-huh-variance-ptr.rs b/src/test/compile-fail/mutable-huh-variance-ptr.rs
index f735af5ba73..852b474eebb 100644
--- a/src/test/compile-fail/mutable-huh-variance-ptr.rs
+++ b/src/test/compile-fail/mutable-huh-variance-ptr.rs
@@ -4,11 +4,11 @@ use std;
fn main() {
let a = [0];
- let v: *mutable [int] = ptr::mut_addr_of(a);
+ let v: *mut [int] = ptr::mut_addr_of(a);
- fn f(&&v: *mutable [const int]) {
+ fn f(&&v: *mut [const int]) {
unsafe {
- *v = [mutable 3]
+ *v = [mut 3]
}
}
diff --git a/src/test/compile-fail/mutable-huh-variance-rec.rs b/src/test/compile-fail/mutable-huh-variance-rec.rs
index 3bd079ba6ff..78143f7fbc6 100644
--- a/src/test/compile-fail/mutable-huh-variance-rec.rs
+++ b/src/test/compile-fail/mutable-huh-variance-rec.rs
@@ -1,10 +1,10 @@
// error-pattern: mismatched types
fn main() {
- let v = {mutable g: [0]};
+ let v = {mut g: [0]};
- fn f(&&v: {mutable g: [const int]}) {
- v.g = [mutable 3]
+ fn f(&&v: {mut g: [const int]}) {
+ v.g = [mut 3]
}
f(v);
diff --git a/src/test/compile-fail/mutable-huh-variance-unique.rs b/src/test/compile-fail/mutable-huh-variance-unique.rs
index 54ffccecaf0..cd8d2ca6f10 100644
--- a/src/test/compile-fail/mutable-huh-variance-unique.rs
+++ b/src/test/compile-fail/mutable-huh-variance-unique.rs
@@ -1,10 +1,10 @@
// error-pattern: mismatched types
fn main() {
- let v = ~mutable [0];
+ let v = ~mut [0];
- fn f(&&v: ~mutable [const int]) {
- *v = [mutable 3]
+ fn f(&&v: ~mut [const int]) {
+ *v = [mut 3]
}
f(v);
diff --git a/src/test/compile-fail/mutable-huh-variance-vec1.rs b/src/test/compile-fail/mutable-huh-variance-vec1.rs
index 895322309d0..3519127ab1b 100644
--- a/src/test/compile-fail/mutable-huh-variance-vec1.rs
+++ b/src/test/compile-fail/mutable-huh-variance-vec1.rs
@@ -2,10 +2,10 @@ fn main() {
// Note: explicit type annot is required here
// because otherwise the inference gets smart
// and assigns a type of [mut [const int]].
- let v: [mut [int]] = [mutable [0]];
+ let v: [mut [int]] = [mut [0]];
- fn f(&&v: [mutable [const int]]) {
- v[0] = [mutable 3]
+ fn f(&&v: [mut [const int]]) {
+ v[0] = [mut 3]
}
f(v); //! ERROR (values differ in mutability)
diff --git a/src/test/compile-fail/mutable-huh-variance-vec2.rs b/src/test/compile-fail/mutable-huh-variance-vec2.rs
index 3a0725f6643..09c3565e8b2 100644
--- a/src/test/compile-fail/mutable-huh-variance-vec2.rs
+++ b/src/test/compile-fail/mutable-huh-variance-vec2.rs
@@ -2,9 +2,9 @@ fn main() {
// Note: explicit type annot is required here
// because otherwise the inference gets smart
// and assigns a type of [mut [const int]].
- let v: [mut [mut int]] = [mutable [mutable 0]];
+ let v: [mut [mut int]] = [mut [mut 0]];
- fn f(&&v: [mutable [const int]]) {
+ fn f(&&v: [mut [const int]]) {
v[0] = [3]
}
diff --git a/src/test/compile-fail/mutable-huh-variance-vec3.rs b/src/test/compile-fail/mutable-huh-variance-vec3.rs
index 786535dd4bc..97b6ccabdfd 100644
--- a/src/test/compile-fail/mutable-huh-variance-vec3.rs
+++ b/src/test/compile-fail/mutable-huh-variance-vec3.rs
@@ -2,10 +2,10 @@ fn main() {
// Note: explicit type annot is required here
// because otherwise the inference gets smart
// and assigns a type of [mut [const int]].
- let v: [mut[mut[int]]] = [mutable [mutable [0]]];
+ let v: [mut[mut[int]]] = [mut [mut [0]]];
- fn f(&&v: [mutable [mutable [const int]]]) {
- v[0][1] = [mutable 3]
+ fn f(&&v: [mut [mut [const int]]]) {
+ v[0][1] = [mut 3]
}
f(v); //! ERROR (values differ in mutability)
diff --git a/src/test/compile-fail/pinned-deep-copy.rs b/src/test/compile-fail/pinned-deep-copy.rs
index 9244b4b73b3..1a07b3f1de0 100644
--- a/src/test/compile-fail/pinned-deep-copy.rs
+++ b/src/test/compile-fail/pinned-deep-copy.rs
@@ -1,11 +1,11 @@
// error-pattern: copying a noncopyable value
-resource r(i: @mutable int) {
+resource r(i: @mut int) {
*i = *i + 1;
}
fn main() {
- let i = @mutable 0;
+ let i = @mut 0;
{
// Can't do this copy
let x = ~~~{y: r(i)};
diff --git a/src/test/compile-fail/private-class-field.rs b/src/test/compile-fail/private-class-field.rs
index a3d77507cb5..c0fb997d14c 100644
--- a/src/test/compile-fail/private-class-field.rs
+++ b/src/test/compile-fail/private-class-field.rs
@@ -1,7 +1,7 @@
// error-pattern:no public field or method with that name
class cat {
priv {
- let mutable meows : uint;
+ let mut meows : uint;
}
let how_hungry : int;
diff --git a/src/test/compile-fail/private-method.rs b/src/test/compile-fail/private-method.rs
index 7dc1f44d71b..7e45660deb7 100644
--- a/src/test/compile-fail/private-method.rs
+++ b/src/test/compile-fail/private-method.rs
@@ -1,7 +1,7 @@
// error-pattern:attempted access of field nap on type
class cat {
priv {
- let mutable meows : uint;
+ let mut meows : uint;
fn nap() { uint::range(1u, 10000u) {|_i|}}
}
diff --git a/src/test/compile-fail/unique-mut.rs b/src/test/compile-fail/unique-mut.rs
index bb5779bc1db..04c88a3d103 100644
--- a/src/test/compile-fail/unique-mut.rs
+++ b/src/test/compile-fail/unique-mut.rs
@@ -1,4 +1,4 @@
//error-pattern:mismatched types
fn main() {
- let i: ~int = ~mutable 0;
+ let i: ~int = ~mut 0;
}
\ No newline at end of file
diff --git a/src/test/compile-fail/unique-vec-res.rs b/src/test/compile-fail/unique-vec-res.rs
index fdc9072fd93..045a22fa8e0 100644
--- a/src/test/compile-fail/unique-vec-res.rs
+++ b/src/test/compile-fail/unique-vec-res.rs
@@ -1,6 +1,6 @@
// error-pattern: copying a noncopyable value
-resource r(i: @mutable int) {
+resource r(i: @mut int) {
*i = *i + 1;
}
@@ -9,8 +9,8 @@ fn f<T>(+i: [T], +j: [T]) {
}
fn main() {
- let i1 = @mutable 0;
- let i2 = @mutable 1;
+ let i1 = @mut 0;
+ let i2 = @mut 1;
let r1 <- [~r(i1)];
let r2 <- [~r(i2)];
f(r1, r2);
diff --git a/src/test/compile-fail/unsafe-alias-2.rs b/src/test/compile-fail/unsafe-alias-2.rs
index ec1e5c01ffb..ac20aeec931 100644
--- a/src/test/compile-fail/unsafe-alias-2.rs
+++ b/src/test/compile-fail/unsafe-alias-2.rs
@@ -1,8 +1,8 @@
// error-pattern:invalidate reference x
-fn whoknows(x: @mutable {mutable x: int}) { x.x = 10; }
+fn whoknows(x: @mut {mut x: int}) { x.x = 10; }
fn main() {
- let box = @mutable {mutable x: 1};
+ let box = @mut {mut x: 1};
alt *box { x { whoknows(box); log(error, x); } }
}
diff --git a/src/test/compile-fail/unsafe-alias.rs b/src/test/compile-fail/unsafe-alias.rs
index 905a6a922f1..0b13c5b5305 100644
--- a/src/test/compile-fail/unsafe-alias.rs
+++ b/src/test/compile-fail/unsafe-alias.rs
@@ -1,10 +1,10 @@
// error-pattern:may alias with argument
-fn foo(x: {mutable x: int}, f: fn@()) { log(debug, x); }
+fn foo(x: {mut x: int}, f: fn@()) { log(debug, x); }
-fn whoknows(x: @mutable {mutable x: int}) { *x = {mutable x: 10}; }
+fn whoknows(x: @mut {mut x: int}) { *x = {mut x: 10}; }
fn main() {
- let box = @mutable {mutable x: 1};
+ let box = @mut {mut x: 1};
foo(*box, bind whoknows(box));
}
diff --git a/src/test/compile-fail/unsafe-alt.rs b/src/test/compile-fail/unsafe-alt.rs
index b0291ea4e83..92aa4ac00a4 100644
--- a/src/test/compile-fail/unsafe-alt.rs
+++ b/src/test/compile-fail/unsafe-alt.rs
@@ -1,8 +1,8 @@
// error-pattern:invalidate reference i
-enum foo { left({mutable x: int}), right(bool) }
+enum foo { left({mut x: int}), right(bool) }
fn main() {
- let x = left({mutable x: 10});
+ let x = left({mut x: 10});
alt x { left(i) { x = right(false); log(debug, i); } _ { } }
}
diff --git a/src/test/compile-fail/unsafe-for.rs b/src/test/compile-fail/unsafe-for.rs
index 05bad8ee833..a4e54d33fe7 100644
--- a/src/test/compile-fail/unsafe-for.rs
+++ b/src/test/compile-fail/unsafe-for.rs
@@ -1,6 +1,6 @@
// error-pattern:invalidate reference x
fn main() {
- let v: [mutable {mutable x: int}] = [mutable {mutable x: 1}];
- for x in v { v[0] = {mutable x: 2}; log(debug, x); }
+ let v: [mut {mut x: int}] = [mut {mut x: 1}];
+ for x in v { v[0] = {mut x: 2}; log(debug, x); }
}
diff --git a/src/test/compile-fail/unsafe-mutable-alias.rs b/src/test/compile-fail/unsafe-mutable-alias.rs
index 3ab7fe974a5..1767eb3983c 100644
--- a/src/test/compile-fail/unsafe-mutable-alias.rs
+++ b/src/test/compile-fail/unsafe-mutable-alias.rs
@@ -1,8 +1,8 @@
-// error-pattern:mutable reference to a variable that roots another reference
+// error-pattern:mut reference to a variable that roots another reference
-fn f(a: {mutable x: int}, &b: {mutable x: int}) -> int {
+fn f(a: {mut x: int}, &b: {mut x: int}) -> int {
b.x += 1;
ret a.x + b.x;
}
-fn main() { let i = {mutable x: 4}; log(debug, f(i, i)); }
+fn main() { let i = {mut x: 4}; log(debug, f(i, i)); }
diff --git a/src/test/pretty/block-disambig.rs b/src/test/pretty/block-disambig.rs
index 64752505952..4157515b41c 100644
--- a/src/test/pretty/block-disambig.rs
+++ b/src/test/pretty/block-disambig.rs
@@ -7,7 +7,7 @@ fn test1() { let val = @0; { } *val; }
fn test2() -> int { let val = @0; { } *val }
fn test3() {
- let regs = @{mutable eax: 0};
+ let regs = @{mut eax: 0};
alt check true { true { } }
(*regs).eax = 1;
}
@@ -36,10 +36,10 @@ fn test8() -> int {
}
}
-fn test9() { let regs = @mutable 0; alt check true { true { } } *regs += 1; }
+fn test9() { let regs = @mut 0; alt check true { true { } } *regs += 1; }
fn test10() -> int {
- let regs = @mutable [0];
+ let regs = @mut [0];
alt check true { true { } }
(*regs)[0]
}
diff --git a/src/test/run-fail/unwind-misc-1.rs b/src/test/run-fail/unwind-misc-1.rs
index 28e93d0edbd..34d08570be4 100644
--- a/src/test/run-fail/unwind-misc-1.rs
+++ b/src/test/run-fail/unwind-misc-1.rs
@@ -6,7 +6,7 @@ import std::map::hashmap;
import uint;
fn main() {
- let count = @mutable 0u;
+ let count = @mut 0u;
fn hash(&&s: [@str]) -> uint {
if (vec::len(s) > 0u && str::eq(*s[0], "boom")) { fail; }
ret 10u;
diff --git a/src/test/run-pass/alignment-gep-tup-like-2.rs b/src/test/run-pass/alignment-gep-tup-like-2.rs
index f3fe07fcc2b..641aceb9b16 100644
--- a/src/test/run-pass/alignment-gep-tup-like-2.rs
+++ b/src/test/run-pass/alignment-gep-tup-like-2.rs
@@ -5,11 +5,11 @@ type pair<A,B> = {
enum rec<A> = _rec<A>;
type _rec<A> = {
val: A,
- mutable rec: option<@rec<A>>
+ mut rec: option<@rec<A>>
};
fn make_cycle<A:copy>(a: A) {
- let g: @rec<A> = @rec({val: a, mutable rec: none});
+ let g: @rec<A> = @rec({val: a, mut rec: none});
g.rec = some(g);
}
diff --git a/src/test/run-pass/alloca-from-derived-tydesc.rs b/src/test/run-pass/alloca-from-derived-tydesc.rs
index 73de058949a..1bad1418382 100644
--- a/src/test/run-pass/alloca-from-derived-tydesc.rs
+++ b/src/test/run-pass/alloca-from-derived-tydesc.rs
@@ -1,7 +1,7 @@
enum option<T> { some(T), none, }
-type r<T> = {mutable v: [option<T>]};
+type r<T> = {mut v: [option<T>]};
fn f<T>() -> [T] { ret []; }
-fn main() { let r: r<int> = {mutable v: []}; r.v = f(); }
+fn main() { let r: r<int> = {mut v: []}; r.v = f(); }
diff --git a/src/test/run-pass/alt-implicit-copy-unique.rs b/src/test/run-pass/alt-implicit-copy-unique.rs
index ce5233ad1df..bffa76efa30 100644
--- a/src/test/run-pass/alt-implicit-copy-unique.rs
+++ b/src/test/run-pass/alt-implicit-copy-unique.rs
@@ -1,5 +1,5 @@
fn main() {
- let x = ~{mutable a: ~10, b: ~20};
+ let x = ~{mut a: ~10, b: ~20};
alt x {
~{a, b} { assert *a == 10; (*x).a = ~30; assert *a == 10; }
}
diff --git a/src/test/run-pass/alt-implicit-copy.rs b/src/test/run-pass/alt-implicit-copy.rs
index 7bb148b1b91..43de34e87a8 100644
--- a/src/test/run-pass/alt-implicit-copy.rs
+++ b/src/test/run-pass/alt-implicit-copy.rs
@@ -1,5 +1,5 @@
fn main() {
- let x = @{mutable a: @10, b: @20};
+ let x = @{mut a: @10, b: @20};
alt x {
@{a, b} { assert *a == 10; (*x).a = @30; assert *a == 10; }
}
diff --git a/src/test/run-pass/argument-passing.rs b/src/test/run-pass/argument-passing.rs
index 3af1d92a8ea..2f17efd3279 100644
--- a/src/test/run-pass/argument-passing.rs
+++ b/src/test/run-pass/argument-passing.rs
@@ -1,4 +1,4 @@
-fn f1(a: {mutable x: int}, &b: int, -c: int) -> int {
+fn f1(a: {mut x: int}, &b: int, -c: int) -> int {
let r = a.x + b + c;
a.x = 0;
b = 10;
@@ -9,7 +9,7 @@ fn f1(a: {mutable x: int}, &b: int, -c: int) -> int {
fn f2(a: int, f: fn(int)) -> int { f(1); ret a; }
fn main() {
- let mut a = {mutable x: 1}, b = 2, c = 3;
+ let mut a = {mut x: 1}, b = 2, c = 3;
assert (f1(a, b, c) == 6);
assert (a.x == 0);
assert (b == 10);
diff --git a/src/test/run-pass/class-methods.rs b/src/test/run-pass/class-methods.rs
index 79daecfe35e..f1769b0fb50 100644
--- a/src/test/run-pass/class-methods.rs
+++ b/src/test/run-pass/class-methods.rs
@@ -1,6 +1,6 @@
class cat {
priv {
- let mutable meows : uint;
+ let mut meows : uint;
}
let how_hungry : int;
diff --git a/src/test/run-pass/classes-simple-method.rs b/src/test/run-pass/classes-simple-method.rs
index 62084958d5a..dff5a035d98 100644
--- a/src/test/run-pass/classes-simple-method.rs
+++ b/src/test/run-pass/classes-simple-method.rs
@@ -1,6 +1,6 @@
class cat {
priv {
- let mutable meows : uint;
+ let mut meows : uint;
}
let how_hungry : int;
diff --git a/src/test/run-pass/classes-simple.rs b/src/test/run-pass/classes-simple.rs
index 3b4df149fa5..bb0384f902e 100644
--- a/src/test/run-pass/classes-simple.rs
+++ b/src/test/run-pass/classes-simple.rs
@@ -1,6 +1,6 @@
class cat {
priv {
- let mutable meows : uint;
+ let mut meows : uint;
}
let how_hungry : int;
diff --git a/src/test/run-pass/classes.rs b/src/test/run-pass/classes.rs
index c2d5735969c..0117519089a 100644
--- a/src/test/run-pass/classes.rs
+++ b/src/test/run-pass/classes.rs
@@ -1,6 +1,6 @@
class cat {
priv {
- let mutable meows : uint;
+ let mut meows : uint;
fn meow() {
#error("Meow");
meows += 1u;
diff --git a/src/test/run-pass/cycle-collection.rs b/src/test/run-pass/cycle-collection.rs
index dd00fcbbbef..2f671625392 100644
--- a/src/test/run-pass/cycle-collection.rs
+++ b/src/test/run-pass/cycle-collection.rs
@@ -1,10 +1,10 @@
enum taggy {
- cons(@mutable taggy),
+ cons(@mut taggy),
nil,
}
fn f() {
- let box = @mutable nil;
+ let box = @mut nil;
*box = cons(box);
}
diff --git a/src/test/run-pass/cycle-collection2.rs b/src/test/run-pass/cycle-collection2.rs
index 33609d17c09..406e73f545c 100644
--- a/src/test/run-pass/cycle-collection2.rs
+++ b/src/test/run-pass/cycle-collection2.rs
@@ -1,10 +1,10 @@
-type foo = { mutable z : fn@() };
+type foo = { mut z : fn@() };
fn nop() { }
fn nop_foo(_x : @foo) { }
fn main() {
- let w = @{ mutable z: bind nop() };
+ let w = @{ mut z: bind nop() };
let x = bind nop_foo(w);
w.z = x;
}
\ No newline at end of file
diff --git a/src/test/run-pass/cycle-collection4.rs b/src/test/run-pass/cycle-collection4.rs
index d7a16f63a6d..833fb3aafc5 100644
--- a/src/test/run-pass/cycle-collection4.rs
+++ b/src/test/run-pass/cycle-collection4.rs
@@ -1,10 +1,10 @@
-type foo = { mutable z : fn@() };
+type foo = { mut z : fn@() };
fn nop() { }
fn nop_foo(_y: [int], _x : @foo) { }
fn main() {
- let w = @{ mutable z: bind nop() };
+ let w = @{ mut z: bind nop() };
let x = bind nop_foo([], w);
w.z = x;
}
\ No newline at end of file
diff --git a/src/test/run-pass/cycle-collection5.rs b/src/test/run-pass/cycle-collection5.rs
index af01d9a35e7..e64bdd16bf4 100644
--- a/src/test/run-pass/cycle-collection5.rs
+++ b/src/test/run-pass/cycle-collection5.rs
@@ -1,4 +1,4 @@
-type foo = { mutable z : fn@() };
+type foo = { mut z : fn@() };
fn nop() { }
fn nop_foo(_y: @int, _x : @foo) { }
@@ -6,7 +6,7 @@ fn nop_foo(_y: @int, _x : @foo) { }
fn o() -> @int { @10 }
fn main() {
- let w = @{ mutable z: bind nop() };
+ let w = @{ mut z: bind nop() };
let x = bind nop_foo(o(), w);
w.z = x;
}
\ No newline at end of file
diff --git a/src/test/run-pass/deref-lval.rs b/src/test/run-pass/deref-lval.rs
index 2784b16b99a..07c2e91d539 100644
--- a/src/test/run-pass/deref-lval.rs
+++ b/src/test/run-pass/deref-lval.rs
@@ -1,3 +1,3 @@
-fn main() { let x = @mutable 5; *x = 1000; log(debug, *x); }
+fn main() { let x = @mut 5; *x = 1000; log(debug, *x); }
diff --git a/src/test/run-pass/empty-mutable-vec.rs b/src/test/run-pass/empty-mutable-vec.rs
index 6dfd5446160..eaec2ab31d5 100644
--- a/src/test/run-pass/empty-mutable-vec.rs
+++ b/src/test/run-pass/empty-mutable-vec.rs
@@ -1,3 +1,3 @@
-fn main() { let v: [mutable int] = [mutable]; }
+fn main() { let v: [mut int] = [mut]; }
diff --git a/src/test/run-pass/expr-copy.rs b/src/test/run-pass/expr-copy.rs
index f0b21469528..279e916b75a 100644
--- a/src/test/run-pass/expr-copy.rs
+++ b/src/test/run-pass/expr-copy.rs
@@ -1,9 +1,9 @@
-fn f(arg: {mutable a: int}) {
+fn f(arg: {mut a: int}) {
arg.a = 100;
}
fn main() {
- let x = {mutable a: 10};
+ let x = {mut a: 10};
f(x);
assert x.a == 100;
x.a = 20;
diff --git a/src/test/run-pass/exterior.rs b/src/test/run-pass/exterior.rs
index 228f7dff061..6890bb12789 100644
--- a/src/test/run-pass/exterior.rs
+++ b/src/test/run-pass/exterior.rs
@@ -2,12 +2,12 @@
// -*- rust -*-
-type point = {x: int, y: int, mutable z: int};
+type point = {x: int, y: int, mut z: int};
fn f(p: @point) { assert (p.z == 12); p.z = 13; assert (p.z == 13); }
fn main() {
- let a: point = {x: 10, y: 11, mutable z: 12};
+ let a: point = {x: 10, y: 11, mut z: 12};
let b: @point = @a;
assert (b.z == 12);
f(b);
diff --git a/src/test/run-pass/for-implicit-copy.rs b/src/test/run-pass/for-implicit-copy.rs
index a91b572e703..572556370a7 100644
--- a/src/test/run-pass/for-implicit-copy.rs
+++ b/src/test/run-pass/for-implicit-copy.rs
@@ -1,5 +1,5 @@
fn main() {
- let x = [@{mutable a: @10, b: @20}];
+ let x = [@{mut a: @10, b: @20}];
for @{a, b} in x {
assert *a == 10;
(*x[0]).a = @30;
diff --git a/src/test/run-pass/foreach-nested.rs b/src/test/run-pass/foreach-nested.rs
index 6afd21559dd..3cc0a5a82f1 100644
--- a/src/test/run-pass/foreach-nested.rs
+++ b/src/test/run-pass/foreach-nested.rs
@@ -5,7 +5,7 @@
fn two(it: fn(int)) { it(0); it(1); }
fn main() {
- let a: [mutable int] = [mutable -1, -1, -1, -1];
+ let a: [mut int] = [mut -1, -1, -1, -1];
let mut p: int = 0;
two {|i|
two {|j| a[p] = 10 * i + j; p += 1; };
diff --git a/src/test/run-pass/iface-cast.rs b/src/test/run-pass/iface-cast.rs
index 94dbc3fcdb0..b771eca4be8 100644
--- a/src/test/run-pass/iface-cast.rs
+++ b/src/test/run-pass/iface-cast.rs
@@ -2,8 +2,8 @@
enum Tree = TreeR;
type TreeR = @{
- mutable left: option<Tree>,
- mutable right: option<Tree>,
+ mut left: option<Tree>,
+ mut right: option<Tree>,
val: to_str
};
@@ -36,11 +36,11 @@ impl of to_str for Tree {
fn foo<T: to_str>(x: T) -> str { x.to_str() }
fn main() {
- let t1 = Tree(@{mutable left: none,
- mutable right: none,
+ let t1 = Tree(@{mut left: none,
+ mut right: none,
val: 1 as to_str });
- let t2 = Tree(@{mutable left: some(t1),
- mutable right: some(t1),
+ let t2 = Tree(@{mut left: some(t1),
+ mut right: some(t1),
val: 2 as to_str });
let expected = "[2, some([1, none, none]), some([1, none, none])]";
assert t2.to_str() == expected;
diff --git a/src/test/run-pass/init-res-into-things.rs b/src/test/run-pass/init-res-into-things.rs
index f79cef2a0e7..c7609973a04 100644
--- a/src/test/run-pass/init-res-into-things.rs
+++ b/src/test/run-pass/init-res-into-things.rs
@@ -1,12 +1,12 @@
// Resources can't be copied, but storing into data structures counts
// as a move unless the stored thing is used afterwards.
-resource r(i: @mutable int) {
+resource r(i: @mut int) {
*i = *i + 1;
}
fn test_box() {
- let i = @mutable 0;
+ let i = @mut 0;
{
let a <- @r(i);
}
@@ -14,7 +14,7 @@ fn test_box() {
}
fn test_rec() {
- let i = @mutable 0;
+ let i = @mut 0;
{
let a <- {x: r(i)};
}
@@ -26,7 +26,7 @@ fn test_tag() {
t0(r),
}
- let i = @mutable 0;
+ let i = @mut 0;
{
let a <- t0(r(i));
}
@@ -34,7 +34,7 @@ fn test_tag() {
}
fn test_tup() {
- let i = @mutable 0;
+ let i = @mut 0;
{
let a <- (r(i), 0);
}
@@ -42,7 +42,7 @@ fn test_tup() {
}
fn test_unique() {
- let i = @mutable 0;
+ let i = @mut 0;
{
let a <- ~r(i);
}
@@ -50,7 +50,7 @@ fn test_unique() {
}
fn test_box_rec() {
- let i = @mutable 0;
+ let i = @mut 0;
{
let a <- @{
x: r(i)
diff --git a/src/test/run-pass/issue-979.rs b/src/test/run-pass/issue-979.rs
index 77482843b07..3de02c5679d 100644
--- a/src/test/run-pass/issue-979.rs
+++ b/src/test/run-pass/issue-979.rs
@@ -1,9 +1,9 @@
-resource r(b: @mutable int) {
+resource r(b: @mut int) {
*b += 1;
}
fn main() {
- let b = @mutable 0;
+ let b = @mut 0;
{
let p = some(r(b));
}
diff --git a/src/test/run-pass/issue-980.rs b/src/test/run-pass/issue-980.rs
index ddbc648ae0a..41702fbee97 100644
--- a/src/test/run-pass/issue-980.rs
+++ b/src/test/run-pass/issue-980.rs
@@ -4,10 +4,10 @@ enum maybe_pointy {
}
type pointy = {
- mutable x : maybe_pointy
+ mut x : maybe_pointy
};
fn main() {
- let m = @{ mutable x : no_pointy };
+ let m = @{ mut x : no_pointy };
m.x = yes_pointy(m);
}
diff --git a/src/test/run-pass/lambda-infer-unresolved.rs b/src/test/run-pass/lambda-infer-unresolved.rs
index d526c00a998..36b93774c86 100644
--- a/src/test/run-pass/lambda-infer-unresolved.rs
+++ b/src/test/run-pass/lambda-infer-unresolved.rs
@@ -1,7 +1,7 @@
// This should typecheck even though the type of e is not fully
// resolved when we finish typechecking the fn@.
fn main() {
- let e = @{mutable refs: [], n: 0};
+ let e = @{mut refs: [], n: 0};
let f = fn@ () { log(error, e.n); };
e.refs += [1];
}
diff --git a/src/test/run-pass/log-linearized.rs b/src/test/run-pass/log-linearized.rs
index 0a7f0b28340..3e202e84b81 100644
--- a/src/test/run-pass/log-linearized.rs
+++ b/src/test/run-pass/log-linearized.rs
@@ -5,11 +5,11 @@ enum option<T> {
some(T),
}
-type smallintmap<T> = @{mutable v: [mutable option<T>]};
+type smallintmap<T> = @{mut v: [mut option<T>]};
fn mk<T>() -> smallintmap<T> {
- let v: [mutable option<T>] = [mutable];
- ret @{mutable v: v};
+ let v: [mut option<T>] = [mut];
+ ret @{mut v: v};
}
fn f<T,U>() {
diff --git a/src/test/run-pass/maybe-mutable.rs b/src/test/run-pass/maybe-mutable.rs
index 788c24aa24d..c66de1b3367 100644
--- a/src/test/run-pass/maybe-mutable.rs
+++ b/src/test/run-pass/maybe-mutable.rs
@@ -11,6 +11,6 @@ fn len(v: [const int]) -> uint {
fn main() {
let v0 = [1, 2, 3, 4, 5];
log(debug, len(v0));
- let v1 = [mutable 1, 2, 3, 4, 5];
+ let v1 = [mut 1, 2, 3, 4, 5];
log(debug, len(v1));
}
diff --git a/src/test/run-pass/mlist-cycle.rs b/src/test/run-pass/mlist-cycle.rs
index 455368c4771..3c7a5007f37 100644
--- a/src/test/run-pass/mlist-cycle.rs
+++ b/src/test/run-pass/mlist-cycle.rs
@@ -2,14 +2,14 @@
// -*- rust -*-
use std;
-type cell = {mutable c: @list};
+type cell = {mut c: @list};
enum list { link(@cell), nil, }
fn main() {
- let first: @cell = @{mutable c: @nil()};
- let second: @cell = @{mutable c: @link(first)};
+ let first: @cell = @{mut c: @nil()};
+ let second: @cell = @{mut c: @link(first)};
first._0 = @link(second);
sys.rustrt.gc();
- let third: @cell = @{mutable c: @nil()};
+ let third: @cell = @{mut c: @nil()};
}
\ No newline at end of file
diff --git a/src/test/run-pass/mutable-huh-variance-vec1.rs b/src/test/run-pass/mutable-huh-variance-vec1.rs
index b36ec502896..31cfab18ddc 100644
--- a/src/test/run-pass/mutable-huh-variance-vec1.rs
+++ b/src/test/run-pass/mutable-huh-variance-vec1.rs
@@ -4,7 +4,7 @@ fn main() {
let v = [[0]];
// This is ok because the outer vec is covariant with respect
- // to the inner vec. If the outer vec was mutable then we
+ // to the inner vec. If the outer vec was mut then we
// couldn't do this.
fn f(&&v: [[const int]]) {
}
diff --git a/src/test/run-pass/mutable-huh-variance-vec2.rs b/src/test/run-pass/mutable-huh-variance-vec2.rs
index 82b0a029ba9..7815554cdab 100644
--- a/src/test/run-pass/mutable-huh-variance-vec2.rs
+++ b/src/test/run-pass/mutable-huh-variance-vec2.rs
@@ -4,7 +4,7 @@ fn main() {
let v = [[0]];
// This is ok because the outer vec is covariant with respect
- // to the inner vec. If the outer vec was mutable then we
+ // to the inner vec. If the outer vec was mut then we
// couldn't do this.
fn f(&&v: [const [const int]]) {
}
diff --git a/src/test/run-pass/mutable-vec-drop.rs b/src/test/run-pass/mutable-vec-drop.rs
index 625bcb17f97..2b1433d8a65 100644
--- a/src/test/run-pass/mutable-vec-drop.rs
+++ b/src/test/run-pass/mutable-vec-drop.rs
@@ -1,6 +1,6 @@
fn main() {
// This just tests whether the vec leaks its members.
- let pvec: [mutable @{a: int, b: int}] =
- [mutable @{a: 1, b: 2}, @{a: 3, b: 4}, @{a: 5, b: 6}];
+ let pvec: [mut @{a: int, b: int}] =
+ [mut @{a: 1, b: 2}, @{a: 3, b: 4}, @{a: 5, b: 6}];
}
diff --git a/src/test/run-pass/nested-patterns.rs b/src/test/run-pass/nested-patterns.rs
index 79eb1d40e4d..d58cb896a60 100644
--- a/src/test/run-pass/nested-patterns.rs
+++ b/src/test/run-pass/nested-patterns.rs
@@ -3,10 +3,10 @@ fn main() {
x@{a, b: @20} { assert x.a == 10; assert a == 10; }
{b, _} { fail; }
}
- let x@{b, _} = {a: 10, b: {mutable c: 20}};
+ let x@{b, _} = {a: 10, b: {mut c: 20}};
x.b.c = 30;
assert b.c == 20;
- let y@{d, _} = {a: 10, d: {mutable c: 20}};
+ let y@{d, _} = {a: 10, d: {mut c: 20}};
y.d.c = 30;
assert d.c == 20;
}
diff --git a/src/test/run-pass/private-class-field.rs b/src/test/run-pass/private-class-field.rs
index 6d11ce2c3da..f2f7c795252 100644
--- a/src/test/run-pass/private-class-field.rs
+++ b/src/test/run-pass/private-class-field.rs
@@ -1,6 +1,6 @@
class cat {
priv {
- let mutable meows : uint;
+ let mut meows : uint;
}
let how_hungry : int;
diff --git a/src/test/run-pass/private-method.rs b/src/test/run-pass/private-method.rs
index 6e95d3d314f..2cc75e1ec3c 100644
--- a/src/test/run-pass/private-method.rs
+++ b/src/test/run-pass/private-method.rs
@@ -1,6 +1,6 @@
class cat {
priv {
- let mutable meows : uint;
+ let mut meows : uint;
fn nap() { uint::range(1u, 10u) {|_i|}}
}
diff --git a/src/test/run-pass/qquote.rs b/src/test/run-pass/qquote.rs
index b1a95b9fff9..de70e2c67d1 100644
--- a/src/test/run-pass/qquote.rs
+++ b/src/test/run-pass/qquote.rs
@@ -17,10 +17,10 @@ fn new_parse_sess() -> parser::parse_sess {
let handler = diagnostic::mk_handler(option::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
};
ret sess;
}
diff --git a/src/test/run-pass/regions-simple.rs b/src/test/run-pass/regions-simple.rs
index 61fcb47725d..36500898f79 100644
--- a/src/test/run-pass/regions-simple.rs
+++ b/src/test/run-pass/regions-simple.rs
@@ -1,6 +1,6 @@
fn main() {
let x: int = 3;
- let y: &mutable int = &mutable x;
+ let y: &mut int = &mut x;
*y = 5;
log (debug, *y);
}
diff --git a/src/test/run-pass/resource-assign-is-not-copy.rs b/src/test/run-pass/resource-assign-is-not-copy.rs
index 1261878db2e..5f8d3a2319d 100644
--- a/src/test/run-pass/resource-assign-is-not-copy.rs
+++ b/src/test/run-pass/resource-assign-is-not-copy.rs
@@ -1,7 +1,7 @@
-resource r(i: @mutable int) { *i += 1; }
+resource r(i: @mut int) { *i += 1; }
fn main() {
- let i = @mutable 0;
+ let i = @mut 0;
// Even though these look like copies, they are guaranteed not to be
{
let a = r(i);
diff --git a/src/test/run-pass/resource-destruct.rs b/src/test/run-pass/resource-destruct.rs
index 2df6dddb2a4..a575d17d2f6 100644
--- a/src/test/run-pass/resource-destruct.rs
+++ b/src/test/run-pass/resource-destruct.rs
@@ -1,9 +1,9 @@
-resource shrinky_pointer(i: @mutable int) { *i -= 1; }
+resource shrinky_pointer(i: @mut int) { *i -= 1; }
fn look_at(pt: shrinky_pointer) -> int { ret **pt; }
fn main() {
- let my_total = @mutable 10;
+ let my_total = @mut 10;
{ let pt <- shrinky_pointer(my_total); assert (look_at(pt) == 10); }
assert (*my_total == 9);
}
diff --git a/src/test/run-pass/resource-generic.rs b/src/test/run-pass/resource-generic.rs
index 34f823a543b..08e546749dc 100644
--- a/src/test/run-pass/resource-generic.rs
+++ b/src/test/run-pass/resource-generic.rs
@@ -3,8 +3,8 @@ resource finish<T>(arg: {val: T, fin: native fn(T)}) {
}
fn main() {
- let box = @mutable 10;
- fn dec_box(&&i: @mutable int) { *i -= 1; }
+ let box = @mut 10;
+ fn dec_box(&&i: @mut int) { *i -= 1; }
{ let i <- finish({val: box, fin: dec_box}); }
assert (*box == 9);
diff --git a/src/test/run-pass/resource-in-struct.rs b/src/test/run-pass/resource-in-struct.rs
index f2dbb04f1b2..f5a0afe9479 100644
--- a/src/test/run-pass/resource-in-struct.rs
+++ b/src/test/run-pass/resource-in-struct.rs
@@ -1,7 +1,7 @@
// Ensures that putting resources inside structual types keeps
// working.
-type closable = @mutable bool;
+type closable = @mut bool;
resource close_res(i: closable) { *i = false; }
@@ -10,7 +10,7 @@ enum option<T> { none, some(T), }
fn sink(res: option<close_res>) { }
fn main() {
- let c = @mutable true;
+ let c = @mut true;
sink(none);
sink(some(close_res(c)));
assert (!*c);
diff --git a/src/test/run-pass/sendfn-deep-copy.rs b/src/test/run-pass/sendfn-deep-copy.rs
index f9d1fc1dbd7..96e06e65c70 100644
--- a/src/test/run-pass/sendfn-deep-copy.rs
+++ b/src/test/run-pass/sendfn-deep-copy.rs
@@ -8,7 +8,7 @@ fn main() { test05(); }
fn mk_counter<A:copy>() -> fn~(A) -> (A,uint) {
// The only reason that the counter is generic is so that it closes
// over both a type descriptor and some data.
- let v = [mutable 0u];
+ let v = [mut 0u];
ret fn~(a: A) -> (A,uint) {
let n = v[0];
v[0] = n + 1u;
diff --git a/src/test/run-pass/swap-2.rs b/src/test/run-pass/swap-2.rs
index c9a599fb73f..f94205f4a9f 100644
--- a/src/test/run-pass/swap-2.rs
+++ b/src/test/run-pass/swap-2.rs
@@ -1,7 +1,7 @@
-fn swap<T>(v: [mutable T], i: int, j: int) { v[i] <-> v[j]; }
+fn swap<T>(v: [mut T], i: int, j: int) { v[i] <-> v[j]; }
fn main() {
- let a: [mutable int] = [mutable 0, 1, 2, 3, 4, 5, 6];
+ let a: [mut int] = [mut 0, 1, 2, 3, 4, 5, 6];
swap(a, 2, 4);
assert (a[2] == 4);
assert (a[4] == 2);
diff --git a/src/test/run-pass/task-killjoin-rsrc.rs b/src/test/run-pass/task-killjoin-rsrc.rs
index f7829aa31df..f84645c1dbf 100644
--- a/src/test/run-pass/task-killjoin-rsrc.rs
+++ b/src/test/run-pass/task-killjoin-rsrc.rs
@@ -8,7 +8,7 @@ import task;
fn joinable(f: fn()) -> (task::task, comm::port<bool>) {
resource notify(data: (comm::chan<bool>,
- @mutable bool)) {
+ @mut bool)) {
let (c, v) = data;
#error["notify: task=%d v=%x unwinding=%b b=%b",
task::get_task(),
@@ -19,7 +19,7 @@ fn joinable(f: fn()) -> (task::task, comm::port<bool>) {
}
fn wrapper(pair: (comm::chan<bool>, fn())) {
let (c, f) = pair;
- let b = @mutable false;
+ let b = @mut false;
#error["wrapper: task=%d allocated v=%x",
task::get_task(),
ptr::addr_of(*b) as uint];
diff --git a/src/test/run-pass/uniq-cc-generic.rs b/src/test/run-pass/uniq-cc-generic.rs
index 9666018d814..b2990d3d101 100644
--- a/src/test/run-pass/uniq-cc-generic.rs
+++ b/src/test/run-pass/uniq-cc-generic.rs
@@ -4,7 +4,7 @@ enum maybe_pointy {
}
type pointy = {
- mutable a : maybe_pointy,
+ mut a : maybe_pointy,
d : fn~() -> uint,
};
@@ -14,7 +14,7 @@ fn make_uniq_closure<A:send>(a: A) -> fn~() -> uint {
fn empty_pointy() -> @pointy {
ret @{
- mutable a : none,
+ mut a : none,
d : make_uniq_closure("hi")
}
}
diff --git a/src/test/run-pass/uniq-cc.rs b/src/test/run-pass/uniq-cc.rs
index ad4581e12cd..f238e3e4e9f 100644
--- a/src/test/run-pass/uniq-cc.rs
+++ b/src/test/run-pass/uniq-cc.rs
@@ -4,14 +4,14 @@ enum maybe_pointy {
}
type pointy = {
- mutable a : maybe_pointy,
+ mut a : maybe_pointy,
c : ~int,
d : fn~()->(),
};
fn empty_pointy() -> @pointy {
ret @{
- mutable a : none,
+ mut a : none,
c : ~22,
d : fn~()->(){},
}
diff --git a/src/test/run-pass/unique-assign-copy.rs b/src/test/run-pass/unique-assign-copy.rs
index 2ae6ea8d289..2c152c9805c 100644
--- a/src/test/run-pass/unique-assign-copy.rs
+++ b/src/test/run-pass/unique-assign-copy.rs
@@ -1,5 +1,5 @@
fn main() {
- let i = ~mutable 1;
+ let i = ~mut 1;
// Should be a copy
let mut j;
j = i;
diff --git a/src/test/run-pass/unique-decl-init-copy.rs b/src/test/run-pass/unique-decl-init-copy.rs
index d9808b6f50d..ab8df403a77 100644
--- a/src/test/run-pass/unique-decl-init-copy.rs
+++ b/src/test/run-pass/unique-decl-init-copy.rs
@@ -1,5 +1,5 @@
fn main() {
- let i = ~mutable 1;
+ let i = ~mut 1;
// Should be a copy
let j = i;
*i = 2;
diff --git a/src/test/run-pass/unique-in-vec-copy.rs b/src/test/run-pass/unique-in-vec-copy.rs
index bad975edb56..1a9eb581c24 100644
--- a/src/test/run-pass/unique-in-vec-copy.rs
+++ b/src/test/run-pass/unique-in-vec-copy.rs
@@ -1,5 +1,5 @@
fn main() {
- let a = [~mutable 10];
+ let a = [~mut 10];
let b = a;
assert *a[0] == 10;
diff --git a/src/test/run-pass/unique-mutable.rs b/src/test/run-pass/unique-mutable.rs
index ef3b818c9f6..fd991c20503 100644
--- a/src/test/run-pass/unique-mutable.rs
+++ b/src/test/run-pass/unique-mutable.rs
@@ -1,5 +1,5 @@
fn main() {
- let i = ~mutable 0;
+ let i = ~mut 0;
*i = 1;
assert *i == 1;
}
\ No newline at end of file
diff --git a/src/test/run-pass/unique-pinned-nocopy-2.rs b/src/test/run-pass/unique-pinned-nocopy-2.rs
index 92b86ad0d34..ff94532f9c5 100644
--- a/src/test/run-pass/unique-pinned-nocopy-2.rs
+++ b/src/test/run-pass/unique-pinned-nocopy-2.rs
@@ -1,9 +1,9 @@
-resource r(i: @mutable int) {
+resource r(i: @mut int) {
*i = *i + 1;
}
fn main() {
- let i = @mutable 0;
+ let i = @mut 0;
{
let j = ~r(i);
}
diff --git a/src/test/run-pass/weird-exprs.rs b/src/test/run-pass/weird-exprs.rs
index 4e0c69cdbcc..0640bacbfe4 100644
--- a/src/test/run-pass/weird-exprs.rs
+++ b/src/test/run-pass/weird-exprs.rs
@@ -8,8 +8,8 @@ fn funny() {
}
fn what() {
- fn the(x: @mutable bool) { ret while !*x { *x = true; }; }
- let i = @mutable false;
+ fn the(x: @mut bool) { ret while !*x { *x = true; }; }
+ let i = @mut false;
let dont = bind the(i);
dont();
assert (*i);
diff --git a/src/test/run-pass/writealias.rs b/src/test/run-pass/writealias.rs
index 816b08db724..9dba2e2adfd 100644
--- a/src/test/run-pass/writealias.rs
+++ b/src/test/run-pass/writealias.rs
@@ -2,12 +2,12 @@
// -*- rust -*-
-type point = {x: int, y: int, mutable z: int};
+type point = {x: int, y: int, mut z: int};
fn f(&p: point) { p.z = 13; }
fn main() {
- let mut x: point = {x: 10, y: 11, mutable z: 12};
+ let mut x: point = {x: 10, y: 11, mut z: 12};
f(x);
assert (x.z == 13);
}