From 4560fe2abffde05e6ceb084e6d42207e0ce84b68 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Fri, 10 Apr 2020 15:53:09 +0200 Subject: Generate only minimal set of ineresting tokens --- crates/ra_syntax/src/ast.rs | 6 +- crates/ra_syntax/src/ast/edit.rs | 6 +- crates/ra_syntax/src/ast/extensions.rs | 16 +- crates/ra_syntax/src/ast/generated/tokens.rs | 1296 +------------------------- crates/ra_syntax/src/ast/traits.rs | 5 +- xtask/src/ast_src.rs | 2 + xtask/src/codegen.rs | 1 + xtask/src/codegen/gen_syntax.rs | 35 + 8 files changed, 61 insertions(+), 1306 deletions(-) diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs index 1ee60e74c..1437a38c9 100644 --- a/crates/ra_syntax/src/ast.rs +++ b/crates/ra_syntax/src/ast.rs @@ -80,7 +80,7 @@ impl Iterator for AstChildren { } mod support { - use super::{AstChildren, AstNode, AstToken, SyntaxKind, SyntaxNode, SyntaxToken}; + use super::{AstChildren, AstNode, SyntaxKind, SyntaxNode, SyntaxToken}; pub(super) fn child(parent: &SyntaxNode) -> Option { parent.children().find_map(N::cast) @@ -90,10 +90,6 @@ mod support { AstChildren::new(parent) } - pub(super) fn token(parent: &SyntaxNode) -> Option { - parent.children_with_tokens().filter_map(|it| it.into_token()).find_map(T::cast) - } - pub(super) fn token2(parent: &SyntaxNode, kind: SyntaxKind) -> Option { parent.children_with_tokens().filter_map(|it| it.into_token()).find(|it| it.kind() == kind) } diff --git a/crates/ra_syntax/src/ast/edit.rs b/crates/ra_syntax/src/ast/edit.rs index 7e14349d2..9e5411ee5 100644 --- a/crates/ra_syntax/src/ast/edit.rs +++ b/crates/ra_syntax/src/ast/edit.rs @@ -189,15 +189,15 @@ impl ast::RecordFieldList { impl ast::TypeParam { #[must_use] pub fn remove_bounds(&self) -> ast::TypeParam { - let colon = match self.colon() { + let colon = match self.colon_token() { Some(it) => it, None => return self.clone(), }; let end = match self.type_bound_list() { Some(it) => it.syntax().clone().into(), - None => colon.syntax().clone().into(), + None => colon.clone().into(), }; - self.replace_children(colon.syntax().clone().into()..=end, iter::empty()) + self.replace_children(colon.into()..=end, iter::empty()) } } diff --git a/crates/ra_syntax/src/ast/extensions.rs b/crates/ra_syntax/src/ast/extensions.rs index 03d94170d..d91275b53 100644 --- a/crates/ra_syntax/src/ast/extensions.rs +++ b/crates/ra_syntax/src/ast/extensions.rs @@ -5,7 +5,7 @@ use itertools::Itertools; use ra_parser::SyntaxKind; use crate::{ - ast::{self, support, AstNode, AstToken, AttrInput, NameOwner, SyntaxNode}, + ast::{self, support, AstNode, AttrInput, NameOwner, SyntaxNode}, SmolStr, SyntaxElement, SyntaxToken, T, }; @@ -327,23 +327,23 @@ impl ast::TypeBound { } } - pub fn const_question_token(&self) -> Option { + pub fn const_question_token(&self) -> Option { self.syntax() .children_with_tokens() .filter_map(|it| it.into_token()) .take_while(|it| it.kind() != T![const]) - .find_map(ast::Question::cast) + .find(|it| it.kind() == T![?]) } - pub fn question_token(&self) -> Option { + pub fn question_token(&self) -> Option { if self.const_token().is_some() { self.syntax() .children_with_tokens() .filter_map(|it| it.into_token()) .skip_while(|it| it.kind() != T![const]) - .find_map(ast::Question::cast) + .find(|it| it.kind() == T![?]) } else { - support::token(&self.syntax) + support::token2(&self.syntax, T![?]) } } } @@ -384,12 +384,12 @@ impl ast::MacroCall { } impl ast::LifetimeParam { - pub fn lifetime_bounds(&self) -> impl Iterator { + pub fn lifetime_bounds(&self) -> impl Iterator { self.syntax() .children_with_tokens() .filter_map(|it| it.into_token()) .skip_while(|x| x.kind() != T![:]) - .filter_map(ast::Lifetime::cast) + .filter(|it| it.kind() == T![lifetime]) } } diff --git a/crates/ra_syntax/src/ast/generated/tokens.rs b/crates/ra_syntax/src/ast/generated/tokens.rs index 293f91c2e..3950e2b7f 100644 --- a/crates/ra_syntax/src/ast/generated/tokens.rs +++ b/crates/ra_syntax/src/ast/generated/tokens.rs @@ -6,1246 +6,6 @@ use crate::{ SyntaxToken, }; #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Semi { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Semi { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Semi { - fn can_cast(kind: SyntaxKind) -> bool { kind == SEMI } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Comma { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Comma { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Comma { - fn can_cast(kind: SyntaxKind) -> bool { kind == COMMA } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LParen { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for LParen { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for LParen { - fn can_cast(kind: SyntaxKind) -> bool { kind == L_PAREN } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RParen { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for RParen { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for RParen { - fn can_cast(kind: SyntaxKind) -> bool { kind == R_PAREN } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LCurly { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for LCurly { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for LCurly { - fn can_cast(kind: SyntaxKind) -> bool { kind == L_CURLY } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RCurly { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for RCurly { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for RCurly { - fn can_cast(kind: SyntaxKind) -> bool { kind == R_CURLY } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LBrack { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for LBrack { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for LBrack { - fn can_cast(kind: SyntaxKind) -> bool { kind == L_BRACK } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RBrack { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for RBrack { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for RBrack { - fn can_cast(kind: SyntaxKind) -> bool { kind == R_BRACK } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LAngle { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for LAngle { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for LAngle { - fn can_cast(kind: SyntaxKind) -> bool { kind == L_ANGLE } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RAngle { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for RAngle { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for RAngle { - fn can_cast(kind: SyntaxKind) -> bool { kind == R_ANGLE } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct At { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for At { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for At { - fn can_cast(kind: SyntaxKind) -> bool { kind == AT } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Pound { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Pound { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Pound { - fn can_cast(kind: SyntaxKind) -> bool { kind == POUND } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Tilde { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Tilde { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Tilde { - fn can_cast(kind: SyntaxKind) -> bool { kind == TILDE } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Question { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Question { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Question { - fn can_cast(kind: SyntaxKind) -> bool { kind == QUESTION } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Dollar { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Dollar { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Dollar { - fn can_cast(kind: SyntaxKind) -> bool { kind == DOLLAR } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Amp { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Amp { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Amp { - fn can_cast(kind: SyntaxKind) -> bool { kind == AMP } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Pipe { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Pipe { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Pipe { - fn can_cast(kind: SyntaxKind) -> bool { kind == PIPE } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Plus { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Plus { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Plus { - fn can_cast(kind: SyntaxKind) -> bool { kind == PLUS } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Star { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Star { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Star { - fn can_cast(kind: SyntaxKind) -> bool { kind == STAR } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Slash { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Slash { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Slash { - fn can_cast(kind: SyntaxKind) -> bool { kind == SLASH } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Caret { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Caret { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Caret { - fn can_cast(kind: SyntaxKind) -> bool { kind == CARET } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Percent { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Percent { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Percent { - fn can_cast(kind: SyntaxKind) -> bool { kind == PERCENT } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Underscore { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Underscore { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Underscore { - fn can_cast(kind: SyntaxKind) -> bool { kind == UNDERSCORE } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Dot { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Dot { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Dot { - fn can_cast(kind: SyntaxKind) -> bool { kind == DOT } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Dotdot { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Dotdot { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Dotdot { - fn can_cast(kind: SyntaxKind) -> bool { kind == DOTDOT } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Dotdotdot { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Dotdotdot { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Dotdotdot { - fn can_cast(kind: SyntaxKind) -> bool { kind == DOTDOTDOT } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Dotdoteq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Dotdoteq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Dotdoteq { - fn can_cast(kind: SyntaxKind) -> bool { kind == DOTDOTEQ } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Colon { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Colon { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Colon { - fn can_cast(kind: SyntaxKind) -> bool { kind == COLON } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Coloncolon { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Coloncolon { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Coloncolon { - fn can_cast(kind: SyntaxKind) -> bool { kind == COLONCOLON } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Eq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Eq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Eq { - fn can_cast(kind: SyntaxKind) -> bool { kind == EQ } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Eqeq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Eqeq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Eqeq { - fn can_cast(kind: SyntaxKind) -> bool { kind == EQEQ } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct FatArrow { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for FatArrow { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for FatArrow { - fn can_cast(kind: SyntaxKind) -> bool { kind == FAT_ARROW } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Excl { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Excl { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Excl { - fn can_cast(kind: SyntaxKind) -> bool { kind == EXCL } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Neq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Neq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Neq { - fn can_cast(kind: SyntaxKind) -> bool { kind == NEQ } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Minus { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Minus { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Minus { - fn can_cast(kind: SyntaxKind) -> bool { kind == MINUS } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ThinArrow { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for ThinArrow { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for ThinArrow { - fn can_cast(kind: SyntaxKind) -> bool { kind == THIN_ARROW } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Lteq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Lteq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Lteq { - fn can_cast(kind: SyntaxKind) -> bool { kind == LTEQ } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Gteq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Gteq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Gteq { - fn can_cast(kind: SyntaxKind) -> bool { kind == GTEQ } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Pluseq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Pluseq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Pluseq { - fn can_cast(kind: SyntaxKind) -> bool { kind == PLUSEQ } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Minuseq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Minuseq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Minuseq { - fn can_cast(kind: SyntaxKind) -> bool { kind == MINUSEQ } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Pipeeq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Pipeeq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Pipeeq { - fn can_cast(kind: SyntaxKind) -> bool { kind == PIPEEQ } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Ampeq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Ampeq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Ampeq { - fn can_cast(kind: SyntaxKind) -> bool { kind == AMPEQ } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Careteq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Careteq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Careteq { - fn can_cast(kind: SyntaxKind) -> bool { kind == CARETEQ } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Slasheq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Slasheq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Slasheq { - fn can_cast(kind: SyntaxKind) -> bool { kind == SLASHEQ } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Stareq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Stareq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Stareq { - fn can_cast(kind: SyntaxKind) -> bool { kind == STAREQ } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Percenteq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Percenteq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Percenteq { - fn can_cast(kind: SyntaxKind) -> bool { kind == PERCENTEQ } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Ampamp { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Ampamp { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Ampamp { - fn can_cast(kind: SyntaxKind) -> bool { kind == AMPAMP } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Pipepipe { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Pipepipe { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Pipepipe { - fn can_cast(kind: SyntaxKind) -> bool { kind == PIPEPIPE } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Shl { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Shl { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Shl { - fn can_cast(kind: SyntaxKind) -> bool { kind == SHL } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Shr { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Shr { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Shr { - fn can_cast(kind: SyntaxKind) -> bool { kind == SHR } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Shleq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Shleq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Shleq { - fn can_cast(kind: SyntaxKind) -> bool { kind == SHLEQ } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Shreq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Shreq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Shreq { - fn can_cast(kind: SyntaxKind) -> bool { kind == SHREQ } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct IntNumber { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for IntNumber { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for IntNumber { - fn can_cast(kind: SyntaxKind) -> bool { kind == INT_NUMBER } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct FloatNumber { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for FloatNumber { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for FloatNumber { - fn can_cast(kind: SyntaxKind) -> bool { kind == FLOAT_NUMBER } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Char { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Char { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Char { - fn can_cast(kind: SyntaxKind) -> bool { kind == CHAR } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Byte { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Byte { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Byte { - fn can_cast(kind: SyntaxKind) -> bool { kind == BYTE } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct String { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for String { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for String { - fn can_cast(kind: SyntaxKind) -> bool { kind == STRING } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RawString { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for RawString { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for RawString { - fn can_cast(kind: SyntaxKind) -> bool { kind == RAW_STRING } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ByteString { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for ByteString { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for ByteString { - fn can_cast(kind: SyntaxKind) -> bool { kind == BYTE_STRING } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RawByteString { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for RawByteString { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for RawByteString { - fn can_cast(kind: SyntaxKind) -> bool { kind == RAW_BYTE_STRING } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Error { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Error { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Error { - fn can_cast(kind: SyntaxKind) -> bool { kind == ERROR } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Ident { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Ident { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Ident { - fn can_cast(kind: SyntaxKind) -> bool { kind == IDENT } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct Whitespace { pub(crate) syntax: SyntaxToken, } @@ -1266,26 +26,6 @@ impl AstToken for Whitespace { fn syntax(&self) -> &SyntaxToken { &self.syntax } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Lifetime { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Lifetime { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Lifetime { - fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct Comment { pub(crate) syntax: SyntaxToken, } @@ -1306,36 +46,16 @@ impl AstToken for Comment { fn syntax(&self) -> &SyntaxToken { &self.syntax } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Shebang { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Shebang { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Shebang { - fn can_cast(kind: SyntaxKind) -> bool { kind == SHEBANG } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { &self.syntax } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LDollar { +pub struct String { pub(crate) syntax: SyntaxToken, } -impl std::fmt::Display for LDollar { +impl std::fmt::Display for String { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { std::fmt::Display::fmt(&self.syntax, f) } } -impl AstToken for LDollar { - fn can_cast(kind: SyntaxKind) -> bool { kind == L_DOLLAR } +impl AstToken for String { + fn can_cast(kind: SyntaxKind) -> bool { kind == STRING } fn cast(syntax: SyntaxToken) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1346,16 +66,16 @@ impl AstToken for LDollar { fn syntax(&self) -> &SyntaxToken { &self.syntax } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RDollar { +pub struct RawString { pub(crate) syntax: SyntaxToken, } -impl std::fmt::Display for RDollar { +impl std::fmt::Display for RawString { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { std::fmt::Display::fmt(&self.syntax, f) } } -impl AstToken for RDollar { - fn can_cast(kind: SyntaxKind) -> bool { kind == R_DOLLAR } +impl AstToken for RawString { + fn can_cast(kind: SyntaxKind) -> bool { kind == RAW_STRING } fn cast(syntax: SyntaxToken) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) diff --git a/crates/ra_syntax/src/ast/traits.rs b/crates/ra_syntax/src/ast/traits.rs index 4ed7cf73b..4d1a290c2 100644 --- a/crates/ra_syntax/src/ast/traits.rs +++ b/crates/ra_syntax/src/ast/traits.rs @@ -6,6 +6,7 @@ use stdx::SepBy; use crate::{ ast::{self, support, AstChildren, AstNode, AstToken}, syntax_node::SyntaxElementChildren, + SyntaxToken, T, }; pub trait TypeAscriptionOwner: AstNode { @@ -63,8 +64,8 @@ pub trait TypeBoundsOwner: AstNode { support::child(self.syntax()) } - fn colon(&self) -> Option { - support::token(self.syntax()) + fn colon_token(&self) -> Option { + support::token2(self.syntax(), T![:]) } } diff --git a/xtask/src/ast_src.rs b/xtask/src/ast_src.rs index 554afc76a..7a20d9991 100644 --- a/xtask/src/ast_src.rs +++ b/xtask/src/ast_src.rs @@ -225,6 +225,7 @@ pub(crate) const KINDS_SRC: KindsSrc = KindsSrc { }; pub(crate) struct AstSrc<'a> { + pub(crate) tokens: &'a [&'a str], pub(crate) nodes: &'a [AstNodeSrc<'a>], pub(crate) enums: &'a [AstEnumSrc<'a>], } @@ -303,6 +304,7 @@ macro_rules! ast_enums { } pub(crate) const AST_SRC: AstSrc = AstSrc { + tokens: &["Whitespace", "Comment", "String", "RawString"], nodes: &ast_nodes! { struct SourceFile: ModuleItemOwner, AttrsOwner { modules: [Module], diff --git a/xtask/src/codegen.rs b/xtask/src/codegen.rs index e6ba2009c..678b40133 100644 --- a/xtask/src/codegen.rs +++ b/xtask/src/codegen.rs @@ -24,6 +24,7 @@ const ERR_INLINE_TESTS_DIR: &str = "crates/ra_syntax/test_data/parser/inline/err const SYNTAX_KINDS: &str = "crates/ra_parser/src/syntax_kind/generated.rs"; const AST_NODES: &str = "crates/ra_syntax/src/ast/generated/nodes.rs"; +const AST_TOKENS: &str = "crates/ra_syntax/src/ast/generated/tokens.rs"; const ASSISTS_DIR: &str = "crates/ra_assists/src/handlers"; const ASSISTS_TESTS: &str = "crates/ra_assists/src/doc_tests/generated.rs"; diff --git a/xtask/src/codegen/gen_syntax.rs b/xtask/src/codegen/gen_syntax.rs index ce18f2b8f..fa48853d2 100644 --- a/xtask/src/codegen/gen_syntax.rs +++ b/xtask/src/codegen/gen_syntax.rs @@ -19,6 +19,10 @@ pub fn generate_syntax(mode: Mode) -> Result<()> { let syntax_kinds = generate_syntax_kinds(KINDS_SRC)?; update(syntax_kinds_file.as_path(), &syntax_kinds, mode)?; + let ast_tokens_file = project_root().join(codegen::AST_TOKENS); + let contents = generate_tokens(KINDS_SRC, AST_SRC)?; + update(ast_tokens_file.as_path(), &contents, mode)?; + let ast_nodes_file = project_root().join(codegen::AST_NODES); let contents = generate_nodes(KINDS_SRC, AST_SRC)?; update(ast_nodes_file.as_path(), &contents, mode)?; @@ -33,6 +37,37 @@ struct ElementKinds { has_tokens: bool, } +fn generate_tokens(kinds: KindsSrc<'_>, grammar: AstSrc<'_>) -> Result { + let tokens = grammar.tokens.iter().map(|token| { + let name = format_ident!("{}", token); + let kind = format_ident!("{}", to_upper_snake_case(token)); + quote! { + #[derive(Debug, Clone, PartialEq, Eq, Hash)] + pub struct #name { + pub(crate) syntax: SyntaxToken, + } + impl std::fmt::Display for #name { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } + } + impl AstToken for #name { + fn can_cast(kind: SyntaxKind) -> bool { kind == #kind } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None } + } + fn syntax(&self) -> &SyntaxToken { &self.syntax } + } + } + }); + + let pretty = crate::reformat(quote! { + use crate::{SyntaxKind::{self, *}, SyntaxToken, ast::AstToken}; + #(#tokens)* + })?; + Ok(pretty) +} + fn generate_nodes(kinds: KindsSrc<'_>, grammar: AstSrc<'_>) -> Result { let nodes = grammar.nodes.iter().map(|node| { let name = format_ident!("{}", node.name); -- cgit v1.2.3