bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

libsyntax: De-@mut Parser::span

Browse source
This commit is contained in:
Patrick Walton 2013-12-30 15:17:53 -08:00
parent 758d854436
commit 0c6cee55ea
3 changed files with 54 additions and 52 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -86,13 +86,13 @@ impl<'a> Context<'a> {
i i
} }
_ if named => { _ if named => {
self.ecx.span_err(*p.span, self.ecx.span_err(p.span,
"expected ident, positional arguments \ "expected ident, positional arguments \
cannot follow named arguments"); cannot follow named arguments");
return (extra, None); return (extra, None);
} }
_ => { _ => {
self.ecx.span_err(*p.span, self.ecx.span_err(p.span,
format!("expected ident for named \ format!("expected ident for named \
argument, but found `{}`", argument, but found `{}`",
p.this_token_to_str())); p.this_token_to_str()));

2
src/libsyntax/ext/tt/macro_rules.rs
View file

@ -48,7 +48,7 @@ impl ParserAnyMacro {
let msg = format!("macro expansion ignores token `{}` and any \ let msg = format!("macro expansion ignores token `{}` and any \
following", following",
token_str); token_str);
let span = *parser.get().span; let span = parser.get().span;
parser.get().span_err(span, msg); parser.get().span_err(span, msg);
} }
} }

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

