rust-lang/rust
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

libsyntax: is_keyword should take a &~str

Browse Source
This commit is contained in:
Erick Tryzelaar
2013-02-24 09:39:29 -08:00
parent 8b94ef0302
commit 1deb858b22
4 changed files with 132 additions and 128 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/libsyntax/ext/trace_macros.rs
View File

@@ -31,9 +31,9 @@ pub fn expand_trace_macros(cx: ext_ctxt, sp: span,
let rdr = tt_rdr as reader; let rdr = tt_rdr as reader;
let rust_parser = Parser(sess, cfg, rdr.dup()); let rust_parser = Parser(sess, cfg, rdr.dup());
if rust_parser.is_keyword(~"true") { if rust_parser.is_keyword(&~"true") {
cx.set_trace_macros(true); cx.set_trace_macros(true);
} else if rust_parser.is_keyword(~"false") { } else if rust_parser.is_keyword(&~"false") {
cx.set_trace_macros(false); cx.set_trace_macros(false);
} else { } else {
cx.span_fatal(sp, ~"trace_macros! only accepts `true` or `false`") cx.span_fatal(sp, ~"trace_macros! only accepts `true` or `false`")

42
src/libsyntax/parse/common.rs
View File

@@ -110,25 +110,25 @@ pub impl Parser {
// Storing keywords as interned idents instead of strings would be nifty. // Storing keywords as interned idents instead of strings would be nifty.
// A sanity check that the word we are asking for is a known keyword // A sanity check that the word we are asking for is a known keyword
fn require_keyword(word: ~str) { fn require_keyword(word: &~str) {
if !self.keywords.contains_key(&word) { if !self.keywords.contains_key(word) {
self.bug(fmt!("unknown keyword: %s", word)); self.bug(fmt!("unknown keyword: %s", *word));
} }
} }
fn token_is_word(word: ~str, ++tok: token::Token) -> bool { fn token_is_word(word: &~str, tok: token::Token) -> bool {
match tok { match tok {
token::IDENT(sid, false) => { *self.id_to_str(sid) == word } token::IDENT(sid, false) => { *self.id_to_str(sid) == *word }
_ => { false } _ => { false }
} }
} }
fn token_is_keyword(word: ~str, ++tok: token::Token) -> bool { fn token_is_keyword(word: &~str, ++tok: token::Token) -> bool {
self.require_keyword(word); self.require_keyword(word);
self.token_is_word(word, tok) self.token_is_word(word, tok)
} }
fn is_keyword(word: ~str) -> bool { fn is_keyword(word: &~str) -> bool {
self.token_is_keyword(word, *self.token) self.token_is_keyword(word, *self.token)
} }
@@ -141,62 +141,62 @@ pub impl Parser {
} }
} }
fn eat_keyword(word: ~str) -> bool { fn eat_keyword(word: &~str) -> bool {
self.require_keyword(word); 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)), token::IDENT(sid, false) => *word == *self.id_to_str(sid),
_ => false _ => false
}; };
if is_kw { self.bump() } if is_kw { self.bump() }
is_kw is_kw
} }
fn expect_keyword(word: ~str) { fn expect_keyword(word: &~str) {
self.require_keyword(word); self.require_keyword(word);
if !self.eat_keyword(word) { if !self.eat_keyword(word) {
self.fatal(~"expected `" + word + ~"`, found `" + self.fatal(~"expected `" + *word + ~"`, found `" +
token_to_str(self.reader, *self.token) + token_to_str(self.reader, *self.token) +
~"`"); ~"`");
} }
} }
fn is_strict_keyword(word: ~str) -> bool { fn is_strict_keyword(word: &~str) -> bool {
self.strict_keywords.contains_key(&word) self.strict_keywords.contains_key(word)
} }
fn check_strict_keywords() { fn check_strict_keywords() {
match *self.token { match *self.token {
token::IDENT(_, false) => { 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); self.check_strict_keywords_(&w);
} }
_ => () _ => ()
} }
} }
fn check_strict_keywords_(w: ~str) { fn check_strict_keywords_(w: &~str) {
if self.is_strict_keyword(w) { if self.is_strict_keyword(w) {
self.fatal(~"found `" + w + ~"` in ident position"); self.fatal(~"found `" + *w + ~"` in ident position");
} }
} }
fn is_reserved_keyword(word: ~str) -> bool { fn is_reserved_keyword(word: &~str) -> bool {
self.reserved_keywords.contains_key(&word) self.reserved_keywords.contains_key(word)
} }
fn check_reserved_keywords() { fn check_reserved_keywords() {
match *self.token { match *self.token {
token::IDENT(_, false) => { 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); self.check_reserved_keywords_(&w);
} }
_ => () _ => ()
} }
} }
fn check_reserved_keywords_(w: ~str) { fn check_reserved_keywords_(w: &~str) {
if self.is_reserved_keyword(w) { if self.is_reserved_keyword(w) {
self.fatal(~"`" + w + ~"` is a reserved keyword"); self.fatal(~"`" + *w + ~"` is a reserved keyword");
} }
} }

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

