bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

make mut a keyword synonymous with mutable

Browse source 
first step towards issue #1273
This commit is contained in:
Niko Matsakis 2012-02-15 11:25:39 -08:00
parent dddd9908d5
commit bfff2a8d55
29 changed files with 224 additions and 206 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/comp/driver/driver.rs
View file

@ -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));

14
src/comp/front/test.rs
View file

@ -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 =

8
src/comp/metadata/astencode.rs
View file

@ -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);

10
src/comp/metadata/tydecode.rs
View file

@ -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 }

10
src/comp/metadata/tyencode.rs
View file

@ -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('='); }

88
src/comp/middle/alias.rs
View file

@ -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] {

8
src/comp/middle/debuginfo.rs
View file

@ -587,21 +587,21 @@ fn create_ty(_cx: @crate_ctxt, _t: ty::t, _ty: @ast::ty)
ty::ty_float(t) { ast::ty_float(t) }
ty::ty_uint(t) { ast::ty_uint(t) }
ty::ty_box(mt) { ast::ty_box({ty: t_to_ty(cx, mt.ty, span),
mut: mt.mut}) }
mutbl: mt.mutbl}) }
ty::ty_uniq(mt) { ast::ty_uniq({ty: t_to_ty(cx, mt.ty, span),
mut: mt.mut}) }
mutbl: mt.mutbl}) }
ty::ty_rec(fields) {
let fs = [];
for field in fields {
fs += [{node: {ident: field.ident,
mt: {ty: t_to_ty(cx, field.mt.ty, span),
mut: field.mt.mut}},
mutbl: field.mt.mutbl}},
span: span}];
}
ast::ty_rec(fs)
}
ty::ty_vec(mt) { ast::ty_vec({ty: t_to_ty(cx, mt.ty, span),
mut: mt.mut}) }
mutbl: mt.mutbl}) }
_ {
cx.tcx.sess.span_bug(span, "t_to_ty: Can't handle this type");
}

2
src/comp/middle/kind.rs
View file

@ -167,7 +167,7 @@ fn check_expr(e: @expr, cx: ctx, v: visit::vt<ctx>) {
for arg_t in ty::ty_fn_args(ty::expr_ty(cx.tcx, f)) {
alt ty::arg_mode(cx.tcx, arg_t) {
by_copy { maybe_copy(cx, args[i]); }
by_ref | by_val | by_mut_ref | by_move { }
by_ref | by_val | by_mutbl_ref | by_move { }
}
i += 1u;
}

4
src/comp/middle/last_use.rs
View file

@ -156,7 +156,7 @@ fn visit_expr(ex: @expr, cx: ctx, v: visit::vt<ctx>) {
}
_ {
alt ty::arg_mode(cx.tcx, arg_ts[i]) {
by_mut_ref { clear_if_path(cx, arg, v, false); }
by_mutbl_ref { clear_if_path(cx, arg, v, false); }
_ { v.visit_expr(arg, cx, v); }
}
}
@ -299,7 +299,7 @@ fn clear_def_if_path(cx: ctx, d: def, to: bool)
clear_in_current(cx, def_id.node, to);
some(def_id.node)
}
by_ref | by_val | by_mut_ref {
by_ref | by_val | by_mutbl_ref {
none
}
}

69
src/comp/middle/mut.rs → src/comp/middle/mutbl.rs
View file

