use ast::{BiBitAnd, BiBitOr, BiBitXor, BiRem, BiLt, BiGt, Block};
use ast::{BlockCheckMode, CaptureByRef, CaptureByValue, CaptureClause};
use ast::{Crate, CrateConfig, Decl, DeclItem};
-use ast::{DeclLocal, DefaultBlock, UnDeref, BiDiv, EMPTY_CTXT, EnumDef, ExplicitSelf};
+use ast::{DeclLocal, DefaultBlock, DefaultReturn};
+use ast::{UnDeref, BiDiv, EMPTY_CTXT, EnumDef, ExplicitSelf};
use ast::{Expr, Expr_, ExprAddrOf, ExprMatch, ExprAgain};
use ast::{ExprAssign, ExprAssignOp, ExprBinary, ExprBlock, ExprBox};
use ast::{ExprBreak, ExprCall, ExprCast};
use ast::{Delimited, SequenceRepetition, TokenTree, TraitItem, TraitRef};
use ast::{TtDelimited, TtSequence, TtToken};
use ast::{TupleVariantKind, Ty, Ty_, TypeBinding};
-use ast::{TypeField, TyFixedLengthVec, TyBareFn};
+use ast::{TyFixedLengthVec, TyBareFn};
use ast::{TyTypeof, TyInfer, TypeMethod};
use ast::{TyParam, TyParamBound, TyParen, TyPath, TyPolyTraitRef, TyPtr, TyQPath};
use ast::{TyRptr, TyTup, TyU32, TyVec, UnUniq};
use parse::classify;
use parse::common::{SeqSep, seq_sep_none, seq_sep_trailing_allowed};
use parse::lexer::{Reader, TokenAndSpan};
-use parse::obsolete::*;
+use parse::obsolete::{ParserObsoleteMethods, ObsoleteSyntax};
use parse::token::{self, MatchNt, SubstNt, SpecialVarNt, InternedString};
use parse::token::{keywords, special_idents, SpecialMacroVar};
use parse::{new_sub_parser_from_file, ParseSess};
/// the previous token or None (only stashed sometimes).
pub last_token: Option<Box<token::Token>>,
pub buffer: [TokenAndSpan; 4],
- pub buffer_start: int,
- pub buffer_end: int,
- pub tokens_consumed: uint,
+ pub buffer_start: isize,
+ pub buffer_end: isize,
+ pub tokens_consumed: usize,
pub restrictions: Restrictions,
- pub quote_depth: uint, // not (yet) related to the quasiquoter
+ pub quote_depth: usize, // not (yet) related to the quasiquoter
pub reader: Box<Reader+'a>,
pub interner: Rc<token::IdentInterner>,
/// The set of seen errors about obsolete syntax. Used to suppress
// would encounter a `>` and stop. This lets the parser handle trailing
// commas in generic parameters, because it can stop either after
// parsing a type or after parsing a comma.
- for i in iter::count(0u, 1) {
+ for i in iter::count(0us, 1) {
if self.check(&token::Gt)
|| self.token == token::BinOp(token::Shr)
|| self.token == token::Ge
self.reader.real_token()
} else {
// Avoid token copies with `replace`.
- let buffer_start = self.buffer_start as uint;
- let next_index = (buffer_start + 1) & 3 as uint;
- self.buffer_start = next_index as int;
+ let buffer_start = self.buffer_start as usize;
+ let next_index = (buffer_start + 1) & 3 as usize;
+ self.buffer_start = next_index as isize;
let placeholder = TokenAndSpan {
tok: token::Underscore,
};
self.span = next.sp;
self.token = next.tok;
- self.tokens_consumed += 1u;
+ self.tokens_consumed += 1us;
self.expected_tokens.clear();
// check after each token
self.check_unknown_macro_variable();
self.token = next;
self.span = mk_sp(lo, hi);
}
- pub fn buffer_length(&mut self) -> int {
+ pub fn buffer_length(&mut self) -> isize {
if self.buffer_start <= self.buffer_end {
return self.buffer_end - self.buffer_start;
}
return (4 - self.buffer_start) + self.buffer_end;
}
- pub fn look_ahead<R, F>(&mut self, distance: uint, f: F) -> R where
+ pub fn look_ahead<R, F>(&mut self, distance: usize, f: F) -> R where
F: FnOnce(&token::Token) -> R,
{
- let dist = distance as int;
+ let dist = distance as isize;
while self.buffer_length() < dist {
- self.buffer[self.buffer_end as uint] = self.reader.real_token();
+ self.buffer[self.buffer_end as usize] = self.reader.real_token();
self.buffer_end = (self.buffer_end + 1) & 3;
}
- f(&self.buffer[((self.buffer_start + dist - 1) & 3) as uint].tok)
+ f(&self.buffer[((self.buffer_start + dist - 1) & 3) as usize].tok)
}
pub fn fatal(&mut self, m: &str) -> ! {
self.sess.span_diagnostic.span_fatal(self.span, m)
MutTy { ty: t, mutbl: mutbl }
}
- /// Parse [mut/const/imm] ID : TY
- /// now used only by obsolete record syntax parser...
- pub fn parse_ty_field(&mut self) -> TypeField {
- let lo = self.span.lo;
- let mutbl = self.parse_mutability();
- let id = self.parse_ident();
- self.expect(&token::Colon);
- let ty = self.parse_ty_sum();
- let hi = ty.span.hi;
- ast::TypeField {
- ident: id,
- mt: MutTy { ty: ty, mutbl: mutbl },
- span: mk_sp(lo, hi),
- }
- }
-
/// Parse optional return type [ -> TY ] in function decl
pub fn parse_ret_ty(&mut self) -> FunctionRetTy {
if self.eat(&token::RArrow) {
}
} else {
let pos = self.span.lo;
- Return(P(Ty {
- id: ast::DUMMY_NODE_ID,
- node: TyTup(vec![]),
- span: mk_sp(pos, pos),
- }))
+ DefaultReturn(mk_sp(pos, pos))
}
}
} else {
TyTup(ts)
}
- } else if self.token == token::Tilde {
- // OWNED POINTER
- self.bump();
- let last_span = self.last_span;
- match self.token {
- token::OpenDelim(token::Bracket) => {
- self.obsolete(last_span, ObsoleteSyntax::OwnedVector)
- }
- _ => self.obsolete(last_span, ObsoleteSyntax::OwnedType)
- }
- TyTup(vec![self.parse_ty()])
} else if self.check(&token::BinOp(token::Star)) {
// STAR POINTER (bare pointer?)
self.bump();
self.expect(&token::OpenDelim(token::Bracket));
let t = self.parse_ty_sum();
- // Parse the `; e` in `[ int; e ]`
+ // Parse the `; e` in `[ i32; e ]`
// where `e` is a const expression
let t = match self.maybe_parse_fixed_length_of_vec() {
None => TyVec(t),
ExprField(expr, ident)
}
- pub fn mk_tup_field(&mut self, expr: P<Expr>, idx: codemap::Spanned<uint>) -> ast::Expr_ {
+ pub fn mk_tup_field(&mut self, expr: P<Expr>, idx: codemap::Spanned<usize>) -> ast::Expr_ {
ExprTupField(expr, idx)
}
let ex: Expr_;
+ // Note: when adding new syntax here, don't forget to adjust Token::can_begin_expr().
match self.token {
token::OpenDelim(token::Paren) => {
self.bump();
hi = self.span.hi;
self.bump();
- let index = n.as_str().parse::<uint>();
+ let index = n.as_str().parse::<usize>();
match index {
Some(n) => {
let id = spanned(dot, hi, n);
};
self.span_help(last_span,
&format!("try parenthesizing the first index; e.g., `(foo.{}){}`",
- float.trunc() as uint,
+ float.trunc() as usize,
&float.fract().to_string()[1..])[]);
}
self.abort_if_errors();
}
pub fn check_unknown_macro_variable(&mut self) {
- if self.quote_depth == 0u {
+ if self.quote_depth == 0us {
match self.token {
token::SubstNt(name, _) =>
self.fatal(&format!("unknown macro variable `{}`",
token_str)[])
},
/* we ought to allow different depths of unquotation */
- token::Dollar | token::SubstNt(..) if p.quote_depth > 0u => {
+ token::Dollar | token::SubstNt(..) if p.quote_depth > 0us => {
p.parse_unquoted()
}
_ => {
let lo = self.span.lo;
let hi;
+ // Note: when adding new unary operators, don't forget to adjust Token::can_begin_expr()
let ex;
match self.token {
token::Not => {
hi = e.span.hi;
ex = ExprAddrOf(m, e);
}
- token::Tilde => {
- self.bump();
- let last_span = self.last_span;
- match self.token {
- token::OpenDelim(token::Bracket) => {
- self.obsolete(last_span, ObsoleteSyntax::OwnedVector)
- },
- _ => self.obsolete(last_span, ObsoleteSyntax::OwnedExpr)
- }
-
- let e = self.parse_prefix_expr();
- hi = e.span.hi;
- ex = self.mk_unary(UnUniq, e);
- }
token::DotDot if !self.restrictions.contains(RESTRICTION_NO_DOTS) => {
// A range, closed above: `..expr`.
self.bump();
}
/// Parse an expression of binops of at least min_prec precedence
- pub fn parse_more_binops(&mut self, lhs: P<Expr>, min_prec: uint) -> P<Expr> {
+ pub fn parse_more_binops(&mut self, lhs: P<Expr>, min_prec: usize) -> P<Expr> {
if self.expr_is_complete(&*lhs) { return lhs; }
// Prevent dynamic borrow errors later on by limiting the
"Chained comparison operators require parentheses");
if op == BiLt && outer_op == BiGt {
self.span_help(op_span,
- "Use ::< instead of < if you meant to specify type arguments.");
+ "use ::< instead of < if you meant to specify type arguments");
}
}
_ => {}
span: self.span,
}));
before_slice = false;
- } else {
- let _ = self.parse_pat();
- let span = self.span;
- self.obsolete(span, ObsoleteSyntax::SubsliceMatch);
}
continue
}
break;
}
- let bind_type = if self.eat_keyword(keywords::Mut) {
- BindByValue(MutMutable)
- } else if self.eat_keyword(keywords::Ref) {
- BindByRef(self.parse_mutability())
- } else {
- BindByValue(MutImmutable)
- };
-
- let fieldname = self.parse_ident();
-
- let (subpat, is_shorthand) = if self.check(&token::Colon) {
- match bind_type {
- BindByRef(..) | BindByValue(MutMutable) => {
- let token_str = self.this_token_to_string();
- self.fatal(&format!("unexpected `{}`",
- token_str)[])
- }
- _ => {}
- }
-
+ // Check if a colon exists one ahead. This means we're parsing a fieldname.
+ let (subpat, fieldname, is_shorthand) = if self.look_ahead(1, |t| t == &token::Colon) {
+ // Parsing a pattern of the form "fieldname: pat"
+ let fieldname = self.parse_ident();
self.bump();
let pat = self.parse_pat();
hi = pat.span.hi;
- (pat, false)
+ (pat, fieldname, false)
} else {
+ // Parsing a pattern of the form "(box) (ref) (mut) fieldname"
+ let is_box = self.eat_keyword(keywords::Box);
+ let boxed_span_lo = self.span.lo;
+ let is_ref = self.eat_keyword(keywords::Ref);
+ let is_mut = self.eat_keyword(keywords::Mut);
+ let fieldname = self.parse_ident();
hi = self.last_span.hi;
- let fieldpath = codemap::Spanned{span:self.last_span, node: fieldname};
- (P(ast::Pat {
+
+ let bind_type = match (is_ref, is_mut) {
+ (true, true) => BindByRef(MutMutable),
+ (true, false) => BindByRef(MutImmutable),
+ (false, true) => BindByValue(MutMutable),
+ (false, false) => BindByValue(MutImmutable),
+ };
+ let fieldpath = codemap::Spanned{span:self.last_span, node:fieldname};
+ let fieldpat = P(ast::Pat{
id: ast::DUMMY_NODE_ID,
node: PatIdent(bind_type, fieldpath, None),
- span: self.last_span
- }), true)
+ span: mk_sp(boxed_span_lo, hi),
+ });
+
+ let subpat = if is_box {
+ P(ast::Pat{
+ id: ast::DUMMY_NODE_ID,
+ node: PatBox(fieldpat),
+ span: mk_sp(lo, hi),
+ })
+ } else {
+ fieldpat
+ };
+ (subpat, fieldname, true)
};
+
fields.push(codemap::Spanned { span: mk_sp(lo, hi),
node: ast::FieldPat { ident: fieldname,
pat: subpat,
span: mk_sp(lo, hi)
})
}
- token::Tilde => {
- // parse ~pat
- self.bump();
- let sub = self.parse_pat();
- pat = PatBox(sub);
- let last_span = self.last_span;
- hi = last_span.hi;
- self.obsolete(last_span, ObsoleteSyntax::OwnedPattern);
- return P(ast::Pat {
- id: ast::DUMMY_NODE_ID,
- node: pat,
- span: mk_sp(lo, hi)
- })
- }
token::BinOp(token::And) | token::AndAnd => {
// parse &pat and &mut pat
let lo = self.span.lo;
self_ident_hi = self.last_span.hi;
eself
}
- token::Tilde => {
- // We need to make sure it isn't a type
- if self.look_ahead(1, |t| t.is_keyword(keywords::Self)) {
- self.bump();
- drop(self.expect_self_ident());
- let last_span = self.last_span;
- self.obsolete(last_span, ObsoleteSyntax::OwnedSelf)
- }
- SelfStatic
- }
token::BinOp(token::Star) => {
// Possibly "*self" or "*mut self" -- not supported. Try to avoid
// emitting cryptic "unexpected token" errors.
} else {
SelfValue(self_ident)
}
- } else if self.token.is_mutability() &&
- self.look_ahead(1, |t| *t == token::Tilde) &&
- self.look_ahead(2, |t| t.is_keyword(keywords::Self)) {
- mutbl_self = self.parse_mutability();
- self.bump();
- drop(self.expect_self_ident());
- let last_span = self.last_span;
- self.obsolete(last_span, ObsoleteSyntax::OwnedSelf);
- SelfStatic
} else {
SelfStatic
}
(optional_unboxed_closure_kind, args)
}
};
- let output = if self.check(&token::RArrow) {
- self.parse_ret_ty()
- } else {
- Return(P(Ty {
- id: ast::DUMMY_NODE_ID,
- node: TyInfer,
- span: self.span,
- }))
- };
+ let output = self.parse_ret_ty();
(P(FnDecl {
inputs: inputs_captures,
seq_sep_trailing_allowed(token::Comma),
|p| p.parse_fn_block_arg());
- let output = if self.check(&token::RArrow) {
- self.parse_ret_ty()
- } else {
- Return(P(Ty {
- id: ast::DUMMY_NODE_ID,
- node: TyInfer,
- span: self.span,
- }))
- };
+ let output = self.parse_ret_ty();
P(FnDecl {
inputs: inputs,
Some(attrs))
}
- /// Parse a::B<String,int>
+ /// Parse a::B<String,i32>
fn parse_trait_ref(&mut self) -> TraitRef {
ast::TraitRef {
path: self.parse_path(LifetimeAndTypesWithoutColons),
}
}
- /// Parse for<'l> a::B<String,int>
+ /// Parse for<'l> a::B<String,i32>
fn parse_poly_trait_ref(&mut self) -> PolyTraitRef {
let lifetime_defs = self.parse_late_bound_lifetime_defs();
}
}
- if first && attrs_remaining_len > 0u {
+ if first && attrs_remaining_len > 0us {
// We parsed attributes for the first item but didn't find it
let last_span = self.last_span;
self.span_err(last_span,
let (maybe_path, ident) = match self.token {
token::Ident(..) => {
let the_ident = self.parse_ident();
- let path = if self.token == token::Eq {
- self.bump();
- let path = self.parse_str();
- let span = self.span;
- self.obsolete(span, ObsoleteSyntax::ExternCrateRenaming);
- Some(path)
- } else if self.eat_keyword(keywords::As) {
+ let path = if self.eat_keyword(keywords::As) {
// skip the ident if there is one
if self.token.is_ident() { self.bump(); }
(id, ItemEnum(enum_definition, generics), None)
}
- fn fn_expr_lookahead(tok: &token::Token) -> bool {
- match *tok {
- token::OpenDelim(token::Paren) | token::At | token::Tilde | token::BinOp(_) => true,
- _ => false
- }
- }
-
/// Parses a string as an ABI spec on an extern type or module. Consumes
/// the `extern` keyword, if one is found.
fn parse_opt_abi(&mut self) -> Option<abi::Abi> {
}
// either a view item or an item:
if self.eat_keyword(keywords::Extern) {
- let next_is_mod = self.eat_keyword(keywords::Mod);
-
- if next_is_mod || self.eat_keyword(keywords::Crate) {
- if next_is_mod {
- let last_span = self.last_span;
- self.span_err(mk_sp(lo, last_span.hi),
- &format!("`extern mod` is obsolete, use \
- `extern crate` instead \
- to refer to external \
- crates.")[])
- }
+ if self.eat_keyword(keywords::Crate) {
return self.parse_item_extern_crate(lo, visibility, attrs);
}
return IoviItem(item);
}
if self.token.is_keyword(keywords::Unsafe) &&
- self.look_ahead(1u, |t| t.is_keyword(keywords::Trait))
+ self.look_ahead(1us, |t| t.is_keyword(keywords::Trait))
{
// UNSAFE TRAIT ITEM
self.expect_keyword(keywords::Unsafe);
return IoviItem(item);
}
if self.token.is_keyword(keywords::Unsafe) &&
- self.look_ahead(1u, |t| t.is_keyword(keywords::Impl))
+ self.look_ahead(1us, |t| t.is_keyword(keywords::Impl))
{
// IMPL ITEM
self.expect_keyword(keywords::Unsafe);
maybe_append(attrs, extra_attrs));
return IoviItem(item);
}
- if self.token.is_keyword(keywords::Fn) &&
- self.look_ahead(1, |f| !Parser::fn_expr_lookahead(f)) {
+ if self.token.is_keyword(keywords::Fn) {
// FUNCTION ITEM
self.bump();
let (ident, item_, extra_attrs) =
return IoviItem(item);
}
if self.token.is_keyword(keywords::Unsafe)
- && self.look_ahead(1u, |t| *t != token::OpenDelim(token::Brace)) {
+ && self.look_ahead(1us, |t| *t != token::OpenDelim(token::Brace)) {
// UNSAFE FUNCTION ITEM
self.bump();
let abi = if self.eat_keyword(keywords::Extern) {
let first_ident = self.parse_ident();
let mut path = vec!(first_ident);
- match self.token {
- token::Eq => {
- // x = foo::bar
- self.bump();
- let path_lo = self.span.lo;
- path = vec!(self.parse_ident());
- while self.check(&token::ModSep) {
- self.bump();
- let id = self.parse_ident();
- path.push(id);
- }
- let span = mk_sp(path_lo, self.span.hi);
- self.obsolete(span, ObsoleteSyntax::ImportRenaming);
- let path = ast::Path {
- span: span,
- global: false,
- segments: path.into_iter().map(|identifier| {
- ast::PathSegment {
- identifier: identifier,
- parameters: ast::PathParameters::none(),
- }
- }).collect()
- };
- return P(spanned(lo, self.span.hi,
- ViewPathSimple(first_ident, path,
- ast::DUMMY_NODE_ID)));
- }
-
- token::ModSep => {
+ if let token::ModSep = self.token {
// foo::bar or foo::{a,b,c} or foo::*
while self.check(&token::ModSep) {
self.bump();
_ => break
}
}
- }
- _ => ()
}
- let mut rename_to = path[path.len() - 1u];
+ let mut rename_to = path[path.len() - 1us];
let path = ast::Path {
span: mk_sp(lo, self.last_span.hi),
global: false,