bendns' repos / rust-analyzer
Unnamed repository; edit this file 'description' to name the repository.
Diffstat (limited to 'crates/syntax/src/ast/generated/nodes.rs')
-rw-r--r--crates/syntax/src/ast/generated/nodes.rs122
1 files changed, 122 insertions, 0 deletions
diff --git a/crates/syntax/src/ast/generated/nodes.rs b/crates/syntax/src/ast/generated/nodes.rs
index e3e5c499d4..c18311bfa3 100644
--- a/crates/syntax/src/ast/generated/nodes.rs
+++ b/crates/syntax/src/ast/generated/nodes.rs
@@ -1186,6 +1186,15 @@ impl NeverType {
#[inline]
pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
}
+pub struct NotNull {
+ pub(crate) syntax: SyntaxNode,
+}
+impl NotNull {
+ #[inline]
+ pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
+ #[inline]
+ pub fn null_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![null]) }
+}
pub struct OffsetOfExpr {
pub(crate) syntax: SyntaxNode,
}
@@ -1357,6 +1366,29 @@ impl PathType {
#[inline]
pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
}
+pub struct PatternType {
+ pub(crate) syntax: SyntaxNode,
+}
+impl PatternType {
+ #[inline]
+ pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
+ #[inline]
+ pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
+ #[inline]
+ pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) }
+ #[inline]
+ pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
+ #[inline]
+ pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
+ #[inline]
+ pub fn builtin_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![builtin]) }
+ #[inline]
+ pub fn is_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![is]) }
+ #[inline]
+ pub fn pattern_type_token(&self) -> Option<SyntaxToken> {
+ support::token(&self.syntax, T![pattern_type])
+ }
+}
pub struct PrefixExpr {
pub(crate) syntax: SyntaxNode,
}
@@ -2275,6 +2307,7 @@ pub enum Pat {
IdentPat(IdentPat),
LiteralPat(LiteralPat),
MacroPat(MacroPat),
+ NotNull(NotNull),
OrPat(OrPat),
ParenPat(ParenPat),
PathPat(PathPat),
@@ -2307,6 +2340,7 @@ pub enum Type {
NeverType(NeverType),
ParenType(ParenType),
PathType(PathType),
+ PatternType(PatternType),
PtrType(PtrType),
RefType(RefType),
SliceType(SliceType),
@@ -5363,6 +5397,38 @@ impl fmt::Debug for NeverType {
f.debug_struct("NeverType").field("syntax", &self.syntax).finish()
}
}
+impl AstNode for NotNull {
+ #[inline]
+ fn kind() -> SyntaxKind
+ where
+ Self: Sized,
+ {
+ NOT_NULL
+ }
+ #[inline]
+ fn can_cast(kind: SyntaxKind) -> bool { kind == NOT_NULL }
+ #[inline]
+ fn cast(syntax: SyntaxNode) -> Option<Self> {
+ if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
+ }
+ #[inline]
+ fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+impl hash::Hash for NotNull {
+ fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
+}
+impl Eq for NotNull {}
+impl PartialEq for NotNull {
+ fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
+}
+impl Clone for NotNull {
+ fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
+}
+impl fmt::Debug for NotNull {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_struct("NotNull").field("syntax", &self.syntax).finish()
+ }
+}
impl AstNode for OffsetOfExpr {
#[inline]
fn kind() -> SyntaxKind
@@ -5811,6 +5877,38 @@ impl fmt::Debug for PathType {
f.debug_struct("PathType").field("syntax", &self.syntax).finish()
}
}
+impl AstNode for PatternType {
+ #[inline]
+ fn kind() -> SyntaxKind
+ where
+ Self: Sized,
+ {
+ PATTERN_TYPE
+ }
+ #[inline]
+ fn can_cast(kind: SyntaxKind) -> bool { kind == PATTERN_TYPE }
+ #[inline]
+ fn cast(syntax: SyntaxNode) -> Option<Self> {
+ if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
+ }
+ #[inline]
+ fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+impl hash::Hash for PatternType {
+ fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
+}
+impl Eq for PatternType {}
+impl PartialEq for PatternType {
+ fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
+}
+impl Clone for PatternType {
+ fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
+}
+impl fmt::Debug for PatternType {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_struct("PatternType").field("syntax", &self.syntax).finish()
+ }
+}
impl AstNode for PrefixExpr {
#[inline]
fn kind() -> SyntaxKind
@@ -8581,6 +8679,10 @@ impl From<MacroPat> for Pat {
#[inline]
fn from(node: MacroPat) -> Pat { Pat::MacroPat(node) }
}
+impl From<NotNull> for Pat {
+ #[inline]
+ fn from(node: NotNull) -> Pat { Pat::NotNull(node) }
+}
impl From<OrPat> for Pat {
#[inline]
fn from(node: OrPat) -> Pat { Pat::OrPat(node) }
@@ -8636,6 +8738,7 @@ impl AstNode for Pat {
| IDENT_PAT
| LITERAL_PAT
| MACRO_PAT
+ | NOT_NULL
| OR_PAT
| PAREN_PAT
| PATH_PAT
@@ -8658,6 +8761,7 @@ impl AstNode for Pat {
IDENT_PAT => Pat::IdentPat(IdentPat { syntax }),
LITERAL_PAT => Pat::LiteralPat(LiteralPat { syntax }),
MACRO_PAT => Pat::MacroPat(MacroPat { syntax }),
+ NOT_NULL => Pat::NotNull(NotNull { syntax }),
OR_PAT => Pat::OrPat(OrPat { syntax }),
PAREN_PAT => Pat::ParenPat(ParenPat { syntax }),
PATH_PAT => Pat::PathPat(PathPat { syntax }),
@@ -8682,6 +8786,7 @@ impl AstNode for Pat {
Pat::IdentPat(it) => &it.syntax,
Pat::LiteralPat(it) => &it.syntax,
Pat::MacroPat(it) => &it.syntax,
+ Pat::NotNull(it) => &it.syntax,
Pat::OrPat(it) => &it.syntax,
Pat::ParenPat(it) => &it.syntax,
Pat::PathPat(it) => &it.syntax,
@@ -8748,6 +8853,10 @@ impl From<PathType> for Type {
#[inline]
fn from(node: PathType) -> Type { Type::PathType(node) }
}
+impl From<PatternType> for Type {
+ #[inline]
+ fn from(node: PatternType) -> Type { Type::PatternType(node) }
+}
impl From<PtrType> for Type {
#[inline]
fn from(node: PtrType) -> Type { Type::PtrType(node) }
@@ -8779,6 +8888,7 @@ impl AstNode for Type {
| NEVER_TYPE
| PAREN_TYPE
| PATH_TYPE
+ | PATTERN_TYPE
| PTR_TYPE
| REF_TYPE
| SLICE_TYPE
@@ -8798,6 +8908,7 @@ impl AstNode for Type {
NEVER_TYPE => Type::NeverType(NeverType { syntax }),
PAREN_TYPE => Type::ParenType(ParenType { syntax }),
PATH_TYPE => Type::PathType(PathType { syntax }),
+ PATTERN_TYPE => Type::PatternType(PatternType { syntax }),
PTR_TYPE => Type::PtrType(PtrType { syntax }),
REF_TYPE => Type::RefType(RefType { syntax }),
SLICE_TYPE => Type::SliceType(SliceType { syntax }),
@@ -8819,6 +8930,7 @@ impl AstNode for Type {
Type::NeverType(it) => &it.syntax,
Type::ParenType(it) => &it.syntax,
Type::PathType(it) => &it.syntax,
+ Type::PatternType(it) => &it.syntax,
Type::PtrType(it) => &it.syntax,
Type::RefType(it) => &it.syntax,
Type::SliceType(it) => &it.syntax,
@@ -10453,6 +10565,11 @@ impl std::fmt::Display for NeverType {
std::fmt::Display::fmt(self.syntax(), f)
}
}
+impl std::fmt::Display for NotNull {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ std::fmt::Display::fmt(self.syntax(), f)
+ }
+}
impl std::fmt::Display for OffsetOfExpr {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
std::fmt::Display::fmt(self.syntax(), f)
@@ -10523,6 +10640,11 @@ impl std::fmt::Display for PathType {
std::fmt::Display::fmt(self.syntax(), f)
}
}
+impl std::fmt::Display for PatternType {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ std::fmt::Display::fmt(self.syntax(), f)
+ }
+}
impl std::fmt::Display for PrefixExpr {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
std::fmt::Display::fmt(self.syntax(), f)