From 17dcaee9d13a39fe38e010514d8489060a20509d Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Thu, 21 Feb 2013 16:13:07 -0800 Subject: [PATCH 1/7] libsyntax: De-mut the pipe compiler --- src/libsyntax/diagnostic.rs | 2 +- src/libsyntax/ext/pipes/mod.rs | 2 +- src/libsyntax/ext/pipes/pipec.rs | 29 ++++++++++++--------- src/libsyntax/ext/pipes/proto.rs | 41 ++++++++++++++---------------- src/libsyntax/ext/tt/transcribe.rs | 2 +- 5 files changed, 39 insertions(+), 37 deletions(-) diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs index 87e1dd2d22cb5..27483ae94a5bd 100644 --- a/src/libsyntax/diagnostic.rs +++ b/src/libsyntax/diagnostic.rs @@ -158,7 +158,7 @@ pub fn mk_handler(emitter: Option) -> @handler { } }; - @mut HandlerT { mut err_count: 0, emit: emit } as @handler + @mut HandlerT { err_count: 0, emit: emit } as @handler } #[deriving_eq] diff --git a/src/libsyntax/ext/pipes/mod.rs b/src/libsyntax/ext/pipes/mod.rs index 6d117f5ad235c..8b8e48bd5229b 100644 --- a/src/libsyntax/ext/pipes/mod.rs +++ b/src/libsyntax/ext/pipes/mod.rs @@ -73,7 +73,7 @@ pub fn expand_proto(cx: ext_ctxt, _sp: span, id: ast::ident, let rdr = tt_rdr as reader; let rust_parser = Parser(sess, cfg, rdr.dup()); - let proto = rust_parser.parse_proto(cx.str_of(id)); + let mut proto = rust_parser.parse_proto(cx.str_of(id)); // check for errors visit(proto, cx); diff --git a/src/libsyntax/ext/pipes/pipec.rs b/src/libsyntax/ext/pipes/pipec.rs index e8e4c93990740..25760aa01b67d 100644 --- a/src/libsyntax/ext/pipes/pipec.rs +++ b/src/libsyntax/ext/pipes/pipec.rs @@ -27,8 +27,8 @@ use core::to_str::ToStr; use core::vec; pub trait gen_send { - fn gen_send(&self, cx: ext_ctxt, try: bool) -> @ast::item; - fn to_ty(&self, cx: ext_ctxt) -> @ast::Ty; + fn gen_send(&mut self, cx: ext_ctxt, try: bool) -> @ast::item; + fn to_ty(&mut self, cx: ext_ctxt) -> @ast::Ty; } pub trait to_type_decls { @@ -47,7 +47,7 @@ pub trait gen_init { } pub impl gen_send for message { - fn gen_send(&self, cx: ext_ctxt, try: bool) -> @ast::item { + fn gen_send(&mut self, cx: ext_ctxt, try: bool) -> @ast::item { debug!("pipec: gen_send"); match *self { message(ref _id, span, ref tys, this, Some(ref next_state)) => { @@ -193,7 +193,7 @@ pub impl gen_send for message { } } - fn to_ty(&self, cx: ext_ctxt) -> @ast::Ty { + fn to_ty(&mut self, cx: ext_ctxt) -> @ast::Ty { cx.ty_path_ast_builder(path(~[cx.ident_of(self.name())], self.span()) .add_tys(cx.ty_vars_global(self.get_params()))) } @@ -259,10 +259,14 @@ pub impl to_type_decls for state { recv => (*self).dir.reverse() }; let mut items = ~[]; - for self.messages.each |m| { - if dir == send { - items.push(m.gen_send(cx, true)); - items.push(m.gen_send(cx, false)); + + { + let messages = &mut *self.messages; + for vec::each_mut(*messages) |m| { + if dir == send { + items.push(m.gen_send(cx, true)); + items.push(m.gen_send(cx, false)); + } } } @@ -395,7 +399,8 @@ pub impl gen_init for protocol { } cx.ty_path_ast_builder(path(~[cx.ident_of(~"super"), - cx.ident_of(~"__Buffer")], self.span) + cx.ident_of(~"__Buffer")], + copy self.span) .add_tys(cx.ty_vars_global(params))) } @@ -453,12 +458,12 @@ pub impl gen_init for protocol { } items.push(cx.item_mod(cx.ident_of(~"client"), - self.span, + copy self.span, client_states)); items.push(cx.item_mod(cx.ident_of(~"server"), - self.span, + copy self.span, server_states)); - cx.item_mod(cx.ident_of(self.name), self.span, items) + cx.item_mod(cx.ident_of(self.name), copy self.span, items) } } diff --git a/src/libsyntax/ext/pipes/proto.rs b/src/libsyntax/ext/pipes/proto.rs index da67e48dfa6e6..7c6dc1f937dca 100644 --- a/src/libsyntax/ext/pipes/proto.rs +++ b/src/libsyntax/ext/pipes/proto.rs @@ -16,7 +16,6 @@ use ext::base::ext_ctxt; use ext::pipes::ast_builder::{append_types, ext_ctxt_ast_builder, path}; use core::cmp; -use core::dvec::DVec; use core::to_str::ToStr; #[deriving_eq] @@ -45,26 +44,24 @@ pub struct next_state { tys: ~[@ast::Ty], } -pub enum message { - // name, span, data, current state, next state - message(~str, span, ~[@ast::Ty], state, Option) -} +// name, span, data, current state, next state +pub struct message(~str, span, ~[@ast::Ty], state, Option); pub impl message { - fn name(&self) -> ~str { + fn name(&mut self) -> ~str { match *self { message(ref id, _, _, _, _) => (*id) } } - fn span(&self) -> span { + fn span(&mut self) -> span { match *self { message(_, span, _, _, _) => span } } /// Return the type parameters actually used by this message - fn get_params(&self) -> ~[ast::ty_param] { + fn get_params(&mut self) -> ~[ast::ty_param] { match *self { message(_, _, _, this, _) => this.ty_params } @@ -80,7 +77,7 @@ pub struct state_ { span: span, dir: direction, ty_params: ~[ast::ty_param], - messages: DVec, + messages: @mut ~[message], proto: protocol } @@ -121,17 +118,17 @@ pub impl state_ { } } -pub type protocol = @protocol_; +pub type protocol = @mut protocol_; pub fn protocol(name: ~str, +span: span) -> protocol { - @protocol_(name, span) + @mut protocol_(name, span) } pub fn protocol_(name: ~str, span: span) -> protocol_ { protocol_ { name: name, span: span, - states: DVec(), + states: @mut ~[], bounded: None } } @@ -139,30 +136,30 @@ pub fn protocol_(name: ~str, span: span) -> protocol_ { pub struct protocol_ { name: ~str, span: span, - states: DVec, + states: @mut ~[state], - mut bounded: Option, + bounded: Option, } pub impl protocol_ { /// Get a state. - fn get_state(&self, name: ~str) -> state { + fn get_state(&mut self, name: ~str) -> state { self.states.find(|i| i.name == name).get() } - fn get_state_by_id(&self, id: uint) -> state { self.states[id] } + fn get_state_by_id(&mut self, id: uint) -> state { self.states[id] } - fn has_state(&self, name: ~str) -> bool { + fn has_state(&mut self, name: ~str) -> bool { self.states.find(|i| i.name == name).is_some() } - fn filename(&self) -> ~str { + fn filename(&mut self) -> ~str { ~"proto://" + self.name } - fn num_states(&self) -> uint { self.states.len() } + fn num_states(&mut self) -> uint { self.states.len() } - fn has_ty_params(&self) -> bool { + fn has_ty_params(&mut self) -> bool { for self.states.each |s| { if s.ty_params.len() > 0 { return true; @@ -170,7 +167,7 @@ pub impl protocol_ { } false } - fn is_bounded(&self) -> bool { + fn is_bounded(&mut self) -> bool { let bounded = self.bounded.get(); bounded } @@ -179,7 +176,7 @@ pub impl protocol_ { pub impl protocol { fn add_state_poly(&self, name: ~str, ident: ast::ident, dir: direction, +ty_params: ~[ast::ty_param]) -> state { - let messages = DVec(); + let messages = @mut ~[]; let state = @state_ { id: self.states.len(), diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs index 3817f89b8173f..a9502ff29020e 100644 --- a/src/libsyntax/ext/tt/transcribe.rs +++ b/src/libsyntax/ext/tt/transcribe.rs @@ -59,7 +59,7 @@ pub fn new_tt_reader(sp_diag: span_handler, let r = @mut TtReader { sp_diag: sp_diag, interner: itr, - mut cur: @mut TtFrame { + cur: @mut TtFrame { readme: @mut src, idx: 0u, dotdotdoted: false, From 77dc3ad810d4887d1148d2b0d8e7807ecadaea3e Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Thu, 21 Feb 2013 16:17:23 -0800 Subject: [PATCH 2/7] libsyntax: De-mut the macro parser. rs=demuting --- src/libsyntax/ext/tt/macro_parser.rs | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs index d51ddae6db2f3..1a04da9580153 100644 --- a/src/libsyntax/ext/tt/macro_parser.rs +++ b/src/libsyntax/ext/tt/macro_parser.rs @@ -114,8 +114,8 @@ pub fn is_some(&&mpu: matcher_pos_up) -> bool { pub struct MatcherPos { elts: ~[ast::matcher], // maybe should be /&? Need to understand regions. sep: Option, - mut idx: uint, - mut up: matcher_pos_up, // mutable for swapping only + idx: uint, + up: matcher_pos_up, // mutable for swapping only matches: ~[DVec<@named_match>], match_lo: uint, match_hi: uint, sp_lo: BytePos, @@ -155,8 +155,8 @@ pub fn initial_matcher_pos(ms: ~[matcher], sep: Option, lo: BytePos) ~MatcherPos { elts: ms, sep: sep, - mut idx: 0u, - mut up: matcher_pos_up(None), + idx: 0u, + up: matcher_pos_up(None), matches: copy vec::from_fn(count_names(ms), |_i| dvec::DVec()), match_lo: 0u, match_hi: match_idx_hi, @@ -267,7 +267,7 @@ pub fn parse(sess: @mut ParseSess, if idx == len { // pop from the matcher position - let new_pos = copy_up(ei.up); + let mut new_pos = copy_up(ei.up); // update matches (the MBE "parse tree") by appending // each tree as a subtree. @@ -295,13 +295,13 @@ pub fn parse(sess: @mut ParseSess, match copy ei.sep { Some(ref t) if idx == len => { // we need a separator if tok == (*t) { //pass the separator - let ei_t = ei; + let mut ei_t = ei; ei_t.idx += 1; next_eis.push(ei_t); } } _ => { // we don't need a separator - let ei_t = ei; + let mut ei_t = ei; ei_t.idx = 0; cur_eis.push(ei_t); } @@ -315,7 +315,7 @@ pub fn parse(sess: @mut ParseSess, match_seq(ref matchers, ref sep, zero_ok, match_idx_lo, match_idx_hi) => { if zero_ok { - let new_ei = copy ei; + let mut new_ei = copy ei; new_ei.idx += 1u; //we specifically matched zero repeats. for uint::range(match_idx_lo, match_idx_hi) |idx| { @@ -331,8 +331,8 @@ pub fn parse(sess: @mut ParseSess, cur_eis.push(~MatcherPos { elts: (*matchers), sep: (*sep), - mut idx: 0u, - mut up: matcher_pos_up(Some(ei_t)), + idx: 0u, + up: matcher_pos_up(Some(ei_t)), matches: matches, match_lo: match_idx_lo, match_hi: match_idx_hi, sp_lo: sp.lo @@ -340,7 +340,7 @@ pub fn parse(sess: @mut ParseSess, } match_nonterminal(_,_,_) => { bb_eis.push(ei) } match_tok(ref t) => { - let ei_t = ei; + let mut ei_t = ei; if (*t) == tok { ei_t.idx += 1; next_eis.push(ei_t); @@ -388,7 +388,7 @@ pub fn parse(sess: @mut ParseSess, } else /* bb_eis.len() == 1 */ { let rust_parser = Parser(sess, cfg, rdr.dup()); - let ei = bb_eis.pop(); + let mut ei = bb_eis.pop(); match ei.elts[ei.idx].node { match_nonterminal(_, name, idx) => { ei.matches[idx].push(@matched_nonterminal( From 934c938f90662522c4a8a86bd58d7618207f5c2a Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Thu, 21 Feb 2013 18:12:13 -0800 Subject: [PATCH 3/7] libsyntax: De-mut the parser. rs=demuting --- src/libsyntax/ext/base.rs | 2 +- src/libsyntax/ext/pipes/parse_proto.rs | 19 +- src/libsyntax/ext/pipes/pipec.rs | 25 +- src/libsyntax/ext/quote.rs | 2 +- src/libsyntax/ext/tt/macro_parser.rs | 8 +- src/libsyntax/parse/attr.rs | 10 +- src/libsyntax/parse/common.rs | 46 +-- src/libsyntax/parse/mod.rs | 2 +- src/libsyntax/parse/obsolete.rs | 12 +- src/libsyntax/parse/parser.rs | 539 +++++++++++++------------ 10 files changed, 332 insertions(+), 333 deletions(-) diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index eb92b23c9d7e7..f3a74302400c9 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -339,7 +339,7 @@ pub fn get_exprs_from_tts(cx: ext_ctxt, tts: ~[ast::token_tree]) cx.cfg(), tts); let mut es = ~[]; - while p.token != token::EOF { + while *p.token != token::EOF { if es.len() != 0 { p.eat(token::COMMA); } diff --git a/src/libsyntax/ext/pipes/parse_proto.rs b/src/libsyntax/ext/pipes/parse_proto.rs index a2f881fc19f71..66feb7cc753cf 100644 --- a/src/libsyntax/ext/pipes/parse_proto.rs +++ b/src/libsyntax/ext/pipes/parse_proto.rs @@ -25,7 +25,7 @@ pub trait proto_parser { pub impl proto_parser for parser::Parser { fn parse_proto(&self, id: ~str) -> protocol { - let proto = protocol(id, self.span); + let proto = protocol(id, *self.span); self.parse_seq_to_before_end(token::EOF, SeqSep { sep: None, @@ -40,7 +40,7 @@ pub impl proto_parser for parser::Parser { let name = *self.interner.get(id); self.expect(token::COLON); - let dir = match copy self.token { + let dir = match *self.token { token::IDENT(n, _) => self.interner.get(n), _ => fail!() }; @@ -51,10 +51,11 @@ pub impl proto_parser for parser::Parser { _ => fail!() }; - let typarms = if self.token == token::LT { + let typarms = if *self.token == token::LT { self.parse_ty_params() - } - else { ~[] }; + } else { + ~[] + }; let state = proto.add_state_poly(name, id, dir, typarms); @@ -69,7 +70,7 @@ pub impl proto_parser for parser::Parser { fn parse_message(&self, state: state) { let mname = *self.interner.get(self.parse_ident()); - let args = if self.token == token::LPAREN { + let args = if *self.token == token::LPAREN { self.parse_unspanned_seq(token::LPAREN, token::RPAREN, SeqSep { sep: Some(token::COMMA), @@ -80,10 +81,10 @@ pub impl proto_parser for parser::Parser { self.expect(token::RARROW); - let next = match copy self.token { + let next = match *self.token { token::IDENT(_, _) => { let name = *self.interner.get(self.parse_ident()); - let ntys = if self.token == token::LT { + let ntys = if *self.token == token::LT { self.parse_unspanned_seq(token::LT, token::GT, SeqSep { sep: Some(token::COMMA), @@ -101,7 +102,7 @@ pub impl proto_parser for parser::Parser { _ => self.fatal(~"invalid next state") }; - state.add_message(mname, copy self.span, args, next); + state.add_message(mname, *self.span, args, next); } } diff --git a/src/libsyntax/ext/pipes/pipec.rs b/src/libsyntax/ext/pipes/pipec.rs index 25760aa01b67d..444b09d9ae458 100644 --- a/src/libsyntax/ext/pipes/pipec.rs +++ b/src/libsyntax/ext/pipes/pipec.rs @@ -49,6 +49,9 @@ pub trait gen_init { pub impl gen_send for message { fn gen_send(&mut self, cx: ext_ctxt, try: bool) -> @ast::item { debug!("pipec: gen_send"); + let name = self.name(); + let params = self.get_params(); + match *self { message(ref _id, span, ref tys, this, Some(ref next_state)) => { debug!("pipec: next state exists"); @@ -67,7 +70,7 @@ pub impl gen_send for message { args_ast); let mut body = ~"{\n"; - body += fmt!("use super::%s;\n", self.name()); + body += fmt!("use super::%s;\n", name); if this.proto.is_bounded() { let (sp, rp) = match (this.dir, next.dir) { @@ -96,7 +99,7 @@ pub impl gen_send for message { body += fmt!("let %s = ::core::pipes::entangle();\n", pat); } body += fmt!("let message = %s(%s);\n", - self.name(), + name, str::connect(vec::append_one( arg_names.map(|x| cx.str_of(*x)), ~"s"), ~", ")); @@ -121,13 +124,12 @@ pub impl gen_send for message { rty = cx.ty_option(rty); } - let name = cx.ident_of(if try { ~"try_" + self.name() - } else { self.name() } ); + let name = cx.ident_of(if try { ~"try_" + name } else { name } ); cx.item_fn_poly(name, args_ast, rty, - self.get_params(), + params, cx.expr_block(body)) } @@ -156,10 +158,8 @@ pub impl gen_send for message { }; let mut body = ~"{ "; - body += fmt!("use super::%s;\n", self.name()); - body += fmt!("let message = %s%s;\n", - self.name(), - message_args); + body += fmt!("use super::%s;\n", name); + body += fmt!("let message = %s%s;\n", name, message_args); if !try { body += fmt!("::core::pipes::send(pipe, message);\n"); @@ -175,10 +175,7 @@ pub impl gen_send for message { let body = cx.parse_expr(body); - let name = if try { - ~"try_" + self.name() - } - else { self.name() }; + let name = if try { ~"try_" + name } else { name }; cx.item_fn_poly(cx.ident_of(name), args_ast, @@ -187,7 +184,7 @@ pub impl gen_send for message { } else { cx.ty_nil_ast_builder() }, - self.get_params(), + params, cx.expr_block(body)) } } diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs index ffa6101d58fcc..d529ee0c01b01 100644 --- a/src/libsyntax/ext/quote.rs +++ b/src/libsyntax/ext/quote.rs @@ -515,7 +515,7 @@ fn expand_tts(cx: ext_ctxt, // try removing it when enough of them are gone. let p = parse::new_parser_from_tts(cx.parse_sess(), cx.cfg(), tts); - p.quote_depth += 1u; + *p.quote_depth += 1u; let tts = p.parse_all_token_trees(); p.abort_if_errors(); diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs index 1a04da9580153..890420edf6d68 100644 --- a/src/libsyntax/ext/tt/macro_parser.rs +++ b/src/libsyntax/ext/tt/macro_parser.rs @@ -421,16 +421,16 @@ pub fn parse_nt(p: Parser, name: ~str) -> nonterminal { ~"expr" => token::nt_expr(p.parse_expr()), ~"ty" => token::nt_ty(p.parse_ty(false /* no need to disambiguate*/)), // this could be handled like a token, since it is one - ~"ident" => match copy p.token { + ~"ident" => match *p.token { token::IDENT(sn,b) => { p.bump(); token::nt_ident(sn,b) } _ => p.fatal(~"expected ident, found " - + token::to_str(p.reader.interner(), copy p.token)) + + token::to_str(p.reader.interner(), *p.token)) }, ~"path" => token::nt_path(p.parse_path_with_tps(false)), ~"tt" => { - p.quote_depth += 1u; //but in theory, non-quoted tts might be useful + *p.quote_depth += 1u; //but in theory, non-quoted tts might be useful let res = token::nt_tt(@p.parse_token_tree()); - p.quote_depth -= 1u; + *p.quote_depth -= 1u; res } ~"matchers" => token::nt_matchers(p.parse_matchers()), diff --git a/src/libsyntax/parse/attr.rs b/src/libsyntax/parse/attr.rs index 4f64d7bed3124..c0c97a0b9eb59 100644 --- a/src/libsyntax/parse/attr.rs +++ b/src/libsyntax/parse/attr.rs @@ -37,7 +37,7 @@ impl parser_attr for Parser { fn parse_outer_attributes() -> ~[ast::attribute] { let mut attrs: ~[ast::attribute] = ~[]; loop { - match copy self.token { + match *self.token { token::POUND => { if self.look_ahead(1u) != token::LBRACKET { break; @@ -90,14 +90,14 @@ impl parser_attr for Parser { let mut inner_attrs: ~[ast::attribute] = ~[]; let mut next_outer_attrs: ~[ast::attribute] = ~[]; loop { - match copy self.token { + match *self.token { token::POUND => { if self.look_ahead(1u) != token::LBRACKET { // This is an extension break; } let attr = self.parse_attribute(ast::attr_inner); - if self.token == token::SEMI { + if *self.token == token::SEMI { self.bump(); inner_attrs += ~[attr]; } else { @@ -131,7 +131,7 @@ impl parser_attr for Parser { fn parse_meta_item() -> @ast::meta_item { let lo = self.span.lo; let name = self.id_to_str(self.parse_ident()); - match self.token { + match *self.token { token::EQ => { self.bump(); let lit = self.parse_lit(); @@ -157,7 +157,7 @@ impl parser_attr for Parser { } fn parse_optional_meta() -> ~[@ast::meta_item] { - match self.token { + match *self.token { token::LPAREN => return self.parse_meta_seq(), _ => return ~[] } diff --git a/src/libsyntax/parse/common.rs b/src/libsyntax/parse/common.rs index 22004be87adc6..57d62d628dc6f 100644 --- a/src/libsyntax/parse/common.rs +++ b/src/libsyntax/parse/common.rs @@ -53,25 +53,25 @@ pub fn token_to_str(reader: reader, ++token: token::Token) -> ~str { pub impl Parser { fn unexpected_last(t: token::Token) -> ! { self.span_fatal( - copy self.last_span, + *self.last_span, ~"unexpected token: `" + token_to_str(self.reader, t) + ~"`"); } fn unexpected() -> ! { self.fatal(~"unexpected token: `" - + token_to_str(self.reader, self.token) + ~"`"); + + token_to_str(self.reader, *self.token) + ~"`"); } // expect and consume the token t. Signal an error if // the next token is not t. fn expect(t: token::Token) { - if self.token == t { + if *self.token == t { self.bump(); } else { let mut s: ~str = ~"expected `"; s += token_to_str(self.reader, t); s += ~"` but found `"; - s += token_to_str(self.reader, self.token); + s += token_to_str(self.reader, *self.token); self.fatal(s + ~"`"); } } @@ -79,12 +79,12 @@ pub impl Parser { fn parse_ident() -> ast::ident { self.check_strict_keywords(); self.check_reserved_keywords(); - match copy self.token { + match *self.token { token::IDENT(i, _) => { self.bump(); return i; } token::INTERPOLATED(token::nt_ident(*)) => { self.bug( ~"ident interpolation not converted to real token"); } _ => { self.fatal(~"expected ident, found `" - + token_to_str(self.reader, self.token) + + token_to_str(self.reader, *self.token) + ~"`"); } } } @@ -104,7 +104,7 @@ pub impl Parser { // consume token 'tok' if it exists. Returns true if the given // token was present, false otherwise. fn eat(tok: token::Token) -> bool { - return if self.token == tok { self.bump(); true } else { false }; + return if *self.token == tok { self.bump(); true } else { false }; } // Storing keywords as interned idents instead of strings would be nifty. @@ -129,7 +129,7 @@ pub impl Parser { } fn is_keyword(word: ~str) -> bool { - self.token_is_keyword(word, self.token) + self.token_is_keyword(word, *self.token) } fn is_any_keyword(tok: token::Token) -> bool { @@ -143,7 +143,7 @@ pub impl Parser { fn eat_keyword(word: ~str) -> bool { self.require_keyword(word); - let is_kw = match self.token { + let is_kw = match *self.token { token::IDENT(sid, false) => (word == *self.id_to_str(sid)), _ => false }; @@ -155,7 +155,7 @@ pub impl Parser { self.require_keyword(word); if !self.eat_keyword(word) { self.fatal(~"expected `" + word + ~"`, found `" + - token_to_str(self.reader, self.token) + + token_to_str(self.reader, *self.token) + ~"`"); } } @@ -165,9 +165,9 @@ pub impl Parser { } fn check_strict_keywords() { - match self.token { + match *self.token { token::IDENT(_, false) => { - let w = token_to_str(self.reader, self.token); + let w = token_to_str(self.reader, *self.token); self.check_strict_keywords_(w); } _ => () @@ -185,9 +185,9 @@ pub impl Parser { } fn check_reserved_keywords() { - match self.token { + match *self.token { token::IDENT(_, false) => { - let w = token_to_str(self.reader, self.token); + let w = token_to_str(self.reader, *self.token); self.check_reserved_keywords_(w); } _ => () @@ -203,9 +203,9 @@ pub impl Parser { // expect and consume a GT. if a >> is seen, replace it // with a single > and continue. fn expect_gt() { - if self.token == token::GT { + if *self.token == token::GT { self.bump(); - } else if self.token == token::BINOP(token::SHR) { + } else if *self.token == token::BINOP(token::SHR) { self.replace_token(token::GT, self.span.lo + BytePos(1u), self.span.hi); @@ -213,7 +213,7 @@ pub impl Parser { let mut s: ~str = ~"expected `"; s += token_to_str(self.reader, token::GT); s += ~"`, found `"; - s += token_to_str(self.reader, self.token); + s += token_to_str(self.reader, *self.token); s += ~"`"; self.fatal(s); } @@ -225,8 +225,8 @@ pub impl Parser { f: fn(Parser) -> T) -> ~[T] { let mut first = true; let mut v = ~[]; - while self.token != token::GT - && self.token != token::BINOP(token::SHR) { + while *self.token != token::GT + && *self.token != token::BINOP(token::SHR) { match sep { Some(ref t) => { if first { first = false; } @@ -276,7 +276,7 @@ pub impl Parser { f: fn(Parser) -> T) -> ~[T] { let mut first: bool = true; let mut v: ~[T] = ~[]; - while self.token != ket { + while *self.token != ket { match sep.sep { Some(ref t) => { if first { first = false; } @@ -284,7 +284,7 @@ pub impl Parser { } _ => () } - if sep.trailing_sep_allowed && self.token == ket { break; } + if sep.trailing_sep_allowed && *self.token == ket { break; } v.push(f(self)); } return v; @@ -293,8 +293,8 @@ pub impl Parser { // parse a sequence, including the closing delimiter. The function // f must consume tokens until reaching the next separator or // closing bracket. - fn parse_unspanned_seq(bra: token::Token, - ket: token::Token, + fn parse_unspanned_seq(+bra: token::Token, + +ket: token::Token, sep: SeqSep, f: fn(Parser) -> T) -> ~[T] { self.expect(bra); diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index 4f330ea86b0b6..5fa6115938506 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -141,7 +141,7 @@ pub fn parse_tts_from_source_str(name: ~str, sess: @mut ParseSess) -> ~[ast::token_tree] { let p = new_parser_from_source_str(sess, cfg, name, codemap::FssNone, source); - p.quote_depth += 1u; + *p.quote_depth += 1u; let r = p.parse_all_token_trees(); p.abort_if_errors(); return r; diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs index f5ee5bd802907..1ae8786e09bb2 100644 --- a/src/libsyntax/parse/obsolete.rs +++ b/src/libsyntax/parse/obsolete.rs @@ -158,7 +158,7 @@ pub impl Parser { } fn is_obsolete_ident(ident: &str) -> bool { - self.token_is_obsolete_ident(ident, copy self.token) + self.token_is_obsolete_ident(ident, *self.token) } fn eat_obsolete_ident(ident: &str) -> bool { @@ -172,7 +172,7 @@ pub impl Parser { fn try_parse_obsolete_struct_ctor() -> bool { if self.eat_obsolete_ident("new") { - self.obsolete(copy self.last_span, ObsoleteStructCtor); + self.obsolete(*self.last_span, ObsoleteStructCtor); self.parse_fn_decl(|p| p.parse_arg()); self.parse_block(); true @@ -182,13 +182,13 @@ pub impl Parser { } fn try_parse_obsolete_with() -> bool { - if self.token == token::COMMA + if *self.token == token::COMMA && self.token_is_obsolete_ident("with", self.look_ahead(1u)) { self.bump(); } if self.eat_obsolete_ident("with") { - self.obsolete(copy self.last_span, ObsoleteWith); + self.obsolete(*self.last_span, ObsoleteWith); self.parse_expr(); true } else { @@ -198,10 +198,10 @@ pub impl Parser { fn try_parse_obsolete_priv_section() -> bool { if self.is_keyword(~"priv") && self.look_ahead(1) == token::LBRACE { - self.obsolete(copy self.span, ObsoletePrivSection); + self.obsolete(*self.span, ObsoletePrivSection); self.eat_keyword(~"priv"); self.bump(); - while self.token != token::RBRACE { + while *self.token != token::RBRACE { self.parse_single_class_item(ast::private); } self.bump(); diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index c7c8836126bdb..9bac163dab6ef 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -127,7 +127,7 @@ enum view_item_parse_mode { The important thing is to make sure that lookahead doesn't balk at INTERPOLATED tokens */ macro_rules! maybe_whole_expr ( - ($p:expr) => ( match copy $p.token { + ($p:expr) => ( match *$p.token { INTERPOLATED(token::nt_expr(e)) => { $p.bump(); return e; @@ -142,28 +142,28 @@ macro_rules! maybe_whole_expr ( ) macro_rules! maybe_whole ( - ($p:expr, $constructor:ident) => ( match copy $p.token { - INTERPOLATED(token::$constructor(ref x)) => { $p.bump(); return (*x); } + ($p:expr, $constructor:ident) => ( match *$p.token { + INTERPOLATED(token::$constructor(x)) => { $p.bump(); return x; } _ => () }) ; - (deref $p:expr, $constructor:ident) => ( match copy $p.token { + (deref $p:expr, $constructor:ident) => ( match *$p.token { INTERPOLATED(token::$constructor(x)) => { $p.bump(); return *x; } _ => () }) ; - (Some $p:expr, $constructor:ident) => ( match copy $p.token { + (Some $p:expr, $constructor:ident) => ( match *$p.token { INTERPOLATED(token::$constructor(x)) => { $p.bump(); return Some(x); } _ => () }) ; - (iovi $p:expr, $constructor:ident) => ( match copy $p.token { + (iovi $p:expr, $constructor:ident) => ( match *$p.token { INTERPOLATED(token::$constructor(x)) => { $p.bump(); return iovi_item(x); } _ => () }) ; - (pair_empty $p:expr, $constructor:ident) => ( match copy $p.token { - INTERPOLATED(token::$constructor(ref x)) => { - $p.bump(); return (~[], (*x)); + (pair_empty $p:expr, $constructor:ident) => ( match *$p.token { + INTERPOLATED(token::$constructor(x)) => { + $p.bump(); return (~[], x); } _ => () }) @@ -202,35 +202,35 @@ pub fn Parser(sess: @mut ParseSess, interner: interner, sess: sess, cfg: cfg, - token: tok0.tok, - span: span0, - last_span: span0, - mut buffer: [TokenAndSpan {tok: tok0.tok, sp: span0}, ..4], - buffer_start: 0, - buffer_end: 0, - tokens_consumed: 0u, - restriction: UNRESTRICTED, - quote_depth: 0u, + token: @mut tok0.tok, + span: @mut span0, + last_span: @mut span0, + buffer: @mut [TokenAndSpan {tok: tok0.tok, sp: span0}, ..4], + buffer_start: @mut 0, + buffer_end: @mut 0, + tokens_consumed: @mut 0u, + restriction: @mut UNRESTRICTED, + quote_depth: @mut 0u, keywords: token::keyword_table(), strict_keywords: token::strict_keyword_table(), reserved_keywords: token::reserved_keyword_table(), obsolete_set: HashMap(), - mod_path_stack: ~[], + mod_path_stack: @mut ~[], } } pub struct Parser { sess: @mut ParseSess, cfg: crate_cfg, - mut token: token::Token, - mut span: span, - mut last_span: span, - mut buffer: [TokenAndSpan * 4], - mut buffer_start: int, - mut buffer_end: int, - mut tokens_consumed: uint, - mut restriction: restriction, - mut quote_depth: uint, // not (yet) related to the quasiquoter + token: @mut token::Token, + span: @mut span, + last_span: @mut span, + buffer: @mut [TokenAndSpan * 4], + buffer_start: @mut int, + buffer_end: @mut int, + tokens_consumed: @mut uint, + restriction: @mut restriction, + quote_depth: @mut uint, // not (yet) related to the quasiquoter reader: reader, interner: @token::ident_interner, keywords: HashMap<~str, ()>, @@ -240,7 +240,7 @@ pub struct Parser { /// extra detail when the same error is seen twice obsolete_set: HashMap, /// Used to determine the path to externally loaded source files - mut mod_path_stack: ~[~str], + mod_path_stack: @mut ~[~str], drop {} /* do not copy the parser; its state is tied to outside state */ } @@ -248,39 +248,39 @@ pub struct Parser { pub impl Parser { // advance the parser by one token fn bump() { - self.last_span = self.span; - let next = if self.buffer_start == self.buffer_end { + *self.last_span = *self.span; + let next = if *self.buffer_start == *self.buffer_end { self.reader.next_token() } else { - let next = self.buffer[self.buffer_start]; - self.buffer_start = (self.buffer_start + 1) & 3; + let next = self.buffer[*self.buffer_start]; + *self.buffer_start = (*self.buffer_start + 1) & 3; next }; - self.token = next.tok; - self.span = next.sp; - self.tokens_consumed += 1u; + *self.token = next.tok; + *self.span = next.sp; + *self.tokens_consumed += 1u; } // EFFECT: replace the current token and span with the given one fn replace_token(next: token::Token, +lo: BytePos, +hi: BytePos) { - self.token = next; - self.span = mk_sp(lo, hi); + *self.token = next; + *self.span = mk_sp(lo, hi); } fn buffer_length() -> int { - if self.buffer_start <= self.buffer_end { - return self.buffer_end - self.buffer_start; + if *self.buffer_start <= *self.buffer_end { + return *self.buffer_end - *self.buffer_start; } - return (4 - self.buffer_start) + self.buffer_end; + return (4 - *self.buffer_start) + *self.buffer_end; } fn look_ahead(distance: uint) -> token::Token { let dist = distance as int; while self.buffer_length() < dist { - self.buffer[self.buffer_end] = self.reader.next_token(); - self.buffer_end = (self.buffer_end + 1) & 3; + self.buffer[*self.buffer_end] = self.reader.next_token(); + *self.buffer_end = (*self.buffer_end + 1) & 3; } - return copy self.buffer[(self.buffer_start + dist - 1) & 3].tok; + return copy self.buffer[(*self.buffer_start + dist - 1) & 3].tok; } fn fatal(m: ~str) -> ! { - self.sess.span_diagnostic.span_fatal(copy self.span, m) + self.sess.span_diagnostic.span_fatal(*copy self.span, m) } fn span_fatal(sp: span, m: ~str) -> ! { self.sess.span_diagnostic.span_fatal(sp, m) @@ -289,10 +289,10 @@ pub impl Parser { self.sess.span_diagnostic.span_note(sp, m) } fn bug(m: ~str) -> ! { - self.sess.span_diagnostic.span_bug(copy self.span, m) + self.sess.span_diagnostic.span_bug(*copy self.span, m) } fn warn(m: ~str) { - self.sess.span_diagnostic.span_warn(copy self.span, m) + self.sess.span_diagnostic.span_warn(*copy self.span, m) } fn span_err(sp: span, m: ~str) { self.sess.span_diagnostic.span_err(sp, m) @@ -451,8 +451,8 @@ pub impl Parser { let hi = p.last_span.hi; debug!("parse_trait_methods(): trait method signature ends in \ `%s`", - token_to_str(p.reader, p.token)); - match p.token { + token_to_str(p.reader, *p.token)); + match *p.token { token::SEMI => { p.bump(); debug!("parse_trait_methods(): parsing required method"); @@ -490,7 +490,7 @@ pub impl Parser { } _ => { p.fatal(~"expected `;` or `}` but found `" + - token_to_str(p.reader, p.token) + ~"`"); + token_to_str(p.reader, *p.token) + ~"`"); } } } @@ -562,7 +562,7 @@ pub impl Parser { fn parse_region() -> @region { self.expect(token::BINOP(token::AND)); - match copy self.token { + match *self.token { token::IDENT(sid, _) => { self.bump(); self.region_from_name(Some(sid)) @@ -578,9 +578,9 @@ pub impl Parser { let lo = self.span.lo; - let t = if self.token == token::LPAREN { + let t = if *self.token == token::LPAREN { self.bump(); - if self.token == token::RPAREN { + if *self.token == token::RPAREN { self.bump(); ty_nil } else { @@ -589,9 +589,9 @@ pub impl Parser { // of type t let mut ts = ~[self.parse_ty(false)]; let mut one_tuple = false; - while self.token == token::COMMA { + while *self.token == token::COMMA { self.bump(); - if self.token != token::RPAREN { + if *self.token != token::RPAREN { ts.push(self.parse_ty(false)); } else { @@ -603,16 +603,16 @@ pub impl Parser { self.expect(token::RPAREN); t } - } else if self.token == token::AT { + } else if *self.token == token::AT { self.bump(); self.parse_box_or_uniq_pointee(ManagedSigil, ty_box) - } else if self.token == token::TILDE { + } else if *self.token == token::TILDE { self.bump(); self.parse_box_or_uniq_pointee(OwnedSigil, ty_uniq) - } else if self.token == token::BINOP(token::STAR) { + } else if *self.token == token::BINOP(token::STAR) { self.bump(); ty_ptr(self.parse_mt()) - } else if self.token == token::LBRACE { + } else if *self.token == token::LBRACE { let elems = self.parse_unspanned_seq( token::LBRACE, token::RBRACE, seq_sep_trailing_allowed(token::COMMA), @@ -621,7 +621,7 @@ pub impl Parser { self.unexpected_last(token::RBRACE); } ty_rec(elems) - } else if self.token == token::LBRACKET { + } else if *self.token == token::LBRACKET { self.expect(token::LBRACKET); let mt = self.parse_mt(); @@ -632,15 +632,15 @@ pub impl Parser { }; self.expect(token::RBRACKET); t - } else if self.token == token::BINOP(token::AND) { + } else if *self.token == token::BINOP(token::AND) { self.bump(); self.parse_borrowed_pointee() } else if self.eat_keyword(~"extern") { self.parse_ty_bare_fn() - } else if self.token_is_closure_keyword(self.token) { + } else if self.token_is_closure_keyword(*self.token) { self.parse_ty_closure(None, None) - } else if self.token == token::MOD_SEP - || is_ident_or_path(self.token) { + } else if *self.token == token::MOD_SEP + || is_ident_or_path(*self.token) { let path = self.parse_path_with_tps(colons_before_params); ty_path(path, self.get_id()) } else { self.fatal(~"expected type"); }; @@ -654,7 +654,7 @@ pub impl Parser { ctor: &fn(+v: mt) -> ty_) -> ty_ { // @'foo fn() or @foo/fn() or @fn() are parsed directly as fn types: - match copy self.token { + match *self.token { token::LIFETIME(rname) => { self.bump(); return self.parse_ty_closure(Some(sigil), Some(rname)); @@ -662,11 +662,10 @@ pub impl Parser { token::IDENT(rname, _) => { if self.look_ahead(1u) == token::BINOP(token::SLASH) && - self.token_is_closure_keyword(self.look_ahead(2u)) - { + self.token_is_closure_keyword(self.look_ahead(2u)) { self.bump(); self.bump(); return self.parse_ty_closure(Some(sigil), Some(rname)); - } else if self.token_is_closure_keyword(self.token) { + } else if self.token_is_closure_keyword(*self.token) { return self.parse_ty_closure(Some(sigil), None); } } @@ -683,7 +682,7 @@ pub impl Parser { fn parse_borrowed_pointee() -> ty_ { // look for `&'lt` or `&foo/` and interpret `foo` as the region name: - let rname = match self.token { + let rname = match *self.token { token::LIFETIME(sid) => { self.bump(); Some(sid) @@ -701,7 +700,7 @@ pub impl Parser { _ => { None } }; - if self.token_is_closure_keyword(self.token) { + if self.token_is_closure_keyword(*self.token) { return self.parse_ty_closure(Some(BorrowedSigil), rname); } @@ -727,13 +726,13 @@ pub impl Parser { } fn is_named_argument() -> bool { - let offset = if self.token == token::BINOP(token::AND) { + let offset = if *self.token == token::BINOP(token::AND) { 1 - } else if self.token == token::BINOP(token::MINUS) { + } else if *self.token == token::BINOP(token::MINUS) { 1 - } else if self.token == token::ANDAND { + } else if *self.token == token::ANDAND { 1 - } else if self.token == token::BINOP(token::PLUS) { + } else if *self.token == token::BINOP(token::PLUS) { if self.look_ahead(1) == token::BINOP(token::PLUS) { 2 } else { @@ -741,7 +740,7 @@ pub impl Parser { } } else { 0 }; if offset == 0 { - is_plain_ident(self.token) + is_plain_ident(*self.token) && self.look_ahead(1) == token::COLON } else { is_plain_ident(self.look_ahead(offset)) @@ -775,7 +774,7 @@ pub impl Parser { } else { m = infer(self.get_id()); ast_util::ident_to_pat(self.get_id(), - copy self.last_span, + *self.last_span, special_idents::invalid) }; @@ -819,7 +818,7 @@ pub impl Parser { fn maybe_parse_fixed_vstore_with_star() -> Option { if self.eat(token::BINOP(token::STAR)) { - match copy self.token { + match *self.token { token::LIT_INT_UNSUFFIXED(i) if i >= 0i64 => { self.bump(); Some(i as uint) @@ -828,7 +827,7 @@ pub impl Parser { self.fatal( fmt!("expected integral vector length \ but found `%s`", - token_to_str(self.reader, self.token))); + token_to_str(self.reader, *self.token))); } } } else { @@ -857,7 +856,8 @@ pub impl Parser { } else if self.eat_keyword(~"false") { lit_bool(false) } else { - let tok = self.token; + // XXX: This is a really bad copy! + let tok = *self.token; self.bump(); self.lit_from_token(tok) }; @@ -920,9 +920,8 @@ pub impl Parser { // vstores is... um... the same. I guess that's my fault. This // is still not ideal as for &str we end up parsing more than we // ought to and have to sort it out later. - if self.token == token::BINOP(token::SLASH) + if *self.token == token::BINOP(token::SLASH) && self.look_ahead(1u) == token::BINOP(token::AND) { - self.expect(token::BINOP(token::SLASH)); Some(self.parse_region()) } else { @@ -958,7 +957,7 @@ pub impl Parser { * Parses 0 or 1 lifetime. */ - match self.token { + match *self.token { token::LIFETIME(_) => { Some(self.parse_lifetime()) } @@ -974,12 +973,12 @@ pub impl Parser { * Parses a single lifetime. */ - match self.token { + match *self.token { token::LIFETIME(i) => { self.bump(); return ast::Lifetime { id: self.get_id(), - span: self.span, + span: *self.span, ident: i }; } @@ -1000,7 +999,7 @@ pub impl Parser { let mut res = ~[]; loop { - match self.token { + match *self.token { token::LIFETIME(_) => { res.push(self.parse_lifetime()); } @@ -1009,7 +1008,7 @@ pub impl Parser { } } - match self.token { + match *self.token { token::COMMA => { self.bump();} token::GT => { return res; } _ => { @@ -1058,14 +1057,16 @@ pub impl Parser { fn mk_lit_u32(i: u32) -> @expr { let span = self.span; - let lv_lit = @codemap::spanned { node: lit_uint(i as u64, ty_u32), - span: span }; + let lv_lit = @codemap::spanned { + node: lit_uint(i as u64, ty_u32), + span: *span + }; @expr { id: self.get_id(), callee_id: self.get_id(), node: expr_lit(lv_lit), - span: span, + span: *span, } } @@ -1076,21 +1077,21 @@ pub impl Parser { let mut ex: expr_; - if self.token == token::LPAREN { + if *self.token == token::LPAREN { self.bump(); // (e) is parenthesized e // (e,) is a tuple with only one field, e let mut one_tuple = false; - if self.token == token::RPAREN { + if *self.token == token::RPAREN { hi = self.span.hi; self.bump(); let lit = @spanned(lo, hi, lit_nil); return self.mk_expr(lo, hi, expr_lit(lit)); } let mut es = ~[self.parse_expr()]; - while self.token == token::COMMA { + while *self.token == token::COMMA { self.bump(); - if self.token != token::RPAREN { + if *self.token != token::RPAREN { es.push(self.parse_expr()); } else { @@ -1106,7 +1107,7 @@ pub impl Parser { else { self.mk_expr(lo, hi, expr_tup(es)) } - } else if self.token == token::LBRACE { + } else if *self.token == token::LBRACE { if self.looking_at_record_literal() { ex = self.parse_record_literal(); hi = self.span.hi; @@ -1116,7 +1117,7 @@ pub impl Parser { return self.mk_expr(blk.span.lo, blk.span.hi, expr_block(blk)); } - } else if token::is_bar(self.token) { + } else if token::is_bar(*self.token) { return self.parse_lambda_expr(); } else if self.eat_keyword(~"if") { return self.parse_if_expr(); @@ -1143,17 +1144,17 @@ pub impl Parser { return self.parse_fn_expr(sigil); } else if self.eat_keyword(~"unsafe") { return self.parse_block_expr(lo, unsafe_blk); - } else if self.token == token::LBRACKET { + } else if *self.token == token::LBRACKET { self.bump(); let mutbl = self.parse_mutability(); - if self.token == token::RBRACKET { + if *self.token == token::RBRACKET { // Empty vector. self.bump(); ex = expr_vec(~[], mutbl); } else { // Nonempty vector. let first_expr = self.parse_expr(); - if self.token == token::COMMA && + if *self.token == token::COMMA && self.look_ahead(1) == token::DOTDOT { // Repeating vector syntax: [ 0, ..512 ] self.bump(); @@ -1161,7 +1162,7 @@ pub impl Parser { let count = self.parse_expr(); self.expect(token::RBRACKET); ex = expr_repeat(first_expr, count, mutbl); - } else if self.token == token::COMMA { + } else if *self.token == token::COMMA { // Vector with two or more elements. self.bump(); let remaining_exprs = @@ -1189,13 +1190,13 @@ pub impl Parser { ex = expr_assert(e); hi = e.span.hi; } else if self.eat_keyword(~"return") { - if can_begin_expr(self.token) { + if can_begin_expr(*self.token) { let e = self.parse_expr(); hi = e.span.hi; ex = expr_ret(Some(e)); } else { ex = expr_ret(None); } } else if self.eat_keyword(~"break") { - if is_ident(self.token) { + if is_ident(*self.token) { ex = expr_break(Some(self.parse_ident())); } else { ex = expr_break(None); @@ -1205,28 +1206,28 @@ pub impl Parser { let e = self.parse_expr(); ex = expr_copy(e); hi = e.span.hi; - } else if self.token == token::MOD_SEP || - is_ident(self.token) && !self.is_keyword(~"true") && - !self.is_keyword(~"false") { + } else if *self.token == token::MOD_SEP || + is_ident(*self.token) && !self.is_keyword(~"true") && + !self.is_keyword(~"false") { let pth = self.parse_path_with_tps(true); /* `!`, as an operator, is prefix, so we know this isn't that */ - if self.token == token::NOT { + if *self.token == token::NOT { self.bump(); - let tts = match self.token { - token::LPAREN | token::LBRACE => { - let ket = token::flip_delimiter(copy self.token); - self.parse_unspanned_seq(copy self.token, ket, - seq_sep_none(), - |p| p.parse_token_tree()) - } + match *self.token { + token::LPAREN | token::LBRACE => {} _ => self.fatal(~"expected open delimiter") }; + + let ket = token::flip_delimiter(*self.token); + let tts = self.parse_unspanned_seq(*self.token, + ket, + seq_sep_none(), + |p| p.parse_token_tree()); let hi = self.span.hi; - return self.mk_mac_expr( - lo, hi, mac_invoc_tt(pth, tts)); - } else if self.token == token::LBRACE { + return self.mk_mac_expr(lo, hi, mac_invoc_tt(pth, tts)); + } else if *self.token == token::LBRACE { // This might be a struct literal. if self.looking_at_record_literal() { // It's a struct literal. @@ -1234,8 +1235,7 @@ pub impl Parser { let mut fields = ~[]; let mut base = None; fields.push(self.parse_field(token::COLON)); - while self.token != token::RBRACE { - + while *self.token != token::RBRACE { if self.try_parse_obsolete_with() { break; } @@ -1247,7 +1247,7 @@ pub impl Parser { break; } - if self.token == token::RBRACE { + if *self.token == token::RBRACE { // Accept an optional trailing comma. break; } @@ -1284,7 +1284,7 @@ pub impl Parser { } fn permits_call() -> bool { - return self.restriction != RESTRICT_NO_CALL_EXPRS; + return *self.restriction != RESTRICT_NO_CALL_EXPRS; } fn parse_dot_or_call_expr_with(e0: @expr) -> @expr { @@ -1294,7 +1294,7 @@ pub impl Parser { loop { // expr.f if self.eat(token::DOT) { - match copy self.token { + match *self.token { token::IDENT(i, _) => { hi = self.span.hi; self.bump(); @@ -1307,7 +1307,7 @@ pub impl Parser { }; // expr.f() method call - match copy self.token { + match *self.token { token::LPAREN if self.permits_call() => { let es = self.parse_unspanned_seq( token::LPAREN, token::RPAREN, @@ -1328,7 +1328,7 @@ pub impl Parser { loop; } if self.expr_is_complete(e) { break; } - match copy self.token { + match *self.token { // expr(...) token::LPAREN if self.permits_call() => { let es = self.parse_unspanned_seq( @@ -1359,17 +1359,17 @@ pub impl Parser { // parse an optional separator followed by a kleene-style // repetition token (+ or *). fn parse_sep_and_zerok() -> (Option, bool) { - if self.token == token::BINOP(token::STAR) - || self.token == token::BINOP(token::PLUS) { - let zerok = self.token == token::BINOP(token::STAR); + if *self.token == token::BINOP(token::STAR) + || *self.token == token::BINOP(token::PLUS) { + let zerok = *self.token == token::BINOP(token::STAR); self.bump(); return (None, zerok); } else { - let sep = self.token; + let sep = *self.token; self.bump(); - if self.token == token::BINOP(token::STAR) - || self.token == token::BINOP(token::PLUS) { - let zerok = self.token == token::BINOP(token::STAR); + if *self.token == token::BINOP(token::STAR) + || *self.token == token::BINOP(token::PLUS) { + let zerok = *self.token == token::BINOP(token::STAR); self.bump(); return (Some(sep), zerok); } else { @@ -1384,18 +1384,18 @@ pub impl Parser { fn parse_non_delim_tt_tok(p: Parser) -> token_tree { maybe_whole!(deref p, nt_tt); - match p.token { + match *p.token { token::RPAREN | token::RBRACE | token::RBRACKET => { p.fatal(~"incorrect close delimiter: `" - + token_to_str(p.reader, p.token) + ~"`"); + + token_to_str(p.reader, *p.token) + ~"`"); } /* we ought to allow different depths of unquotation */ - token::DOLLAR if p.quote_depth > 0u => { + token::DOLLAR if *p.quote_depth > 0u => { p.bump(); - let sp = p.span; + let sp = *p.span; - if p.token == token::LPAREN { + if *p.token == token::LPAREN { let seq = p.parse_seq(token::LPAREN, token::RPAREN, seq_sep_none(), |p| p.parse_token_tree()); @@ -1413,18 +1413,18 @@ pub impl Parser { // turn the next token into a tt_tok: fn parse_any_tt_tok(p: Parser) -> token_tree{ - let res = tt_tok(p.span, p.token); + let res = tt_tok(*p.span, *p.token); p.bump(); res } - match self.token { + match *self.token { token::EOF => { self.fatal(~"file ended in the middle of a macro invocation"); } token::LPAREN | token::LBRACE | token::LBRACKET => { // tjc: ?????? - let ket = token::flip_delimiter(copy self.token); + let ket = token::flip_delimiter(*self.token); tt_delim(vec::append( // the open delimiter: ~[parse_any_tt_tok(self)], @@ -1441,7 +1441,7 @@ pub impl Parser { fn parse_all_token_trees() -> ~[token_tree] { let mut tts = ~[]; - while self.token != token::EOF { + while *self.token != token::EOF { tts.push(self.parse_token_tree()); } tts @@ -1452,11 +1452,11 @@ pub impl Parser { // the interpolation of matchers maybe_whole!(self, nt_matchers); let name_idx = @mut 0u; - return match self.token { + return match *self.token { token::LBRACE | token::LPAREN | token::LBRACKET => { - self.parse_matcher_subseq(name_idx, copy self.token, + self.parse_matcher_subseq(name_idx, *self.token, // tjc: not sure why we need a copy - token::flip_delimiter(copy self.token)) + token::flip_delimiter(*self.token)) } _ => self.fatal(~"expected open delimiter") } @@ -1473,9 +1473,9 @@ pub impl Parser { self.expect(bra); - while self.token != ket || lparens > 0u { - if self.token == token::LPAREN { lparens += 1u; } - if self.token == token::RPAREN { lparens -= 1u; } + while *self.token != ket || lparens > 0u { + if *self.token == token::LPAREN { lparens += 1u; } + if *self.token == token::RPAREN { lparens -= 1u; } ret_val.push(self.parse_matcher(name_idx)); } @@ -1487,11 +1487,12 @@ pub impl Parser { fn parse_matcher(name_idx: @mut uint) -> matcher { let lo = self.span.lo; - let m = if self.token == token::DOLLAR { + let m = if *self.token == token::DOLLAR { self.bump(); - if self.token == token::LPAREN { + if *self.token == token::LPAREN { let name_idx_lo = *name_idx; - let ms = self.parse_matcher_subseq(name_idx, token::LPAREN, + let ms = self.parse_matcher_subseq(name_idx, + token::LPAREN, token::RPAREN); if ms.len() == 0u { self.fatal(~"repetition body must be nonempty"); @@ -1507,7 +1508,7 @@ pub impl Parser { m } } else { - let m = match_tok(self.token); + let m = match_tok(*self.token); self.bump(); m }; @@ -1521,7 +1522,7 @@ pub impl Parser { let mut hi; let mut ex; - match copy self.token { + match *self.token { token::NOT => { self.bump(); let e = self.parse_prefix_expr(); @@ -1610,13 +1611,13 @@ pub impl Parser { fn parse_more_binops(lhs: @expr, min_prec: uint) -> @expr { if self.expr_is_complete(lhs) { return lhs; } - let peeked = self.token; + let peeked = *self.token; if peeked == token::BINOP(token::OR) && - (self.restriction == RESTRICT_NO_BAR_OP || - self.restriction == RESTRICT_NO_BAR_OR_DOUBLEBAR_OP) { + (*self.restriction == RESTRICT_NO_BAR_OP || + *self.restriction == RESTRICT_NO_BAR_OR_DOUBLEBAR_OP) { lhs } else if peeked == token::OROR && - self.restriction == RESTRICT_NO_BAR_OR_DOUBLEBAR_OP { + *self.restriction == RESTRICT_NO_BAR_OR_DOUBLEBAR_OP { lhs } else { let cur_opt = token_to_binop(peeked); @@ -1656,7 +1657,7 @@ pub impl Parser { fn parse_assign_expr() -> @expr { let lo = self.span.lo; let lhs = self.parse_binops(); - match copy self.token { + match *self.token { token::EQ => { self.bump(); let rhs = self.parse_expr(); @@ -1683,7 +1684,7 @@ pub impl Parser { expr_assign_op(aop, lhs, rhs)) } token::LARROW => { - self.obsolete(copy self.span, ObsoleteBinaryMove); + self.obsolete(*self.span, ObsoleteBinaryMove); // Bogus value (but it's an error) self.bump(); // <- self.bump(); // rhs @@ -1733,7 +1734,7 @@ pub impl Parser { fn parse_lambda_block_expr() -> @expr { self.parse_lambda_expr_( || { - match self.token { + match *self.token { token::BINOP(token::OR) | token::OROR => { self.parse_fn_block_decl() } @@ -1744,7 +1745,7 @@ pub impl Parser { output: @Ty { id: self.get_id(), node: ty_infer, - span: self.span + span: *self.span }, cf: return_val } @@ -1841,8 +1842,8 @@ pub impl Parser { // but they aren't represented by tests debug!("sugary call on %?", e.node); self.span_fatal( - lo, fmt!("`%s` must be followed by a block call", - keyword)); + *lo, + fmt!("`%s` must be followed by a block call", keyword)); } } } @@ -1858,13 +1859,13 @@ pub impl Parser { fn parse_loop_expr() -> @expr { // loop headers look like 'loop {' or 'loop unsafe {' let is_loop_header = - self.token == token::LBRACE - || (is_ident(copy self.token) + *self.token == token::LBRACE + || (is_ident(*self.token) && self.look_ahead(1) == token::LBRACE); // labeled loop headers look like 'loop foo: {' let is_labeled_loop_header = - is_ident(self.token) - && !self.is_any_keyword(copy self.token) + is_ident(*self.token) + && !self.is_any_keyword(*self.token) && self.look_ahead(1) == token::COLON; if is_loop_header || is_labeled_loop_header { @@ -1884,7 +1885,7 @@ pub impl Parser { } else { // This is a 'continue' expression let lo = self.span.lo; - let ex = if is_ident(self.token) { + let ex = if is_ident(*self.token) { expr_again(Some(self.parse_ident())) } else { expr_again(None) @@ -1897,7 +1898,7 @@ pub impl Parser { // For distingishing between record literals and blocks fn looking_at_record_literal() -> bool { let lookahead = self.look_ahead(1); - self.token == token::LBRACE && + *self.token == token::LBRACE && (self.token_is_keyword(~"mut", lookahead) || (is_plain_ident(lookahead) && self.look_ahead(2) == token::COLON)) @@ -1907,8 +1908,8 @@ pub impl Parser { self.expect(token::LBRACE); let mut fields = ~[self.parse_field(token::COLON)]; let mut base = None; - while self.token != token::RBRACE { - if self.token == token::COMMA + while *self.token != token::RBRACE { + if *self.token == token::COMMA && self.look_ahead(1) == token::DOTDOT { self.bump(); self.bump(); @@ -1920,7 +1921,7 @@ pub impl Parser { } self.expect(token::COMMA); - if self.token == token::RBRACE { + if *self.token == token::RBRACE { // record ends by an optional trailing comma break; } @@ -1936,7 +1937,7 @@ pub impl Parser { let discriminant = self.parse_expr(); self.expect(token::LBRACE); let mut arms: ~[arm] = ~[]; - while self.token != token::RBRACE { + while *self.token != token::RBRACE { let pats = self.parse_pats(); let mut guard = None; if self.eat_keyword(~"if") { guard = Some(self.parse_expr()); } @@ -1945,7 +1946,7 @@ pub impl Parser { let require_comma = !classify::expr_is_simple_block(expr) - && self.token != token::RBRACE; + && *self.token != token::RBRACE; if require_comma { self.expect(token::COMMA); @@ -1978,21 +1979,21 @@ pub impl Parser { // parse an expression, subject to the given restriction fn parse_expr_res(r: restriction) -> @expr { - let old = self.restriction; - self.restriction = r; + let old = *self.restriction; + *self.restriction = r; let e = self.parse_assign_expr(); - self.restriction = old; + *self.restriction = old; return e; } fn parse_initializer() -> Option<@expr> { - match self.token { + match *self.token { token::EQ => { self.bump(); return Some(self.parse_expr()); } token::LARROW => { - self.obsolete(copy self.span, ObsoleteMoveInit); + self.obsolete(*self.span, ObsoleteMoveInit); self.bump(); self.bump(); return None; @@ -2007,7 +2008,7 @@ pub impl Parser { let mut pats = ~[]; loop { pats.push(self.parse_pat(true)); - if self.token == token::BINOP(token::OR) { self.bump(); } + if *self.token == token::BINOP(token::OR) { self.bump(); } else { return pats; } }; } @@ -2017,12 +2018,12 @@ pub impl Parser { let mut tail = None; let mut first = true; - while self.token != token::RBRACKET { + while *self.token != token::RBRACKET { if first { first = false; } else { self.expect(token::COMMA); } let mut is_tail = false; - if self.token == token::DOTDOT { + if *self.token == token::DOTDOT { self.bump(); is_tail = true; } @@ -2049,15 +2050,15 @@ pub impl Parser { let mut fields = ~[]; let mut etc = false; let mut first = true; - while self.token != token::RBRACE { + while *self.token != token::RBRACE { if first { first = false; } else { self.expect(token::COMMA); } - if self.token == token::UNDERSCORE { + if *self.token == token::UNDERSCORE { self.bump(); - if self.token != token::RBRACE { + if *self.token != token::RBRACE { self.fatal(~"expected `}`, found `" + - token_to_str(self.reader, self.token) + + token_to_str(self.reader, *self.token) + ~"`"); } etc = true; @@ -2074,14 +2075,14 @@ pub impl Parser { let fieldpath = ast_util::ident_to_path(mk_sp(lo1, hi1), fieldname); let mut subpat; - if self.token == token::COLON { + if *self.token == token::COLON { self.bump(); subpat = self.parse_pat(refutable); } else { subpat = @ast::pat { id: self.get_id(), node: pat_ident(bind_infer, fieldpath, None), - span: self.last_span + span: *self.last_span }; } fields.push(ast::field_pat { ident: fieldname, pat: subpat }); @@ -2095,7 +2096,7 @@ pub impl Parser { let lo = self.span.lo; let mut hi = self.span.hi; let mut pat; - match self.token { + match *self.token { token::UNDERSCORE => { self.bump(); pat = pat_wild; } token::AT => { self.bump(); @@ -2173,7 +2174,7 @@ pub impl Parser { } token::LPAREN => { self.bump(); - if self.token == token::RPAREN { + if *self.token == token::RPAREN { hi = self.span.hi; self.bump(); let lit = @codemap::spanned { @@ -2184,7 +2185,7 @@ pub impl Parser { } else { let mut fields = ~[self.parse_pat(refutable)]; if self.look_ahead(1) != token::RPAREN { - while self.token == token::COMMA { + while *self.token == token::COMMA { self.bump(); fields.push(self.parse_pat(refutable)); } @@ -2233,7 +2234,7 @@ pub impl Parser { cannot_be_enum_or_struct = true } - if is_plain_ident(self.token) && cannot_be_enum_or_struct { + if is_plain_ident(*self.token) && cannot_be_enum_or_struct { let name = self.parse_value_path(); let sub; if self.eat(token::AT) { @@ -2244,7 +2245,7 @@ pub impl Parser { pat = pat_ident(binding_mode, name, sub); } else { let enum_path = self.parse_path_with_tps(true); - match self.token { + match *self.token { token::LBRACE => { self.bump(); let (fields, etc) = @@ -2255,7 +2256,7 @@ pub impl Parser { _ => { let mut args: ~[@pat] = ~[]; let mut star_pat = false; - match self.token { + match *self.token { token::LPAREN => match self.look_ahead(1u) { token::BINOP(token::STAR) => { // This is a "top constructor only" pat @@ -2299,9 +2300,9 @@ pub impl Parser { fn parse_pat_ident(refutable: bool, binding_mode: ast::binding_mode) -> ast::pat_ { - if !is_plain_ident(self.token) { + if !is_plain_ident(*self.token) { self.span_fatal( - copy self.last_span, + *self.last_span, ~"expected identifier, found path"); } let name = self.parse_value_path(); @@ -2315,9 +2316,9 @@ pub impl Parser { // leads to a parse error. Note that if there is no explicit // binding mode then we do not end up here, because the lookahead // will direct us over to parse_enum_variant() - if self.token == token::LPAREN { + if *self.token == token::LPAREN { self.span_fatal( - copy self.last_span, + *self.last_span, ~"expected identifier, found enum pattern"); } @@ -2365,7 +2366,7 @@ pub impl Parser { if self.eat_keyword(~"mut") { is_mutbl = struct_mutable; } - if !is_plain_ident(self.token) { + if !is_plain_ident(*self.token) { self.fatal(~"expected ident"); } let name = self.parse_ident(); @@ -2394,8 +2395,8 @@ pub impl Parser { self.expect_keyword(~"let"); let decl = self.parse_let(); return @spanned(lo, decl.span.hi, stmt_decl(decl, self.get_id())); - } else if is_ident(self.token) - && !self.is_any_keyword(copy self.token) + } else if is_ident(*self.token) + && !self.is_any_keyword(*self.token) && self.look_ahead(1) == token::NOT { check_expected_item(self, first_item_attrs); @@ -2405,7 +2406,7 @@ pub impl Parser { let pth = self.parse_value_path(); self.bump(); - let id = if self.token == token::LPAREN { + let id = if *self.token == token::LPAREN { token::special_idents::invalid // no special identifier } else { self.parse_ident() @@ -2460,7 +2461,7 @@ pub impl Parser { } fn expr_is_complete(e: @expr) -> bool { - return self.restriction == RESTRICT_STMT_EXPR && + return *self.restriction == RESTRICT_STMT_EXPR && !classify::expr_requires_semi_to_be_stmt(e); } @@ -2486,7 +2487,7 @@ pub impl Parser { let lo = self.span.lo; if self.eat_keyword(~"unsafe") { - self.obsolete(copy self.span, ObsoleteUnsafeBlock); + self.obsolete(*self.span, ObsoleteUnsafeBlock); } self.expect(token::LBRACE); let (inner, next) = @@ -2530,12 +2531,12 @@ pub impl Parser { let mut initial_attrs = attrs_remaining; - if self.token == token::RBRACE && !vec::is_empty(initial_attrs) { + if *self.token == token::RBRACE && !vec::is_empty(initial_attrs) { self.fatal(~"expected item"); } - while self.token != token::RBRACE { - match self.token { + while *self.token != token::RBRACE { + match *self.token { token::SEMI => { self.bump(); // empty } @@ -2545,7 +2546,7 @@ pub impl Parser { match stmt.node { stmt_expr(e, stmt_id) => { // Expression without semicolon - match self.token { + match *self.token { token::SEMI => { self.bump(); stmts.push(@codemap::spanned { @@ -2570,7 +2571,7 @@ pub impl Parser { stmt_mac(ref m, _) => { // Statement macro; might be an expr - match self.token { + match *self.token { token::SEMI => { self.bump(); stmts.push(@codemap::spanned { @@ -2616,9 +2617,9 @@ pub impl Parser { @Ty { id: self.get_id(), node: ty_path( - ident_to_path(copy self.last_span, i), + ident_to_path(*self.last_span, i), self.get_id()), - span: self.last_span, + span: *self.last_span, } } @@ -2644,12 +2645,12 @@ pub impl Parser { if self.eat_keyword(~"static") { bounds.push(RegionTyParamBound); } else { - self.span_err(copy self.span, + self.span_err(*self.span, ~"`&static` is the only permissible \ region bound here"); } - } else if is_ident(self.token) { - let maybe_bound = match self.token { + } else if is_ident(*self.token) { + let maybe_bound = match *self.token { token::IDENT(copy sid, _) => { match *self.id_to_str(sid) { @@ -2657,7 +2658,7 @@ pub impl Parser { | ~"copy" | ~"const" | ~"owned" => { - self.obsolete(copy self.span, + self.obsolete(*self.span, ObsoleteLowerCaseKindBounds); // Bogus value, but doesn't matter, since // is an error @@ -2689,8 +2690,8 @@ pub impl Parser { loop; } - if is_ident_or_path(self.token) { - self.obsolete(copy self.span, + if is_ident_or_path(*self.token) { + self.obsolete(*self.span, ObsoleteTraitBoundSeparator); } } @@ -2732,7 +2733,7 @@ pub impl Parser { } fn is_self_ident() -> bool { - match self.token { + match *self.token { token::IDENT(id, false) if id == special_idents::self_ => true, _ => false @@ -2742,7 +2743,7 @@ pub impl Parser { fn expect_self_ident() { if !self.is_self_ident() { self.fatal(fmt!("expected `self` but found `%s`", - token_to_str(self.reader, self.token))); + token_to_str(self.reader, *self.token))); } self.bump(); } @@ -2773,7 +2774,7 @@ pub impl Parser { // A bit of complexity and lookahead is needed here in order to to be // backwards compatible. let lo = self.span.lo; - let self_ty = match copy self.token { + let self_ty = match *self.token { token::BINOP(token::AND) => { maybe_parse_self_ty(sty_region, self) } @@ -2795,7 +2796,7 @@ pub impl Parser { // If we parsed a self type, expect a comma before the argument list. let args_or_capture_items; if self_ty != sty_by_ref { - match copy self.token { + match *self.token { token::COMMA => { self.bump(); let sep = seq_sep_trailing_disallowed(token::COMMA); @@ -2809,7 +2810,8 @@ pub impl Parser { } _ => { self.fatal(~"expected `,` or `)`, found `" + - token_to_str(self.reader, self.token) + ~"`"); + token_to_str(self.reader, *self.token) + + ~"`"); } } } else { @@ -2850,7 +2852,7 @@ pub impl Parser { let output = if self.eat(token::RARROW) { self.parse_ty(false) } else { - @Ty { id: self.get_id(), node: ty_infer, span: self.span } + @Ty { id: self.get_id(), node: ty_infer, span: *self.span } }; ast::fn_decl { @@ -2929,7 +2931,7 @@ pub impl Parser { // Parse traits, if necessary. let traits; - if self.token == token::COLON { + if *self.token == token::COLON { self.bump(); traits = self.parse_trait_ref_list(token::LBRACE); } else { @@ -2954,7 +2956,7 @@ pub impl Parser { // First, parse type parameters if necessary. let mut tps; - if self.token == token::LT { + if *self.token == token::LT { tps = self.parse_ty_params(); } else { tps = ~[]; @@ -2978,7 +2980,7 @@ pub impl Parser { }) } _ => { - self.span_err(copy self.span, ~"not a trait"); + self.span_err(*self.span, ~"not a trait"); None } }; @@ -2986,7 +2988,7 @@ pub impl Parser { ty = self.parse_ty(false); opt_trait_ref } else if self.eat(token::COLON) { - self.obsolete(copy self.span, ObsoleteImplSyntax); + self.obsolete(*self.span, ObsoleteImplSyntax); Some(self.parse_trait_ref()) } else { None @@ -3008,7 +3010,7 @@ pub impl Parser { // the return type of the ctor function. fn ident_to_path_tys(i: ident, typarams: ~[ty_param]) -> @path { - let s = self.last_span; + let s = *self.last_span; @ast::path { span: s, @@ -3026,7 +3028,7 @@ pub impl Parser { } fn ident_to_path(i: ident) -> @path { - @ast::path { span: self.last_span, + @ast::path { span: *self.last_span, global: false, idents: ~[i], rp: None, @@ -3051,7 +3053,7 @@ pub impl Parser { self.parse_region_param(); let ty_params = self.parse_ty_params(); if self.eat(token::COLON) { - self.obsolete(copy self.span, ObsoleteClassTraits); + self.obsolete(*self.span, ObsoleteClassTraits); let _ = self.parse_trait_ref_list(token::LBRACE); } @@ -3063,7 +3065,7 @@ pub impl Parser { // It's a record-like struct. is_tuple_like = false; fields = ~[]; - while self.token != token::RBRACE { + while *self.token != token::RBRACE { match self.parse_class_item() { dtor_decl(ref blk, ref attrs, s) => { match the_dtor { @@ -3087,7 +3089,7 @@ pub impl Parser { } } self.bump(); - } else if self.token == token::LPAREN { + } else if *self.token == token::LPAREN { // It's a tuple-like struct. is_tuple_like = true; fields = do self.parse_unspanned_seq(token::LPAREN, token::RPAREN, @@ -3109,7 +3111,7 @@ pub impl Parser { } else { self.fatal(fmt!("expected `{`, `(`, or `;` after struct name \ but found `%s`", - token_to_str(self.reader, self.token))); + token_to_str(self.reader, *self.token))); } let actual_dtor = do the_dtor.map |dtor| { @@ -3139,13 +3141,13 @@ pub impl Parser { fn parse_single_class_item(vis: visibility) -> @struct_field { if self.eat_obsolete_ident("let") { - self.obsolete(copy self.last_span, ObsoleteLet); + self.obsolete(*self.last_span, ObsoleteLet); } let a_var = self.parse_instance_var(vis); - match self.token { + match *self.token { token::SEMI => { - self.obsolete(copy self.span, ObsoleteFieldTerminator); + self.obsolete(*self.span, ObsoleteFieldTerminator); self.bump(); } token::COMMA => { @@ -3153,11 +3155,11 @@ pub impl Parser { } token::RBRACE => {} _ => { - self.span_fatal(copy self.span, + self.span_fatal(*self.span, fmt!("expected `;`, `,`, or '}' but \ found `%s`", token_to_str(self.reader, - self.token))); + *self.token))); } } a_var @@ -3226,7 +3228,7 @@ pub impl Parser { // outer attributes can't occur on view items (or macros // invocations?) let mut first = true; - while self.token != term { + while *self.token != term { let mut attrs = self.parse_outer_attributes(); if first { attrs = vec::append(attrs_remaining, attrs); @@ -3243,7 +3245,7 @@ pub impl Parser { } _ => { self.fatal(~"expected item but found `" + - token_to_str(self.reader, self.token) + ~"`"); + token_to_str(self.reader, *self.token) + ~"`"); } } debug!("parse_mod_items: attrs=%?", attrs); @@ -3268,9 +3270,9 @@ pub impl Parser { } fn parse_item_mod(outer_attrs: ~[ast::attribute]) -> item_info { - let id_span = self.span; + let id_span = *self.span; let id = self.parse_ident(); - let info_ = if self.token == token::SEMI { + let info_ = if *self.token == token::SEMI { self.bump(); // This mod is in an external file. Let's go get it! let (m, attrs) = self.eval_src_mod(id, outer_attrs, id_span); @@ -3292,7 +3294,7 @@ pub impl Parser { match ::attr::first_attr_value_str_by_name(outer_attrs, ~"merge") { Some(path) => { let prefix = Path( - self.sess.cm.span_to_filename(copy self.span)); + self.sess.cm.span_to_filename(*self.span)); let prefix = prefix.dir_path(); let path = Path(copy *path); let (new_mod_item, new_attrs) = self.eval_src_mod_from_path( @@ -3337,9 +3339,9 @@ pub impl Parser { outer_attrs: ~[ast::attribute], id_sp: span) -> (ast::item_, ~[ast::attribute]) { - let prefix = Path(self.sess.cm.span_to_filename(copy self.span)); + let prefix = Path(self.sess.cm.span_to_filename(*self.span)); let prefix = prefix.dir_path(); - let mod_path = Path(".").push_many(self.mod_path_stack); + let mod_path = Path(".").push_many(*self.mod_path_stack); let default_path = self.sess.interner.get(id) + ~".rs"; let file_path = match ::attr::first_attr_value_str_by_name( outer_attrs, ~"path") { @@ -3456,7 +3458,7 @@ pub impl Parser { let mut items: ~[@foreign_item] = foreign_items; let mut initial_attrs = attrs_remaining; - while self.token != token::RBRACE { + while *self.token != token::RBRACE { let attrs = vec::append(initial_attrs, self.parse_outer_attributes()); initial_attrs = ~[]; @@ -3478,7 +3480,7 @@ pub impl Parser { // Parse the ABI. let abi_opt; - match self.token { + match *self.token { token::LIT_STR(copy found_abi) => { self.bump(); abi_opt = Some(found_abi); @@ -3492,21 +3494,21 @@ pub impl Parser { if self.is_keyword(~"mod") { must_be_named_mod = true; self.expect_keyword(~"mod"); - } else if self.token != token::LBRACE { - self.span_fatal(copy self.span, + } else if *self.token != token::LBRACE { + self.span_fatal(*self.span, fmt!("expected `{` or `mod` but found %s", - token_to_str(self.reader, self.token))); + token_to_str(self.reader, *self.token))); } - let (sort, ident) = match self.token { + let (sort, ident) = match *self.token { token::IDENT(*) => (ast::named, self.parse_ident()), _ => { if must_be_named_mod { - self.span_fatal(copy self.span, + self.span_fatal(*self.span, fmt!("expected foreign module name but \ found %s", token_to_str(self.reader, - self.token))); + *self.token))); } (ast::anonymous, @@ -3534,7 +3536,7 @@ pub impl Parser { match abi_opt { None => {} // OK. Some(_) => { - self.span_err(copy self.span, ~"an ABI may not be specified \ + self.span_err(*self.span, ~"an ABI may not be specified \ here"); } } @@ -3575,7 +3577,7 @@ pub impl Parser { fn parse_struct_def() -> @struct_def { let mut the_dtor: Option<(blk, ~[attribute], codemap::span)> = None; let mut fields: ~[@struct_field] = ~[]; - while self.token != token::RBRACE { + while *self.token != token::RBRACE { match self.parse_class_item() { dtor_decl(ref blk, ref attrs, s) => { match the_dtor { @@ -3621,7 +3623,7 @@ pub impl Parser { let mut all_nullary = true, have_disr = false; let mut common_fields = None; - while self.token != token::RBRACE { + while *self.token != token::RBRACE { let variant_attrs = self.parse_outer_attributes(); let vlo = self.span.lo; @@ -3652,7 +3654,7 @@ pub impl Parser { // Parse a struct variant. all_nullary = false; kind = struct_variant_kind(self.parse_struct_def()); - } else if self.token == token::LPAREN { + } else if *self.token == token::LPAREN { all_nullary = false; let arg_tys = self.parse_unspanned_seq( token::LPAREN, token::RPAREN, @@ -3701,7 +3703,7 @@ pub impl Parser { self.parse_region_param(); let ty_params = self.parse_ty_params(); // Newtype syntax - if self.token == token::EQ { + if *self.token == token::EQ { self.bump(); let ty = self.parse_ty(false); self.expect(token::SEMI); @@ -3733,7 +3735,7 @@ pub impl Parser { } fn parse_fn_ty_sigil() -> Option { - match self.token { + match *self.token { token::AT => { self.bump(); Some(ManagedSigil) @@ -3879,7 +3881,7 @@ pub impl Parser { vis: visibility, span: mk_sp(lo, self.last_span.hi) }); - } else if macros_allowed && !self.is_any_keyword(copy self.token) + } else if macros_allowed && !self.is_any_keyword(*self.token) && self.look_ahead(1) == token::NOT && (is_plain_ident(self.look_ahead(2)) || self.look_ahead(2) == token::LPAREN @@ -3896,16 +3898,16 @@ pub impl Parser { // a 'special' identifier (like what `macro_rules!` uses) // is optional. We should eventually unify invoc syntax // and remove this. - let id = if is_plain_ident(self.token) { + let id = if is_plain_ident(*self.token) { self.parse_ident() } else { token::special_idents::invalid // no special identifier }; // eat a matched-delimiter token tree: - let tts = match self.token { + let tts = match *self.token { token::LPAREN | token::LBRACE => { - let ket = token::flip_delimiter(copy self.token); - self.parse_unspanned_seq(copy self.token, ket, + let ket = token::flip_delimiter(*self.token); + self.parse_unspanned_seq(*self.token, ket, seq_sep_none(), |p| p.parse_token_tree()) } @@ -3925,7 +3927,7 @@ pub impl Parser { let mut s = ~"unmatched visibility `"; s += if visibility == public { ~"pub" } else { ~"priv" }; s += ~"`"; - self.span_fatal(copy self.last_span, s); + self.span_fatal(*self.last_span, s); } return iovi_none; }; @@ -3961,12 +3963,12 @@ pub impl Parser { let first_ident = self.parse_ident(); let mut path = ~[first_ident]; debug!("parsed view_path: %s", *self.id_to_str(first_ident)); - match self.token { + match *self.token { token::EQ => { // x = foo::bar self.bump(); path = ~[self.parse_ident()]; - while self.token == token::MOD_SEP { + while *self.token == token::MOD_SEP { self.bump(); let id = self.parse_ident(); path.push(id); @@ -3983,11 +3985,10 @@ pub impl Parser { token::MOD_SEP => { // foo::bar or foo::{a,b,c} or foo::* - while self.token == token::MOD_SEP { + while *self.token == token::MOD_SEP { self.bump(); - match copy self.token { - + match *self.token { token::IDENT(i, _) => { self.bump(); path.push(i); @@ -4038,7 +4039,7 @@ pub impl Parser { fn parse_view_paths() -> ~[@view_path] { let mut vp = ~[self.parse_view_path()]; - while self.token == token::COMMA { + while *self.token == token::COMMA { self.bump(); vp.push(self.parse_view_path()); } @@ -4048,7 +4049,7 @@ pub impl Parser { fn is_view_item() -> bool { let tok, next_tok; if !self.is_keyword(~"pub") && !self.is_keyword(~"priv") { - tok = self.token; + tok = *self.token; next_tok = self.look_ahead(1); } else { tok = self.look_ahead(1); @@ -4159,7 +4160,7 @@ pub impl Parser { } fn parse_str() -> @~str { - match copy self.token { + match *self.token { token::LIT_STR(s) => { self.bump(); self.id_to_str(s) } _ => self.fatal(~"expected string literal") } From a07192fadd794b1eaaec85541886e07578002b74 Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Thu, 21 Feb 2013 18:27:24 -0800 Subject: [PATCH 4/7] libsyntax: Remove all mutable fields from libsyntax. rs=demuting --- src/libsyntax/codemap.rs | 6 +++--- src/libsyntax/util/interner.rs | 4 ++-- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs index 3a863fc7ac5dc..1ab55fe9035bc 100644 --- a/src/libsyntax/codemap.rs +++ b/src/libsyntax/codemap.rs @@ -242,7 +242,7 @@ pub struct FileMap { /// The start position of this source in the CodeMap start_pos: BytePos, /// Locations of lines beginnings in the source code - mut lines: ~[BytePos], + lines: @mut ~[BytePos], /// Locations of multi-byte characters in the source code multibyte_chars: DVec } @@ -312,7 +312,7 @@ pub impl CodeMap { let filemap = @FileMap { name: filename, substr: substr, src: src, start_pos: BytePos(start_pos), - mut lines: ~[], + lines: @mut ~[], multibyte_chars: DVec() }; @@ -439,7 +439,7 @@ priv impl CodeMap { let idx = self.lookup_filemap_idx(pos); let f = self.files[idx]; let mut a = 0u; - let mut b = vec::len(f.lines); + let mut b = f.lines.len(); while b - a > 1u { let m = (a + b) / 2u; if f.lines[m] > pos { b = m; } else { a = m; } diff --git a/src/libsyntax/util/interner.rs b/src/libsyntax/util/interner.rs index 4b13818974c30..41500d6a409a8 100644 --- a/src/libsyntax/util/interner.rs +++ b/src/libsyntax/util/interner.rs @@ -18,7 +18,7 @@ use hashmap::linear::LinearMap; use dvec::DVec; pub struct Interner { - priv mut map: LinearMap, + priv map: @mut LinearMap, priv vect: DVec, } @@ -26,7 +26,7 @@ pub struct Interner { pub impl Interner { static fn new() -> Interner { Interner { - map: LinearMap::new(), + map: @mut LinearMap::new(), vect: DVec(), } } From ce707363638c0dab5f60ff25489afcd67ba9d48d Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Thu, 21 Feb 2013 18:31:16 -0800 Subject: [PATCH 5/7] etc: Suppress the remaining Valgrind error in rustdoc. rs=burningtree --- src/etc/x86.supp | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/etc/x86.supp b/src/etc/x86.supp index 722f7c4aee699..16a3144c01717 100644 --- a/src/etc/x86.supp +++ b/src/etc/x86.supp @@ -415,6 +415,13 @@ ... } +{ + enum-instruction-scheduling-8 + Memcheck:Cond + fun:*should_set_output_format_to_markdown_if_requested* + ... +} + { llvm-user-new-leak Memcheck:Leak From 1144fdde1f658e957e6ab54f8bc199e40583e851 Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Thu, 21 Feb 2013 18:41:33 -0800 Subject: [PATCH 6/7] librustpkg: De-mut librustdoc and librustpkg. rs=demuting --- src/librustdoc/path_pass.rs | 8 ++++---- src/librustpkg/rustpkg.rc | 4 ++-- src/librustpkg/util.rs | 31 ++++++++++++++++--------------- 3 files changed, 22 insertions(+), 21 deletions(-) diff --git a/src/librustdoc/path_pass.rs b/src/librustdoc/path_pass.rs index ac50221445f73..c03eb06d2dde0 100644 --- a/src/librustdoc/path_pass.rs +++ b/src/librustdoc/path_pass.rs @@ -31,14 +31,14 @@ pub fn mk_pass() -> Pass { struct Ctxt { srv: astsrv::Srv, - mut path: ~[~str] + path: @mut ~[~str] } impl Clone for Ctxt { fn clone(&self) -> Ctxt { Ctxt { srv: self.srv.clone(), - path: copy self.path + path: @mut copy *self.path } } } @@ -47,7 +47,7 @@ impl Clone for Ctxt { fn run(srv: astsrv::Srv, doc: doc::Doc) -> doc::Doc { let ctxt = Ctxt { srv: srv, - mut path: ~[] + path: @mut ~[] }; let fold = Fold { ctxt: ctxt.clone(), @@ -61,7 +61,7 @@ fn run(srv: astsrv::Srv, doc: doc::Doc) -> doc::Doc { fn fold_item(fold: &fold::Fold, doc: doc::ItemDoc) -> doc::ItemDoc { doc::ItemDoc { - path: copy fold.ctxt.path, + path: copy *fold.ctxt.path, .. doc } } diff --git a/src/librustpkg/rustpkg.rc b/src/librustpkg/rustpkg.rc index 78db7dccb86b6..c16a56249ffab 100644 --- a/src/librustpkg/rustpkg.rc +++ b/src/librustpkg/rustpkg.rc @@ -252,7 +252,7 @@ impl PackageScript { struct Ctx { cfgs: ~[~str], json: bool, - mut dep_cache: LinearMap<~str, bool> + dep_cache: @mut LinearMap<~str, bool> } impl Ctx { @@ -912,7 +912,7 @@ pub fn main() { Ctx { cfgs: cfgs, json: json, - mut dep_cache: LinearMap::new() + dep_cache: @mut LinearMap::new() }.run(cmd, args); } diff --git a/src/librustpkg/util.rs b/src/librustpkg/util.rs index 5e549d9649080..64a6d9c50554a 100644 --- a/src/librustpkg/util.rs +++ b/src/librustpkg/util.rs @@ -72,11 +72,11 @@ struct ReadyCtx { sess: session::Session, crate: @ast::crate, ext_cx: ext_ctxt, - mut path: ~[ast::ident], - mut fns: ~[ListenerFn] + path: ~[ast::ident], + fns: ~[ListenerFn] } -fn fold_mod(_ctx: @ReadyCtx, m: ast::_mod, +fn fold_mod(_ctx: @mut ReadyCtx, m: ast::_mod, fold: fold::ast_fold) -> ast::_mod { fn strip_main(item: @ast::item) -> @ast::item { @ast::item { @@ -95,7 +95,7 @@ fn fold_mod(_ctx: @ReadyCtx, m: ast::_mod, }, fold) } -fn fold_item(ctx: @ReadyCtx, item: @ast::item, +fn fold_item(ctx: @mut ReadyCtx, item: @ast::item, fold: fold::ast_fold) -> Option<@ast::item> { ctx.path.push(item.ident); @@ -133,7 +133,7 @@ fn fold_item(ctx: @ReadyCtx, item: @ast::item, res } -fn add_pkg_module(ctx: @ReadyCtx, m: ast::_mod) -> ast::_mod { +fn add_pkg_module(ctx: @mut ReadyCtx, m: ast::_mod) -> ast::_mod { let listeners = mk_listener_vec(ctx); let ext_cx = ctx.ext_cx; let item = quote_item! ( @@ -152,24 +152,25 @@ fn add_pkg_module(ctx: @ReadyCtx, m: ast::_mod) -> ast::_mod { } } -fn mk_listener_vec(ctx: @ReadyCtx) -> @ast::expr { +fn mk_listener_vec(ctx: @mut ReadyCtx) -> @ast::expr { let fns = ctx.fns; let descs = do fns.map |listener| { mk_listener_rec(ctx, *listener) }; - build::mk_slice_vec_e(ctx.ext_cx, dummy_sp(), descs) + let ext_cx = ctx.ext_cx; + build::mk_slice_vec_e(ext_cx, dummy_sp(), descs) } -fn mk_listener_rec(ctx: @ReadyCtx, listener: ListenerFn) -> @ast::expr { - +fn mk_listener_rec(ctx: @mut ReadyCtx, listener: ListenerFn) -> @ast::expr { let span = listener.span; let cmds = do listener.cmds.map |&cmd| { - build::mk_base_str(ctx.ext_cx, span, cmd) + let ext_cx = ctx.ext_cx; + build::mk_base_str(ext_cx, span, cmd) }; - let cmds_expr = build::mk_slice_vec_e(ctx.ext_cx, span, cmds); - let cb_expr = build::mk_path(ctx.ext_cx, span, copy listener.path); let ext_cx = ctx.ext_cx; + let cmds_expr = build::mk_slice_vec_e(ext_cx, span, cmds); + let cb_expr = build::mk_path(ext_cx, span, copy listener.path); quote_expr!( Listener { @@ -182,12 +183,12 @@ fn mk_listener_rec(ctx: @ReadyCtx, listener: ListenerFn) -> @ast::expr { /// Generate/filter main function, add the list of commands, etc. pub fn ready_crate(sess: session::Session, crate: @ast::crate) -> @ast::crate { - let ctx = @ReadyCtx { + let ctx = @mut ReadyCtx { sess: sess, crate: crate, ext_cx: mk_ctxt(sess.parse_sess, copy sess.opts.cfg), - mut path: ~[], - mut fns: ~[] + path: ~[], + fns: ~[] }; let precursor = @fold::AstFoldFns { // fold_crate: fold::wrap(|a, b| fold_crate(ctx, a, b)), From c56343b95c575660ab2f0a70327c8d8a2b035d95 Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Fri, 22 Feb 2013 16:08:16 -0800 Subject: [PATCH 7/7] test: De-mut the test suite. rs=demuting --- src/test/auxiliary/issue_3882.rs | 4 +- src/test/bench/shootout-fasta.rs | 6 +- src/test/bench/shootout-nbody.rs | 101 ++++++++++-------- src/test/compile-fail/borrowck-assign-comp.rs | 17 +-- src/test/compile-fail/borrowck-call-sendfn.rs | 2 +- ...k-imm-ref-to-mut-rec-field-issue-3162-b.rs | 26 ----- ...wck-imm-ref-to-mut-rec-field-issue-3162.rs | 25 ----- .../borrowck-mut-field-imm-base.rs | 30 ------ .../borrowck-no-cycle-in-exchange-heap.rs | 10 +- .../compile-fail/borrowck-uniq-via-box.rs | 12 --- .../compile-fail/borrowck-uniq-via-ref.rs | 12 --- src/test/compile-fail/issue-1451.rs | 12 +-- src/test/compile-fail/issue-3021-b.rs | 4 +- src/test/compile-fail/issue-3044.rs | 8 +- .../compile-fail/issue-3177-mutable-struct.rs | 2 +- src/test/compile-fail/issue-3214.rs | 2 +- src/test/compile-fail/issue-3601.rs | 4 +- src/test/compile-fail/issue-3973.rs | 4 +- .../compile-fail/mutable-huh-variance-rec.rs | 10 +- src/test/compile-fail/non-const.rs | 58 ---------- .../compile-fail/pure-modifies-aliased.rs | 10 +- src/test/compile-fail/regions-addr-of-self.rs | 10 +- .../regions-addr-of-upvar-self.rs | 6 +- .../compile-fail/regions-glb-free-free.rs | 2 +- ...ions-infer-invariance-due-to-mutability.rs | 6 +- .../regions-infer-paramd-method.rs | 16 +-- src/test/compile-fail/tps-invariant-class.rs | 2 +- src/test/compile-fail/tps-invariant-enum.rs | 7 +- src/test/compile-fail/tps-invariant-trait.rs | 4 +- src/test/pretty/block-disambig.rs | 4 +- src/test/run-pass-fulldeps/issue-1926.rs | 8 +- src/test/run-pass/alignment-gep-tup-like-2.rs | 4 +- .../run-pass/alloca-from-derived-tydesc.rs | 4 +- src/test/run-pass/alt-implicit-copy-unique.rs | 6 +- src/test/run-pass/argument-passing.rs | 8 +- src/test/run-pass/binops.rs | 16 +-- src/test/run-pass/borrowck-binding-mutbl.rs | 4 +- .../run-pass/borrowck-newtype-issue-2573.rs | 6 +- .../run-pass/borrowck-root-while-cond-2.rs | 4 +- src/test/run-pass/borrowck-root-while-cond.rs | 4 +- .../run-pass/boxed-class-type-substitution.rs | 4 +- src/test/run-pass/cycle-collection2.rs | 8 +- src/test/run-pass/cycle-collection5.rs | 6 +- src/test/run-pass/explicit-self.rs | 8 +- src/test/run-pass/expr-copy.rs | 11 +- src/test/run-pass/exterior.rs | 8 +- src/test/run-pass/issue-2633.rs | 2 +- src/test/run-pass/issue-2718.rs | 70 ++++++------ src/test/run-pass/issue-3389.rs | 6 +- src/test/run-pass/issue-3447.rs | 6 +- src/test/run-pass/issue-3904.rs | 2 +- src/test/run-pass/issue-3979-generics.rs | 6 +- src/test/run-pass/issue-3979-xcrate.rs | 8 +- src/test/run-pass/issue-3979.rs | 16 +-- src/test/run-pass/lambda-infer-unresolved.rs | 4 +- src/test/run-pass/log-linearized.rs | 8 +- src/test/run-pass/mlist-cycle.rs | 10 +- src/test/run-pass/nested-patterns.rs | 6 +- src/test/run-pass/reflect-visit-data.rs | 15 ++- src/test/run-pass/reflect-visit-type.rs | 4 +- src/test/run-pass/resource-cycle.rs | 14 +-- src/test/run-pass/resource-cycle2.rs | 10 +- src/test/run-pass/resource-cycle3.rs | 10 +- src/test/run-pass/trait-cast.rs | 35 +++--- src/test/run-pass/writealias.rs | 4 +- 65 files changed, 311 insertions(+), 450 deletions(-) delete mode 100644 src/test/compile-fail/borrowck-imm-ref-to-mut-rec-field-issue-3162-b.rs delete mode 100644 src/test/compile-fail/borrowck-imm-ref-to-mut-rec-field-issue-3162.rs delete mode 100644 src/test/compile-fail/borrowck-mut-field-imm-base.rs delete mode 100644 src/test/compile-fail/non-const.rs diff --git a/src/test/auxiliary/issue_3882.rs b/src/test/auxiliary/issue_3882.rs index c2b95e4e7d653..6d232c34b47e0 100644 --- a/src/test/auxiliary/issue_3882.rs +++ b/src/test/auxiliary/issue_3882.rs @@ -10,10 +10,10 @@ mod issue_3882 { struct Completions { - mut len: libc::size_t, + len: libc::size_t, } extern mod c { - fn linenoiseAddCompletion(lc: *Completions); + fn linenoiseAddCompletion(lc: *mut Completions); } } diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs index da2f2d5c3d221..509861e2f470f 100644 --- a/src/test/bench/shootout-fasta.rs +++ b/src/test/bench/shootout-fasta.rs @@ -21,10 +21,10 @@ use io::WriterUtil; fn LINE_LENGTH() -> uint { return 60u; } struct MyRandom { - mut last: u32 + last: u32 } -fn myrandom_next(r: @MyRandom, mx: u32) -> u32 { +fn myrandom_next(r: @mut MyRandom, mx: u32) -> u32 { r.last = (r.last * 3877u32 + 29573u32) % 139968u32; mx * r.last / 139968u32 } @@ -59,7 +59,7 @@ fn select_random(r: u32, genelist: ~[AminoAcids]) -> char { fn make_random_fasta(wr: io::Writer, id: ~str, desc: ~str, genelist: ~[AminoAcids], n: int) { wr.write_line(~">" + id + ~" " + desc); - let rng = @MyRandom {mut last: rand::Rng().next()}; + let rng = @mut MyRandom {last: rand::Rng().next()}; let mut op: ~str = ~""; for uint::range(0u, n as uint) |_i| { str::push_char(&mut op, select_random(myrandom_next(rng, 100u32), diff --git a/src/test/bench/shootout-nbody.rs b/src/test/bench/shootout-nbody.rs index 67d3391ed1336..e7b3547ab8c7e 100644 --- a/src/test/bench/shootout-nbody.rs +++ b/src/test/bench/shootout-nbody.rs @@ -170,67 +170,80 @@ mod Body { // was 4 * PI * PI originally pub const DAYS_PER_YEAR: float = 365.24; - pub struct Props - {mut x: float, - mut y: float, - mut z: float, - mut vx: float, - mut vy: float, - mut vz: float, - mass: float} + pub struct Props { + x: float, + y: float, + z: float, + vx: float, + vy: float, + vz: float, + mass: float + } pub fn jupiter() -> Body::Props { - return Props {mut x: 4.84143144246472090e+00, - mut y: -1.16032004402742839e+00, - mut z: -1.03622044471123109e-01, - mut vx: 1.66007664274403694e-03 * DAYS_PER_YEAR, - mut vy: 7.69901118419740425e-03 * DAYS_PER_YEAR, - mut vz: -6.90460016972063023e-05 * DAYS_PER_YEAR, - mass: 9.54791938424326609e-04 * SOLAR_MASS}; + return Props { + x: 4.84143144246472090e+00, + y: -1.16032004402742839e+00, + z: -1.03622044471123109e-01, + vx: 1.66007664274403694e-03 * DAYS_PER_YEAR, + vy: 7.69901118419740425e-03 * DAYS_PER_YEAR, + vz: -6.90460016972063023e-05 * DAYS_PER_YEAR, + mass: 9.54791938424326609e-04 * SOLAR_MASS + }; } pub fn saturn() -> Body::Props { - return Props {mut x: 8.34336671824457987e+00, - mut y: 4.12479856412430479e+00, - mut z: -4.03523417114321381e-01, - mut vx: -2.76742510726862411e-03 * DAYS_PER_YEAR, - mut vy: 4.99852801234917238e-03 * DAYS_PER_YEAR, - mut vz: 2.30417297573763929e-05 * DAYS_PER_YEAR, - mass: 2.85885980666130812e-04 * SOLAR_MASS}; + return Props { + x: 8.34336671824457987e+00, + y: 4.12479856412430479e+00, + z: -4.03523417114321381e-01, + vx: -2.76742510726862411e-03 * DAYS_PER_YEAR, + vy: 4.99852801234917238e-03 * DAYS_PER_YEAR, + vz: 2.30417297573763929e-05 * DAYS_PER_YEAR, + mass: 2.85885980666130812e-04 * SOLAR_MASS + }; } pub fn uranus() -> Body::Props { - return Props {mut x: 1.28943695621391310e+01, - mut y: -1.51111514016986312e+01, - mut z: -2.23307578892655734e-01, - mut vx: 2.96460137564761618e-03 * DAYS_PER_YEAR, - mut vy: 2.37847173959480950e-03 * DAYS_PER_YEAR, - mut vz: -2.96589568540237556e-05 * DAYS_PER_YEAR, - mass: 4.36624404335156298e-05 * SOLAR_MASS}; + return Props { + x: 1.28943695621391310e+01, + y: -1.51111514016986312e+01, + z: -2.23307578892655734e-01, + vx: 2.96460137564761618e-03 * DAYS_PER_YEAR, + vy: 2.37847173959480950e-03 * DAYS_PER_YEAR, + vz: -2.96589568540237556e-05 * DAYS_PER_YEAR, + mass: 4.36624404335156298e-05 * SOLAR_MASS + }; } pub fn neptune() -> Body::Props { - return Props {mut x: 1.53796971148509165e+01, - mut y: -2.59193146099879641e+01, - mut z: 1.79258772950371181e-01, - mut vx: 2.68067772490389322e-03 * DAYS_PER_YEAR, - mut vy: 1.62824170038242295e-03 * DAYS_PER_YEAR, - mut vz: -9.51592254519715870e-05 * DAYS_PER_YEAR, - mass: 5.15138902046611451e-05 * SOLAR_MASS}; + return Props { + x: 1.53796971148509165e+01, + y: -2.59193146099879641e+01, + z: 1.79258772950371181e-01, + vx: 2.68067772490389322e-03 * DAYS_PER_YEAR, + vy: 1.62824170038242295e-03 * DAYS_PER_YEAR, + vz: -9.51592254519715870e-05 * DAYS_PER_YEAR, + mass: 5.15138902046611451e-05 * SOLAR_MASS + }; } pub fn sun() -> Body::Props { - return Props {mut x: 0.0, - mut y: 0.0, - mut z: 0.0, - mut vx: 0.0, - mut vy: 0.0, - mut vz: 0.0, - mass: SOLAR_MASS}; + return Props { + x: 0.0, + y: 0.0, + z: 0.0, + vx: 0.0, + vy: 0.0, + vz: 0.0, + mass: SOLAR_MASS + }; } pub fn offset_momentum(props: &mut Body::Props, - px: float, py: float, pz: float) { + px: float, + py: float, + pz: float) { props.vx = -px / SOLAR_MASS; props.vy = -py / SOLAR_MASS; props.vz = -pz / SOLAR_MASS; diff --git a/src/test/compile-fail/borrowck-assign-comp.rs b/src/test/compile-fail/borrowck-assign-comp.rs index f5597859433b3..283f04a283f4e 100644 --- a/src/test/compile-fail/borrowck-assign-comp.rs +++ b/src/test/compile-fail/borrowck-assign-comp.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -struct point {x: int, mut y: int } +struct point { x: int, y: int } fn a() { let mut p = point {x: 3, y: 4}; @@ -20,22 +20,13 @@ fn a() { p.x = 5; //~ ERROR assigning to mutable field prohibited due to outstanding loan } -fn b() { - let mut p = point {x: 3, mut y: 4}; - // This assignment is legal because `y` is inherently mutable (and - // hence &_q.y is &mut int). - let _q = &p; - - p.y = 5; -} - fn c() { // this is sort of the opposite. We take a loan to the interior of `p` // and then try to overwrite `p` as a whole. - let mut p = point {x: 3, mut y: 4}; + let mut p = point {x: 3, y: 4}; let _q = &p.y; //~ NOTE loan of mutable local variable granted here - p = point {x: 5, mut y: 7};//~ ERROR assigning to mutable local variable prohibited due to outstanding loan + p = point {x: 5, y: 7};//~ ERROR assigning to mutable local variable prohibited due to outstanding loan copy p; } @@ -43,7 +34,7 @@ fn d() { // just for completeness's sake, the easy case, where we take the // address of a subcomponent and then modify that subcomponent: - let mut p = point {x: 3, mut y: 4}; + let mut p = point {x: 3, y: 4}; let _q = &p.y; //~ NOTE loan of mutable field granted here p.y = 5; //~ ERROR assigning to mutable field prohibited due to outstanding loan copy p; diff --git a/src/test/compile-fail/borrowck-call-sendfn.rs b/src/test/compile-fail/borrowck-call-sendfn.rs index c83f9230dbb99..51047631ea665 100644 --- a/src/test/compile-fail/borrowck-call-sendfn.rs +++ b/src/test/compile-fail/borrowck-call-sendfn.rs @@ -10,7 +10,7 @@ // xfail-test #2978 -fn call(x: @{mut f: fn~()}) { +fn call(x: @{f: fn~()}) { x.f(); //~ ERROR foo //~^ NOTE bar } diff --git a/src/test/compile-fail/borrowck-imm-ref-to-mut-rec-field-issue-3162-b.rs b/src/test/compile-fail/borrowck-imm-ref-to-mut-rec-field-issue-3162-b.rs deleted file mode 100644 index 64baf3a945766..0000000000000 --- a/src/test/compile-fail/borrowck-imm-ref-to-mut-rec-field-issue-3162-b.rs +++ /dev/null @@ -1,26 +0,0 @@ -// Copyright 2012 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -fn each(x: &[T], op: fn(elem: &T) -> bool) { - uint::range(0, x.len(), |i| op(&x[i])); -} - -struct A { - mut a: int -} - -fn main() { - let x = [A {mut a: 0}]; - for each(x) |y| { - let z = &y.a; //~ ERROR illegal borrow unless pure - x[0].a = 10; //~ NOTE impure due to assigning to mutable field - log(error, z); - } -} diff --git a/src/test/compile-fail/borrowck-imm-ref-to-mut-rec-field-issue-3162.rs b/src/test/compile-fail/borrowck-imm-ref-to-mut-rec-field-issue-3162.rs deleted file mode 100644 index a14fd18c7d554..0000000000000 --- a/src/test/compile-fail/borrowck-imm-ref-to-mut-rec-field-issue-3162.rs +++ /dev/null @@ -1,25 +0,0 @@ -// Copyright 2012 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -fn each(x: &[T], op: fn(elem: &T) -> bool) { - uint::range(0, x.len(), |i| op(&x[i])); -} - -fn main() { - struct A { - mut a: int - } - let x = ~[A {mut a: 0}]; - for each(x) |y| { - let z = &y.a; //~ ERROR illegal borrow unless pure - x[0].a = 10; //~ NOTE impure due to assigning to mutable field - log(error, z); - } -} diff --git a/src/test/compile-fail/borrowck-mut-field-imm-base.rs b/src/test/compile-fail/borrowck-mut-field-imm-base.rs deleted file mode 100644 index 685efcacf0c58..0000000000000 --- a/src/test/compile-fail/borrowck-mut-field-imm-base.rs +++ /dev/null @@ -1,30 +0,0 @@ -// Copyright 2012 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -struct Foo { - mut x: uint -} - -struct Bar { - foo: Foo -} - -fn main() { - let mut b = Bar { foo: Foo { x: 3 } }; - let p = &b; - let q = &mut b.foo.x; - let r = &p.foo.x; //~ ERROR illegal borrow unless pure - let s = &b.foo.x; //~ ERROR loan of mutable field as immutable conflicts with prior loan - io::println(fmt!("*r = %u", *r)); - io::println(fmt!("*r = %u", *s)); - *q += 1; - io::println(fmt!("*r = %u", *r)); - io::println(fmt!("*r = %u", *s)); -} diff --git a/src/test/compile-fail/borrowck-no-cycle-in-exchange-heap.rs b/src/test/compile-fail/borrowck-no-cycle-in-exchange-heap.rs index e7cbab4107984..4af3bc17240ce 100644 --- a/src/test/compile-fail/borrowck-no-cycle-in-exchange-heap.rs +++ b/src/test/compile-fail/borrowck-no-cycle-in-exchange-heap.rs @@ -9,7 +9,7 @@ // except according to those terms. struct node_ { - mut a: ~cycle + a: ~cycle } enum cycle { @@ -17,11 +17,11 @@ enum cycle { empty } fn main() { - let x = ~node(node_ {mut a: ~empty}); + let mut x = ~node(node_ {a: ~empty}); // Create a cycle! - match *x { //~ NOTE loan of immutable local variable granted here - node(ref y) => { - y.a = x; //~ ERROR moving out of immutable local variable prohibited due to outstanding loan + match *x { //~ NOTE loan of mutable local variable granted here + node(ref mut y) => { + y.a = x; //~ ERROR moving out of mutable local variable prohibited due to outstanding loan } empty => {} }; diff --git a/src/test/compile-fail/borrowck-uniq-via-box.rs b/src/test/compile-fail/borrowck-uniq-via-box.rs index e4b8214fb984c..9a63c8698c65a 100644 --- a/src/test/compile-fail/borrowck-uniq-via-box.rs +++ b/src/test/compile-fail/borrowck-uniq-via-box.rs @@ -14,10 +14,6 @@ fn box_mut(v: @mut ~int) { borrow(*v); //~ ERROR illegal borrow unless pure } -fn box_rec_mut(v: @{mut f: ~int}) { - borrow(v.f); //~ ERROR illegal borrow unless pure -} - fn box_mut_rec(v: @mut {f: ~int}) { borrow(v.f); //~ ERROR illegal borrow unless pure } @@ -42,14 +38,6 @@ fn box_const(v: @const ~int) { borrow(*v); //~ ERROR illegal borrow unless pure } -fn box_rec_const(v: @{const f: ~int}) { - borrow(v.f); //~ ERROR illegal borrow unless pure -} - -fn box_recs_const(v: @{f: {g: {const h: ~int}}}) { - borrow(v.f.g.h); //~ ERROR illegal borrow unless pure -} - fn box_const_rec(v: @const {f: ~int}) { borrow(v.f); //~ ERROR illegal borrow unless pure } diff --git a/src/test/compile-fail/borrowck-uniq-via-ref.rs b/src/test/compile-fail/borrowck-uniq-via-ref.rs index 48d39c39e5a47..8d6e7039057f6 100644 --- a/src/test/compile-fail/borrowck-uniq-via-ref.rs +++ b/src/test/compile-fail/borrowck-uniq-via-ref.rs @@ -14,10 +14,6 @@ fn box_mut(v: &mut ~int) { borrow(*v); // OK: &mut -> &imm } -fn box_rec_mut(v: &{mut f: ~int}) { - borrow(v.f); //~ ERROR illegal borrow unless pure -} - fn box_mut_rec(v: &mut {f: ~int}) { borrow(v.f); // OK: &mut -> &imm } @@ -42,14 +38,6 @@ fn box_const(v: &const ~int) { borrow(*v); //~ ERROR illegal borrow unless pure } -fn box_rec_const(v: &{const f: ~int}) { - borrow(v.f); //~ ERROR illegal borrow unless pure -} - -fn box_recs_const(v: &{f: {g: {const h: ~int}}}) { - borrow(v.f.g.h); //~ ERROR illegal borrow unless pure -} - fn box_const_rec(v: &const {f: ~int}) { borrow(v.f); //~ ERROR illegal borrow unless pure } diff --git a/src/test/compile-fail/issue-1451.rs b/src/test/compile-fail/issue-1451.rs index 62bc322f41600..2e80a7b09defa 100644 --- a/src/test/compile-fail/issue-1451.rs +++ b/src/test/compile-fail/issue-1451.rs @@ -9,8 +9,8 @@ // except according to those terms. // xfail-test -type T = { mut f: fn@() }; -type S = { f: fn@() }; +struct T { f: fn@() }; +struct S { f: fn@() }; fn fooS(t: S) { } @@ -23,11 +23,11 @@ fn bar() { fn main() { let x: fn@() = bar; - fooS({f: x}); - fooS({f: bar}); + fooS(S {f: x}); + fooS(S {f: bar}); let x: fn@() = bar; - fooT({mut f: x}); - fooT({mut f: bar}); + fooT(T {f: x}); + fooT(T {f: bar}); } diff --git a/src/test/compile-fail/issue-3021-b.rs b/src/test/compile-fail/issue-3021-b.rs index 09454d4326ab7..a782dd58ee671 100644 --- a/src/test/compile-fail/issue-3021-b.rs +++ b/src/test/compile-fail/issue-3021-b.rs @@ -13,11 +13,11 @@ extern mod std; fn siphash(k0 : u64) { struct siphash { - mut v0: u64, + v0: u64, } impl siphash { - fn reset() { + fn reset(&mut self) { self.v0 = k0 ^ 0x736f6d6570736575; //~ ERROR attempted dynamic environment-capture //~^ ERROR unresolved name: k0 } diff --git a/src/test/compile-fail/issue-3044.rs b/src/test/compile-fail/issue-3044.rs index 46ad7f6458944..fcd5b1deee552 100644 --- a/src/test/compile-fail/issue-3044.rs +++ b/src/test/compile-fail/issue-3044.rs @@ -11,10 +11,10 @@ fn main() { let needlesArr: ~[char] = ~['a', 'f']; do vec::foldr(needlesArr) |x, y| { - //~^ ERROR 2 parameters were supplied (including the closure passed by the `do` keyword) - //~^^ ERROR Unconstrained region variable #2 - // - // this last error is, um, non-ideal. + //~^ ERROR Unconstrained region variable #2 } + //~^ ERROR 2 parameters were supplied (including the closure passed by the `do` keyword) + // + // the first error is, um, non-ideal. } diff --git a/src/test/compile-fail/issue-3177-mutable-struct.rs b/src/test/compile-fail/issue-3177-mutable-struct.rs index ab28b461a2c6b..31c0dc7d9c4e2 100644 --- a/src/test/compile-fail/issue-3177-mutable-struct.rs +++ b/src/test/compile-fail/issue-3177-mutable-struct.rs @@ -12,7 +12,7 @@ // error-pattern: instantiating a type parameter with an incompatible type struct S { s: T, - mut cant_nest: () + cant_nest: () } fn main() { diff --git a/src/test/compile-fail/issue-3214.rs b/src/test/compile-fail/issue-3214.rs index ff19551896b86..2dd58906ddb71 100644 --- a/src/test/compile-fail/issue-3214.rs +++ b/src/test/compile-fail/issue-3214.rs @@ -10,7 +10,7 @@ fn foo() { struct foo { - mut x: T, //~ ERROR attempt to use a type argument out of scope + x: T, //~ ERROR attempt to use a type argument out of scope //~^ ERROR use of undeclared type name } diff --git a/src/test/compile-fail/issue-3601.rs b/src/test/compile-fail/issue-3601.rs index 40d65938795ff..3dd070b44a04c 100644 --- a/src/test/compile-fail/issue-3601.rs +++ b/src/test/compile-fail/issue-3601.rs @@ -10,7 +10,7 @@ // xfail-test struct HTMLImageData { - mut image: Option<~str> + image: Option<~str> } struct ElementData { @@ -30,7 +30,7 @@ enum NodeData = { }; fn main() { - let id = HTMLImageData { image: None }; + let mut id = HTMLImageData { image: None }; let ed = ElementData { kind: ~HTMLImageElement(id) }; let n = NodeData({kind : ~Element(ed)}); match n.kind { diff --git a/src/test/compile-fail/issue-3973.rs b/src/test/compile-fail/issue-3973.rs index 812e0fc8c9660..19244d24bcc71 100644 --- a/src/test/compile-fail/issue-3973.rs +++ b/src/test/compile-fail/issue-3973.rs @@ -11,8 +11,8 @@ // xfail-test struct Point { - mut x: float, - mut y: float, + x: float, + y: float, } impl ToStr for Point { //~ ERROR implements a method not defined in the trait diff --git a/src/test/compile-fail/mutable-huh-variance-rec.rs b/src/test/compile-fail/mutable-huh-variance-rec.rs index 1ee2bb18321c3..6d79e23e999a7 100644 --- a/src/test/compile-fail/mutable-huh-variance-rec.rs +++ b/src/test/compile-fail/mutable-huh-variance-rec.rs @@ -10,11 +10,15 @@ // error-pattern: mismatched types +struct S { + g: ~[int] +} + fn main() { - let v = {mut g: ~[0]}; + let v = S {g: ~[0]}; - fn f(&&v: {mut g: ~[const int]}) { - v.g = ~[mut 3] + fn f(&&v: {g: ~[const int]}) { + v.g = ~[3] } f(v); diff --git a/src/test/compile-fail/non-const.rs b/src/test/compile-fail/non-const.rs deleted file mode 100644 index 3b6522c308dd2..0000000000000 --- a/src/test/compile-fail/non-const.rs +++ /dev/null @@ -1,58 +0,0 @@ -// Copyright 2012 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -// Test that various non const things are rejected. - -fn foo(_x: T) { } - -struct r { - x:int, -} - -impl Drop for r { - fn finalize(&self) {} -} - -fn r(x:int) -> r { - r { - x: x - } -} - -struct r2 { - x:@mut int, -} - -impl Drop for r2 { - fn finalize(&self) {} -} - -fn r2(x:@mut int) -> r2 { - r2 { - x: x - } -} - -fn main() { - struct A { f: T } - struct B { mut f: T } - - foo(A {f: 3}); - foo(B {mut f: 3}); //~ ERROR does not fulfill `Const` - foo(~[1]); - foo(~[mut 1]); //~ ERROR does not fulfill `Const` - foo(~1); - foo(~mut 1); //~ ERROR does not fulfill `Const` - foo(@1); - foo(@mut 1); //~ ERROR does not fulfill `Const` - foo(r(1)); // this is okay now. - foo(r2(@mut 1)); //~ ERROR does not fulfill `Const` - foo(A {f: B {mut f: 1}}); //~ ERROR does not fulfill `Const` -} diff --git a/src/test/compile-fail/pure-modifies-aliased.rs b/src/test/compile-fail/pure-modifies-aliased.rs index 90c507091e932..2aa81dd4fa21e 100644 --- a/src/test/compile-fail/pure-modifies-aliased.rs +++ b/src/test/compile-fail/pure-modifies-aliased.rs @@ -10,20 +10,20 @@ // Check that pure functions cannot modify aliased state. -pure fn modify_in_ref(&&sum: {mut f: int}) { - sum.f = 3; //~ ERROR assigning to mutable field prohibited in pure context +struct S { + f: int, } -pure fn modify_in_box(sum: @mut {f: int}) { +pure fn modify_in_box(sum: @mut S) { sum.f = 3; //~ ERROR assigning to mutable field prohibited in pure context } trait modify_in_box_rec { - pure fn modify_in_box_rec(sum: @{mut f: int}); + pure fn modify_in_box_rec(sum: @mut S); } impl modify_in_box_rec for int { - pure fn modify_in_box_rec(sum: @{mut f: int}) { + pure fn modify_in_box_rec(sum: @mut S) { sum.f = self; //~ ERROR assigning to mutable field prohibited in pure context } } diff --git a/src/test/compile-fail/regions-addr-of-self.rs b/src/test/compile-fail/regions-addr-of-self.rs index 2b52200908338..c6c89a3ae04a7 100644 --- a/src/test/compile-fail/regions-addr-of-self.rs +++ b/src/test/compile-fail/regions-addr-of-self.rs @@ -9,16 +9,16 @@ // except according to those terms. struct dog { - mut cats_chased: uint, + cats_chased: uint, } impl dog { - fn chase_cat() { - let p: &static/mut uint = &mut self.cats_chased; //~ ERROR illegal borrow + fn chase_cat(&mut self) { + let p: &static/mut uint = &mut self.cats_chased; //~ ERROR cannot infer an appropriate lifetime due to conflicting requirements *p += 1u; } - fn chase_cat_2() { + fn chase_cat_2(&mut self) { let p: &blk/mut uint = &mut self.cats_chased; *p += 1u; } @@ -31,7 +31,7 @@ fn dog() -> dog { } fn main() { - let d = dog(); + let mut d = dog(); d.chase_cat(); debug!("cats_chased: %u", d.cats_chased); } diff --git a/src/test/compile-fail/regions-addr-of-upvar-self.rs b/src/test/compile-fail/regions-addr-of-upvar-self.rs index cf026785420d7..8e98d4341a8b3 100644 --- a/src/test/compile-fail/regions-addr-of-upvar-self.rs +++ b/src/test/compile-fail/regions-addr-of-upvar-self.rs @@ -9,13 +9,13 @@ // except according to those terms. struct dog { - mut food: uint, + food: uint, } impl dog { - fn chase_cat() { + fn chase_cat(&mut self) { for uint::range(0u, 10u) |_i| { - let p: &'static mut uint = &mut self.food; //~ ERROR illegal borrow + let p: &'static mut uint = &mut self.food; //~ ERROR cannot infer an appropriate lifetime due to conflicting requirements *p = 3u; } } diff --git a/src/test/compile-fail/regions-glb-free-free.rs b/src/test/compile-fail/regions-glb-free-free.rs index a8bbc24ffd475..f9ea3c6f933a3 100644 --- a/src/test/compile-fail/regions-glb-free-free.rs +++ b/src/test/compile-fail/regions-glb-free-free.rs @@ -17,7 +17,7 @@ mod argparse { name: &str, desc: &str, max_count: uint, - mut value: uint + value: uint } pub fn flag(name: &r/str, desc: &r/str) -> Flag/&r { diff --git a/src/test/compile-fail/regions-infer-invariance-due-to-mutability.rs b/src/test/compile-fail/regions-infer-invariance-due-to-mutability.rs index fabce969b9c3f..bdd9b372e4ef6 100644 --- a/src/test/compile-fail/regions-infer-invariance-due-to-mutability.rs +++ b/src/test/compile-fail/regions-infer-invariance-due-to-mutability.rs @@ -9,7 +9,7 @@ // except according to those terms. struct invariant { - mut f: &int + f: &int } fn to_same_lifetime(bi: invariant/&r) { @@ -17,8 +17,8 @@ fn to_same_lifetime(bi: invariant/&r) { } fn to_shorter_lifetime(bi: invariant/&r) { - let bj: invariant/&blk = bi; //~ ERROR mismatched types -} + let bj: invariant/&blk = bi; +} fn to_longer_lifetime(bi: invariant/&r) -> invariant/&static { bi //~ ERROR mismatched types diff --git a/src/test/compile-fail/regions-infer-paramd-method.rs b/src/test/compile-fail/regions-infer-paramd-method.rs index a75e1deb6a2a3..0f1b23b2839c6 100644 --- a/src/test/compile-fail/regions-infer-paramd-method.rs +++ b/src/test/compile-fail/regions-infer-paramd-method.rs @@ -17,14 +17,16 @@ trait foo { fn any_int() -> ∫ } -type with_foo = {mut f: foo}; +struct with_foo { + f: foo +} trait set_foo_foo { - fn set_foo(f: foo); + fn set_foo(&mut self, f: foo); } impl set_foo_foo for with_foo { - fn set_foo(f: foo) { + fn set_foo(&mut self, f: foo) { self.f = f; //~ ERROR mismatched types: expected `@foo/&self` but found `@foo/&` } } @@ -35,14 +37,16 @@ trait bar { fn any_int() -> ∫ } -type with_bar = {mut f: bar}; +struct with_bar { + f: bar +} trait set_foo_bar { - fn set_foo(f: bar); + fn set_foo(&mut self, f: bar); } impl set_foo_bar for with_bar { - fn set_foo(f: bar) { + fn set_foo(&mut self, f: bar) { self.f = f; } } diff --git a/src/test/compile-fail/tps-invariant-class.rs b/src/test/compile-fail/tps-invariant-class.rs index c1a0b2209711c..0411eeb05ebe1 100644 --- a/src/test/compile-fail/tps-invariant-class.rs +++ b/src/test/compile-fail/tps-invariant-class.rs @@ -9,7 +9,7 @@ // except according to those terms. struct box_impl { - mut f: T, + f: T, } fn box_impl(f: T) -> box_impl { diff --git a/src/test/compile-fail/tps-invariant-enum.rs b/src/test/compile-fail/tps-invariant-enum.rs index ead155320b81c..967b201908c4b 100644 --- a/src/test/compile-fail/tps-invariant-enum.rs +++ b/src/test/compile-fail/tps-invariant-enum.rs @@ -9,8 +9,9 @@ // except according to those terms. struct box { - mut f: T + f: T } + enum box_impl = box; fn set_box_impl(b: box_impl<@const T>, v: @const T) { @@ -18,12 +19,12 @@ fn set_box_impl(b: box_impl<@const T>, v: @const T) { } fn main() { - let b = box_impl::<@int>(box::<@int> {mut f: @3}); + let b = box_impl::<@int>(box::<@int> {f: @3}); set_box_impl(b, @mut 5); //~^ ERROR values differ in mutability // No error when type of parameter actually IS @const int let x: @const int = @3; // only way I could find to upcast - let b = box_impl::<@const int>(box::<@const int>{mut f: x}); + let b = box_impl::<@const int>(box::<@const int>{f: x}); set_box_impl(b, @mut 5); } diff --git a/src/test/compile-fail/tps-invariant-trait.rs b/src/test/compile-fail/tps-invariant-trait.rs index adf8223289887..60da6d2208a83 100644 --- a/src/test/compile-fail/tps-invariant-trait.rs +++ b/src/test/compile-fail/tps-invariant-trait.rs @@ -14,7 +14,7 @@ trait box_trait { } struct box { - mut f: T + f: T } enum box_impl = box; @@ -33,7 +33,7 @@ fn set_box_impl(b: box_impl<@const T>, v: @const T) { } fn main() { - let b = box_impl::<@int>(box::<@int> {mut f: @3}); + let b = box_impl::<@int>(box::<@int> {f: @3}); set_box_trait(b as box_trait::<@int>, @mut 5); //~^ ERROR values differ in mutability set_box_impl(b, @mut 5); diff --git a/src/test/pretty/block-disambig.rs b/src/test/pretty/block-disambig.rs index 17a2db5d1f067..5cc8f6e6edc58 100644 --- a/src/test/pretty/block-disambig.rs +++ b/src/test/pretty/block-disambig.rs @@ -16,10 +16,10 @@ fn test1() { let val = @0; { } *val; } fn test2() -> int { let val = @0; { } *val } -struct S { mut eax: int } +struct S { eax: int } fn test3() { - let regs = @S {mut eax: 0}; + let regs = @mut S {eax: 0}; match true { true => { } _ => { } } (*regs).eax = 1; } diff --git a/src/test/run-pass-fulldeps/issue-1926.rs b/src/test/run-pass-fulldeps/issue-1926.rs index 7d52f13b0750a..95a80630d7c6d 100644 --- a/src/test/run-pass-fulldeps/issue-1926.rs +++ b/src/test/run-pass-fulldeps/issue-1926.rs @@ -20,12 +20,12 @@ use syntax::parse::parser; fn new_parse_sess() -> parser::parse_sess { let cm = codemap::new_codemap(); let handler = diagnostic::mk_handler(option::none); - let sess = @{ + let sess = @mut { cm: cm, - mut next_id: 1, + next_id: 1, span_diagnostic: diagnostic::mk_span_handler(handler, cm), - mut chpos: 0u, - mut byte_pos: 0u + chpos: 0u, + byte_pos: 0u }; return sess; } diff --git a/src/test/run-pass/alignment-gep-tup-like-2.rs b/src/test/run-pass/alignment-gep-tup-like-2.rs index 2a09de7a81c22..2f008e5158695 100644 --- a/src/test/run-pass/alignment-gep-tup-like-2.rs +++ b/src/test/run-pass/alignment-gep-tup-like-2.rs @@ -15,11 +15,11 @@ struct Pair { enum RecEnum = Rec; struct Rec { val: A, - mut rec: Option<@RecEnum> + rec: Option<@mut RecEnum> } fn make_cycle(a: A) { - let g: @RecEnum = @RecEnum(Rec {val: a, mut rec: None}); + let g: @mut RecEnum = @mut RecEnum(Rec {val: a, rec: None}); g.rec = Some(g); } diff --git a/src/test/run-pass/alloca-from-derived-tydesc.rs b/src/test/run-pass/alloca-from-derived-tydesc.rs index 37fdfca4468ce..ddaa38223ecae 100644 --- a/src/test/run-pass/alloca-from-derived-tydesc.rs +++ b/src/test/run-pass/alloca-from-derived-tydesc.rs @@ -10,8 +10,8 @@ enum option { some(T), none, } -struct R {mut v: ~[option]} +struct R {v: ~[option]} fn f() -> ~[T] { return ~[]; } -pub fn main() { let r: R = R {mut v: ~[]}; r.v = f(); } +pub fn main() { let mut r: R = R {v: ~[]}; r.v = f(); } diff --git a/src/test/run-pass/alt-implicit-copy-unique.rs b/src/test/run-pass/alt-implicit-copy-unique.rs index 58076b59cebfb..e73eb57d607c1 100644 --- a/src/test/run-pass/alt-implicit-copy-unique.rs +++ b/src/test/run-pass/alt-implicit-copy-unique.rs @@ -8,12 +8,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -struct Pair { mut a: ~int, mut b: ~int } +struct Pair { a: ~int, b: ~int } pub fn main() { - let x = ~Pair {mut a: ~10, b: ~20}; + let mut x = ~Pair {a: ~10, b: ~20}; match x { - ~Pair {a: ref mut a, b: ref b} => { + ~Pair {a: ref mut a, b: ref mut b} => { assert **a == 10; *a = ~30; assert **a == 30; } } diff --git a/src/test/run-pass/argument-passing.rs b/src/test/run-pass/argument-passing.rs index 89c86c1cf430f..95c23753c27e4 100644 --- a/src/test/run-pass/argument-passing.rs +++ b/src/test/run-pass/argument-passing.rs @@ -10,7 +10,7 @@ // xfail-fast -struct X { mut x: int } +struct X { x: int } fn f1(a: &mut X, b: &mut int, -c: int) -> int { let r = a.x + *b + c; @@ -19,13 +19,13 @@ fn f1(a: &mut X, b: &mut int, -c: int) -> int { return r; } -fn f2(a: int, f: fn(int)) -> int { f(1); return a; } +fn f2(a: int, f: &fn(int)) -> int { f(1); return a; } pub fn main() { - let mut a = X {mut x: 1}, b = 2, c = 3; + let mut a = X {x: 1}, b = 2, c = 3; assert (f1(&mut a, &mut b, c) == 6); assert (a.x == 0); assert (b == 10); - assert (f2(a.x, |x| a.x = 50 ) == 0); + assert (f2(a.x, |x| a.x = 50) == 0); assert (a.x == 50); } diff --git a/src/test/run-pass/binops.rs b/src/test/run-pass/binops.rs index 99379813840ff..2044a5c2346b4 100644 --- a/src/test/run-pass/binops.rs +++ b/src/test/run-pass/binops.rs @@ -86,9 +86,10 @@ extern mod test { pub fn get_task_id() -> libc::intptr_t; } +#[deriving_eq] struct p { - mut x: int, - mut y: int, + x: int, + y: int, } fn p(x: int, y: int) -> p { @@ -98,16 +99,9 @@ fn p(x: int, y: int) -> p { } } -impl cmp::Eq for p { - pure fn eq(&self, other: &p) -> bool { - (*self).x == (*other).x && (*self).y == (*other).y - } - pure fn ne(&self, other: &p) -> bool { !(*self).eq(other) } -} - fn test_class() { - let q = p(1, 2); - let r = p(1, 2); + let mut q = p(1, 2); + let mut r = p(1, 2); unsafe { error!("q = %x, r = %x", diff --git a/src/test/run-pass/borrowck-binding-mutbl.rs b/src/test/run-pass/borrowck-binding-mutbl.rs index 6e8b35f76788d..377ed2608e513 100644 --- a/src/test/run-pass/borrowck-binding-mutbl.rs +++ b/src/test/run-pass/borrowck-binding-mutbl.rs @@ -8,13 +8,13 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -struct F { mut f: ~[int] } +struct F { f: ~[int] } fn impure(_v: &[int]) { } pub fn main() { - let x = F {f: ~[3]}; + let mut x = F {f: ~[3]}; match x { F {f: ref mut v} => { diff --git a/src/test/run-pass/borrowck-newtype-issue-2573.rs b/src/test/run-pass/borrowck-newtype-issue-2573.rs index 5dc373aa50fef..7e81345739f64 100644 --- a/src/test/run-pass/borrowck-newtype-issue-2573.rs +++ b/src/test/run-pass/borrowck-newtype-issue-2573.rs @@ -8,9 +8,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -enum foo = {mut bar: baz}; +struct foo {bar: baz} -enum baz = @{mut baz: int}; +struct baz_ {baz: int} + +type baz = @mut baz_; trait frob { fn frob(); diff --git a/src/test/run-pass/borrowck-root-while-cond-2.rs b/src/test/run-pass/borrowck-root-while-cond-2.rs index 5b2232daa4a1d..ea165e53ceb1a 100644 --- a/src/test/run-pass/borrowck-root-while-cond-2.rs +++ b/src/test/run-pass/borrowck-root-while-cond-2.rs @@ -8,10 +8,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -struct F { mut f: @G } +struct F { f: @G } struct G { g: ~[int] } pub fn main() { - let rec = @F {mut f: @G {g: ~[1, 2, 3]}}; + let rec = @mut F {f: @G {g: ~[1, 2, 3]}}; while rec.f.g.len() == 23 {} } diff --git a/src/test/run-pass/borrowck-root-while-cond.rs b/src/test/run-pass/borrowck-root-while-cond.rs index 432847cc1983c..285796db20e66 100644 --- a/src/test/run-pass/borrowck-root-while-cond.rs +++ b/src/test/run-pass/borrowck-root-while-cond.rs @@ -10,9 +10,9 @@ fn borrow(x: &r/T) -> &r/T {x} -struct Rec { mut f: @int } +struct Rec { f: @int } pub fn main() { - let rec = @Rec {mut f: @22}; + let rec = @mut Rec {f: @22}; while *borrow(rec.f) == 23 {} } diff --git a/src/test/run-pass/boxed-class-type-substitution.rs b/src/test/run-pass/boxed-class-type-substitution.rs index 4fe553ec03958..025bf8fd9d94f 100644 --- a/src/test/run-pass/boxed-class-type-substitution.rs +++ b/src/test/run-pass/boxed-class-type-substitution.rs @@ -12,7 +12,7 @@ // the boxed type parameter type Tree = { - mut parent: Option, + parent: Option, }; fn empty() -> Tree { fail!() } @@ -28,7 +28,7 @@ fn Box() -> Box { } enum layout_data = { - mut box: Option<@Box> + box: Option<@Box> }; pub fn main() { } diff --git a/src/test/run-pass/cycle-collection2.rs b/src/test/run-pass/cycle-collection2.rs index 127a1c9703896..125c3ba1027b7 100644 --- a/src/test/run-pass/cycle-collection2.rs +++ b/src/test/run-pass/cycle-collection2.rs @@ -8,13 +8,13 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -struct foo { mut z : fn@() } +struct foo { z: fn@() } fn nop() { } -fn nop_foo(_x : @foo) { } +fn nop_foo(_x : @mut foo) { } pub fn main() { - let w = @foo{ mut z: || nop() }; - let x : fn@() = || nop_foo(w); + let w = @mut foo{ z: || nop() }; + let x: fn@() = || nop_foo(w); w.z = x; } diff --git a/src/test/run-pass/cycle-collection5.rs b/src/test/run-pass/cycle-collection5.rs index 6f3297c660272..fe0d294f01a7a 100644 --- a/src/test/run-pass/cycle-collection5.rs +++ b/src/test/run-pass/cycle-collection5.rs @@ -8,15 +8,15 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -struct foo { mut z : fn@() } +struct foo { z: fn@() } fn nop() { } -fn nop_foo(_y: @int, _x : @foo) { } +fn nop_foo(_y: @int, _x: @mut foo) { } fn o() -> @int { @10 } pub fn main() { - let w = @foo { mut z: || nop() }; + let w = @mut foo { z: || nop() }; let x : fn@() = || nop_foo(o(), w); w.z = x; } diff --git a/src/test/run-pass/explicit-self.rs b/src/test/run-pass/explicit-self.rs index f162a1bc48a6a..26e2023e89c50 100644 --- a/src/test/run-pass/explicit-self.rs +++ b/src/test/run-pass/explicit-self.rs @@ -46,7 +46,7 @@ struct thing { x: A } -struct A { mut a: @int } +struct A { a: @int } fn thing(x: A) -> thing { thing { @@ -67,14 +67,14 @@ impl Nus for thing { fn f(&self) {} } pub fn main() { - let x = @thing(A {mut a: @10}); + let x = @thing(A {a: @10}); assert x.foo() == 10; assert x.quux() == 10; - let y = ~thing(A {mut a: @10}); + let y = ~thing(A {a: @10}); assert (copy y).bar() == 10; assert y.quux() == 10; - let z = thing(A {mut a: @11}); + let z = thing(A {a: @11}); assert z.spam() == 11; } diff --git a/src/test/run-pass/expr-copy.rs b/src/test/run-pass/expr-copy.rs index 21080280d2c4c..babe04813a97b 100644 --- a/src/test/run-pass/expr-copy.rs +++ b/src/test/run-pass/expr-copy.rs @@ -10,17 +10,18 @@ // xfail-fast -fn f(arg: &A) { +fn f(arg: &mut A) { arg.a = 100; } -struct A { mut a: int } +struct A { a: int } pub fn main() { - let x = A {a: 10}; - f(&x); + let mut x = A {a: 10}; + f(&mut x); assert x.a == 100; x.a = 20; - f(© x); + let mut x = copy x; + f(&mut x); assert x.a == 20; } diff --git a/src/test/run-pass/exterior.rs b/src/test/run-pass/exterior.rs index f7faf26bc4c40..2ce67f16c06fb 100644 --- a/src/test/run-pass/exterior.rs +++ b/src/test/run-pass/exterior.rs @@ -12,13 +12,13 @@ // -*- rust -*- -struct Point {x: int, y: int, mut z: int} +struct Point {x: int, y: int, z: int} -fn f(p: @Point) { assert (p.z == 12); p.z = 13; assert (p.z == 13); } +fn f(p: @mut Point) { assert (p.z == 12); p.z = 13; assert (p.z == 13); } pub fn main() { - let a: Point = Point {x: 10, y: 11, mut z: 12}; - let b: @Point = @copy a; + let a: Point = Point {x: 10, y: 11, z: 12}; + let b: @mut Point = @mut copy a; assert (b.z == 12); f(b); assert (a.z == 12); diff --git a/src/test/run-pass/issue-2633.rs b/src/test/run-pass/issue-2633.rs index 8ff51b0c28e69..04d75fd08e184 100644 --- a/src/test/run-pass/issue-2633.rs +++ b/src/test/run-pass/issue-2633.rs @@ -9,7 +9,7 @@ // except according to those terms. struct cat { - mut meow: fn@(), + meow: fn@(), } fn cat() -> cat { diff --git a/src/test/run-pass/issue-2718.rs b/src/test/run-pass/issue-2718.rs index 029fe12fcd984..249d1c21376bd 100644 --- a/src/test/run-pass/issue-2718.rs +++ b/src/test/run-pass/issue-2718.rs @@ -15,9 +15,9 @@ pub mod pipes { use core::cast::{forget, transmute}; pub struct Stuff { - mut state: state, - mut blocked_task: Option, - mut payload: Option + state: state, + blocked_task: Option, + payload: Option } #[deriving_eq] @@ -29,17 +29,17 @@ pub mod pipes { } pub type packet = { - mut state: state, - mut blocked_task: Option, - mut payload: Option + state: state, + blocked_task: Option, + payload: Option }; pub fn packet() -> *packet { unsafe { let p: *packet = cast::transmute(~Stuff{ - mut state: empty, - mut blocked_task: None::, - mut payload: None:: + state: empty, + blocked_task: None::, + payload: None:: }); p } @@ -70,9 +70,9 @@ pub mod pipes { } } - pub fn send(-p: send_packet, -payload: T) { - let p = p.unwrap(); - let p = unsafe { uniquify(p) }; + pub fn send(mut p: send_packet, -payload: T) { + let mut p = p.unwrap(); + let mut p = unsafe { uniquify(p) }; assert (*p).payload.is_none(); (*p).payload = Some(payload); let old_state = swap_state_rel(&mut (*p).state, full); @@ -96,9 +96,9 @@ pub mod pipes { } } - pub fn recv(-p: recv_packet) -> Option { - let p = p.unwrap(); - let p = unsafe { uniquify(p) }; + pub fn recv(mut p: recv_packet) -> Option { + let mut p = p.unwrap(); + let mut p = unsafe { uniquify(p) }; loop { let old_state = swap_state_acq(&mut (*p).state, blocked); @@ -117,8 +117,8 @@ pub mod pipes { } } - pub fn sender_terminate(p: *packet) { - let p = unsafe { uniquify(p) }; + pub fn sender_terminate(mut p: *packet) { + let mut p = unsafe { uniquify(p) }; match swap_state_rel(&mut (*p).state, terminated) { empty | blocked => { // The receiver will eventually clean up. @@ -134,8 +134,8 @@ pub mod pipes { } } - pub fn receiver_terminate(p: *packet) { - let p = unsafe { uniquify(p) }; + pub fn receiver_terminate(mut p: *packet) { + let mut p = unsafe { uniquify(p) }; match swap_state_rel(&mut (*p).state, terminated) { empty => { // the sender will clean up @@ -152,21 +152,25 @@ pub mod pipes { } pub struct send_packet { - mut p: Option<*packet>, + p: Option<*packet>, } pub impl Drop for send_packet { fn finalize(&self) { - if self.p != None { - let mut p = None; - p <-> self.p; - sender_terminate(option::unwrap(p)) + unsafe { + if self.p != None { + let mut p = None; + let self_p: &mut Option<*packet> = + cast::transmute(&self.p); + p <-> *self_p; + sender_terminate(option::unwrap(p)) + } } } } pub impl send_packet { - fn unwrap() -> *packet { + fn unwrap(&mut self) -> *packet { let mut p = None; p <-> self.p; option::unwrap(p) @@ -180,21 +184,25 @@ pub mod pipes { } pub struct recv_packet { - mut p: Option<*packet>, + p: Option<*packet>, } pub impl Drop for recv_packet { fn finalize(&self) { - if self.p != None { - let mut p = None; - p <-> self.p; - receiver_terminate(option::unwrap(p)) + unsafe { + if self.p != None { + let mut p = None; + let self_p: &mut Option<*packet> = + cast::transmute(&self.p); + p <-> *self_p; + receiver_terminate(option::unwrap(p)) + } } } } pub impl recv_packet { - fn unwrap() -> *packet { + fn unwrap(&mut self) -> *packet { let mut p = None; p <-> self.p; option::unwrap(p) diff --git a/src/test/run-pass/issue-3389.rs b/src/test/run-pass/issue-3389.rs index b25e6ae2d2d91..5555867073491 100644 --- a/src/test/run-pass/issue-3389.rs +++ b/src/test/run-pass/issue-3389.rs @@ -9,8 +9,8 @@ // except according to those terms. struct trie_node { - mut content: ~[~str], - mut children: ~[trie_node], + content: ~[~str], + children: ~[trie_node], } fn print_str_vector(vector: ~[~str]) { @@ -20,7 +20,7 @@ fn print_str_vector(vector: ~[~str]) { } pub fn main() { - let node: trie_node = trie_node { + let mut node: trie_node = trie_node { content: ~[], children: ~[] }; diff --git a/src/test/run-pass/issue-3447.rs b/src/test/run-pass/issue-3447.rs index 0bcc5983eb719..0d1b0b9d0029e 100644 --- a/src/test/run-pass/issue-3447.rs +++ b/src/test/run-pass/issue-3447.rs @@ -10,17 +10,17 @@ struct list { element: &self/T, - mut next: Option<@list> + next: Option<@mut list> } impl list{ - fn addEnd(&self, element: &self/T) { + fn addEnd(&mut self, element: &self/T) { let newList = list { element: element, next: option::None }; - self.next = Some(@(newList)); + self.next = Some(@mut newList); } } diff --git a/src/test/run-pass/issue-3904.rs b/src/test/run-pass/issue-3904.rs index 885b8da9325da..8f2b13b6eb028 100644 --- a/src/test/run-pass/issue-3904.rs +++ b/src/test/run-pass/issue-3904.rs @@ -20,7 +20,7 @@ fn exit(+print: ErrPrinter, prog: &str, arg: &str) { } struct X { - mut err: ErrPrinter + err: ErrPrinter } impl X { diff --git a/src/test/run-pass/issue-3979-generics.rs b/src/test/run-pass/issue-3979-generics.rs index ab042922df942..ce0ae64856236 100644 --- a/src/test/run-pass/issue-3979-generics.rs +++ b/src/test/run-pass/issue-3979-generics.rs @@ -10,7 +10,7 @@ // xfail-test trait Positioned { - fn SetX(&self, S); + fn SetX(&mut self, S); fn X(&self) -> S; } @@ -21,10 +21,10 @@ trait Movable: Positioned { } } -struct Point { mut x: int, mut y: int } +struct Point { x: int, y: int } impl Positioned for Point { - fn SetX(&self, x: int) { + fn SetX(&mut self, x: int) { self.x = x; } fn X(&self) -> int { diff --git a/src/test/run-pass/issue-3979-xcrate.rs b/src/test/run-pass/issue-3979-xcrate.rs index 07cf9d68d167c..18ad14153d760 100644 --- a/src/test/run-pass/issue-3979-xcrate.rs +++ b/src/test/run-pass/issue-3979-xcrate.rs @@ -13,10 +13,10 @@ extern mod issue_3979_traits; use issue_3979_traits::*; -struct Point { mut x: int, mut y: int } +struct Point { x: int, y: int } impl Positioned for Point { - fn SetX(&self, x: int) { + fn SetX(&mut self, x: int) { self.x = x; } fn X(&self) -> int { @@ -24,10 +24,10 @@ impl Positioned for Point { } } -impl Point: Movable; +impl Movable for Point; pub fn main() { - let p = Point{ x: 1, y: 2}; + let mut p = Point{ x: 1, y: 2}; p.translate(3); assert p.X() == 4; } diff --git a/src/test/run-pass/issue-3979.rs b/src/test/run-pass/issue-3979.rs index 5d48d1e72de1c..6d6be35bfa06a 100644 --- a/src/test/run-pass/issue-3979.rs +++ b/src/test/run-pass/issue-3979.rs @@ -1,3 +1,6 @@ +// xfail-test +// Reason: ICE with explicit self + // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. @@ -9,21 +12,22 @@ // except according to those terms. trait Positioned { - fn SetX(&self, int); + fn SetX(&mut self, int); fn X(&self) -> int; } #[allow(default_methods)] trait Movable: Positioned { - fn translate(&self, dx: int) { - self.SetX(self.X() + dx); + fn translate(&mut self, dx: int) { + let x = self.X(); + self.SetX(x + dx); } } -struct Point { mut x: int, mut y: int } +struct Point { x: int, y: int } impl Positioned for Point { - fn SetX(&self, x: int) { + fn SetX(&mut self, x: int) { self.x = x; } fn X(&self) -> int { @@ -34,7 +38,7 @@ impl Positioned for Point { impl Movable for Point; pub fn main() { - let p = Point{ x: 1, y: 2}; + let mut p = Point{ x: 1, y: 2}; p.translate(3); assert p.X() == 4; } diff --git a/src/test/run-pass/lambda-infer-unresolved.rs b/src/test/run-pass/lambda-infer-unresolved.rs index e6c2ff2814214..b68ec3755d5b3 100644 --- a/src/test/run-pass/lambda-infer-unresolved.rs +++ b/src/test/run-pass/lambda-infer-unresolved.rs @@ -12,10 +12,10 @@ // resolved when we finish typechecking the fn@. -struct Refs { mut refs: ~[int], n: int } +struct Refs { refs: ~[int], n: int } pub fn main() { - let e = @Refs{mut refs: ~[], n: 0}; + let e = @mut Refs{refs: ~[], n: 0}; let f = fn@ () { log(error, e.n); }; e.refs += ~[1]; } diff --git a/src/test/run-pass/log-linearized.rs b/src/test/run-pass/log-linearized.rs index 152dcb3d4a7a7..465e5b63d6bdc 100644 --- a/src/test/run-pass/log-linearized.rs +++ b/src/test/run-pass/log-linearized.rs @@ -15,17 +15,17 @@ enum option { some(T), } -struct Smallintmap {mut v: ~[option]} +struct Smallintmap {v: ~[option]} struct V { v: ~[option] } -fn mk() -> @Smallintmap { +fn mk() -> @mut Smallintmap { let mut v: ~[option] = ~[]; - return @Smallintmap {mut v: v}; + return @mut Smallintmap {v: v}; } fn f() { - let sim = mk::(); + let mut sim = mk::(); log(error, sim); } diff --git a/src/test/run-pass/mlist-cycle.rs b/src/test/run-pass/mlist-cycle.rs index 8e544c09216ac..e886c941a4b6a 100644 --- a/src/test/run-pass/mlist-cycle.rs +++ b/src/test/run-pass/mlist-cycle.rs @@ -12,14 +12,14 @@ // -*- rust -*- extern mod std; -type cell = {mut c: @list}; +type cell = {c: @list}; -enum list { link(@cell), nil, } +enum list { link(@mut cell), nil, } pub fn main() { - let first: @cell = @{mut c: @nil()}; - let second: @cell = @{mut c: @link(first)}; + let first: @cell = @mut {c: @nil()}; + let second: @cell = @mut {c: @link(first)}; first._0 = @link(second); sys.rustrt.gc(); - let third: @cell = @{mut c: @nil()}; + let third: @cell = @mut {c: @nil()}; } diff --git a/src/test/run-pass/nested-patterns.rs b/src/test/run-pass/nested-patterns.rs index 846136c242c36..10d76cdd9775e 100644 --- a/src/test/run-pass/nested-patterns.rs +++ b/src/test/run-pass/nested-patterns.rs @@ -11,17 +11,17 @@ struct A { a: int, b: @int } struct B { a: int, b: C } struct D { a: int, d: C } -struct C { mut c: int } +struct C { c: int } pub fn main() { match A {a: 10, b: @20} { x@A {a, b: @20} => { assert x.a == 10; assert a == 10; } A {b, _} => { fail!(); } } - let x@B {b, _} = B {a: 10, b: C {mut c: 20}}; + let mut x@B {b, _} = B {a: 10, b: C {c: 20}}; x.b.c = 30; assert b.c == 20; - let y@D {d, _} = D {a: 10, d: C {mut c: 20}}; + let mut y@D {d, _} = D {a: 10, d: C {c: 20}}; y.d.c = 30; assert d.c == 20; } diff --git a/src/test/run-pass/reflect-visit-data.rs b/src/test/run-pass/reflect-visit-data.rs index b25a95cbb8a56..27afde631b2ab 100644 --- a/src/test/run-pass/reflect-visit-data.rs +++ b/src/test/run-pass/reflect-visit-data.rs @@ -470,12 +470,12 @@ impl TyVisitor for ptr_visit_adaptor { } } -enum my_visitor = @Stuff; +enum my_visitor = @mut Stuff; struct Stuff { - mut ptr1: *c_void, - mut ptr2: *c_void, - mut vals: ~[~str] + ptr1: *c_void, + ptr2: *c_void, + vals: ~[~str] } impl my_visitor { @@ -637,10 +637,9 @@ pub fn main() { unsafe { let r = (1,2,3,true,false, Triple {x:5,y:4,z:3}, (12,)); let p = ptr::addr_of(&r) as *c_void; - let u = my_visitor(@Stuff {mut ptr1: p, - mut ptr2: p, - mut vals: ~[] - }); + let u = my_visitor(@mut Stuff {ptr1: p, + ptr2: p, + vals: ~[]}); let v = ptr_visit_adaptor(Inner {inner: u}); let td = get_tydesc_for(r); unsafe { error!("tydesc sz: %u, align: %u", diff --git a/src/test/run-pass/reflect-visit-type.rs b/src/test/run-pass/reflect-visit-type.rs index 6b57c73d0f276..672e87e4f443d 100644 --- a/src/test/run-pass/reflect-visit-type.rs +++ b/src/test/run-pass/reflect-visit-type.rs @@ -10,7 +10,7 @@ // xfail-test use intrinsic::{TyDesc, get_tydesc, visit_tydesc, TyVisitor}; -enum my_visitor = @{ mut types: ~[str] }; +enum my_visitor = @mut { types: ~[str] }; impl TyVisitor for my_visitor { fn visit_bot() -> bool { @@ -141,7 +141,7 @@ fn visit_ty(v: TyVisitor) { } pub fn main() { - let v = my_visitor(@{mut types: ~[]}); + let v = my_visitor(@mut {types: ~[]}); let vv = v as TyVisitor; visit_ty::(vv); diff --git a/src/test/run-pass/resource-cycle.rs b/src/test/run-pass/resource-cycle.rs index d47d56b6021b3..f5a959b2dbcab 100644 --- a/src/test/run-pass/resource-cycle.rs +++ b/src/test/run-pass/resource-cycle.rs @@ -37,7 +37,7 @@ fn r(v: *int) -> r { enum t = Node; struct Node { - mut next: Option<@t>, + next: Option<@mut t>, r: r } @@ -50,8 +50,8 @@ pub fn main() { let i2p = cast::reinterpret_cast(&i2); cast::forget(i2); - let x1 = @t(Node{ - mut next: None, + let mut x1 = @mut t(Node{ + next: None, r: { let rs = r(i1p); debug!("r = %x", @@ -60,11 +60,11 @@ pub fn main() { }); debug!("x1 = %x, x1.r = %x", - cast::reinterpret_cast::<@t, uint>(&x1), + cast::reinterpret_cast::<@mut t, uint>(&x1), cast::reinterpret_cast::<*r, uint>(&ptr::addr_of(&(x1.r)))); - let x2 = @t(Node{ - mut next: None, + let mut x2 = @mut t(Node{ + next: None, r: { let rs = r(i2p); debug!("r2 = %x", @@ -74,7 +74,7 @@ pub fn main() { }); debug!("x2 = %x, x2.r = %x", - cast::reinterpret_cast::<@t, uint>(&x2), + cast::reinterpret_cast::<@mut t, uint>(&x2), cast::reinterpret_cast::<*r, uint>(&ptr::addr_of(&(x2.r)))); x1.next = Some(x2); diff --git a/src/test/run-pass/resource-cycle2.rs b/src/test/run-pass/resource-cycle2.rs index 1b39093c7d05c..cf5f36916a041 100644 --- a/src/test/run-pass/resource-cycle2.rs +++ b/src/test/run-pass/resource-cycle2.rs @@ -37,7 +37,7 @@ fn r(v: U) -> r { enum t = Node; struct Node { - mut next: Option<@t>, + next: Option<@mut t>, r: r } @@ -53,12 +53,12 @@ pub fn main() { let u1 = U {a: 0xB, b: 0xC, c: i1p}; let u2 = U {a: 0xB, b: 0xC, c: i2p}; - let x1 = @t(Node { - mut next: None, + let x1 = @mut t(Node { + next: None, r: r(u1) }); - let x2 = @t(Node { - mut next: None, + let x2 = @mut t(Node { + next: None, r: r(u2) }); x1.next = Some(x2); diff --git a/src/test/run-pass/resource-cycle3.rs b/src/test/run-pass/resource-cycle3.rs index 036ca2496698c..4cd3df0f87f90 100644 --- a/src/test/run-pass/resource-cycle3.rs +++ b/src/test/run-pass/resource-cycle3.rs @@ -46,7 +46,7 @@ fn r(v: U, w: int, _x: *int) -> R { enum t = Node; struct Node { - mut next: Option<@t>, + next: Option<@mut t>, r: R } @@ -62,12 +62,12 @@ pub fn main() { let u1 = U {a: 0xB, b: 0xC, c: i1p}; let u2 = U {a: 0xB, b: 0xC, c: i2p}; - let x1 = @t(Node{ - mut next: None, + let x1 = @mut t(Node{ + next: None, r: r(u1, 42, i1p) }); - let x2 = @t(Node{ - mut next: None, + let x2 = @mut t(Node{ + next: None, r: r(u2, 42, i2p) }); x1.next = Some(x2); diff --git a/src/test/run-pass/trait-cast.rs b/src/test/run-pass/trait-cast.rs index e0e3c6e15975c..fb3756320f5c4 100644 --- a/src/test/run-pass/trait-cast.rs +++ b/src/test/run-pass/trait-cast.rs @@ -1,3 +1,6 @@ +// xfail-test +// Weird borrow check bug + // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. @@ -10,20 +13,20 @@ // Test cyclic detector when using trait instances. -enum Tree = @TreeR; +enum Tree = @mut TreeR; struct TreeR { - mut left: Option, - mut right: Option, + left: Option, + right: Option, val: to_str } trait to_str { - fn to_str() -> ~str; + fn to_str(&self) -> ~str; } impl to_str for Option { - fn to_str() -> ~str { - match self { + fn to_str(&self) -> ~str { + match *self { None => { ~"none" } Some(ref t) => { ~"some(" + t.to_str() + ~")" } } @@ -31,26 +34,26 @@ impl to_str for Option { } impl to_str for int { - fn to_str() -> ~str { int::str(self) } + fn to_str(&self) -> ~str { int::str(*self) } } impl to_str for Tree { - fn to_str() -> ~str { + fn to_str(&self) -> ~str { let l = self.left, r = self.right; - fmt!("[%s, %s, %s]", self.val.to_str(), - l.to_str(), r.to_str()) + let val = &self.val; + fmt!("[%s, %s, %s]", val.to_str(), l.to_str(), r.to_str()) } } fn foo(x: T) -> ~str { x.to_str() } pub fn main() { - let t1 = Tree(@TreeR{mut left: None, - mut right: None, - val: 1 as to_str }); - let t2 = Tree(@TreeR{mut left: Some(t1), - mut right: Some(t1), - val: 2 as to_str }); + let t1 = Tree(@mut TreeR{left: None, + right: None, + val: 1 as to_str }); + let t2 = Tree(@mut TreeR{left: Some(t1), + right: Some(t1), + val: 2 as to_str }); let expected = ~"[2, some([1, none, none]), some([1, none, none])]"; assert t2.to_str() == expected; assert foo(t2 as to_str) == expected; diff --git a/src/test/run-pass/writealias.rs b/src/test/run-pass/writealias.rs index 2aa3bc30d07b8..c9c5ce0c928fd 100644 --- a/src/test/run-pass/writealias.rs +++ b/src/test/run-pass/writealias.rs @@ -12,12 +12,12 @@ // -*- rust -*- -struct Point {x: int, y: int, mut z: int} +struct Point {x: int, y: int, z: int} fn f(p: &mut Point) { p.z = 13; } pub fn main() { - let mut x: Point = Point {x: 10, y: 11, mut z: 12}; + let mut x: Point = Point {x: 10, y: 11, z: 12}; f(&mut x); assert (x.z == 13); }