bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Allow static strings to be used with keyword checks

Browse source
This commit is contained in:
Björn Steinbrink 2013-05-11 17:42:59 +02:00
parent 31cedf6927
commit 109bb7c78b
5 changed files with 131 additions and 127 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/libcore/hashmap.rs
View file

@ -825,6 +825,10 @@ pub impl <T:Hash + Eq> HashSet<T> {
fn consume(&mut self, f: &fn(T)) { fn consume(&mut self, f: &fn(T)) {
self.map.consume(|k, _| f(k)) self.map.consume(|k, _| f(k))
} }
fn contains_equiv<Q:Hash + Equiv<T>>(&self, value: &Q) -> bool {
self.map.contains_key_equiv(value)
}
} }
#[cfg(test)] #[cfg(test)]

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

@ -34,9 +34,9 @@ pub fn expand_trace_macros(cx: @ext_ctxt,
rdr.dup() 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

@ -137,27 +137,27 @@ pub impl Parser {
// 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
// NOTE: this could be done statically.... // NOTE: this could be done statically....
fn require_keyword(&self, word: &~str) { fn require_keyword(&self, word: &str) {
if !self.keywords.contains(word) { if !self.keywords.contains_equiv(&word) {
self.bug(fmt!("unknown keyword: %s", *word)); self.bug(fmt!("unknown keyword: %s", word));
} }
} }
// return true when this token represents the given string, and is not // return true when this token represents the given string, and is not
// followed immediately by :: . // followed immediately by :: .
fn token_is_word(&self, word: &~str, tok: &token::Token) -> bool { fn token_is_word(&self, word: &str, tok: &token::Token) -> bool {
match *tok { match *tok {
token::IDENT(sid, false) => { *self.id_to_str(sid) == *word } token::IDENT(sid, false) => { word == *self.id_to_str(sid) }
_ => { false } _ => { false }
} }
} }
fn token_is_keyword(&self, word: &~str, tok: &token::Token) -> bool { fn token_is_keyword(&self, 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(&self, word: &~str) -> bool { fn is_keyword(&self, word: &str) -> bool {
self.token_is_keyword(word, &copy *self.token) self.token_is_keyword(word, &copy *self.token)
} }
@ -177,10 +177,10 @@ pub impl Parser {
// if the given word is not a keyword, signal an error. // if the given word is not a keyword, signal an error.
// if the next token is the given keyword, eat it and return // if the next token is the given keyword, eat it and return
// true. Otherwise, return false. // true. Otherwise, return false.
fn eat_keyword(&self, word: &~str) -> bool { fn eat_keyword(&self, 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() }
@ -190,13 +190,13 @@ pub impl Parser {
// if the given word is not a keyword, signal an error. // if the given word is not a keyword, signal an error.
// if the next token is not the given word, signal an error. // if the next token is not the given word, signal an error.
// otherwise, eat it. // otherwise, eat it.
fn expect_keyword(&self, word: &~str) { fn expect_keyword(&self, word: &str) {
self.require_keyword(word); self.require_keyword(word);
if !self.eat_keyword(word) { if !self.eat_keyword(word) {
self.fatal( self.fatal(
fmt!( fmt!(
"expected `%s`, found `%s`", "expected `%s`, found `%s`",
*word, word,
self.this_token_to_str() self.this_token_to_str()
) )
); );
@ -204,8 +204,8 @@ pub impl Parser {
} }
// return true if the given string is a strict keyword // return true if the given string is a strict keyword
fn is_strict_keyword(&self, word: &~str) -> bool { fn is_strict_keyword(&self, word: &str) -> bool {
self.strict_keywords.contains(word) self.strict_keywords.contains_equiv(&word)
} }
// signal an error if the current token is a strict keyword // signal an error if the current token is a strict keyword
@ -213,23 +213,23 @@ pub impl Parser {
match *self.token { match *self.token {
token::IDENT(_, false) => { token::IDENT(_, false) => {
let w = token_to_str(self.reader, &copy *self.token); let w = token_to_str(self.reader, &copy *self.token);
self.check_strict_keywords_(&w); self.check_strict_keywords_(w);
} }
_ => () _ => ()
} }
} }
// signal an error if the given string is a strict keyword // signal an error if the given string is a strict keyword
fn check_strict_keywords_(&self, w: &~str) { fn check_strict_keywords_(&self, w: &str) {
if self.is_strict_keyword(w) { if self.is_strict_keyword(w) {
self.span_err(*self.last_span, self.span_err(*self.last_span,
fmt!("found `%s` in ident position", *w)); fmt!("found `%s` in ident position", w));
} }
} }
// return true if this is a reserved keyword // return true if this is a reserved keyword
fn is_reserved_keyword(&self, word: &~str) -> bool { fn is_reserved_keyword(&self, word: &str) -> bool {
self.reserved_keywords.contains(word) self.reserved_keywords.contains_equiv(&word)
} }
// signal an error if the current token is a reserved keyword // signal an error if the current token is a reserved keyword
@ -237,16 +237,16 @@ pub impl Parser {
match *self.token { match *self.token {
token::IDENT(_, false) => { token::IDENT(_, false) => {
let w = token_to_str(self.reader, &copy *self.token); let w = token_to_str(self.reader, &copy *self.token);
self.check_reserved_keywords_(&w); self.check_reserved_keywords_(w);
} }
_ => () _ => ()
} }
} }
// signal an error if the given string is a reserved keyword // signal an error if the given string is a reserved keyword
fn check_reserved_keywords_(&self, w: &~str) { fn check_reserved_keywords_(&self, w: &str) {
if self.is_reserved_keyword(w) { if self.is_reserved_keyword(w) {
self.fatal(fmt!("`%s` is a reserved keyword", *w)); self.fatal(fmt!("`%s` is a reserved keyword", w));
} }
} }

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

@ -302,9 +302,9 @@ pub impl Parser {
} }
fn try_parse_obsolete_priv_section(&self, attrs: &[attribute]) -> bool { fn try_parse_obsolete_priv_section(&self, attrs: &[attribute]) -> 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(copy *self.span, ObsoletePrivSection); self.obsolete(copy *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_struct_field(ast::private, attrs.to_owned()); self.parse_single_struct_field(ast::private, attrs.to_owned());

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

@ -338,10 +338,10 @@ pub impl Parser {
// is this one of the keywords that signals a closure type? // is this one of the keywords that signals a closure type?
fn token_is_closure_keyword(&self, tok: &token::Token) -> bool { fn token_is_closure_keyword(&self, 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 token_is_lifetime(&self, tok: &token::Token) -> bool { fn token_is_lifetime(&self, tok: &token::Token) -> bool {
@ -378,7 +378,7 @@ pub impl Parser {
let opt_abis = self.parse_opt_abis(); let opt_abis = self.parse_opt_abis();
let abis = opt_abis.get_or_default(AbiSet::Rust()); let abis = opt_abis.get_or_default(AbiSet::Rust());
let purity = self.parse_unsafety(); let purity = self.parse_unsafety();
self.expect_keyword(&~"fn"); self.expect_keyword("fn");
let (decl, lifetimes) = self.parse_ty_fn_decl(); let (decl, lifetimes) = self.parse_ty_fn_decl();
return ty_bare_fn(@TyBareFn { return ty_bare_fn(@TyBareFn {
abis: abis, abis: abis,
@ -413,7 +413,7 @@ pub impl Parser {
let purity = self.parse_unsafety(); let purity = self.parse_unsafety();
let onceness = parse_onceness(self); let onceness = parse_onceness(self);
self.expect_keyword(&~"fn"); self.expect_keyword("fn");
if self.parse_fn_ty_sigil().is_some() { if self.parse_fn_ty_sigil().is_some() {
self.obsolete(*self.span, ObsoletePostFnTySigil); self.obsolete(*self.span, ObsoletePostFnTySigil);
@ -431,7 +431,7 @@ pub impl Parser {
}); });
fn parse_onceness(this: &Parser) -> Onceness { fn parse_onceness(this: &Parser) -> Onceness {
if this.eat_keyword(&~"once") { if this.eat_keyword(~"once") {
Once Once
} else { } else {
Many Many
@ -441,10 +441,10 @@ pub impl Parser {
// looks like this should be called parse_unsafety // looks like this should be called parse_unsafety
fn parse_unsafety(&self) -> purity { fn parse_unsafety(&self) -> purity {
if self.eat_keyword(&~"pure") { if self.eat_keyword("pure") {
self.obsolete(*self.last_span, ObsoletePurity); self.obsolete(*self.last_span, ObsoletePurity);
return impure_fn; return impure_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;
@ -699,7 +699,7 @@ pub impl Parser {
// BORROWED POINTER // BORROWED POINTER
self.bump(); self.bump();
self.parse_borrowed_pointee() self.parse_borrowed_pointee()
} else if self.eat_keyword(&~"extern") { } else if self.eat_keyword("extern") {
// EXTERN FUNCTION // EXTERN FUNCTION
self.parse_ty_bare_fn() self.parse_ty_bare_fn()
} else if self.token_is_closure_keyword(&copy *self.token) { } else if self.token_is_closure_keyword(&copy *self.token) {
@ -823,7 +823,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() {
self.parse_arg_mode(); 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
@ -851,7 +851,7 @@ pub impl Parser {
// parse an argument in a lambda header e.g. |arg, arg| // parse an argument in a lambda header e.g. |arg, arg|
fn parse_fn_block_arg(&self) -> arg_or_capture_item { fn parse_fn_block_arg(&self) -> arg_or_capture_item {
self.parse_arg_mode(); self.parse_arg_mode();
let is_mutbl = self.eat_keyword(&~"mut"); let is_mutbl = self.eat_keyword("mut");
let pat = self.parse_pat(false); let pat = self.parse_pat(false);
let t = if self.eat(&token::COLON) { let t = if self.eat(&token::COLON) {
self.parse_ty(false) self.parse_ty(false)
@ -902,9 +902,9 @@ pub impl Parser {
// matches lit = true | false | token_lit // matches lit = true | false | token_lit
fn parse_lit(&self) -> lit { fn parse_lit(&self) -> 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!
@ -1140,15 +1140,15 @@ pub impl Parser {
} }
fn token_is_mutability(&self, tok: &token::Token) -> bool { fn token_is_mutability(&self, tok: &token::Token) -> bool {
self.token_is_keyword(&~"mut", tok) || self.token_is_keyword("mut", tok) ||
self.token_is_keyword(&~"const", tok) self.token_is_keyword("const", tok)
} }
// parse mutability declaration (mut/const/imm) // parse mutability declaration (mut/const/imm)
fn parse_mutability(&self) -> mutability { fn parse_mutability(&self) -> 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
@ -1246,30 +1246,30 @@ pub impl Parser {
expr_block(blk)); expr_block(blk));
} 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(&~"self") { } else if self.eat_keyword("self") {
ex = expr_self; ex = expr_self;
hi = self.span.hi; hi = self.span.hi;
} 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.token_is_lifetime(&*self.token) { } else if self.token_is_lifetime(&*self.token) {
let lifetime = self.get_lifetime(&*self.token); let lifetime = self.get_lifetime(&*self.token);
self.bump(); self.bump();
self.expect(&token::COLON); self.expect(&token::COLON);
self.expect_keyword(&~"loop"); self.expect_keyword("loop");
return self.parse_loop_expr(Some(lifetime)); return self.parse_loop_expr(Some(lifetime));
} else if self.eat_keyword(&~"loop") { } else if self.eat_keyword("loop") {
return self.parse_loop_expr(None); return self.parse_loop_expr(None);
} 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(&~"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();
@ -1309,7 +1309,7 @@ pub impl Parser {
} }
} }
hi = self.span.hi; hi = self.span.hi;
} else if self.eat_keyword(&~"__log") { } else if self.eat_keyword("__log") {
// LOG expression // LOG expression
self.expect(&token::LPAREN); self.expect(&token::LPAREN);
let lvl = self.parse_expr(); let lvl = self.parse_expr();
@ -1318,14 +1318,14 @@ pub impl Parser {
ex = expr_log(lvl, e); ex = expr_log(lvl, e);
hi = self.span.hi; hi = self.span.hi;
self.expect(&token::RPAREN); self.expect(&token::RPAREN);
} else if self.eat_keyword(&~"return") { } else if self.eat_keyword("return") {
// RETURN expression // RETURN expression
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") {
// BREAK expression // BREAK expression
if self.token_is_lifetime(&*self.token) { if self.token_is_lifetime(&*self.token) {
let lifetime = self.get_lifetime(&*self.token); let lifetime = self.get_lifetime(&*self.token);
@ -1335,14 +1335,14 @@ pub impl Parser {
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") {
// COPY expression // COPY expression
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
@ -1822,7 +1822,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,
@ -1896,7 +1896,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;
@ -1963,7 +1963,7 @@ pub impl Parser {
} }
fn parse_else_expr(&self) -> @expr { fn parse_else_expr(&self) -> @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();
@ -2077,7 +2077,7 @@ pub impl Parser {
fn looking_at_record_literal(&self) -> bool { fn looking_at_record_literal(&self) -> 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))
} }
@ -2090,7 +2090,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);
@ -2379,8 +2379,8 @@ pub impl Parser {
} }
ref tok => { ref 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")
{ {
// Parse an expression pattern or exp .. exp. // Parse an expression pattern or exp .. exp.
// //
@ -2399,11 +2399,11 @@ 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") {
// parse ref pat // parse ref pat
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") {
// parse copy pat // parse copy pat
pat = self.parse_pat_ident(refutable, bind_by_copy); pat = self.parse_pat_ident(refutable, bind_by_copy);
} else { } else {
@ -2552,7 +2552,7 @@ pub impl Parser {
// parse a "let" stmt // parse a "let" stmt
fn parse_let(&self) -> @decl { fn parse_let(&self) -> @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)]; let mut locals = ~[self.parse_local(is_mutbl)];
while self.eat(&token::COMMA) { while self.eat(&token::COMMA) {
@ -2566,7 +2566,7 @@ pub impl Parser {
pr: visibility, pr: visibility,
attrs: ~[attribute]) -> @struct_field { attrs: ~[attribute]) -> @struct_field {
let lo = self.span.lo; let lo = self.span.lo;
if self.eat_keyword(&~"mut") { if self.eat_keyword("mut") {
// Do nothing, for backwards compatibility. // Do nothing, for backwards compatibility.
// XXX: Remove after snapshot. // XXX: Remove after snapshot.
} }
@ -2596,9 +2596,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)
@ -2685,7 +2685,7 @@ pub impl Parser {
maybe_whole!(self, nt_block); maybe_whole!(self, nt_block);
let lo = self.span.lo; let lo = self.span.lo;
if self.eat_keyword(&~"unsafe") { if self.eat_keyword("unsafe") {
self.obsolete(copy *self.span, ObsoleteUnsafeBlock); self.obsolete(copy *self.span, ObsoleteUnsafeBlock);
} }
self.expect(&token::LBRACE); self.expect(&token::LBRACE);
@ -2700,7 +2700,7 @@ pub impl Parser {
maybe_whole!(pair_empty self, nt_block); maybe_whole!(pair_empty self, nt_block);
let lo = self.span.lo; let lo = self.span.lo;
if self.eat_keyword(&~"unsafe") { if self.eat_keyword("unsafe") {
self.obsolete(copy *self.span, ObsoleteUnsafeBlock); self.obsolete(copy *self.span, ObsoleteUnsafeBlock);
} }
self.expect(&token::LBRACE); self.expect(&token::LBRACE);
@ -2834,10 +2834,10 @@ pub impl Parser {
} }
fn parse_optional_purity(&self) -> ast::purity { fn parse_optional_purity(&self) -> ast::purity {
if self.eat_keyword(&~"pure") { if self.eat_keyword("pure") {
self.obsolete(*self.last_span, ObsoletePurity); self.obsolete(*self.last_span, ObsoletePurity);
ast::impure_fn ast::impure_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
@ -2845,7 +2845,7 @@ pub impl Parser {
} }
fn parse_optional_onceness(&self) -> ast::Onceness { fn parse_optional_onceness(&self) -> ast::Onceness {
if self.eat_keyword(&~"once") { ast::Once } else { ast::Many } if self.eat_keyword("once") { ast::Once } else { ast::Many }
} }
// matches optbounds = ( ( : ( boundseq )? )? ) // matches optbounds = ( ( : ( boundseq )? )? )
@ -3008,10 +3008,10 @@ pub impl Parser {
p: &Parser p: &Parser
) -> ast::self_ty_ { ) -> 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();
@ -3032,25 +3032,25 @@ pub impl Parser {
// //
// We already know that the current token is `&`. // We already know that the current token is `&`.
if (this.token_is_keyword(&~"self", &this.look_ahead(1))) { if (this.token_is_keyword("self", &this.look_ahead(1))) {
this.bump(); this.bump();
this.expect_self_ident(); this.expect_self_ident();
sty_region(None, m_imm) sty_region(None, m_imm)
} else if (this.token_is_mutability(&this.look_ahead(1)) && } else if (this.token_is_mutability(&this.look_ahead(1)) &&
this.token_is_keyword(&~"self", &this.look_ahead(2))) { this.token_is_keyword("self", &this.look_ahead(2))) {
this.bump(); this.bump();
let mutability = this.parse_mutability(); let mutability = this.parse_mutability();
this.expect_self_ident(); this.expect_self_ident();
sty_region(None, mutability) sty_region(None, mutability)
} else if (this.token_is_lifetime(&this.look_ahead(1)) && } else if (this.token_is_lifetime(&this.look_ahead(1)) &&
this.token_is_keyword(&~"self", &this.look_ahead(2))) { this.token_is_keyword("self", &this.look_ahead(2))) {
this.bump(); this.bump();
let lifetime = @this.parse_lifetime(); let lifetime = @this.parse_lifetime();
this.expect_self_ident(); this.expect_self_ident();
sty_region(Some(lifetime), m_imm) sty_region(Some(lifetime), m_imm)
} else if (this.token_is_lifetime(&this.look_ahead(1)) && } else if (this.token_is_lifetime(&this.look_ahead(1)) &&
this.token_is_mutability(&this.look_ahead(2)) && this.token_is_mutability(&this.look_ahead(2)) &&
this.token_is_keyword(&~"self", &this.look_ahead(3))) { this.token_is_keyword("self", &this.look_ahead(3))) {
this.bump(); this.bump();
let lifetime = @this.parse_lifetime(); let lifetime = @this.parse_lifetime();
let mutability = this.parse_mutability(); let mutability = this.parse_mutability();
@ -3259,7 +3259,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 could_be_trait && self.eat_keyword(&~"for") { let opt_trait = if could_be_trait && 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) => {
@ -3434,11 +3434,11 @@ pub impl Parser {
return ~[]; return ~[];
} }
if self.eat_keyword(&~"priv") { if self.eat_keyword("priv") {
return ~[self.parse_single_struct_field(private, attrs)] return ~[self.parse_single_struct_field(private, attrs)]
} }
if self.eat_keyword(&~"pub") { if self.eat_keyword("pub") {
return ~[self.parse_single_struct_field(public, attrs)]; return ~[self.parse_single_struct_field(public, attrs)];
} }
@ -3451,13 +3451,13 @@ pub impl Parser {
// parse visiility: PUB, PRIV, or nothing // parse visiility: PUB, PRIV, or nothing
fn parse_visibility(&self) -> visibility { fn parse_visibility(&self) -> 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(&self) -> bool { fn parse_staticness(&self) -> bool {
if self.eat_keyword(&~"static") { if self.eat_keyword("static") {
self.obsolete(*self.last_span, ObsoleteStaticMethod); self.obsolete(*self.last_span, ObsoleteStaticMethod);
true true
} else { } else {
@ -3677,10 +3677,10 @@ pub impl Parser {
let lo = self.span.lo; let lo = self.span.lo;
// XXX: Obsolete; remove after snap. // XXX: Obsolete; remove after snap.
if self.eat_keyword(&~"const") { if self.eat_keyword("const") {
self.obsolete(*self.last_span, ObsoleteConstItem); self.obsolete(*self.last_span, ObsoleteConstItem);
} else { } else {
self.expect_keyword(&~"static"); self.expect_keyword("static");
} }
let ident = self.parse_ident(); let ident = self.parse_ident();
@ -3698,14 +3698,14 @@ pub impl Parser {
// parse safe/unsafe and fn // parse safe/unsafe and fn
fn parse_fn_purity(&self) -> purity { fn parse_fn_purity(&self) -> 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.obsolete(*self.last_span, ObsoletePurity); self.obsolete(*self.last_span, ObsoletePurity);
self.expect_keyword(&~"fn"); self.expect_keyword("fn");
// NB: We parse this as impure for bootstrapping purposes. // NB: We parse this as impure for bootstrapping purposes.
impure_fn impure_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(); }
@ -3743,9 +3743,9 @@ pub impl Parser {
items_allowed: bool) items_allowed: bool)
-> item_or_view_item { -> item_or_view_item {
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_fatal(
copy *self.span, copy *self.span,
@ -4030,7 +4030,7 @@ pub impl Parser {
let visibility = self.parse_visibility(); let visibility = self.parse_visibility();
// must be a view item: // must be a view item:
if self.eat_keyword(&~"use") { if self.eat_keyword("use") {
// USE ITEM (iovi_view_item) // USE ITEM (iovi_view_item)
let view_item = self.parse_use(); let view_item = self.parse_use();
self.expect(&token::SEMI); self.expect(&token::SEMI);
@ -4042,10 +4042,10 @@ pub impl Parser {
}); });
} }
// either a view item or an item: // either a view item or an item:
if self.eat_keyword(&~"extern") { if self.eat_keyword("extern") {
let opt_abis = self.parse_opt_abis(); let opt_abis = self.parse_opt_abis();
if self.eat_keyword(&~"fn") { if self.eat_keyword("fn") {
// EXTERN FUNCTION ITEM // EXTERN FUNCTION ITEM
let abis = opt_abis.get_or_default(AbiSet::C()); let abis = opt_abis.get_or_default(AbiSet::C());
let (ident, item_, extra_attrs) = let (ident, item_, extra_attrs) =
@ -4061,11 +4061,11 @@ pub impl Parser {
} }
} }
// the rest are all guaranteed to be items: // the rest are all guaranteed to be items:
if (self.is_keyword(&~"const") || if (self.is_keyword("const") ||
(self.is_keyword(&~"static") && (self.is_keyword("static") &&
!self.token_is_keyword(&~"fn", &self.look_ahead(1)))) { !self.token_is_keyword("fn", &self.look_ahead(1)))) {
// CONST / STATIC ITEM // CONST / STATIC ITEM
if self.is_keyword(&~"const") { if self.is_keyword("const") {
self.obsolete(*self.span, ObsoleteConstItem); self.obsolete(*self.span, ObsoleteConstItem);
} }
self.bump(); self.bump();
@ -4074,7 +4074,7 @@ pub impl Parser {
visibility, visibility,
maybe_append(attrs, extra_attrs))); maybe_append(attrs, extra_attrs)));
} }
if self.is_keyword(&~"fn") && if self.is_keyword("fn") &&
!self.fn_expr_lookahead(self.look_ahead(1u)) { !self.fn_expr_lookahead(self.look_ahead(1u)) {
// FUNCTION ITEM // FUNCTION ITEM
self.bump(); self.bump();
@ -4084,28 +4084,28 @@ pub impl Parser {
visibility, visibility,
maybe_append(attrs, extra_attrs))); maybe_append(attrs, extra_attrs)));
} }
if self.eat_keyword(&~"pure") { if self.eat_keyword("pure") {
// PURE FUNCTION ITEM (obsolete) // PURE FUNCTION ITEM (obsolete)
self.obsolete(*self.last_span, ObsoletePurity); self.obsolete(*self.last_span, ObsoletePurity);
self.expect_keyword(&~"fn"); self.expect_keyword("fn");
let (ident, item_, extra_attrs) = let (ident, item_, extra_attrs) =
self.parse_item_fn(impure_fn, AbiSet::Rust()); self.parse_item_fn(impure_fn, AbiSet::Rust());
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)));
} }
if self.is_keyword(&~"unsafe") if self.is_keyword("unsafe")
&& self.look_ahead(1u) != token::LBRACE { && self.look_ahead(1u) != token::LBRACE {
// UNSAFE FUNCTION ITEM // UNSAFE FUNCTION ITEM
self.bump(); self.bump();
self.expect_keyword(&~"fn"); self.expect_keyword("fn");
let (ident, item_, extra_attrs) = let (ident, item_, extra_attrs) =
self.parse_item_fn(unsafe_fn, AbiSet::Rust()); self.parse_item_fn(unsafe_fn, AbiSet::Rust());
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)));
} }
if self.eat_keyword(&~"mod") { if self.eat_keyword("mod") {
// MODULE ITEM // MODULE ITEM
let (ident, item_, extra_attrs) = let (ident, item_, extra_attrs) =
self.parse_item_mod(/*bad*/ copy attrs); self.parse_item_mod(/*bad*/ copy attrs);
@ -4113,28 +4113,28 @@ pub impl Parser {
visibility, visibility,
maybe_append(attrs, extra_attrs))); maybe_append(attrs, extra_attrs)));
} }
if self.eat_keyword(&~"type") { if 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)));
} }
if self.eat_keyword(&~"enum") { if 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)));
} }
if self.eat_keyword(&~"trait") { if 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)));
} }
if self.eat_keyword(&~"impl") { if self.eat_keyword("impl") {
// IMPL ITEM // IMPL ITEM
let (ident, item_, extra_attrs) = let (ident, item_, extra_attrs) =
self.parse_item_impl(visibility); self.parse_item_impl(visibility);
@ -4142,7 +4142,7 @@ pub impl Parser {
visibility, visibility,
maybe_append(attrs, extra_attrs))); maybe_append(attrs, extra_attrs)));
} }
if self.eat_keyword(&~"struct") { if 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_,
@ -4163,13 +4163,13 @@ pub impl Parser {
let visibility = self.parse_visibility(); let visibility = self.parse_visibility();
if (self.is_keyword(&~"const") || self.is_keyword(&~"static")) { if (self.is_keyword("const") || self.is_keyword("static")) {
// 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);
} }
if (self.is_keyword(&~"fn") || self.is_keyword(&~"pure") || if (self.is_keyword("fn") || self.is_keyword("pure") ||
self.is_keyword(&~"unsafe")) { self.is_keyword("unsafe")) {
// FOREIGN FUNCTION ITEM // FOREIGN FUNCTION ITEM
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);
@ -4360,16 +4360,16 @@ pub impl Parser {
fn is_view_item(&self) -> bool { fn is_view_item(&self) -> 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 = copy *self.token; tok = copy *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.
@ -4379,10 +4379,10 @@ pub impl Parser {
vis: visibility vis: visibility
) -> @view_item { ) -> @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())