From a95bff5559edc49b585c1d767c0979ed493358f3 Mon Sep 17 00:00:00 2001 From: Marek Kaput Date: Fri, 10 Jan 2025 13:07:12 +0100 Subject: [PATCH 1/2] Add TypedSyntaxNode::cast and Terminal::cast_token methods (#7044) --- crates/cairo-lang-doc/src/parser.rs | 7 +- .../src/formatter_impl.rs | 11 +- .../src/plugins/generate_trait.rs | 8 +- .../src/plugin/starknet_module/mod.rs | 6 +- .../src/generator.rs | 32 + crates/cairo-lang-syntax/src/node/ast.rs | 3031 +++++++++++++++++ crates/cairo-lang-syntax/src/node/mod.rs | 47 +- 7 files changed, 3100 insertions(+), 42 deletions(-) diff --git a/crates/cairo-lang-doc/src/parser.rs b/crates/cairo-lang-doc/src/parser.rs index 90d630503ab..3d2a0e2b58a 100644 --- a/crates/cairo-lang-doc/src/parser.rs +++ b/crates/cairo-lang-doc/src/parser.rs @@ -14,7 +14,6 @@ use cairo_lang_semantic::items::functions::GenericFunctionId; use cairo_lang_semantic::resolve::{AsSegments, ResolvedGenericItem, Resolver}; use cairo_lang_syntax::node::ast::{Expr, ExprPath, ItemModule}; use cairo_lang_syntax::node::helpers::GetIdentifier; -use cairo_lang_syntax::node::kind::SyntaxKind; use cairo_lang_syntax::node::{SyntaxNode, TypedSyntaxNode}; use cairo_lang_utils::Intern; use pulldown_cmark::{ @@ -230,9 +229,9 @@ impl<'a> DocumentationCommentParser<'a> { // Get the stack (bottom-up) of submodule names in the file containing the node, in the main // module, that lead to the node. iter::successors(node.parent(), SyntaxNode::parent) - .filter(|node| node.kind(syntax_db) == SyntaxKind::ItemModule) - .map(|node| { - ItemModule::from_syntax_node(syntax_db, node) + .filter_map(|node| ItemModule::cast(syntax_db, node)) + .map(|item_module| { + item_module .stable_ptr() .name_green(syntax_db) .identifier(syntax_db) diff --git a/crates/cairo-lang-formatter/src/formatter_impl.rs b/crates/cairo-lang-formatter/src/formatter_impl.rs index 0040661599d..e7c5b108bf9 100644 --- a/crates/cairo-lang-formatter/src/formatter_impl.rs +++ b/crates/cairo-lang-formatter/src/formatter_impl.rs @@ -1088,13 +1088,10 @@ impl<'a> FormatterImpl<'a> { /// Returns whether the node has only whitespace trivia. fn has_only_whitespace_trivia(&self, node: &SyntaxNode) -> bool { node.descendants(self.db).all(|descendant| { - if descendant.kind(self.db) == SyntaxKind::Trivia { - ast::Trivia::from_syntax_node(self.db, descendant) - .elements(self.db) - .into_iter() - .all(|element| { - matches!(element, ast::Trivium::Whitespace(_) | ast::Trivium::Newline(_)) - }) + if let Some(trivia) = ast::Trivia::cast(self.db, descendant) { + trivia.elements(self.db).into_iter().all(|element| { + matches!(element, ast::Trivium::Whitespace(_) | ast::Trivium::Newline(_)) + }) } else { true } diff --git a/crates/cairo-lang-plugins/src/plugins/generate_trait.rs b/crates/cairo-lang-plugins/src/plugins/generate_trait.rs index 8dc472cbe4e..d821f78a05a 100644 --- a/crates/cairo-lang-plugins/src/plugins/generate_trait.rs +++ b/crates/cairo-lang-plugins/src/plugins/generate_trait.rs @@ -7,7 +7,6 @@ use cairo_lang_defs::plugin::{ use cairo_lang_syntax::attribute::structured::{AttributeArgVariant, AttributeStructurize}; use cairo_lang_syntax::node::db::SyntaxGroup; use cairo_lang_syntax::node::helpers::{BodyItems, GenericParamEx, QueryAttrs}; -use cairo_lang_syntax::node::kind::SyntaxKind; use cairo_lang_syntax::node::{Terminal, TypedSyntaxNode, ast}; #[derive(Debug, Default)] @@ -159,10 +158,7 @@ fn generate_trait_for_impl(db: &dyn SyntaxGroup, impl_ast: ast::ItemImpl) -> Plu for node in db.get_children(signature.parameters(db).node.clone()).iter().cloned() { - if node.kind(db) != SyntaxKind::Param { - builder.add_node(node); - } else { - let param = ast::Param::from_syntax_node(db, node); + if let Some(param) = ast::Param::cast(db, node.clone()) { for modifier in param.modifiers(db).elements(db) { // `mut` modifiers are only relevant for impls, not traits. if !matches!(modifier, ast::Modifier::Mut(_)) { @@ -171,6 +167,8 @@ fn generate_trait_for_impl(db: &dyn SyntaxGroup, impl_ast: ast::ItemImpl) -> Plu } builder.add_node(param.name(db).as_syntax_node()); builder.add_node(param.type_clause(db).as_syntax_node()); + } else { + builder.add_node(node); } } let rparen = signature.rparen(db); diff --git a/crates/cairo-lang-starknet/src/plugin/starknet_module/mod.rs b/crates/cairo-lang-starknet/src/plugin/starknet_module/mod.rs index de34c310d46..3c293fa9bae 100644 --- a/crates/cairo-lang-starknet/src/plugin/starknet_module/mod.rs +++ b/crates/cairo-lang-starknet/src/plugin/starknet_module/mod.rs @@ -10,9 +10,8 @@ use cairo_lang_plugins::plugins::HasItemsInCfgEx; use cairo_lang_syntax::node::ast::MaybeModuleBody; use cairo_lang_syntax::node::db::SyntaxGroup; use cairo_lang_syntax::node::helpers::{BodyItems, QueryAttrs}; -use cairo_lang_syntax::node::kind::SyntaxKind; use cairo_lang_syntax::node::{SyntaxNode, Terminal, TypedSyntaxNode, ast}; -use cairo_lang_utils::{extract_matches, require}; +use cairo_lang_utils::extract_matches; use self::component::generate_component_specific_code; use self::contract::generate_contract_specific_code; @@ -244,8 +243,7 @@ fn grand_grand_parent_starknet_module( // Get the containing module node. The parent is the item list, the grand parent is the module // body, and the grand grand parent is the module. let module_node = item_node.parent()?.parent()?.parent()?; - require(module_node.kind(db) == SyntaxKind::ItemModule)?; - let module_ast = ast::ItemModule::from_syntax_node(db, module_node); + let module_ast = ast::ItemModule::cast(db, module_node)?; let (module_kind, attr) = StarknetModuleKind::from_module(db, &module_ast)?; Some((module_ast, module_kind, attr)) } diff --git a/crates/cairo-lang-syntax-codegen/src/generator.rs b/crates/cairo-lang-syntax-codegen/src/generator.rs index 2182703963e..a00f15db7b6 100644 --- a/crates/cairo-lang-syntax-codegen/src/generator.rs +++ b/crates/cairo-lang-syntax-codegen/src/generator.rs @@ -366,6 +366,13 @@ fn gen_common_list_code(name: &str, green_name: &str, ptr_name: &str) -> rust::T fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self { Self(ElementList::new(node)) } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + if node.kind(db) == SyntaxKind::$name { + Some(Self(ElementList::new(node))) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -390,6 +397,7 @@ fn gen_enum_code( let green_name = format!("{name}Green"); let mut enum_body = quote! {}; let mut from_node_body = quote! {}; + let mut cast_body = quote! {}; let mut ptr_conversions = quote! {}; let mut green_conversions = quote! {}; for variant in &variants { @@ -402,6 +410,9 @@ fn gen_enum_code( from_node_body.extend(quote! { SyntaxKind::$k => $(&name)::$n($k::from_syntax_node(db, node)), }); + cast_body.extend(quote! { + SyntaxKind::$k => Some($(&name)::$n($k::from_syntax_node(db, node))), + }); let variant_ptr = format!("{k}Ptr"); ptr_conversions.extend(quote! { impl From<$(&variant_ptr)> for $(&ptr_name) { @@ -469,6 +480,13 @@ fn gen_enum_code( $[str]($[const](&name))), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + $cast_body + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { $(for v in &variants => $(&name)::$(&v.name)(x) => x.as_syntax_node(),) @@ -556,6 +574,12 @@ fn gen_token_code(name: String) -> rust::Tokens { ), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -706,6 +730,14 @@ fn gen_struct_code(name: String, members: Vec, is_terminal: bool) -> rus let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::$(&name) { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } diff --git a/crates/cairo-lang-syntax/src/node/ast.rs b/crates/cairo-lang-syntax/src/node/ast.rs index 72e3517b894..a509e050c14 100644 --- a/crates/cairo-lang-syntax/src/node/ast.rs +++ b/crates/cairo-lang-syntax/src/node/ast.rs @@ -76,6 +76,9 @@ impl TypedSyntaxNode for Trivia { fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self { Self(ElementList::new(node)) } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + if node.kind(db) == SyntaxKind::Trivia { Some(Self(ElementList::new(node))) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -216,6 +219,33 @@ impl TypedSyntaxNode for Trivium { _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "Trivium"), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::TokenSingleLineComment => { + Some(Trivium::SingleLineComment(TokenSingleLineComment::from_syntax_node(db, node))) + } + SyntaxKind::TokenSingleLineDocComment => Some(Trivium::SingleLineDocComment( + TokenSingleLineDocComment::from_syntax_node(db, node), + )), + SyntaxKind::TokenSingleLineInnerComment => Some(Trivium::SingleLineInnerComment( + TokenSingleLineInnerComment::from_syntax_node(db, node), + )), + SyntaxKind::TokenWhitespace => { + Some(Trivium::Whitespace(TokenWhitespace::from_syntax_node(db, node))) + } + SyntaxKind::TokenNewline => { + Some(Trivium::Newline(TokenNewline::from_syntax_node(db, node))) + } + SyntaxKind::TokenSkipped => { + Some(Trivium::Skipped(TokenSkipped::from_syntax_node(db, node))) + } + SyntaxKind::TriviumSkippedNode => { + Some(Trivium::SkippedNode(TriviumSkippedNode::from_syntax_node(db, node))) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { Trivium::SingleLineComment(x) => x.as_syntax_node(), @@ -605,6 +635,61 @@ impl TypedSyntaxNode for Expr { _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "Expr"), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::ExprPath => Some(Expr::Path(ExprPath::from_syntax_node(db, node))), + SyntaxKind::TerminalLiteralNumber => { + Some(Expr::Literal(TerminalLiteralNumber::from_syntax_node(db, node))) + } + SyntaxKind::TerminalShortString => { + Some(Expr::ShortString(TerminalShortString::from_syntax_node(db, node))) + } + SyntaxKind::TerminalString => { + Some(Expr::String(TerminalString::from_syntax_node(db, node))) + } + SyntaxKind::TerminalFalse => { + Some(Expr::False(TerminalFalse::from_syntax_node(db, node))) + } + SyntaxKind::TerminalTrue => Some(Expr::True(TerminalTrue::from_syntax_node(db, node))), + SyntaxKind::ExprParenthesized => { + Some(Expr::Parenthesized(ExprParenthesized::from_syntax_node(db, node))) + } + SyntaxKind::ExprUnary => Some(Expr::Unary(ExprUnary::from_syntax_node(db, node))), + SyntaxKind::ExprBinary => Some(Expr::Binary(ExprBinary::from_syntax_node(db, node))), + SyntaxKind::ExprListParenthesized => { + Some(Expr::Tuple(ExprListParenthesized::from_syntax_node(db, node))) + } + SyntaxKind::ExprFunctionCall => { + Some(Expr::FunctionCall(ExprFunctionCall::from_syntax_node(db, node))) + } + SyntaxKind::ExprStructCtorCall => { + Some(Expr::StructCtorCall(ExprStructCtorCall::from_syntax_node(db, node))) + } + SyntaxKind::ExprBlock => Some(Expr::Block(ExprBlock::from_syntax_node(db, node))), + SyntaxKind::ExprMatch => Some(Expr::Match(ExprMatch::from_syntax_node(db, node))), + SyntaxKind::ExprIf => Some(Expr::If(ExprIf::from_syntax_node(db, node))), + SyntaxKind::ExprLoop => Some(Expr::Loop(ExprLoop::from_syntax_node(db, node))), + SyntaxKind::ExprWhile => Some(Expr::While(ExprWhile::from_syntax_node(db, node))), + SyntaxKind::ExprFor => Some(Expr::For(ExprFor::from_syntax_node(db, node))), + SyntaxKind::ExprClosure => Some(Expr::Closure(ExprClosure::from_syntax_node(db, node))), + SyntaxKind::ExprErrorPropagate => { + Some(Expr::ErrorPropagate(ExprErrorPropagate::from_syntax_node(db, node))) + } + SyntaxKind::ExprFieldInitShorthand => { + Some(Expr::FieldInitShorthand(ExprFieldInitShorthand::from_syntax_node(db, node))) + } + SyntaxKind::ExprIndexed => Some(Expr::Indexed(ExprIndexed::from_syntax_node(db, node))), + SyntaxKind::ExprInlineMacro => { + Some(Expr::InlineMacro(ExprInlineMacro::from_syntax_node(db, node))) + } + SyntaxKind::ExprFixedSizeArray => { + Some(Expr::FixedSizeArray(ExprFixedSizeArray::from_syntax_node(db, node))) + } + SyntaxKind::ExprMissing => Some(Expr::Missing(ExprMissing::from_syntax_node(db, node))), + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { Expr::Path(x) => x.as_syntax_node(), @@ -759,6 +844,13 @@ impl TypedSyntaxNode for ExprList { fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self { Self(ElementList::new(node)) } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + if node.kind(db) == SyntaxKind::ExprList { + Some(Self(ElementList::new(node))) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -850,6 +942,10 @@ impl TypedSyntaxNode for Arg { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::Arg { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -938,6 +1034,21 @@ impl TypedSyntaxNode for ArgClause { _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "ArgClause"), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::ArgClauseUnnamed => { + Some(ArgClause::Unnamed(ArgClauseUnnamed::from_syntax_node(db, node))) + } + SyntaxKind::ArgClauseNamed => { + Some(ArgClause::Named(ArgClauseNamed::from_syntax_node(db, node))) + } + SyntaxKind::ArgClauseFieldInitShorthand => Some(ArgClause::FieldInitShorthand( + ArgClauseFieldInitShorthand::from_syntax_node(db, node), + )), + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { ArgClause::Unnamed(x) => x.as_syntax_node(), @@ -1053,6 +1164,14 @@ impl TypedSyntaxNode for ArgClauseNamed { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ArgClauseNamed { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -1136,6 +1255,14 @@ impl TypedSyntaxNode for ArgClauseUnnamed { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ArgClauseUnnamed { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -1230,6 +1357,14 @@ impl TypedSyntaxNode for ArgClauseFieldInitShorthand { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ArgClauseFieldInitShorthand { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -1316,6 +1451,14 @@ impl TypedSyntaxNode for ExprFieldInitShorthand { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ExprFieldInitShorthand { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -1411,6 +1554,9 @@ impl TypedSyntaxNode for ArgList { fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self { Self(ElementList::new(node)) } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + if node.kind(db) == SyntaxKind::ArgList { Some(Self(ElementList::new(node))) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -1486,6 +1632,10 @@ impl TypedSyntaxNode for ExprMissing { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ExprMissing { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -1560,6 +1710,18 @@ impl TypedSyntaxNode for PathSegment { _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "PathSegment"), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::PathSegmentWithGenericArgs => Some(PathSegment::WithGenericArgs( + PathSegmentWithGenericArgs::from_syntax_node(db, node), + )), + SyntaxKind::PathSegmentSimple => { + Some(PathSegment::Simple(PathSegmentSimple::from_syntax_node(db, node))) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { PathSegment::WithGenericArgs(x) => x.as_syntax_node(), @@ -1655,6 +1817,14 @@ impl TypedSyntaxNode for PathSegmentSimple { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::PathSegmentSimple { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -1732,6 +1902,18 @@ impl TypedSyntaxNode for OptionTerminalColonColon { ), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::OptionTerminalColonColonEmpty => Some(OptionTerminalColonColon::Empty( + OptionTerminalColonColonEmpty::from_syntax_node(db, node), + )), + SyntaxKind::TerminalColonColon => Some(OptionTerminalColonColon::TerminalColonColon( + TerminalColonColon::from_syntax_node(db, node), + )), + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { OptionTerminalColonColon::Empty(x) => x.as_syntax_node(), @@ -1816,6 +1998,14 @@ impl TypedSyntaxNode for OptionTerminalColonColonEmpty { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::OptionTerminalColonColonEmpty { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -1916,6 +2106,14 @@ impl TypedSyntaxNode for PathSegmentWithGenericArgs { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::PathSegmentWithGenericArgs { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -2011,6 +2209,13 @@ impl TypedSyntaxNode for ExprPath { fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self { Self(ElementList::new(node)) } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + if node.kind(db) == SyntaxKind::ExprPath { + Some(Self(ElementList::new(node))) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -2111,6 +2316,14 @@ impl TypedSyntaxNode for ExprParenthesized { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ExprParenthesized { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -2202,6 +2415,10 @@ impl TypedSyntaxNode for ExprUnary { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ExprUnary { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -2314,6 +2531,27 @@ impl TypedSyntaxNode for UnaryOperator { _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "UnaryOperator"), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::TerminalNot => { + Some(UnaryOperator::Not(TerminalNot::from_syntax_node(db, node))) + } + SyntaxKind::TerminalBitNot => { + Some(UnaryOperator::BitNot(TerminalBitNot::from_syntax_node(db, node))) + } + SyntaxKind::TerminalMinus => { + Some(UnaryOperator::Minus(TerminalMinus::from_syntax_node(db, node))) + } + SyntaxKind::TerminalAt => { + Some(UnaryOperator::At(TerminalAt::from_syntax_node(db, node))) + } + SyntaxKind::TerminalMul => { + Some(UnaryOperator::Desnap(TerminalMul::from_syntax_node(db, node))) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { UnaryOperator::Not(x) => x.as_syntax_node(), @@ -2433,6 +2671,10 @@ impl TypedSyntaxNode for ExprBinary { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ExprBinary { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -2803,6 +3045,87 @@ impl TypedSyntaxNode for BinaryOperator { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::TerminalDot => { + Some(BinaryOperator::Dot(TerminalDot::from_syntax_node(db, node))) + } + SyntaxKind::TerminalNot => { + Some(BinaryOperator::Not(TerminalNot::from_syntax_node(db, node))) + } + SyntaxKind::TerminalMul => { + Some(BinaryOperator::Mul(TerminalMul::from_syntax_node(db, node))) + } + SyntaxKind::TerminalMulEq => { + Some(BinaryOperator::MulEq(TerminalMulEq::from_syntax_node(db, node))) + } + SyntaxKind::TerminalDiv => { + Some(BinaryOperator::Div(TerminalDiv::from_syntax_node(db, node))) + } + SyntaxKind::TerminalDivEq => { + Some(BinaryOperator::DivEq(TerminalDivEq::from_syntax_node(db, node))) + } + SyntaxKind::TerminalMod => { + Some(BinaryOperator::Mod(TerminalMod::from_syntax_node(db, node))) + } + SyntaxKind::TerminalModEq => { + Some(BinaryOperator::ModEq(TerminalModEq::from_syntax_node(db, node))) + } + SyntaxKind::TerminalPlus => { + Some(BinaryOperator::Plus(TerminalPlus::from_syntax_node(db, node))) + } + SyntaxKind::TerminalPlusEq => { + Some(BinaryOperator::PlusEq(TerminalPlusEq::from_syntax_node(db, node))) + } + SyntaxKind::TerminalMinus => { + Some(BinaryOperator::Minus(TerminalMinus::from_syntax_node(db, node))) + } + SyntaxKind::TerminalMinusEq => { + Some(BinaryOperator::MinusEq(TerminalMinusEq::from_syntax_node(db, node))) + } + SyntaxKind::TerminalEqEq => { + Some(BinaryOperator::EqEq(TerminalEqEq::from_syntax_node(db, node))) + } + SyntaxKind::TerminalNeq => { + Some(BinaryOperator::Neq(TerminalNeq::from_syntax_node(db, node))) + } + SyntaxKind::TerminalEq => { + Some(BinaryOperator::Eq(TerminalEq::from_syntax_node(db, node))) + } + SyntaxKind::TerminalAnd => { + Some(BinaryOperator::And(TerminalAnd::from_syntax_node(db, node))) + } + SyntaxKind::TerminalAndAnd => { + Some(BinaryOperator::AndAnd(TerminalAndAnd::from_syntax_node(db, node))) + } + SyntaxKind::TerminalOr => { + Some(BinaryOperator::Or(TerminalOr::from_syntax_node(db, node))) + } + SyntaxKind::TerminalOrOr => { + Some(BinaryOperator::OrOr(TerminalOrOr::from_syntax_node(db, node))) + } + SyntaxKind::TerminalXor => { + Some(BinaryOperator::Xor(TerminalXor::from_syntax_node(db, node))) + } + SyntaxKind::TerminalLE => { + Some(BinaryOperator::LE(TerminalLE::from_syntax_node(db, node))) + } + SyntaxKind::TerminalGE => { + Some(BinaryOperator::GE(TerminalGE::from_syntax_node(db, node))) + } + SyntaxKind::TerminalLT => { + Some(BinaryOperator::LT(TerminalLT::from_syntax_node(db, node))) + } + SyntaxKind::TerminalGT => { + Some(BinaryOperator::GT(TerminalGT::from_syntax_node(db, node))) + } + SyntaxKind::TerminalDotDot => { + Some(BinaryOperator::DotDot(TerminalDotDot::from_syntax_node(db, node))) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { BinaryOperator::Dot(x) => x.as_syntax_node(), @@ -2962,6 +3285,14 @@ impl TypedSyntaxNode for ExprListParenthesized { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ExprListParenthesized { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -3053,6 +3384,14 @@ impl TypedSyntaxNode for ExprFunctionCall { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ExprFunctionCall { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -3153,6 +3492,14 @@ impl TypedSyntaxNode for ArgListParenthesized { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ArgListParenthesized { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -3230,6 +3577,20 @@ impl TypedSyntaxNode for OptionArgListParenthesized { ), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::OptionArgListParenthesizedEmpty => Some(OptionArgListParenthesized::Empty( + OptionArgListParenthesizedEmpty::from_syntax_node(db, node), + )), + SyntaxKind::ArgListParenthesized => { + Some(OptionArgListParenthesized::ArgListParenthesized( + ArgListParenthesized::from_syntax_node(db, node), + )) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { OptionArgListParenthesized::Empty(x) => x.as_syntax_node(), @@ -3317,6 +3678,14 @@ impl TypedSyntaxNode for OptionArgListParenthesizedEmpty { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::OptionArgListParenthesizedEmpty { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -3408,6 +3777,14 @@ impl TypedSyntaxNode for ExprStructCtorCall { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ExprStructCtorCall { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -3508,6 +3885,14 @@ impl TypedSyntaxNode for StructArgListBraced { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::StructArgListBraced { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -3608,6 +3993,10 @@ impl TypedSyntaxNode for ExprBlock { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ExprBlock { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -3720,6 +4109,10 @@ impl TypedSyntaxNode for ExprMatch { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ExprMatch { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -3815,6 +4208,13 @@ impl TypedSyntaxNode for MatchArms { fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self { Self(ElementList::new(node)) } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + if node.kind(db) == SyntaxKind::MatchArms { + Some(Self(ElementList::new(node))) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -3915,6 +4315,10 @@ impl TypedSyntaxNode for MatchArm { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::MatchArm { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -4021,6 +4425,10 @@ impl TypedSyntaxNode for ExprIf { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ExprIf { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -4091,6 +4499,18 @@ impl TypedSyntaxNode for Condition { _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "Condition"), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::ConditionLet => { + Some(Condition::Let(ConditionLet::from_syntax_node(db, node))) + } + SyntaxKind::ConditionExpr => { + Some(Condition::Expr(ConditionExpr::from_syntax_node(db, node))) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { Condition::Let(x) => x.as_syntax_node(), @@ -4206,6 +4626,10 @@ impl TypedSyntaxNode for ConditionLet { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ConditionLet { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -4289,6 +4713,14 @@ impl TypedSyntaxNode for ConditionExpr { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ConditionExpr { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -4359,6 +4791,14 @@ impl TypedSyntaxNode for BlockOrIf { _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "BlockOrIf"), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::ExprBlock => Some(BlockOrIf::Block(ExprBlock::from_syntax_node(db, node))), + SyntaxKind::ExprIf => Some(BlockOrIf::If(ExprIf::from_syntax_node(db, node))), + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { BlockOrIf::Block(x) => x.as_syntax_node(), @@ -4459,6 +4899,10 @@ impl TypedSyntaxNode for ExprLoop { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ExprLoop { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -4559,6 +5003,10 @@ impl TypedSyntaxNode for ExprWhile { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ExprWhile { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -4688,6 +5136,10 @@ impl TypedSyntaxNode for ExprFor { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ExprFor { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -4779,6 +5231,10 @@ impl TypedSyntaxNode for ElseClause { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ElseClause { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -4856,6 +5312,18 @@ impl TypedSyntaxNode for OptionElseClause { ), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::OptionElseClauseEmpty => { + Some(OptionElseClause::Empty(OptionElseClauseEmpty::from_syntax_node(db, node))) + } + SyntaxKind::ElseClause => { + Some(OptionElseClause::ElseClause(ElseClause::from_syntax_node(db, node))) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { OptionElseClause::Empty(x) => x.as_syntax_node(), @@ -4940,6 +5408,14 @@ impl TypedSyntaxNode for OptionElseClauseEmpty { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::OptionElseClauseEmpty { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -5031,6 +5507,14 @@ impl TypedSyntaxNode for ExprErrorPropagate { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ExprErrorPropagate { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -5137,6 +5621,10 @@ impl TypedSyntaxNode for ExprIndexed { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ExprIndexed { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -5237,6 +5725,14 @@ impl TypedSyntaxNode for ExprInlineMacro { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ExprInlineMacro { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -5343,6 +5839,14 @@ impl TypedSyntaxNode for ExprFixedSizeArray { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ExprFixedSizeArray { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -5434,6 +5938,14 @@ impl TypedSyntaxNode for FixedSizeArraySize { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::FixedSizeArraySize { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -5511,6 +6023,18 @@ impl TypedSyntaxNode for OptionFixedSizeArraySize { ), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::OptionFixedSizeArraySizeEmpty => Some(OptionFixedSizeArraySize::Empty( + OptionFixedSizeArraySizeEmpty::from_syntax_node(db, node), + )), + SyntaxKind::FixedSizeArraySize => Some(OptionFixedSizeArraySize::FixedSizeArraySize( + FixedSizeArraySize::from_syntax_node(db, node), + )), + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { OptionFixedSizeArraySize::Empty(x) => x.as_syntax_node(), @@ -5595,6 +6119,14 @@ impl TypedSyntaxNode for OptionFixedSizeArraySizeEmpty { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::OptionFixedSizeArraySizeEmpty { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -5701,6 +6233,10 @@ impl TypedSyntaxNode for ExprClosure { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ExprClosure { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -5778,6 +6314,18 @@ impl TypedSyntaxNode for ClosureParamWrapper { ), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::TerminalOrOr => { + Some(ClosureParamWrapper::Nullary(TerminalOrOr::from_syntax_node(db, node))) + } + SyntaxKind::ClosureParamWrapperNAry => { + Some(ClosureParamWrapper::NAry(ClosureParamWrapperNAry::from_syntax_node(db, node))) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { ClosureParamWrapper::Nullary(x) => x.as_syntax_node(), @@ -5887,6 +6435,14 @@ impl TypedSyntaxNode for ClosureParamWrapperNAry { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ClosureParamWrapperNAry { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -5978,6 +6534,14 @@ impl TypedSyntaxNode for StructArgExpr { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::StructArgExpr { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -6055,6 +6619,18 @@ impl TypedSyntaxNode for OptionStructArgExpr { ), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::OptionStructArgExprEmpty => Some(OptionStructArgExpr::Empty( + OptionStructArgExprEmpty::from_syntax_node(db, node), + )), + SyntaxKind::StructArgExpr => { + Some(OptionStructArgExpr::StructArgExpr(StructArgExpr::from_syntax_node(db, node))) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { OptionStructArgExpr::Empty(x) => x.as_syntax_node(), @@ -6139,6 +6715,14 @@ impl TypedSyntaxNode for OptionStructArgExprEmpty { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::OptionStructArgExprEmpty { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -6242,6 +6826,14 @@ impl TypedSyntaxNode for StructArgSingle { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::StructArgSingle { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -6333,6 +6925,14 @@ impl TypedSyntaxNode for StructArgTail { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::StructArgTail { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -6407,6 +7007,18 @@ impl TypedSyntaxNode for StructArg { _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "StructArg"), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::StructArgSingle => { + Some(StructArg::StructArgSingle(StructArgSingle::from_syntax_node(db, node))) + } + SyntaxKind::StructArgTail => { + Some(StructArg::StructArgTail(StructArgTail::from_syntax_node(db, node))) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { StructArg::StructArgSingle(x) => x.as_syntax_node(), @@ -6511,6 +7123,13 @@ impl TypedSyntaxNode for StructArgList { fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self { Self(ElementList::new(node)) } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + if node.kind(db) == SyntaxKind::StructArgList { + Some(Self(ElementList::new(node))) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -6611,6 +7230,14 @@ impl TypedSyntaxNode for ArgListBraced { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ArgListBraced { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -6711,6 +7338,14 @@ impl TypedSyntaxNode for ArgListBracketed { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ArgListBracketed { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -6815,6 +7450,24 @@ impl TypedSyntaxNode for WrappedArgList { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::ArgListBracketed => { + Some(WrappedArgList::BracketedArgList(ArgListBracketed::from_syntax_node(db, node))) + } + SyntaxKind::ArgListParenthesized => Some(WrappedArgList::ParenthesizedArgList( + ArgListParenthesized::from_syntax_node(db, node), + )), + SyntaxKind::ArgListBraced => { + Some(WrappedArgList::BracedArgList(ArgListBraced::from_syntax_node(db, node))) + } + SyntaxKind::WrappedArgListMissing => { + Some(WrappedArgList::Missing(WrappedArgListMissing::from_syntax_node(db, node))) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { WrappedArgList::BracketedArgList(x) => x.as_syntax_node(), @@ -6907,6 +7560,14 @@ impl TypedSyntaxNode for WrappedArgListMissing { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::WrappedArgListMissing { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -7109,6 +7770,44 @@ impl TypedSyntaxNode for Pattern { _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "Pattern"), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::TerminalUnderscore => { + Some(Pattern::Underscore(TerminalUnderscore::from_syntax_node(db, node))) + } + SyntaxKind::TerminalLiteralNumber => { + Some(Pattern::Literal(TerminalLiteralNumber::from_syntax_node(db, node))) + } + SyntaxKind::TerminalFalse => { + Some(Pattern::False(TerminalFalse::from_syntax_node(db, node))) + } + SyntaxKind::TerminalTrue => { + Some(Pattern::True(TerminalTrue::from_syntax_node(db, node))) + } + SyntaxKind::TerminalShortString => { + Some(Pattern::ShortString(TerminalShortString::from_syntax_node(db, node))) + } + SyntaxKind::TerminalString => { + Some(Pattern::String(TerminalString::from_syntax_node(db, node))) + } + SyntaxKind::PatternIdentifier => { + Some(Pattern::Identifier(PatternIdentifier::from_syntax_node(db, node))) + } + SyntaxKind::PatternStruct => { + Some(Pattern::Struct(PatternStruct::from_syntax_node(db, node))) + } + SyntaxKind::PatternTuple => { + Some(Pattern::Tuple(PatternTuple::from_syntax_node(db, node))) + } + SyntaxKind::PatternEnum => Some(Pattern::Enum(PatternEnum::from_syntax_node(db, node))), + SyntaxKind::PatternFixedSizeArray => { + Some(Pattern::FixedSizeArray(PatternFixedSizeArray::from_syntax_node(db, node))) + } + SyntaxKind::ExprPath => Some(Pattern::Path(ExprPath::from_syntax_node(db, node))), + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { Pattern::Underscore(x) => x.as_syntax_node(), @@ -7242,6 +7941,14 @@ impl TypedSyntaxNode for PatternIdentifier { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::PatternIdentifier { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -7348,6 +8055,14 @@ impl TypedSyntaxNode for PatternStruct { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::PatternStruct { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -7443,6 +8158,13 @@ impl TypedSyntaxNode for PatternStructParamList { fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self { Self(ElementList::new(node)) } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + if node.kind(db) == SyntaxKind::PatternStructParamList { + Some(Self(ElementList::new(node))) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -7543,6 +8265,10 @@ impl TypedSyntaxNode for PatternTuple { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::PatternTuple { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -7643,6 +8369,14 @@ impl TypedSyntaxNode for PatternFixedSizeArray { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::PatternFixedSizeArray { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -7738,6 +8472,13 @@ impl TypedSyntaxNode for PatternList { fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self { Self(ElementList::new(node)) } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + if node.kind(db) == SyntaxKind::PatternList { + Some(Self(ElementList::new(node))) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -7833,6 +8574,13 @@ impl TypedSyntaxNode for PatternListOr { fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self { Self(ElementList::new(node)) } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + if node.kind(db) == SyntaxKind::PatternListOr { + Some(Self(ElementList::new(node))) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -7924,6 +8672,21 @@ impl TypedSyntaxNode for PatternStructParam { ), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::PatternIdentifier => { + Some(PatternStructParam::Single(PatternIdentifier::from_syntax_node(db, node))) + } + SyntaxKind::PatternStructParamWithExpr => Some(PatternStructParam::WithExpr( + PatternStructParamWithExpr::from_syntax_node(db, node), + )), + SyntaxKind::TerminalDotDot => { + Some(PatternStructParam::Tail(TerminalDotDot::from_syntax_node(db, node))) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { PatternStructParam::Single(x) => x.as_syntax_node(), @@ -8045,6 +8808,14 @@ impl TypedSyntaxNode for PatternStructParamWithExpr { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::PatternStructParamWithExpr { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -8139,6 +8910,10 @@ impl TypedSyntaxNode for PatternEnum { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::PatternEnum { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -8239,6 +9014,14 @@ impl TypedSyntaxNode for PatternEnumInnerPattern { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::PatternEnumInnerPattern { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -8318,6 +9101,22 @@ impl TypedSyntaxNode for OptionPatternEnumInnerPattern { ), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::OptionPatternEnumInnerPatternEmpty => { + Some(OptionPatternEnumInnerPattern::Empty( + OptionPatternEnumInnerPatternEmpty::from_syntax_node(db, node), + )) + } + SyntaxKind::PatternEnumInnerPattern => { + Some(OptionPatternEnumInnerPattern::PatternEnumInnerPattern( + PatternEnumInnerPattern::from_syntax_node(db, node), + )) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { OptionPatternEnumInnerPattern::Empty(x) => x.as_syntax_node(), @@ -8405,6 +9204,14 @@ impl TypedSyntaxNode for OptionPatternEnumInnerPatternEmpty { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::OptionPatternEnumInnerPatternEmpty { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -8496,6 +9303,10 @@ impl TypedSyntaxNode for TypeClause { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TypeClause { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -8573,6 +9384,18 @@ impl TypedSyntaxNode for OptionTypeClause { ), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::OptionTypeClauseEmpty => { + Some(OptionTypeClause::Empty(OptionTypeClauseEmpty::from_syntax_node(db, node))) + } + SyntaxKind::TypeClause => { + Some(OptionTypeClause::TypeClause(TypeClause::from_syntax_node(db, node))) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { OptionTypeClause::Empty(x) => x.as_syntax_node(), @@ -8657,6 +9480,14 @@ impl TypedSyntaxNode for OptionTypeClauseEmpty { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::OptionTypeClauseEmpty { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -8748,6 +9579,14 @@ impl TypedSyntaxNode for ReturnTypeClause { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ReturnTypeClause { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -8825,6 +9664,18 @@ impl TypedSyntaxNode for OptionReturnTypeClause { ), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::OptionReturnTypeClauseEmpty => Some(OptionReturnTypeClause::Empty( + OptionReturnTypeClauseEmpty::from_syntax_node(db, node), + )), + SyntaxKind::ReturnTypeClause => Some(OptionReturnTypeClause::ReturnTypeClause( + ReturnTypeClause::from_syntax_node(db, node), + )), + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { OptionReturnTypeClause::Empty(x) => x.as_syntax_node(), @@ -8909,6 +9760,14 @@ impl TypedSyntaxNode for OptionReturnTypeClauseEmpty { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::OptionReturnTypeClauseEmpty { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -9047,6 +9906,33 @@ impl TypedSyntaxNode for Statement { _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "Statement"), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::StatementLet => { + Some(Statement::Let(StatementLet::from_syntax_node(db, node))) + } + SyntaxKind::StatementExpr => { + Some(Statement::Expr(StatementExpr::from_syntax_node(db, node))) + } + SyntaxKind::StatementContinue => { + Some(Statement::Continue(StatementContinue::from_syntax_node(db, node))) + } + SyntaxKind::StatementReturn => { + Some(Statement::Return(StatementReturn::from_syntax_node(db, node))) + } + SyntaxKind::StatementBreak => { + Some(Statement::Break(StatementBreak::from_syntax_node(db, node))) + } + SyntaxKind::StatementItem => { + Some(Statement::Item(StatementItem::from_syntax_node(db, node))) + } + SyntaxKind::StatementMissing => { + Some(Statement::Missing(StatementMissing::from_syntax_node(db, node))) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { Statement::Let(x) => x.as_syntax_node(), @@ -9139,6 +10025,13 @@ impl TypedSyntaxNode for StatementList { fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self { Self(ElementList::new(node)) } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + if node.kind(db) == SyntaxKind::StatementList { + Some(Self(ElementList::new(node))) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -9214,6 +10107,14 @@ impl TypedSyntaxNode for StatementMissing { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::StatementMissing { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -9348,6 +10249,10 @@ impl TypedSyntaxNode for StatementLet { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::StatementLet { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -9425,6 +10330,18 @@ impl TypedSyntaxNode for OptionTerminalSemicolon { ), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::OptionTerminalSemicolonEmpty => Some(OptionTerminalSemicolon::Empty( + OptionTerminalSemicolonEmpty::from_syntax_node(db, node), + )), + SyntaxKind::TerminalSemicolon => Some(OptionTerminalSemicolon::TerminalSemicolon( + TerminalSemicolon::from_syntax_node(db, node), + )), + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { OptionTerminalSemicolon::Empty(x) => x.as_syntax_node(), @@ -9509,6 +10426,14 @@ impl TypedSyntaxNode for OptionTerminalSemicolonEmpty { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::OptionTerminalSemicolonEmpty { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -9609,6 +10534,14 @@ impl TypedSyntaxNode for StatementExpr { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::StatementExpr { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -9709,6 +10642,14 @@ impl TypedSyntaxNode for StatementContinue { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::StatementContinue { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -9792,6 +10733,10 @@ impl TypedSyntaxNode for ExprClause { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ExprClause { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -9869,6 +10814,18 @@ impl TypedSyntaxNode for OptionExprClause { ), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::OptionExprClauseEmpty => { + Some(OptionExprClause::Empty(OptionExprClauseEmpty::from_syntax_node(db, node))) + } + SyntaxKind::ExprClause => { + Some(OptionExprClause::ExprClause(ExprClause::from_syntax_node(db, node))) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { OptionExprClause::Empty(x) => x.as_syntax_node(), @@ -9953,6 +10910,14 @@ impl TypedSyntaxNode for OptionExprClauseEmpty { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::OptionExprClauseEmpty { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -10059,6 +11024,14 @@ impl TypedSyntaxNode for StatementReturn { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::StatementReturn { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -10165,6 +11138,14 @@ impl TypedSyntaxNode for StatementBreak { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::StatementBreak { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -10248,6 +11229,14 @@ impl TypedSyntaxNode for StatementItem { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::StatementItem { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -10357,6 +11346,10 @@ impl TypedSyntaxNode for Param { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::Param { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -10426,6 +11419,13 @@ impl TypedSyntaxNode for ModifierList { fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self { Self(ElementList::new(node)) } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + if node.kind(db) == SyntaxKind::ModifierList { + Some(Self(ElementList::new(node))) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -10496,6 +11496,14 @@ impl TypedSyntaxNode for Modifier { _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "Modifier"), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::TerminalRef => Some(Modifier::Ref(TerminalRef::from_syntax_node(db, node))), + SyntaxKind::TerminalMut => Some(Modifier::Mut(TerminalMut::from_syntax_node(db, node))), + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { Modifier::Ref(x) => x.as_syntax_node(), @@ -10600,6 +11608,13 @@ impl TypedSyntaxNode for ParamList { fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self { Self(ElementList::new(node)) } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + if node.kind(db) == SyntaxKind::ParamList { + Some(Self(ElementList::new(node))) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -10706,6 +11721,14 @@ impl TypedSyntaxNode for ImplicitsClause { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ImplicitsClause { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -10801,6 +11824,13 @@ impl TypedSyntaxNode for ImplicitsList { fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self { Self(ElementList::new(node)) } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + if node.kind(db) == SyntaxKind::ImplicitsList { + Some(Self(ElementList::new(node))) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -10878,6 +11908,18 @@ impl TypedSyntaxNode for OptionImplicitsClause { ), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::OptionImplicitsClauseEmpty => Some(OptionImplicitsClause::Empty( + OptionImplicitsClauseEmpty::from_syntax_node(db, node), + )), + SyntaxKind::ImplicitsClause => Some(OptionImplicitsClause::ImplicitsClause( + ImplicitsClause::from_syntax_node(db, node), + )), + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { OptionImplicitsClause::Empty(x) => x.as_syntax_node(), @@ -10962,6 +12004,14 @@ impl TypedSyntaxNode for OptionImplicitsClauseEmpty { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::OptionImplicitsClauseEmpty { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -11039,6 +12089,18 @@ impl TypedSyntaxNode for OptionTerminalNoPanic { ), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::OptionTerminalNoPanicEmpty => Some(OptionTerminalNoPanic::Empty( + OptionTerminalNoPanicEmpty::from_syntax_node(db, node), + )), + SyntaxKind::TerminalNoPanic => Some(OptionTerminalNoPanic::TerminalNoPanic( + TerminalNoPanic::from_syntax_node(db, node), + )), + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { OptionTerminalNoPanic::Empty(x) => x.as_syntax_node(), @@ -11123,6 +12185,14 @@ impl TypedSyntaxNode for OptionTerminalNoPanicEmpty { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::OptionTerminalNoPanicEmpty { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -11248,6 +12318,14 @@ impl TypedSyntaxNode for FunctionSignature { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::FunctionSignature { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -11363,6 +12441,10 @@ impl TypedSyntaxNode for Member { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::Member { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -11458,6 +12540,13 @@ impl TypedSyntaxNode for MemberList { fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self { Self(ElementList::new(node)) } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + if node.kind(db) == SyntaxKind::MemberList { + Some(Self(ElementList::new(node))) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -11567,6 +12656,10 @@ impl TypedSyntaxNode for Variant { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::Variant { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -11662,6 +12755,13 @@ impl TypedSyntaxNode for VariantList { fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self { Self(ElementList::new(node)) } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + if node.kind(db) == SyntaxKind::VariantList { + Some(Self(ElementList::new(node))) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -11906,6 +13006,49 @@ impl TypedSyntaxNode for ModuleItem { _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "ModuleItem"), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::ItemConstant => { + Some(ModuleItem::Constant(ItemConstant::from_syntax_node(db, node))) + } + SyntaxKind::ItemModule => { + Some(ModuleItem::Module(ItemModule::from_syntax_node(db, node))) + } + SyntaxKind::ItemUse => Some(ModuleItem::Use(ItemUse::from_syntax_node(db, node))), + SyntaxKind::FunctionWithBody => { + Some(ModuleItem::FreeFunction(FunctionWithBody::from_syntax_node(db, node))) + } + SyntaxKind::ItemExternFunction => { + Some(ModuleItem::ExternFunction(ItemExternFunction::from_syntax_node(db, node))) + } + SyntaxKind::ItemExternType => { + Some(ModuleItem::ExternType(ItemExternType::from_syntax_node(db, node))) + } + SyntaxKind::ItemTrait => Some(ModuleItem::Trait(ItemTrait::from_syntax_node(db, node))), + SyntaxKind::ItemImpl => Some(ModuleItem::Impl(ItemImpl::from_syntax_node(db, node))), + SyntaxKind::ItemImplAlias => { + Some(ModuleItem::ImplAlias(ItemImplAlias::from_syntax_node(db, node))) + } + SyntaxKind::ItemStruct => { + Some(ModuleItem::Struct(ItemStruct::from_syntax_node(db, node))) + } + SyntaxKind::ItemEnum => Some(ModuleItem::Enum(ItemEnum::from_syntax_node(db, node))), + SyntaxKind::ItemTypeAlias => { + Some(ModuleItem::TypeAlias(ItemTypeAlias::from_syntax_node(db, node))) + } + SyntaxKind::ItemInlineMacro => { + Some(ModuleItem::InlineMacro(ItemInlineMacro::from_syntax_node(db, node))) + } + SyntaxKind::ItemHeaderDoc => { + Some(ModuleItem::HeaderDoc(ItemHeaderDoc::from_syntax_node(db, node))) + } + SyntaxKind::ModuleItemMissing => { + Some(ModuleItem::Missing(ModuleItemMissing::from_syntax_node(db, node))) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { ModuleItem::Constant(x) => x.as_syntax_node(), @@ -12014,6 +13157,13 @@ impl TypedSyntaxNode for ModuleItemList { fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self { Self(ElementList::new(node)) } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + if node.kind(db) == SyntaxKind::ModuleItemList { + Some(Self(ElementList::new(node))) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -12089,6 +13239,14 @@ impl TypedSyntaxNode for ModuleItemMissing { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ModuleItemMissing { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -12201,6 +13359,10 @@ impl TypedSyntaxNode for Attribute { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::Attribute { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -12270,6 +13432,13 @@ impl TypedSyntaxNode for AttributeList { fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self { Self(ElementList::new(node)) } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + if node.kind(db) == SyntaxKind::AttributeList { + Some(Self(ElementList::new(node))) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -12345,6 +13514,14 @@ impl TypedSyntaxNode for VisibilityDefault { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::VisibilityDefault { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -12445,6 +13622,14 @@ impl TypedSyntaxNode for VisibilityPubArgumentClause { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::VisibilityPubArgumentClause { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -12526,6 +13711,22 @@ impl TypedSyntaxNode for OptionVisibilityPubArgumentClause { ), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::OptionVisibilityPubArgumentClauseEmpty => { + Some(OptionVisibilityPubArgumentClause::Empty( + OptionVisibilityPubArgumentClauseEmpty::from_syntax_node(db, node), + )) + } + SyntaxKind::VisibilityPubArgumentClause => { + Some(OptionVisibilityPubArgumentClause::VisibilityPubArgumentClause( + VisibilityPubArgumentClause::from_syntax_node(db, node), + )) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { OptionVisibilityPubArgumentClause::Empty(x) => x.as_syntax_node(), @@ -12615,6 +13816,14 @@ impl TypedSyntaxNode for OptionVisibilityPubArgumentClauseEmpty { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::OptionVisibilityPubArgumentClauseEmpty { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -12709,6 +13918,14 @@ impl TypedSyntaxNode for VisibilityPub { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::VisibilityPub { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -12781,6 +13998,18 @@ impl TypedSyntaxNode for Visibility { _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "Visibility"), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::VisibilityDefault => { + Some(Visibility::Default(VisibilityDefault::from_syntax_node(db, node))) + } + SyntaxKind::VisibilityPub => { + Some(Visibility::Pub(VisibilityPub::from_syntax_node(db, node))) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { Visibility::Default(x) => x.as_syntax_node(), @@ -12911,6 +14140,10 @@ impl TypedSyntaxNode for ItemModule { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ItemModule { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -12985,6 +14218,18 @@ impl TypedSyntaxNode for MaybeModuleBody { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::ModuleBody => { + Some(MaybeModuleBody::Some(ModuleBody::from_syntax_node(db, node))) + } + SyntaxKind::TerminalSemicolon => { + Some(MaybeModuleBody::None(TerminalSemicolon::from_syntax_node(db, node))) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { MaybeModuleBody::Some(x) => x.as_syntax_node(), @@ -13094,6 +14339,10 @@ impl TypedSyntaxNode for ModuleBody { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ModuleBody { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -13209,6 +14458,14 @@ impl TypedSyntaxNode for FunctionDeclaration { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::FunctionDeclaration { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -13357,6 +14614,10 @@ impl TypedSyntaxNode for ItemConstant { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ItemConstant { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -13472,6 +14733,14 @@ impl TypedSyntaxNode for FunctionWithBody { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::FunctionWithBody { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -13594,6 +14863,14 @@ impl TypedSyntaxNode for ItemExternFunction { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ItemExternFunction { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -13735,6 +15012,14 @@ impl TypedSyntaxNode for ItemExternType { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ItemExternType { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -13863,6 +15148,10 @@ impl TypedSyntaxNode for ItemTrait { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ItemTrait { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -13937,6 +15226,18 @@ impl TypedSyntaxNode for MaybeTraitBody { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::TraitBody => { + Some(MaybeTraitBody::Some(TraitBody::from_syntax_node(db, node))) + } + SyntaxKind::TerminalSemicolon => { + Some(MaybeTraitBody::None(TerminalSemicolon::from_syntax_node(db, node))) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { MaybeTraitBody::Some(x) => x.as_syntax_node(), @@ -14046,6 +15347,10 @@ impl TypedSyntaxNode for TraitBody { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TraitBody { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -14115,6 +15420,13 @@ impl TypedSyntaxNode for TraitItemList { fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self { Self(ElementList::new(node)) } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + if node.kind(db) == SyntaxKind::TraitItemList { + Some(Self(ElementList::new(node))) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -14227,6 +15539,27 @@ impl TypedSyntaxNode for TraitItem { _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "TraitItem"), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::TraitItemFunction => { + Some(TraitItem::Function(TraitItemFunction::from_syntax_node(db, node))) + } + SyntaxKind::TraitItemType => { + Some(TraitItem::Type(TraitItemType::from_syntax_node(db, node))) + } + SyntaxKind::TraitItemConstant => { + Some(TraitItem::Constant(TraitItemConstant::from_syntax_node(db, node))) + } + SyntaxKind::TraitItemImpl => { + Some(TraitItem::Impl(TraitItemImpl::from_syntax_node(db, node))) + } + SyntaxKind::TraitItemMissing => { + Some(TraitItem::Missing(TraitItemMissing::from_syntax_node(db, node))) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { TraitItem::Function(x) => x.as_syntax_node(), @@ -14321,6 +15654,14 @@ impl TypedSyntaxNode for TraitItemMissing { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TraitItemMissing { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -14430,6 +15771,14 @@ impl TypedSyntaxNode for TraitItemFunction { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TraitItemFunction { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -14552,6 +15901,14 @@ impl TypedSyntaxNode for TraitItemType { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TraitItemType { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -14674,6 +16031,14 @@ impl TypedSyntaxNode for TraitItemConstant { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TraitItemConstant { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -14802,6 +16167,14 @@ impl TypedSyntaxNode for TraitItemImpl { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TraitItemImpl { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -14879,6 +16252,18 @@ impl TypedSyntaxNode for MaybeTraitFunctionBody { ), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::ExprBlock => { + Some(MaybeTraitFunctionBody::Some(ExprBlock::from_syntax_node(db, node))) + } + SyntaxKind::TerminalSemicolon => { + Some(MaybeTraitFunctionBody::None(TerminalSemicolon::from_syntax_node(db, node))) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { MaybeTraitFunctionBody::Some(x) => x.as_syntax_node(), @@ -15036,6 +16421,10 @@ impl TypedSyntaxNode for ItemImpl { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ItemImpl { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -15148,6 +16537,14 @@ impl TypedSyntaxNode for ItemInlineMacro { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ItemInlineMacro { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -15231,6 +16628,14 @@ impl TypedSyntaxNode for ItemHeaderDoc { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ItemHeaderDoc { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -15303,6 +16708,16 @@ impl TypedSyntaxNode for MaybeImplBody { _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "MaybeImplBody"), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::ImplBody => Some(MaybeImplBody::Some(ImplBody::from_syntax_node(db, node))), + SyntaxKind::TerminalSemicolon => { + Some(MaybeImplBody::None(TerminalSemicolon::from_syntax_node(db, node))) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { MaybeImplBody::Some(x) => x.as_syntax_node(), @@ -15412,6 +16827,10 @@ impl TypedSyntaxNode for ImplBody { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ImplBody { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -15481,6 +16900,13 @@ impl TypedSyntaxNode for ImplItemList { fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self { Self(ElementList::new(node)) } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + if node.kind(db) == SyntaxKind::ImplItemList { + Some(Self(ElementList::new(node))) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -15681,6 +17107,42 @@ impl TypedSyntaxNode for ImplItem { _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "ImplItem"), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::FunctionWithBody => { + Some(ImplItem::Function(FunctionWithBody::from_syntax_node(db, node))) + } + SyntaxKind::ItemTypeAlias => { + Some(ImplItem::Type(ItemTypeAlias::from_syntax_node(db, node))) + } + SyntaxKind::ItemConstant => { + Some(ImplItem::Constant(ItemConstant::from_syntax_node(db, node))) + } + SyntaxKind::ItemImplAlias => { + Some(ImplItem::Impl(ItemImplAlias::from_syntax_node(db, node))) + } + SyntaxKind::ItemModule => { + Some(ImplItem::Module(ItemModule::from_syntax_node(db, node))) + } + SyntaxKind::ItemUse => Some(ImplItem::Use(ItemUse::from_syntax_node(db, node))), + SyntaxKind::ItemExternFunction => { + Some(ImplItem::ExternFunction(ItemExternFunction::from_syntax_node(db, node))) + } + SyntaxKind::ItemExternType => { + Some(ImplItem::ExternType(ItemExternType::from_syntax_node(db, node))) + } + SyntaxKind::ItemTrait => Some(ImplItem::Trait(ItemTrait::from_syntax_node(db, node))), + SyntaxKind::ItemStruct => { + Some(ImplItem::Struct(ItemStruct::from_syntax_node(db, node))) + } + SyntaxKind::ItemEnum => Some(ImplItem::Enum(ItemEnum::from_syntax_node(db, node))), + SyntaxKind::ImplItemMissing => { + Some(ImplItem::Missing(ImplItemMissing::from_syntax_node(db, node))) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { ImplItem::Function(x) => x.as_syntax_node(), @@ -15789,6 +17251,14 @@ impl TypedSyntaxNode for ImplItemMissing { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ImplItemMissing { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -15937,6 +17407,14 @@ impl TypedSyntaxNode for ItemImplAlias { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ItemImplAlias { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -16085,6 +17563,10 @@ impl TypedSyntaxNode for ItemStruct { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ItemStruct { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -16233,6 +17715,10 @@ impl TypedSyntaxNode for ItemEnum { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ItemEnum { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -16381,6 +17867,14 @@ impl TypedSyntaxNode for ItemTypeAlias { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ItemTypeAlias { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -16503,6 +17997,10 @@ impl TypedSyntaxNode for ItemUse { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::ItemUse { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -16597,6 +18095,20 @@ impl TypedSyntaxNode for UsePath { _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "UsePath"), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::UsePathLeaf => Some(UsePath::Leaf(UsePathLeaf::from_syntax_node(db, node))), + SyntaxKind::UsePathSingle => { + Some(UsePath::Single(UsePathSingle::from_syntax_node(db, node))) + } + SyntaxKind::UsePathMulti => { + Some(UsePath::Multi(UsePathMulti::from_syntax_node(db, node))) + } + SyntaxKind::UsePathStar => Some(UsePath::Star(UsePathStar::from_syntax_node(db, node))), + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { UsePath::Leaf(x) => x.as_syntax_node(), @@ -16722,6 +18234,10 @@ impl TypedSyntaxNode for UsePathLeaf { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::UsePathLeaf { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -16822,6 +18338,14 @@ impl TypedSyntaxNode for UsePathSingle { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::UsePathSingle { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -16922,6 +18446,10 @@ impl TypedSyntaxNode for UsePathMulti { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::UsePathMulti { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -17005,6 +18533,10 @@ impl TypedSyntaxNode for UsePathStar { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::UsePathStar { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -17100,6 +18632,13 @@ impl TypedSyntaxNode for UsePathList { fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self { Self(ElementList::new(node)) } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + if node.kind(db) == SyntaxKind::UsePathList { + Some(Self(ElementList::new(node))) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -17200,6 +18739,10 @@ impl TypedSyntaxNode for AliasClause { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::AliasClause { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -17277,6 +18820,18 @@ impl TypedSyntaxNode for OptionAliasClause { ), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::OptionAliasClauseEmpty => { + Some(OptionAliasClause::Empty(OptionAliasClauseEmpty::from_syntax_node(db, node))) + } + SyntaxKind::AliasClause => { + Some(OptionAliasClause::AliasClause(AliasClause::from_syntax_node(db, node))) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { OptionAliasClause::Empty(x) => x.as_syntax_node(), @@ -17361,6 +18916,14 @@ impl TypedSyntaxNode for OptionAliasClauseEmpty { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::OptionAliasClauseEmpty { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -17435,6 +18998,18 @@ impl TypedSyntaxNode for GenericArg { _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "GenericArg"), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::GenericArgUnnamed => { + Some(GenericArg::Unnamed(GenericArgUnnamed::from_syntax_node(db, node))) + } + SyntaxKind::GenericArgNamed => { + Some(GenericArg::Named(GenericArgNamed::from_syntax_node(db, node))) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { GenericArg::Unnamed(x) => x.as_syntax_node(), @@ -17544,6 +19119,14 @@ impl TypedSyntaxNode for GenericArgNamed { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::GenericArgNamed { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -17627,6 +19210,14 @@ impl TypedSyntaxNode for GenericArgUnnamed { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::GenericArgUnnamed { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -17703,6 +19294,18 @@ impl TypedSyntaxNode for GenericArgValue { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::GenericArgValueExpr => { + Some(GenericArgValue::Expr(GenericArgValueExpr::from_syntax_node(db, node))) + } + SyntaxKind::TerminalUnderscore => { + Some(GenericArgValue::Underscore(TerminalUnderscore::from_syntax_node(db, node))) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { GenericArgValue::Expr(x) => x.as_syntax_node(), @@ -17795,6 +19398,14 @@ impl TypedSyntaxNode for GenericArgValueExpr { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::GenericArgValueExpr { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -17895,6 +19506,10 @@ impl TypedSyntaxNode for GenericArgs { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::GenericArgs { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -17990,6 +19605,13 @@ impl TypedSyntaxNode for GenericArgList { fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self { Self(ElementList::new(node)) } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + if node.kind(db) == SyntaxKind::GenericArgList { + Some(Self(ElementList::new(node))) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -18090,6 +19712,14 @@ impl TypedSyntaxNode for AssociatedItemConstraint { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::AssociatedItemConstraint { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -18193,6 +19823,14 @@ impl TypedSyntaxNode for AssociatedItemConstraints { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::AssociatedItemConstraints { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -18288,6 +19926,13 @@ impl TypedSyntaxNode for AssociatedItemConstraintList { fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self { Self(ElementList::new(node)) } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + if node.kind(db) == SyntaxKind::AssociatedItemConstraintList { + Some(Self(ElementList::new(node))) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -18369,6 +20014,22 @@ impl TypedSyntaxNode for OptionAssociatedItemConstraints { ), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::OptionAssociatedItemConstraintsEmpty => { + Some(OptionAssociatedItemConstraints::Empty( + OptionAssociatedItemConstraintsEmpty::from_syntax_node(db, node), + )) + } + SyntaxKind::AssociatedItemConstraints => { + Some(OptionAssociatedItemConstraints::AssociatedItemConstraints( + AssociatedItemConstraints::from_syntax_node(db, node), + )) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { OptionAssociatedItemConstraints::Empty(x) => x.as_syntax_node(), @@ -18458,6 +20119,14 @@ impl TypedSyntaxNode for OptionAssociatedItemConstraintsEmpty { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::OptionAssociatedItemConstraintsEmpty { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -18537,6 +20206,22 @@ impl TypedSyntaxNode for OptionWrappedGenericParamList { ), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::OptionWrappedGenericParamListEmpty => { + Some(OptionWrappedGenericParamList::Empty( + OptionWrappedGenericParamListEmpty::from_syntax_node(db, node), + )) + } + SyntaxKind::WrappedGenericParamList => { + Some(OptionWrappedGenericParamList::WrappedGenericParamList( + WrappedGenericParamList::from_syntax_node(db, node), + )) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { OptionWrappedGenericParamList::Empty(x) => x.as_syntax_node(), @@ -18624,6 +20309,14 @@ impl TypedSyntaxNode for OptionWrappedGenericParamListEmpty { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::OptionWrappedGenericParamListEmpty { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -18724,6 +20417,14 @@ impl TypedSyntaxNode for WrappedGenericParamList { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::WrappedGenericParamList { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -18819,6 +20520,13 @@ impl TypedSyntaxNode for GenericParamList { fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self { Self(ElementList::new(node)) } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + if node.kind(db) == SyntaxKind::GenericParamList { + Some(Self(ElementList::new(node))) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -18935,6 +20643,27 @@ impl TypedSyntaxNode for GenericParam { _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "GenericParam"), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::GenericParamType => { + Some(GenericParam::Type(GenericParamType::from_syntax_node(db, node))) + } + SyntaxKind::GenericParamConst => { + Some(GenericParam::Const(GenericParamConst::from_syntax_node(db, node))) + } + SyntaxKind::GenericParamImplNamed => { + Some(GenericParam::ImplNamed(GenericParamImplNamed::from_syntax_node(db, node))) + } + SyntaxKind::GenericParamImplAnonymous => Some(GenericParam::ImplAnonymous( + GenericParamImplAnonymous::from_syntax_node(db, node), + )), + SyntaxKind::GenericParamNegativeImpl => Some(GenericParam::NegativeImpl( + GenericParamNegativeImpl::from_syntax_node(db, node), + )), + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { GenericParam::Type(x) => x.as_syntax_node(), @@ -19046,6 +20775,14 @@ impl TypedSyntaxNode for GenericParamType { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::GenericParamType { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -19161,6 +20898,14 @@ impl TypedSyntaxNode for GenericParamConst { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::GenericParamConst { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -19283,6 +21028,14 @@ impl TypedSyntaxNode for GenericParamImplNamed { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::GenericParamImplNamed { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -19383,6 +21136,14 @@ impl TypedSyntaxNode for GenericParamImplAnonymous { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::GenericParamImplAnonymous { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -19474,6 +21235,14 @@ impl TypedSyntaxNode for GenericParamNegativeImpl { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::GenericParamNegativeImpl { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -19557,6 +21326,14 @@ impl TypedSyntaxNode for TriviumSkippedNode { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TriviumSkippedNode { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -19631,6 +21408,18 @@ impl TypedSyntaxNode for SkippedNode { _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "SkippedNode"), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::AttributeList => { + Some(SkippedNode::AttributeList(AttributeList::from_syntax_node(db, node))) + } + SyntaxKind::VisibilityPub => { + Some(SkippedNode::VisibilityPub(VisibilityPub::from_syntax_node(db, node))) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { SkippedNode::AttributeList(x) => x.as_syntax_node(), @@ -19715,6 +21504,12 @@ impl TypedSyntaxNode for TokenIdentifier { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -19817,6 +21612,14 @@ impl TypedSyntaxNode for TerminalIdentifier { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalIdentifier { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -19893,6 +21696,12 @@ impl TypedSyntaxNode for TokenLiteralNumber { ), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -19995,6 +21804,14 @@ impl TypedSyntaxNode for TerminalLiteralNumber { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalLiteralNumber { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -20070,6 +21887,12 @@ impl TypedSyntaxNode for TokenShortString { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -20172,6 +21995,14 @@ impl TypedSyntaxNode for TerminalShortString { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalShortString { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -20247,6 +22078,12 @@ impl TypedSyntaxNode for TokenString { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -20349,6 +22186,14 @@ impl TypedSyntaxNode for TerminalString { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalString { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -20424,6 +22269,12 @@ impl TypedSyntaxNode for TokenAs { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -20526,6 +22377,10 @@ impl TypedSyntaxNode for TerminalAs { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalAs { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -20601,6 +22456,12 @@ impl TypedSyntaxNode for TokenConst { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -20703,6 +22564,14 @@ impl TypedSyntaxNode for TerminalConst { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalConst { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -20778,6 +22647,12 @@ impl TypedSyntaxNode for TokenElse { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -20880,6 +22755,10 @@ impl TypedSyntaxNode for TerminalElse { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalElse { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -20955,6 +22834,12 @@ impl TypedSyntaxNode for TokenEnum { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -21057,6 +22942,10 @@ impl TypedSyntaxNode for TerminalEnum { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalEnum { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -21132,6 +23021,12 @@ impl TypedSyntaxNode for TokenExtern { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -21234,6 +23129,14 @@ impl TypedSyntaxNode for TerminalExtern { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalExtern { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -21309,6 +23212,12 @@ impl TypedSyntaxNode for TokenFalse { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -21411,6 +23320,14 @@ impl TypedSyntaxNode for TerminalFalse { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalFalse { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -21486,6 +23403,12 @@ impl TypedSyntaxNode for TokenFunction { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -21588,6 +23511,14 @@ impl TypedSyntaxNode for TerminalFunction { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalFunction { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -21663,6 +23594,12 @@ impl TypedSyntaxNode for TokenIf { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -21765,6 +23702,10 @@ impl TypedSyntaxNode for TerminalIf { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalIf { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -21840,6 +23781,12 @@ impl TypedSyntaxNode for TokenWhile { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -21942,6 +23889,14 @@ impl TypedSyntaxNode for TerminalWhile { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalWhile { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -22017,6 +23972,12 @@ impl TypedSyntaxNode for TokenFor { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -22119,6 +24080,10 @@ impl TypedSyntaxNode for TerminalFor { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalFor { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -22194,6 +24159,12 @@ impl TypedSyntaxNode for TokenLoop { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -22296,6 +24267,10 @@ impl TypedSyntaxNode for TerminalLoop { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalLoop { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -22371,6 +24346,12 @@ impl TypedSyntaxNode for TokenImpl { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -22473,6 +24454,10 @@ impl TypedSyntaxNode for TerminalImpl { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalImpl { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -22548,6 +24533,12 @@ impl TypedSyntaxNode for TokenImplicits { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -22650,6 +24641,14 @@ impl TypedSyntaxNode for TerminalImplicits { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalImplicits { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -22725,6 +24724,12 @@ impl TypedSyntaxNode for TokenLet { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -22827,6 +24832,10 @@ impl TypedSyntaxNode for TerminalLet { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalLet { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -22902,6 +24911,12 @@ impl TypedSyntaxNode for TokenMatch { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -23004,6 +25019,14 @@ impl TypedSyntaxNode for TerminalMatch { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalMatch { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -23079,6 +25102,12 @@ impl TypedSyntaxNode for TokenModule { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -23181,6 +25210,14 @@ impl TypedSyntaxNode for TerminalModule { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalModule { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -23256,6 +25293,12 @@ impl TypedSyntaxNode for TokenMut { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -23358,6 +25401,10 @@ impl TypedSyntaxNode for TerminalMut { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalMut { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -23433,6 +25480,12 @@ impl TypedSyntaxNode for TokenNoPanic { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -23535,6 +25588,14 @@ impl TypedSyntaxNode for TerminalNoPanic { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalNoPanic { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -23610,6 +25671,12 @@ impl TypedSyntaxNode for TokenOf { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -23712,6 +25779,10 @@ impl TypedSyntaxNode for TerminalOf { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalOf { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -23787,6 +25858,12 @@ impl TypedSyntaxNode for TokenRef { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -23889,6 +25966,10 @@ impl TypedSyntaxNode for TerminalRef { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalRef { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -23964,6 +26045,12 @@ impl TypedSyntaxNode for TokenContinue { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -24066,6 +26153,14 @@ impl TypedSyntaxNode for TerminalContinue { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalContinue { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -24141,6 +26236,12 @@ impl TypedSyntaxNode for TokenReturn { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -24243,6 +26344,14 @@ impl TypedSyntaxNode for TerminalReturn { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalReturn { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -24318,6 +26427,12 @@ impl TypedSyntaxNode for TokenBreak { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -24420,6 +26535,14 @@ impl TypedSyntaxNode for TerminalBreak { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalBreak { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -24495,6 +26618,12 @@ impl TypedSyntaxNode for TokenStruct { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -24597,6 +26726,14 @@ impl TypedSyntaxNode for TerminalStruct { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalStruct { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -24672,6 +26809,12 @@ impl TypedSyntaxNode for TokenTrait { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -24774,6 +26917,14 @@ impl TypedSyntaxNode for TerminalTrait { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalTrait { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -24849,6 +27000,12 @@ impl TypedSyntaxNode for TokenTrue { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -24951,6 +27108,10 @@ impl TypedSyntaxNode for TerminalTrue { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalTrue { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -25026,6 +27187,12 @@ impl TypedSyntaxNode for TokenType { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -25128,6 +27295,10 @@ impl TypedSyntaxNode for TerminalType { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalType { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -25203,6 +27374,12 @@ impl TypedSyntaxNode for TokenUse { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -25305,6 +27482,10 @@ impl TypedSyntaxNode for TerminalUse { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalUse { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -25380,6 +27561,12 @@ impl TypedSyntaxNode for TokenPub { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -25482,6 +27669,10 @@ impl TypedSyntaxNode for TerminalPub { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalPub { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -25557,6 +27748,12 @@ impl TypedSyntaxNode for TokenAnd { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -25659,6 +27856,10 @@ impl TypedSyntaxNode for TerminalAnd { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalAnd { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -25734,6 +27935,12 @@ impl TypedSyntaxNode for TokenAndAnd { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -25836,6 +28043,14 @@ impl TypedSyntaxNode for TerminalAndAnd { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalAndAnd { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -25911,6 +28126,12 @@ impl TypedSyntaxNode for TokenArrow { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -26013,6 +28234,14 @@ impl TypedSyntaxNode for TerminalArrow { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalArrow { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -26088,6 +28317,12 @@ impl TypedSyntaxNode for TokenAt { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -26190,6 +28425,10 @@ impl TypedSyntaxNode for TerminalAt { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalAt { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -26266,6 +28505,12 @@ impl TypedSyntaxNode for TokenBadCharacters { ), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -26368,6 +28613,14 @@ impl TypedSyntaxNode for TerminalBadCharacters { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalBadCharacters { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -26443,6 +28696,12 @@ impl TypedSyntaxNode for TokenColon { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -26545,6 +28804,14 @@ impl TypedSyntaxNode for TerminalColon { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalColon { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -26620,6 +28887,12 @@ impl TypedSyntaxNode for TokenColonColon { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -26722,6 +28995,14 @@ impl TypedSyntaxNode for TerminalColonColon { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalColonColon { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -26797,6 +29078,12 @@ impl TypedSyntaxNode for TokenComma { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -26899,6 +29186,14 @@ impl TypedSyntaxNode for TerminalComma { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalComma { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -26974,6 +29269,12 @@ impl TypedSyntaxNode for TokenDiv { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -27076,6 +29377,10 @@ impl TypedSyntaxNode for TerminalDiv { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalDiv { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -27151,6 +29456,12 @@ impl TypedSyntaxNode for TokenDivEq { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -27253,6 +29564,14 @@ impl TypedSyntaxNode for TerminalDivEq { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalDivEq { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -27328,6 +29647,12 @@ impl TypedSyntaxNode for TokenDot { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -27430,6 +29755,10 @@ impl TypedSyntaxNode for TerminalDot { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalDot { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -27505,6 +29834,12 @@ impl TypedSyntaxNode for TokenDotDot { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -27607,6 +29942,14 @@ impl TypedSyntaxNode for TerminalDotDot { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalDotDot { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -27682,6 +30025,12 @@ impl TypedSyntaxNode for TokenEndOfFile { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -27784,6 +30133,14 @@ impl TypedSyntaxNode for TerminalEndOfFile { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalEndOfFile { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -27859,6 +30216,12 @@ impl TypedSyntaxNode for TokenEq { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -27961,6 +30324,10 @@ impl TypedSyntaxNode for TerminalEq { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalEq { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -28036,6 +30403,12 @@ impl TypedSyntaxNode for TokenEqEq { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -28138,6 +30511,10 @@ impl TypedSyntaxNode for TerminalEqEq { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalEqEq { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -28213,6 +30590,12 @@ impl TypedSyntaxNode for TokenGE { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -28315,6 +30698,10 @@ impl TypedSyntaxNode for TerminalGE { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalGE { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -28390,6 +30777,12 @@ impl TypedSyntaxNode for TokenGT { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -28492,6 +30885,10 @@ impl TypedSyntaxNode for TerminalGT { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalGT { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -28567,6 +30964,12 @@ impl TypedSyntaxNode for TokenHash { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -28669,6 +31072,10 @@ impl TypedSyntaxNode for TerminalHash { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalHash { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -28744,6 +31151,12 @@ impl TypedSyntaxNode for TokenLBrace { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -28846,6 +31259,14 @@ impl TypedSyntaxNode for TerminalLBrace { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalLBrace { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -28921,6 +31342,12 @@ impl TypedSyntaxNode for TokenLBrack { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -29023,6 +31450,14 @@ impl TypedSyntaxNode for TerminalLBrack { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalLBrack { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -29098,6 +31533,12 @@ impl TypedSyntaxNode for TokenLE { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -29200,6 +31641,10 @@ impl TypedSyntaxNode for TerminalLE { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalLE { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -29275,6 +31720,12 @@ impl TypedSyntaxNode for TokenLParen { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -29377,6 +31828,14 @@ impl TypedSyntaxNode for TerminalLParen { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalLParen { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -29452,6 +31911,12 @@ impl TypedSyntaxNode for TokenLT { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -29554,6 +32019,10 @@ impl TypedSyntaxNode for TerminalLT { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalLT { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -29629,6 +32098,12 @@ impl TypedSyntaxNode for TokenMatchArrow { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -29731,6 +32206,14 @@ impl TypedSyntaxNode for TerminalMatchArrow { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalMatchArrow { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -29806,6 +32289,12 @@ impl TypedSyntaxNode for TokenMinus { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -29908,6 +32397,14 @@ impl TypedSyntaxNode for TerminalMinus { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalMinus { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -29983,6 +32480,12 @@ impl TypedSyntaxNode for TokenMinusEq { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -30085,6 +32588,14 @@ impl TypedSyntaxNode for TerminalMinusEq { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalMinusEq { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -30160,6 +32671,12 @@ impl TypedSyntaxNode for TokenMod { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -30262,6 +32779,10 @@ impl TypedSyntaxNode for TerminalMod { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalMod { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -30337,6 +32858,12 @@ impl TypedSyntaxNode for TokenModEq { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -30439,6 +32966,14 @@ impl TypedSyntaxNode for TerminalModEq { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalModEq { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -30514,6 +33049,12 @@ impl TypedSyntaxNode for TokenMul { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -30616,6 +33157,10 @@ impl TypedSyntaxNode for TerminalMul { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalMul { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -30691,6 +33236,12 @@ impl TypedSyntaxNode for TokenMulEq { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -30793,6 +33344,14 @@ impl TypedSyntaxNode for TerminalMulEq { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalMulEq { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -30868,6 +33427,12 @@ impl TypedSyntaxNode for TokenNeq { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -30970,6 +33535,10 @@ impl TypedSyntaxNode for TerminalNeq { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalNeq { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -31045,6 +33614,12 @@ impl TypedSyntaxNode for TokenNot { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -31147,6 +33722,10 @@ impl TypedSyntaxNode for TerminalNot { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalNot { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -31222,6 +33801,12 @@ impl TypedSyntaxNode for TokenBitNot { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -31324,6 +33909,14 @@ impl TypedSyntaxNode for TerminalBitNot { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalBitNot { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -31399,6 +33992,12 @@ impl TypedSyntaxNode for TokenOr { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -31501,6 +34100,10 @@ impl TypedSyntaxNode for TerminalOr { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalOr { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -31576,6 +34179,12 @@ impl TypedSyntaxNode for TokenOrOr { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -31678,6 +34287,10 @@ impl TypedSyntaxNode for TerminalOrOr { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalOrOr { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -31753,6 +34366,12 @@ impl TypedSyntaxNode for TokenPlus { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -31855,6 +34474,10 @@ impl TypedSyntaxNode for TerminalPlus { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalPlus { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -31930,6 +34553,12 @@ impl TypedSyntaxNode for TokenPlusEq { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -32032,6 +34661,14 @@ impl TypedSyntaxNode for TerminalPlusEq { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalPlusEq { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -32107,6 +34744,12 @@ impl TypedSyntaxNode for TokenQuestionMark { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -32209,6 +34852,14 @@ impl TypedSyntaxNode for TerminalQuestionMark { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalQuestionMark { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -32284,6 +34935,12 @@ impl TypedSyntaxNode for TokenRBrace { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -32386,6 +35043,14 @@ impl TypedSyntaxNode for TerminalRBrace { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalRBrace { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -32461,6 +35126,12 @@ impl TypedSyntaxNode for TokenRBrack { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -32563,6 +35234,14 @@ impl TypedSyntaxNode for TerminalRBrack { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalRBrack { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -32638,6 +35317,12 @@ impl TypedSyntaxNode for TokenRParen { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -32740,6 +35425,14 @@ impl TypedSyntaxNode for TerminalRParen { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalRParen { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -32815,6 +35508,12 @@ impl TypedSyntaxNode for TokenSemicolon { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -32917,6 +35616,14 @@ impl TypedSyntaxNode for TerminalSemicolon { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalSemicolon { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -32992,6 +35699,12 @@ impl TypedSyntaxNode for TokenUnderscore { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -33094,6 +35807,14 @@ impl TypedSyntaxNode for TerminalUnderscore { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalUnderscore { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -33169,6 +35890,12 @@ impl TypedSyntaxNode for TokenXor { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -33271,6 +35998,10 @@ impl TypedSyntaxNode for TerminalXor { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalXor { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -33362,6 +36093,10 @@ impl TypedSyntaxNode for SyntaxFile { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::SyntaxFile { Some(Self::from_syntax_node(db, node)) } else { None } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -33437,6 +36172,12 @@ impl TypedSyntaxNode for TokenEmpty { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -33539,6 +36280,14 @@ impl TypedSyntaxNode for TerminalEmpty { let children = db.get_children(node.clone()); Self { node, children } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + if kind == SyntaxKind::TerminalEmpty { + Some(Self::from_syntax_node(db, node)) + } else { + None + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -33615,6 +36364,12 @@ impl TypedSyntaxNode for TokenSingleLineComment { ), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -33691,6 +36446,12 @@ impl TypedSyntaxNode for TokenSingleLineInnerComment { ), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -33767,6 +36528,12 @@ impl TypedSyntaxNode for TokenSingleLineDocComment { ), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -33842,6 +36609,12 @@ impl TypedSyntaxNode for TokenWhitespace { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -33917,6 +36690,12 @@ impl TypedSyntaxNode for TokenNewline { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -33992,6 +36771,12 @@ impl TypedSyntaxNode for TokenMissing { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -34067,6 +36852,12 @@ impl TypedSyntaxNode for TokenSkipped { } } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + match node.0.green.lookup_intern(db).details { + GreenNodeDetails::Token(_) => Some(Self { node }), + GreenNodeDetails::Node { .. } => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { self.node.clone() } @@ -35185,6 +37976,246 @@ impl TypedSyntaxNode for TokenNode { _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "TokenNode"), } } + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + let kind = node.kind(db); + match kind { + SyntaxKind::TerminalIdentifier => { + Some(TokenNode::TerminalIdentifier(TerminalIdentifier::from_syntax_node(db, node))) + } + SyntaxKind::TerminalLiteralNumber => Some(TokenNode::TerminalLiteralNumber( + TerminalLiteralNumber::from_syntax_node(db, node), + )), + SyntaxKind::TerminalShortString => Some(TokenNode::TerminalShortString( + TerminalShortString::from_syntax_node(db, node), + )), + SyntaxKind::TerminalString => { + Some(TokenNode::TerminalString(TerminalString::from_syntax_node(db, node))) + } + SyntaxKind::TerminalAs => { + Some(TokenNode::TerminalAs(TerminalAs::from_syntax_node(db, node))) + } + SyntaxKind::TerminalConst => { + Some(TokenNode::TerminalConst(TerminalConst::from_syntax_node(db, node))) + } + SyntaxKind::TerminalElse => { + Some(TokenNode::TerminalElse(TerminalElse::from_syntax_node(db, node))) + } + SyntaxKind::TerminalEnum => { + Some(TokenNode::TerminalEnum(TerminalEnum::from_syntax_node(db, node))) + } + SyntaxKind::TerminalExtern => { + Some(TokenNode::TerminalExtern(TerminalExtern::from_syntax_node(db, node))) + } + SyntaxKind::TerminalFalse => { + Some(TokenNode::TerminalFalse(TerminalFalse::from_syntax_node(db, node))) + } + SyntaxKind::TerminalFunction => { + Some(TokenNode::TerminalFunction(TerminalFunction::from_syntax_node(db, node))) + } + SyntaxKind::TerminalIf => { + Some(TokenNode::TerminalIf(TerminalIf::from_syntax_node(db, node))) + } + SyntaxKind::TerminalWhile => { + Some(TokenNode::TerminalWhile(TerminalWhile::from_syntax_node(db, node))) + } + SyntaxKind::TerminalFor => { + Some(TokenNode::TerminalFor(TerminalFor::from_syntax_node(db, node))) + } + SyntaxKind::TerminalLoop => { + Some(TokenNode::TerminalLoop(TerminalLoop::from_syntax_node(db, node))) + } + SyntaxKind::TerminalImpl => { + Some(TokenNode::TerminalImpl(TerminalImpl::from_syntax_node(db, node))) + } + SyntaxKind::TerminalImplicits => { + Some(TokenNode::TerminalImplicits(TerminalImplicits::from_syntax_node(db, node))) + } + SyntaxKind::TerminalLet => { + Some(TokenNode::TerminalLet(TerminalLet::from_syntax_node(db, node))) + } + SyntaxKind::TerminalMatch => { + Some(TokenNode::TerminalMatch(TerminalMatch::from_syntax_node(db, node))) + } + SyntaxKind::TerminalModule => { + Some(TokenNode::TerminalModule(TerminalModule::from_syntax_node(db, node))) + } + SyntaxKind::TerminalMut => { + Some(TokenNode::TerminalMut(TerminalMut::from_syntax_node(db, node))) + } + SyntaxKind::TerminalNoPanic => { + Some(TokenNode::TerminalNoPanic(TerminalNoPanic::from_syntax_node(db, node))) + } + SyntaxKind::TerminalOf => { + Some(TokenNode::TerminalOf(TerminalOf::from_syntax_node(db, node))) + } + SyntaxKind::TerminalRef => { + Some(TokenNode::TerminalRef(TerminalRef::from_syntax_node(db, node))) + } + SyntaxKind::TerminalContinue => { + Some(TokenNode::TerminalContinue(TerminalContinue::from_syntax_node(db, node))) + } + SyntaxKind::TerminalReturn => { + Some(TokenNode::TerminalReturn(TerminalReturn::from_syntax_node(db, node))) + } + SyntaxKind::TerminalBreak => { + Some(TokenNode::TerminalBreak(TerminalBreak::from_syntax_node(db, node))) + } + SyntaxKind::TerminalStruct => { + Some(TokenNode::TerminalStruct(TerminalStruct::from_syntax_node(db, node))) + } + SyntaxKind::TerminalTrait => { + Some(TokenNode::TerminalTrait(TerminalTrait::from_syntax_node(db, node))) + } + SyntaxKind::TerminalTrue => { + Some(TokenNode::TerminalTrue(TerminalTrue::from_syntax_node(db, node))) + } + SyntaxKind::TerminalType => { + Some(TokenNode::TerminalType(TerminalType::from_syntax_node(db, node))) + } + SyntaxKind::TerminalUse => { + Some(TokenNode::TerminalUse(TerminalUse::from_syntax_node(db, node))) + } + SyntaxKind::TerminalPub => { + Some(TokenNode::TerminalPub(TerminalPub::from_syntax_node(db, node))) + } + SyntaxKind::TerminalAnd => { + Some(TokenNode::TerminalAnd(TerminalAnd::from_syntax_node(db, node))) + } + SyntaxKind::TerminalAndAnd => { + Some(TokenNode::TerminalAndAnd(TerminalAndAnd::from_syntax_node(db, node))) + } + SyntaxKind::TerminalArrow => { + Some(TokenNode::TerminalArrow(TerminalArrow::from_syntax_node(db, node))) + } + SyntaxKind::TerminalAt => { + Some(TokenNode::TerminalAt(TerminalAt::from_syntax_node(db, node))) + } + SyntaxKind::TerminalBadCharacters => Some(TokenNode::TerminalBadCharacters( + TerminalBadCharacters::from_syntax_node(db, node), + )), + SyntaxKind::TerminalColon => { + Some(TokenNode::TerminalColon(TerminalColon::from_syntax_node(db, node))) + } + SyntaxKind::TerminalColonColon => { + Some(TokenNode::TerminalColonColon(TerminalColonColon::from_syntax_node(db, node))) + } + SyntaxKind::TerminalComma => { + Some(TokenNode::TerminalComma(TerminalComma::from_syntax_node(db, node))) + } + SyntaxKind::TerminalDiv => { + Some(TokenNode::TerminalDiv(TerminalDiv::from_syntax_node(db, node))) + } + SyntaxKind::TerminalDivEq => { + Some(TokenNode::TerminalDivEq(TerminalDivEq::from_syntax_node(db, node))) + } + SyntaxKind::TerminalDot => { + Some(TokenNode::TerminalDot(TerminalDot::from_syntax_node(db, node))) + } + SyntaxKind::TerminalDotDot => { + Some(TokenNode::TerminalDotDot(TerminalDotDot::from_syntax_node(db, node))) + } + SyntaxKind::TerminalEndOfFile => { + Some(TokenNode::TerminalEndOfFile(TerminalEndOfFile::from_syntax_node(db, node))) + } + SyntaxKind::TerminalEq => { + Some(TokenNode::TerminalEq(TerminalEq::from_syntax_node(db, node))) + } + SyntaxKind::TerminalEqEq => { + Some(TokenNode::TerminalEqEq(TerminalEqEq::from_syntax_node(db, node))) + } + SyntaxKind::TerminalGE => { + Some(TokenNode::TerminalGE(TerminalGE::from_syntax_node(db, node))) + } + SyntaxKind::TerminalGT => { + Some(TokenNode::TerminalGT(TerminalGT::from_syntax_node(db, node))) + } + SyntaxKind::TerminalHash => { + Some(TokenNode::TerminalHash(TerminalHash::from_syntax_node(db, node))) + } + SyntaxKind::TerminalLBrace => { + Some(TokenNode::TerminalLBrace(TerminalLBrace::from_syntax_node(db, node))) + } + SyntaxKind::TerminalLBrack => { + Some(TokenNode::TerminalLBrack(TerminalLBrack::from_syntax_node(db, node))) + } + SyntaxKind::TerminalLE => { + Some(TokenNode::TerminalLE(TerminalLE::from_syntax_node(db, node))) + } + SyntaxKind::TerminalLParen => { + Some(TokenNode::TerminalLParen(TerminalLParen::from_syntax_node(db, node))) + } + SyntaxKind::TerminalLT => { + Some(TokenNode::TerminalLT(TerminalLT::from_syntax_node(db, node))) + } + SyntaxKind::TerminalMatchArrow => { + Some(TokenNode::TerminalMatchArrow(TerminalMatchArrow::from_syntax_node(db, node))) + } + SyntaxKind::TerminalMinus => { + Some(TokenNode::TerminalMinus(TerminalMinus::from_syntax_node(db, node))) + } + SyntaxKind::TerminalMinusEq => { + Some(TokenNode::TerminalMinusEq(TerminalMinusEq::from_syntax_node(db, node))) + } + SyntaxKind::TerminalMod => { + Some(TokenNode::TerminalMod(TerminalMod::from_syntax_node(db, node))) + } + SyntaxKind::TerminalModEq => { + Some(TokenNode::TerminalModEq(TerminalModEq::from_syntax_node(db, node))) + } + SyntaxKind::TerminalMul => { + Some(TokenNode::TerminalMul(TerminalMul::from_syntax_node(db, node))) + } + SyntaxKind::TerminalMulEq => { + Some(TokenNode::TerminalMulEq(TerminalMulEq::from_syntax_node(db, node))) + } + SyntaxKind::TerminalNeq => { + Some(TokenNode::TerminalNeq(TerminalNeq::from_syntax_node(db, node))) + } + SyntaxKind::TerminalNot => { + Some(TokenNode::TerminalNot(TerminalNot::from_syntax_node(db, node))) + } + SyntaxKind::TerminalBitNot => { + Some(TokenNode::TerminalBitNot(TerminalBitNot::from_syntax_node(db, node))) + } + SyntaxKind::TerminalOr => { + Some(TokenNode::TerminalOr(TerminalOr::from_syntax_node(db, node))) + } + SyntaxKind::TerminalOrOr => { + Some(TokenNode::TerminalOrOr(TerminalOrOr::from_syntax_node(db, node))) + } + SyntaxKind::TerminalPlus => { + Some(TokenNode::TerminalPlus(TerminalPlus::from_syntax_node(db, node))) + } + SyntaxKind::TerminalPlusEq => { + Some(TokenNode::TerminalPlusEq(TerminalPlusEq::from_syntax_node(db, node))) + } + SyntaxKind::TerminalQuestionMark => Some(TokenNode::TerminalQuestionMark( + TerminalQuestionMark::from_syntax_node(db, node), + )), + SyntaxKind::TerminalRBrace => { + Some(TokenNode::TerminalRBrace(TerminalRBrace::from_syntax_node(db, node))) + } + SyntaxKind::TerminalRBrack => { + Some(TokenNode::TerminalRBrack(TerminalRBrack::from_syntax_node(db, node))) + } + SyntaxKind::TerminalRParen => { + Some(TokenNode::TerminalRParen(TerminalRParen::from_syntax_node(db, node))) + } + SyntaxKind::TerminalSemicolon => { + Some(TokenNode::TerminalSemicolon(TerminalSemicolon::from_syntax_node(db, node))) + } + SyntaxKind::TerminalUnderscore => { + Some(TokenNode::TerminalUnderscore(TerminalUnderscore::from_syntax_node(db, node))) + } + SyntaxKind::TerminalXor => { + Some(TokenNode::TerminalXor(TerminalXor::from_syntax_node(db, node))) + } + SyntaxKind::TerminalEmpty => { + Some(TokenNode::TerminalEmpty(TerminalEmpty::from_syntax_node(db, node))) + } + _ => None, + } + } fn as_syntax_node(&self) -> SyntaxNode { match self { TokenNode::TerminalIdentifier(x) => x.as_syntax_node(), diff --git a/crates/cairo-lang-syntax/src/node/mod.rs b/crates/cairo-lang-syntax/src/node/mod.rs index c4ef7d26c43..6758ac0e7a5 100644 --- a/crates/cairo-lang-syntax/src/node/mod.rs +++ b/crates/cairo-lang-syntax/src/node/mod.rs @@ -228,26 +228,21 @@ impl SyntaxNode { green::GreenNodeDetails::Token(text) => buffer.push_str(text), green::GreenNodeDetails::Node { .. } => { for child in db.get_children(self.clone()).iter() { - let kind = child.kind(db); - - if matches!(kind, SyntaxKind::Trivia) { - ast::Trivia::from_syntax_node(db, child.clone()) - .elements(db) - .iter() - .for_each(|element| { - if !matches!( - element, - ast::Trivium::SingleLineComment(_) - | ast::Trivium::SingleLineDocComment(_) - | ast::Trivium::SingleLineInnerComment(_) - ) { - buffer.push_str( - &element - .as_syntax_node() - .get_text_without_all_comment_trivia(db), - ); - } - }); + if let Some(trivia) = ast::Trivia::cast(db, child.clone()) { + trivia.elements(db).iter().for_each(|element| { + if !matches!( + element, + ast::Trivium::SingleLineComment(_) + | ast::Trivium::SingleLineDocComment(_) + | ast::Trivium::SingleLineInnerComment(_) + ) { + buffer.push_str( + &element + .as_syntax_node() + .get_text_without_all_comment_trivia(db), + ); + } + }); } else { buffer .push_str(&SyntaxNode::get_text_without_all_comment_trivia(child, db)); @@ -317,14 +312,14 @@ impl SyntaxNode { /// Trait for the typed view of the syntax tree. All the internal node implementations are under /// the ast module. -pub trait TypedSyntaxNode { +pub trait TypedSyntaxNode: Sized { /// The relevant SyntaxKind. None for enums. const OPTIONAL_KIND: Option; type StablePtr: TypedStablePtr; type Green; fn missing(db: &dyn SyntaxGroup) -> Self::Green; - // TODO(spapini): Make this return an Option, if the kind is wrong. fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self; + fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option; fn as_syntax_node(&self) -> SyntaxNode; fn stable_ptr(&self) -> Self::StablePtr; } @@ -345,6 +340,14 @@ pub trait Terminal: TypedSyntaxNode { ) -> ::Green; /// Returns the text of the token of this terminal (excluding the trivia). fn text(&self, db: &dyn SyntaxGroup) -> SmolStr; + /// Casts a syntax node to this terminal type's token and then walks up to return the terminal. + fn cast_token(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option { + if node.kind(db) == Self::TokenType::OPTIONAL_KIND? { + Some(Self::from_syntax_node(db, node.parent()?)) + } else { + None + } + } } /// Trait for stable pointers to syntax nodes. From fa0a148c567f55213973a13bc285e45975e7c903 Mon Sep 17 00:00:00 2001 From: Marek Kaput Date: Fri, 10 Jan 2025 14:32:03 +0100 Subject: [PATCH 2/2] Add QoL conversion methods and explicit 0s to TextWidth and TextOffset (#7036) --- crates/cairo-lang-defs/src/patcher.rs | 17 +++--- .../src/diagnostics_test.rs | 4 +- crates/cairo-lang-filesystem/src/db.rs | 4 +- crates/cairo-lang-filesystem/src/span.rs | 29 ++++++++++ crates/cairo-lang-parser/src/db_test.rs | 9 +--- crates/cairo-lang-parser/src/lexer.rs | 4 +- crates/cairo-lang-plugins/src/test.rs | 7 +-- .../src/inline_macros/consteval_int.rs | 7 +-- crates/cairo-lang-starknet/src/plugin/test.rs | 7 ++- crates/cairo-lang-syntax/src/node/ast_test.rs | 54 ++++++------------- crates/cairo-lang-syntax/src/node/mod.rs | 7 ++- 11 files changed, 70 insertions(+), 79 deletions(-) diff --git a/crates/cairo-lang-defs/src/patcher.rs b/crates/cairo-lang-defs/src/patcher.rs index 933c841c834..79b21b3fd9c 100644 --- a/crates/cairo-lang-defs/src/patcher.rs +++ b/crates/cairo-lang-defs/src/patcher.rs @@ -268,13 +268,8 @@ impl<'a> PatchBuilder<'a> { /// Builds the resulting code and code mappings. pub fn build(mut self) -> (String, Vec) { // Adds the mapping to the original node from all code not previously mapped. - self.code_mappings.push(CodeMapping { - span: TextSpan { - start: TextOffset::default(), - end: TextOffset::default().add_width(TextWidth::from_str(&self.code)), - }, - origin: self.origin, - }); + self.code_mappings + .push(CodeMapping { span: TextSpan::from_str(&self.code), origin: self.origin }); (self.code, self.code_mappings) } @@ -320,7 +315,7 @@ impl<'a> PatchBuilder<'a> { } pub fn add_node(&mut self, node: SyntaxNode) { - let start = TextOffset::default().add_width(TextWidth::from_str(&self.code)); + let start = TextOffset::from_str(&self.code); let orig_span = node.span(self.db); self.code_mappings.push(CodeMapping { span: TextSpan { start, end: start.add_width(orig_span.width()) }, @@ -330,9 +325,9 @@ impl<'a> PatchBuilder<'a> { } fn add_mapped(&mut self, node: RewriteNode, origin: TextSpan) { - let start = TextOffset::default().add_width(TextWidth::from_str(&self.code)); + let start = TextOffset::from_str(&self.code); self.add_modified(node); - let end = TextOffset::default().add_width(TextWidth::from_str(&self.code)); + let end = TextOffset::from_str(&self.code); self.code_mappings .push(CodeMapping { span: TextSpan { start, end }, origin: CodeOrigin::Span(origin) }); } @@ -344,7 +339,7 @@ impl<'a> PatchBuilder<'a> { let origin_span = TextSpan { start: orig_start, end: orig_end }; let text = node.get_text_of_span(self.db, origin_span); - let start = TextOffset::default().add_width(TextWidth::from_str(&self.code)); + let start = TextOffset::from_str(&self.code); self.code += &text; diff --git a/crates/cairo-lang-diagnostics/src/diagnostics_test.rs b/crates/cairo-lang-diagnostics/src/diagnostics_test.rs index c9c41baf27b..662db1768c5 100644 --- a/crates/cairo-lang-diagnostics/src/diagnostics_test.rs +++ b/crates/cairo-lang-diagnostics/src/diagnostics_test.rs @@ -24,8 +24,8 @@ impl DiagnosticEntry for SimpleDiag { DiagnosticLocation { file_id: self.file_id, span: TextSpan { - start: TextOffset::default().add_width(TextWidth::new_for_testing(0)), - end: TextOffset::default().add_width(TextWidth::new_for_testing(6)), + start: TextOffset::START, + end: TextWidth::new_for_testing(6).as_offset(), }, } } diff --git a/crates/cairo-lang-filesystem/src/db.rs b/crates/cairo-lang-filesystem/src/db.rs index 94b5e8eca1c..41197aba63c 100644 --- a/crates/cairo-lang-filesystem/src/db.rs +++ b/crates/cairo-lang-filesystem/src/db.rs @@ -334,8 +334,8 @@ fn file_content(db: &dyn FilesGroup, file: FileId) -> Option> { } fn file_summary(db: &dyn FilesGroup, file: FileId) -> Option> { let content = db.file_content(file)?; - let mut line_offsets = vec![TextOffset::default()]; - let mut offset = TextOffset::default(); + let mut line_offsets = vec![TextOffset::START]; + let mut offset = TextOffset::START; for ch in content.chars() { offset = offset.add_width(TextWidth::from_char(ch)); if ch == '\n' { diff --git a/crates/cairo-lang-filesystem/src/span.rs b/crates/cairo-lang-filesystem/src/span.rs index 9386fe681e9..2d8f87062b6 100644 --- a/crates/cairo-lang-filesystem/src/span.rs +++ b/crates/cairo-lang-filesystem/src/span.rs @@ -17,6 +17,8 @@ mod test; )] pub struct TextWidth(u32); impl TextWidth { + pub const ZERO: Self = Self(0); + pub fn from_char(c: char) -> Self { Self(c.len_utf8() as u32) } @@ -27,9 +29,24 @@ impl TextWidth { pub fn new_for_testing(value: u32) -> Self { Self(value) } + /// Creates a `TextWidth` at the given index of a string. + /// + /// The index is required to be a char boundary. + /// This function runs a debug assertion to verify this, + /// while retains performance on release builds. + pub fn at(s: &str, index: usize) -> Self { + debug_assert!( + s.is_char_boundary(index), + "cannot create a TextWidth outside of a char boundary" + ); + Self(index as u32) + } pub fn as_u32(self) -> u32 { self.0 } + pub fn as_offset(self) -> TextOffset { + TextOffset(self) + } } impl Add for TextWidth { type Output = Self; @@ -57,6 +74,13 @@ impl Sum for TextWidth { )] pub struct TextOffset(TextWidth); impl TextOffset { + pub const START: Self = Self(TextWidth::ZERO); + + /// Creates a `TextOffset` at the end of a given string. + #[allow(clippy::should_implement_trait)] + pub fn from_str(content: &str) -> Self { + Self(TextWidth::from_str(content)) + } pub fn add_width(self, width: TextWidth) -> Self { TextOffset(self.0 + width) } @@ -87,6 +111,11 @@ pub struct TextSpan { pub end: TextOffset, } impl TextSpan { + /// Creates a `TextSpan` for the entirety of a given string. + #[allow(clippy::should_implement_trait)] + pub fn from_str(content: &str) -> Self { + Self { start: TextOffset::START, end: TextOffset::from_str(content) } + } pub fn width(self) -> TextWidth { self.end - self.start } diff --git a/crates/cairo-lang-parser/src/db_test.rs b/crates/cairo-lang-parser/src/db_test.rs index abc1452000d..c6f1192e242 100644 --- a/crates/cairo-lang-parser/src/db_test.rs +++ b/crates/cairo-lang-parser/src/db_test.rs @@ -1,7 +1,7 @@ use std::path::PathBuf; use cairo_lang_filesystem::ids::FileId; -use cairo_lang_filesystem::span::{TextOffset, TextSpan, TextWidth}; +use cairo_lang_filesystem::span::TextSpan; use cairo_lang_syntax::node::ast::{ ModuleItemList, SyntaxFile, TerminalEndOfFile, TokenEndOfFile, Trivia, }; @@ -9,7 +9,6 @@ use cairo_lang_syntax::node::db::SyntaxGroup; use cairo_lang_syntax::node::{SyntaxNode, Terminal, Token as SyntaxToken, TypedSyntaxNode}; use cairo_lang_utils::Upcast; use indoc::indoc; -use num_traits::ToPrimitive; use pretty_assertions::assert_eq; use smol_str::SmolStr; use test_log::test; @@ -96,11 +95,7 @@ fn test_token_stream_expr_parser() { let token_stream = MockTokenStream { tokens: vec![MockToken { content: expr_code.to_string(), - span: TextSpan { - start: TextOffset::default(), - end: TextOffset::default() - .add_width(TextWidth::new_for_testing(expr_code.len().to_u32().unwrap())), - }, + span: TextSpan::from_str(expr_code), }], content_string: expr_code.to_string(), }; diff --git a/crates/cairo-lang-parser/src/lexer.rs b/crates/cairo-lang-parser/src/lexer.rs index f729e5c4ff8..a90c6367c2f 100644 --- a/crates/cairo-lang-parser/src/lexer.rs +++ b/crates/cairo-lang-parser/src/lexer.rs @@ -27,8 +27,8 @@ impl<'a> Lexer<'a> { Lexer { db, text, - previous_position: TextOffset::default(), - current_position: TextOffset::default(), + previous_position: TextOffset::START, + current_position: TextOffset::START, done: false, } } diff --git a/crates/cairo-lang-plugins/src/test.rs b/crates/cairo-lang-plugins/src/test.rs index d860baf6e0d..92e488aaf5e 100644 --- a/crates/cairo-lang-plugins/src/test.rs +++ b/crates/cairo-lang-plugins/src/test.rs @@ -14,7 +14,7 @@ use cairo_lang_filesystem::db::{ use cairo_lang_filesystem::ids::{ CodeMapping, CodeOrigin, CrateId, Directory, FileLongId, VirtualFile, }; -use cairo_lang_filesystem::span::{TextOffset, TextSpan, TextWidth}; +use cairo_lang_filesystem::span::TextSpan; use cairo_lang_parser::db::ParserDatabase; use cairo_lang_syntax::node::db::{SyntaxDatabase, SyntaxGroup}; use cairo_lang_syntax::node::helpers::QueryAttrs; @@ -160,10 +160,7 @@ impl MacroPlugin for DoubleIndirectionPlugin { let orig_span = node.span(db); let code_mappings = |content: &str| { vec![CodeMapping { - span: TextSpan { - start: TextOffset::default(), - end: TextOffset::default().add_width(TextWidth::from_str(content)), - }, + span: TextSpan::from_str(content), origin: CodeOrigin::Start(orig_span.start), }] }; diff --git a/crates/cairo-lang-semantic/src/inline_macros/consteval_int.rs b/crates/cairo-lang-semantic/src/inline_macros/consteval_int.rs index 447a9bd3323..8a9062a4464 100644 --- a/crates/cairo-lang-semantic/src/inline_macros/consteval_int.rs +++ b/crates/cairo-lang-semantic/src/inline_macros/consteval_int.rs @@ -4,7 +4,7 @@ use cairo_lang_defs::plugin::{ PluginGeneratedFile, }; use cairo_lang_filesystem::ids::{CodeMapping, CodeOrigin}; -use cairo_lang_filesystem::span::{TextOffset, TextSpan, TextWidth}; +use cairo_lang_filesystem::span::TextSpan; use cairo_lang_syntax::node::db::SyntaxGroup; use cairo_lang_syntax::node::{TypedStablePtr, TypedSyntaxNode, ast}; use indoc::indoc; @@ -45,10 +45,7 @@ impl InlineMacroExprPlugin for ConstevalIntMacro { InlinePluginResult { code: code.map(|x| { let content = x.to_string(); - let span = TextSpan { - start: TextOffset::default(), - end: TextOffset::default().add_width(TextWidth::from_str(&content)), - }; + let span = TextSpan::from_str(&content); PluginGeneratedFile { name: "consteval_int_inline_macro".into(), content, diff --git a/crates/cairo-lang-starknet/src/plugin/test.rs b/crates/cairo-lang-starknet/src/plugin/test.rs index d68c79a7f75..a8b9f6d61c3 100644 --- a/crates/cairo-lang-starknet/src/plugin/test.rs +++ b/crates/cairo-lang-starknet/src/plugin/test.rs @@ -7,7 +7,7 @@ use cairo_lang_defs::ids::ModuleId; use cairo_lang_diagnostics::DiagnosticLocation; use cairo_lang_filesystem::db::FilesGroup; use cairo_lang_filesystem::ids::FileLongId; -use cairo_lang_filesystem::span::{TextOffset, TextSpan, TextWidth}; +use cairo_lang_filesystem::span::TextSpan; use cairo_lang_plugins::test_utils::expand_module_text; use cairo_lang_semantic::test_utils::setup_test_module; use cairo_lang_test_utils::parse_test_file::{TestFileRunner, TestRunnerResult}; @@ -49,9 +49,8 @@ impl TestFileRunner for ExpandContractTestRunner { for file_id in files { let content = db.file_content(file_id).unwrap(); - let start = TextOffset::default(); - let end = start.add_width(TextWidth::from_str(&content)); - let content_location = DiagnosticLocation { file_id, span: TextSpan { start, end } }; + let content_location = + DiagnosticLocation { file_id, span: TextSpan::from_str(&content) }; let original_location = content_location.user_location(db.upcast()); let origin = (content_location != original_location) .then(|| format!("{:?}\n", original_location.debug(db.upcast()))) diff --git a/crates/cairo-lang-syntax/src/node/ast_test.rs b/crates/cairo-lang-syntax/src/node/ast_test.rs index 62382776d46..7dc74ab2b41 100644 --- a/crates/cairo-lang-syntax/src/node/ast_test.rs +++ b/crates/cairo-lang-syntax/src/node/ast_test.rs @@ -26,106 +26,86 @@ fn test_ast() { .map(|node| (node.kind(db), node.text(db), node.offset(), node.width(db))) .collect::>(), vec![ - ( - SyntaxKind::ExprBinary, - None, - TextOffset::default().add_width(TextWidth::new_for_testing(0)), - TextWidth::new_for_testing(7) - ), - ( - SyntaxKind::ExprPath, - None, - TextOffset::default().add_width(TextWidth::new_for_testing(0)), - TextWidth::new_for_testing(4) - ), - ( - SyntaxKind::PathSegmentSimple, - None, - TextOffset::default().add_width(TextWidth::new_for_testing(0)), - TextWidth::new_for_testing(4) - ), + (SyntaxKind::ExprBinary, None, TextOffset::START, TextWidth::new_for_testing(7)), + (SyntaxKind::ExprPath, None, TextOffset::START, TextWidth::new_for_testing(4)), + (SyntaxKind::PathSegmentSimple, None, TextOffset::START, TextWidth::new_for_testing(4)), ( SyntaxKind::TerminalIdentifier, None, - TextOffset::default().add_width(TextWidth::new_for_testing(0)), + TextOffset::START, TextWidth::new_for_testing(4) ), - ( - SyntaxKind::Trivia, - None, - TextOffset::default().add_width(TextWidth::new_for_testing(0)), - TextWidth::new_for_testing(0) - ), + (SyntaxKind::Trivia, None, TextOffset::START, TextWidth::new_for_testing(0)), ( SyntaxKind::TokenIdentifier, Some("foo".into()), - TextOffset::default().add_width(TextWidth::new_for_testing(0)), + TextOffset::START, TextWidth::new_for_testing(3) ), ( SyntaxKind::Trivia, None, - TextOffset::default().add_width(TextWidth::new_for_testing(3)), + TextWidth::new_for_testing(3).as_offset(), TextWidth::new_for_testing(1) ), ( SyntaxKind::TokenWhitespace, Some(" ".into()), - TextOffset::default().add_width(TextWidth::new_for_testing(3)), + TextWidth::new_for_testing(3).as_offset(), TextWidth::new_for_testing(1) ), ( SyntaxKind::TerminalPlus, None, - TextOffset::default().add_width(TextWidth::new_for_testing(4)), + TextWidth::new_for_testing(4).as_offset(), TextWidth::new_for_testing(2) ), ( SyntaxKind::Trivia, None, - TextOffset::default().add_width(TextWidth::new_for_testing(4)), + TextWidth::new_for_testing(4).as_offset(), TextWidth::new_for_testing(0) ), ( SyntaxKind::TokenPlus, Some("+".into()), - TextOffset::default().add_width(TextWidth::new_for_testing(4)), + TextWidth::new_for_testing(4).as_offset(), TextWidth::new_for_testing(1) ), ( SyntaxKind::Trivia, None, - TextOffset::default().add_width(TextWidth::new_for_testing(5)), + TextWidth::new_for_testing(5).as_offset(), TextWidth::new_for_testing(1) ), ( SyntaxKind::TokenWhitespace, Some(" ".into()), - TextOffset::default().add_width(TextWidth::new_for_testing(5)), + TextWidth::new_for_testing(5).as_offset(), TextWidth::new_for_testing(1) ), ( SyntaxKind::TerminalLiteralNumber, None, - TextOffset::default().add_width(TextWidth::new_for_testing(6)), + TextWidth::new_for_testing(6).as_offset(), TextWidth::new_for_testing(1) ), ( SyntaxKind::Trivia, None, - TextOffset::default().add_width(TextWidth::new_for_testing(6)), + TextWidth::new_for_testing(6).as_offset(), TextWidth::new_for_testing(0) ), ( SyntaxKind::TokenLiteralNumber, Some("5".into()), - TextOffset::default().add_width(TextWidth::new_for_testing(6)), + TextWidth::new_for_testing(6).as_offset(), TextWidth::new_for_testing(1) ), ( SyntaxKind::Trivia, None, - TextOffset::default().add_width(TextWidth::new_for_testing(7)), + TextWidth::new_for_testing(7).as_offset(), TextWidth::new_for_testing(0) ) ] diff --git a/crates/cairo-lang-syntax/src/node/mod.rs b/crates/cairo-lang-syntax/src/node/mod.rs index 6758ac0e7a5..620aa112614 100644 --- a/crates/cairo-lang-syntax/src/node/mod.rs +++ b/crates/cairo-lang-syntax/src/node/mod.rs @@ -49,7 +49,7 @@ impl SyntaxNode { pub fn new_root(db: &dyn SyntaxGroup, file_id: FileId, green: GreenId) -> Self { let inner = SyntaxNodeInner { green, - offset: TextOffset::default(), + offset: TextOffset::START, parent: None, stable_ptr: SyntaxStablePtr::Root(file_id, green).intern(db), }; @@ -272,11 +272,10 @@ impl SyntaxNode { let orig_span = self.span(db); assert!(orig_span.contains(span)); let full_text = self.get_text(db); - let zero_offset = TextOffset::default(); let span_in_span = TextSpan { - start: zero_offset.add_width(span.start - orig_span.start), - end: zero_offset.add_width(span.end - orig_span.start), + start: (span.start - orig_span.start).as_offset(), + end: (span.end - orig_span.start).as_offset(), }; span_in_span.take(&full_text).to_string() }