@@ -197,9 +197,9 @@ pub impl Parser {
} }
fn try_parse_obsolete_priv_section() -> bool { fn try_parse_obsolete_priv_section() -> bool {
if self.is_keyword(~"priv") && self.look_ahead(1) == token::LBRACE { if self.is_keyword(&~"priv") && self.look_ahead(1) == token::LBRACE {
self.obsolete(*self.span, ObsoletePrivSection); self.obsolete(*self.span, ObsoletePrivSection);
self.eat_keyword(~"priv"); self.eat_keyword(&~"priv");
self.bump(); self.bump();
while *self.token != token::RBRACE { while *self.token != token::RBRACE {
self.parse_single_class_item(ast::private); self.parse_single_class_item(ast::private);

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

@@ -310,10 +310,10 @@ pub impl Parser {
pure fn id_to_str(id: ident) -> @~str { self.sess.interner.get(id) } pure fn id_to_str(id: ident) -> @~str { self.sess.interner.get(id) }
fn token_is_closure_keyword(+tok: token::Token) -> bool { fn token_is_closure_keyword(+tok: token::Token) -> bool {
self.token_is_keyword(~"pure", tok) || self.token_is_keyword(&~"pure", tok) ||
self.token_is_keyword(~"unsafe", tok) || self.token_is_keyword(&~"unsafe", tok) ||
self.token_is_keyword(~"once", tok) || self.token_is_keyword(&~"once", tok) ||
self.token_is_keyword(~"fn", tok) self.token_is_keyword(&~"fn", tok)
} }
fn parse_ty_bare_fn() -> ty_ fn parse_ty_bare_fn() -> ty_
@@ -333,7 +333,7 @@ pub impl Parser {
*/ */
let purity = self.parse_purity(); let purity = self.parse_purity();
self.expect_keyword(~"fn"); self.expect_keyword(&~"fn");
return ty_bare_fn(@TyBareFn { return ty_bare_fn(@TyBareFn {
abi: RustAbi, abi: RustAbi,
purity: purity, purity: purity,
@@ -364,7 +364,7 @@ pub impl Parser {
let purity = self.parse_purity(); let purity = self.parse_purity();
let onceness = parse_onceness(&self); let onceness = parse_onceness(&self);
self.expect_keyword(~"fn"); self.expect_keyword(&~"fn");
let post_sigil = self.parse_fn_ty_sigil(); let post_sigil = self.parse_fn_ty_sigil();
let sigil = match (pre_sigil, post_sigil) { let sigil = match (pre_sigil, post_sigil) {
@@ -392,14 +392,14 @@ pub impl Parser {
}); });
fn parse_onceness(self: &Parser) -> Onceness { fn parse_onceness(self: &Parser) -> Onceness {
if self.eat_keyword(~"once") {Once} else {Many} if self.eat_keyword(&~"once") { Once } else { Many }
} }
} }
fn parse_purity() -> purity { fn parse_purity() -> purity {
if self.eat_keyword(~"pure") { if self.eat_keyword(&~"pure") {
return pure_fn; return pure_fn;
} else if self.eat_keyword(~"unsafe") { } else if self.eat_keyword(&~"unsafe") {
return unsafe_fn; return unsafe_fn;
} else { } else {
return impure_fn; return impure_fn;
@@ -640,7 +640,7 @@ pub impl Parser {
} else if *self.token == token::BINOP(token::AND) { } else if *self.token == token::BINOP(token::AND) {
self.bump(); self.bump();
self.parse_borrowed_pointee() self.parse_borrowed_pointee()
} else if self.eat_keyword(~"extern") { } else if self.eat_keyword(&~"extern") {
self.parse_ty_bare_fn() 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) self.parse_ty_closure(None, None)
@@ -648,7 +648,9 @@ pub impl Parser {
|| is_ident_or_path(*self.token) { || is_ident_or_path(*self.token) {
let path = self.parse_path_with_tps(colons_before_params); let path = self.parse_path_with_tps(colons_before_params);
ty_path(path, self.get_id()) ty_path(path, self.get_id())
} else { self.fatal(~"expected type"); }; } else {
self.fatal(~"expected type");
};
let sp = mk_sp(lo, self.last_span.hi); let sp = mk_sp(lo, self.last_span.hi);
@Ty {id: self.get_id(), node: t, span: sp} @Ty {id: self.get_id(), node: t, span: sp}
@@ -667,8 +669,10 @@ pub impl Parser {
token::IDENT(rname, _) => { token::IDENT(rname, _) => {
if self.look_ahead(1u) == token::BINOP(token::SLASH) && 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(); {
self.bump();
self.bump();
return self.parse_ty_closure(Some(sigil), Some(rname)); 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); return self.parse_ty_closure(Some(sigil), None);
@@ -756,7 +760,7 @@ pub impl Parser {
fn parse_capture_item_or(parse_arg_fn: fn(Parser) -> arg_or_capture_item) fn parse_capture_item_or(parse_arg_fn: fn(Parser) -> arg_or_capture_item)
-> arg_or_capture_item -> arg_or_capture_item
{ {
if self.eat_keyword(~"copy") { if self.eat_keyword(&~"copy") {
// XXX outdated syntax now that moves-based-on-type has gone in // XXX outdated syntax now that moves-based-on-type has gone in
self.parse_ident(); self.parse_ident();
either::Right(()) either::Right(())
@@ -772,7 +776,7 @@ pub impl Parser {
let mut is_mutbl = false; let mut is_mutbl = false;
let pat = if require_name || self.is_named_argument() { let pat = if require_name || self.is_named_argument() {
m = self.parse_arg_mode(); m = self.parse_arg_mode();
is_mutbl = self.eat_keyword(~"mut"); is_mutbl = self.eat_keyword(&~"mut");
let pat = self.parse_pat(false); let pat = self.parse_pat(false);
self.expect(token::COLON); self.expect(token::COLON);
pat pat
@@ -800,7 +804,7 @@ pub impl Parser {
fn parse_fn_block_arg() -> arg_or_capture_item { fn parse_fn_block_arg() -> arg_or_capture_item {
do self.parse_capture_item_or |p| { do self.parse_capture_item_or |p| {
let m = p.parse_arg_mode(); let m = p.parse_arg_mode();
let is_mutbl = self.eat_keyword(~"mut"); let is_mutbl = self.eat_keyword(&~"mut");
let pat = p.parse_pat(false); let pat = p.parse_pat(false);
let t = if p.eat(token::COLON) { let t = if p.eat(token::COLON) {
p.parse_ty(false) p.parse_ty(false)
@@ -856,9 +860,9 @@ pub impl Parser {
fn parse_lit() -> lit { fn parse_lit() -> lit {
let lo = self.span.lo; let lo = self.span.lo;
let lit = if self.eat_keyword(~"true") { let lit = if self.eat_keyword(&~"true") {
lit_bool(true) lit_bool(true)
} else if self.eat_keyword(~"false") { } else if self.eat_keyword(&~"false") {
lit_bool(false) lit_bool(false)
} else { } else {
// XXX: This is a really bad copy! // XXX: This is a really bad copy!
@@ -1024,9 +1028,9 @@ pub impl Parser {
} }
fn parse_mutability() -> mutability { fn parse_mutability() -> mutability {
if self.eat_keyword(~"mut") { if self.eat_keyword(&~"mut") {
m_mutbl m_mutbl
} else if self.eat_keyword(~"const") { } else if self.eat_keyword(&~"const") {
m_const m_const
} else { } else {
m_imm m_imm
@@ -1124,21 +1128,21 @@ pub impl Parser {
} }
} else if token::is_bar(*self.token) { } else if token::is_bar(*self.token) {
return self.parse_lambda_expr(); return self.parse_lambda_expr();
} else if self.eat_keyword(~"if") { } else if self.eat_keyword(&~"if") {
return self.parse_if_expr(); return self.parse_if_expr();
} else if self.eat_keyword(~"for") { } else if self.eat_keyword(&~"for") {
return self.parse_sugary_call_expr(~"for", ForSugar, return self.parse_sugary_call_expr(~"for", ForSugar,
expr_loop_body); expr_loop_body);
} else if self.eat_keyword(~"do") { } else if self.eat_keyword(&~"do") {
return self.parse_sugary_call_expr(~"do", DoSugar, return self.parse_sugary_call_expr(~"do", DoSugar,
expr_do_body); expr_do_body);
} else if self.eat_keyword(~"while") { } else if self.eat_keyword(&~"while") {
return self.parse_while_expr(); return self.parse_while_expr();
} else if self.eat_keyword(~"loop") { } else if self.eat_keyword(&~"loop") {
return self.parse_loop_expr(); return self.parse_loop_expr();
} else if self.eat_keyword(~"match") { } else if self.eat_keyword(&~"match") {
return self.parse_match_expr(); return self.parse_match_expr();
} else if self.eat_keyword(~"fn") { } else if self.eat_keyword(&~"fn") {
let opt_sigil = self.parse_fn_ty_sigil(); let opt_sigil = self.parse_fn_ty_sigil();
let sigil = match opt_sigil { let sigil = match opt_sigil {
None => { None => {
@@ -1147,7 +1151,7 @@ pub impl Parser {
Some(p) => { p } Some(p) => { p }
}; };
return self.parse_fn_expr(sigil); return self.parse_fn_expr(sigil);
} else if self.eat_keyword(~"unsafe") { } else if self.eat_keyword(&~"unsafe") {
return self.parse_block_expr(lo, unsafe_blk); return self.parse_block_expr(lo, unsafe_blk);
} else if *self.token == token::LBRACKET { } else if *self.token == token::LBRACKET {
self.bump(); self.bump();
@@ -1182,7 +1186,7 @@ pub impl Parser {
} }
} }
hi = self.span.hi; hi = self.span.hi;
} else if self.eat_keyword(~"log") { } else if self.eat_keyword(&~"log") {
self.expect(token::LPAREN); self.expect(token::LPAREN);
let lvl = self.parse_expr(); let lvl = self.parse_expr();
self.expect(token::COMMA); self.expect(token::COMMA);
@@ -1190,30 +1194,30 @@ pub impl Parser {
ex = expr_log(ast::log_other, lvl, e); ex = expr_log(ast::log_other, lvl, e);
hi = self.span.hi; hi = self.span.hi;
self.expect(token::RPAREN); self.expect(token::RPAREN);
} else if self.eat_keyword(~"assert") { } else if self.eat_keyword(&~"assert") {
let e = self.parse_expr(); let e = self.parse_expr();
ex = expr_assert(e); ex = expr_assert(e);
hi = e.span.hi; hi = e.span.hi;
} else if self.eat_keyword(~"return") { } else if self.eat_keyword(&~"return") {
if can_begin_expr(*self.token) { if can_begin_expr(*self.token) {
let e = self.parse_expr(); let e = self.parse_expr();
hi = e.span.hi; hi = e.span.hi;
ex = expr_ret(Some(e)); ex = expr_ret(Some(e));
} else { ex = expr_ret(None); } } else { ex = expr_ret(None); }
} else if self.eat_keyword(~"break") { } else if self.eat_keyword(&~"break") {
if is_ident(*self.token) { if is_ident(*self.token) {
ex = expr_break(Some(self.parse_ident())); ex = expr_break(Some(self.parse_ident()));
} else { } else {
ex = expr_break(None); ex = expr_break(None);
} }
hi = self.span.hi; hi = self.span.hi;
} else if self.eat_keyword(~"copy") { } else if self.eat_keyword(&~"copy") {
let e = self.parse_expr(); let e = self.parse_expr();
ex = expr_copy(e); ex = expr_copy(e);
hi = e.span.hi; hi = e.span.hi;
} else if *self.token == token::MOD_SEP || } else if *self.token == token::MOD_SEP ||
is_ident(*self.token) && !self.is_keyword(~"true") && is_ident(*self.token) && !self.is_keyword(&~"true") &&
!self.is_keyword(~"false") { !self.is_keyword(&~"false") {
let pth = self.parse_path_with_tps(true); let pth = self.parse_path_with_tps(true);
/* `!`, as an operator, is prefix, so we know this isn't that */ /* `!`, as an operator, is prefix, so we know this isn't that */
@@ -1642,7 +1646,7 @@ pub impl Parser {
} }
} }
None => { None => {
if as_prec > min_prec && self.eat_keyword(~"as") { if as_prec > min_prec && self.eat_keyword(&~"as") {
let rhs = self.parse_ty(true); let rhs = self.parse_ty(true);
let _as = self.mk_expr(lhs.span.lo, let _as = self.mk_expr(lhs.span.lo,
rhs.span.hi, rhs.span.hi,
@@ -1714,7 +1718,7 @@ pub impl Parser {
let thn = self.parse_block(); let thn = self.parse_block();
let mut els: Option<@expr> = None; let mut els: Option<@expr> = None;
let mut hi = thn.span.hi; let mut hi = thn.span.hi;
if self.eat_keyword(~"else") { if self.eat_keyword(&~"else") {
let elexpr = self.parse_else_expr(); let elexpr = self.parse_else_expr();
els = Some(elexpr); els = Some(elexpr);
hi = elexpr.span.hi; hi = elexpr.span.hi;
@@ -1788,7 +1792,7 @@ pub impl Parser {
} }
fn parse_else_expr() -> @expr { fn parse_else_expr() -> @expr {
if self.eat_keyword(~"if") { if self.eat_keyword(&~"if") {
return self.parse_if_expr(); return self.parse_if_expr();
} else { } else {
let blk = self.parse_block(); let blk = self.parse_block();
@@ -1904,7 +1908,7 @@ pub impl Parser {
fn looking_at_record_literal() -> bool { fn looking_at_record_literal() -> bool {
let lookahead = self.look_ahead(1); let lookahead = self.look_ahead(1);
*self.token == token::LBRACE && *self.token == token::LBRACE &&
(self.token_is_keyword(~"mut", lookahead) || (self.token_is_keyword(&~"mut", lookahead) ||
(is_plain_ident(lookahead) && (is_plain_ident(lookahead) &&
self.look_ahead(2) == token::COLON)) self.look_ahead(2) == token::COLON))
} }
@@ -1945,7 +1949,7 @@ pub impl Parser {
while *self.token != token::RBRACE { while *self.token != token::RBRACE {
let pats = self.parse_pats(); let pats = self.parse_pats();
let mut guard = None; let mut guard = None;
if self.eat_keyword(~"if") { guard = Some(self.parse_expr()); } if self.eat_keyword(&~"if") { guard = Some(self.parse_expr()); }
self.expect(token::FAT_ARROW); self.expect(token::FAT_ARROW);
let expr = self.parse_expr_res(RESTRICT_STMT_EXPR); let expr = self.parse_expr_res(RESTRICT_STMT_EXPR);
@@ -2210,8 +2214,8 @@ pub impl Parser {
} }
copy tok => { copy tok => {
if !is_ident_or_path(tok) if !is_ident_or_path(tok)
|| self.is_keyword(~"true") || self.is_keyword(&~"true")
|| self.is_keyword(~"false") || self.is_keyword(&~"false")
{ {
let val = self.parse_expr_res(RESTRICT_NO_BAR_OP); let val = self.parse_expr_res(RESTRICT_NO_BAR_OP);
if self.eat(token::DOTDOT) { if self.eat(token::DOTDOT) {
@@ -2220,10 +2224,10 @@ pub impl Parser {
} else { } else {
pat = pat_lit(val); pat = pat_lit(val);
} }
} else if self.eat_keyword(~"ref") { } else if self.eat_keyword(&~"ref") {
let mutbl = self.parse_mutability(); let mutbl = self.parse_mutability();
pat = self.parse_pat_ident(refutable, bind_by_ref(mutbl)); pat = self.parse_pat_ident(refutable, bind_by_ref(mutbl));
} else if self.eat_keyword(~"copy") { } else if self.eat_keyword(&~"copy") {
pat = self.parse_pat_ident(refutable, bind_by_copy); pat = self.parse_pat_ident(refutable, bind_by_copy);
} else { } else {
// XXX---refutable match bindings should work same as let // XXX---refutable match bindings should work same as let
@@ -2355,7 +2359,7 @@ pub impl Parser {
} }
fn parse_let() -> @decl { fn parse_let() -> @decl {
let is_mutbl = self.eat_keyword(~"mut"); let is_mutbl = self.eat_keyword(&~"mut");
let lo = self.span.lo; let lo = self.span.lo;
let mut locals = ~[self.parse_local(is_mutbl, true)]; let mut locals = ~[self.parse_local(is_mutbl, true)];
while self.eat(token::COMMA) { while self.eat(token::COMMA) {
@@ -2368,7 +2372,7 @@ pub impl Parser {
fn parse_instance_var(pr: visibility) -> @struct_field { fn parse_instance_var(pr: visibility) -> @struct_field {
let mut is_mutbl = struct_immutable; let mut is_mutbl = struct_immutable;
let lo = self.span.lo; let lo = self.span.lo;
if self.eat_keyword(~"mut") { if self.eat_keyword(&~"mut") {
is_mutbl = struct_mutable; is_mutbl = struct_mutable;
} }
if !is_plain_ident(*self.token) { if !is_plain_ident(*self.token) {
@@ -2395,9 +2399,9 @@ pub impl Parser {
} }
let lo = self.span.lo; let lo = self.span.lo;
if self.is_keyword(~"let") { if self.is_keyword(&~"let") {
check_expected_item(self, first_item_attrs); check_expected_item(self, first_item_attrs);
self.expect_keyword(~"let"); self.expect_keyword(&~"let");
let decl = self.parse_let(); let decl = self.parse_let();
return @spanned(lo, decl.span.hi, stmt_decl(decl, self.get_id())); return @spanned(lo, decl.span.hi, stmt_decl(decl, self.get_id()));
} else if is_ident(*self.token) } else if is_ident(*self.token)
@@ -2491,7 +2495,7 @@ pub impl Parser {
} }
let lo = self.span.lo; let lo = self.span.lo;
if self.eat_keyword(~"unsafe") { if self.eat_keyword(&~"unsafe") {
self.obsolete(*self.span, ObsoleteUnsafeBlock); self.obsolete(*self.span, ObsoleteUnsafeBlock);
} }
self.expect(token::LBRACE); self.expect(token::LBRACE);
@@ -2629,9 +2633,9 @@ pub impl Parser {
} }
fn parse_optional_purity() -> ast::purity { fn parse_optional_purity() -> ast::purity {
if self.eat_keyword(~"pure") { if self.eat_keyword(&~"pure") {
ast::pure_fn ast::pure_fn
} else if self.eat_keyword(~"unsafe") { } else if self.eat_keyword(&~"unsafe") {
ast::unsafe_fn ast::unsafe_fn
} else { } else {
ast::impure_fn ast::impure_fn
@@ -2639,7 +2643,7 @@ pub impl Parser {
} }
fn parse_optional_onceness() -> ast::Onceness { fn parse_optional_onceness() -> ast::Onceness {
if self.eat_keyword(~"once") { ast::Once } else { ast::Many } if self.eat_keyword(&~"once") { ast::Once } else { ast::Many }
} }
fn parse_optional_ty_param_bounds() -> @~[ty_param_bound] { fn parse_optional_ty_param_bounds() -> @~[ty_param_bound] {
@@ -2647,7 +2651,7 @@ pub impl Parser {
if self.eat(token::COLON) { if self.eat(token::COLON) {
loop { loop {
if self.eat(token::BINOP(token::AND)) { if self.eat(token::BINOP(token::AND)) {
if self.eat_keyword(~"static") { if self.eat_keyword(&~"static") {
bounds.push(RegionTyParamBound); bounds.push(RegionTyParamBound);
} else { } else {
self.span_err(*self.span, self.span_err(*self.span,
@@ -2760,10 +2764,10 @@ pub impl Parser {
fn maybe_parse_self_ty(cnstr: fn(+v: mutability) -> ast::self_ty_, fn maybe_parse_self_ty(cnstr: fn(+v: mutability) -> ast::self_ty_,
p: Parser) -> ast::self_ty_ { p: Parser) -> ast::self_ty_ {
// We need to make sure it isn't a mode or a type // We need to make sure it isn't a mode or a type
if p.token_is_keyword(~"self", p.look_ahead(1)) || if p.token_is_keyword(&~"self", p.look_ahead(1)) ||
((p.token_is_keyword(~"const", p.look_ahead(1)) || ((p.token_is_keyword(&~"const", p.look_ahead(1)) ||
p.token_is_keyword(~"mut", p.look_ahead(1))) && p.token_is_keyword(&~"mut", p.look_ahead(1))) &&
p.token_is_keyword(~"self", p.look_ahead(2))) { p.token_is_keyword(&~"self", p.look_ahead(2))) {
p.bump(); p.bump();
let mutability = p.parse_mutability(); let mutability = p.parse_mutability();
@@ -2975,7 +2979,7 @@ pub impl Parser {
let mut ty = self.parse_ty(false); let mut ty = self.parse_ty(false);
// Parse traits, if necessary. // Parse traits, if necessary.
let opt_trait = if self.eat_keyword(~"for") { let opt_trait = if self.eat_keyword(&~"for") {
// New-style trait. Reinterpret the type as a trait. // New-style trait. Reinterpret the type as a trait.
let opt_trait_ref = match ty.node { let opt_trait_ref = match ty.node {
ty_path(path, node_id) => { ty_path(path, node_id) => {
@@ -3184,11 +3188,11 @@ pub impl Parser {
let attrs = self.parse_outer_attributes(); let attrs = self.parse_outer_attributes();
if self.eat_keyword(~"priv") { if self.eat_keyword(&~"priv") {
return members(~[self.parse_single_class_item(private)]) return members(~[self.parse_single_class_item(private)])
} }
if self.eat_keyword(~"pub") { if self.eat_keyword(&~"pub") {
return members(~[self.parse_single_class_item(public)]); return members(~[self.parse_single_class_item(public)]);
} }
@@ -3196,7 +3200,7 @@ pub impl Parser {
return members(~[]); return members(~[]);
} }
if self.eat_keyword(~"drop") { if self.eat_keyword(&~"drop") {
return self.parse_dtor(attrs); return self.parse_dtor(attrs);
} }
else { else {
@@ -3205,12 +3209,12 @@ pub impl Parser {
} }
fn parse_visibility() -> visibility { fn parse_visibility() -> visibility {
if self.eat_keyword(~"pub") { public } if self.eat_keyword(&~"pub") { public }
else if self.eat_keyword(~"priv") { private } else if self.eat_keyword(&~"priv") { private }
else { inherited } else { inherited }
} }
fn parse_staticness() -> bool { fn parse_staticness() -> bool {
self.eat_keyword(~"static") self.eat_keyword(&~"static")
} }
// given a termination token and a vector of already-parsed // given a termination token and a vector of already-parsed
@@ -3412,7 +3416,7 @@ pub impl Parser {
fn parse_item_foreign_const(vis: ast::visibility, fn parse_item_foreign_const(vis: ast::visibility,
+attrs: ~[attribute]) -> @foreign_item { +attrs: ~[attribute]) -> @foreign_item {
let lo = self.span.lo; let lo = self.span.lo;
self.expect_keyword(~"const"); self.expect_keyword(&~"const");
let ident = self.parse_ident(); let ident = self.parse_ident();
self.expect(token::COLON); self.expect(token::COLON);
let ty = self.parse_ty(false); let ty = self.parse_ty(false);
@@ -3427,12 +3431,12 @@ pub impl Parser {
} }
fn parse_fn_purity() -> purity { fn parse_fn_purity() -> purity {
if self.eat_keyword(~"fn") { impure_fn } if self.eat_keyword(&~"fn") { impure_fn }
else if self.eat_keyword(~"pure") { else if self.eat_keyword(&~"pure") {
self.expect_keyword(~"fn"); self.expect_keyword(&~"fn");
pure_fn pure_fn
} else if self.eat_keyword(~"unsafe") { } else if self.eat_keyword(&~"unsafe") {
self.expect_keyword(~"fn"); self.expect_keyword(&~"fn");
unsafe_fn unsafe_fn
} }
else { self.unexpected(); } else { self.unexpected(); }
@@ -3440,7 +3444,7 @@ pub impl Parser {
fn parse_foreign_item(+attrs: ~[attribute]) -> @foreign_item { fn parse_foreign_item(+attrs: ~[attribute]) -> @foreign_item {
let vis = self.parse_visibility(); let vis = self.parse_visibility();
if self.is_keyword(~"const") { if self.is_keyword(&~"const") {
self.parse_item_foreign_const(vis, attrs) self.parse_item_foreign_const(vis, attrs)
} else { } else {
self.parse_item_foreign_fn(attrs) self.parse_item_foreign_fn(attrs)
@@ -3496,9 +3500,9 @@ pub impl Parser {
} }
let mut must_be_named_mod = false; let mut must_be_named_mod = false;
if self.is_keyword(~"mod") { if self.is_keyword(&~"mod") {
must_be_named_mod = true; must_be_named_mod = true;
self.expect_keyword(~"mod"); self.expect_keyword(&~"mod");
} else if *self.token != token::LBRACE { } else if *self.token != token::LBRACE {
self.span_fatal(*self.span, self.span_fatal(*self.span,
fmt!("expected `{` or `mod` but found %s", fmt!("expected `{` or `mod` but found %s",
@@ -3633,7 +3637,7 @@ pub impl Parser {
let vlo = self.span.lo; let vlo = self.span.lo;
// Is this a common field declaration? // Is this a common field declaration?
if self.eat_keyword(~"struct") { if self.eat_keyword(&~"struct") {
if common_fields.is_some() { if common_fields.is_some() {
self.fatal(~"duplicate declaration of shared fields"); self.fatal(~"duplicate declaration of shared fields");
} }
@@ -3647,7 +3651,7 @@ pub impl Parser {
// Is this a nested enum declaration? // Is this a nested enum declaration?
let ident, needs_comma, kind; let ident, needs_comma, kind;
let mut args = ~[], disr_expr = None; let mut args = ~[], disr_expr = None;
if self.eat_keyword(~"enum") { if self.eat_keyword(&~"enum") {
ident = self.parse_ident(); ident = self.parse_ident();
self.expect(token::LBRACE); self.expect(token::LBRACE);
let nested_enum_def = self.parse_enum_def(ty_params); let nested_enum_def = self.parse_enum_def(ty_params);
@@ -3778,57 +3782,57 @@ pub impl Parser {
let lo = self.span.lo; let lo = self.span.lo;
let visibility; let visibility;
if self.eat_keyword(~"pub") { if self.eat_keyword(&~"pub") {
visibility = public; visibility = public;
} else if self.eat_keyword(~"priv") { } else if self.eat_keyword(&~"priv") {
visibility = private; visibility = private;
} else { } else {
visibility = inherited; visibility = inherited;
} }
if items_allowed && self.eat_keyword(~"const") { if items_allowed && self.eat_keyword(&~"const") {
// CONST ITEM // CONST ITEM
let (ident, item_, extra_attrs) = self.parse_item_const(); let (ident, item_, extra_attrs) = self.parse_item_const();
return iovi_item(self.mk_item(lo, self.last_span.hi, ident, item_, return iovi_item(self.mk_item(lo, self.last_span.hi, ident, item_,
visibility, visibility,
maybe_append(attrs, extra_attrs))); maybe_append(attrs, extra_attrs)));
} else if foreign_items_allowed && self.is_keyword(~"const") { } else if foreign_items_allowed && self.is_keyword(&~"const") {
// FOREIGN CONST ITEM // FOREIGN CONST ITEM
let item = self.parse_item_foreign_const(visibility, attrs); let item = self.parse_item_foreign_const(visibility, attrs);
return iovi_foreign_item(item); return iovi_foreign_item(item);
} else if items_allowed && } else if items_allowed &&
// FUNCTION ITEM (not sure about lookahead condition...) // FUNCTION ITEM (not sure about lookahead condition...)
self.is_keyword(~"fn") && self.is_keyword(&~"fn") &&
!self.fn_expr_lookahead(self.look_ahead(1u)) { !self.fn_expr_lookahead(self.look_ahead(1u)) {
self.bump(); self.bump();
let (ident, item_, extra_attrs) = self.parse_item_fn(impure_fn); let (ident, item_, extra_attrs) = self.parse_item_fn(impure_fn);
return iovi_item(self.mk_item(lo, self.last_span.hi, ident, item_, return iovi_item(self.mk_item(lo, self.last_span.hi, ident, item_,
visibility, visibility,
maybe_append(attrs, extra_attrs))); maybe_append(attrs, extra_attrs)));
} else if items_allowed && self.eat_keyword(~"pure") { } else if items_allowed && self.eat_keyword(&~"pure") {
// PURE FUNCTION ITEM // PURE FUNCTION ITEM
self.expect_keyword(~"fn"); self.expect_keyword(&~"fn");
let (ident, item_, extra_attrs) = self.parse_item_fn(pure_fn); let (ident, item_, extra_attrs) = self.parse_item_fn(pure_fn);
return iovi_item(self.mk_item(lo, self.last_span.hi, ident, item_, return iovi_item(self.mk_item(lo, self.last_span.hi, ident, item_,
visibility, visibility,
maybe_append(attrs, extra_attrs))); maybe_append(attrs, extra_attrs)));
} else if foreign_items_allowed && } else if foreign_items_allowed &&
(self.is_keyword(~"fn") || self.is_keyword(~"pure") || (self.is_keyword(&~"fn") || self.is_keyword(&~"pure") ||
self.is_keyword(~"unsafe")) { self.is_keyword(&~"unsafe")) {
// FOREIGN FUNCTION ITEM (no items allowed) // FOREIGN FUNCTION ITEM (no items allowed)
let item = self.parse_item_foreign_fn(attrs); let item = self.parse_item_foreign_fn(attrs);
return iovi_foreign_item(item); return iovi_foreign_item(item);
} else if items_allowed && self.is_keyword(~"unsafe") } else if items_allowed && self.is_keyword(&~"unsafe")
&& self.look_ahead(1u) != token::LBRACE { && self.look_ahead(1u) != token::LBRACE {
// UNSAFE FUNCTION ITEM (where items are allowed) // UNSAFE FUNCTION ITEM (where items are allowed)
self.bump(); self.bump();
self.expect_keyword(~"fn"); self.expect_keyword(&~"fn");
let (ident, item_, extra_attrs) = self.parse_item_fn(unsafe_fn); let (ident, item_, extra_attrs) = self.parse_item_fn(unsafe_fn);
return iovi_item(self.mk_item(lo, self.last_span.hi, ident, item_, return iovi_item(self.mk_item(lo, self.last_span.hi, ident, item_,
visibility, visibility,
maybe_append(attrs, extra_attrs))); maybe_append(attrs, extra_attrs)));
} else if self.eat_keyword(~"extern") { } else if self.eat_keyword(&~"extern") {
if items_allowed && self.eat_keyword(~"fn") { if items_allowed && self.eat_keyword(&~"fn") {
// EXTERN FUNCTION ITEM // EXTERN FUNCTION ITEM
let (ident, item_, extra_attrs) = let (ident, item_, extra_attrs) =
self.parse_item_fn(extern_fn); self.parse_item_fn(extern_fn);
@@ -3840,43 +3844,43 @@ pub impl Parser {
// EXTERN MODULE ITEM // EXTERN MODULE ITEM
return self.parse_item_foreign_mod(lo, visibility, attrs, return self.parse_item_foreign_mod(lo, visibility, attrs,
items_allowed); items_allowed);
} else if items_allowed && self.eat_keyword(~"mod") { } else if items_allowed && self.eat_keyword(&~"mod") {
// MODULE ITEM // MODULE ITEM
let (ident, item_, extra_attrs) = self.parse_item_mod(attrs); let (ident, item_, extra_attrs) = self.parse_item_mod(attrs);
return iovi_item(self.mk_item(lo, self.last_span.hi, ident, item_, return iovi_item(self.mk_item(lo, self.last_span.hi, ident, item_,
visibility, visibility,
maybe_append(attrs, extra_attrs))); maybe_append(attrs, extra_attrs)));
} else if items_allowed && self.eat_keyword(~"type") { } else if items_allowed && self.eat_keyword(&~"type") {
// TYPE ITEM // TYPE ITEM
let (ident, item_, extra_attrs) = self.parse_item_type(); let (ident, item_, extra_attrs) = self.parse_item_type();
return iovi_item(self.mk_item(lo, self.last_span.hi, ident, item_, return iovi_item(self.mk_item(lo, self.last_span.hi, ident, item_,
visibility, visibility,
maybe_append(attrs, extra_attrs))); maybe_append(attrs, extra_attrs)));
} else if items_allowed && self.eat_keyword(~"enum") { } else if items_allowed && self.eat_keyword(&~"enum") {
// ENUM ITEM // ENUM ITEM
let (ident, item_, extra_attrs) = self.parse_item_enum(); let (ident, item_, extra_attrs) = self.parse_item_enum();
return iovi_item(self.mk_item(lo, self.last_span.hi, ident, item_, return iovi_item(self.mk_item(lo, self.last_span.hi, ident, item_,
visibility, visibility,
maybe_append(attrs, extra_attrs))); maybe_append(attrs, extra_attrs)));
} else if items_allowed && self.eat_keyword(~"trait") { } else if items_allowed && self.eat_keyword(&~"trait") {
// TRAIT ITEM // TRAIT ITEM
let (ident, item_, extra_attrs) = self.parse_item_trait(); let (ident, item_, extra_attrs) = self.parse_item_trait();
return iovi_item(self.mk_item(lo, self.last_span.hi, ident, item_, return iovi_item(self.mk_item(lo, self.last_span.hi, ident, item_,
visibility, visibility,
maybe_append(attrs, extra_attrs))); maybe_append(attrs, extra_attrs)));
} else if items_allowed && self.eat_keyword(~"impl") { } else if items_allowed && self.eat_keyword(&~"impl") {
// IMPL ITEM // IMPL ITEM
let (ident, item_, extra_attrs) = self.parse_item_impl(); let (ident, item_, extra_attrs) = self.parse_item_impl();
return iovi_item(self.mk_item(lo, self.last_span.hi, ident, item_, return iovi_item(self.mk_item(lo, self.last_span.hi, ident, item_,
visibility, visibility,
maybe_append(attrs, extra_attrs))); maybe_append(attrs, extra_attrs)));
} else if items_allowed && self.eat_keyword(~"struct") { } else if items_allowed && self.eat_keyword(&~"struct") {
// STRUCT ITEM // STRUCT ITEM
let (ident, item_, extra_attrs) = self.parse_item_struct(); let (ident, item_, extra_attrs) = self.parse_item_struct();
return iovi_item(self.mk_item(lo, self.last_span.hi, ident, item_, return iovi_item(self.mk_item(lo, self.last_span.hi, ident, item_,
visibility, visibility,
maybe_append(attrs, extra_attrs))); maybe_append(attrs, extra_attrs)));
} else if self.eat_keyword(~"use") { } else if self.eat_keyword(&~"use") {
// USE ITEM // USE ITEM
let view_item = self.parse_use(); let view_item = self.parse_use();
self.expect(token::SEMI); self.expect(token::SEMI);
@@ -3959,7 +3963,7 @@ pub impl Parser {
let lo = self.span.lo; let lo = self.span.lo;
let namespace; let namespace;
if self.eat_keyword(~"mod") { if self.eat_keyword(&~"mod") {
namespace = module_ns; namespace = module_ns;
} else { } else {
namespace = type_value_ns; namespace = type_value_ns;
@@ -4053,25 +4057,25 @@ pub impl Parser {
fn is_view_item() -> bool { fn is_view_item() -> bool {
let tok, next_tok; let tok, next_tok;
if !self.is_keyword(~"pub") && !self.is_keyword(~"priv") { if !self.is_keyword(&~"pub") && !self.is_keyword(&~"priv") {
tok = *self.token; tok = *self.token;
next_tok = self.look_ahead(1); next_tok = self.look_ahead(1);
} else { } else {
tok = self.look_ahead(1); tok = self.look_ahead(1);
next_tok = self.look_ahead(2); next_tok = self.look_ahead(2);
}; };
self.token_is_keyword(~"use", tok) self.token_is_keyword(&~"use", tok)
|| (self.token_is_keyword(~"extern", tok) && || (self.token_is_keyword(&~"extern", tok) &&
self.token_is_keyword(~"mod", next_tok)) self.token_is_keyword(&~"mod", next_tok))
} }
// parse a view item. // parse a view item.
fn parse_view_item(+attrs: ~[attribute], vis: visibility) -> @view_item { fn parse_view_item(+attrs: ~[attribute], vis: visibility) -> @view_item {
let lo = self.span.lo; let lo = self.span.lo;
let node = if self.eat_keyword(~"use") { let node = if self.eat_keyword(&~"use") {
self.parse_use() self.parse_use()
} else if self.eat_keyword(~"extern") { } else if self.eat_keyword(&~"extern") {
self.expect_keyword(~"mod"); self.expect_keyword(&~"mod");
let ident = self.parse_ident(); let ident = self.parse_ident();
let metadata = self.parse_optional_meta(); let metadata = self.parse_optional_meta();
view_item_extern_mod(ident, metadata, self.get_id()) view_item_extern_mod(ident, metadata, self.get_id())