db::HirDatabase,
};
use ra_syntax::{
- SyntaxKind,
+ T,
ast::{LetStmt, PatKind, NameOwner, AstNode}
};
let name = pat.name()?;
let name_range = name.syntax().range();
// Assist not applicable if the type has already been specified
- if stmt.syntax().children_with_tokens().any(|child| child.kind() == SyntaxKind::COLON) {
+ if stmt.syntax().children_with_tokens().any(|child| child.kind() == T![:]) {
return None;
}
// Infer type
use arrayvec::ArrayVec;
use ra_text_edit::TextEditBuilder;
-use ra_syntax::{AstNode, TreeArc, ast, SyntaxKind::*, SyntaxElement, SourceFile, InsertPosition, Direction};
+use ra_syntax::{AstNode, TreeArc, ast, SyntaxKind::*, SyntaxElement, SourceFile, InsertPosition, Direction, T};
use ra_fmt::leading_indent;
use hir::Name;
fn do_make_multiline(&mut self) {
let l_curly =
- match self.ast().syntax().children_with_tokens().find(|it| it.kind() == L_CURLY) {
+ match self.ast().syntax().children_with_tokens().find(|it| it.kind() == T!['{']) {
Some(it) => it,
None => return,
};
if let Some(comma) = $anchor
.syntax()
.siblings_with_tokens(Direction::Next)
- .find(|it| it.kind() == COMMA)
+ .find(|it| it.kind() == T![,])
{
InsertPosition::After(comma)
} else {
}
fn l_curly(&self) -> Option<SyntaxElement> {
- self.ast().syntax().children_with_tokens().find(|it| it.kind() == L_CURLY)
+ self.ast().syntax().children_with_tokens().find(|it| it.kind() == T!['{'])
}
}
}
fn l_curly(&self) -> Option<SyntaxElement> {
- self.ast().syntax().children_with_tokens().find(|it| it.kind() == L_CURLY)
+ self.ast().syntax().children_with_tokens().find(|it| it.kind() == T!['{'])
}
}
mod tokens {
use once_cell::sync::Lazy;
- use ra_syntax::{AstNode, SourceFile, TreeArc, SyntaxToken, SyntaxKind::*};
+ use ra_syntax::{AstNode, SourceFile, TreeArc, SyntaxToken, SyntaxKind::*, T};
static SOURCE_FILE: Lazy<TreeArc<SourceFile>> = Lazy::new(|| SourceFile::parse(",\n; ;"));
.syntax()
.descendants_with_tokens()
.filter_map(|it| it.as_token())
- .find(|it| it.kind() == COMMA)
+ .find(|it| it.kind() == T![,])
.unwrap()
}
use hir::{ self, db::HirDatabase};
use ra_syntax::{
+ T,
ast::{ self, NameOwner }, AstNode, SyntaxNode, Direction, TextRange, SmolStr,
- SyntaxKind::{ PATH, PATH_SEGMENT, COLONCOLON, COMMA }
+ SyntaxKind::{ PATH, PATH_SEGMENT }
};
use crate::{
AssistId,
children.next().map(|n| (n, n.kind())),
);
match (first, second, third) {
- (Some((subpath, PATH)), Some((_, COLONCOLON)), Some((segment, PATH_SEGMENT))) => {
+ (Some((subpath, PATH)), Some((_, T![::])), Some((segment, PATH_SEGMENT))) => {
path = ast::Path::cast(subpath.as_node()?)?;
segments.push(ast::PathSegment::cast(segment.as_node()?)?);
}
let last = tree_list.use_trees().last();
if let Some(last) = last {
let mut buf = String::new();
- let comma = last.syntax().siblings(Direction::Next).find(|n| n.kind() == COMMA);
+ let comma = last.syntax().siblings(Direction::Next).find(|n| n.kind() == T![,]);
let offset = if let Some(comma) = comma {
comma.range().end()
} else {
use hir::db::HirDatabase;
use ra_syntax::{
+ T,
AstNode, SyntaxNode, TextUnit,
ast::{self, VisibilityOwner, NameOwner},
- SyntaxKind::{VISIBILITY, FN_KW, MOD_KW, STRUCT_KW, ENUM_KW, TRAIT_KW, FN_DEF, MODULE, STRUCT_DEF, ENUM_DEF, TRAIT_DEF, IDENT, WHITESPACE, COMMENT, ATTR},
+ SyntaxKind::{VISIBILITY, FN_DEF, MODULE, STRUCT_DEF, ENUM_DEF, TRAIT_DEF, IDENT, WHITESPACE, COMMENT, ATTR},
};
use crate::{AssistCtx, Assist, AssistId};
fn add_vis(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
let item_keyword = ctx.token_at_offset().find(|leaf| match leaf.kind() {
- FN_KW | MOD_KW | STRUCT_KW | ENUM_KW | TRAIT_KW => true,
+ T![fn] | T![mod] | T![struct] | T![enum] | T![trait] => true,
_ => false,
});
use hir::db::HirDatabase;
use ra_syntax::{
+ T,
Direction,
- SyntaxKind::COMMA,
algo::non_trivia_sibling,
};
use crate::{AssistCtx, Assist, AssistId};
pub(crate) fn flip_comma(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
- let comma = ctx.token_at_offset().find(|leaf| leaf.kind() == COMMA)?;
+ let comma = ctx.token_at_offset().find(|leaf| leaf.kind() == T![,])?;
let prev = non_trivia_sibling(comma.into(), Direction::Prev)?;
let next = non_trivia_sibling(comma.into(), Direction::Next)?;
ctx.add_action(AssistId("flip_comma"), "flip comma", |edit| {
use ra_syntax::{
ast::{self, AstNode},
TextUnit,
- SyntaxKind::{
- L_PAREN, R_PAREN, L_CURLY, R_CURLY, L_BRACK, R_BRACK, EXCL
- },
+ T
};
use crate::{AssistCtx, Assist, AssistId};
// Make sure it is actually a dbg-macro call, dbg followed by !
let excl = path.syntax().next_sibling_or_token()?;
- if name_ref.text() != macro_name || excl.kind() != EXCL {
+ if name_ref.text() != macro_name || excl.kind() != T![!] {
return None;
}
let last_child = node.last_child_or_token()?;
match (first_child.kind(), last_child.kind()) {
- (L_PAREN, R_PAREN) | (L_BRACK, R_BRACK) | (L_CURLY, R_CURLY) => Some(true),
+ (T!['('], T![')']) | (T!['['], T![']']) | (T!['{'], T!['}']) => Some(true),
_ => Some(false),
}
}
use hir::db::HirDatabase;
use ra_syntax::{
- TextUnit, AstNode, SyntaxKind::COLONCOLON,
+ T,
+ TextUnit, AstNode,
ast,
};
use crate::{AssistCtx, Assist, AssistId};
pub(crate) fn split_import(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
- let colon_colon = ctx.token_at_offset().find(|leaf| leaf.kind() == COLONCOLON)?;
+ let colon_colon = ctx.token_at_offset().find(|leaf| leaf.kind() == T![::])?;
let path = ast::Path::cast(colon_colon.parent())?;
let top_path = successors(Some(path), |it| it.parent_path()).last()?;
use std::iter::successors;
use itertools::Itertools;
use ra_syntax::{
- SyntaxNode, SyntaxKind::*, SyntaxToken, SyntaxKind,
+ SyntaxNode, SyntaxKind::*, SyntaxToken, SyntaxKind, T,
ast::{self, AstNode, AstToken},
};
return None;
}
let non_trivial_children = block.syntax().children().filter(|it| match it.kind() {
- WHITESPACE | L_CURLY | R_CURLY => false,
+ WHITESPACE | T!['{'] | T!['}'] => false,
_ => it != &expr.syntax(),
});
if non_trivial_children.count() > 0 {
pub fn compute_ws(left: SyntaxKind, right: SyntaxKind) -> &'static str {
match left {
- L_PAREN | L_BRACK => return "",
- L_CURLY => {
+ T!['('] | T!['['] => return "",
+ T!['{'] => {
if let USE_TREE = right {
return "";
}
_ => (),
}
match right {
- R_PAREN | R_BRACK => return "",
- R_CURLY => {
+ T![')'] | T![']'] => return "",
+ T!['}'] => {
if let USE_TREE = left {
return "";
}
}
- DOT => return "",
+ T![.] => return "",
_ => (),
}
" "
use hir::{source_binder, diagnostics::{Diagnostic as _, DiagnosticSink}};
use ra_db::SourceDatabase;
use ra_syntax::{
- Location, SourceFile, SyntaxKind, TextRange, SyntaxNode,
+ T, Location, SourceFile, TextRange, SyntaxNode,
ast::{self, AstNode, NamedFieldList, NamedField},
};
use ra_assists::ast_editor::{AstEditor, AstBuilder};
single_use_tree: &ast::UseTree,
) -> Option<TextEdit> {
let use_tree_list_node = single_use_tree.syntax().parent()?;
- if single_use_tree.path()?.segment()?.syntax().first_child_or_token()?.kind()
- == SyntaxKind::SELF_KW
- {
+ if single_use_tree.path()?.segment()?.syntax().first_child_or_token()?.kind() == T![self] {
let start = use_tree_list_node.prev_sibling_or_token()?.range().start();
let end = use_tree_list_node.range().end();
let range = TextRange::from_to(start, end);
})
.next()
.and_then(|it| it.as_token())
- .filter(|node| node.kind() == COMMA)
+ .filter(|node| node.kind() == T![,])
}
if let Some(comma_node) = nearby_comma(node, Direction::Prev) {
use itertools::Itertools;
use ra_syntax::{
+ T,
SourceFile, TextRange, TextUnit, SyntaxNode, SyntaxElement, SyntaxToken,
- SyntaxKind::{self, WHITESPACE, COMMA, R_CURLY, R_PAREN, R_BRACK},
+ SyntaxKind::{self, WHITESPACE},
algo::{find_covering_element, non_trivia_sibling},
ast::{self, AstNode, AstToken},
Direction,
if is_trailing_comma(prev.kind(), next.kind()) {
// Removes: trailing comma, newline (incl. surrounding whitespace)
edit.delete(TextRange::from_to(prev.range().start(), token.range().end()));
- } else if prev.kind() == COMMA && next.kind() == R_CURLY {
+ } else if prev.kind() == T![,] && next.kind() == T!['}'] {
// Removes: comma, newline (incl. surrounding whitespace)
let space = if let Some(left) = prev.prev_sibling_or_token() {
compute_ws(left.kind(), next.kind())
fn has_comma_after(node: &SyntaxNode) -> bool {
match non_trivia_sibling(node.into(), Direction::Next) {
- Some(n) => n.kind() == COMMA,
+ Some(n) => n.kind() == T![,],
_ => false,
}
}
fn is_trailing_comma(left: SyntaxKind, right: SyntaxKind) -> bool {
match (left, right) {
- (COMMA, R_PAREN) | (COMMA, R_BRACK) => true,
+ (T![,], T![')']) | (T![,], T![']']) => true,
_ => false,
}
}
use ra_syntax::{
SourceFile, TextUnit,
algo::find_token_at_offset,
- SyntaxKind::{self, *},
+ SyntaxKind::{self},
ast::AstNode,
+ T
};
pub fn matching_brace(file: &SourceFile, offset: TextUnit) -> Option<TextUnit> {
const BRACES: &[SyntaxKind] =
- &[L_CURLY, R_CURLY, L_BRACK, R_BRACK, L_PAREN, R_PAREN, L_ANGLE, R_ANGLE];
+ &[T!['{'], T!['}'], T!['['], T![']'], T!['('], T![')'], T![<], T![>]];
let (brace_node, brace_idx) = find_token_at_offset(file.syntax(), offset)
.filter_map(|node| {
let idx = BRACES.iter().position(|&brace| brace == node.kind())?;
use rustc_hash::FxHashSet;
-use ra_syntax::{ast, AstNode, TextRange, Direction, SyntaxKind::*, SyntaxElement};
+use ra_syntax::{ast, AstNode, TextRange, Direction, SyntaxKind::*, SyntaxElement, T};
use ra_db::SourceDatabase;
use crate::{FileId, db::RootDatabase};
let mut range_end = name_ref.syntax().range().end();
for sibling in path.syntax().siblings_with_tokens(Direction::Next) {
match sibling.kind() {
- EXCL | IDENT => range_end = sibling.range().end(),
+ T![!] | IDENT => range_end = sibling.range().end(),
_ => (),
}
}
use ra_parser::{TokenSource};
-use ra_syntax::{classify_literal, SmolStr, SyntaxKind, SyntaxKind::*};
+use ra_syntax::{classify_literal, SmolStr, SyntaxKind, SyntaxKind::*, T};
use std::cell::{RefCell};
// A Sequece of Token,
fn convert_delim(d: tt::Delimiter, closing: bool) -> TtToken {
let (kinds, texts) = match d {
- tt::Delimiter::Parenthesis => ([L_PAREN, R_PAREN], "()"),
- tt::Delimiter::Brace => ([L_CURLY, R_CURLY], "{}"),
- tt::Delimiter::Bracket => ([L_BRACK, R_BRACK], "[]"),
+ tt::Delimiter::Parenthesis => ([T!['('], T![')']], "()"),
+ tt::Delimiter::Brace => ([T!['{'], T!['}']], "{}"),
+ tt::Delimiter::Bracket => ([T!['['], T![']']], "[]"),
tt::Delimiter::None => ([L_DOLLAR, R_DOLLAR], ""),
};
fn convert_literal(l: &tt::Literal) -> TtToken {
let kind =
classify_literal(&l.text).map(|tkn| tkn.kind).unwrap_or_else(|| match l.text.as_ref() {
- "true" => SyntaxKind::TRUE_KW,
- "false" => SyntaxKind::FALSE_KW,
+ "true" => T![true],
+ "false" => T![false],
_ => panic!("Fail to convert given literal {:#?}", &l),
});
fn convert_punct(p: &tt::Punct) -> TtToken {
let kind = match p.char {
// lexer may produce compound tokens for these ones
- '.' => DOT,
- ':' => COLON,
- '=' => EQ,
- '!' => EXCL,
- '-' => MINUS,
+ '.' => T![.],
+ ':' => T![:],
+ '=' => T![=],
+ '!' => T![!],
+ '-' => T![-],
c => SyntaxKind::from_char(c).unwrap(),
};
let text = {
use ra_parser::{TreeSink, ParseError};
use ra_syntax::{
AstNode, SyntaxNode, TextRange, SyntaxKind, SmolStr, SyntaxTreeBuilder, TreeArc, SyntaxElement,
- ast, SyntaxKind::*, TextUnit
+ ast, SyntaxKind::*, TextUnit, T
};
use crate::subtree_source::{SubtreeTokenSource, Querier};
let first_child = tt.first_child_or_token()?;
let last_child = tt.last_child_or_token()?;
let (delimiter, skip_first) = match (first_child.kind(), last_child.kind()) {
- (L_PAREN, R_PAREN) => (tt::Delimiter::Parenthesis, true),
- (L_CURLY, R_CURLY) => (tt::Delimiter::Brace, true),
- (L_BRACK, R_BRACK) => (tt::Delimiter::Bracket, true),
+ (T!['('], T![')']) => (tt::Delimiter::Parenthesis, true),
+ (T!['{'], T!['}']) => (tt::Delimiter::Brace, true),
+ (T!['['], T![']']) => (tt::Delimiter::Bracket, true),
_ => (tt::Delimiter::None, false),
};
token_trees.push(tt::Leaf::from(tt::Punct { char, spacing }).into());
} else {
- let child: tt::TokenTree = if token.kind() == SyntaxKind::TRUE_KW
- || token.kind() == SyntaxKind::FALSE_KW
- {
- tt::Leaf::from(tt::Literal { text: token.text().clone() }).into()
- } else if token.kind().is_keyword()
- || token.kind() == IDENT
- || token.kind() == LIFETIME
- {
- let relative_range = token.range() - global_offset;
- let id = token_map.alloc(relative_range);
- let text = token.text().clone();
- tt::Leaf::from(tt::Ident { text, id }).into()
- } else if token.kind().is_literal() {
- tt::Leaf::from(tt::Literal { text: token.text().clone() }).into()
- } else {
- return None;
- };
+ let child: tt::TokenTree =
+ if token.kind() == T![true] || token.kind() == T![false] {
+ tt::Leaf::from(tt::Literal { text: token.text().clone() }).into()
+ } else if token.kind().is_keyword()
+ || token.kind() == IDENT
+ || token.kind() == LIFETIME
+ {
+ let relative_range = token.range() - global_offset;
+ let id = token_map.alloc(relative_range);
+ let text = token.text().clone();
+ tt::Leaf::from(tt::Ident { text, id }).into()
+ } else if token.kind().is_literal() {
+ tt::Leaf::from(tt::Literal { text: token.text().clone() }).into()
+ } else {
+ return None;
+ };
token_trees.push(child);
}
}
}
fn is_delimiter(kind: SyntaxKind) -> bool {
- use SyntaxKind::*;
-
match kind {
- L_PAREN | L_BRACK | L_CURLY | R_PAREN | R_BRACK | R_CURLY => true,
+ T!['('] | T!['['] | T!['{'] | T![')'] | T![']'] | T!['}'] => true,
_ => false,
}
}
/// The events for it would look like this:
///
///
- /// START(PATH) IDENT('foo') FINISH START(PATH) COLONCOLON IDENT('bar') FINISH
+ /// START(PATH) IDENT('foo') FINISH START(PATH) T![::] IDENT('bar') FINISH
/// | /\
/// | |
/// +------forward-parent------+
let m = p.start();
while !p.at(EOF) {
- if p.current() == SEMI {
+ if p.current() == T![;] {
p.bump();
continue;
}
pub(crate) fn meta_item(p: &mut Parser) {
fn is_delimiter(p: &mut Parser) -> bool {
match p.current() {
- L_CURLY | L_PAREN | L_BRACK => true,
+ T!['{'] | T!['('] | T!['['] => true,
_ => false,
}
}
// https://doc.rust-lang.org/reference/paths.html#simple-paths
// The start of an meta must be a simple path
match p.current() {
- IDENT | COLONCOLON | SUPER_KW | SELF_KW | CRATE_KW => p.bump(),
- EQ => {
+ IDENT | T![::] | T![super] | T![self] | T![crate] => p.bump(),
+ T![=] => {
p.bump();
match p.current() {
c if c.is_literal() => p.bump(),
- TRUE_KW | FALSE_KW => p.bump(),
+ T![true] | T![false] => p.bump(),
_ => {}
}
break;
MATCH_ARM_LIST => items::match_arm_list,
USE_TREE_LIST => items::use_tree_list,
EXTERN_ITEM_LIST => items::extern_item_list,
- TOKEN_TREE if first_child? == L_CURLY => items::token_tree,
+ TOKEN_TREE if first_child? == T!['{'] => items::token_tree,
ITEM_LIST => match parent? {
IMPL_BLOCK => items::impl_item_list,
TRAIT_DEF => items::trait_item_list,
pub(crate) fn opt_visibility(p: &mut Parser) -> bool {
match p.current() {
- PUB_KW => {
+ T![pub] => {
let m = p.start();
p.bump();
- if p.at(L_PAREN) {
+ if p.at(T!['(']) {
match p.nth(1) {
// test crate_visibility
// pub(crate) struct S;
// pub(self) struct S;
// pub(self) struct S;
// pub(self) struct S;
- CRATE_KW | SELF_KW | SUPER_KW => {
+ T![crate] | T![self] | T![super] => {
p.bump();
p.bump();
- p.expect(R_PAREN);
+ p.expect(T![')']);
}
- IN_KW => {
+ T![in] => {
p.bump();
p.bump();
paths::use_path(p);
- p.expect(R_PAREN);
+ p.expect(T![')']);
}
_ => (),
}
//
// test crate_keyword_path
// fn foo() { crate::foo(); }
- CRATE_KW if p.nth(1) != COLONCOLON => {
+ T![crate] if p.nth(1) != T![::] => {
let m = p.start();
p.bump();
m.complete(p, VISIBILITY);
}
fn opt_alias(p: &mut Parser) {
- if p.at(AS_KW) {
+ if p.at(T![as]) {
let m = p.start();
p.bump();
- if !p.eat(UNDERSCORE) {
+ if !p.eat(T![_]) {
name(p);
}
m.complete(p, ALIAS);
}
fn abi(p: &mut Parser) {
- assert!(p.at(EXTERN_KW));
+ assert!(p.at(T![extern]));
let abi = p.start();
p.bump();
match p.current() {
}
fn opt_fn_ret_type(p: &mut Parser) -> bool {
- if p.at(THIN_ARROW) {
+ if p.at(T![->]) {
let m = p.start();
p.bump();
types::type_(p);
let m = p.start();
p.bump();
m.complete(p, NAME_REF);
- } else if p.at(SELF_KW) {
+ } else if p.at(T![self]) {
let m = p.start();
p.bump();
- m.complete(p, SELF_KW);
+ m.complete(p, T![self]);
} else {
p.err_and_bump("expected identifier");
}
}
fn error_block(p: &mut Parser, message: &str) {
- assert!(p.at(L_CURLY));
+ assert!(p.at(T!['{']));
let m = p.start();
p.error(message);
p.bump();
expressions::expr_block_contents(p);
- p.eat(R_CURLY);
+ p.eat(T!['}']);
m.complete(p, ERROR);
}
use super::*;
pub(super) fn inner_attributes(p: &mut Parser) {
- while p.current() == POUND && p.nth(1) == EXCL {
+ while p.current() == T![#] && p.nth(1) == T![!] {
attribute(p, true)
}
}
pub(super) fn outer_attributes(p: &mut Parser) {
- while p.at(POUND) {
+ while p.at(T![#]) {
attribute(p, false)
}
}
fn attribute(p: &mut Parser, inner: bool) {
let attr = p.start();
- assert!(p.at(POUND));
+ assert!(p.at(T![#]));
p.bump();
if inner {
- assert!(p.at(EXCL));
+ assert!(p.at(T![!]));
p.bump();
}
- if p.at(L_BRACK) {
+ if p.at(T!['[']) {
items::token_tree(p);
} else {
p.error("expected `[`");
// fn c() { 1; 2; }
// fn d() { 1; 2 }
pub(crate) fn block(p: &mut Parser) {
- if !p.at(L_CURLY) {
+ if !p.at(T!['{']) {
p.error("expected a block");
return;
}
let m = p.start();
p.bump();
expr_block_contents(p);
- p.expect(R_CURLY);
+ p.expect(T!['}']);
m.complete(p, BLOCK);
}
// #[C] #[D] {}
// #[D] return ();
// }
- let has_attrs = p.at(POUND);
+ let has_attrs = p.at(T![#]);
attributes::outer_attributes(p);
- if p.at(LET_KW) {
+ if p.at(T![let]) {
let_stmt(p, m, with_semi);
return;
}
p.error(format!("attributes are not allowed on {:?}", kind));
}
- if p.at(R_CURLY) {
+ if p.at(T!['}']) {
// test attr_on_last_expr_in_block
// fn foo() {
// { #[A] bar!()? }
match with_semi {
StmtWithSemi::Yes => {
if blocklike.is_block() {
- p.eat(SEMI);
+ p.eat(T![;]);
} else {
- p.expect(SEMI);
+ p.expect(T![;]);
}
}
StmtWithSemi::No => {}
StmtWithSemi::Optional => {
- if p.at(SEMI) {
- p.eat(SEMI);
+ if p.at(T![;]) {
+ p.eat(T![;]);
}
}
}
// let d: i32 = 92;
// }
fn let_stmt(p: &mut Parser, m: Marker, with_semi: StmtWithSemi) {
- assert!(p.at(LET_KW));
+ assert!(p.at(T![let]));
p.bump();
patterns::pattern(p);
- if p.at(COLON) {
+ if p.at(T![:]) {
types::ascription(p);
}
- if p.eat(EQ) {
+ if p.eat(T![=]) {
expressions::expr(p);
}
match with_semi {
StmtWithSemi::Yes => {
- p.expect(SEMI);
+ p.expect(T![;]);
}
StmtWithSemi::No => {}
StmtWithSemi::Optional => {
- if p.at(SEMI) {
- p.eat(SEMI);
+ if p.at(T![;]) {
+ p.eat(T![;]);
}
}
}
// This is checked by a validator
attributes::inner_attributes(p);
- while !p.at(EOF) && !p.at(R_CURLY) {
+ while !p.at(EOF) && !p.at(T!['}']) {
// test nocontentexpr
// fn foo(){
// ;;;some_expr();;;;{;;;};;;;Ok(())
// }
- if p.current() == SEMI {
+ if p.current() == T![;] {
p.bump();
continue;
}
fn current_op(p: &Parser) -> (u8, Op) {
if let Some(t) = p.current3() {
match t {
- (L_ANGLE, L_ANGLE, EQ) => return (1, Op::Composite(SHLEQ, 3)),
- (R_ANGLE, R_ANGLE, EQ) => return (1, Op::Composite(SHREQ, 3)),
+ (T![<], T![<], T![=]) => return (1, Op::Composite(T![<<=], 3)),
+ (T![>], T![>], T![=]) => return (1, Op::Composite(T![>>=], 3)),
_ => (),
}
}
if let Some(t) = p.current2() {
match t {
- (PLUS, EQ) => return (1, Op::Composite(PLUSEQ, 2)),
- (MINUS, EQ) => return (1, Op::Composite(MINUSEQ, 2)),
- (STAR, EQ) => return (1, Op::Composite(STAREQ, 2)),
- (PERCENT, EQ) => return (1, Op::Composite(PERCENTEQ, 2)),
- (SLASH, EQ) => return (1, Op::Composite(SLASHEQ, 2)),
- (PIPE, EQ) => return (1, Op::Composite(PIPEEQ, 2)),
- (AMP, EQ) => return (1, Op::Composite(AMPEQ, 2)),
- (CARET, EQ) => return (1, Op::Composite(CARETEQ, 2)),
- (PIPE, PIPE) => return (3, Op::Composite(PIPEPIPE, 2)),
- (AMP, AMP) => return (4, Op::Composite(AMPAMP, 2)),
- (L_ANGLE, EQ) => return (5, Op::Composite(LTEQ, 2)),
- (R_ANGLE, EQ) => return (5, Op::Composite(GTEQ, 2)),
- (L_ANGLE, L_ANGLE) => return (9, Op::Composite(SHL, 2)),
- (R_ANGLE, R_ANGLE) => return (9, Op::Composite(SHR, 2)),
+ (T![+], T![=]) => return (1, Op::Composite(T![+=], 2)),
+ (T![-], T![=]) => return (1, Op::Composite(T![-=], 2)),
+ (T![*], T![=]) => return (1, Op::Composite(T![*=], 2)),
+ (T![%], T![=]) => return (1, Op::Composite(T![%=], 2)),
+ (T![/], T![=]) => return (1, Op::Composite(T![/=], 2)),
+ (T![|], T![=]) => return (1, Op::Composite(T![|=], 2)),
+ (T![&], T![=]) => return (1, Op::Composite(T![&=], 2)),
+ (T![^], T![=]) => return (1, Op::Composite(T![^=], 2)),
+ (T![|], T![|]) => return (3, Op::Composite(T![||], 2)),
+ (T![&], T![&]) => return (4, Op::Composite(T![&&], 2)),
+ (T![<], T![=]) => return (5, Op::Composite(T![<=], 2)),
+ (T![>], T![=]) => return (5, Op::Composite(T![>=], 2)),
+ (T![<], T![<]) => return (9, Op::Composite(T![<<], 2)),
+ (T![>], T![>]) => return (9, Op::Composite(T![>>], 2)),
_ => (),
}
}
let bp = match p.current() {
- EQ => 1,
- DOTDOT | DOTDOTEQ => 2,
- EQEQ | NEQ | L_ANGLE | R_ANGLE => 5,
- PIPE => 6,
- CARET => 7,
- AMP => 8,
- MINUS | PLUS => 10,
- STAR | SLASH | PERCENT => 11,
+ T![=] => 1,
+ T![..] | T![..=] => 2,
+ T![==] | T![!=] | T![<] | T![>] => 5,
+ T![|] => 6,
+ T![^] => 7,
+ T![&] => 8,
+ T![-] | T![+] => 10,
+ T![*] | T![/] | T![%] => 11,
_ => 0,
};
(bp, Op::Simple)
newly_dollar_open = false;
}
- let is_range = p.current() == DOTDOT || p.current() == DOTDOTEQ;
+ let is_range = p.current() == T![..] || p.current() == T![..=];
let (op_bp, op) = current_op(p);
if op_bp < bp {
break;
// let _ = &1;
// let _ = &mut &f();
// }
- AMP => {
+ T![&] => {
m = p.start();
p.bump();
- p.eat(MUT_KW);
+ p.eat(T![mut]);
REF_EXPR
}
// test unary_expr
// !!true;
// --1;
// }
- STAR | EXCL | MINUS => {
+ T![*] | T![!] | T![-] => {
m = p.start();
p.bump();
PREFIX_EXPR
}
// test full_range_expr
// fn foo() { xs[..]; }
- DOTDOT | DOTDOTEQ => {
+ T![..] | T![..=] => {
m = p.start();
p.bump();
if p.at_ts(EXPR_FIRST) {
// [] => {}
// }
// }
- L_PAREN if allow_calls => call_expr(p, lhs),
- L_BRACK if allow_calls => index_expr(p, lhs),
- DOT if p.nth(1) == IDENT && (p.nth(2) == L_PAREN || p.nth(2) == COLONCOLON) => {
+ T!['('] if allow_calls => call_expr(p, lhs),
+ T!['['] if allow_calls => index_expr(p, lhs),
+ T![.] if p.nth(1) == IDENT && (p.nth(2) == T!['('] || p.nth(2) == T![::]) => {
method_call_expr(p, lhs)
}
- DOT => field_expr(p, lhs),
+ T![.] => field_expr(p, lhs),
// test postfix_range
// fn foo() { let x = 1..; }
- DOTDOT | DOTDOTEQ if !EXPR_FIRST.contains(p.nth(1)) => {
+ T![..] | T![..=] if !EXPR_FIRST.contains(p.nth(1)) => {
let m = lhs.precede(p);
p.bump();
m.complete(p, RANGE_EXPR)
}
- QUESTION => try_expr(p, lhs),
- AS_KW => cast_expr(p, lhs),
+ T![?] => try_expr(p, lhs),
+ T![as] => cast_expr(p, lhs),
_ => break,
};
allow_calls = true
// f(<Foo as Trait>::func());
// }
fn call_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
- assert!(p.at(L_PAREN));
+ assert!(p.at(T!['(']));
let m = lhs.precede(p);
arg_list(p);
m.complete(p, CALL_EXPR)
// x[1][2];
// }
fn index_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
- assert!(p.at(L_BRACK));
+ assert!(p.at(T!['[']));
let m = lhs.precede(p);
p.bump();
expr(p);
- p.expect(R_BRACK);
+ p.expect(T![']']);
m.complete(p, INDEX_EXPR)
}
// y.bar::<T>(1, 2,);
// }
fn method_call_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
- assert!(p.at(DOT) && p.nth(1) == IDENT && (p.nth(2) == L_PAREN || p.nth(2) == COLONCOLON));
+ assert!(p.at(T![.]) && p.nth(1) == IDENT && (p.nth(2) == T!['('] || p.nth(2) == T![::]));
let m = lhs.precede(p);
p.bump();
name_ref(p);
type_args::opt_type_arg_list(p, true);
- if p.at(L_PAREN) {
+ if p.at(T!['(']) {
arg_list(p);
}
m.complete(p, METHOD_CALL_EXPR)
// x.0x01;
// }
fn field_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
- assert!(p.at(DOT));
+ assert!(p.at(T![.]));
let m = lhs.precede(p);
p.bump();
if p.at(IDENT) {
} else if p.at(INT_NUMBER) {
p.bump();
} else if p.at(FLOAT_NUMBER) {
- // FIXME: How to recover and instead parse INT + DOT?
+ // FIXME: How to recover and instead parse INT + T![.]?
p.bump();
} else {
p.error("expected field name or number")
// x?;
// }
fn try_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
- assert!(p.at(QUESTION));
+ assert!(p.at(T![?]));
let m = lhs.precede(p);
p.bump();
m.complete(p, TRY_EXPR)
// 0x36 as u8 <= 0x37;
// }
fn cast_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
- assert!(p.at(AS_KW));
+ assert!(p.at(T![as]));
let m = lhs.precede(p);
p.bump();
// Use type_no_bounds(), because cast expressions are not
}
fn arg_list(p: &mut Parser) {
- assert!(p.at(L_PAREN));
+ assert!(p.at(T!['(']));
let m = p.start();
p.bump();
- while !p.at(R_PAREN) && !p.at(EOF) {
+ while !p.at(T![')']) && !p.at(EOF) {
if !p.at_ts(EXPR_FIRST) {
p.error("expected expression");
break;
}
expr(p);
- if !p.at(R_PAREN) && !p.expect(COMMA) {
+ if !p.at(T![')']) && !p.expect(T![,]) {
break;
}
}
- p.eat(R_PAREN);
+ p.eat(T![')']);
m.complete(p, ARG_LIST);
}
// let _ = format!();
// }
fn path_expr(p: &mut Parser, r: Restrictions) -> (CompletedMarker, BlockLike) {
- assert!(paths::is_path_start(p) || p.at(L_ANGLE));
+ assert!(paths::is_path_start(p) || p.at(T![<]));
let m = p.start();
paths::expr_path(p);
match p.current() {
- L_CURLY if !r.forbid_structs => {
+ T!['{'] if !r.forbid_structs => {
named_field_list(p);
(m.complete(p, STRUCT_LIT), BlockLike::NotBlock)
}
- EXCL => {
+ T![!] => {
let block_like = items::macro_call_after_excl(p);
(m.complete(p, MACRO_CALL), block_like)
}
// S { x, y: 32, ..Default::default() };
// }
pub(crate) fn named_field_list(p: &mut Parser) {
- assert!(p.at(L_CURLY));
+ assert!(p.at(T!['{']));
let m = p.start();
p.bump();
- while !p.at(EOF) && !p.at(R_CURLY) {
+ while !p.at(EOF) && !p.at(T!['}']) {
match p.current() {
// test struct_literal_field_with_attr
// fn main() {
// S { #[cfg(test)] field: 1 }
// }
- IDENT | POUND => {
+ IDENT | T![#] => {
let m = p.start();
attributes::outer_attributes(p);
name_ref(p);
- if p.eat(COLON) {
+ if p.eat(T![:]) {
expr(p);
}
m.complete(p, NAMED_FIELD);
}
- DOTDOT => {
+ T![..] => {
p.bump();
expr(p);
}
- L_CURLY => error_block(p, "expected a field"),
+ T!['{'] => error_block(p, "expected a field"),
_ => p.err_and_bump("expected identifier"),
}
- if !p.at(R_CURLY) {
- p.expect(COMMA);
+ if !p.at(T!['}']) {
+ p.expect(T![,]);
}
}
- p.expect(R_CURLY);
+ p.expect(T!['}']);
m.complete(p, NAMED_FIELD_LIST);
}
if let Some(m) = literal(p) {
return Some((m, BlockLike::NotBlock));
}
- if paths::is_path_start(p) || p.at(L_ANGLE) {
+ if paths::is_path_start(p) || p.at(T![<]) {
return Some(path_expr(p, r));
}
let la = p.nth(1);
let done = match p.current() {
- L_PAREN => tuple_expr(p),
- L_BRACK => array_expr(p),
- PIPE => lambda_expr(p),
- MOVE_KW if la == PIPE => lambda_expr(p),
- ASYNC_KW if la == PIPE || (la == MOVE_KW && p.nth(2) == PIPE) => lambda_expr(p),
- IF_KW => if_expr(p),
+ T!['('] => tuple_expr(p),
+ T!['['] => array_expr(p),
+ T![|] => lambda_expr(p),
+ T![move] if la == T![|] => lambda_expr(p),
+ T![async] if la == T![|] || (la == T![move] && p.nth(2) == T![|]) => lambda_expr(p),
+ T![if] => if_expr(p),
- LOOP_KW => loop_expr(p, None),
- FOR_KW => for_expr(p, None),
- WHILE_KW => while_expr(p, None),
- LIFETIME if la == COLON => {
+ T![loop] => loop_expr(p, None),
+ T![for] => for_expr(p, None),
+ T![while] => while_expr(p, None),
+ LIFETIME if la == T![:] => {
let m = p.start();
label(p);
match p.current() {
- LOOP_KW => loop_expr(p, Some(m)),
- FOR_KW => for_expr(p, Some(m)),
- WHILE_KW => while_expr(p, Some(m)),
- L_CURLY => block_expr(p, Some(m)),
+ T![loop] => loop_expr(p, Some(m)),
+ T![for] => for_expr(p, Some(m)),
+ T![while] => while_expr(p, Some(m)),
+ T!['{'] => block_expr(p, Some(m)),
_ => {
// test_err misplaced_label_err
// fn main() {
}
}
}
- ASYNC_KW if la == L_CURLY || (la == MOVE_KW && p.nth(2) == L_CURLY) => {
+ T![async] if la == T!['{'] || (la == T![move] && p.nth(2) == T!['{']) => {
let m = p.start();
p.bump();
- p.eat(MOVE_KW);
+ p.eat(T![move]);
block_expr(p, Some(m))
}
- MATCH_KW => match_expr(p),
- UNSAFE_KW if la == L_CURLY => {
+ T![match] => match_expr(p),
+ T![unsafe] if la == T!['{'] => {
let m = p.start();
p.bump();
block_expr(p, Some(m))
}
- L_CURLY => block_expr(p, None),
- RETURN_KW => return_expr(p),
- CONTINUE_KW => continue_expr(p),
- BREAK_KW => break_expr(p, r),
+ T!['{'] => block_expr(p, None),
+ T![return] => return_expr(p),
+ T![continue] => continue_expr(p),
+ T![break] => break_expr(p, r),
_ => {
p.err_recover("expected expression", EXPR_RECOVERY_SET);
return None;
// (1,);
// }
fn tuple_expr(p: &mut Parser) -> CompletedMarker {
- assert!(p.at(L_PAREN));
+ assert!(p.at(T!['(']));
let m = p.start();
- p.expect(L_PAREN);
+ p.expect(T!['(']);
let mut saw_comma = false;
let mut saw_expr = false;
- while !p.at(EOF) && !p.at(R_PAREN) {
+ while !p.at(EOF) && !p.at(T![')']) {
saw_expr = true;
if !p.at_ts(EXPR_FIRST) {
p.error("expected expression");
break;
}
expr(p);
- if !p.at(R_PAREN) {
+ if !p.at(T![')']) {
saw_comma = true;
- p.expect(COMMA);
+ p.expect(T![,]);
}
}
- p.expect(R_PAREN);
+ p.expect(T![')']);
m.complete(p, if saw_expr && !saw_comma { PAREN_EXPR } else { TUPLE_EXPR })
}
// [1; 2];
// }
fn array_expr(p: &mut Parser) -> CompletedMarker {
- assert!(p.at(L_BRACK));
+ assert!(p.at(T!['[']));
let m = p.start();
p.bump();
- if p.eat(R_BRACK) {
+ if p.eat(T![']']) {
return m.complete(p, ARRAY_EXPR);
}
expr(p);
- if p.eat(SEMI) {
+ if p.eat(T![;]) {
expr(p);
- p.expect(R_BRACK);
+ p.expect(T![']']);
return m.complete(p, ARRAY_EXPR);
}
- while !p.at(EOF) && !p.at(R_BRACK) {
- p.expect(COMMA);
- if p.at(R_BRACK) {
+ while !p.at(EOF) && !p.at(T![']']) {
+ p.expect(T![,]);
+ if p.at(T![']']) {
break;
}
if !p.at_ts(EXPR_FIRST) {
}
expr(p);
}
- p.expect(R_BRACK);
+ p.expect(T![']']);
m.complete(p, ARRAY_EXPR)
}
// }
fn lambda_expr(p: &mut Parser) -> CompletedMarker {
assert!(
- p.at(PIPE)
- || (p.at(MOVE_KW) && p.nth(1) == PIPE)
- || (p.at(ASYNC_KW) && p.nth(1) == PIPE)
- || (p.at(ASYNC_KW) && p.nth(1) == MOVE_KW && p.nth(2) == PIPE)
+ p.at(T![|])
+ || (p.at(T![move]) && p.nth(1) == T![|])
+ || (p.at(T![async]) && p.nth(1) == T![|])
+ || (p.at(T![async]) && p.nth(1) == T![move] && p.nth(2) == T![|])
);
let m = p.start();
- p.eat(ASYNC_KW);
- p.eat(MOVE_KW);
+ p.eat(T![async]);
+ p.eat(T![move]);
params::param_list_opt_types(p);
if opt_fn_ret_type(p) {
- if !p.at(L_CURLY) {
+ if !p.at(T!['{']) {
p.error("expected `{`");
}
}
// if S {};
// }
fn if_expr(p: &mut Parser) -> CompletedMarker {
- assert!(p.at(IF_KW));
+ assert!(p.at(T![if]));
let m = p.start();
p.bump();
cond(p);
block(p);
- if p.at(ELSE_KW) {
+ if p.at(T![else]) {
p.bump();
- if p.at(IF_KW) {
+ if p.at(T![if]) {
if_expr(p);
} else {
block(p);
// 'c: for x in () {}
// }
fn label(p: &mut Parser) {
- assert!(p.at(LIFETIME) && p.nth(1) == COLON);
+ assert!(p.at(LIFETIME) && p.nth(1) == T![:]);
let m = p.start();
p.bump();
p.bump();
// loop {};
// }
fn loop_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
- assert!(p.at(LOOP_KW));
+ assert!(p.at(T![loop]));
let m = m.unwrap_or_else(|| p.start());
p.bump();
block(p);
// while let Some(x) = it.next() {};
// }
fn while_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
- assert!(p.at(WHILE_KW));
+ assert!(p.at(T![while]));
let m = m.unwrap_or_else(|| p.start());
p.bump();
cond(p);
// for x in [] {};
// }
fn for_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
- assert!(p.at(FOR_KW));
+ assert!(p.at(T![for]));
let m = m.unwrap_or_else(|| p.start());
p.bump();
patterns::pattern(p);
- p.expect(IN_KW);
+ p.expect(T![in]);
expr_no_struct(p);
block(p);
m.complete(p, FOR_EXPR)
// }
fn cond(p: &mut Parser) {
let m = p.start();
- if p.eat(LET_KW) {
+ if p.eat(T![let]) {
patterns::pattern_list(p);
- p.expect(EQ);
+ p.expect(T![=]);
}
expr_no_struct(p);
m.complete(p, CONDITION);
// match S {};
// }
fn match_expr(p: &mut Parser) -> CompletedMarker {
- assert!(p.at(MATCH_KW));
+ assert!(p.at(T![match]));
let m = p.start();
p.bump();
expr_no_struct(p);
- if p.at(L_CURLY) {
+ if p.at(T!['{']) {
match_arm_list(p);
} else {
p.error("expected `{`")
}
pub(crate) fn match_arm_list(p: &mut Parser) {
- assert!(p.at(L_CURLY));
+ assert!(p.at(T!['{']));
let m = p.start();
- p.eat(L_CURLY);
+ p.eat(T!['{']);
// test match_arms_inner_attribute
// fn foo() {
// }
attributes::inner_attributes(p);
- while !p.at(EOF) && !p.at(R_CURLY) {
- if p.at(L_CURLY) {
+ while !p.at(EOF) && !p.at(T!['}']) {
+ if p.at(T!['{']) {
error_block(p, "expected match arm");
continue;
}
// }
// }
if match_arm(p).is_block() {
- p.eat(COMMA);
- } else if !p.at(R_CURLY) {
- p.expect(COMMA);
+ p.eat(T![,]);
+ } else if !p.at(T!['}']) {
+ p.expect(T![,]);
}
}
- p.expect(R_CURLY);
+ p.expect(T!['}']);
m.complete(p, MATCH_ARM_LIST);
}
attributes::outer_attributes(p);
patterns::pattern_list_r(p, TokenSet::empty());
- if p.at(IF_KW) {
+ if p.at(T![if]) {
match_guard(p);
}
- p.expect(FAT_ARROW);
+ p.expect(T![=>]);
let blocklike = expr_stmt(p).1;
m.complete(p, MATCH_ARM);
blocklike
// }
// }
fn match_guard(p: &mut Parser) -> CompletedMarker {
- assert!(p.at(IF_KW));
+ assert!(p.at(T![if]));
let m = p.start();
p.bump();
expr(p);
// 'label: {};
// }
fn block_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
- assert!(p.at(L_CURLY));
+ assert!(p.at(T!['{']));
let m = m.unwrap_or_else(|| p.start());
block(p);
m.complete(p, BLOCK_EXPR)
// return 92;
// }
fn return_expr(p: &mut Parser) -> CompletedMarker {
- assert!(p.at(RETURN_KW));
+ assert!(p.at(T![return]));
let m = p.start();
p.bump();
if p.at_ts(EXPR_FIRST) {
// }
// }
fn continue_expr(p: &mut Parser) -> CompletedMarker {
- assert!(p.at(CONTINUE_KW));
+ assert!(p.at(T![continue]));
let m = p.start();
p.bump();
p.eat(LIFETIME);
// }
// }
fn break_expr(p: &mut Parser, r: Restrictions) -> CompletedMarker {
- assert!(p.at(BREAK_KW));
+ assert!(p.at(T![break]));
let m = p.start();
p.bump();
p.eat(LIFETIME);
// for i in break {}
// match break {}
// }
- if p.at_ts(EXPR_FIRST) && !(r.forbid_structs && p.at(L_CURLY)) {
+ if p.at_ts(EXPR_FIRST) && !(r.forbid_structs && p.at(T!['{'])) {
expr(p);
}
m.complete(p, BREAK_EXPR)
// struct S;
pub(super) fn mod_contents(p: &mut Parser, stop_on_r_curly: bool) {
attributes::inner_attributes(p);
- while !p.at(EOF) && !(stop_on_r_curly && p.at(R_CURLY)) {
+ while !p.at(EOF) && !(stop_on_r_curly && p.at(T!['}'])) {
item_or_macro(p, stop_on_r_curly, ItemFlavor::Mod)
}
}
match macro_call(p) {
BlockLike::Block => (),
BlockLike::NotBlock => {
- p.expect(SEMI);
+ p.expect(T![;]);
}
}
m.complete(p, MACRO_CALL);
} else {
m.abandon(p);
- if p.at(L_CURLY) {
+ if p.at(T!['{']) {
error_block(p, "expected an item");
- } else if p.at(R_CURLY) && !stop_on_r_curly {
+ } else if p.at(T!['}']) && !stop_on_r_curly {
let e = p.start();
p.error("unmatched `}`");
p.bump();
e.complete(p, ERROR);
- } else if !p.at(EOF) && !p.at(R_CURLY) {
+ } else if !p.at(EOF) && !p.at(T!['}']) {
p.err_and_bump("expected an item");
} else {
p.error("expected an item");
let mut has_mods = false;
// modifiers
- has_mods |= p.eat(CONST_KW);
+ has_mods |= p.eat(T![const]);
// test_err unsafe_block_in_mod
// fn foo(){} unsafe { } fn bar(){}
- if p.at(UNSAFE_KW) && p.nth(1) != L_CURLY {
- p.eat(UNSAFE_KW);
+ if p.at(T![unsafe]) && p.nth(1) != T!['{'] {
+ p.eat(T![unsafe]);
has_mods = true;
}
// test_err async_without_semicolon
// fn foo() { let _ = async {} }
- if p.at(ASYNC_KW) && p.nth(1) != L_CURLY && p.nth(1) != MOVE_KW && p.nth(1) != PIPE {
- p.eat(ASYNC_KW);
+ if p.at(T![async]) && p.nth(1) != T!['{'] && p.nth(1) != T![move] && p.nth(1) != T![|] {
+ p.eat(T![async]);
has_mods = true;
}
- if p.at(EXTERN_KW) {
+ if p.at(T![extern]) {
has_mods = true;
abi(p);
}
- if p.at(IDENT) && p.at_contextual_kw("auto") && p.nth(1) == TRAIT_KW {
- p.bump_remap(AUTO_KW);
+ if p.at(IDENT) && p.at_contextual_kw("auto") && p.nth(1) == T![trait] {
+ p.bump_remap(T![auto]);
has_mods = true;
}
- if p.at(IDENT) && p.at_contextual_kw("default") && p.nth(1) == IMPL_KW {
- p.bump_remap(DEFAULT_KW);
+ if p.at(IDENT) && p.at_contextual_kw("default") && p.nth(1) == T![impl ] {
+ p.bump_remap(T![default]);
has_mods = true;
}
// test_err wrong_order_fns
// async unsafe fn foo() {}
// unsafe const fn bar() {}
- FN_KW => {
+ T![fn] => {
fn_def(p, flavor);
m.complete(p, FN_DEF);
}
// test unsafe_auto_trait
// unsafe auto trait T {}
- TRAIT_KW => {
+ T![trait] => {
traits::trait_def(p);
m.complete(p, TRAIT_DEF);
}
// test unsafe_default_impl
// unsafe default impl Foo {}
- IMPL_KW => {
+ T![impl ] => {
traits::impl_block(p);
m.complete(p, IMPL_BLOCK);
}
match p.current() {
// test extern_crate
// extern crate foo;
- EXTERN_KW if la == CRATE_KW => extern_crate_item(p, m),
- TYPE_KW => type_def(p, m),
- MOD_KW => mod_item(p, m),
- STRUCT_KW => {
+ T![extern] if la == T![crate] => extern_crate_item(p, m),
+ T![type] => type_def(p, m),
+ T![mod] => mod_item(p, m),
+ T![struct] => {
// test struct_items
// struct Foo;
// struct Foo {}
// a: i32,
// b: f32,
// }
- nominal::struct_def(p, m, STRUCT_KW);
+ nominal::struct_def(p, m, T![struct]);
}
IDENT if p.at_contextual_kw("union") && p.nth(1) == IDENT => {
// test union_items
// a: i32,
// b: f32,
// }
- nominal::struct_def(p, m, UNION_KW);
+ nominal::struct_def(p, m, T![union]);
}
- ENUM_KW => nominal::enum_def(p, m),
- USE_KW => use_item::use_item(p, m),
- CONST_KW if (la == IDENT || la == MUT_KW) => consts::const_def(p, m),
- STATIC_KW => consts::static_def(p, m),
+ T![enum] => nominal::enum_def(p, m),
+ T![use] => use_item::use_item(p, m),
+ T![const] if (la == IDENT || la == T![mut]) => consts::const_def(p, m),
+ T![static] => consts::static_def(p, m),
// test extern_block
// extern {}
- EXTERN_KW
- if la == L_CURLY || ((la == STRING || la == RAW_STRING) && p.nth(2) == L_CURLY) =>
+ T![extern]
+ if la == T!['{'] || ((la == STRING || la == RAW_STRING) && p.nth(2) == T!['{']) =>
{
abi(p);
extern_item_list(p);
}
_ => return Err(m),
};
- if p.at(SEMI) {
+ if p.at(T![;]) {
p.err_and_bump(
"expected item, found `;`\n\
consider removing this semicolon",
}
fn extern_crate_item(p: &mut Parser, m: Marker) {
- assert!(p.at(EXTERN_KW));
+ assert!(p.at(T![extern]));
p.bump();
- assert!(p.at(CRATE_KW));
+ assert!(p.at(T![crate]));
p.bump();
name_ref(p);
opt_alias(p);
- p.expect(SEMI);
+ p.expect(T![;]);
m.complete(p, EXTERN_CRATE_ITEM);
}
pub(crate) fn extern_item_list(p: &mut Parser) {
- assert!(p.at(L_CURLY));
+ assert!(p.at(T!['{']));
let m = p.start();
p.bump();
mod_contents(p, true);
- p.expect(R_CURLY);
+ p.expect(T!['}']);
m.complete(p, EXTERN_ITEM_LIST);
}
fn fn_def(p: &mut Parser, flavor: ItemFlavor) {
- assert!(p.at(FN_KW));
+ assert!(p.at(T![fn]));
p.bump();
name_r(p, ITEM_RECOVERY_SET);
// fn foo<T: Clone + Copy>(){}
type_params::opt_type_param_list(p);
- if p.at(L_PAREN) {
+ if p.at(T!['(']) {
match flavor {
ItemFlavor::Mod => params::param_list(p),
ItemFlavor::Trait => params::param_list_opt_patterns(p),
// test fn_decl
// trait T { fn foo(); }
- if p.at(SEMI) {
+ if p.at(T![;]) {
p.bump();
} else {
expressions::block(p)
// test type_item
// type Foo = Bar;
fn type_def(p: &mut Parser, m: Marker) {
- assert!(p.at(TYPE_KW));
+ assert!(p.at(T![type]));
p.bump();
name(p);
// type Result<T> = ();
type_params::opt_type_param_list(p);
- if p.at(COLON) {
+ if p.at(T![:]) {
type_params::bounds(p);
}
// type Foo where Foo: Copy = ();
type_params::opt_where_clause(p);
- if p.eat(EQ) {
+ if p.eat(T![=]) {
types::type_(p);
}
- p.expect(SEMI);
+ p.expect(T![;]);
m.complete(p, TYPE_ALIAS_DEF);
}
pub(crate) fn mod_item(p: &mut Parser, m: Marker) {
- assert!(p.at(MOD_KW));
+ assert!(p.at(T![mod]));
p.bump();
name(p);
- if p.at(L_CURLY) {
+ if p.at(T!['{']) {
mod_item_list(p);
- } else if !p.eat(SEMI) {
+ } else if !p.eat(T![;]) {
p.error("expected `;` or `{`");
}
m.complete(p, MODULE);
}
pub(crate) fn mod_item_list(p: &mut Parser) {
- assert!(p.at(L_CURLY));
+ assert!(p.at(T!['{']));
let m = p.start();
p.bump();
mod_contents(p, true);
- p.expect(R_CURLY);
+ p.expect(T!['}']);
m.complete(p, ITEM_LIST);
}
}
pub(super) fn macro_call_after_excl(p: &mut Parser) -> BlockLike {
- p.expect(EXCL);
+ p.expect(T![!]);
if p.at(IDENT) {
name(p);
}
match p.current() {
- L_CURLY => {
+ T!['{'] => {
token_tree(p);
BlockLike::Block
}
- L_PAREN | L_BRACK => {
+ T!['('] | T!['['] => {
token_tree(p);
BlockLike::NotBlock
}
pub(crate) fn token_tree(p: &mut Parser) {
let closing_paren_kind = match p.current() {
- L_CURLY => R_CURLY,
- L_PAREN => R_PAREN,
- L_BRACK => R_BRACK,
+ T!['{'] => T!['}'],
+ T!['('] => T![')'],
+ T!['['] => T![']'],
_ => unreachable!(),
};
let m = p.start();
p.bump();
while !p.at(EOF) && !p.at(closing_paren_kind) {
match p.current() {
- L_CURLY | L_PAREN | L_BRACK => token_tree(p),
- R_CURLY => {
+ T!['{'] | T!['('] | T!['['] => token_tree(p),
+ T!['}'] => {
p.error("unmatched `}`");
m.complete(p, TOKEN_TREE);
return;
}
- R_PAREN | R_BRACK => p.err_and_bump("unmatched brace"),
+ T![')'] | T![']'] => p.err_and_bump("unmatched brace"),
_ => p.bump_raw(),
}
}
use super::*;
pub(super) fn static_def(p: &mut Parser, m: Marker) {
- const_or_static(p, m, STATIC_KW, STATIC_DEF)
+ const_or_static(p, m, T![static], STATIC_DEF)
}
pub(super) fn const_def(p: &mut Parser, m: Marker) {
- const_or_static(p, m, CONST_KW, CONST_DEF)
+ const_or_static(p, m, T![const], CONST_DEF)
}
fn const_or_static(p: &mut Parser, m: Marker, kw: SyntaxKind, def: SyntaxKind) {
assert!(p.at(kw));
p.bump();
- p.eat(MUT_KW); // FIXME: validator to forbid const mut
+ p.eat(T![mut]); // FIXME: validator to forbid const mut
name(p);
types::ascription(p);
- if p.eat(EQ) {
+ if p.eat(T![=]) {
expressions::expr(p);
}
- p.expect(SEMI);
+ p.expect(T![;]);
m.complete(p, def);
}
use super::*;
pub(super) fn struct_def(p: &mut Parser, m: Marker, kind: SyntaxKind) {
- assert!(p.at(STRUCT_KW) || p.at_contextual_kw("union"));
+ assert!(p.at(T![struct]) || p.at_contextual_kw("union"));
p.bump_remap(kind);
name_r(p, ITEM_RECOVERY_SET);
type_params::opt_type_param_list(p);
match p.current() {
- WHERE_KW => {
+ T![where] => {
type_params::opt_where_clause(p);
match p.current() {
- SEMI => {
+ T![;] => {
p.bump();
}
- L_CURLY => named_field_def_list(p),
+ T!['{'] => named_field_def_list(p),
_ => {
//FIXME: special case `(` error message
p.error("expected `;` or `{`");
}
}
}
- SEMI if kind == STRUCT_KW => {
+ T![;] if kind == T![struct] => {
p.bump();
}
- L_CURLY => named_field_def_list(p),
- L_PAREN if kind == STRUCT_KW => {
+ T!['{'] => named_field_def_list(p),
+ T!['('] if kind == T![struct] => {
pos_field_def_list(p);
// test tuple_struct_where
// struct Test<T>(T) where T: Clone;
// struct Test<T>(T);
type_params::opt_where_clause(p);
- p.expect(SEMI);
+ p.expect(T![;]);
}
- _ if kind == STRUCT_KW => {
+ _ if kind == T![struct] => {
p.error("expected `;`, `{`, or `(`");
}
_ => {
}
pub(super) fn enum_def(p: &mut Parser, m: Marker) {
- assert!(p.at(ENUM_KW));
+ assert!(p.at(T![enum]));
p.bump();
name_r(p, ITEM_RECOVERY_SET);
type_params::opt_type_param_list(p);
type_params::opt_where_clause(p);
- if p.at(L_CURLY) {
+ if p.at(T!['{']) {
enum_variant_list(p);
} else {
p.error("expected `{`")
}
pub(crate) fn enum_variant_list(p: &mut Parser) {
- assert!(p.at(L_CURLY));
+ assert!(p.at(T!['{']));
let m = p.start();
p.bump();
- while !p.at(EOF) && !p.at(R_CURLY) {
- if p.at(L_CURLY) {
+ while !p.at(EOF) && !p.at(T!['}']) {
+ if p.at(T!['{']) {
error_block(p, "expected enum variant");
continue;
}
if p.at(IDENT) {
name(p);
match p.current() {
- L_CURLY => named_field_def_list(p),
- L_PAREN => pos_field_def_list(p),
- EQ => {
+ T!['{'] => named_field_def_list(p),
+ T!['('] => pos_field_def_list(p),
+ T![=] => {
p.bump();
expressions::expr(p);
}
var.abandon(p);
p.err_and_bump("expected enum variant");
}
- if !p.at(R_CURLY) {
- p.expect(COMMA);
+ if !p.at(T!['}']) {
+ p.expect(T![,]);
}
}
- p.expect(R_CURLY);
+ p.expect(T!['}']);
m.complete(p, ENUM_VARIANT_LIST);
}
pub(crate) fn named_field_def_list(p: &mut Parser) {
- assert!(p.at(L_CURLY));
+ assert!(p.at(T!['{']));
let m = p.start();
p.bump();
- while !p.at(R_CURLY) && !p.at(EOF) {
- if p.at(L_CURLY) {
+ while !p.at(T!['}']) && !p.at(EOF) {
+ if p.at(T!['{']) {
error_block(p, "expected field");
continue;
}
named_field_def(p);
- if !p.at(R_CURLY) {
- p.expect(COMMA);
+ if !p.at(T!['}']) {
+ p.expect(T![,]);
}
}
- p.expect(R_CURLY);
+ p.expect(T!['}']);
m.complete(p, NAMED_FIELD_DEF_LIST);
fn named_field_def(p: &mut Parser) {
opt_visibility(p);
if p.at(IDENT) {
name(p);
- p.expect(COLON);
+ p.expect(T![:]);
types::type_(p);
m.complete(p, NAMED_FIELD_DEF);
} else {
}
fn pos_field_def_list(p: &mut Parser) {
- assert!(p.at(L_PAREN));
+ assert!(p.at(T!['(']));
let m = p.start();
- if !p.expect(L_PAREN) {
+ if !p.expect(T!['(']) {
return;
}
- while !p.at(R_PAREN) && !p.at(EOF) {
+ while !p.at(T![')']) && !p.at(EOF) {
let m = p.start();
// test pos_field_attrs
// struct S (
types::type_(p);
m.complete(p, POS_FIELD_DEF);
- if !p.at(R_PAREN) {
- p.expect(COMMA);
+ if !p.at(T![')']) {
+ p.expect(T![,]);
}
}
- p.expect(R_PAREN);
+ p.expect(T![')']);
m.complete(p, POS_FIELD_DEF_LIST);
}
// trait T<U>: Hash + Clone where U: Copy {}
// trait X<U: Debug + Display>: Hash + Clone where U: Copy {}
pub(super) fn trait_def(p: &mut Parser) {
- assert!(p.at(TRAIT_KW));
+ assert!(p.at(T![trait]));
p.bump();
name_r(p, ITEM_RECOVERY_SET);
type_params::opt_type_param_list(p);
- if p.at(COLON) {
+ if p.at(T![:]) {
type_params::bounds(p);
}
type_params::opt_where_clause(p);
- if p.at(L_CURLY) {
+ if p.at(T!['{']) {
trait_item_list(p);
} else {
p.error("expected `{`");
// fn bar(&self);
// }
pub(crate) fn trait_item_list(p: &mut Parser) {
- assert!(p.at(L_CURLY));
+ assert!(p.at(T!['{']));
let m = p.start();
p.bump();
- while !p.at(EOF) && !p.at(R_CURLY) {
- if p.at(L_CURLY) {
+ while !p.at(EOF) && !p.at(T!['}']) {
+ if p.at(T!['{']) {
error_block(p, "expected an item");
continue;
}
item_or_macro(p, true, ItemFlavor::Trait);
}
- p.expect(R_CURLY);
+ p.expect(T!['}']);
m.complete(p, ITEM_LIST);
}
// test impl_block
// impl Foo {}
pub(super) fn impl_block(p: &mut Parser) {
- assert!(p.at(IMPL_KW));
+ assert!(p.at(T![impl ]));
p.bump();
if choose_type_params_over_qpath(p) {
type_params::opt_type_param_list(p);
// test impl_block_neg
// impl !Send for X {}
- p.eat(EXCL);
+ p.eat(T![!]);
impl_type(p);
- if p.eat(FOR_KW) {
+ if p.eat(T![for]) {
impl_type(p);
}
type_params::opt_where_clause(p);
- if p.at(L_CURLY) {
+ if p.at(T!['{']) {
impl_item_list(p);
} else {
p.error("expected `{`");
// fn bar(&self) {}
// }
pub(crate) fn impl_item_list(p: &mut Parser) {
- assert!(p.at(L_CURLY));
+ assert!(p.at(T!['{']));
let m = p.start();
p.bump();
// test impl_inner_attributes
// }
attributes::inner_attributes(p);
- while !p.at(EOF) && !p.at(R_CURLY) {
- if p.at(L_CURLY) {
+ while !p.at(EOF) && !p.at(T!['}']) {
+ if p.at(T!['{']) {
error_block(p, "expected an item");
continue;
}
item_or_macro(p, true, ItemFlavor::Mod);
}
- p.expect(R_CURLY);
+ p.expect(T!['}']);
m.complete(p, ITEM_LIST);
}
// we disambiguate it in favor of generics (`impl<T> ::absolute::Path<T> { ... }`)
// because this is what almost always expected in practice, qualified paths in impls
// (`impl <Type>::AssocTy { ... }`) aren't even allowed by type checker at the moment.
- if !p.at(L_ANGLE) {
+ if !p.at(T![<]) {
return false;
}
- if p.nth(1) == POUND || p.nth(1) == R_ANGLE {
+ if p.nth(1) == T![#] || p.nth(1) == T![>] {
return true;
}
(p.nth(1) == LIFETIME || p.nth(1) == IDENT)
- && (p.nth(2) == R_ANGLE || p.nth(2) == COMMA || p.nth(2) == COLON || p.nth(2) == EQ)
+ && (p.nth(2) == T![>] || p.nth(2) == T![,] || p.nth(2) == T![:] || p.nth(2) == T![=])
}
// test_err impl_type
// impl impl NotType {}
// impl Trait2 for impl NotType {}
pub(crate) fn impl_type(p: &mut Parser) {
- if p.at(IMPL_KW) {
+ if p.at(T![impl ]) {
p.error("expected trait or type");
return;
}
use super::*;
pub(super) fn use_item(p: &mut Parser, m: Marker) {
- assert!(p.at(USE_KW));
+ assert!(p.at(T![use]));
p.bump();
use_tree(p);
- p.expect(SEMI);
+ p.expect(T![;]);
m.complete(p, USE_ITEM);
}
// use ::*;
// use some::path::{*};
// use some::path::{::*};
- (STAR, _) => p.bump(),
- (COLONCOLON, STAR) => {
+ (T![*], _) => p.bump(),
+ (T![::], T![*]) => {
// Parse `use ::*;`, which imports all from the crate root in Rust 2015
// This is invalid inside a use_tree_list, (e.g. `use some::path::{::*}`)
// but still parses and errors later: ('crate root in paths can only be used in start position')
// use {path::from::root}; // Rust 2015
// use ::{some::arbritrary::path}; // Rust 2015
// use ::{{{crate::export}}}; // Nonsensical but perfectly legal nestnig
- (L_CURLY, _) | (COLONCOLON, L_CURLY) => {
- if p.at(COLONCOLON) {
+ (T!['{'], _) | (T![::], T!['{']) => {
+ if p.at(T![::]) {
p.bump();
}
use_tree_list(p);
_ if paths::is_path_start(p) => {
paths::use_path(p);
match p.current() {
- AS_KW => {
+ T![as] => {
// test use_alias
// use some::path as some_name;
// use some::{
// use Trait as _;
opt_alias(p);
}
- COLONCOLON => {
+ T![::] => {
p.bump();
match p.current() {
- STAR => {
+ T![*] => {
p.bump();
}
// test use_tree_list_after_path
// use crate::{Item};
// use self::{Item};
- L_CURLY => use_tree_list(p),
+ T!['{'] => use_tree_list(p),
_ => {
// is this unreachable?
p.error("expected `{` or `*`");
}
pub(crate) fn use_tree_list(p: &mut Parser) {
- assert!(p.at(L_CURLY));
+ assert!(p.at(T!['{']));
let m = p.start();
p.bump();
- while !p.at(EOF) && !p.at(R_CURLY) {
+ while !p.at(EOF) && !p.at(T!['}']) {
use_tree(p);
- if !p.at(R_CURLY) {
- p.expect(COMMA);
+ if !p.at(T!['}']) {
+ p.expect(T![,]);
}
}
- p.expect(R_CURLY);
+ p.expect(T!['}']);
m.complete(p, USE_TREE_LIST);
}
}
fn list_(p: &mut Parser, flavor: Flavor) {
- let (bra, ket) = if flavor.type_required() { (L_PAREN, R_PAREN) } else { (PIPE, PIPE) };
+ let (bra, ket) = if flavor.type_required() { (T!['('], T![')']) } else { (T![|], T![|]) };
assert!(p.at(bra));
let m = p.start();
p.bump();
if flavor.type_required() {
opt_self_param(p);
}
- while !p.at(EOF) && !p.at(ket) && !(flavor.type_required() && p.at(DOTDOTDOT)) {
+ while !p.at(EOF) && !p.at(ket) && !(flavor.type_required() && p.at(T![...])) {
if !p.at_ts(VALUE_PARAMETER_FIRST) {
p.error("expected value parameter");
break;
}
value_parameter(p, flavor);
if !p.at(ket) {
- p.expect(COMMA);
+ p.expect(T![,]);
}
}
// test param_list_vararg
// extern "C" { fn printf(format: *const i8, ...) -> i32; }
if flavor.type_required() {
- p.eat(DOTDOTDOT);
+ p.eat(T![...]);
}
p.expect(ket);
m.complete(p, PARAM_LIST);
match flavor {
Flavor::OptionalType | Flavor::Normal => {
patterns::pattern(p);
- if p.at(COLON) || flavor.type_required() {
+ if p.at(T![:]) || flavor.type_required() {
types::ascription(p)
}
}
// trait Foo {
// fn bar(_: u64, mut x: i32);
// }
- if (la0 == IDENT || la0 == UNDERSCORE) && la1 == COLON
- || la0 == MUT_KW && la1 == IDENT && la2 == COLON
- || la0 == AMP && la1 == IDENT && la2 == COLON
- || la0 == AMP && la1 == MUT_KW && la2 == IDENT && la3 == COLON
+ if (la0 == IDENT || la0 == T![_]) && la1 == T![:]
+ || la0 == T![mut] && la1 == IDENT && la2 == T![:]
+ || la0 == T![&] && la1 == IDENT && la2 == T![:]
+ || la0 == T![&] && la1 == T![mut] && la2 == IDENT && la3 == T![:]
{
patterns::pattern(p);
types::ascription(p);
// }
fn opt_self_param(p: &mut Parser) {
let m;
- if p.at(SELF_KW) || p.at(MUT_KW) && p.nth(1) == SELF_KW {
+ if p.at(T![self]) || p.at(T![mut]) && p.nth(1) == T![self] {
m = p.start();
- p.eat(MUT_KW);
- p.eat(SELF_KW);
+ p.eat(T![mut]);
+ p.eat(T![self]);
// test arb_self_types
// impl S {
// fn a(self: &Self) {}
// fn b(mut self: Box<Self>) {}
// }
- if p.at(COLON) {
+ if p.at(T![:]) {
types::ascription(p);
}
} else {
let la2 = p.nth(2);
let la3 = p.nth(3);
let n_toks = match (p.current(), la1, la2, la3) {
- (AMP, SELF_KW, _, _) => 2,
- (AMP, MUT_KW, SELF_KW, _) => 3,
- (AMP, LIFETIME, SELF_KW, _) => 3,
- (AMP, LIFETIME, MUT_KW, SELF_KW) => 4,
+ (T![&], T![self], _, _) => 2,
+ (T![&], T![mut], T![self], _) => 3,
+ (T![&], LIFETIME, T![self], _) => 3,
+ (T![&], LIFETIME, T![mut], T![self]) => 4,
_ => return,
};
m = p.start();
}
}
m.complete(p, SELF_PARAM);
- if !p.at(R_PAREN) {
- p.expect(COMMA);
+ if !p.at(T![')']) {
+ p.expect(T![,]);
}
}
pub(super) fn is_path_start(p: &Parser) -> bool {
match p.current() {
- IDENT | SELF_KW | SUPER_KW | CRATE_KW | COLONCOLON => true,
+ IDENT | T![self] | T![super] | T![crate] | T![::] => true,
_ => false,
}
}
let mut qual = path.complete(p, PATH);
loop {
let use_tree = match p.nth(1) {
- STAR | L_CURLY => true,
+ T![*] | T!['{'] => true,
_ => false,
};
- if p.at(COLONCOLON) && !use_tree {
+ if p.at(T![::]) && !use_tree {
let path = qual.precede(p);
p.bump();
path_segment(p, mode, false);
// test qual_paths
// type X = <A as B>::Output;
// fn foo() { <usize as Default>::default(); }
- if first && p.eat(L_ANGLE) {
+ if first && p.eat(T![<]) {
types::type_(p);
- if p.eat(AS_KW) {
+ if p.eat(T![as]) {
if is_path_start(p) {
types::path_type(p);
} else {
p.error("expected a trait");
}
}
- p.expect(R_ANGLE);
+ p.expect(T![>]);
} else {
if first {
- p.eat(COLONCOLON);
+ p.eat(T![::]);
}
match p.current() {
IDENT => {
}
// test crate_path
// use crate::foo;
- SELF_KW | SUPER_KW | CRATE_KW => p.bump(),
+ T![self] | T![super] | T![crate] => p.bump(),
_ => {
p.err_recover("expected identifier", items::ITEM_RECOVERY_SET);
}
Mode::Type => {
// test path_fn_trait_args
// type F = Box<Fn(x: i32) -> ()>;
- if p.at(L_PAREN) {
+ if p.at(T!['(']) {
params::param_list_opt_patterns(p);
opt_fn_ret_type(p);
} else {
/// Parses a pattern list separated by pipes `|`
/// using the given `recovery_set`
pub(super) fn pattern_list_r(p: &mut Parser, recovery_set: TokenSet) {
- p.eat(PIPE);
+ p.eat(T![|]);
pattern_r(p, recovery_set);
- while p.eat(PIPE) {
+ while p.eat(T![|]) {
pattern_r(p, recovery_set);
}
}
// 200 .. 301=> (),
// }
// }
- if p.at(DOTDOTDOT) || p.at(DOTDOTEQ) || p.at(DOTDOT) {
+ if p.at(T![...]) || p.at(T![..=]) || p.at(T![..]) {
let m = lhs.precede(p);
p.bump();
atom_pat(p, recovery_set);
// fn main() {
// let m!(x) = 0;
// }
- else if lhs.kind() == PATH_PAT && p.at(EXCL) {
+ else if lhs.kind() == PATH_PAT && p.at(T![!]) {
let m = lhs.precede(p);
items::macro_call_after_excl(p);
m.complete(p, MACRO_CALL);
fn atom_pat(p: &mut Parser, recovery_set: TokenSet) -> Option<CompletedMarker> {
let la0 = p.nth(0);
let la1 = p.nth(1);
- if la0 == REF_KW
- || la0 == MUT_KW
- || (la0 == IDENT && !(la1 == COLONCOLON || la1 == L_PAREN || la1 == L_CURLY || la1 == EXCL))
+ if la0 == T![ref]
+ || la0 == T![mut]
+ || (la0 == IDENT && !(la1 == T![::] || la1 == T!['('] || la1 == T!['{'] || la1 == T![!]))
{
return Some(bind_pat(p, true));
}
}
let m = match la0 {
- UNDERSCORE => placeholder_pat(p),
- AMP => ref_pat(p),
- L_PAREN => tuple_pat(p),
- L_BRACK => slice_pat(p),
+ T![_] => placeholder_pat(p),
+ T![&] => ref_pat(p),
+ T!['('] => tuple_pat(p),
+ T!['['] => slice_pat(p),
_ => {
p.err_recover("expected pattern", recovery_set);
return None;
}
fn is_literal_pat_start(p: &mut Parser) -> bool {
- p.at(MINUS) && (p.nth(1) == INT_NUMBER || p.nth(1) == FLOAT_NUMBER)
+ p.at(T![-]) && (p.nth(1) == INT_NUMBER || p.nth(1) == FLOAT_NUMBER)
|| p.at_ts(expressions::LITERAL_FIRST)
}
fn literal_pat(p: &mut Parser) -> CompletedMarker {
assert!(is_literal_pat_start(p));
let m = p.start();
- if p.at(MINUS) {
+ if p.at(T![-]) {
p.bump();
}
expressions::literal(p);
let m = p.start();
paths::expr_path(p);
let kind = match p.current() {
- L_PAREN => {
+ T!['('] => {
tuple_pat_fields(p);
TUPLE_STRUCT_PAT
}
- L_CURLY => {
+ T!['{'] => {
field_pat_list(p);
STRUCT_PAT
}
// let S(_, .. , x) = ();
// }
fn tuple_pat_fields(p: &mut Parser) {
- assert!(p.at(L_PAREN));
+ assert!(p.at(T!['(']));
p.bump();
- pat_list(p, R_PAREN);
- p.expect(R_PAREN);
+ pat_list(p, T![')']);
+ p.expect(T![')']);
}
// test field_pat_list
// let S { h: _, } = ();
// }
fn field_pat_list(p: &mut Parser) {
- assert!(p.at(L_CURLY));
+ assert!(p.at(T!['{']));
let m = p.start();
p.bump();
- while !p.at(EOF) && !p.at(R_CURLY) {
+ while !p.at(EOF) && !p.at(T!['}']) {
match p.current() {
- DOTDOT => p.bump(),
- IDENT if p.nth(1) == COLON => field_pat(p),
- L_CURLY => error_block(p, "expected ident"),
+ T![..] => p.bump(),
+ IDENT if p.nth(1) == T![:] => field_pat(p),
+ T!['{'] => error_block(p, "expected ident"),
_ => {
bind_pat(p, false);
}
}
- if !p.at(R_CURLY) {
- p.expect(COMMA);
+ if !p.at(T!['}']) {
+ p.expect(T![,]);
}
}
- p.expect(R_CURLY);
+ p.expect(T!['}']);
m.complete(p, FIELD_PAT_LIST);
}
fn field_pat(p: &mut Parser) {
assert!(p.at(IDENT));
- assert!(p.nth(1) == COLON);
+ assert!(p.nth(1) == T![:]);
let m = p.start();
name(p);
// test placeholder_pat
// fn main() { let _ = (); }
fn placeholder_pat(p: &mut Parser) -> CompletedMarker {
- assert!(p.at(UNDERSCORE));
+ assert!(p.at(T![_]));
let m = p.start();
p.bump();
m.complete(p, PLACEHOLDER_PAT)
// let &mut b = ();
// }
fn ref_pat(p: &mut Parser) -> CompletedMarker {
- assert!(p.at(AMP));
+ assert!(p.at(T![&]));
let m = p.start();
p.bump();
- p.eat(MUT_KW);
+ p.eat(T![mut]);
pattern(p);
m.complete(p, REF_PAT)
}
// let (a, b, ..) = ();
// }
fn tuple_pat(p: &mut Parser) -> CompletedMarker {
- assert!(p.at(L_PAREN));
+ assert!(p.at(T!['(']));
let m = p.start();
tuple_pat_fields(p);
m.complete(p, TUPLE_PAT)
// let [a, b, ..] = [];
// }
fn slice_pat(p: &mut Parser) -> CompletedMarker {
- assert!(p.at(L_BRACK));
+ assert!(p.at(T!['[']));
let m = p.start();
p.bump();
- pat_list(p, R_BRACK);
- p.expect(R_BRACK);
+ pat_list(p, T![']']);
+ p.expect(T![']']);
m.complete(p, SLICE_PAT)
}
fn pat_list(p: &mut Parser, ket: SyntaxKind) {
while !p.at(EOF) && !p.at(ket) {
match p.current() {
- DOTDOT => p.bump(),
+ T![..] => p.bump(),
_ => {
if !p.at_ts(PATTERN_FIRST) {
p.error("expected a pattern");
}
}
if !p.at(ket) {
- p.expect(COMMA);
+ p.expect(T![,]);
}
}
}
// }
fn bind_pat(p: &mut Parser, with_at: bool) -> CompletedMarker {
let m = p.start();
- p.eat(REF_KW);
- p.eat(MUT_KW);
+ p.eat(T![ref]);
+ p.eat(T![mut]);
name(p);
- if with_at && p.eat(AT) {
+ if with_at && p.eat(T![@]) {
pattern(p);
}
m.complete(p, BIND_PAT)
pub(super) fn opt_type_arg_list(p: &mut Parser, colon_colon_required: bool) {
let m;
match (colon_colon_required, p.nth(0), p.nth(1)) {
- (_, COLONCOLON, L_ANGLE) => {
+ (_, T![::], T![<]) => {
m = p.start();
p.bump();
p.bump();
}
- (false, L_ANGLE, EQ) => return,
- (false, L_ANGLE, _) => {
+ (false, T![<], T![=]) => return,
+ (false, T![<], _) => {
m = p.start();
p.bump();
}
_ => return,
};
- while !p.at(EOF) && !p.at(R_ANGLE) {
+ while !p.at(EOF) && !p.at(T![>]) {
type_arg(p);
- if !p.at(R_ANGLE) && !p.expect(COMMA) {
+ if !p.at(T![>]) && !p.expect(T![,]) {
break;
}
}
- p.expect(R_ANGLE);
+ p.expect(T![>]);
m.complete(p, TYPE_ARG_LIST);
}
p.bump();
m.complete(p, LIFETIME_ARG);
}
- IDENT if p.nth(1) == EQ => {
+ IDENT if p.nth(1) == T![=] => {
name_ref(p);
p.bump();
types::type_(p);
use super::*;
pub(super) fn opt_type_param_list(p: &mut Parser) {
- if !p.at(L_ANGLE) {
+ if !p.at(T![<]) {
return;
}
type_param_list(p);
}
fn type_param_list(p: &mut Parser) {
- assert!(p.at(L_ANGLE));
+ assert!(p.at(T![<]));
let m = p.start();
p.bump();
- while !p.at(EOF) && !p.at(R_ANGLE) {
+ while !p.at(EOF) && !p.at(T![>]) {
let m = p.start();
// test generic_lifetime_type_attribute
p.err_and_bump("expected type parameter")
}
}
- if !p.at(R_ANGLE) && !p.expect(COMMA) {
+ if !p.at(T![>]) && !p.expect(T![,]) {
break;
}
}
- p.expect(R_ANGLE);
+ p.expect(T![>]);
m.complete(p, TYPE_PARAM_LIST);
}
fn lifetime_param(p: &mut Parser, m: Marker) {
assert!(p.at(LIFETIME));
p.bump();
- if p.at(COLON) {
+ if p.at(T![:]) {
lifetime_bounds(p);
}
m.complete(p, LIFETIME_PARAM);
fn type_param(p: &mut Parser, m: Marker) {
assert!(p.at(IDENT));
name(p);
- if p.at(COLON) {
+ if p.at(T![:]) {
bounds(p);
}
// test type_param_default
// struct S<T = i32>;
- if p.at(EQ) {
+ if p.at(T![=]) {
p.bump();
types::type_(p)
}
// test type_param_bounds
// struct S<T: 'a + ?Sized + (Copy)>;
pub(super) fn bounds(p: &mut Parser) {
- assert!(p.at(COLON));
+ assert!(p.at(T![:]));
p.bump();
bounds_without_colon(p);
}
fn lifetime_bounds(p: &mut Parser) {
- assert!(p.at(COLON));
+ assert!(p.at(T![:]));
p.bump();
while p.at(LIFETIME) {
p.bump();
- if !p.eat(PLUS) {
+ if !p.eat(T![+]) {
break;
}
}
pub(super) fn bounds_without_colon_m(p: &mut Parser, marker: Marker) -> CompletedMarker {
while type_bound(p) {
- if !p.eat(PLUS) {
+ if !p.eat(T![+]) {
break;
}
}
fn type_bound(p: &mut Parser) -> bool {
let m = p.start();
- let has_paren = p.eat(L_PAREN);
- p.eat(QUESTION);
+ let has_paren = p.eat(T!['(']);
+ p.eat(T![?]);
match p.current() {
LIFETIME => p.bump(),
- FOR_KW => types::for_type(p),
+ T![for] => types::for_type(p),
_ if paths::is_path_start(p) => types::path_type_(p, false),
_ => {
m.abandon(p);
}
}
if has_paren {
- p.expect(R_PAREN);
+ p.expect(T![')']);
}
m.complete(p, TYPE_BOUND);
// <T as Iterator>::Item: 'a
// {}
pub(super) fn opt_where_clause(p: &mut Parser) {
- if !p.at(WHERE_KW) {
+ if !p.at(T![where]) {
return;
}
let m = p.start();
while is_where_predicate(p) {
where_predicate(p);
- let comma = p.eat(COMMA);
+ let comma = p.eat(T![,]);
if is_where_clause_end(p) {
break;
fn is_where_predicate(p: &mut Parser) -> bool {
match p.current() {
LIFETIME => true,
- IMPL_KW => false,
+ T![impl ] => false,
token => types::TYPE_FIRST.contains(token),
}
}
fn is_where_clause_end(p: &mut Parser) -> bool {
- p.current() == L_CURLY || p.current() == SEMI || p.current() == EQ
+ p.current() == T!['{'] || p.current() == T![;] || p.current() == T![=]
}
fn where_predicate(p: &mut Parser) {
match p.current() {
LIFETIME => {
p.bump();
- if p.at(COLON) {
+ if p.at(T![:]) {
bounds(p);
} else {
p.error("expected colon");
}
}
- IMPL_KW => {
+ T![impl ] => {
p.error("expected lifetime or type");
}
_ => {
// { }
types::type_(p);
- if p.at(COLON) {
+ if p.at(T![:]) {
bounds(p);
} else {
p.error("expected colon");
fn type_with_bounds_cond(p: &mut Parser, allow_bounds: bool) {
match p.current() {
- L_PAREN => paren_or_tuple_type(p),
- EXCL => never_type(p),
- STAR => pointer_type(p),
- L_BRACK => array_or_slice_type(p),
- AMP => reference_type(p),
- UNDERSCORE => placeholder_type(p),
- FN_KW | UNSAFE_KW | EXTERN_KW => fn_pointer_type(p),
- FOR_KW => for_type(p),
- IMPL_KW => impl_trait_type(p),
- DYN_KW => dyn_trait_type(p),
+ T!['('] => paren_or_tuple_type(p),
+ T![!] => never_type(p),
+ T![*] => pointer_type(p),
+ T!['['] => array_or_slice_type(p),
+ T![&] => reference_type(p),
+ T![_] => placeholder_type(p),
+ T![fn] | T![unsafe] | T![extern] => fn_pointer_type(p),
+ T![for] => for_type(p),
+ T![impl ] => impl_trait_type(p),
+ T![dyn ] => dyn_trait_type(p),
// Some path types are not allowed to have bounds (no plus)
- L_ANGLE => path_type_(p, allow_bounds),
+ T![<] => path_type_(p, allow_bounds),
_ if paths::is_path_start(p) => path_or_macro_type_(p, allow_bounds),
_ => {
p.err_recover("expected type", TYPE_RECOVERY_SET);
}
pub(super) fn ascription(p: &mut Parser) {
- p.expect(COLON);
+ p.expect(T![:]);
type_(p)
}
fn paren_or_tuple_type(p: &mut Parser) {
- assert!(p.at(L_PAREN));
+ assert!(p.at(T!['(']));
let m = p.start();
p.bump();
let mut n_types: u32 = 0;
let mut trailing_comma: bool = false;
- while !p.at(EOF) && !p.at(R_PAREN) {
+ while !p.at(EOF) && !p.at(T![')']) {
n_types += 1;
type_(p);
- if p.eat(COMMA) {
+ if p.eat(T![,]) {
trailing_comma = true;
} else {
trailing_comma = false;
break;
}
}
- p.expect(R_PAREN);
+ p.expect(T![')']);
let kind = if n_types == 1 && !trailing_comma {
// test paren_type
// test never_type
// type Never = !;
fn never_type(p: &mut Parser) {
- assert!(p.at(EXCL));
+ assert!(p.at(T![!]));
let m = p.start();
p.bump();
m.complete(p, NEVER_TYPE);
}
fn pointer_type(p: &mut Parser) {
- assert!(p.at(STAR));
+ assert!(p.at(T![*]));
let m = p.start();
p.bump();
// test pointer_type_mut
// type M = *mut ();
// type C = *mut ();
- MUT_KW | CONST_KW => p.bump(),
+ T![mut] | T![const] => p.bump(),
_ => {
// test_err pointer_type_no_mutability
// type T = *();
}
fn array_or_slice_type(p: &mut Parser) {
- assert!(p.at(L_BRACK));
+ assert!(p.at(T!['[']));
let m = p.start();
p.bump();
let kind = match p.current() {
// test slice_type
// type T = [()];
- R_BRACK => {
+ T![']'] => {
p.bump();
SLICE_TYPE
}
// test array_type
// type T = [(); 92];
- SEMI => {
+ T![;] => {
p.bump();
expressions::expr(p);
- p.expect(R_BRACK);
+ p.expect(T![']']);
ARRAY_TYPE
}
// test_err array_type_missing_semi
// type B = &'static ();
// type C = &mut ();
fn reference_type(p: &mut Parser) {
- assert!(p.at(AMP));
+ assert!(p.at(T![&]));
let m = p.start();
p.bump();
p.eat(LIFETIME);
- p.eat(MUT_KW);
+ p.eat(T![mut]);
type_no_bounds(p);
m.complete(p, REFERENCE_TYPE);
}
// test placeholder_type
// type Placeholder = _;
fn placeholder_type(p: &mut Parser) {
- assert!(p.at(UNDERSCORE));
+ assert!(p.at(T![_]));
let m = p.start();
p.bump();
m.complete(p, PLACEHOLDER_TYPE);
// type D = extern "C" fn ( u8 , ... ) -> u8;
fn fn_pointer_type(p: &mut Parser) {
let m = p.start();
- p.eat(UNSAFE_KW);
- if p.at(EXTERN_KW) {
+ p.eat(T![unsafe]);
+ if p.at(T![extern]) {
abi(p);
}
// test_err fn_pointer_type_missing_fn
// type F = unsafe ();
- if !p.eat(FN_KW) {
+ if !p.eat(T![fn]) {
m.abandon(p);
p.error("expected `fn`");
return;
}
- if p.at(L_PAREN) {
+ if p.at(T!['(']) {
params::param_list_opt_patterns(p);
} else {
p.error("expected parameters")
}
pub(super) fn for_binder(p: &mut Parser) {
- assert!(p.at(FOR_KW));
+ assert!(p.at(T![for]));
p.bump();
- if p.at(L_ANGLE) {
+ if p.at(T![<]) {
type_params::opt_type_param_list(p);
} else {
p.error("expected `<`");
// fn foo<T>(_t: &T) where for<'a> &'a T: Iterator {}
// fn bar<T>(_t: &T) where for<'a> &'a mut T: Iterator {}
pub(super) fn for_type(p: &mut Parser) {
- assert!(p.at(FOR_KW));
+ assert!(p.at(T![for]));
let m = p.start();
for_binder(p);
match p.current() {
- FN_KW | UNSAFE_KW | EXTERN_KW => fn_pointer_type(p),
- AMP => reference_type(p),
+ T![fn] | T![unsafe] | T![extern] => fn_pointer_type(p),
+ T![&] => reference_type(p),
_ if paths::is_path_start(p) => path_type_(p, false),
_ => p.error("expected a path"),
}
// test impl_trait_type
// type A = impl Iterator<Item=Foo<'a>> + 'a;
fn impl_trait_type(p: &mut Parser) {
- assert!(p.at(IMPL_KW));
+ assert!(p.at(T![impl ]));
let m = p.start();
p.bump();
type_params::bounds_without_colon(p);
// test dyn_trait_type
// type A = dyn Iterator<Item=Foo<'a>> + 'a;
fn dyn_trait_type(p: &mut Parser) {
- assert!(p.at(DYN_KW));
+ assert!(p.at(T![dyn ]));
let m = p.start();
p.bump();
type_params::bounds_without_colon(p);
// type A = foo!();
// type B = crate::foo!();
fn path_or_macro_type_(p: &mut Parser, allow_bounds: bool) {
- assert!(paths::is_path_start(p) || p.at(L_ANGLE));
+ assert!(paths::is_path_start(p) || p.at(T![<]));
let m = p.start();
paths::type_path(p);
- let kind = if p.at(EXCL) {
+ let kind = if p.at(T![!]) {
items::macro_call_after_excl(p);
MACRO_CALL
} else {
}
pub(super) fn path_type_(p: &mut Parser, allow_bounds: bool) {
- assert!(paths::is_path_start(p) || p.at(L_ANGLE));
+ assert!(paths::is_path_start(p) || p.at(T![<]));
let m = p.start();
paths::type_path(p);
/// This turns a parsed PATH_TYPE optionally into a DYN_TRAIT_TYPE
/// with a TYPE_BOUND_LIST
fn opt_path_type_bounds_as_dyn_trait_type(p: &mut Parser, path_type_marker: CompletedMarker) {
- if !p.at(PLUS) {
+ if !p.at(T![+]) {
return;
}
// This gets consumed here so it gets properly set
// in the TYPE_BOUND_LIST
- p.eat(PLUS);
+ p.eat(T![+]);
// Parse rest of the bounds into the TYPE_BOUND_LIST
let m = type_params::bounds_without_colon_m(p, m);
SyntaxKind::{self, ERROR, EOF, TOMBSTONE},
TokenSource, ParseError, TokenSet,
event::Event,
+ T
};
/// `Parser` struct provides the low-level API for
// Handle parser composites
match kind {
- DOTDOTDOT | DOTDOTEQ => {
+ T![...] | T![..=] => {
self.bump_compound(kind, 3);
}
- DOTDOT | COLONCOLON | EQEQ | FAT_ARROW | NEQ | THIN_ARROW => {
+ T![..] | T![::] | T![==] | T![=>] | T![!=] | T![->] => {
self.bump_compound(kind, 2);
}
_ => {
/// Create an error node and consume the next token.
pub(crate) fn err_recover(&mut self, message: &str, recovery: TokenSet) {
- if self.at(SyntaxKind::L_CURLY) || self.at(SyntaxKind::R_CURLY) || self.at_ts(recovery) {
+ if self.at(T!['{']) || self.at(T!['}']) || self.at_ts(recovery) {
self.error(message);
} else {
let m = self.start();
let jn2 = self.token_source.is_token_joint_to_next(self.token_pos + n + 1);
let la3 = self.token_source.token_kind(self.token_pos + n + 2);
- use SyntaxKind::*;
-
match kind {
- DOT if jn1 && la2 == DOT && jn2 && la3 == DOT => Some((DOTDOTDOT, 3)),
- DOT if jn1 && la2 == DOT && la3 == EQ => Some((DOTDOTEQ, 3)),
- DOT if jn1 && la2 == DOT => Some((DOTDOT, 2)),
+ T![.] if jn1 && la2 == T![.] && jn2 && la3 == T![.] => Some((T![...], 3)),
+ T![.] if jn1 && la2 == T![.] && la3 == T![=] => Some((T![..=], 3)),
+ T![.] if jn1 && la2 == T![.] => Some((T![..], 2)),
- COLON if jn1 && la2 == COLON => Some((COLONCOLON, 2)),
- EQ if jn1 && la2 == EQ => Some((EQEQ, 2)),
- EQ if jn1 && la2 == R_ANGLE => Some((FAT_ARROW, 2)),
+ T![:] if jn1 && la2 == T![:] => Some((T![::], 2)),
+ T![=] if jn1 && la2 == T![=] => Some((T![==], 2)),
+ T![=] if jn1 && la2 == T![>] => Some((T![=>], 2)),
- EXCL if la2 == EQ => Some((NEQ, 2)),
- MINUS if la2 == R_ANGLE => Some((THIN_ARROW, 2)),
+ T![!] if la2 == T![=] => Some((T![!=], 2)),
+ T![-] if la2 == T![>] => Some((T![->], 2)),
_ => None,
}
}
use crate::{
SyntaxToken, SyntaxElement, SmolStr,
ast::{self, AstNode, AstChildren, children, child_opt},
- SyntaxKind::*
+ SyntaxKind::*,
+ T
};
#[derive(Debug, Clone, PartialEq, Eq)]
impl ast::RefExpr {
pub fn is_mut(&self) -> bool {
- self.syntax().children_with_tokens().any(|n| n.kind() == MUT_KW)
+ self.syntax().children_with_tokens().any(|n| n.kind() == T![mut])
}
}
impl ast::PrefixExpr {
pub fn op_kind(&self) -> Option<PrefixOp> {
match self.op_token()?.kind() {
- STAR => Some(PrefixOp::Deref),
- EXCL => Some(PrefixOp::Not),
- MINUS => Some(PrefixOp::Neg),
+ T![*] => Some(PrefixOp::Deref),
+ T![!] => Some(PrefixOp::Not),
+ T![-] => Some(PrefixOp::Neg),
_ => None,
}
}
fn op_details(&self) -> Option<(SyntaxToken, BinOp)> {
self.syntax().children_with_tokens().filter_map(|it| it.as_token()).find_map(|c| {
match c.kind() {
- PIPEPIPE => Some((c, BinOp::BooleanOr)),
- AMPAMP => Some((c, BinOp::BooleanAnd)),
- EQEQ => Some((c, BinOp::EqualityTest)),
- NEQ => Some((c, BinOp::NegatedEqualityTest)),
- LTEQ => Some((c, BinOp::LesserEqualTest)),
- GTEQ => Some((c, BinOp::GreaterEqualTest)),
- L_ANGLE => Some((c, BinOp::LesserTest)),
- R_ANGLE => Some((c, BinOp::GreaterTest)),
- PLUS => Some((c, BinOp::Addition)),
- STAR => Some((c, BinOp::Multiplication)),
- MINUS => Some((c, BinOp::Subtraction)),
- SLASH => Some((c, BinOp::Division)),
- PERCENT => Some((c, BinOp::Remainder)),
- SHL => Some((c, BinOp::LeftShift)),
- SHR => Some((c, BinOp::RightShift)),
- CARET => Some((c, BinOp::BitwiseXor)),
- PIPE => Some((c, BinOp::BitwiseOr)),
- AMP => Some((c, BinOp::BitwiseAnd)),
- DOTDOT => Some((c, BinOp::RangeRightOpen)),
- DOTDOTEQ => Some((c, BinOp::RangeRightClosed)),
- EQ => Some((c, BinOp::Assignment)),
- PLUSEQ => Some((c, BinOp::AddAssign)),
- SLASHEQ => Some((c, BinOp::DivAssign)),
- STAREQ => Some((c, BinOp::MulAssign)),
- PERCENTEQ => Some((c, BinOp::RemAssign)),
- SHREQ => Some((c, BinOp::ShrAssign)),
- SHLEQ => Some((c, BinOp::ShlAssign)),
- MINUSEQ => Some((c, BinOp::SubAssign)),
- PIPEEQ => Some((c, BinOp::BitOrAssign)),
- AMPEQ => Some((c, BinOp::BitAndAssign)),
- CARETEQ => Some((c, BinOp::BitXorAssign)),
+ T![||] => Some((c, BinOp::BooleanOr)),
+ T![&&] => Some((c, BinOp::BooleanAnd)),
+ T![==] => Some((c, BinOp::EqualityTest)),
+ T![!=] => Some((c, BinOp::NegatedEqualityTest)),
+ T![<=] => Some((c, BinOp::LesserEqualTest)),
+ T![>=] => Some((c, BinOp::GreaterEqualTest)),
+ T![<] => Some((c, BinOp::LesserTest)),
+ T![>] => Some((c, BinOp::GreaterTest)),
+ T![+] => Some((c, BinOp::Addition)),
+ T![*] => Some((c, BinOp::Multiplication)),
+ T![-] => Some((c, BinOp::Subtraction)),
+ T![/] => Some((c, BinOp::Division)),
+ T![%] => Some((c, BinOp::Remainder)),
+ T![<<] => Some((c, BinOp::LeftShift)),
+ T![>>] => Some((c, BinOp::RightShift)),
+ T![^] => Some((c, BinOp::BitwiseXor)),
+ T![|] => Some((c, BinOp::BitwiseOr)),
+ T![&] => Some((c, BinOp::BitwiseAnd)),
+ T![..] => Some((c, BinOp::RangeRightOpen)),
+ T![..=] => Some((c, BinOp::RangeRightClosed)),
+ T![=] => Some((c, BinOp::Assignment)),
+ T![+=] => Some((c, BinOp::AddAssign)),
+ T![/=] => Some((c, BinOp::DivAssign)),
+ T![*=] => Some((c, BinOp::MulAssign)),
+ T![%=] => Some((c, BinOp::RemAssign)),
+ T![>>=] => Some((c, BinOp::ShrAssign)),
+ T![<<=] => Some((c, BinOp::ShlAssign)),
+ T![-=] => Some((c, BinOp::SubAssign)),
+ T![|=] => Some((c, BinOp::BitOrAssign)),
+ T![&=] => Some((c, BinOp::BitAndAssign)),
+ T![^=] => Some((c, BinOp::BitXorAssign)),
_ => None,
}
})
}
fn is_repeat(&self) -> bool {
- self.syntax().children_with_tokens().any(|it| it.kind() == SEMI)
+ self.syntax().children_with_tokens().any(|it| it.kind() == T![;])
}
}
LiteralKind::FloatNumber { suffix: suffix }
}
STRING | RAW_STRING => LiteralKind::String,
- TRUE_KW | FALSE_KW => LiteralKind::Bool,
+ T![true] | T![false] => LiteralKind::Bool,
BYTE_STRING | RAW_BYTE_STRING => LiteralKind::ByteString,
CHAR => LiteralKind::Char,
BYTE => LiteralKind::Byte,
use itertools::Itertools;
-use crate::{SmolStr, SyntaxToken, ast::{self, AstNode, children, child_opt}, SyntaxKind::*, SyntaxElement};
+use crate::{SmolStr, SyntaxToken, ast::{self, AstNode, children, child_opt}, SyntaxKind::*, SyntaxElement, T};
use ra_parser::SyntaxKind;
impl ast::Name {
Some(prev) => prev,
};
- prev.kind() == EXCL
+ prev.kind() == T![!]
}
pub fn as_atom(&self) -> Option<SmolStr> {
PathSegmentKind::Name(name_ref)
} else {
match self.syntax().first_child_or_token()?.kind() {
- SELF_KW => PathSegmentKind::SelfKw,
- SUPER_KW => PathSegmentKind::SuperKw,
- CRATE_KW => PathSegmentKind::CrateKw,
+ T![self] => PathSegmentKind::SelfKw,
+ T![super] => PathSegmentKind::SuperKw,
+ T![crate] => PathSegmentKind::CrateKw,
_ => return None,
}
};
pub fn has_colon_colon(&self) -> bool {
match self.syntax.first_child_or_token().map(|s| s.kind()) {
- Some(COLONCOLON) => true,
+ Some(T![::]) => true,
_ => false,
}
}
pub fn has_semi(&self) -> bool {
match self.syntax().last_child_or_token() {
None => false,
- Some(node) => node.kind() == SEMI,
+ Some(node) => node.kind() == T![;],
}
}
}
impl ast::UseTree {
pub fn has_star(&self) -> bool {
- self.syntax().children_with_tokens().any(|it| it.kind() == STAR)
+ self.syntax().children_with_tokens().any(|it| it.kind() == T![*])
}
}
}
pub fn is_negative(&self) -> bool {
- self.syntax().children_with_tokens().any(|t| t.kind() == EXCL)
+ self.syntax().children_with_tokens().any(|t| t.kind() == T![!])
}
}
self.syntax()
.last_child_or_token()
.and_then(|it| it.as_token())
- .filter(|it| it.kind() == SEMI)
+ .filter(|it| it.kind() == T![;])
}
}
pub fn has_semi(&self) -> bool {
match self.syntax().last_child_or_token() {
None => false,
- Some(node) => node.kind() == SEMI,
+ Some(node) => node.kind() == T![;],
}
}
}
pub fn has_semi(&self) -> bool {
match self.syntax().last_child_or_token() {
None => false,
- Some(node) => node.kind() == SEMI,
+ Some(node) => node.kind() == T![;],
}
}
}
impl ast::RefPat {
pub fn is_mut(&self) -> bool {
- self.syntax().children_with_tokens().any(|n| n.kind() == MUT_KW)
+ self.syntax().children_with_tokens().any(|n| n.kind() == T![mut])
}
}
impl ast::BindPat {
pub fn is_mutable(&self) -> bool {
- self.syntax().children_with_tokens().any(|n| n.kind() == MUT_KW)
+ self.syntax().children_with_tokens().any(|n| n.kind() == T![mut])
}
pub fn is_ref(&self) -> bool {
- self.syntax().children_with_tokens().any(|n| n.kind() == REF_KW)
+ self.syntax().children_with_tokens().any(|n| n.kind() == T![ref])
}
}
impl ast::PointerType {
pub fn is_mut(&self) -> bool {
- self.syntax().children_with_tokens().any(|n| n.kind() == MUT_KW)
+ self.syntax().children_with_tokens().any(|n| n.kind() == T![mut])
}
}
impl ast::ReferenceType {
pub fn is_mut(&self) -> bool {
- self.syntax().children_with_tokens().any(|n| n.kind() == MUT_KW)
+ self.syntax().children_with_tokens().any(|n| n.kind() == T![mut])
}
}
self.syntax()
.children_with_tokens()
.filter_map(|it| it.as_token())
- .find(|it| it.kind() == SELF_KW)
+ .find(|it| it.kind() == T![self])
.expect("invalid tree: self param must have self")
}
pub fn kind(&self) -> SelfParamKind {
- let borrowed = self.syntax().children_with_tokens().any(|n| n.kind() == AMP);
+ let borrowed = self.syntax().children_with_tokens().any(|n| n.kind() == T![&]);
if borrowed {
// check for a `mut` coming after the & -- `mut &self` != `&mut self`
if self
.syntax()
.children_with_tokens()
- .skip_while(|n| n.kind() != AMP)
- .any(|n| n.kind() == MUT_KW)
+ .skip_while(|n| n.kind() != T![&])
+ .any(|n| n.kind() == T![mut])
{
SelfParamKind::MutRef
} else {
impl ast::TraitDef {
pub fn is_auto(&self) -> bool {
- self.syntax().children_with_tokens().any(|t| t.kind() == AUTO_KW)
+ self.syntax().children_with_tokens().any(|t| t.kind() == T![auto])
}
}
// There's a bunch of traversal methods on `SyntaxNode`:
assert_eq!(expr_syntax.parent(), Some(block.syntax()));
- assert_eq!(
- block.syntax().first_child_or_token().map(|it| it.kind()),
- Some(SyntaxKind::L_CURLY)
- );
+ assert_eq!(block.syntax().first_child_or_token().map(|it| it.kind()), Some(T!['{']));
assert_eq!(
expr_syntax.next_sibling_or_token().map(|it| it.kind()),
Some(SyntaxKind::WHITESPACE)
// As well as some iterator helpers:
let f = expr_syntax.ancestors().find_map(ast::FnDef::cast);
assert_eq!(f, Some(&*func));
- assert!(expr_syntax
- .siblings_with_tokens(Direction::Next)
- .any(|it| it.kind() == SyntaxKind::R_CURLY));
+ assert!(expr_syntax.siblings_with_tokens(Direction::Next).any(|it| it.kind() == T!['}']));
assert_eq!(
expr_syntax.descendants_with_tokens().count(),
8, // 5 tokens `1`, ` `, `+`, ` `, `!`
use crate::{
SyntaxKind::{self, *},
TextUnit,
+ T,
};
use self::{
match c {
// Possiblily multi-byte tokens,
// but we only produce single byte token now
- // DOTDOTDOT, DOTDOT, DOTDOTEQ, DOT
- '.' => return DOT,
- // COLONCOLON COLON
- ':' => return COLON,
- // EQEQ FATARROW EQ
- '=' => return EQ,
- // NEQ EXCL
- '!' => return EXCL,
- // THIN_ARROW MINUS
- '-' => return MINUS,
+ // T![...], T![..], T![..=], T![.]
+ '.' => return T![.],
+ // T![::] T![:]
+ ':' => return T![:],
+ // T![==] FATARROW T![=]
+ '=' => return T![=],
+ // T![!=] T![!]
+ '!' => return T![!],
+ // T![->] T![-]
+ '-' => return T![-],
// If the character is an ident start not followed by another single
// quote, then this is a lifetime name:
ptr.bump();
true
}
- ('_', None) => return UNDERSCORE,
- ('_', Some(c)) if !is_ident_continue(c) => return UNDERSCORE,
+ ('_', None) => return T![_],
+ ('_', Some(c)) if !is_ident_continue(c) => return T![_],
_ => false,
};
ptr.bump_while(is_ident_continue);
text_token_source::TextTokenSource,
text_tree_sink::TextTreeSink,
lexer::{tokenize, Token},
- }
+ },
+ T,
};
pub(crate) fn incremental_reparse(
fn is_balanced(tokens: &[Token]) -> bool {
if tokens.is_empty()
- || tokens.first().unwrap().kind != L_CURLY
- || tokens.last().unwrap().kind != R_CURLY
+ || tokens.first().unwrap().kind != T!['{']
+ || tokens.last().unwrap().kind != T!['}']
{
return false;
}
let mut balance = 0usize;
for t in &tokens[1..tokens.len() - 1] {
match t.kind {
- L_CURLY => balance += 1,
- R_CURLY => {
+ T!['{'] => balance += 1,
+ T!['}'] => {
balance = match balance.checked_sub(1) {
Some(b) => b,
None => return false,
use crate::{
SourceFile, SyntaxError, AstNode, SyntaxNode, TextUnit,
- SyntaxKind::{L_CURLY, R_CURLY, BYTE, BYTE_STRING, STRING, CHAR},
+ SyntaxKind::{BYTE, BYTE_STRING, STRING, CHAR},
ast,
algo::visit::{visitor_ctx, VisitorCtx},
+ T,
};
pub(crate) use unescape::EscapeError;
let mut stack = Vec::new();
for node in root.descendants() {
match node.kind() {
- L_CURLY => stack.push(node),
- R_CURLY => {
+ T!['{'] => stack.push(node),
+ T!['}'] => {
if let Some(pair) = stack.pop() {
assert_eq!(
node.parent(),
projects / rust.git / commitdiff