@ -5,7 +5,7 @@ import driver::session::session;
enum deref_t { unbox(bool), field, index, }
type deref = @{mut: bool, kind: deref_t, outer_t: ty::t};
type deref = @{mutbl: bool, kind: deref_t, outer_t: ty::t};
// Finds the root (the thing that is dereferenced) for the given expr, and a
// vec of dereferences that were used on this root. Note that, in this vec,
@ -18,15 +18,19 @@ fn expr_root(tcx: ty::ctxt, ex: @expr, autoderef: bool) ->
while true {
alt ty::get(t).struct {
ty::ty_box(mt) {
ds += [@{mut: mt.mut == mut, kind: unbox(false), outer_t: t}];
ds += [@{mutbl: mt.mutbl == m_mutbl,
kind: unbox(false),
outer_t: t}];
t = mt.ty;
}
ty::ty_uniq(mt) {
ds += [@{mut: mt.mut == mut, kind: unbox(false), outer_t: t}];
ds += [@{mutbl: mt.mutbl == m_mutbl,
kind: unbox(false),
outer_t: t}];
t = mt.ty;
}
ty::ty_res(_, inner, tps) {
ds += [@{mut: false, kind: unbox(false), outer_t: t}];
ds += [@{mutbl: false, kind: unbox(false), outer_t: t}];
t = ty::substitute_type_params(tcx, tps, inner);
}
ty::ty_enum(did, tps) {
@ -35,7 +39,7 @@ fn expr_root(tcx: ty::ctxt, ex: @expr, autoderef: bool) ->
vec::len(variants[0].args) != 1u {
break;
}
ds += [@{mut: false, kind: unbox(false), outer_t: t}];
ds += [@{mutbl: false, kind: unbox(false), outer_t: t}];
t = ty::substitute_type_params(tcx, tps, variants[0].args[0]);
}
_ { break; }
@ -48,19 +52,19 @@ fn expr_root(tcx: ty::ctxt, ex: @expr, autoderef: bool) ->
alt copy ex.node {
expr_field(base, ident, _) {
let auto_unbox = maybe_auto_unbox(tcx, ty::expr_ty(tcx, base));
let is_mut = false;
let is_mutbl = false;
alt ty::get(auto_unbox.t).struct {
ty::ty_rec(fields) {
for fld: ty::field in fields {
if str::eq(ident, fld.ident) {
is_mut = fld.mt.mut == mut;
is_mutbl = fld.mt.mutbl == m_mutbl;
break;
}
}
}
_ {}
}
ds += [@{mut: is_mut, kind: field, outer_t: auto_unbox.t}];
ds += [@{mutbl: is_mutbl, kind: field, outer_t: auto_unbox.t}];
ds += auto_unbox.ds;
ex = base;
}
@ -69,12 +73,12 @@ fn expr_root(tcx: ty::ctxt, ex: @expr, autoderef: bool) ->
alt ty::get(auto_unbox.t).struct {
ty::ty_vec(mt) {
ds +=
[@{mut: mt.mut == mut,
[@{mutbl: mt.mutbl == m_mutbl,
kind: index,
outer_t: auto_unbox.t}];
}
ty::ty_str {
ds += [@{mut: false, kind: index, outer_t: auto_unbox.t}];
ds += [@{mutbl: false, kind: index, outer_t: auto_unbox.t}];
}
_ { break; }
}
@ -84,17 +88,20 @@ fn expr_root(tcx: ty::ctxt, ex: @expr, autoderef: bool) ->
expr_unary(op, base) {
if op == deref {
let base_t = ty::expr_ty(tcx, base);
let is_mut = false, ptr = false;
let is_mutbl = false, ptr = false;
alt ty::get(base_t).struct {
ty::ty_box(mt) { is_mut = mt.mut == mut; }
ty::ty_uniq(mt) { is_mut = mt.mut == mut; }
ty::ty_box(mt) { is_mutbl = mt.mutbl == m_mutbl; }
ty::ty_uniq(mt) { is_mutbl = mt.mutbl == m_mutbl; }
ty::ty_res(_, _, _) { }
ty::ty_enum(_, _) { }
ty::ty_ptr(mt) { is_mut = mt.mut == mut; ptr = true; }
ty::ty_ptr(mt) {
is_mutbl = mt.mutbl == m_mutbl;
ptr = true;
}
_ { tcx.sess.span_bug(base.span, "Ill-typed base \
expression in deref"); }
}
ds += [@{mut: is_mut, kind: unbox(ptr && is_mut),
ds += [@{mutbl: is_mutbl, kind: unbox(ptr && is_mutbl),
outer_t: base_t}];
ex = base;
} else { break; }
@ -109,27 +116,27 @@ fn expr_root(tcx: ty::ctxt, ex: @expr, autoderef: bool) ->
ret {ex: ex, ds: @ds};
}
// Actual mut-checking pass
// Actual mutbl-checking pass
type mut_map = std::map::hashmap<node_id, ()>;
type ctx = {tcx: ty::ctxt, mut_map: mut_map};
type mutbl_map = std::map::hashmap<node_id, ()>;
type ctx = {tcx: ty::ctxt, mutbl_map: mutbl_map};
fn check_crate(tcx: ty::ctxt, crate: @crate) -> mut_map {
let cx = @{tcx: tcx, mut_map: std::map::new_int_hash()};
fn check_crate(tcx: ty::ctxt, crate: @crate) -> mutbl_map {
let cx = @{tcx: tcx, mutbl_map: std::map::new_int_hash()};
let v = @{visit_expr: bind visit_expr(cx, _, _, _),
visit_decl: bind visit_decl(cx, _, _, _)
with *visit::default_visitor()};
visit::visit_crate(*crate, (), visit::mk_vt(v));
ret cx.mut_map;
ret cx.mutbl_map;
}
enum msg { msg_assign, msg_move_out, msg_mut_ref, }
enum msg { msg_assign, msg_move_out, msg_mutbl_ref, }
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_mut_ref { "passing " + name + " by mutable reference" }
msg_mutbl_ref { "passing " + name + " by mutable reference" }
});
}
@ -178,7 +185,7 @@ fn check_lval(cx: @ctx, dest: @expr, msg: msg) {
some(name) { mk_err(cx, dest.span, msg, name); }
_ { }
}
cx.mut_map.insert(ast_util::def_id_of_def(def).node, ());
cx.mutbl_map.insert(ast_util::def_id_of_def(def).node, ());
}
_ {
let root = expr_root(cx.tcx, dest, false);
@ -186,12 +193,12 @@ fn check_lval(cx: @ctx, dest: @expr, msg: msg) {
if msg != msg_move_out {
mk_err(cx, dest.span, msg, "non-lvalue");
}
} else if !root.ds[0].mut {
} else if !root.ds[0].mutbl {
let name =
alt root.ds[0].kind {
mut::unbox(_) { "immutable box" }
mut::field { "immutable field" }
mut::index { "immutable vec content" }
mutbl::unbox(_) { "immutable box" }
mutbl::field { "immutable field" }
mutbl::index { "immutable vec content" }
};
mk_err(cx, dest.span, msg, name);
}
@ -227,7 +234,7 @@ fn check_call(cx: @ctx, f: @expr, args: [@expr]) {
let i = 0u;
for arg_t: ty::arg in arg_ts {
alt ty::resolved_mode(cx.tcx, arg_t.mode) {
by_mut_ref { check_lval(cx, args[i], msg_mut_ref); }
by_mutbl_ref { check_lval(cx, args[i], msg_mutbl_ref); }
by_move { check_lval(cx, args[i], msg_move_out); }
by_ref | by_val | by_copy { }
}
@ -242,7 +249,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_mut_ref { some("by mutable reference") }
by_mutbl_ref { some("by mutable reference") }
by_move { some("by move") }
_ { none }
};
@ -269,7 +276,7 @@ fn is_immutable_def(cx: @ctx, def: def) -> option<str> {
def_arg(_, m) {
alt ty::resolved_mode(cx.tcx, m) {
by_ref | by_val { some("argument") }
by_mut_ref | by_move | by_copy { none }
by_mutbl_ref | by_move | by_copy { none }
}
}
def_self(_) { some("self argument") }

10
src/comp/middle/trans/base.rs
View file

@ -3987,7 +3987,7 @@ fn alloc_local(cx: @block_ctxt, local: @ast::local) -> @block_ctxt {
};
// Do not allocate space for locals that can be kept immediate.
let ccx = bcx_ccx(cx);
if is_simple && !ccx.mut_map.contains_key(local.node.pat.id) &&
if is_simple && !ccx.mutbl_map.contains_key(local.node.pat.id) &&
!ccx.last_uses.contains_key(local.node.pat.id) &&
ty::type_is_immediate(t) {
alt local.node.init {
@ -4166,7 +4166,7 @@ fn copy_args_to_allocas(fcx: @fn_ctxt, bcx: @block_ctxt, args: [ast::arg],
let argval = alt fcx.llargs.get(id) { local_mem(v) { v }
_ { epic_fail() } };
alt ty::resolved_mode(tcx, arg.mode) {
ast::by_mut_ref { }
ast::by_mutbl_ref { }
ast::by_move | ast::by_copy { add_clean(bcx, argval, arg.ty); }
ast::by_val {
if !ty::type_is_immediate(arg.ty) {
@ -4598,7 +4598,7 @@ fn create_main_wrapper(ccx: @crate_ctxt, sp: span, main_llfn: ValueRef,
let unit_ty = ty::mk_str(ccx.tcx);
let vecarg_ty: ty::arg =
{mode: ast::expl(ast::by_val),
ty: ty::mk_vec(ccx.tcx, {ty: unit_ty, mut: ast::imm})};
ty: ty::mk_vec(ccx.tcx, {ty: unit_ty, mutbl: ast::m_imm})};
// FIXME: mk_nil should have a postcondition
let nt = ty::mk_nil(ccx.tcx);
let llfty = type_of_fn(ccx, [vecarg_ty], nt, []);
@ -5003,7 +5003,7 @@ fn write_abi_version(ccx: @crate_ctxt) {
fn trans_crate(sess: session::session, crate: @ast::crate, tcx: ty::ctxt,
output: str, emap: resolve::exp_map, amap: ast_map::map,
mut_map: mut::mut_map, copy_map: alias::copy_map,
mutbl_map: mutbl::mutbl_map, copy_map: alias::copy_map,
last_uses: last_use::last_uses, impl_map: resolve::impl_map,
method_map: typeck::method_map, dict_map: typeck::dict_map)
-> (ModuleRef, link::link_meta) {
@ -5080,7 +5080,7 @@ fn trans_crate(sess: session::session, crate: @ast::crate, tcx: ty::ctxt,
type_sha1s: ty::new_ty_hash(),
type_short_names: ty::new_ty_hash(),
tcx: tcx,
mut_map: mut_map,
mutbl_map: mutbl_map,
copy_map: copy_map,
last_uses: last_uses,
impl_map: impl_map,

4
src/comp/middle/trans/closure.rs
View file

@ -276,7 +276,7 @@ fn store_environment(
// tuple. This could be a ptr in uniq or a box or on stack,
// whatever.
let cbox_ty = tuplify_box_ty(tcx, cdata_ty);
let cboxptr_ty = ty::mk_ptr(tcx, {ty:cbox_ty, mut:ast::imm});
let cboxptr_ty = ty::mk_ptr(tcx, {ty:cbox_ty, mutbl:ast::m_imm});
let llbox = cast_if_we_can(bcx, llbox, cboxptr_ty);
// If necessary, copy tydescs describing type parameters into the
@ -905,7 +905,7 @@ fn trans_bind_thunk(ccx: @crate_ctxt,
bcx = take_ty(bcx, alloc, out_arg.ty);
val = alloc;
}
ast::by_ref | ast::by_mut_ref | ast::by_move { }
ast::by_ref | ast::by_mutbl_ref | ast::by_move { }
}
// If the type is parameterized, then we need to cast the

4
src/comp/middle/trans/common.rs
View file

@ -104,7 +104,7 @@ type crate_ctxt =
type_sha1s: hashmap<ty::t, str>,
type_short_names: hashmap<ty::t, str>,
tcx: ty::ctxt,
mut_map: mut::mut_map,
mutbl_map: mutbl::mutbl_map,
copy_map: alias::copy_map,
last_uses: last_use::last_uses,
impl_map: resolve::impl_map,
@ -622,7 +622,7 @@ fn tuplify_box_ty(tcx: ty::ctxt, t: ty::t) -> ty::t {
// descr is embedded in the box (ty::type vs ty::send_type). This is useful
// for unique closure boxes, hence the name "cbox_ty" (closure box type).
fn tuplify_cbox_ty(tcx: ty::ctxt, t: ty::t, tydesc_t: ty::t) -> ty::t {
let ptr = ty::mk_ptr(tcx, {ty: ty::mk_nil(tcx), mut: ast::imm});
let ptr = ty::mk_ptr(tcx, {ty: ty::mk_nil(tcx), mutbl: ast::m_imm});
ret ty::mk_tup(tcx, [ty::mk_uint(tcx), tydesc_t,
ptr, ptr,
t]);

2
src/comp/middle/trans/shape.rs
View file

@ -782,7 +782,7 @@ fn dynamic_metrics(cx: @block_ctxt, t: ty::t) -> metrics {
// nominal type that has pointers to itself in it.
fn simplify_type(tcx: ty::ctxt, typ: ty::t) -> ty::t {
fn nilptr(tcx: ty::ctxt) -> ty::t {
ty::mk_ptr(tcx, {ty: ty::mk_nil(tcx), mut: ast::imm})
ty::mk_ptr(tcx, {ty: ty::mk_nil(tcx), mutbl: ast::m_imm})
}
fn simplifier(tcx: ty::ctxt, typ: ty::t) -> ty::t {
alt ty::get(typ).struct {

2
src/comp/middle/tstate/auxiliary.rs
View file

@ -1089,7 +1089,7 @@ fn callee_arg_init_ops(fcx: fn_ctxt, callee: node_id) -> [init_op] {
vec::map(callee_modes(fcx, callee)) {|m|
alt ty::resolved_mode(fcx.ccx.tcx, m) {
by_move { init_move }
by_copy | by_ref | by_val | by_mut_ref { init_assign }
by_copy | by_ref | by_val | by_mutbl_ref { init_assign }
}
}
}

2
src/comp/middle/tstate/pre_post_conditions.rs
View file

@ -275,7 +275,7 @@ fn forget_args_moved_in(fcx: fn_ctxt, parent: @expr, modes: [mode],
vec::iteri(modes) {|i,mode|
alt ty::resolved_mode(fcx.ccx.tcx, mode) {
by_move { forget_in_postcond(fcx, parent.id, operands[i].id); }
by_ref | by_val | by_mut_ref | by_copy { }
by_ref | by_val | by_mutbl_ref | by_copy { }
}
}
}

57
src/comp/middle/ty.rs
View file

@ -147,7 +147,7 @@ type method = {ident: ast::ident,
type constr_table = hashmap<ast::node_id, [constr]>;
type mt = {ty: t, mut: ast::mutability};
type mt = {ty: t, mutbl: ast::mutability};
// Contains information needed to resolve types and (in the future) look up
@ -423,15 +423,18 @@ fn mk_enum(cx: ctxt, did: ast::def_id, tys: [t]) -> t {
fn mk_box(cx: ctxt, tm: mt) -> t { mk_t(cx, ty_box(tm)) }
fn mk_imm_box(cx: ctxt, ty: t) -> t { mk_box(cx, {ty: ty, mut: ast::imm}) }
fn mk_imm_box(cx: ctxt, ty: t) -> t { mk_box(cx, {ty: ty,
mutbl: ast::m_imm}) }
fn mk_uniq(cx: ctxt, tm: mt) -> t { mk_t(cx, ty_uniq(tm)) }
fn mk_imm_uniq(cx: ctxt, ty: t) -> t { mk_uniq(cx, {ty: ty, mut: ast::imm}) }
fn mk_imm_uniq(cx: ctxt, ty: t) -> t { mk_uniq(cx, {ty: ty,
mutbl: ast::m_imm}) }
fn mk_ptr(cx: ctxt, tm: mt) -> t { mk_t(cx, ty_ptr(tm)) }
fn mk_mut_ptr(cx: ctxt, ty: t) -> t { mk_ptr(cx, {ty: ty, mut: ast::mut}) }
fn mk_mut_ptr(cx: ctxt, ty: t) -> t { mk_ptr(cx, {ty: ty,
mutbl: ast::m_mutbl}) }
fn mk_vec(cx: ctxt, tm: mt) -> t { mk_t(cx, ty_vec(tm)) }
@ -541,16 +544,16 @@ fn fold_ty(cx: ctxt, fld: fold_mode, ty_0: t) -> t {
ty_str | ty_type | ty_send_type | ty_opaque_closure_ptr(_) |
ty_opaque_box {}
ty_box(tm) {
ty = mk_box(cx, {ty: fold_ty(cx, fld, tm.ty), mut: tm.mut});
ty = mk_box(cx, {ty: fold_ty(cx, fld, tm.ty), mutbl: tm.mutbl});
}
ty_uniq(tm) {
ty = mk_uniq(cx, {ty: fold_ty(cx, fld, tm.ty), mut: tm.mut});
ty = mk_uniq(cx, {ty: fold_ty(cx, fld, tm.ty), mutbl: tm.mutbl});
}
ty_ptr(tm) {
ty = mk_ptr(cx, {ty: fold_ty(cx, fld, tm.ty), mut: tm.mut});
ty = mk_ptr(cx, {ty: fold_ty(cx, fld, tm.ty), mutbl: tm.mutbl});
}
ty_vec(tm) {
ty = mk_vec(cx, {ty: fold_ty(cx, fld, tm.ty), mut: tm.mut});
ty = mk_vec(cx, {ty: fold_ty(cx, fld, tm.ty), mutbl: tm.mutbl});
}
ty_enum(tid, subtys) {
ty = mk_enum(cx, tid, vec::map(subtys, {|t| fold_ty(cx, fld, t) }));
@ -565,7 +568,7 @@ fn fold_ty(cx: ctxt, fld: fold_mode, ty_0: t) -> t {
let new_fields: [field] = [];
for fl: field in fields {
let new_ty = fold_ty(cx, fld, fl.mt.ty);
let new_mt = {ty: new_ty, mut: fl.mt.mut};
let new_mt = {ty: new_ty, mutbl: fl.mt.mutbl};
new_fields += [{ident: fl.ident, mt: new_mt}];
}
ty = mk_rec(cx, new_fields);
@ -922,12 +925,11 @@ fn type_allows_implicit_copy(cx: ctxt, ty: t) -> bool {
alt sty {
ty_param(_, _) { true }
ty_vec(mt) {
mt.mut != ast::imm
mt.mutbl != ast::m_imm
}
ty_rec(fields) {
for field in fields {
if field.mt.mut !=
ast::imm {
if field.mt.mutbl != ast::m_imm {
ret true;
}
}
@ -1665,7 +1667,7 @@ mod unify {
// If you're unifying on something mutable then we have to
// be invariant on the inner type
let newvariance = alt expected {
ast::mut {
ast::m_mutbl {
variance_transform(variance, invariant)
}
_ {
@ -1675,11 +1677,11 @@ mod unify {
if expected == actual { ret some((expected, newvariance)); }
if variance == covariant {
if expected == ast::maybe_mut {
if expected == ast::m_const {
ret some((actual, newvariance));
}
} else if variance == contravariant {
if actual == ast::maybe_mut {
if actual == ast::m_const {
ret some((expected, newvariance));
}
}
@ -1960,7 +1962,7 @@ mod unify {
alt get(actual).struct {
ty_box(actual_mt) {
let (mutt, var) = alt unify_mut(
expected_mt.mut, actual_mt.mut, variance) {
expected_mt.mutbl, actual_mt.mutbl, variance) {
none { ret ures_err(terr_box_mutability); }
some(mv) { mv }
};
@ -1968,7 +1970,7 @@ mod unify {
cx, expected_mt.ty, actual_mt.ty, var);
alt result {
ures_ok(result_sub) {
let mt = {ty: result_sub, mut: mutt};
let mt = {ty: result_sub, mutbl: mutt};
ret ures_ok(mk_box(cx.tcx, mt));
}
_ { ret result; }
@ -1981,7 +1983,7 @@ mod unify {
alt get(actual).struct {
ty_uniq(actual_mt) {
let (mutt, var) = alt unify_mut(
expected_mt.mut, actual_mt.mut, variance) {
expected_mt.mutbl, actual_mt.mutbl, variance) {
none { ret ures_err(terr_box_mutability); }
some(mv) { mv }
};
@ -1989,7 +1991,7 @@ mod unify {
cx, expected_mt.ty, actual_mt.ty, var);
alt result {
ures_ok(result_mt) {
let mt = {ty: result_mt, mut: mutt};
let mt = {ty: result_mt, mutbl: mutt};
ret ures_ok(mk_uniq(cx.tcx, mt));
}
_ { ret result; }
@ -2002,7 +2004,7 @@ mod unify {
alt get(actual).struct {
ty_vec(actual_mt) {
let (mutt, var) = alt unify_mut(
expected_mt.mut, actual_mt.mut, variance) {
expected_mt.mutbl, actual_mt.mutbl, variance) {
none { ret ures_err(terr_vec_mutability); }
some(mv) { mv }
};
@ -2010,7 +2012,7 @@ mod unify {
cx, expected_mt.ty, actual_mt.ty, var);
alt result {
ures_ok(result_sub) {
let mt = {ty: result_sub, mut: mutt};
let mt = {ty: result_sub, mutbl: mutt};
ret ures_ok(mk_vec(cx.tcx, mt));
}
_ { ret result; }
@ -2023,7 +2025,7 @@ mod unify {
alt get(actual).struct {
ty_ptr(actual_mt) {
let (mutt, var) = alt unify_mut(
expected_mt.mut, actual_mt.mut, variance) {
expected_mt.mutbl, actual_mt.mutbl, variance) {
none { ret ures_err(terr_vec_mutability); }
some(mv) { mv }
};
@ -2031,7 +2033,7 @@ mod unify {
cx, expected_mt.ty, actual_mt.ty, var);
alt result {
ures_ok(result_sub) {
let mt = {ty: result_sub, mut: mutt};
let mt = {ty: result_sub, mutbl: mutt};
ret ures_ok(mk_ptr(cx.tcx, mt));
}
_ { ret result; }
@ -2086,9 +2088,10 @@ mod unify {
while i < expected_len {
let expected_field = expected_fields[i];
let actual_field = actual_fields[i];
let (mutt, var) = alt unify_mut(
expected_field.mt.mut, actual_field.mt.mut, variance)
{
let u_mut = unify_mut(expected_field.mt.mutbl,
actual_field.mt.mutbl,
variance);
let (mutt, var) = alt u_mut {
none { ret ures_err(terr_record_mutability); }
some(mv) { mv }
};
@ -2103,7 +2106,7 @@ mod unify {
actual_field.mt.ty, var);
alt result {
ures_ok(rty) {
let mt = {ty: rty, mut: mutt};
let mt = {ty: rty, mutbl: mutt};
result_fields += [{mt: mt with expected_field}];
}
_ { ret result; }

20
src/comp/middle/typeck.rs
View file

@ -115,7 +115,7 @@ fn ty_param_bounds_and_ty_for_def(fcx: @fn_ctxt, sp: span, defn: ast::def) ->
fcx.ccx.tcx,
{
ty: ty::mk_mach_uint(fcx.ccx.tcx, ast::ty_u8),
mut: ast::imm
mutbl: ast::m_imm
})
};
}
@ -259,7 +259,7 @@ fn ast_ty_to_ty(tcx: ty::ctxt, mode: mode, &&ast_ty: @ast::ty) -> ty::t {
tcx.ast_ty_to_ty_cache.insert(ast_ty, none::<ty::t>);
fn ast_mt_to_mt(tcx: ty::ctxt, mode: mode, mt: ast::mt) -> ty::mt {
ret {ty: ast_ty_to_ty(tcx, mode, mt.ty), mut: mt.mut};
ret {ty: ast_ty_to_ty(tcx, mode, mt.ty), mutbl: mt.mutbl};
}
fn instantiate(tcx: ty::ctxt, sp: span, mode: mode,
id: ast::def_id, args: [@ast::ty]) -> ty::t {
@ -2057,9 +2057,11 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier,
bot = check_expr(fcx, oper);
let oper_t = expr_ty(tcx, oper);
alt unop {
ast::box(mut) { oper_t = ty::mk_box(tcx, {ty: oper_t, mut: mut}); }
ast::uniq(mut) {
oper_t = ty::mk_uniq(tcx, {ty: oper_t, mut: mut});
ast::box(mutbl) {
oper_t = ty::mk_box(tcx, {ty: oper_t, mutbl: mutbl});
}
ast::uniq(mutbl) {
oper_t = ty::mk_uniq(tcx, {ty: oper_t, mutbl: mutbl});
}
ast::deref {
alt structure_of(fcx, expr.span, oper_t) {
@ -2358,10 +2360,10 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier,
}
write_ty(tcx, id, t_1);
}
ast::expr_vec(args, mut) {
ast::expr_vec(args, mutbl) {
let t: ty::t = next_ty_var(fcx);
for e: @ast::expr in args { bot |= check_expr_with(fcx, e, t); }
let typ = ty::mk_vec(tcx, {ty: t, mut: mut});
let typ = ty::mk_vec(tcx, {ty: t, mutbl: mutbl});
write_ty(tcx, id, typ);
}
ast::expr_tup(elts) {
@ -2381,7 +2383,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier,
for f: ast::field in fields {
bot |= check_expr(fcx, f.node.expr);
let expr_t = expr_ty(tcx, f.node.expr);
let expr_mt = {ty: expr_t, mut: f.node.mut};
let expr_mt = {ty: expr_t, mutbl: f.node.mutbl};
// for the most precise error message,
// should be f.node.expr.span, not f.span
fields_t +=
@ -2894,7 +2896,7 @@ fn check_item(ccx: @crate_ctxt, it: @ast::item) {
fn arg_is_argv_ty(_tcx: ty::ctxt, a: ty::arg) -> bool {
alt ty::get(a.ty).struct {
ty::ty_vec(mt) {
if mt.mut != ast::imm { ret false; }
if mt.mutbl != ast::m_imm { ret false; }
alt ty::get(mt.ty).struct {
ty::ty_str { ret true; }
_ { ret false; }

2
src/comp/rustc.rc
View file

@ -34,7 +34,7 @@ mod middle {
mod check_alt;
mod check_const;
mod lint;
mod mut;
mod mutbl;
mod alias;
mod last_use;
mod block_use;

8
src/comp/syntax/ast.rs
View file

@ -121,7 +121,7 @@ enum pat_ {
pat_range(@expr, @expr),
}
enum mutability { mut, imm, maybe_mut, }
enum mutability { m_mutbl, m_imm, m_const, }
enum proto {
proto_bare, // native fn
@ -173,7 +173,7 @@ enum inferable<T> {
}
// "resolved" mode: the real modes.
enum rmode { by_ref, by_val, by_mut_ref, by_move, by_copy }
enum rmode { by_ref, by_val, by_mutbl_ref, by_move, by_copy }
// inferable mode.
type mode = inferable<rmode>;
@ -205,7 +205,7 @@ enum decl_ { decl_local([@local]), decl_item(@item), }
type arm = {pats: [@pat], guard: option<@expr>, body: blk};
type field_ = {mut: mutability, ident: ident, expr: @expr};
type field_ = {mutbl: mutability, ident: ident, expr: @expr};
type field = spanned<field_>;
@ -316,7 +316,7 @@ enum lit_ {
// NB: If you change this, you'll probably want to change the corresponding
// type structure in middle/ty.rs as well.
type mt = {ty: @ty, mut: mutability};
type mt = {ty: @ty, mutbl: mutability};
type ty_field_ = {ident: ident, mt: mt};

4
src/comp/syntax/ast_util.rs
View file

@ -66,8 +66,8 @@ pure fn lazy_binop(b: binop) -> bool {
fn unop_to_str(op: unop) -> str {
alt op {
box(mt) { if mt == mut { ret "@mutable "; } ret "@"; }
uniq(mt) { if mt == mut { ret "~mutable "; } ret "~"; }
box(mt) { if mt == m_mutbl { ret "@mut "; } ret "@"; }
uniq(mt) { if mt == m_mutbl { ret "~mut "; } ret "~"; }
deref { ret "*"; }
not { ret "!"; }
neg { ret "-"; }

4
src/comp/syntax/ext/build.rs
View file

@ -61,7 +61,7 @@ fn mk_call(cx: ext_ctxt, sp: span, fn_path: [ast::ident],
// e = expr, t = type
fn mk_vec_e(cx: ext_ctxt, sp: span, exprs: [@ast::expr]) ->
@ast::expr {
let vecexpr = ast::expr_vec(exprs, ast::imm);
let vecexpr = ast::expr_vec(exprs, ast::m_imm);
ret @{id: cx.next_id(), node: vecexpr, span: sp};
}
fn mk_rec_e(cx: ext_ctxt, sp: span,
@ -72,7 +72,7 @@ fn mk_rec_e(cx: ext_ctxt, sp: span,
let ident = field.ident;
let val = field.ex;
let astfield =
{node: {mut: ast::imm, ident: ident, expr: val}, span: sp};
{node: {mutbl: ast::m_imm, ident: ident, expr: val}, span: sp};
astfields += [astfield];
}
let recexpr = ast::expr_rec(astfields, option::none::<@ast::expr>);

2
src/comp/syntax/ext/qquote.rs
View file

@ -231,7 +231,7 @@ fn finish<T: qq_helper>
[mk_str(cx,sp, loc.file.name),
mk_uint(cx,sp, loc.line),
mk_uint(cx,sp, loc.col)]),
mk_unary(cx,sp, ast::box(ast::imm),
mk_unary(cx,sp, ast::box(ast::m_imm),
mk_str(cx,sp, str2)),
mk_access_(cx,sp,
mk_access_(cx,sp, session_call(), "opts"),

2
src/comp/syntax/ext/simplext.rs
View file

@ -682,7 +682,7 @@ fn add_new_extension(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
let clauses: [@clause] = [];
for arg: @expr in args {
alt arg.node {
expr_vec(elts, mut) {
expr_vec(elts, mutbl) {
if vec::len(elts) != 2u {
cx.span_fatal((*arg).span,
"extension clause must consist of [" +

4
src/comp/syntax/fold.rs
View file

@ -337,7 +337,7 @@ fn wrap<T>(f: fn@(T, ast_fold) -> T)
fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
fn fold_field_(field: field, fld: ast_fold) -> field {
ret {node:
{mut: field.node.mut,
{mutbl: field.node.mutbl,
ident: fld.fold_ident(field.node.ident),
expr: fld.fold_expr(field.node.expr)},
span: field.span};
@ -434,7 +434,7 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
fn noop_fold_ty(t: ty_, fld: ast_fold) -> ty_ {
let fold_mac = bind fold_mac_(_, fld);
fn fold_mt(mt: mt, fld: ast_fold) -> mt {
{ty: fld.fold_ty(mt.ty), mut: mt.mut}
{ty: fld.fold_ty(mt.ty), mutbl: mt.mutbl}
}
fn fold_field(f: ty_field, fld: ast_fold) -> ty_field {
{node: {ident: fld.fold_ident(f.node.ident),

41
src/comp/syntax/parse/parser.rs
View file

@ -150,7 +150,7 @@ fn bad_expr_word_table() -> hashmap<str, ()> {
"export", "fail", "fn", "for", "if", "iface", "impl",
"import", "let", "log", "mod", "mutable", "native", "pure",
"resource", "ret", "trait", "type", "unchecked", "unsafe",
"while, crust"] {
"while", "crust", "mut"] {
words.insert(word, ());
}
words
@ -293,18 +293,18 @@ fn parse_ty_methods(p: parser) -> [ast::ty_method] {
}
fn parse_mt(p: parser) -> ast::mt {
let mut = parse_mutability(p);
let mutbl = parse_mutability(p);
let t = parse_ty(p, false);
ret {ty: t, mut: mut};
ret {ty: t, mutbl: mutbl};
}
fn parse_ty_field(p: parser) -> ast::ty_field {
let lo = p.span.lo;
let mut = parse_mutability(p);
let mutbl = parse_mutability(p);
let id = parse_ident(p);
expect(p, token::COLON);
let ty = parse_ty(p, false);
ret spanned(lo, ty.span.hi, {ident: id, mt: {ty: ty, mut: mut}});
ret spanned(lo, ty.span.hi, {ident: id, mt: {ty: ty, mutbl: mutbl}});
}
// if i is the jth ident in args, return j
@ -486,7 +486,7 @@ fn parse_ty(p: parser, colons_before_params: bool) -> @ast::ty {
fn parse_arg_mode(p: parser) -> ast::mode {
if eat(p, token::BINOP(token::AND)) {
ast::expl(ast::by_mut_ref)
ast::expl(ast::by_mutbl_ref)
} else if eat(p, token::BINOP(token::MINUS)) {
ast::expl(ast::by_move)
} else if eat(p, token::ANDAND) {
@ -693,11 +693,13 @@ 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") {
ast::mut
ast::m_mutbl
} else if eat_word(p, "mut") {
ast::m_mutbl
} else if eat_word(p, "const") {
ast::maybe_mut
ast::m_const
} else {
ast::imm
ast::m_imm
}
}
@ -707,7 +709,7 @@ fn parse_field(p: parser, sep: token::token) -> ast::field {
let i = parse_ident(p);
expect(p, sep);
let e = parse_expr(p);
ret spanned(lo, e.span.hi, {mut: m, ident: i, expr: e});
ret spanned(lo, e.span.hi, {mutbl: m, ident: i, expr: e});
}
fn mk_expr(p: parser, lo: uint, hi: uint, node: ast::expr_) -> @ast::expr {
@ -786,7 +788,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, "mutable") ||
if is_word(p, "mut") || is_word(p, "mutable") ||
is_plain_ident(p) && p.look_ahead(1u) == token::COLON {
let fields = [parse_field(p, token::COLON)];
let base = none;
@ -832,11 +834,11 @@ fn parse_bottom_expr(p: parser) -> pexpr {
ret pexpr(parse_block_expr(p, lo, ast::unsafe_blk));
} else if p.token == token::LBRACKET {
p.bump();
let mut = parse_mutability(p);
let mutbl = parse_mutability(p);
let es =
parse_seq_to_end(token::RBRACKET, seq_sep(token::COMMA),
parse_expr, p);
ex = ast::expr_vec(es, mut);
ex = ast::expr_vec(es, mutbl);
} else if p.token == token::POUND_LT {
p.bump();
let ty = parse_ty(p, false);
@ -971,7 +973,7 @@ fn parse_syntax_ext_naked(p: parser, lo: uint) -> @ast::expr {
};
let hi = es.span.hi;
e = some(mk_expr(p, es.span.lo, hi,
ast::expr_vec(es.node, ast::imm)));
ast::expr_vec(es.node, ast::m_imm)));
}
let b = none;
if p.token == token::LBRACE {
@ -1578,6 +1580,9 @@ fn parse_local(p: parser, allow_init: bool) -> @ast::local {
}
fn parse_let(p: parser) -> @ast::decl {
if eat_word(p, "mut") {
/* TODO */
}
let lo = p.span.lo;
let locals = [parse_local(p, true)];
while eat(p, token::COMMA) {
@ -1587,10 +1592,10 @@ fn parse_let(p: parser) -> @ast::decl {
}
fn parse_instance_var(p:parser) -> ast::class_member {
let is_mut = ast::class_immutable;
let is_mutbl = ast::class_immutable;
expect_word(p, "let");
if eat_word(p, "mutable") {
is_mut = ast::class_mutable;
if eat_word(p, "mut") || eat_word(p, "mutable") {
is_mutbl = ast::class_mutable;
}
if !is_plain_ident(p) {
p.fatal("expecting ident");
@ -1598,7 +1603,7 @@ fn parse_instance_var(p:parser) -> ast::class_member {
let name = parse_ident(p);
expect(p, token::COLON);
let ty = parse_ty(p, false);
ret ast::instance_var(name, ty, is_mut, p.get_id());
ret ast::instance_var(name, ty, is_mutbl, p.get_id());
}
fn parse_stmt(p: parser, first_item_attrs: [ast::attribute]) -> @ast::stmt {

30
src/comp/syntax/print/pprust.rs
View file

@ -318,10 +318,10 @@ fn print_type(s: ps, &&ty: @ast::ty) {
ast::ty_uniq(mt) { word(s.s, "~"); print_mt(s, mt); }
ast::ty_vec(mt) {
word(s.s, "[");
alt mt.mut {
ast::mut { word_space(s, "mutable"); }
ast::maybe_mut { word_space(s, "const"); }
ast::imm { }
alt mt.mutbl {
ast::m_mutbl { word_space(s, "mut"); }
ast::m_const { word_space(s, "const"); }
ast::m_imm { }
}
print_type(s, mt.ty);
word(s.s, "]");
@ -331,7 +331,7 @@ fn print_type(s: ps, &&ty: @ast::ty) {
word(s.s, "{");
fn print_field(s: ps, f: ast::ty_field) {
cbox(s, indent_unit);
print_mutability(s, f.node.mt.mut);
print_mutability(s, f.node.mt.mutbl);
word(s.s, f.node.ident);
word_space(s, ":");
print_type(s, f.node.mt.ty);
@ -785,10 +785,10 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
let ann_node = node_expr(s, expr);
s.ann.pre(ann_node);
alt expr.node {
ast::expr_vec(exprs, mut) {
ast::expr_vec(exprs, mutbl) {
ibox(s, indent_unit);
word(s.s, "[");
if mut == ast::mut {
if mutbl == ast::m_mutbl {
word(s.s, "mutable");
if vec::len(exprs) > 0u { nbsp(s); }
}
@ -799,7 +799,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.mut == ast::mut { word_nbsp(s, "mutable"); }
if field.node.mutbl == ast::m_mutbl { word_nbsp(s, "mutable"); }
word(s.s, field.node.ident);
word_space(s, ":");
print_expr(s, field.node.expr);
@ -1274,7 +1274,7 @@ fn print_fn_block_args(s: ps, decl: ast::fn_decl) {
fn mode_to_str(m: ast::mode) -> str {
alt m {
ast::expl(ast::by_mut_ref) { "&" }
ast::expl(ast::by_mutbl_ref) { "&" }
ast::expl(ast::by_move) { "-" }
ast::expl(ast::by_ref) { "&&" }
ast::expl(ast::by_val) { "++" }
@ -1436,16 +1436,16 @@ fn print_op_maybe_parens(s: ps, expr: @ast::expr, outer_prec: int) {
if add_them { pclose(s); }
}
fn print_mutability(s: ps, mut: ast::mutability) {
alt mut {
ast::mut { word_nbsp(s, "mutable"); }
ast::maybe_mut { word_nbsp(s, "const"); }
ast::imm {/* nothing */ }
fn print_mutability(s: ps, mutbl: ast::mutability) {
alt mutbl {
ast::m_mutbl { word_nbsp(s, "mutable"); }
ast::m_const { word_nbsp(s, "const"); }
ast::m_imm {/* nothing */ }
}
}
fn print_mt(s: ps, mt: ast::mt) {
print_mutability(s, mt.mut);
print_mutability(s, mt.mutbl);
print_type(s, mt.ty);
}

11
src/comp/util/ppaux.rs
View file

@ -53,12 +53,11 @@ fn ty_to_str(cx: ctxt, typ: t) -> str {
ret f.ident + ": " + mt_to_str(cx, f.mt);
}
fn mt_to_str(cx: ctxt, m: mt) -> str {
let mstr;
alt m.mut {
ast::mut { mstr = "mutable "; }
ast::imm { mstr = ""; }
ast::maybe_mut { mstr = "const "; }
}
let mstr = alt m.mutbl {
ast::m_mutbl { "mut " }
ast::m_imm { "" }
ast::m_const { "const " }
};
ret mstr + ty_to_str(cx, m.ty);
}
fn parameterized(cx: ctxt, base: str, tps: [ty::t]) -> str {

6
src/fuzzer/fuzzer.rs
View file

@ -50,8 +50,10 @@ fn common_exprs() -> [ast::expr] {
dse(ast::expr_lit(@dsl(ast::lit_nil))),
dse(ast::expr_lit(@dsl(ast::lit_bool(false)))),
dse(ast::expr_lit(@dsl(ast::lit_bool(true)))),
dse(ast::expr_unary(ast::box(ast::imm), @dse(ast::expr_lit(@dsl(ast::lit_bool(true)))))),
dse(ast::expr_unary(ast::uniq(ast::imm), @dse(ast::expr_lit(@dsl(ast::lit_bool(true))))))
dse(ast::expr_unary(ast::box(ast::m_imm),
@dse(ast::expr_lit(@dsl(ast::lit_bool(true)))))),
dse(ast::expr_unary(ast::uniq(ast::m_imm),
@dse(ast::expr_lit(@dsl(ast::lit_bool(true))))))
]
}