make mut a keyword synonymous with mutable

first step towards issue #1273

Author: nikomatsakis

src/comp/driver/driver.rs

@@ -159,7 +159,7 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg,
          bind middle::tstate::ck::check_crate(ty_cx, crate));
     let mut_map =
         time(time_passes, "mutability checking",
-             bind middle::mut::check_crate(ty_cx, crate));
+             bind middle::mutbl::check_crate(ty_cx, crate));
     let (copy_map, ref_map) =
         time(time_passes, "alias checking",
              bind middle::alias::check_crate(ty_cx, crate));

src/comp/front/test.rs

@@ -256,7 +256,7 @@ fn mk_test_desc_vec_ty(cx: test_ctxt) -> @ast::ty {
     let test_desc_ty: ast::ty =
         nospan(ast::ty_path(test_desc_ty_path, cx.sess.next_node_id()));
 
-    let vec_mt: ast::mt = {ty: @test_desc_ty, mut: ast::imm};
+    let vec_mt: ast::mt = {ty: @test_desc_ty, mutbl: ast::m_imm};
 
     ret @nospan(ast::ty_vec(vec_mt));
 }
@@ -270,7 +270,7 @@ fn mk_test_desc_vec(cx: test_ctxt) -> @ast::expr {
     }
 
     ret @{id: cx.sess.next_node_id(),
-          node: ast::expr_vec(descs, ast::imm),
+          node: ast::expr_vec(descs, ast::m_imm),
           span: dummy_sp()};
 }
 
@@ -288,7 +288,7 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr {
          span: span};
 
     let name_field: ast::field =
-        nospan({mut: ast::imm, ident: "name", expr: @name_expr});
+        nospan({mutbl: ast::m_imm, ident: "name", expr: @name_expr});
 
     let fn_path = @nospan({global: false, idents: path, types: []});
 
