Bulk-edit mutable -> mut.

11 files changed, 95 insertions, 95 deletions

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 {