language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-10-29 19:17:12 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

refactor: Reduce codegen burden for SyntaxNode and SyntaxToken

Browse source
This commit is contained in:
Lukas Wirth 2025-03-21 10:54:38 +01:00
parent d6dc1bf05e
commit d31301cbe7
4 changed files with 2767 additions and 426 deletions
Download patch file Download diff file Expand all files Collapse all files

2929
crates/syntax/src/ast/generated/nodes.rs
View file

File diff suppressed because it is too large Load diff

171
crates/syntax/src/ast/generated/tokens.rs
View file

@ -5,8 +5,7 @@ use crate::{
SyntaxKind::{self, *},
SyntaxToken,
};
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
use std::{fmt, hash};
pub struct Byte {
pub(crate) syntax: SyntaxToken,
}
@ -26,8 +25,21 @@ impl AstToken for Byte {
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
impl fmt::Debug for Byte {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Byte").field("syntax", &self.syntax).finish()
}
}
impl Clone for Byte {
fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl hash::Hash for Byte {
fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for Byte {}
impl PartialEq for Byte {
fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
pub struct ByteString {
pub(crate) syntax: SyntaxToken,
}
@ -47,8 +59,21 @@ impl AstToken for ByteString {
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
impl fmt::Debug for ByteString {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("ByteString").field("syntax", &self.syntax).finish()
}
}
impl Clone for ByteString {
fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl hash::Hash for ByteString {
fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for ByteString {}
impl PartialEq for ByteString {
fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
pub struct CString {
pub(crate) syntax: SyntaxToken,
}
@ -68,8 +93,21 @@ impl AstToken for CString {
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
impl fmt::Debug for CString {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("CString").field("syntax", &self.syntax).finish()
}
}
impl Clone for CString {
fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl hash::Hash for CString {
fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for CString {}
impl PartialEq for CString {
fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
pub struct Char {
pub(crate) syntax: SyntaxToken,
}
@ -89,8 +127,21 @@ impl AstToken for Char {
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
impl fmt::Debug for Char {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Char").field("syntax", &self.syntax).finish()
}
}
impl Clone for Char {
fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl hash::Hash for Char {
fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for Char {}
impl PartialEq for Char {
fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
pub struct Comment {
pub(crate) syntax: SyntaxToken,
}
@ -110,8 +161,21 @@ impl AstToken for Comment {
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
impl fmt::Debug for Comment {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Comment").field("syntax", &self.syntax).finish()
}
}
impl Clone for Comment {
fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl hash::Hash for Comment {
fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for Comment {}
impl PartialEq for Comment {
fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
pub struct FloatNumber {
pub(crate) syntax: SyntaxToken,
}
@ -131,8 +195,21 @@ impl AstToken for FloatNumber {
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
impl fmt::Debug for FloatNumber {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("FloatNumber").field("syntax", &self.syntax).finish()
}
}
impl Clone for FloatNumber {
fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl hash::Hash for FloatNumber {
fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for FloatNumber {}
impl PartialEq for FloatNumber {
fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
pub struct Ident {
pub(crate) syntax: SyntaxToken,
}
@ -152,8 +229,21 @@ impl AstToken for Ident {
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
impl fmt::Debug for Ident {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Ident").field("syntax", &self.syntax).finish()
}
}
impl Clone for Ident {
fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl hash::Hash for Ident {
fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for Ident {}
impl PartialEq for Ident {
fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
pub struct IntNumber {
pub(crate) syntax: SyntaxToken,
}
@ -173,8 +263,21 @@ impl AstToken for IntNumber {
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
impl fmt::Debug for IntNumber {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("IntNumber").field("syntax", &self.syntax).finish()
}
}
impl Clone for IntNumber {
fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl hash::Hash for IntNumber {
fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for IntNumber {}
impl PartialEq for IntNumber {
fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
pub struct String {
pub(crate) syntax: SyntaxToken,
}
@ -194,8 +297,21 @@ impl AstToken for String {
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
impl fmt::Debug for String {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("String").field("syntax", &self.syntax).finish()
}
}
impl Clone for String {
fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl hash::Hash for String {
fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for String {}
impl PartialEq for String {
fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
pub struct Whitespace {
pub(crate) syntax: SyntaxToken,
}
@ -215,3 +331,18 @@ impl AstToken for Whitespace {
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
impl fmt::Debug for Whitespace {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Whitespace").field("syntax", &self.syntax).finish()
}
}
impl Clone for Whitespace {
fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl hash::Hash for Whitespace {
fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for Whitespace {}
impl PartialEq for Whitespace {
fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}