From b653a1841631949f6d21c551a700a3cbe13bf42f Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Thu, 15 Mar 2012 09:47:03 -0400 Subject: add mut decls to rustc and make them mandatory --- src/rustc/syntax/parse/parser.rs | 194 ++++++++++++++++++++------------------- 1 file changed, 98 insertions(+), 96 deletions(-) (limited to 'src/rustc/syntax/parse/parser.rs') diff --git a/src/rustc/syntax/parse/parser.rs b/src/rustc/syntax/parse/parser.rs index 99746aed84a..b35b68ea5e2 100644 --- a/src/rustc/syntax/parse/parser.rs +++ b/src/rustc/syntax/parse/parser.rs @@ -169,7 +169,7 @@ fn expect(p: parser, t: token::token) { if p.token == t { p.bump(); } else { - let s: str = "expecting '"; + let mut s: str = "expecting '"; s += token::to_str(p.reader, t); s += "' but found '"; s += token::to_str(p.reader, p.token); @@ -185,7 +185,7 @@ fn expect_gt(p: parser) { } else if p.token == token::BINOP(token::ASR) { p.swap(token::BINOP(token::LSR), p.span.lo + 1u, p.span.hi); } else { - let s: str = "expecting "; + let mut s: str = "expecting "; s += token::to_str(p.reader, token::GT); s += ", found "; s += token::to_str(p.reader, p.token); @@ -313,14 +313,14 @@ fn parse_ty_field(p: parser) -> ast::ty_field { // if i is the jth ident in args, return j // otherwise, fail fn ident_index(p: parser, args: [ast::arg], i: ast::ident) -> uint { - let j = 0u; + let mut j = 0u; for a: ast::arg in args { if a.ident == i { ret j; } j += 1u; } p.fatal("unbound variable `" + i + "` in constraint arg"); } fn parse_type_constr_arg(p: parser) -> @ast::ty_constr_arg { let sp = p.span; - let carg = ast::carg_base; + let mut carg = ast::carg_base; expect(p, token::BINOP(token::STAR)); if p.token == token::DOT { // "*..." notation for record fields @@ -334,7 +334,7 @@ fn parse_type_constr_arg(p: parser) -> @ast::ty_constr_arg { fn parse_constr_arg(args: [ast::arg], p: parser) -> @ast::constr_arg { let sp = p.span; - let carg = ast::carg_base; + let mut carg = ast::carg_base; if p.token == token::BINOP(token::STAR) { p.bump(); } else { @@ -369,7 +369,7 @@ fn parse_constr_in_type(p: parser) -> @ast::ty_constr { fn parse_constrs(pser: fn(parser) -> @ast::constr_general, p: parser) -> [@ast::constr_general] { - let constrs: [@ast::constr_general] = []; + let mut constrs: [@ast::constr_general] = []; loop { let constr = pser(p); constrs += [constr]; @@ -463,7 +463,7 @@ fn parse_ty(p: parser, colons_before_params: bool) -> @ast::ty { p.bump(); ast::ty_nil } else { - let ts = [parse_ty(p, false)]; + let mut ts = [parse_ty(p, false)]; while p.token == token::COMMA { p.bump(); ts += [parse_ty(p, false)]; @@ -564,8 +564,8 @@ fn parse_fn_block_arg(p: parser) -> ast::arg { fn parse_seq_to_before_gt(sep: option, f: fn(parser) -> T, p: parser) -> [T] { - let first = true; - let v = []; + let mut first = true; + let mut v = []; while p.token != token::GT && p.token != token::BINOP(token::LSR) && p.token != token::BINOP(token::ASR) { alt sep { @@ -622,8 +622,8 @@ fn seq_sep_none() -> seq_sep { fn parse_seq_to_before_end(ket: token::token, sep: seq_sep, f: fn(parser) -> T, p: parser) -> [T] { - let first: bool = true; - let v: [T] = []; + let mut first: bool = true; + let mut v: [T] = []; while p.token != ket { alt sep.sep { some(t) { if first { first = false; } else { expect(p, t); } } @@ -701,7 +701,8 @@ fn is_plain_ident(p: parser) -> bool { fn parse_path(p: parser) -> @ast::path { let lo = p.span.lo; - let global = eat(p, token::MOD_SEP), ids = [parse_ident(p)]; + let global = eat(p, token::MOD_SEP); + let mut ids = [parse_ident(p)]; while p.look_ahead(1u) != token::LT && eat(p, token::MOD_SEP) { ids += [parse_ident(p)]; } @@ -800,9 +801,9 @@ fn to_expr(e: pexpr) -> @ast::expr { fn parse_bottom_expr(p: parser) -> pexpr { let lo = p.span.lo; - let hi = p.span.hi; + let mut hi = p.span.hi; - let ex: ast::expr_; + let mut ex: ast::expr_; alt have_dollar(p) { some(x) {ret pexpr(mk_mac_expr(p, lo, p.span.hi, x));} @@ -817,7 +818,7 @@ fn parse_bottom_expr(p: parser) -> pexpr { let lit = @spanned(lo, hi, ast::lit_nil); ret mk_pexpr(p, lo, hi, ast::expr_lit(lit)); } - let es = [parse_expr(p)]; + let mut es = [parse_expr(p)]; while p.token == token::COMMA { p.bump(); es += [parse_expr(p)]; } hi = p.span.hi; expect(p, token::RPAREN); @@ -832,8 +833,8 @@ fn parse_bottom_expr(p: parser) -> pexpr { p.bump(); if is_word(p, "mut") || is_word(p, "mutable") || is_plain_ident(p) && p.look_ahead(1u) == token::COLON { - let fields = [parse_field(p, token::COLON)]; - let base = none; + let mut fields = [parse_field(p, token::COLON)]; + let mut base = none; while p.token != token::RBRACE { if eat_word(p, "with") { base = some(parse_expr(p)); break; } expect(p, token::COMMA); @@ -1011,7 +1012,7 @@ fn parse_syntax_ext_naked(p: parser, lo: uint) -> @ast::expr { let pth = parse_path(p); //temporary for a backwards-compatible cycle: let sep = seq_sep(token::COMMA); - let e = none; + let mut e = none; if (p.token == token::LPAREN || p.token == token::LBRACKET) { let es = if p.token == token::LPAREN { @@ -1025,11 +1026,11 @@ fn parse_syntax_ext_naked(p: parser, lo: uint) -> @ast::expr { e = some(mk_expr(p, es.span.lo, hi, ast::expr_vec(es.node, ast::m_imm))); } - let b = none; + let mut b = none; if p.token == token::LBRACE { p.bump(); let lo = p.span.lo; - let depth = 1u; + let mut depth = 1u; while (depth > 0u) { alt (p.token) { token::LBRACE {depth += 1u;} @@ -1055,9 +1056,9 @@ fn permits_call(p: parser) -> bool { } fn parse_dot_or_call_expr_with(p: parser, e0: pexpr) -> pexpr { - let e = e0; + let mut e = e0; let lo = e.span.lo; - let hi = e.span.hi; + let mut hi = e.span.hi; loop { // expr.f if eat(p, token::DOT) { @@ -1132,9 +1133,9 @@ fn parse_dot_or_call_expr_with(p: parser, e0: pexpr) -> pexpr { fn parse_prefix_expr(p: parser) -> pexpr { let lo = p.span.lo; - let hi = p.span.hi; + let mut hi = p.span.hi; - let ex; + let mut ex; alt p.token { token::NOT { p.bump(); @@ -1261,7 +1262,7 @@ fn parse_assign_expr(p: parser) -> @ast::expr { token::BINOPEQ(op) { p.bump(); let rhs = parse_expr(p); - let aop = ast::add; + let mut aop; alt op { token::PLUS { aop = ast::add; } token::MINUS { aop = ast::subtract; } @@ -1302,8 +1303,8 @@ fn parse_if_expr_1(p: parser) -> let lo = p.last_span.lo; let cond = parse_expr(p); let thn = parse_block(p); - let els: option<@ast::expr> = none; - let hi = thn.span.hi; + let mut els: option<@ast::expr> = none; + let mut hi = thn.span.hi; if eat_word(p, "else") { let elexpr = parse_else_expr(p); els = some(elexpr); @@ -1337,7 +1338,7 @@ fn parse_capture_clause(p: parser) -> @ast::capture_clause { } fn eat_ident_list(p: parser) -> [@ast::capture_item] { - let res = []; + let mut res = []; loop { alt p.token { token::IDENT(_, _) { @@ -1355,8 +1356,8 @@ fn parse_capture_clause(p: parser) -> @ast::capture_clause { }; } - let copies = []; - let moves = []; + let mut copies = []; + let mut moves = []; if eat(p, token::LBRACKET) { while !eat(p, token::RBRACKET) { @@ -1407,7 +1408,7 @@ fn parse_for_expr(p: parser) -> @ast::expr { expect_word(p, "in"); let seq = parse_expr(p); let body = parse_block_no_value(p); - let hi = body.span.hi; + let mut hi = body.span.hi; ret mk_expr(p, lo, hi, ast::expr_for(decl, seq, body)); } @@ -1415,7 +1416,7 @@ fn parse_while_expr(p: parser) -> @ast::expr { let lo = p.last_span.lo; let cond = parse_expr(p); let body = parse_block_no_value(p); - let hi = body.span.hi; + let mut hi = body.span.hi; ret mk_expr(p, lo, hi, ast::expr_while(cond, body)); } @@ -1424,14 +1425,14 @@ fn parse_do_while_expr(p: parser) -> @ast::expr { let body = parse_block_no_value(p); expect_word(p, "while"); let cond = parse_expr(p); - let hi = cond.span.hi; + let mut hi = cond.span.hi; ret mk_expr(p, lo, hi, ast::expr_do_while(body, cond)); } fn parse_loop_expr(p: parser) -> @ast::expr { let lo = p.last_span.lo; let body = parse_block_no_value(p); - let hi = body.span.hi; + let mut hi = body.span.hi; ret mk_expr(p, lo, hi, ast::expr_loop(body)); } @@ -1441,15 +1442,15 @@ fn parse_alt_expr(p: parser) -> @ast::expr { else { ast::alt_exhaustive }; let discriminant = parse_expr(p); expect(p, token::LBRACE); - let arms: [ast::arm] = []; + let mut arms: [ast::arm] = []; while p.token != token::RBRACE { let pats = parse_pats(p); - let guard = none; + let mut guard = none; if eat_word(p, "if") { guard = some(parse_expr(p)); } let blk = parse_block(p); arms += [{pats: pats, guard: guard, body: blk}]; } - let hi = p.span.hi; + let mut hi = p.span.hi; p.bump(); ret mk_expr(p, lo, hi, ast::expr_alt(discriminant, arms, mode)); } @@ -1497,7 +1498,7 @@ fn parse_initializer(p: parser) -> option { } fn parse_pats(p: parser) -> [@ast::pat] { - let pats = []; + let mut pats = []; loop { pats += [parse_pat(p)]; if p.token == token::BINOP(token::OR) { p.bump(); } else { ret pats; } @@ -1506,8 +1507,8 @@ fn parse_pats(p: parser) -> [@ast::pat] { fn parse_pat(p: parser) -> @ast::pat { let lo = p.span.lo; - let hi = p.span.hi; - let pat; + let mut hi = p.span.hi; + let mut pat; alt p.token { token::UNDERSCORE { p.bump(); pat = ast::pat_wild; } token::AT { @@ -1524,9 +1525,9 @@ fn parse_pat(p: parser) -> @ast::pat { } token::LBRACE { p.bump(); - let fields = []; - let etc = false; - let first = true; + let mut fields = []; + let mut etc = false; + let mut first = true; while p.token != token::RBRACE { if first { first = false; } else { expect(p, token::COMMA); } @@ -1545,7 +1546,7 @@ fn parse_pat(p: parser) -> @ast::pat { let hi1 = p.last_span.lo; let fieldpath = ast_util::ident_to_path(ast_util::mk_sp(lo1, hi1), fieldname); - let subpat; + let mut subpat; if p.token == token::COLON { p.bump(); subpat = parse_pat(p); @@ -1572,7 +1573,7 @@ fn parse_pat(p: parser) -> @ast::pat { let expr = mk_expr(p, lo, hi, ast::expr_lit(lit)); pat = ast::pat_lit(expr); } else { - let fields = [parse_pat(p)]; + let mut fields = [parse_pat(p)]; while p.token == token::COMMA { p.bump(); fields += [parse_pat(p)]; @@ -1606,7 +1607,7 @@ fn parse_pat(p: parser) -> @ast::pat { } else { let enum_path = parse_path_and_ty_param_substs(p, true); hi = enum_path.span.hi; - let args: [@ast::pat]; + let mut args: [@ast::pat]; alt p.token { token::LPAREN { let a = @@ -1635,9 +1636,9 @@ fn parse_local(p: parser, is_mutbl: bool, allow_init: bool) -> @ast::local { let lo = p.span.lo; let pat = parse_pat(p); - let ty = @{id: p.get_id(), - node: ast::ty_infer, - span: ast_util::mk_sp(lo, lo)}; + let mut ty = @{id: p.get_id(), + node: ast::ty_infer, + span: ast_util::mk_sp(lo, lo)}; if eat(p, token::COLON) { ty = parse_ty(p, false); } let init = if allow_init { parse_initializer(p) } else { none }; ret @spanned(lo, p.last_span.hi, @@ -1648,7 +1649,7 @@ fn parse_local(p: parser, is_mutbl: bool, fn parse_let(p: parser) -> @ast::decl { let is_mutbl = eat_word(p, "mut"); let lo = p.span.lo; - let locals = [parse_local(p, is_mutbl, true)]; + let mut locals = [parse_local(p, is_mutbl, true)]; while eat(p, token::COMMA) { locals += [parse_local(p, is_mutbl, true)]; } @@ -1657,7 +1658,7 @@ fn parse_let(p: parser) -> @ast::decl { /* assumes "let" token has already been consumed */ fn parse_instance_var(p:parser) -> (ast::class_member, codemap::span) { - let is_mutbl = ast::class_immutable; + let mut is_mutbl = ast::class_immutable; let lo = p.span.lo; if eat_word(p, "mut") || eat_word(p, "mutable") { is_mutbl = ast::class_mutable; @@ -1687,7 +1688,7 @@ fn parse_stmt(p: parser, first_item_attrs: [ast::attribute]) -> @ast::stmt { let decl = parse_let(p); ret @spanned(lo, decl.span.hi, ast::stmt_decl(decl, p.get_id())); } else { - let item_attrs; + let mut item_attrs; alt parse_outer_attrs_or_ext(p, first_item_attrs) { none { item_attrs = []; } some(left(attrs)) { item_attrs = attrs; } @@ -1700,7 +1701,7 @@ fn parse_stmt(p: parser, first_item_attrs: [ast::attribute]) -> @ast::stmt { alt parse_item(p, item_attrs) { some(i) { - let hi = i.span.hi; + let mut hi = i.span.hi; let decl = @spanned(lo, hi, ast::decl_item(i)); ret @spanned(lo, hi, ast::stmt_decl(decl, p.get_id())); } @@ -1805,10 +1806,10 @@ fn parse_block_tail(p: parser, lo: uint, s: ast::blk_check_mode) -> ast::blk { fn parse_block_tail_(p: parser, lo: uint, s: ast::blk_check_mode, first_item_attrs: [ast::attribute]) -> ast::blk { - let stmts = []; - let expr = none; + let mut stmts = []; + let mut expr = none; let view_items = maybe_parse_view_import_only(p, first_item_attrs); - let initial_attrs = first_item_attrs; + let mut initial_attrs = first_item_attrs; if p.token == token::RBRACE && !vec::is_empty(initial_attrs) { p.fatal("expected item"); @@ -1854,7 +1855,7 @@ fn parse_block_tail_(p: parser, lo: uint, s: ast::blk_check_mode, } } } - let hi = p.span.hi; + let mut hi = p.span.hi; p.bump(); let bloc = {view_items: view_items, stmts: stmts, expr: expr, id: p.get_id(), rules: s}; @@ -1862,7 +1863,7 @@ fn parse_block_tail_(p: parser, lo: uint, s: ast::blk_check_mode, } fn parse_ty_param(p: parser) -> ast::ty_param { - let bounds = []; + let mut bounds = []; let ident = parse_ident(p); if eat(p, token::COLON) { while p.token != token::COMMA && p.token != token::GT { @@ -1888,7 +1889,7 @@ fn parse_fn_decl(p: parser, purity: ast::purity) // Use the args list to translate each bound variable // mentioned in a constraint to an arg index. // Seems weird to do this in the parser, but I'm not sure how else to. - let constrs = []; + let mut constrs = []; if p.token == token::COLON { p.bump(); constrs = parse_constrs({|x| parse_ty_constr(inputs.node, x) }, p); @@ -1990,7 +1991,7 @@ fn parse_item_impl(p: parser, attrs: [ast::attribute]) -> @ast::item { fn wrap_path(p: parser, pt: @ast::path) -> @ast::ty { @{id: p.get_id(), node: ast::ty_path(pt, p.get_id()), span: pt.span} } - let (ident, tps) = if !is_word(p, "of") { + let mut (ident, tps) = if !is_word(p, "of") { if p.token == token::LT { (none, parse_ty_params(p)) } else { (some(parse_ident(p)), parse_ty_params(p)) } } else { (none, []) }; @@ -2006,7 +2007,8 @@ fn parse_item_impl(p: parser, attrs: [ast::attribute]) -> @ast::item { none { expect_word(p, "of"); fail; } }; expect_word(p, "for"); - let ty = parse_ty(p, false), meths = []; + let ty = parse_ty(p, false); + let mut meths = []; expect(p, token::LBRACE); while !eat(p, token::RBRACE) { meths += [parse_method(p)]; } ret mk_item(p, lo, p.last_span.hi, ident, @@ -2044,9 +2046,9 @@ fn parse_item_class(p: parser, attrs: [ast::attribute]) -> @ast::item { let class_path = ident_to_path(p.last_span, class_name); let ty_params = parse_ty_params(p); expect(p, token::LBRACE); - let items: [@ast::class_item] = []; + let mut items: [@ast::class_item] = []; let ctor_id = p.get_id(); - let the_ctor : option<(ast::fn_decl, ast::blk, codemap::span)> = none; + let mut the_ctor : option<(ast::fn_decl, ast::blk, codemap::span)> = none; while p.token != token::RBRACE { alt parse_class_item(p, class_path) { ctor_decl(a_fn_decl, blk, s) { @@ -2109,7 +2111,7 @@ enum class_contents { ctor_decl(ast::fn_decl, ast::blk, codemap::span), // FIXME: refactor else if eat_word(p, "priv") { expect(p, token::LBRACE); - let results = []; + let mut results = []; while p.token != token::RBRACE { if eat_word(p, "let") { let a_var = parse_instance_var(p); @@ -2142,8 +2144,8 @@ fn parse_mod_items(p: parser, term: token::token, first_item_attrs: [ast::attribute]) -> ast::_mod { // Shouldn't be any view items since we've already parsed an item attr let view_items = maybe_parse_view(p, first_item_attrs); - let items: [@ast::item] = []; - let initial_attrs = first_item_attrs; + let mut items: [@ast::item] = []; + let mut initial_attrs = first_item_attrs; while p.token != term { let attrs = initial_attrs + parse_outer_attributes(p); #debug["parse_mod_items: parse_item(attrs=%?)", attrs]; @@ -2173,7 +2175,7 @@ fn parse_item_const(p: parser, attrs: [ast::attribute]) -> @ast::item { let ty = parse_ty(p, false); expect(p, token::EQ); let e = parse_expr(p); - let hi = p.span.hi; + let mut hi = p.span.hi; expect(p, token::SEMI); ret mk_item(p, lo, hi, id, ast::item_const(ty, e), attrs); } @@ -2185,7 +2187,7 @@ fn parse_item_mod(p: parser, attrs: [ast::attribute]) -> @ast::item { let inner_attrs = parse_inner_attrs_and_next(p); let first_item_outer_attrs = inner_attrs.next; let m = parse_mod_items(p, token::RBRACE, first_item_outer_attrs); - let hi = p.span.hi; + let mut hi = p.span.hi; expect(p, token::RBRACE); ret mk_item(p, lo, hi, id, ast::item_mod(m), attrs + inner_attrs.inner); } @@ -2195,7 +2197,7 @@ fn parse_item_native_fn(p: parser, attrs: [ast::attribute], let lo = p.last_span.lo; let t = parse_fn_header(p); let decl = parse_fn_decl(p, purity); - let hi = p.span.hi; + let mut hi = p.span.hi; expect(p, token::SEMI); ret @{ident: t.ident, attrs: attrs, @@ -2223,8 +2225,8 @@ fn parse_native_mod_items(p: parser, first_item_attrs: [ast::attribute]) -> if vec::len(first_item_attrs) == 0u { parse_native_view(p) } else { [] }; - let items: [@ast::native_item] = []; - let initial_attrs = first_item_attrs; + let mut items: [@ast::native_item] = []; + let mut initial_attrs = first_item_attrs; while p.token != token::RBRACE { let attrs = initial_attrs + parse_outer_attributes(p); initial_attrs = []; @@ -2243,7 +2245,7 @@ fn parse_item_native_mod(p: parser, attrs: [ast::attribute]) -> @ast::item { let inner_attrs = more_attrs.inner; let first_item_outer_attrs = more_attrs.next; let m = parse_native_mod_items(p, first_item_outer_attrs); - let hi = p.span.hi; + let mut hi = p.span.hi; expect(p, token::RBRACE); ret mk_item(p, lo, hi, id, ast::item_native_mod(m), attrs + inner_attrs); } @@ -2259,7 +2261,7 @@ fn parse_item_type(p: parser, attrs: [ast::attribute]) -> @ast::item { let tps = parse_ty_params(p); expect(p, token::EQ); let ty = parse_ty(p, false); - let hi = p.span.hi; + let mut hi = p.span.hi; expect(p, token::SEMI); ret mk_item(p, t.lo, hi, t.ident, ast::item_ty(ty, tps), attrs); } @@ -2268,7 +2270,7 @@ fn parse_item_enum(p: parser, attrs: [ast::attribute]) -> @ast::item { let lo = p.last_span.lo; let id = parse_ident(p); let ty_params = parse_ty_params(p); - let variants: [ast::variant] = []; + let mut variants: [ast::variant] = []; // Newtype syntax if p.token == token::EQ { if p.bad_expr_words.contains_key(id) { @@ -2289,13 +2291,13 @@ fn parse_item_enum(p: parser, attrs: [ast::attribute]) -> @ast::item { } expect(p, token::LBRACE); - let all_nullary = true, have_disr = false; + let mut all_nullary = true, have_disr = false; while p.token != token::RBRACE { let variant_attrs = parse_outer_attributes(p); let vlo = p.span.lo; let ident = parse_value_ident(p); - let args = [], disr_expr = none; + let mut args = [], disr_expr = none; if p.token == token::LPAREN { all_nullary = false; let arg_tys = parse_seq(token::LPAREN, token::RPAREN, @@ -2416,7 +2418,7 @@ fn parse_outer_attrs_or_ext( // Parse attributes that appear before an item fn parse_outer_attributes(p: parser) -> [ast::attribute] { - let attrs: [ast::attribute] = []; + let mut attrs: [ast::attribute] = []; while p.token == token::POUND { attrs += [parse_attribute(p, ast::attr_outer)]; } @@ -2434,7 +2436,7 @@ fn parse_attribute_naked(p: parser, style: ast::attr_style, lo: uint) -> expect(p, token::LBRACKET); let meta_item = parse_meta_item(p); expect(p, token::RBRACKET); - let hi = p.span.hi; + let mut hi = p.span.hi; ret spanned(lo, hi, {style: style, value: *meta_item}); } @@ -2446,8 +2448,8 @@ fn parse_attribute_naked(p: parser, style: ast::attr_style, lo: uint) -> // until we see the semi). fn parse_inner_attrs_and_next(p: parser) -> {inner: [ast::attribute], next: [ast::attribute]} { - let inner_attrs: [ast::attribute] = []; - let next_outer_attrs: [ast::attribute] = []; + let mut inner_attrs: [ast::attribute] = []; + let mut next_outer_attrs: [ast::attribute] = []; while p.token == token::POUND { if p.look_ahead(1u) != token::LBRACKET { // This is an extension @@ -2476,16 +2478,16 @@ fn parse_meta_item(p: parser) -> @ast::meta_item { token::EQ { p.bump(); let lit = parse_lit(p); - let hi = p.span.hi; + let mut hi = p.span.hi; ret @spanned(lo, hi, ast::meta_name_value(ident, lit)); } token::LPAREN { let inner_items = parse_meta_seq(p); - let hi = p.span.hi; + let mut hi = p.span.hi; ret @spanned(lo, hi, ast::meta_list(ident, inner_items)); } _ { - let hi = p.span.hi; + let mut hi = p.span.hi; ret @spanned(lo, hi, ast::meta_word(ident)); } } @@ -2509,7 +2511,7 @@ fn parse_use(p: parser) -> ast::view_item_ { fn parse_view_path(p: parser) -> @ast::view_path { let lo = p.span.lo; let first_ident = parse_ident(p); - let path = [first_ident]; + let mut path = [first_ident]; #debug("parsed view_path: %s", first_ident); alt p.token { token::EQ { @@ -2521,7 +2523,7 @@ fn parse_view_path(p: parser) -> @ast::view_path { let id = parse_ident(p); path += [id]; } - let hi = p.span.hi; + let mut hi = p.span.hi; ret @spanned(lo, hi, ast::view_path_simple(first_ident, @path, p.get_id())); @@ -2545,7 +2547,7 @@ fn parse_view_path(p: parser) -> @ast::view_path { parse_seq(token::LBRACE, token::RBRACE, seq_sep(token::COMMA), parse_path_list_ident, p).node; - let hi = p.span.hi; + let mut hi = p.span.hi; ret @spanned(lo, hi, ast::view_path_list(@path, idents, p.get_id())); @@ -2554,7 +2556,7 @@ fn parse_view_path(p: parser) -> @ast::view_path { // foo::bar::* token::BINOP(token::STAR) { p.bump(); - let hi = p.span.hi; + let mut hi = p.span.hi; ret @spanned(lo, hi, ast::view_path_glob(@path, p.get_id())); @@ -2566,7 +2568,7 @@ fn parse_view_path(p: parser) -> @ast::view_path { } _ { } } - let hi = p.span.hi; + let mut hi = p.span.hi; let last = path[vec::len(path) - 1u]; ret @spanned(lo, hi, ast::view_path_simple(last, @path, @@ -2574,7 +2576,7 @@ fn parse_view_path(p: parser) -> @ast::view_path { } fn parse_view_paths(p: parser) -> [@ast::view_path] { - let vp = [parse_view_path(p)]; + let mut vp = [parse_view_path(p)]; while p.token == token::COMMA { p.bump(); vp += [parse_view_path(p)]; @@ -2594,7 +2596,7 @@ fn parse_view_item(p: parser) -> @ast::view_item { } else { fail }; - let hi = p.span.lo; + let mut hi = p.span.lo; expect(p, token::SEMI); ret @spanned(lo, hi, the_item); } @@ -2630,7 +2632,7 @@ fn maybe_parse_view_while( f: fn@(parser) -> bool) -> [@ast::view_item] { if vec::len(first_item_attrs) == 0u { - let items = []; + let mut items = []; while f(p) { items += [parse_view_item(p)]; } ret items; } else { @@ -2729,7 +2731,7 @@ fn parse_crate_directive(p: parser, first_outer_attr: [ast::attribute]) -> alt p.token { // mod x = "foo.rs"; token::SEMI { - let hi = p.span.hi; + let mut hi = p.span.hi; p.bump(); ret spanned(lo, hi, ast::cdir_src_mod(id, outer_attrs)); } @@ -2741,7 +2743,7 @@ fn parse_crate_directive(p: parser, first_outer_attr: [ast::attribute]) -> let next_outer_attr = inner_attrs.next; let cdirs = parse_crate_directives(p, token::RBRACE, next_outer_attr); - let hi = p.span.hi; + let mut hi = p.span.hi; expect(p, token::RBRACE); ret spanned(lo, hi, ast::cdir_dir_mod(id, cdirs, mod_attrs)); @@ -2765,8 +2767,8 @@ fn parse_crate_directives(p: parser, term: token::token, expect_word(p, "mod"); } - let cdirs: [@ast::crate_directive] = []; - let first_outer_attr = first_outer_attr; + let mut cdirs: [@ast::crate_directive] = []; + let mut first_outer_attr = first_outer_attr; while p.token != term { let cdir = @parse_crate_directive(p, first_outer_attr); cdirs += [cdir]; @@ -2793,7 +2795,7 @@ fn parse_crate_from_crate_file(input: str, cfg: ast::crate_cfg, let (companionmod, _) = path::splitext(path::basename(input)); let (m, attrs) = eval::eval_crate_directives_to_mod( cx, cdirs, prefix, option::some(companionmod)); - let hi = p.span.hi; + let mut hi = p.span.hi; expect(p, token::EOF); ret @spanned(lo, hi, {directives: cdirs, -- cgit 1.4.1-3-g733a5