}
}
+ /// Returns whether any of the given keywords are `dist` tokens ahead of the current one.
+ fn is_keyword_ahead(&self, dist: usize, kws: &[Symbol]) -> bool {
+ self.look_ahead(dist, |t| kws.iter().any(|&kw| t.is_keyword(kw)))
+ }
+
/// Is the current token one of the keywords that signals a bare function type?
fn token_is_bare_fn_keyword(&mut self) -> bool {
self.check_keyword(kw::Fn) ||
self.token.is_keyword(kw::Async) &&
(
( // `async move {`
- self.look_ahead(1, |t| t.is_keyword(kw::Move)) &&
+ self.is_keyword_ahead(1, &[kw::Move]) &&
self.look_ahead(2, |t| *t == token::OpenDelim(token::Brace))
) || ( // `async {`
self.look_ahead(1, |t| *t == token::OpenDelim(token::Brace))
fn is_async_fn(&self) -> bool {
self.token.is_keyword(kw::Async) &&
- self.look_ahead(1, |t| t.is_keyword(kw::Fn))
+ self.is_keyword_ahead(1, &[kw::Fn])
}
fn is_do_catch_block(&self) -> bool {
self.token.is_keyword(kw::Do) &&
- self.look_ahead(1, |t| t.is_keyword(kw::Catch)) &&
+ self.is_keyword_ahead(1, &[kw::Catch]) &&
self.look_ahead(2, |t| *t == token::OpenDelim(token::Brace)) &&
!self.restrictions.contains(Restrictions::NO_STRUCT_LITERAL)
}
fn is_existential_type_decl(&self) -> bool {
self.token.is_keyword(kw::Existential) &&
- self.look_ahead(1, |t| t.is_keyword(kw::Type))
+ self.is_keyword_ahead(1, &[kw::Type])
}
fn is_auto_trait_item(&self) -> bool {
// auto trait
- (self.token.is_keyword(kw::Auto)
- && self.look_ahead(1, |t| t.is_keyword(kw::Trait)))
+ (self.token.is_keyword(kw::Auto) &&
+ self.is_keyword_ahead(1, &[kw::Trait]))
|| // unsafe auto trait
(self.token.is_keyword(kw::Unsafe) &&
- self.look_ahead(1, |t| t.is_keyword(kw::Auto)) &&
- self.look_ahead(2, |t| t.is_keyword(kw::Trait)))
+ self.is_keyword_ahead(1, &[kw::Auto]) &&
+ self.is_keyword_ahead(2, &[kw::Trait]))
}
fn eat_macro_def(&mut self, attrs: &[Attribute], vis: &Visibility, lo: Span)
(if isolated_self(self, 1) {
self.bump();
SelfKind::Region(None, Mutability::Immutable)
- } else if self.look_ahead(1, |t| t.is_keyword(kw::Mut)) &&
+ } else if self.is_keyword_ahead(1, &[kw::Mut]) &&
isolated_self(self, 2) {
self.bump();
self.bump();
let lt = self.expect_lifetime();
SelfKind::Region(Some(lt), Mutability::Immutable)
} else if self.look_ahead(1, |t| t.is_lifetime()) &&
- self.look_ahead(2, |t| t.is_keyword(kw::Mut)) &&
+ self.is_keyword_ahead(2, &[kw::Mut]) &&
isolated_self(self, 3) {
self.bump();
let lt = self.expect_lifetime();
/// (returns `false` for things like `const fn`, etc.).
fn is_const_item(&self) -> bool {
self.token.is_keyword(kw::Const) &&
- !self.look_ahead(1, |t| t.is_keyword(kw::Fn)) &&
- !self.look_ahead(1, |t| t.is_keyword(kw::Unsafe))
+ !self.is_keyword_ahead(1, &[kw::Fn, kw::Unsafe])
}
/// Parses all the "front matter" for a `fn` declaration, up to
self.look_ahead(1, |t| t.is_lifetime() || t.is_ident()) &&
self.look_ahead(2, |t| t == &token::Gt || t == &token::Comma ||
t == &token::Colon || t == &token::Eq) ||
- self.look_ahead(1, |t| t.is_keyword(kw::Const)))
+ self.is_keyword_ahead(1, &[kw::Const]))
}
fn parse_impl_body(&mut self) -> PResult<'a, (Vec<ImplItem>, Vec<Attribute>)> {
// `()` or a tuple might be allowed. For example, `struct Struct(pub (), pub (usize));`.
// Because of this, we only `bump` the `(` if we're assured it is appropriate to do so
// by the following tokens.
- if self.look_ahead(1, |t| t.is_keyword(kw::Crate)) &&
+ if self.is_keyword_ahead(1, &[kw::Crate]) &&
self.look_ahead(2, |t| t != &token::ModSep) // account for `pub(crate::foo)`
{
// `pub(crate)`
VisibilityKind::Crate(CrateSugar::PubCrate),
);
return Ok(vis)
- } else if self.look_ahead(1, |t| t.is_keyword(kw::In)) {
+ } else if self.is_keyword_ahead(1, &[kw::In]) {
// `pub(in path)`
self.bump(); // `(`
self.bump(); // `in`
});
return Ok(vis)
} else if self.look_ahead(2, |t| t == &token::CloseDelim(token::Paren)) &&
- self.look_ahead(1, |t| t.is_keyword(kw::Super) ||
- t.is_keyword(kw::SelfLower))
+ self.is_keyword_ahead(1, &[kw::Super, kw::SelfLower])
{
// `pub(self)` or `pub(super)`
self.bump(); // `(`
fn parse_defaultness(&mut self) -> Defaultness {
// `pub` is included for better error messages
if self.check_keyword(kw::Default) &&
- self.look_ahead(1, |t| t.is_keyword(kw::Impl) ||
- t.is_keyword(kw::Const) ||
- t.is_keyword(kw::Fn) ||
- t.is_keyword(kw::Unsafe) ||
- t.is_keyword(kw::Extern) ||
- t.is_keyword(kw::Type) ||
- t.is_keyword(kw::Pub)) {
+ self.is_keyword_ahead(1, &[
+ kw::Impl,
+ kw::Const,
+ kw::Fn,
+ kw::Unsafe,
+ kw::Extern,
+ kw::Type,
+ kw::Pub,
+ ])
+ {
self.bump(); // `default`
Defaultness::Default
} else {
// Ident ["<"...">"] ["where" ...] ("=" | ":") Ty ";"
if self.check_keyword(kw::Type) ||
self.check_keyword(kw::Existential) &&
- self.look_ahead(1, |t| t.is_keyword(kw::Type)) {
+ self.is_keyword_ahead(1, &[kw::Type]) {
let existential = self.eat_keyword(kw::Existential);
assert!(self.eat_keyword(kw::Type));
Some(self.parse_existential_or_alias(existential))
let const_span = self.prev_span;
if self.check_keyword(kw::Fn)
|| (self.check_keyword(kw::Unsafe)
- && self.look_ahead(1, |t| t.is_keyword(kw::Fn))) {
+ && self.is_keyword_ahead(1, &[kw::Fn])) {
// CONST FUNCTION ITEM
let unsafety = self.parse_unsafety();
self.bump();
// `unsafe async fn` or `async fn`
if (
self.check_keyword(kw::Unsafe) &&
- self.look_ahead(1, |t| t.is_keyword(kw::Async))
+ self.is_keyword_ahead(1, &[kw::Async])
) || (
self.check_keyword(kw::Async) &&
- self.look_ahead(1, |t| t.is_keyword(kw::Fn))
+ self.is_keyword_ahead(1, &[kw::Fn])
)
{
// ASYNC FUNCTION ITEM
return Ok(Some(item));
}
if self.check_keyword(kw::Unsafe) &&
- (self.look_ahead(1, |t| t.is_keyword(kw::Trait)) ||
- self.look_ahead(1, |t| t.is_keyword(kw::Auto)))
+ self.is_keyword_ahead(1, &[kw::Trait, kw::Auto])
{
// UNSAFE TRAIT ITEM
self.bump(); // `unsafe`
}
if self.check_keyword(kw::Impl) ||
self.check_keyword(kw::Unsafe) &&
- self.look_ahead(1, |t| t.is_keyword(kw::Impl)) ||
- self.check_keyword(kw::Default) &&
- self.look_ahead(1, |t| t.is_keyword(kw::Impl)) ||
+ self.is_keyword_ahead(1, &[kw::Impl]) ||
self.check_keyword(kw::Default) &&
- self.look_ahead(1, |t| t.is_keyword(kw::Unsafe)) {
+ self.is_keyword_ahead(1, &[kw::Impl, kw::Unsafe]) {
// IMPL ITEM
let defaultness = self.parse_defaultness();
let unsafety = self.parse_unsafety();
}
if self.check_keyword(kw::Trait)
|| (self.check_keyword(kw::Auto)
- && self.look_ahead(1, |t| t.is_keyword(kw::Trait)))
+ && self.is_keyword_ahead(1, &[kw::Trait]))
{
let is_auto = if self.eat_keyword(kw::Trait) {
IsAuto::No