user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rewrite everything to use [] instead of vec() in value position.

Browse source
This commit is contained in:
Graydon Hoare 2011-05-16 18:21:22 -07:00
parent ae030c5bf2
commit fbbc1a77d2
87 changed files with 1137 additions and 1134 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/comp/front/codemap.rs
View file

@ -13,14 +13,14 @@ type codemap = @rec(mutable vec[filemap] files);
type loc = rec(str filename, uint line, uint col);
fn new_codemap() -> codemap {
let vec[filemap] files = vec();
let vec[filemap] files = [];
ret @rec(mutable files=files);
}
fn new_filemap(str filename, uint start_pos) -> filemap {
ret @rec(name=filename,
start_pos=start_pos,
mutable lines=vec(0u));
mutable lines=[0u]);
}
fn next_line(filemap file, uint pos) {

36
src/comp/front/creader.rs
View file

@ -90,9 +90,9 @@ fn parse_ty(@pstate st, str_def sd) -> ty::t {
case ('t') {
assert (next(st) as char == '[');
auto def = parse_def(st, sd);
let vec[ty::t] params = vec();
let vec[ty::t] params = [];
while (peek(st) as char != ']') {
params += vec(parse_ty(st, sd));
params += [parse_ty(st, sd)];
}
st.pos = st.pos + 1u;
ret ty::mk_tag(st.tcx, def, params);
@ -104,23 +104,23 @@ fn parse_ty(@pstate st, str_def sd) -> ty::t {
case ('C') { ret ty::mk_chan(st.tcx, parse_ty(st, sd)); }
case ('T') {
assert (next(st) as char == '[');
let vec[ty::mt] params = vec();
let vec[ty::mt] params = [];
while (peek(st) as char != ']') {
params += vec(parse_mt(st, sd));
params += [parse_mt(st, sd)];
}
st.pos = st.pos + 1u;
ret ty::mk_tup(st.tcx, params);
}
case ('R') {
assert (next(st) as char == '[');
let vec[ty::field] fields = vec();
let vec[ty::field] fields = [];
while (peek(st) as char != ']') {
auto name = "";
while (peek(st) as char != '=') {
name += _str::unsafe_from_byte(next(st));
}
st.pos = st.pos + 1u;
fields += vec(rec(ident=name, mt=parse_mt(st, sd)));
fields += [rec(ident=name, mt=parse_mt(st, sd))];
}
st.pos = st.pos + 1u;
ret ty::mk_rec(st.tcx, fields);
@ -146,7 +146,7 @@ fn parse_ty(@pstate st, str_def sd) -> ty::t {
}
case ('O') {
assert (next(st) as char == '[');
let vec[ty::method] methods = vec();
let vec[ty::method] methods = [];
while (peek(st) as char != ']') {
auto proto;
alt (next(st) as char) {
@ -158,10 +158,10 @@ fn parse_ty(@pstate st, str_def sd) -> ty::t {
name += _str::unsafe_from_byte(next(st));
}
auto func = parse_ty_fn(st, sd);
methods += vec(rec(proto=proto,
methods += [rec(proto=proto,
ident=name,
inputs=func._0,
output=func._1));
output=func._1)];
}
st.pos += 1u;
ret ty::mk_obj(st.tcx, methods);
@ -242,14 +242,14 @@ fn parse_hex(@pstate st) -> uint {
fn parse_ty_fn(@pstate st, str_def sd) -> tup(vec[ty::arg], ty::t) {
assert (next(st) as char == '[');
let vec[ty::arg] inputs = vec();
let vec[ty::arg] inputs = [];
while (peek(st) as char != ']') {
auto mode = ty::mo_val;
if (peek(st) as char == '&') {
mode = ty::mo_alias;
st.pos = st.pos + 1u;
}
inputs += vec(rec(mode=mode, ty=parse_ty(st, sd)));
inputs += [rec(mode=mode, ty=parse_ty(st, sd))];
}
st.pos = st.pos + 1u;
ret tup(inputs, parse_ty(st, sd));
@ -285,7 +285,7 @@ fn lookup_hash(&ebml::doc d, fn(vec[u8]) -> bool eq_fn, uint hash)
auto pos = ebml::be_uint_from_bytes(d.data, hash_pos, 4u);
auto bucket = ebml::doc_at(d.data, pos);
// Awkward logic because we can't ret from foreach yet
let vec[ebml::doc] result = vec();
let vec[ebml::doc] result = [];
auto belt = metadata::tag_index_buckets_bucket_elt;
for each (ebml::doc elt in ebml::tagged_docs(bucket, belt)) {
auto pos = ebml::be_uint_from_bytes(elt.data, elt.start, 4u);
@ -306,7 +306,7 @@ fn resolve_path(vec[ast::ident] path, vec[u8] data) -> vec[ast::def_id] {
auto md = ebml::new_doc(data);
auto paths = ebml::get_doc(md, metadata::tag_paths);
auto eqer = bind eq_item(_, s);
let vec[ast::def_id] result = vec();
let vec[ast::def_id] result = [];
for (ebml::doc doc in lookup_hash(paths, eqer, metadata::hash_path(s))) {
auto did_doc = ebml::get_doc(doc, metadata::tag_def_id);
_vec::push(result, parse_def_id(ebml::doc_data(did_doc)));
@ -380,7 +380,7 @@ fn item_ty_param_count(&ebml::doc item, int this_cnum) -> uint {
}
fn tag_variant_ids(&ebml::doc item, int this_cnum) -> vec[ast::def_id] {
let vec[ast::def_id] ids = vec();
let vec[ast::def_id] ids = [];
auto v = metadata::tag_items_data_item_variant;
for each (ebml::doc p in ebml::tagged_docs(item, v)) {
auto ext = parse_def_id(ebml::doc_data(p));
@ -544,23 +544,23 @@ fn get_tag_variants(session::session sess, ty::ctxt tcx, ast::def_id def)
auto items = ebml::get_doc(ebml::new_doc(data), metadata::tag_items);
auto item = find_item(def._1, items);
let vec[trans::variant_info] infos = vec();
let vec[trans::variant_info] infos = [];
auto variant_ids = tag_variant_ids(item, external_crate_id);
for (ast::def_id did in variant_ids) {
auto item = find_item(did._1, items);
auto ctor_ty = item_type(item, external_crate_id, tcx);
let vec[ty::t] arg_tys = vec();
let vec[ty::t] arg_tys = [];
alt (ty::struct(tcx, ctor_ty)) {
case (ty::ty_fn(_, ?args, _)) {
for (ty::arg a in args) {
arg_tys += vec(a.ty);
arg_tys += [a.ty];
}
}
case (_) {
// Nullary tag variant.
}
}
infos += vec(rec(args=arg_tys, ctor_ty=ctor_ty, id=did));
infos += [rec(args=arg_tys, ctor_ty=ctor_ty, id=did)];
}
ret infos;

10
src/comp/front/eval.rs
View file

@ -38,7 +38,7 @@ type ctx = @rec(parser p,
mutable uint next_ann);
fn mk_env() -> env {
let env e = vec();
let env e = [];
ret e;
}
@ -249,8 +249,8 @@ fn eval_crate_directives(ctx cx,
fn eval_crate_directives_to_mod(ctx cx, env e,
vec[@ast::crate_directive] cdirs,
str prefix) -> ast::_mod {
let vec[@ast::view_item] view_items = vec();
let vec[@ast::item] items = vec();
let vec[@ast::view_item] view_items = [];
let vec[@ast::item] items = [];
eval_crate_directives(cx, e, cdirs, prefix,
view_items, items);
@ -356,7 +356,7 @@ fn eval_crate_directive(ctx cx,
case (ast::cdir_let(?id, ?x, ?cdirs)) {
auto v = eval_expr(cx, e, x);
auto e0 = vec(tup(id, v)) + e;
auto e0 = [tup(id, v)] + e;
eval_crate_directives(cx, e0, cdirs, prefix,
view_items, items);
}
@ -379,7 +379,7 @@ fn eval_crate_directive(ctx cx,
auto full_path = prefix + std::fs::path_sep() + file_path;
if (cx.mode == mode_depend) {
cx.deps += vec(full_path);
cx.deps += [full_path];
ret;
}

22
src/comp/front/extfmt.rs
View file

@ -118,7 +118,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args)
fn make_path_expr(parser p, common::span sp, vec[ast::ident] idents)
-> @ast::expr {
let vec[@ast::ty] types = vec();
let vec[@ast::ty] types = [];
auto path = rec(idents=idents, types=types);
auto sp_path = rec(node=path, span=sp);
auto pathexpr = ast::expr_path(sp_path, p.get_ann());
@ -143,14 +143,14 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args)
fn make_rec_expr(parser p, common::span sp,
vec[tup(ast::ident, @ast::expr)] fields) -> @ast::expr {
let vec[ast::field] astfields = vec();
let vec[ast::field] astfields = [];
for (tup(ast::ident, @ast::expr) field in fields) {
auto ident = field._0;
auto val = field._1;
auto astfield = rec(mut = ast::imm,
ident = ident,
expr = val);
astfields += vec(astfield);
astfields += [astfield];
}
auto recexpr = ast::expr_rec(astfields,
@ -163,7 +163,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args)
fn make_path_vec(str ident) -> vec[str] {
// FIXME: #fmt can't currently be used from within std
// because we're explicitly referencing the 'std' crate here
ret vec("std", "extfmt", "rt", ident);
ret ["std", "extfmt", "rt", ident];
}
fn make_rt_path_expr(parser p, common::span sp, str ident) -> @ast::expr {
@ -177,7 +177,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args)
fn make_flags(parser p, common::span sp, vec[flag] flags)
-> @ast::expr {
let vec[@ast::expr] flagexprs = vec();
let vec[@ast::expr] flagexprs = [];
for (flag f in flags) {
auto fstr;
alt (f) {
@ -197,14 +197,14 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args)
fstr = "flag_alternate";
}
}
flagexprs += vec(make_rt_path_expr(p, sp, fstr));
flagexprs += [make_rt_path_expr(p, sp, fstr)];
}
// FIXME: 0-length vectors can't have their type inferred
// through the rec that these flags are a member of, so
// this is a hack placeholder flag
if (_vec::len[@ast::expr](flagexprs) == 0u) {
flagexprs += vec(make_rt_path_expr(p, sp, "flag_none"));
flagexprs += [make_rt_path_expr(p, sp, "flag_none")];
}
ret make_vec_expr(p, sp, flagexprs);
@ -218,7 +218,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args)
case (count_is(?c)) {
auto count_lit = make_new_int(p, sp, c);
auto count_is_path = make_path_vec("count_is");
auto count_is_args = vec(count_lit);
auto count_is_args = [count_lit];
ret make_call(p, sp, count_is_path, count_is_args);
}
case (_) {
@ -261,10 +261,10 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args)
@ast::expr width_expr,
@ast::expr precision_expr,
@ast::expr ty_expr) -> @ast::expr {
ret make_rec_expr(p, sp, vec(tup("flags", flags_expr),
ret make_rec_expr(p, sp, [tup("flags", flags_expr),
tup("width", width_expr),
tup("precision", precision_expr),
tup("ty", ty_expr)));
tup("ty", ty_expr)]);
}
auto rt_conv_flags = make_flags(p, sp, cnv.flags);
@ -284,7 +284,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args)
auto fname = "conv_" + conv_type;
auto path = make_path_vec(fname);
auto cnv_expr = make_rt_conv_expr(p, sp, cnv);
auto args = vec(cnv_expr, arg);
auto args = [cnv_expr, arg];
ret make_call(p, arg.span, path, args);
}

12
src/comp/front/lexer.rs
View file

@ -91,7 +91,7 @@ fn new_reader(session sess, io::reader rdr,
}
}
auto file = _str::unsafe_from_bytes(rdr.read_whole_stream());
let vec[str] strs = vec();
let vec[str] strs = [];
auto rd = reader(sess, file, _str::byte_len(file), 0u, -1 as char,
filemap.start_pos, filemap.start_pos,
strs, filemap, itr);
@ -228,11 +228,11 @@ fn scan_exponent(reader rdr) -> option::t[str] {
auto res = "";
if (c == 'e' || c == 'E') {
res += _str::from_bytes(vec(c as u8));
res += _str::from_bytes([c as u8]);
rdr.bump();
c = rdr.curr();
if (c == '-' || c == '+') {
res += _str::from_bytes(vec(c as u8));
res += _str::from_bytes([c as u8]);
rdr.bump();
}
auto exponent = scan_dec_digits(rdr);
@ -256,7 +256,7 @@ fn scan_dec_digits(reader rdr) -> str {
while (is_dec_digit (c) || c == '_') {
if (c != '_') {
res += _str::from_bytes(vec(c as u8));
res += _str::from_bytes([c as u8]);
}
rdr.bump();
c = rdr.curr();
@ -766,7 +766,7 @@ fn read_block_comment(reader rdr) -> cmnt {
auto p = rdr.get_chpos();
rdr.bump(); rdr.bump();
while (rdr.curr() == ' ') {rdr.bump();}
let vec[str] lines = vec();
let vec[str] lines = [];
auto val = "";
auto level = 1;
while (true) {
@ -802,7 +802,7 @@ fn gather_comments(session sess, str path) -> vec[cmnt] {
auto srdr = io::file_reader(path);
auto itr = @interner::mk_interner[str](_str::hash, _str::eq);
auto rdr = new_reader(sess, srdr, codemap::new_filemap(path, 0u), itr);
let vec[cmnt] comments = vec();
let vec[cmnt] comments = [];
while (!rdr.is_eof()) {
while (true) {
consume_whitespace(rdr);

78
src/comp/front/parser.rs
View file

@ -422,7 +422,7 @@ fn parse_ty_constr(parser p) -> @ast::constr {
fn parse_constrs(parser p) -> common::spanned[vec[@ast::constr]] {
auto lo = p.get_lo_pos();
auto hi = p.get_hi_pos();
let vec[@ast::constr] constrs = vec();
let vec[@ast::constr] constrs = [];
if (p.peek() == token::COLON) {
p.bump();
while (true) {
@ -580,7 +580,7 @@ fn parse_seq_to_end[T](token::token ket,
uint hi,
parser p) -> vec[T] {
let bool first = true;
let vec[T] v = vec();
let vec[T] v = [];
while (p.peek() != ket) {
alt(sep) {
case (some[token::token](?t)) {
@ -595,7 +595,7 @@ fn parse_seq_to_end[T](token::token ket,
}
// FIXME: v += f(p) doesn't work at the moment.
let T t = f(p);
v += vec(t);
v += [t];
}
hi = p.get_hi_pos();
expect(p, ket);
@ -677,7 +677,7 @@ fn parse_ty_args(parser p, uint hi) ->
some(token::COMMA),
pf, p);
}
let vec[@ast::ty] v = vec();
let vec[@ast::ty] v = [];
auto pos = p.get_lo_pos();
ret spanned(hi, hi, v);
}
@ -687,12 +687,12 @@ fn parse_path(parser p) -> ast::path {
auto lo = p.get_lo_pos();
auto hi = lo;
let vec[ast::ident] ids = vec();
let vec[ast::ident] ids = [];
while (true) {
alt (p.peek()) {
case (token::IDENT(?i, _)) {
hi = p.get_hi_pos();
ids += vec(p.get_str(i));
ids += [p.get_str(i)];
p.bump();
if (p.peek() == token::MOD_SEP) {
p.bump();
@ -797,7 +797,7 @@ fn parse_bottom_expr(parser p) -> @ast::expr {
pf, hi, p));
}
let vec[@ast::method] meths = vec();
let vec[@ast::method] meths = [];
let option::t[ast::ident] with_obj = none[ast::ident];
expect(p, token::LBRACE);
@ -830,7 +830,7 @@ fn parse_bottom_expr(parser p) -> @ast::expr {
} else if (eat_word(p, "rec")) {
expect(p, token::LPAREN);
auto fields = vec(parse_field(p));
auto fields = [parse_field(p)];
auto more = true;
auto base = none[@ast::expr];
@ -846,7 +846,7 @@ fn parse_bottom_expr(parser p) -> @ast::expr {
more = false;
} else if (p.peek() == token::COMMA) {
p.bump();
fields += vec(parse_field(p));
fields += [parse_field(p)];
} else {
unexpected(p, p.peek());
}
@ -1151,7 +1151,7 @@ type op_spec = rec(token::token tok, ast::binop op, int prec);
// FIXME make this a const, don't store it in parser state
fn prec_table() -> vec[op_spec] {
ret vec(rec(tok=token::BINOP(token::STAR), op=ast::mul, prec=11),
ret [rec(tok=token::BINOP(token::STAR), op=ast::mul, prec=11),
rec(tok=token::BINOP(token::SLASH), op=ast::div, prec=11),
rec(tok=token::BINOP(token::PERCENT), op=ast::rem, prec=11),
rec(tok=token::BINOP(token::PLUS), op=ast::add, prec=10),
@ -1170,7 +1170,7 @@ fn prec_table() -> vec[op_spec] {
rec(tok=token::EQEQ, op=ast::eq, prec=3),
rec(tok=token::NE, op=ast::ne, prec=3),
rec(tok=token::ANDAND, op=ast::and, prec=2),
rec(tok=token::OROR, op=ast::or, prec=1));
rec(tok=token::OROR, op=ast::or, prec=1)];
}
fn parse_binops(parser p) -> @ast::expr {
@ -1342,14 +1342,14 @@ fn parse_alt_expr(parser p) -> @ast::expr {
expect(p, token::RPAREN);
expect(p, token::LBRACE);
let vec[ast::arm] arms = vec();
let vec[ast::arm] arms = [];
while (p.peek() != token::RBRACE) {
if (eat_word(p, "case")) {
expect(p, token::LPAREN);
auto pat = parse_pat(p);
expect(p, token::RPAREN);
auto block = parse_block(p);
arms += vec(rec(pat=pat, block=block));
arms += [rec(pat=pat, block=block)];
} else if (p.peek() == token::RBRACE) {
/* empty */
} else {
@ -1480,7 +1480,7 @@ fn parse_pat(parser p) -> @ast::pat {
args = a.node;
hi = a.span.hi;
}
case (_) { args = vec(); }
case (_) { args = []; }
}
pat = ast::pat_tag(tag_path, args, p.get_ann());
@ -1630,7 +1630,7 @@ fn stmt_ends_with_semi(@ast::stmt stmt) -> bool {
fn parse_block(parser p) -> ast::block {
auto lo = p.get_lo_pos();
let vec[@ast::stmt] stmts = vec();
let vec[@ast::stmt] stmts = [];
let option::t[@ast::expr] expr = none[@ast::expr];
expect(p, token::LBRACE);
@ -1650,7 +1650,7 @@ fn parse_block(parser p) -> ast::block {
alt (p.peek()) {
case (token::SEMI) {
p.bump();
stmts += vec(stmt);
stmts += [stmt];
}
case (token::RBRACE) { expr = some(e); }
case (?t) {
@ -1660,13 +1660,13 @@ fn parse_block(parser p) -> ast::block {
token::to_str(p.get_reader(), t));
fail;
}
stmts += vec(stmt);
stmts += [stmt];
}
}
}
case (none[@ast::expr]) {
// Not an expression statement.
stmts += vec(stmt);
stmts += [stmt];
// FIXME: crazy differentiation between conditions
// used in branches and binary expressions in rustboot
// means we cannot use && here. I know, right?
@ -1693,7 +1693,7 @@ fn parse_ty_param(parser p) -> ast::ty_param {
}
fn parse_ty_params(parser p) -> vec[ast::ty_param] {
let vec[ast::ty_param] ty_params = vec();
let vec[ast::ty_param] ty_params = [];
if (p.peek() == token::LBRACKET) {
auto f = parse_ty_param; // FIXME: pass as lval directly
ty_params = parse_seq[ast::ty_param](token::LBRACKET, token::RBRACKET,
@ -1775,7 +1775,7 @@ fn parse_method(parser p) -> @ast::method {
fn parse_dtor(parser p) -> @ast::method {
auto lo = p.get_last_lo_pos();
let ast::block b = parse_block(p);
let vec[ast::arg] inputs = vec();
let vec[ast::arg] inputs = [];
let @ast::ty output = @spanned(lo, lo, ast::ty_nil);
let ast::fn_decl d = rec(inputs=inputs,
output=output,
@ -1802,7 +1802,7 @@ fn parse_item_obj(parser p, ast::layer lyr) -> @ast::item {
some(token::COMMA),
pf, p);
let vec[@ast::method] meths = vec();
let vec[@ast::method] meths = [];
let option::t[@ast::method] dtor = none[@ast::method];
expect(p, token::LBRACE);
@ -1829,9 +1829,9 @@ fn parse_item_obj(parser p, ast::layer lyr) -> @ast::item {
fn parse_mod_items(parser p, token::token term) -> ast::_mod {
auto view_items = parse_view(p);
let vec[@ast::item] items = vec();
let vec[@ast::item] items = [];
while (p.peek() != term) {
items += vec(parse_item(p));
items += [parse_item(p)];
}
ret rec(view_items=view_items, items=items);
}
@ -1899,12 +1899,12 @@ fn parse_native_item(parser p) -> @ast::native_item {
fn parse_native_mod_items(parser p,
str native_name,
ast::native_abi abi) -> ast::native_mod {
let vec[@ast::native_item] items = vec();
let vec[@ast::native_item] items = [];
auto view_items = parse_native_view(p);
while (p.peek() != token::RBRACE) {
items += vec(parse_native_item(p));
items += [parse_native_item(p)];
}
ret rec(native_name=native_name, abi=abi,
view_items=view_items,
@ -1982,7 +1982,7 @@ fn parse_item_tag(parser p) -> @ast::item {
auto id = parse_ident(p);
auto ty_params = parse_ty_params(p);
let vec[ast::variant] variants = vec();
let vec[ast::variant] variants = [];
expect(p, token::LBRACE);
while (p.peek() != token::RBRACE) {
auto tok = p.peek();
@ -1992,7 +1992,7 @@ fn parse_item_tag(parser p) -> @ast::item {
auto vlo = p.get_lo_pos();
p.bump();
let vec[ast::variant_arg] args = vec();
let vec[ast::variant_arg] args = [];
alt (p.peek()) {
case (token::LPAREN) {
auto f = parse_ty;
@ -2001,7 +2001,7 @@ fn parse_item_tag(parser p) -> @ast::item {
some(token::COMMA),
f, p);
for (@ast::ty ty in arg_tys.node) {
args += vec(rec(ty=ty, id=p.next_def_id()));
args += [rec(ty=ty, id=p.next_def_id())];
}
}
case (_) { /* empty */ }
@ -2013,7 +2013,7 @@ fn parse_item_tag(parser p) -> @ast::item {
auto id = p.next_def_id();
auto vr = rec(name=p.get_str(name), args=args,
id=id, ann=p.get_ann());
variants += vec(spanned[ast::variant_](vlo, vhi, vr));
variants += [spanned[ast::variant_](vlo, vhi, vr)];
}
case (token::RBRACE) { /* empty */ }
case (_) {
@ -2135,7 +2135,7 @@ fn parse_optional_meta(parser p) -> vec[@ast::meta_item] {
ret parse_meta(p);
}
case (_) {
let vec[@ast::meta_item] v = vec();
let vec[@ast::meta_item] v = [];
ret v;
}
}
@ -2156,11 +2156,11 @@ fn parse_rest_import_name(parser p, ast::ident first,
option::t[ast::ident] def_ident)
-> @ast::view_item {
auto lo = p.get_lo_pos();
let vec[ast::ident] identifiers = vec(first);
let vec[ast::ident] identifiers = [first];
while (p.peek() != token::SEMI) {
expect(p, token::MOD_SEP);
auto i = parse_ident(p);
identifiers += vec(i);
identifiers += [i];
}
auto hi = p.get_hi_pos();
p.bump();
@ -2248,17 +2248,17 @@ fn is_view_item(&parser p) -> bool {
}
fn parse_view(parser p) -> vec[@ast::view_item] {
let vec[@ast::view_item] items = vec();
let vec[@ast::view_item] items = [];
while (is_view_item(p)) {
items += vec(parse_view_item(p));
items += [parse_view_item(p)];
}
ret items;
}
fn parse_native_view(parser p) -> vec[@ast::view_item] {
let vec[@ast::view_item] items = vec();
let vec[@ast::view_item] items = [];
while (is_view_item(p)) {
items += vec(parse_view_item(p));
items += [parse_view_item(p)];
}
ret items;
}
@ -2267,7 +2267,7 @@ fn parse_native_view(parser p) -> vec[@ast::view_item] {
fn parse_crate_from_source_file(parser p) -> @ast::crate {
auto lo = p.get_lo_pos();
auto m = parse_mod_items(p, token::EOF);
let vec[@ast::crate_directive] cdirs = vec();
let vec[@ast::crate_directive] cdirs = [];
ret @spanned(lo, p.get_lo_pos(), rec(directives=cdirs,
module=m));
}
@ -2362,7 +2362,7 @@ fn parse_crate_directive(parser p) -> ast::crate_directive
fn parse_crate_directives(parser p, token::token term)
-> vec[@ast::crate_directive] {
let vec[@ast::crate_directive] cdirs = vec();
let vec[@ast::crate_directive] cdirs = [];
while (p.peek() != term) {
auto cdir = @parse_crate_directive(p);
@ -2376,7 +2376,7 @@ fn parse_crate_from_crate_file(parser p) -> @ast::crate {
auto lo = p.get_lo_pos();
auto prefix = std::fs::dirname(p.get_filemap().name);
auto cdirs = parse_crate_directives(p, token::EOF);
let vec[str] deps = vec();
let vec[str] deps = [];
auto cx = @rec(p=p,
mode=eval::mode_parse,
mutable deps = deps,