@@ -300,7 +300,7 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr {
     let fn_wrapper_expr = mk_test_wrapper(cx, fn_expr, span);
 
     let fn_field: ast::field =
-        nospan({mut: ast::imm, ident: "fn", expr: fn_wrapper_expr});
+        nospan({mutbl: ast::m_imm, ident: "fn", expr: fn_wrapper_expr});
 
     let ignore_lit: ast::lit = nospan(ast::lit_bool(test.ignore));
 
@@ -310,7 +310,7 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr {
          span: span};
 
     let ignore_field: ast::field =
-        nospan({mut: ast::imm, ident: "ignore", expr: @ignore_expr});
+        nospan({mutbl: ast::m_imm, ident: "ignore", expr: @ignore_expr});
 
     let fail_lit: ast::lit = nospan(ast::lit_bool(test.should_fail));
 
@@ -320,7 +320,7 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr {
          span: span};
 
     let fail_field: ast::field =
-        nospan({mut: ast::imm, ident: "should_fail", expr: @fail_expr});
+        nospan({mutbl: ast::m_imm, ident: "should_fail", expr: @fail_expr});
 
     let desc_rec_: ast::expr_ =
         ast::expr_rec([name_field, fn_field, ignore_field, fail_field],
@@ -378,7 +378,7 @@ fn mk_test_wrapper(cx: test_ctxt,
 fn mk_main(cx: test_ctxt) -> @ast::item {
     let str_pt = @nospan({global: false, idents: ["str"], types: []});
     let str_ty = @nospan(ast::ty_path(str_pt, cx.sess.next_node_id()));
-    let args_mt: ast::mt = {ty: str_ty, mut: ast::imm};
+    let args_mt: ast::mt = {ty: str_ty, mutbl: ast::m_imm};
     let args_ty: ast::ty = nospan(ast::ty_vec(args_mt));
 
     let args_arg: ast::arg =

src/comp/metadata/astencode.rs

@@ -483,28 +483,28 @@ impl ast_output for ast_ctxt {
                 self.tag(at_ty_bot) {||}
               }
 
-              ty_box({ty: ty, mut: m}) {
+              ty_box({ty: ty, mutbl: m}) {
                 self.tag(at_ty_box) {||
                     self.ty(ty);
                     self.mutbl(m);
                 }
               }
 
-              ty_uniq({ty: ty, mut: m}) {
+              ty_uniq({ty: ty, mutbl: m}) {
                 self.tag(at_ty_uniq) {||
                     self.ty(ty);
                     self.mutbl(m);
                 }
               }
 
-              ty_vec({ty: ty, mut: m}) {
+              ty_vec({ty: ty, mutbl: m}) {
                 self.tag(at_ty_vec) {||
                     self.ty(ty);
                     self.mutbl(m);
                 }
               }
 
-              ty_ptr({ty: ty, mut: m}) {
+              ty_ptr({ty: ty, mutbl: m}) {
                 self.tag(at_ty_ptr) {||
                     self.ty(ty);
                     self.mutbl(m);

src/comp/metadata/tydecode.rs

@@ -311,11 +311,11 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t {
 fn parse_mt(st: @pstate, conv: conv_did) -> ty::mt {
     let m;
     alt peek(st) {
-      'm' { next(st); m = ast::mut; }
-      '?' { next(st); m = ast::maybe_mut; }
-      _ { m = ast::imm; }
+      'm' { next(st); m = ast::m_mutbl; }
+      '?' { next(st); m = ast::m_const; }
+      _ { m = ast::m_imm; }
     }
-    ret {ty: parse_ty(st, conv), mut: m};
+    ret {ty: parse_ty(st, conv), mutbl: m};
 }
 
 fn parse_def(st: @pstate, conv: conv_did) -> ast::def_id {
@@ -356,7 +356,7 @@ fn parse_ty_fn(st: @pstate, conv: conv_did) -> ty::fn_ty {
     let inputs: [ty::arg] = [];
     while peek(st) != ']' {
         let mode = alt check peek(st) {
-          '&' { ast::by_mut_ref }
+          '&' { ast::by_mutbl_ref }
           '-' { ast::by_move }
           '+' { ast::by_copy }
           '=' { ast::by_ref }

src/comp/metadata/tyencode.rs

@@ -85,10 +85,10 @@ fn enc_ty(w: io::writer, cx: @ctxt, t: ty::t) {
     }
 }
 fn enc_mt(w: io::writer, cx: @ctxt, mt: ty::mt) {
-    alt mt.mut {
-      imm { }
-      mut { w.write_char('m'); }
-      maybe_mut { w.write_char('?'); }
+    alt mt.mutbl {
+      m_imm { }
+      m_mutbl { w.write_char('m'); }
+      m_const { w.write_char('?'); }
     }
     enc_ty(w, cx, mt.ty);
 }
@@ -215,7 +215,7 @@ fn enc_ty_fn(w: io::writer, cx: @ctxt, ft: ty::fn_ty) {
     w.write_char('[');
     for arg: ty::arg in ft.inputs {
         alt ty::resolved_mode(cx.tcx, arg.mode) {
-          by_mut_ref { w.write_char('&'); }
+          by_mutbl_ref { w.write_char('&'); }
           by_move { w.write_char('-'); }
           by_copy { w.write_char('+'); }
           by_ref { w.write_char('='); }

src/comp/middle/alias.rs

@@ -22,7 +22,7 @@ type invalid = {reason: invalid_reason,
                 node_id: node_id,
                 sp: span, path: @ast::path};
 
-enum unsafe_ty { contains(ty::t), mut_contains(ty::t), }
+enum unsafe_ty { contains(ty::t), mutbl_contains(ty::t), }
 
 type binding = @{node_id: node_id,
                  span: span,
@@ -183,9 +183,9 @@ fn add_bindings_for_let(cx: ctx, &bs: [binding], loc: @ast::local) {
             err(cx, loc.span, "a reference binding can't be \
                                rooted in a temporary");
         }
-        for proot in pattern_roots(cx.tcx, root.mut, loc.node.pat) {
+        for proot in pattern_roots(cx.tcx, root.mutbl, loc.node.pat) {
             let bnd = mk_binding(cx, proot.id, proot.span, root_var,
-                                 unsafe_set(proot.mut));
+                                 unsafe_set(proot.mutbl));
             // Don't implicitly copy explicit references
             bnd.copied = not_allowed;
             bs += [bnd];
@@ -228,7 +228,7 @@ fn check_call(cx: ctx, sc: scope, f: @ast::expr, args: [@ast::expr])
         let arg = args[i];
         let root = expr_root(cx, arg, false);
         alt ty::resolved_mode(cx.tcx, arg_t.mode) {
-          ast::by_mut_ref {
+          ast::by_mutbl_ref {
             alt path_def(cx, arg) {
               some(def) {
                 let dnum = ast_util::def_id_of_def(def).node;
@@ -242,14 +242,14 @@ fn check_call(cx: ctx, sc: scope, f: @ast::expr, args: [@ast::expr])
         let root_var = path_def_id(cx, root.ex);
         let arg_copied = alt ty::resolved_mode(cx.tcx, arg_t.mode) {
           ast::by_move | ast::by_copy { copied }
-          ast::by_mut_ref { not_allowed }
+          ast::by_mutbl_ref { not_allowed }
           ast::by_ref | ast::by_val { not_copied }
         };
         bindings += [@{node_id: arg.id,
                        span: arg.span,
                        root_var: root_var,
                        local_id: 0u,
-                       unsafe_tys: unsafe_set(root.mut),
+                       unsafe_tys: unsafe_set(root.mutbl),
                        mutable copied: arg_copied}];
         i += 1u;
     }
@@ -285,7 +285,7 @@ fn check_call(cx: ctx, sc: scope, f: @ast::expr, args: [@ast::expr])
             let i = 0u;
             for arg_t: ty::arg in arg_ts {
                 let mut_alias =
-                    (ast::by_mut_ref == ty::arg_mode(cx.tcx, arg_t));
+                    (ast::by_mutbl_ref == ty::arg_mode(cx.tcx, arg_t));
                 if i != j &&
                        ty_can_unsafely_include(cx, unsafe_ty, arg_t.ty,
                                                mut_alias) &&
@@ -339,14 +339,14 @@ fn check_alt(cx: ctx, input: @ast::expr, arms: [ast::arm], sc: scope,
             span: span};
         let binding_info: [info] = [];
         for pat in a.pats {
-            for proot in pattern_roots(cx.tcx, root.mut, pat) {
+            for proot in pattern_roots(cx.tcx, root.mutbl, pat) {
                 let canon_id = pat_id_map.get(proot.name);
                 alt vec::find(binding_info, {|x| x.id == canon_id}) {
-                  some(s) { s.unsafe_tys += unsafe_set(proot.mut); }
+                  some(s) { s.unsafe_tys += unsafe_set(proot.mutbl); }
                   none {
                       binding_info += [
                           {id: canon_id,
-                           mutable unsafe_tys: unsafe_set(proot.mut),
+                           mutable unsafe_tys: unsafe_set(proot.mutbl),
                            span: proot.span}];
                   }
                 }
@@ -369,20 +369,20 @@ fn check_for(cx: ctx, local: @ast::local, seq: @ast::expr, blk: ast::blk,
 
     // If this is a mutable vector, don't allow it to be touched.
     let seq_t = ty::expr_ty(cx.tcx, seq);
-    let cur_mut = root.mut;
+    let cur_mutbl = root.mutbl;
     alt ty::get(seq_t).struct {
       ty::ty_vec(mt) {
-        if mt.mut != ast::imm {
-            cur_mut = some(contains(seq_t));
+        if mt.mutbl != ast::m_imm {
+            cur_mutbl = some(contains(seq_t));
         }
       }
       _ {}
     }
     let root_var = path_def_id(cx, root.ex);
     let new_bs = sc.bs;
-    for proot in pattern_roots(cx.tcx, cur_mut, local.node.pat) {
+    for proot in pattern_roots(cx.tcx, cur_mutbl, local.node.pat) {
         new_bs += [mk_binding(cx, proot.id, proot.span, root_var,
-                              unsafe_set(proot.mut))];
+                              unsafe_set(proot.mutbl))];
     }
     visit::visit_block(blk, {bs: new_bs with sc}, v);
 }
@@ -493,36 +493,36 @@ fn path_def_id(cx: ctx, ex: @ast::expr) -> option<ast::node_id> {
 }
 
 fn ty_can_unsafely_include(cx: ctx, needle: unsafe_ty, haystack: ty::t,
-                           mut: bool) -> bool {
-    fn get_mut(cur: bool, mt: ty::mt) -> bool {
-        ret cur || mt.mut != ast::imm;
+                           mutbl: bool) -> bool {
+    fn get_mutbl(cur: bool, mt: ty::mt) -> bool {
+        ret cur || mt.mutbl != ast::m_imm;
     }
-    fn helper(tcx: ty::ctxt, needle: unsafe_ty, haystack: ty::t, mut: bool)
+    fn helper(tcx: ty::ctxt, needle: unsafe_ty, haystack: ty::t, mutbl: bool)
         -> bool {
         if alt needle {
           contains(ty) { ty == haystack }
-          mut_contains(ty) { mut && ty == haystack }
+          mutbl_contains(ty) { mutbl && ty == haystack }
         } { ret true; }
         alt ty::get(haystack).struct {
           ty::ty_enum(_, ts) {
             for t: ty::t in ts {
-                if helper(tcx, needle, t, mut) { ret true; }
+                if helper(tcx, needle, t, mutbl) { ret true; }
             }
             ret false;
           }
           ty::ty_box(mt) | ty::ty_ptr(mt) | ty::ty_uniq(mt) {
-            ret helper(tcx, needle, mt.ty, get_mut(mut, mt));
+            ret helper(tcx, needle, mt.ty, get_mutbl(mutbl, mt));
           }
           ty::ty_rec(fields) {
             for f: ty::field in fields {
-                if helper(tcx, needle, f.mt.ty, get_mut(mut, f.mt)) {
+                if helper(tcx, needle, f.mt.ty, get_mutbl(mutbl, f.mt)) {
                     ret true;
                 }
             }
             ret false;
           }
           ty::ty_tup(ts) {
-            for t in ts { if helper(tcx, needle, t, mut) { ret true; } }
+            for t in ts { if helper(tcx, needle, t, mutbl) { ret true; } }
             ret false;
           }
           ty::ty_fn({proto: ast::proto_bare, _}) { ret false; }
@@ -532,11 +532,11 @@ fn ty_can_unsafely_include(cx: ctx, needle: unsafe_ty, haystack: ty::t,
           // treated as opaque downstream, and is thus safe unless we
           // saw mutable fields, in which case the whole thing can be
           // overwritten.
-          ty::ty_param(_, _) { ret mut; }
+          ty::ty_param(_, _) { ret mutbl; }
           _ { ret false; }
         }
     }
-    ret helper(cx.tcx, needle, haystack, mut);
+    ret helper(cx.tcx, needle, haystack, mutbl);
 }
 
 fn def_is_local(d: ast::def) -> bool {
@@ -589,66 +589,66 @@ fn copy_is_expensive(tcx: ty::ctxt, ty: ty::t) -> bool {
 
 type pattern_root = {id: node_id,
                      name: ident,
-                     mut: option<unsafe_ty>,
+                     mutbl: option<unsafe_ty>,
                      span: span};
 
-fn pattern_roots(tcx: ty::ctxt, mut: option<unsafe_ty>, pat: @ast::pat)
+fn pattern_roots(tcx: ty::ctxt, mutbl: option<unsafe_ty>, pat: @ast::pat)
     -> [pattern_root] {
-    fn walk(tcx: ty::ctxt, mut: option<unsafe_ty>, pat: @ast::pat,
+    fn walk(tcx: ty::ctxt, mutbl: option<unsafe_ty>, pat: @ast::pat,
             &set: [pattern_root]) {
         alt normalize_pat(tcx, pat).node {
           ast::pat_wild | ast::pat_lit(_) | ast::pat_range(_, _) {}
           ast::pat_ident(nm, sub) {
-            set += [{id: pat.id, name: path_to_ident(nm), mut: mut,
+            set += [{id: pat.id, name: path_to_ident(nm), mutbl: mutbl,
                         span: pat.span}];
-            alt sub { some(p) { walk(tcx, mut, p, set); } _ {} }
+            alt sub { some(p) { walk(tcx, mutbl, p, set); } _ {} }
           }
           ast::pat_enum(_, ps) | ast::pat_tup(ps) {
-            for p in ps { walk(tcx, mut, p, set); }
+            for p in ps { walk(tcx, mutbl, p, set); }
           }
           ast::pat_rec(fs, _) {
             let ty = ty::node_id_to_type(tcx, pat.id);
             for f in fs {
-                let m = ty::get_field(ty, f.ident).mt.mut != ast::imm,
-                    c = if m { some(contains(ty)) } else { mut };
+                let m = ty::get_field(ty, f.ident).mt.mutbl != ast::m_imm,
+                    c = if m { some(contains(ty)) } else { mutbl };
                 walk(tcx, c, f.pat, set);
             }
           }
           ast::pat_box(p) {
             let ty = ty::node_id_to_type(tcx, pat.id);
             let m = alt ty::get(ty).struct {
-              ty::ty_box(mt) { mt.mut != ast::imm }
+              ty::ty_box(mt) { mt.mutbl != ast::m_imm }
               _ { tcx.sess.span_bug(pat.span, "box pat has non-box type"); }
             },
-                c = if m  {some(contains(ty)) } else { mut };
+                c = if m  {some(contains(ty)) } else { mutbl };
             walk(tcx, c, p, set);
           }
           ast::pat_uniq(p) {
             let ty = ty::node_id_to_type(tcx, pat.id);
             let m = alt ty::get(ty).struct {
-              ty::ty_uniq(mt) { mt.mut != ast::imm }
+              ty::ty_uniq(mt) { mt.mutbl != ast::m_imm }
               _ { tcx.sess.span_bug(pat.span, "uniq pat has non-uniq type"); }
             },
-                c = if m { some(contains(ty)) } else { mut };
+                c = if m { some(contains(ty)) } else { mutbl };
             walk(tcx, c, p, set);
           }
         }
     }
     let set = [];
-    walk(tcx, mut, pat, set);
+    walk(tcx, mutbl, pat, set);
     ret set;
 }
 
-// Wraps the expr_root in mut.rs to also handle roots that exist through
+// Wraps the expr_root in mutbl.rs to also handle roots that exist through
 // return-by-reference
 fn expr_root(cx: ctx, ex: @ast::expr, autoderef: bool)
-    -> {ex: @ast::expr, mut: option<unsafe_ty>} {
-    let base_root = mut::expr_root(cx.tcx, ex, autoderef);
+    -> {ex: @ast::expr, mutbl: option<unsafe_ty>} {
+    let base_root = mutbl::expr_root(cx.tcx, ex, autoderef);
     let unsafe_ty = none;
     for d in *base_root.ds {
-        if d.mut { unsafe_ty = some(contains(d.outer_t)); break; }
+        if d.mutbl { unsafe_ty = some(contains(d.outer_t)); break; }
     }
-    ret {ex: base_root.ex, mut: unsafe_ty};
+    ret {ex: base_root.ex, mutbl: unsafe_ty};
 }
 
 fn unsafe_set(from: option<unsafe_ty>) -> [unsafe_ty] {