Bulk-edit mutable -> mut.

42 files changed, 314 insertions, 314 deletions

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; }
           _ { }