bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Replace more vector + (issue #2719)

Browse source
This commit is contained in:
Eric Holk 2012-06-27 23:09:51 -07:00
parent 0b84437b68
commit ae06546bbf
10 changed files with 82 additions and 65 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/libcore/vec.rs
View file

@ -1888,7 +1888,7 @@ mod tests {
let mut results: [[int]/~]/~;
results = []/~;
permute([]/~) {|v| results += [v]/~; }
permute([]/~) {|v| vec::push(results, v); }
assert results == [[]/~]/~;
results = []/~;

4
src/libsyntax/attr.rs
View file

@ -77,7 +77,7 @@ fn attr_meta(attr: ast::attribute) -> @ast::meta_item { @attr.node.value }
// Get the meta_items from inside a vector of attributes
fn attr_metas(attrs: [ast::attribute]/~) -> [@ast::meta_item]/~ {
let mut mitems = []/~;
for attrs.each {|a| mitems += [attr_meta(a)]/~; }
for attrs.each {|a| vec::push(mitems, attr_meta(a)); }
ret mitems;
}
@ -303,7 +303,7 @@ fn find_linkage_attrs(attrs: [ast::attribute]/~) -> [ast::attribute]/~ {
let mut found = []/~;
for find_attrs_by_name(attrs, "link").each {|attr|
alt attr.node.value.node {
ast::meta_list(_, _) { found += [attr]/~ }
ast::meta_list(_, _) { vec::push(found, attr) }
_ { #debug("ignoring link attribute that has incorrect type"); }
}
}

56
src/libsyntax/ext/auto_serialize.rs
View file

@ -103,12 +103,14 @@ fn expand(cx: ext_ctxt,
vec::flat_map(in_items) {|in_item|
alt in_item.node {
ast::item_ty(ty, tps, _) {
[filter_attrs(in_item)]/~ + ty_fns(cx, in_item.ident, ty, tps)
vec::append([filter_attrs(in_item)]/~,
ty_fns(cx, in_item.ident, ty, tps))
}
ast::item_enum(variants, tps, _) {
[filter_attrs(in_item)]/~ + enum_fns(cx, in_item.ident,
in_item.span, variants, tps)
vec::append([filter_attrs(in_item)]/~,
enum_fns(cx, in_item.ident,
in_item.span, variants, tps))
}
_ {
@ -126,7 +128,8 @@ impl helpers for ext_ctxt {
helper_name: str) -> @ast::path {
let head = vec::init(base_path.idents);
let tail = vec::last(base_path.idents);
self.path(base_path.span, head + [@(helper_name + "_" + *tail)]/~)
self.path(base_path.span,
vec::append(head, [@(helper_name + "_" + *tail)]/~))
}
fn path(span: span, strs: [ast::ident]/~) -> @ast::path {
@ -301,7 +304,7 @@ fn ser_path(cx: ext_ctxt, tps: ser_tps_map, path: @ast::path,
[cx.stmt(
cx.expr(
path.span,
ast::expr_call(callee, [s, v]/~ + ty_args, false)))]/~
ast::expr_call(callee, vec::append([s, v]/~, ty_args), false)))]/~
}
fn ser_variant(cx: ext_ctxt,
@ -502,15 +505,15 @@ fn mk_ser_fn(cx: ext_ctxt, span: span, name: ast::ident,
let ser_inputs: [ast::arg]/~ =
[{mode: ast::expl(ast::by_ref),
ty: cx.ty_path(span, [@"__S"]/~, []/~),
ident: @"__s",
id: cx.next_id()},
{mode: ast::expl(ast::by_ref),
ty: v_ty,
ident: @"__v",
id: cx.next_id()}]/~
+ tp_inputs;
vec::append([{mode: ast::expl(ast::by_ref),
ty: cx.ty_path(span, [@"__S"]/~, []/~),
ident: @"__s",
id: cx.next_id()},
{mode: ast::expl(ast::by_ref),
ty: v_ty,
ident: @"__v",
id: cx.next_id()}]/~,
tp_inputs);
let tps_map = map::str_hash();
vec::iter2(tps, tp_inputs) {|tp, arg|
@ -531,10 +534,10 @@ fn mk_ser_fn(cx: ext_ctxt, span: span, name: ast::ident,
[]/~))]/~;
let ser_tps: [ast::ty_param]/~ =
[{ident: @"__S",
id: cx.next_id(),
bounds: ser_bnds}]/~ +
vec::map(tps) {|tp| cx.clone_ty_param(tp) };
vec::append([{ident: @"__S",
id: cx.next_id(),
bounds: ser_bnds}]/~,
vec::map(tps) {|tp| cx.clone_ty_param(tp) });
let ser_output: @ast::ty = @{id: cx.next_id(),
node: ast::ty_nil,
@ -575,7 +578,8 @@ fn deser_path(cx: ext_ctxt, tps: deser_tps_map, path: @ast::path,
cx.lambda(cx.expr_blk(dv_expr))
};
cx.expr(path.span, ast::expr_call(callee, [d]/~ + ty_args, false))
cx.expr(path.span, ast::expr_call(callee, vec::append([d]/~, ty_args),
false))
}
fn deser_lambda(cx: ext_ctxt, tps: deser_tps_map, ty: @ast::ty,
@ -712,11 +716,11 @@ fn mk_deser_fn(cx: ext_ctxt, span: span,
#debug["tp_inputs = %?", tp_inputs];
let deser_inputs: [ast::arg]/~ =
[{mode: ast::expl(ast::by_ref),
ty: cx.ty_path(span, [@"__D"]/~, []/~),
ident: @"__d",
id: cx.next_id()}]/~
+ tp_inputs;
vec::append([{mode: ast::expl(ast::by_ref),
ty: cx.ty_path(span, [@"__D"]/~, []/~),
ident: @"__d",
id: cx.next_id()}]/~,
tp_inputs);
let tps_map = map::str_hash();
vec::iter2(tps, tp_inputs) {|tp, arg|
@ -740,7 +744,9 @@ fn mk_deser_fn(cx: ext_ctxt, span: span,
id: cx.next_id(),
bounds: deser_bnds}]/~ + vec::map(tps) {|tp|
let cloned = cx.clone_ty_param(tp);
{bounds: @(*cloned.bounds + [ast::bound_copy]/~) with cloned}
{bounds: @(vec::append(*cloned.bounds,
[ast::bound_copy]/~))
with cloned}
};
let deser_blk = cx.expr_blk(f(cx, tps_map, #ast(expr){__d}));

2
src/libsyntax/ext/build.rs
View file

@ -82,7 +82,7 @@ fn mk_rec_e(cx: ext_ctxt, sp: span,
let val = field.ex;
let astfield =
{node: {mutbl: ast::m_imm, ident: ident, expr: val}, span: sp};
astfields += [astfield]/~;
vec::push(astfields, astfield);
}
let recexpr = ast::expr_rec(astfields, option::none::<@ast::expr>);
ret @{id: cx.next_id(), node: recexpr, span: sp};

2
src/libsyntax/ext/fmt.rs
View file

@ -60,7 +60,7 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
flag_sign_always { fstr = "flag_sign_always"; }
flag_alternate { fstr = "flag_alternate"; }
}
flagexprs += [make_rt_path_expr(cx, sp, @fstr)]/~;
vec::push(flagexprs, make_rt_path_expr(cx, sp, @fstr));
}
ret mk_uniq_vec_e(cx, sp, flagexprs);
}

14
src/libsyntax/ext/simplext.rs
View file

@ -104,7 +104,7 @@ fn option_flatten_map<T: copy, U: copy>(f: fn@(T) -> option<U>, v: [T]/~) ->
option<[U]/~> {
let mut res = []/~;
for v.each {|elem|
alt f(elem) { none { ret none; } some(fv) { res += [fv]/~; } }
alt f(elem) { none { ret none; } some(fv) { vec::push(res, fv); } }
}
ret some(res);
}
@ -309,8 +309,8 @@ fn transcribe_exprs(cx: ext_ctxt, b: bindings, idx_path: @mut [uint]/~,
/* Whew, we now know how how many times to repeat */
let mut idx: uint = 0u;
while idx < rc {
*idx_path += [idx]/~;
res += [recur(repeat_me)]/~; // whew!
vec::push(*idx_path, idx);
vec::push(res, recur(repeat_me)); // whew!
vec::pop(*idx_path);
idx += 1u;
}
@ -318,7 +318,7 @@ fn transcribe_exprs(cx: ext_ctxt, b: bindings, idx_path: @mut [uint]/~,
}
}
}
res += vec::map(post, recur);
res = vec::append(res, vec::map(post, recur));
ret res;
}
}
@ -718,9 +718,9 @@ fn add_new_extension(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
none { cx.span_fatal(mac.span,
"macro must have arguments")}
};
clauses +=
[@{params: pattern_to_selectors(cx, arg),
body: elts[1u]}]/~;
vec::push(clauses,
@{params: pattern_to_selectors(cx, arg),
body: elts[1u]});
// FIXME (#2251): check duplicates (or just simplify
// the macro arg situation)

2
src/libsyntax/parse.rs
View file

@ -84,7 +84,7 @@ fn parse_crate_from_crate_file(input: str, cfg: ast::crate_cfg,
ret @ast_util::respan(ast_util::mk_sp(lo, hi),
{directives: cdirs,
module: m,
attrs: crate_attrs + attrs,
attrs: vec::append(crate_attrs, attrs),
config: /* FIXME (#2543) */ copy p.cfg});
}

10
src/libsyntax/parse/attr.rs
View file

@ -21,8 +21,8 @@ impl parser_attr for parser {
self.bump();
let first_attr =
self.parse_attribute_naked(ast::attr_outer, lo);
ret some(left([first_attr]/~ +
self.parse_outer_attributes()));
ret some(left(vec::append([first_attr]/~,
self.parse_outer_attributes())));
} else if !(self.look_ahead(1u) == token::LT
|| self.look_ahead(1u) == token::LBRACKET
|| self.look_ahead(1u) == token::POUND
@ -38,7 +38,7 @@ impl parser_attr for parser {
let mut attrs: [ast::attribute]/~ = []/~;
while self.token == token::POUND
&& self.look_ahead(1u) == token::LBRACKET {
attrs += [self.parse_attribute(ast::attr_outer)]/~;
vec::push(attrs, self.parse_attribute(ast::attr_outer));
}
ret attrs;
}
@ -76,13 +76,13 @@ impl parser_attr for parser {
let attr = self.parse_attribute(ast::attr_inner);
if self.token == token::SEMI {
self.bump();
inner_attrs += [attr]/~;
vec::push(inner_attrs, attr);
} else {
// It's not really an inner attribute
let outer_attr =
spanned(attr.span.lo, attr.span.hi,
{style: ast::attr_outer, value: attr.node.value});
next_outer_attrs += [outer_attr]/~;
vec::push(next_outer_attrs, outer_attr);
break;
}
}

14
src/libsyntax/parse/eval.rs
View file

@ -28,8 +28,8 @@ fn eval_crate_directives_to_mod(cx: ctx, cdirs: [@ast::crate_directive]/~,
let mut view_items: [@ast::view_item]/~ = []/~;
let mut items: [@ast::item]/~ = []/~;
eval_crate_directives(cx, cdirs, prefix, view_items, items);
ret ({view_items: view_items + cview_items,
items: items + citems},
ret ({view_items: vec::append(view_items, cview_items),
items: vec::append(items, citems)},
cattrs);
}
@ -100,7 +100,7 @@ fn eval_crate_directive(cx: ctx, cdir: @ast::crate_directive, prefix: str,
let (p0, r0) =
new_parser_etc_from_file(cx.sess, cx.cfg, full_path, SOURCE_FILE);
let inner_attrs = p0.parse_inner_attrs_and_next();
let mod_attrs = attrs + inner_attrs.inner;
let mod_attrs = vec::append(attrs, inner_attrs.inner);
let first_item_outer_attrs = inner_attrs.next;
let m0 = p0.parse_mod_items(token::EOF, first_item_outer_attrs);
@ -110,7 +110,7 @@ fn eval_crate_directive(cx: ctx, cdir: @ast::crate_directive, prefix: str,
// Thread defids, chpos and byte_pos through the parsers
cx.sess.chpos = r0.chpos;
cx.sess.byte_pos = cx.sess.byte_pos + r0.pos;
items += [i]/~;
vec::push(items, i);
}
ast::cdir_dir_mod(id, cdirs, attrs) {
let path = cdir_path_opt(id, attrs);
@ -122,15 +122,15 @@ fn eval_crate_directive(cx: ctx, cdir: @ast::crate_directive, prefix: str,
cx, cdirs, full_path, none);
let i =
@{ident: /* FIXME (#2543) */ copy id,
attrs: attrs + a0,
attrs: vec::append(attrs, a0),
id: cx.sess.next_id,
node: ast::item_mod(m0),
vis: ast::public,
span: cdir.span};
cx.sess.next_id += 1;
items += [i]/~;
vec::push(items, i);
}
ast::cdir_view_item(vi) { view_items += [vi]/~; }
ast::cdir_view_item(vi) { vec::push(view_items, vi); }
ast::cdir_syntax(pth) { }
}
}

41
src/libsyntax/parse/parser.rs
View file

@ -1030,7 +1030,9 @@ class parser {
let blk = self.parse_fn_block_expr();
alt e.node {
expr_call(f, args, false) {
e = pexpr(@{node: expr_call(f, args + [blk]/~, true)
e = pexpr(@{node: expr_call(f,
vec::append(args, [blk]/~),
true)
with *self.to_expr(e)});
}
_ {
@ -1088,10 +1090,13 @@ class parser {
ret alt self.token {
token::LPAREN | token::LBRACE | token::LBRACKET {
let ket = flip(self.token);
tt_delim([parse_tt_flat(self, true)]/~ +
self.parse_seq_to_before_end(ket, seq_sep_none(),
{|p| p.parse_token_tree()})
+ [parse_tt_flat(self, true)]/~)
tt_delim(vec::append(
[parse_tt_flat(self, true)]/~,
vec::append(
self.parse_seq_to_before_end(
ket, seq_sep_none(),
{|p| p.parse_token_tree()}),
[parse_tt_flat(self, true)]/~)))
}
_ { parse_tt_flat(self, false) }
};
@ -1357,7 +1362,7 @@ class parser {
let b_arg = vec::last(args);
let last = self.mk_expr(b_arg.span.lo, b_arg.span.hi,
ctor(b_arg));
@{node: expr_call(f, vec::init(args) + [last]/~, true)
@{node: expr_call(f, vec::append(vec::init(args), [last]/~), true)
with *call}
}
_ {
@ -1655,7 +1660,7 @@ class parser {
}
}
let item_attrs = first_item_attrs + item_attrs;
let item_attrs = vec::append(first_item_attrs, item_attrs);
alt self.parse_item(item_attrs, public) {
some(i) {
@ -1914,7 +1919,7 @@ class parser {
let tps = self.parse_ty_params();
let (decl, _) = self.parse_fn_decl(pur, {|p| p.parse_arg()});
let (inner_attrs, body) = self.parse_inner_attrs_and_block(true);
let attrs = attrs + inner_attrs;
let attrs = vec::append(attrs, inner_attrs);
@{ident: ident, attrs: attrs, tps: tps, decl: decl, body: body,
id: self.get_id(), span: mk_sp(lo, body.span.hi),
self_id: self.get_id(), vis: pr}
@ -2026,7 +2031,7 @@ class parser {
dtor_decl(blk, s) {
the_dtor = some((blk, s));
}
members(mms) { ms += mms; }
members(mms) { ms = vec::append(ms, mms); }
}
}
let actual_dtor = option::map(the_dtor) {|dtor|
@ -2127,7 +2132,10 @@ class parser {
let mut first = true;
while self.token != term {
let mut attrs = self.parse_outer_attributes();
if first { attrs = attrs_remaining + attrs; first = false; }
if first {
attrs = vec::append(attrs_remaining, attrs);
first = false;
}
#debug["parse_mod_items: parse_item(attrs=%?)", attrs];
let vis = self.parse_visibility(private);
alt self.parse_item(attrs, vis) {
@ -2206,7 +2214,8 @@ class parser {
let mut items: [@foreign_item]/~ = []/~;
let mut initial_attrs = attrs_remaining;
while self.token != token::RBRACE {
let attrs = initial_attrs + self.parse_outer_attributes();
let attrs = vec::append(initial_attrs,
self.parse_outer_attributes());
initial_attrs = []/~;
vec::push(items, self.parse_foreign_item(attrs));
}
@ -2383,7 +2392,7 @@ class parser {
} else { ret none; };
some(self.mk_item(lo, self.last_span.hi, ident, item_, vis,
alt extra_attrs {
some(as) { attrs + as }
some(as) { vec::append(attrs, as) }
none { attrs }
}))
}
@ -2498,7 +2507,8 @@ class parser {
fn parse_view(+first_item_attrs: [attribute]/~,
only_imports: bool) -> {attrs_remaining: [attribute]/~,
view_items: [@view_item]/~} {
let mut attrs = first_item_attrs + self.parse_outer_attributes();
let mut attrs = vec::append(first_item_attrs,
self.parse_outer_attributes());
let mut items = []/~;
while if only_imports { self.is_keyword("import") }
else { self.is_view_item() } {
@ -2540,7 +2550,8 @@ class parser {
crate_directive {
// Collect the next attributes
let outer_attrs = first_outer_attr + self.parse_outer_attributes();
let outer_attrs = vec::append(first_outer_attr,
self.parse_outer_attributes());
// In a crate file outer attributes are only going to apply to mods
let expect_mod = vec::len(outer_attrs) > 0u;
@ -2559,7 +2570,7 @@ class parser {
token::LBRACE {
self.bump();
let inner_attrs = self.parse_inner_attrs_and_next();
let mod_attrs = outer_attrs + inner_attrs.inner;
let mod_attrs = vec::append(outer_attrs, inner_attrs.inner);
let next_outer_attr = inner_attrs.next;
let cdirs = self.parse_crate_directives(token::RBRACE,
next_outer_attr);