@ -304,7 +304,7 @@ pub fn Parser(sess: @mut ParseSess,
sess: sess, sess: sess,
cfg: cfg, cfg: cfg,
token: tok0.tok, token: tok0.tok,
span: @mut span, span: span,
last_span: @mut span, last_span: @mut span,
last_token: @mut None, last_token: @mut None,
buffer: @mut ([ buffer: @mut ([
@ -332,7 +332,7 @@ pub struct Parser {
// the current token: // the current token:
token: token::Token, token: token::Token,
// the span of the current token: // the span of the current token:
span: @mut Span, span: Span,
// the span of the prior token: // the span of the prior token:
last_span: @mut Span, last_span: @mut Span,
// the previous token or None (only stashed sometimes). // the previous token or None (only stashed sometimes).
@ -434,7 +434,7 @@ impl Parser {
&& expected.iter().all(|t| *t != token::LBRACE) && expected.iter().all(|t| *t != token::LBRACE)
&& self.look_ahead(1, |t| *t == token::RBRACE) { && self.look_ahead(1, |t| *t == token::RBRACE) {
// matched; signal non-fatal error and recover. // matched; signal non-fatal error and recover.
self.span_err(*self.span, self.span_err(self.span,
"Unit-like struct construction is written with no trailing `{ }`"); "Unit-like struct construction is written with no trailing `{ }`");
self.eat(&token::LBRACE); self.eat(&token::LBRACE);
self.eat(&token::RBRACE); self.eat(&token::RBRACE);
@ -547,7 +547,7 @@ impl Parser {
pub fn check_strict_keywords(&mut self) { pub fn check_strict_keywords(&mut self) {
if token::is_strict_keyword(&self.token) { if token::is_strict_keyword(&self.token) {
let token_str = self.this_token_to_str(); let token_str = self.this_token_to_str();
self.span_err(*self.span, self.span_err(self.span,
format!("found `{}` in ident position", token_str)); format!("found `{}` in ident position", token_str));
} }
} }
@ -566,9 +566,8 @@ impl Parser {
match self.token { match self.token {
token::BINOP(token::OR) => self.bump(), token::BINOP(token::OR) => self.bump(),
token::OROR => { token::OROR => {
self.replace_token(token::BINOP(token::OR), let lo = self.span.lo + BytePos(1);
self.span.lo + BytePos(1), self.replace_token(token::BINOP(token::OR), lo, self.span.hi)
self.span.hi)
} }
_ => { _ => {
let token_str = self.this_token_to_str(); let token_str = self.this_token_to_str();
@ -608,11 +607,10 @@ impl Parser {
pub fn expect_gt(&mut self) { pub fn expect_gt(&mut self) {
match self.token { match self.token {
token::GT => self.bump(), token::GT => self.bump(),
token::BINOP(token::SHR) => self.replace_token( token::BINOP(token::SHR) => {
token::GT, let lo = self.span.lo + BytePos(1);
self.span.lo + BytePos(1), self.replace_token(token::GT, lo, self.span.hi)
self.span.hi }
),
_ => { _ => {
let gt_str = Parser::token_to_str(&token::GT); let gt_str = Parser::token_to_str(&token::GT);
let this_token_str = self.this_token_to_str(); let this_token_str = self.this_token_to_str();
@ -730,7 +728,7 @@ impl Parser {
// advance the parser by one token // advance the parser by one token
pub fn bump(&mut self) { pub fn bump(&mut self) {
*self.last_span = *self.span; *self.last_span = self.span;
// Stash token for error recovery (sometimes; clone is not necessarily cheap). // Stash token for error recovery (sometimes; clone is not necessarily cheap).
*self.last_token = if is_ident_or_path(&self.token) { *self.last_token = if is_ident_or_path(&self.token) {
Some(~self.token.clone()) Some(~self.token.clone())
@ -747,11 +745,11 @@ impl Parser {
let placeholder = TokenAndSpan { let placeholder = TokenAndSpan {
tok: token::UNDERSCORE, tok: token::UNDERSCORE,
sp: *self.span, sp: self.span,
}; };
util::replace(&mut self.buffer[buffer_start], placeholder) util::replace(&mut self.buffer[buffer_start], placeholder)
}; };
*self.span = next.sp; self.span = next.sp;
self.token = next.tok; self.token = next.tok;
*self.tokens_consumed += 1u; *self.tokens_consumed += 1u;
} }
@ -769,7 +767,7 @@ impl Parser {
lo: BytePos, lo: BytePos,
hi: BytePos) { hi: BytePos) {
self.token = next; self.token = next;
*self.span = mk_sp(lo, hi); self.span = mk_sp(lo, hi);
} }
pub fn buffer_length(&mut self) -> int { pub fn buffer_length(&mut self) -> int {
if *self.buffer_start <= *self.buffer_end { if *self.buffer_start <= *self.buffer_end {
@ -787,7 +785,7 @@ impl Parser {
f(&self.buffer[(*self.buffer_start + dist - 1) & 3].tok) f(&self.buffer[(*self.buffer_start + dist - 1) & 3].tok)
} }
pub fn fatal(&mut self, m: &str) -> ! { pub fn fatal(&mut self, m: &str) -> ! {
self.sess.span_diagnostic.span_fatal(*self.span, m) self.sess.span_diagnostic.span_fatal(self.span, m)
} }
pub fn span_fatal(&mut self, sp: Span, m: &str) -> ! { pub fn span_fatal(&mut self, sp: Span, m: &str) -> ! {
self.sess.span_diagnostic.span_fatal(sp, m) self.sess.span_diagnostic.span_fatal(sp, m)
@ -796,10 +794,10 @@ impl Parser {
self.sess.span_diagnostic.span_note(sp, m) self.sess.span_diagnostic.span_note(sp, m)
} }
pub fn bug(&mut self, m: &str) -> ! { pub fn bug(&mut self, m: &str) -> ! {
self.sess.span_diagnostic.span_bug(*self.span, m) self.sess.span_diagnostic.span_bug(self.span, m)
} }
pub fn warn(&mut self, m: &str) { pub fn warn(&mut self, m: &str) {
self.sess.span_diagnostic.span_warn(*self.span, m) self.sess.span_diagnostic.span_warn(self.span, m)
} }
pub fn span_err(&mut self, sp: Span, m: &str) { pub fn span_err(&mut self, sp: Span, m: &str) {
self.sess.span_diagnostic.span_err(sp, m) self.sess.span_diagnostic.span_err(sp, m)
@ -1047,7 +1045,7 @@ impl Parser {
let attrs = p.parse_outer_attributes(); let attrs = p.parse_outer_attributes();
let lo = p.span.lo; let lo = p.span.lo;
let vis_span = *p.span; let vis_span = p.span;
let vis = p.parse_visibility(); let vis = p.parse_visibility();
let pur = p.parse_fn_purity(); let pur = p.parse_fn_purity();
// NB: at the moment, trait methods are public by default; this // NB: at the moment, trait methods are public by default; this
@ -1590,7 +1588,7 @@ impl Parser {
pub fn parse_lifetime(&mut self) -> ast::Lifetime { pub fn parse_lifetime(&mut self) -> ast::Lifetime {
match self.token { match self.token {
token::LIFETIME(i) => { token::LIFETIME(i) => {
let span = *self.span; let span = self.span;
self.bump(); self.bump();
return ast::Lifetime { return ast::Lifetime {
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
@ -1722,7 +1720,7 @@ impl Parser {
} }
pub fn mk_lit_u32(&mut self, i: u32) -> @Expr { pub fn mk_lit_u32(&mut self, i: u32) -> @Expr {
let span = self.span; let span = &self.span;
let lv_lit = @codemap::Spanned { let lv_lit = @codemap::Spanned {
node: lit_uint(i as u64, ty_u32), node: lit_uint(i as u64, ty_u32),
span: *span span: *span
@ -2105,7 +2103,7 @@ impl Parser {
/* we ought to allow different depths of unquotation */ /* we ought to allow different depths of unquotation */
token::DOLLAR if p.quote_depth > 0u => { token::DOLLAR if p.quote_depth > 0u => {
p.bump(); p.bump();
let sp = *p.span; let sp = p.span;
if p.token == token::LPAREN { if p.token == token::LPAREN {
let seq = p.parse_seq( let seq = p.parse_seq(
@ -2136,7 +2134,7 @@ impl Parser {
// turn the next token into a tt_tok: // turn the next token into a tt_tok:
fn parse_any_tt_tok(p: &mut Parser) -> token_tree{ fn parse_any_tt_tok(p: &mut Parser) -> token_tree{
tt_tok(*p.span, p.bump_and_get()) tt_tok(p.span, p.bump_and_get())
} }
match self.token { match self.token {
@ -2152,7 +2150,7 @@ impl Parser {
let close_delim = token::flip_delimiter(&self.token); let close_delim = token::flip_delimiter(&self.token);
// Parse the open delimiter. // Parse the open delimiter.
(*self.open_braces).push(*self.span); (*self.open_braces).push(self.span);
let mut result = ~[parse_any_tt_tok(self)]; let mut result = ~[parse_any_tt_tok(self)];
let trees = let trees =
@ -2430,7 +2428,7 @@ impl Parser {
self.mk_expr(lo, rhs.span.hi, assign_op) self.mk_expr(lo, rhs.span.hi, assign_op)
} }
token::DARROW => { token::DARROW => {
self.obsolete(*self.span, ObsoleteSwap); self.obsolete(self.span, ObsoleteSwap);
self.bump(); self.bump();
// Ignore what we get, this is an error anyway // Ignore what we get, this is an error anyway
self.parse_expr(); self.parse_expr();
@ -2472,7 +2470,7 @@ impl Parser {
output: P(Ty { output: P(Ty {
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
node: ty_infer, node: ty_infer,
span: *p.span span: p.span
}), }),
cf: return_val, cf: return_val,
variadic: false variadic: false
@ -2758,13 +2756,13 @@ impl Parser {
slice = Some(@ast::Pat { slice = Some(@ast::Pat {
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
node: PatWildMulti, node: PatWildMulti,
span: *self.span, span: self.span,
}) })
} else { } else {
let subpat = self.parse_pat(); let subpat = self.parse_pat();
match subpat { match subpat {
@ast::Pat { id, node: PatWild, span } => { @ast::Pat { id, node: PatWild, span } => {
self.obsolete(*self.span, ObsoleteVecDotDotWildcard); self.obsolete(self.span, ObsoleteVecDotDotWildcard);
slice = Some(@ast::Pat { slice = Some(@ast::Pat {
id: id, id: id,
node: PatWildMulti, node: PatWildMulti,
@ -2808,7 +2806,7 @@ impl Parser {
etc = self.token == token::UNDERSCORE || self.token == token::DOTDOT; etc = self.token == token::UNDERSCORE || self.token == token::DOTDOT;
if self.token == token::UNDERSCORE { if self.token == token::UNDERSCORE {
self.obsolete(*self.span, ObsoleteStructWildcard); self.obsolete(self.span, ObsoleteStructWildcard);
} }
if etc { if etc {
self.bump(); self.bump();
@ -3093,7 +3091,7 @@ impl Parser {
// This is a "top constructor only" pat // This is a "top constructor only" pat
self.bump(); self.bump();
if is_star { if is_star {
self.obsolete(*self.span, ObsoleteEnumWildcard); self.obsolete(self.span, ObsoleteEnumWildcard);
} }
self.bump(); self.bump();
self.expect(&token::RPAREN); self.expect(&token::RPAREN);
@ -3193,7 +3191,7 @@ impl Parser {
let local = self.parse_local(); let local = self.parse_local();
while self.eat(&token::COMMA) { while self.eat(&token::COMMA) {
let _ = self.parse_local(); let _ = self.parse_local();
self.obsolete(*self.span, ObsoleteMultipleLocalDecl); self.obsolete(self.span, ObsoleteMultipleLocalDecl);
} }
return @spanned(lo, self.last_span.hi, DeclLocal(local)); return @spanned(lo, self.last_span.hi, DeclLocal(local));
} }
@ -3324,7 +3322,7 @@ impl Parser {
let lo = self.span.lo; let lo = self.span.lo;
if self.eat_keyword(keywords::Unsafe) { if self.eat_keyword(keywords::Unsafe) {
self.obsolete(*self.span, ObsoleteUnsafeBlock); self.obsolete(self.span, ObsoleteUnsafeBlock);
} }
self.expect(&token::LBRACE); self.expect(&token::LBRACE);
@ -3339,7 +3337,7 @@ impl Parser {
let lo = self.span.lo; let lo = self.span.lo;
if self.eat_keyword(keywords::Unsafe) { if self.eat_keyword(keywords::Unsafe) {
self.obsolete(*self.span, ObsoleteUnsafeBlock); self.obsolete(self.span, ObsoleteUnsafeBlock);
} }
self.expect(&token::LBRACE); self.expect(&token::LBRACE);
let (inner, next) = self.parse_inner_attrs_and_next(); let (inner, next) = self.parse_inner_attrs_and_next();
@ -3497,7 +3495,7 @@ impl Parser {
if "static" == self.id_to_str(lifetime) { if "static" == self.id_to_str(lifetime) {
result.push(RegionTyParamBound); result.push(RegionTyParamBound);
} else { } else {
self.span_err(*self.span, self.span_err(self.span,
"`'static` is the only permissible region bound here"); "`'static` is the only permissible region bound here");
} }
self.bump(); self.bump();
@ -3552,7 +3550,7 @@ impl Parser {
fn parse_fn_args(&mut self, named_args: bool, allow_variadic: bool) fn parse_fn_args(&mut self, named_args: bool, allow_variadic: bool)
-> (~[arg], bool) { -> (~[arg], bool) {
let sp = *self.span; let sp = self.span;
let mut args: ~[Option<arg>] = let mut args: ~[Option<arg>] =
self.parse_unspanned_seq( self.parse_unspanned_seq(
&token::LPAREN, &token::LPAREN,
@ -3563,11 +3561,11 @@ impl Parser {
p.bump(); p.bump();
if allow_variadic { if allow_variadic {
if p.token != token::RPAREN { if p.token != token::RPAREN {
p.span_fatal(*p.span, p.span_fatal(p.span,
"`...` must be last in argument list for variadic function"); "`...` must be last in argument list for variadic function");
} }
} else { } else {
p.span_fatal(*p.span, p.span_fatal(p.span,
"only foreign functions are allowed to be variadic"); "only foreign functions are allowed to be variadic");
} }
None None
@ -3729,7 +3727,7 @@ impl Parser {
self.parse_mutability() self.parse_mutability()
} else { MutImmutable }; } else { MutImmutable };
if self.is_self_ident() { if self.is_self_ident() {
self.span_err(*self.span, "cannot pass self by unsafe pointer"); self.span_err(self.span, "cannot pass self by unsafe pointer");
self.bump(); self.bump();
} }
sty_value(mutability) sty_value(mutability)
@ -3815,7 +3813,11 @@ impl Parser {
let output = if self.eat(&token::RARROW) { let output = if self.eat(&token::RARROW) {
self.parse_ty(false) self.parse_ty(false)
} else { } else {
P(Ty { id: ast::DUMMY_NODE_ID, node: ty_infer, span: *self.span }) P(Ty {
id: ast::DUMMY_NODE_ID,
node: ty_infer,
span: self.span,
})
}; };
P(ast::fn_decl { P(ast::fn_decl {
@ -3840,7 +3842,7 @@ impl Parser {
P(Ty { P(Ty {
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
node: ty_infer, node: ty_infer,
span: *self.span, span: self.span,
}) })
}; };
@ -4087,7 +4089,7 @@ impl Parser {
token::RBRACE => {} token::RBRACE => {}
_ => { _ => {
let token_str = self.this_token_to_str(); let token_str = self.this_token_to_str();
self.span_fatal(*self.span, self.span_fatal(self.span,
format!("expected `,`, or `\\}` but found `{}`", format!("expected `,`, or `\\}` but found `{}`",
token_str)) token_str))
} }
@ -4183,7 +4185,7 @@ impl Parser {
// parse a `mod <foo> { ... }` or `mod <foo>;` item // parse a `mod <foo> { ... }` or `mod <foo>;` item
fn parse_item_mod(&mut self, outer_attrs: &[Attribute]) -> item_info { fn parse_item_mod(&mut self, outer_attrs: &[Attribute]) -> item_info {
let id_span = *self.span; let id_span = self.span;
let id = self.parse_ident(); let id = self.parse_ident();
if self.token == token::SEMI { if self.token == token::SEMI {
self.bump(); self.bump();
@ -4221,7 +4223,7 @@ impl Parser {
outer_attrs: &[ast::Attribute], outer_attrs: &[ast::Attribute],
id_sp: Span) id_sp: Span)
-> (ast::item_, ~[ast::Attribute]) { -> (ast::item_, ~[ast::Attribute]) {
let mut prefix = Path::new(self.sess.cm.span_to_filename(*self.span)); let mut prefix = Path::new(self.sess.cm.span_to_filename(self.span));
prefix.pop(); prefix.pop();
let mod_path_stack = &*self.mod_path_stack; let mod_path_stack = &*self.mod_path_stack;
let mod_path = Path::new(".").join_many(*mod_path_stack); let mod_path = Path::new(".").join_many(*mod_path_stack);
@ -4383,7 +4385,7 @@ impl Parser {
self.expect_keyword(keywords::Mod); self.expect_keyword(keywords::Mod);
} else if self.token != token::LBRACE { } else if self.token != token::LBRACE {
let token_str = self.this_token_to_str(); let token_str = self.this_token_to_str();
self.span_fatal(*self.span, self.span_fatal(self.span,
format!("expected `\\{` or `mod` but found `{}`", format!("expected `\\{` or `mod` but found `{}`",
token_str)) token_str))
} }
@ -4401,7 +4403,7 @@ impl Parser {
_ => { _ => {
if must_be_named_mod { if must_be_named_mod {
let token_str = self.this_token_to_str(); let token_str = self.this_token_to_str();
self.span_fatal(*self.span, self.span_fatal(self.span,
format!("expected foreign module name but \ format!("expected foreign module name but \
found `{}`", found `{}`",
token_str)) token_str))
@ -4435,7 +4437,7 @@ impl Parser {
} }
if opt_abis.is_some() { if opt_abis.is_some() {
self.span_err(*self.span, "an ABI may not be specified here"); self.span_err(self.span, "an ABI may not be specified here");
} }
@ -4580,7 +4582,7 @@ impl Parser {
Some(abi) => { Some(abi) => {
if abis.contains(abi) { if abis.contains(abi) {
self.span_err( self.span_err(
*self.span, self.span,
format!("ABI `{}` appears twice", format!("ABI `{}` appears twice",
word)); word));
} else { } else {
@ -4590,7 +4592,7 @@ impl Parser {
None => { None => {
self.span_err( self.span_err(
*self.span, self.span,
format!("illegal ABI: \ format!("illegal ABI: \
expected one of [{}], \ expected one of [{}], \
found `{}`", found `{}`",