mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

syntax: Removing some bad copies

Browse Source
This commit is contained in:
Alex Crichton 2013-03-19 21:24:01 -04:00
parent 251d0c4557
commit cd7f3ad22e
4 changed files with 69 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/libsyntax/ext/fmt.rs
View File

@ -65,7 +65,7 @@ fn pieces_to_expr(cx: @ext_ctxt, sp: span,
// Produces an AST expression that represents a RT::conv record,
// which tells the RT::conv* functions how to perform the conversion
fn make_rt_conv_expr(cx: @ext_ctxt, sp: span, cnv: Conv) -> @ast::expr {
fn make_rt_conv_expr(cx: @ext_ctxt, sp: span, cnv: &Conv) -> @ast::expr {
fn make_flags(cx: @ext_ctxt, sp: span, flags: ~[Flag]) -> @ast::expr {
let mut tmp_expr = make_rt_path_expr(cx, sp, @~"flag_none");
for flags.each |f| {
@ -139,7 +139,7 @@ fn pieces_to_expr(cx: @ext_ctxt, sp: span,
make_conv_struct(cx, sp, rt_conv_flags, rt_conv_width,
rt_conv_precision, rt_conv_ty)
}
fn make_conv_call(cx: @ext_ctxt, sp: span, conv_type: ~str, cnv: Conv,
fn make_conv_call(cx: @ext_ctxt, sp: span, conv_type: ~str, cnv: &Conv,
arg: @ast::expr) -> @ast::expr {
let fname = ~"conv_" + conv_type;
let path = make_path_vec(cx, @fname);
@ -148,11 +148,11 @@ fn pieces_to_expr(cx: @ext_ctxt, sp: span,
return mk_call_global(cx, arg.span, path, args);
}
fn make_new_conv(cx: @ext_ctxt, sp: span, cnv: Conv, arg: @ast::expr) ->
fn make_new_conv(cx: @ext_ctxt, sp: span, cnv: &Conv, arg: @ast::expr) ->
@ast::expr {
// FIXME: Move validation code into core::extfmt (Issue #2249)
fn is_signed_type(cnv: Conv) -> bool {
fn is_signed_type(cnv: &Conv) -> bool {
match cnv.ty {
TyInt(s) => match s {
Signed => return true,
@ -220,7 +220,7 @@ fn pieces_to_expr(cx: @ext_ctxt, sp: span,
mk_addr_of(cx, sp, arg))
}
}
fn log_conv(c: Conv) {
fn log_conv(c: &Conv) {
match c.param {
Some(p) => { debug!("param: %s", p.to_str()); }
_ => debug!("param: none")
@ -285,12 +285,12 @@ fn pieces_to_expr(cx: @ext_ctxt, sp: span,
~"for the given format string");
}
debug!("Building conversion:");
log_conv(/*bad*/ copy *conv);
log_conv(conv);
let arg_expr = args[n];
let c_expr = make_new_conv(
cx,
fmt_sp,
/*bad*/ copy *conv,
conv,
arg_expr
);
piece_exprs.push(c_expr);

4
src/libsyntax/parse/comments.rs
View File

@ -220,7 +220,7 @@ fn trim_whitespace_prefix_and_push_line(lines: &mut ~[~str],
if col < len {
s1 = str::slice(s, col, len);
} else { s1 = ~""; }
} else { s1 = /*bad*/ copy s; }
} else { s1 = s; }
debug!("pushing line: %s", s1);
lines.push(s1);
}
@ -357,8 +357,8 @@ pub fn gather_comments_and_literals(span_diagnostic:
let TokenAndSpan {tok: tok, sp: sp} = rdr.peek();
if token::is_lit(&tok) {
let s = get_str_from(rdr, bstart);
literals.push(lit {lit: /*bad*/ copy s, pos: sp.lo});
debug!("tok lit: %s", s);
literals.push(lit {lit: s, pos: sp.lo});
} else {
debug!("tok: %s", token::to_str(rdr.interner, &tok));
}

13
src/libsyntax/parse/parser.rs
View File

@ -1438,7 +1438,7 @@ pub impl Parser {
let (s, z) = p.parse_sep_and_zerok();
tt_seq(
mk_sp(sp.lo ,p.span.hi),
/*bad*/ copy seq.node,
seq.node,
s,
z
)
@ -1855,7 +1855,7 @@ pub impl Parser {
// Turn on the restriction to stop at | or || so we can parse
// them as the lambda arguments
let e = self.parse_expr_res(RESTRICT_NO_BAR_OR_DOUBLEBAR_OP);
match /*bad*/ copy e.node {
match e.node {
expr_call(f, args, NoSugar) => {
let block = self.parse_lambda_block_expr();
let last_arg = self.mk_expr(block.span.lo, block.span.hi,
@ -2129,7 +2129,7 @@ pub impl Parser {
let lo = self.span.lo;
let mut hi = self.span.hi;
let mut pat;
match copy *self.token {
match *self.token {
token::UNDERSCORE => { self.bump(); pat = pat_wild; }
token::AT => {
self.bump();
@ -2237,7 +2237,7 @@ pub impl Parser {
self.expect(&token::RBRACKET);
pat = ast::pat_vec(before, slice, after);
}
copy tok => {
tok => {
if !is_ident_or_path(&tok)
|| self.is_keyword(&~"true")
|| self.is_keyword(&~"false")
@ -3341,6 +3341,7 @@ pub impl Parser {
VIEW_ITEMS_AND_ITEMS_ALLOWED,
true);
let mut items: ~[@item] = starting_items;
let attrs_remaining_len = attrs_remaining.len();
// looks like this code depends on the invariant that
// outer attributes can't occur on view items (or macros
@ -3349,7 +3350,7 @@ pub impl Parser {
while *self.token != term {
let mut attrs = self.parse_outer_attributes();
if first {
attrs = vec::append(/*bad*/ copy attrs_remaining, attrs);
attrs = attrs_remaining + attrs;
first = false;
}
debug!("parse_mod_items: parse_item_or_view_item(attrs=%?)",
@ -3378,7 +3379,7 @@ pub impl Parser {
debug!("parse_mod_items: attrs=%?", attrs);
}
if first && attrs_remaining.len() > 0u {
if first && attrs_remaining_len > 0u {
// We parsed attributes for the first item but didn't find it
self.fatal(~"expected item");
}

106
src/libsyntax/print/pprust.rs
View File

@ -134,7 +134,7 @@ pub fn print_crate(cm: @CodeMap,
}
pub fn print_crate_(s: @ps, &&crate: @ast::crate) {
print_mod(s, crate.node.module, crate.node.attrs);
print_mod(s, &crate.node.module, crate.node.attrs);
print_remaining_comments(s);
eof(s.s);
}
@ -310,7 +310,7 @@ pub fn synth_comment(s: @ps, text: ~str) {
word(s.s, ~"*/");
}
pub fn commasep<IN>(s: @ps, b: breaks, elts: ~[IN], op: &fn(@ps, IN)) {
pub fn commasep<IN>(s: @ps, b: breaks, elts: &[IN], op: &fn(@ps, IN)) {
box(s, 0u, b);
let mut first = true;
for elts.each |elt| {
@ -321,7 +321,7 @@ pub fn commasep<IN>(s: @ps, b: breaks, elts: ~[IN], op: &fn(@ps, IN)) {
}
pub fn commasep_cmnt<IN>(s: @ps, b: breaks, elts: ~[IN], op: &fn(@ps, IN),
pub fn commasep_cmnt<IN>(s: @ps, b: breaks, elts: &[IN], op: &fn(@ps, IN),
get_span: &fn(IN) -> codemap::span) {
box(s, 0u, b);
let len = vec::len::<IN>(elts);
@ -340,12 +340,12 @@ pub fn commasep_cmnt<IN>(s: @ps, b: breaks, elts: ~[IN], op: &fn(@ps, IN),
end(s);
}
pub fn commasep_exprs(s: @ps, b: breaks, exprs: ~[@ast::expr]) {
pub fn commasep_exprs(s: @ps, b: breaks, exprs: &[@ast::expr]) {
fn expr_span(&&expr: @ast::expr) -> codemap::span { return expr.span; }
commasep_cmnt(s, b, exprs, print_expr, expr_span);
}
pub fn print_mod(s: @ps, _mod: ast::_mod, attrs: ~[ast::attribute]) {
pub fn print_mod(s: @ps, _mod: &ast::_mod, attrs: ~[ast::attribute]) {
print_inner_attributes(s, attrs);
for _mod.view_items.each |vitem| {
print_view_item(s, *vitem);
@ -353,7 +353,7 @@ pub fn print_mod(s: @ps, _mod: ast::_mod, attrs: ~[ast::attribute]) {
for _mod.items.each |item| { print_item(s, *item); }
}
pub fn print_foreign_mod(s: @ps, nmod: ast::foreign_mod,
pub fn print_foreign_mod(s: @ps, nmod: &ast::foreign_mod,
attrs: ~[ast::attribute]) {
print_inner_attributes(s, attrs);
for nmod.view_items.each |vitem| {
@ -376,12 +376,12 @@ pub fn print_type(s: @ps, &&ty: @ast::Ty) {
pub fn print_type_ex(s: @ps, &&ty: @ast::Ty, print_colons: bool) {
maybe_print_comment(s, ty.span.lo);
ibox(s, 0u);
match /*bad*/ copy ty.node {
match ty.node {
ast::ty_nil => word(s.s, ~"()"),
ast::ty_bot => word(s.s, ~"!"),
ast::ty_box(mt) => { word(s.s, ~"@"); print_mt(s, mt); }
ast::ty_uniq(mt) => { word(s.s, ~"~"); print_mt(s, mt); }
ast::ty_vec(mt) => {
ast::ty_box(ref mt) => { word(s.s, ~"@"); print_mt(s, mt); }
ast::ty_uniq(ref mt) => { word(s.s, ~"~"); print_mt(s, mt); }
ast::ty_vec(ref mt) => {
word(s.s, ~"[");
match mt.mutbl {
ast::m_mutbl => word_space(s, ~"mut"),
@ -391,15 +391,15 @@ pub fn print_type_ex(s: @ps, &&ty: @ast::Ty, print_colons: bool) {
print_type(s, mt.ty);
word(s.s, ~"]");
}
ast::ty_ptr(mt) => { word(s.s, ~"*"); print_mt(s, mt); }
ast::ty_rptr(lifetime, mt) => {
ast::ty_ptr(ref mt) => { word(s.s, ~"*"); print_mt(s, mt); }
ast::ty_rptr(lifetime, ref mt) => {
word(s.s, ~"&");
print_opt_lifetime(s, lifetime);
print_mt(s, mt);
}
ast::ty_tup(elts) => {
ast::ty_tup(ref elts) => {
popen(s);
commasep(s, inconsistent, elts, print_type);
commasep(s, inconsistent, *elts, print_type);
if elts.len() == 1 {
word(s.s, ~",");
}
@ -416,7 +416,7 @@ pub fn print_type_ex(s: @ps, &&ty: @ast::Ty, print_colons: bool) {
None, None);
}
ast::ty_path(path, _) => print_path(s, path, print_colons),
ast::ty_fixed_length_vec(mt, v) => {
ast::ty_fixed_length_vec(ref mt, v) => {
word(s.s, ~"[");
match mt.mutbl {
ast::m_mutbl => word_space(s, ~"mut"),
@ -443,7 +443,7 @@ pub fn print_foreign_item(s: @ps, item: @ast::foreign_item) {
hardbreak_if_not_bol(s);
maybe_print_comment(s, item.span.lo);
print_outer_attributes(s, item.attrs);
match /*bad*/ copy item.node {
match item.node {
ast::foreign_item_fn(ref decl, purity, ref generics) => {
print_fn(s, decl, Some(purity), item.ident, generics, None,
ast::inherited);
@ -469,7 +469,7 @@ pub fn print_item(s: @ps, &&item: @ast::item) {
print_outer_attributes(s, item.attrs);
let ann_node = node_item(s, item);
(s.ann.pre)(ann_node);
match /*bad*/ copy item.node {
match item.node {
ast::item_const(ty, expr) => {
head(s, visibility_qualified(item.vis, ~"const"));
print_ident(s, item.ident);
@ -497,7 +497,7 @@ pub fn print_item(s: @ps, &&item: @ast::item) {
word(s.s, ~" ");
print_block_with_attrs(s, body, item.attrs);
}
ast::item_mod(_mod) => {
ast::item_mod(ref _mod) => {
head(s, visibility_qualified(item.vis, ~"mod"));
print_ident(s, item.ident);
nbsp(s);
@ -505,7 +505,7 @@ pub fn print_item(s: @ps, &&item: @ast::item) {
print_mod(s, _mod, item.attrs);
bclose(s, item.span);
}
ast::item_foreign_mod(nmod) => {
ast::item_foreign_mod(ref nmod) => {
head(s, visibility_qualified(item.vis, ~"extern"));
print_string(s, *s.intr.get(nmod.abi));
nbsp(s);
@ -767,15 +767,15 @@ pub fn print_tts(s: @ps, &&tts: &[ast::token_tree]) {
pub fn print_variant(s: @ps, v: ast::variant) {
print_visibility(s, v.node.vis);
match /*bad*/ copy v.node.kind {
ast::tuple_variant_kind(args) => {
match v.node.kind {
ast::tuple_variant_kind(ref args) => {
print_ident(s, v.node.name);
if !args.is_empty() {
popen(s);
fn print_variant_arg(s: @ps, arg: ast::variant_arg) {
print_type(s, arg.ty);
}
commasep(s, consistent, args, print_variant_arg);
commasep(s, consistent, *args, print_variant_arg);
pclose(s);
}
}
@ -1103,7 +1103,7 @@ pub fn print_expr(s: @ps, &&expr: @ast::expr) {
ibox(s, indent_unit);
let ann_node = node_expr(s, expr);
(s.ann.pre)(ann_node);
match /*bad*/ copy expr.node {
match expr.node {
ast::expr_vstore(e, v) => match v {
ast::expr_vstore_fixed(_) => {
print_expr(s, e);
@ -1115,14 +1115,14 @@ pub fn print_expr(s: @ps, &&expr: @ast::expr) {
print_expr(s, e);
}
},
ast::expr_vec(exprs, mutbl) => {
ast::expr_vec(ref exprs, mutbl) => {
ibox(s, indent_unit);
word(s.s, ~"[");
if mutbl == ast::m_mutbl {
word(s.s, ~"mut");
if vec::len(exprs) > 0u { nbsp(s); }
if exprs.len() > 0u { nbsp(s); }
}
commasep_exprs(s, inconsistent, exprs);
commasep_exprs(s, inconsistent, *exprs);
word(s.s, ~"]");
end(s);
}
@ -1159,29 +1159,29 @@ pub fn print_expr(s: @ps, &&expr: @ast::expr) {
}
word(s.s, ~"}");
}
ast::expr_tup(exprs) => {
ast::expr_tup(ref exprs) => {
popen(s);
commasep_exprs(s, inconsistent, exprs);
commasep_exprs(s, inconsistent, *exprs);
if exprs.len() == 1 {
word(s.s, ~",");
}
pclose(s);
}
ast::expr_call(func, args, sugar) => {
let mut base_args = copy args;
ast::expr_call(func, ref args, sugar) => {
let mut base_args = copy *args;
let blk = print_call_pre(s, sugar, &mut base_args);
print_expr(s, func);
print_call_post(s, sugar, &blk, &mut base_args);
}
ast::expr_method_call(func, ident, tys, args, sugar) => {
let mut base_args = copy args;
ast::expr_method_call(func, ident, ref tys, ref args, sugar) => {
let mut base_args = copy *args;
let blk = print_call_pre(s, sugar, &mut base_args);
print_expr(s, func);
word(s.s, ~".");
print_ident(s, ident);
if vec::len(tys) > 0u {
if tys.len() > 0u {
word(s.s, ~"::<");
commasep(s, inconsistent, tys, print_type);
commasep(s, inconsistent, *tys, print_type);
word(s.s, ~">");
}
print_call_post(s, sugar, &blk, &mut base_args);
@ -1356,13 +1356,13 @@ pub fn print_expr(s: @ps, &&expr: @ast::expr) {
word_space(s, ~"=");
print_expr(s, rhs);
}
ast::expr_field(expr, id, tys) => {
ast::expr_field(expr, id, ref tys) => {
print_expr(s, expr);
word(s.s, ~".");
print_ident(s, id);
if vec::len(tys) > 0u {
if tys.len() > 0u {
word(s.s, ~"::<");
commasep(s, inconsistent, tys, print_type);
commasep(s, inconsistent, *tys, print_type);
word(s.s, ~">");
}
}
@ -1454,15 +1454,15 @@ pub fn print_local_decl(s: @ps, loc: @ast::local) {
pub fn print_decl(s: @ps, decl: @ast::decl) {
maybe_print_comment(s, decl.span.lo);
match /*bad*/ copy decl.node {
ast::decl_local(locs) => {
match decl.node {
ast::decl_local(ref locs) => {
space_if_not_bol(s);
ibox(s, indent_unit);
word_nbsp(s, ~"let");
// if any are mut, all are mut
if vec::any(locs, |l| l.node.is_mutbl) {
fail_unless!(vec::all(locs, |l| l.node.is_mutbl));
if locs.any(|l| l.node.is_mutbl) {
fail_unless!(locs.all(|l| l.node.is_mutbl));
word_nbsp(s, ~"mut");
}
@ -1479,7 +1479,7 @@ pub fn print_decl(s: @ps, decl: @ast::decl) {
_ => ()
}
}
commasep(s, consistent, locs, print_local);
commasep(s, consistent, *locs, print_local);
end(s);
}
ast::decl_item(item) => print_item(s, item)
@ -1539,7 +1539,7 @@ pub fn print_pat(s: @ps, &&pat: @ast::pat, refutable: bool) {
(s.ann.pre)(ann_node);
/* Pat isn't normalized, but the beauty of it
is that it doesn't matter */
match /*bad*/ copy pat.node {
match pat.node {
ast::pat_wild => word(s.s, ~"_"),
ast::pat_ident(binding_mode, path, sub) => {
if refutable {
@ -1563,14 +1563,14 @@ pub fn print_pat(s: @ps, &&pat: @ast::pat, refutable: bool) {
None => ()
}
}
ast::pat_enum(path, args_) => {
ast::pat_enum(path, ref args_) => {
print_path(s, path, true);
match args_ {
match *args_ {
None => word(s.s, ~"(*)"),
Some(args) => {
Some(ref args) => {
if !args.is_empty() {
popen(s);
commasep(s, inconsistent, args,
commasep(s, inconsistent, *args,
|s, p| print_pat(s, p, refutable));
pclose(s);
} else { }
@ -1851,7 +1851,7 @@ pub fn print_view_path(s: @ps, &&vp: @ast::view_path) {
}
}
pub fn print_view_paths(s: @ps, vps: ~[@ast::view_path]) {
pub fn print_view_paths(s: @ps, vps: &[@ast::view_path]) {
commasep(s, inconsistent, vps, print_view_path);
}
@ -1860,7 +1860,7 @@ pub fn print_view_item(s: @ps, item: @ast::view_item) {
maybe_print_comment(s, item.span.lo);
print_outer_attributes(s, item.attrs);
print_visibility(s, item.vis);
match /*bad*/ copy item.node {
match item.node {
ast::view_item_extern_mod(id, mta, _) => {
head(s, ~"extern mod");
print_ident(s, id);
@ -1871,9 +1871,9 @@ pub fn print_view_item(s: @ps, item: @ast::view_item) {
}
}
ast::view_item_use(vps) => {
ast::view_item_use(ref vps) => {
head(s, ~"use");
print_view_paths(s, vps);
print_view_paths(s, *vps);
}
}
word(s.s, ~";");
@ -1889,7 +1889,7 @@ pub fn print_mutability(s: @ps, mutbl: ast::mutability) {
}
}
pub fn print_mt(s: @ps, mt: ast::mt) {
pub fn print_mt(s: @ps, mt: &ast::mt) {
print_mutability(s, mt.mutbl);
print_type(s, mt.ty);
}
@ -1942,7 +1942,7 @@ pub fn print_ty_fn(s: @ps,
print_onceness(s, onceness);
word(s.s, ~"fn");
match id { Some(id) => { word(s.s, ~" "); print_ident(s, id); } _ => () }
match /*bad*/ copy generics { Some(g) => print_generics(s, g), _ => () }
match generics { Some(g) => print_generics(s, g), _ => () }
zerobreak(s.s);
popen(s);