use crate::{
CppSyntaxNode,
kind::{CppKind, CppSyntaxKind, CppTokenKind},
syntax::traits::{CppAstChildren, CppAstNode, CppAstToken},
};
use super::{CppDeclaration, CppDeclarator, CppRequiresExpr, CppTypeId};
use crate::syntax::node::token::{CppLiteralToken, CppNameToken, CppOperatorToken};
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum CppExpr {
LiteralExpr(CppLiteralExpr),
NameExpr(CppNameExpr),
ParenExpr(CppParenExpr),
UnaryExpr(CppUnaryExpr),
BinaryExpr(CppBinaryExpr),
TernaryExpr(CppTernaryExpr),
CallExpr(CppCallExpr),
IndexExpr(CppIndexExpr),
MemberExpr(CppMemberExpr),
CastExpr(CppCastExpr),
InitListExpr(CppInitListExpr),
DesignatedInitExpr(CppDesignatedInitExpr),
LambdaExpr(CppLambdaExpr),
ThisExpr(CppThisExpr),
GenericSelectionExpr(CppGenericSelectionExpr),
NewExpr(CppNewExpr),
ThrowExpr(CppThrowExpr),
SizeofExpr(CppSizeofExpr),
TypeidExpr(CppTypeidExpr),
FoldExpr(CppFoldExpr),
PackExpansionExpr(CppPackExpansionExpr),
RequiresExpr(CppRequiresExpr),
ReflectExpr(CppReflectExpr),
SpliceExpr(CppSpliceExpr),
ErrorNode(CppUnknownExpr),
}
impl CppAstNode for CppExpr {
fn syntax(&self) -> &CppSyntaxNode {
match self {
CppExpr::LiteralExpr(node) => node.syntax(),
CppExpr::NameExpr(node) => node.syntax(),
CppExpr::ParenExpr(node) => node.syntax(),
CppExpr::UnaryExpr(node) => node.syntax(),
CppExpr::BinaryExpr(node) => node.syntax(),
CppExpr::TernaryExpr(node) => node.syntax(),
CppExpr::CallExpr(node) => node.syntax(),
CppExpr::IndexExpr(node) => node.syntax(),
CppExpr::MemberExpr(node) => node.syntax(),
CppExpr::CastExpr(node) => node.syntax(),
CppExpr::InitListExpr(node) => node.syntax(),
CppExpr::DesignatedInitExpr(node) => node.syntax(),
CppExpr::LambdaExpr(node) => node.syntax(),
CppExpr::ThisExpr(node) => node.syntax(),
CppExpr::ErrorNode(node) => node.syntax(),
CppExpr::GenericSelectionExpr(node) => node.syntax(),
CppExpr::NewExpr(node) => node.syntax(),
CppExpr::ThrowExpr(node) => node.syntax(),
CppExpr::SizeofExpr(node) => node.syntax(),
CppExpr::TypeidExpr(node) => node.syntax(),
CppExpr::FoldExpr(node) => node.syntax(),
CppExpr::PackExpansionExpr(node) => node.syntax(),
CppExpr::RequiresExpr(node) => node.syntax(),
CppExpr::ReflectExpr(node) => node.syntax(),
CppExpr::SpliceExpr(node) => node.syntax(),
}
}
fn can_cast(kind: CppSyntaxKind) -> bool {
matches!(
kind,
CppSyntaxKind::LiteralExpr
| CppSyntaxKind::IdentifierExpr
| CppSyntaxKind::NameExpr
| CppSyntaxKind::ParenExpr
| CppSyntaxKind::UnaryExpr
| CppSyntaxKind::BinaryExpr
| CppSyntaxKind::TernaryExpr
| CppSyntaxKind::CallExpr
| CppSyntaxKind::IndexExpr
| CppSyntaxKind::MemberExpr
| CppSyntaxKind::ArrowExpr
| CppSyntaxKind::CastExpr
| CppSyntaxKind::InitListExpr
| CppSyntaxKind::DesignatedInitExpr
| CppSyntaxKind::LambdaExpr
| CppSyntaxKind::ClosureExpr
| CppSyntaxKind::ThisExpr
| CppSyntaxKind::GenericSelectionExpr
| CppSyntaxKind::NewExpr
| CppSyntaxKind::ThrowExpr
| CppSyntaxKind::SizeofExpr
| CppSyntaxKind::TypeidExpr
| CppSyntaxKind::FoldExpr
| CppSyntaxKind::PackExpansionExpr
| CppSyntaxKind::RequiresExpr
| CppSyntaxKind::ReflectExpr
| CppSyntaxKind::SpliceExpr
| CppSyntaxKind::ErrorNode
)
}
fn cast(syntax: CppSyntaxNode) -> Option<Self> {
match CppSyntaxKind::from(syntax.kind()) {
CppSyntaxKind::LiteralExpr => CppLiteralExpr::cast(syntax).map(CppExpr::LiteralExpr),
CppSyntaxKind::IdentifierExpr | CppSyntaxKind::NameExpr => {
CppNameExpr::cast(syntax).map(CppExpr::NameExpr)
}
CppSyntaxKind::ParenExpr => CppParenExpr::cast(syntax).map(CppExpr::ParenExpr),
CppSyntaxKind::UnaryExpr => CppUnaryExpr::cast(syntax).map(CppExpr::UnaryExpr),
CppSyntaxKind::BinaryExpr => CppBinaryExpr::cast(syntax).map(CppExpr::BinaryExpr),
CppSyntaxKind::TernaryExpr => CppTernaryExpr::cast(syntax).map(CppExpr::TernaryExpr),
CppSyntaxKind::CallExpr => CppCallExpr::cast(syntax).map(CppExpr::CallExpr),
CppSyntaxKind::IndexExpr => CppIndexExpr::cast(syntax).map(CppExpr::IndexExpr),
CppSyntaxKind::MemberExpr | CppSyntaxKind::ArrowExpr => {
CppMemberExpr::cast(syntax).map(CppExpr::MemberExpr)
}
CppSyntaxKind::CastExpr => CppCastExpr::cast(syntax).map(CppExpr::CastExpr),
CppSyntaxKind::InitListExpr => CppInitListExpr::cast(syntax).map(CppExpr::InitListExpr),
CppSyntaxKind::DesignatedInitExpr => {
CppDesignatedInitExpr::cast(syntax).map(CppExpr::DesignatedInitExpr)
}
CppSyntaxKind::LambdaExpr | CppSyntaxKind::ClosureExpr => {
CppLambdaExpr::cast(syntax).map(CppExpr::LambdaExpr)
}
CppSyntaxKind::ThisExpr => CppThisExpr::cast(syntax).map(CppExpr::ThisExpr),
CppSyntaxKind::GenericSelectionExpr => {
CppGenericSelectionExpr::cast(syntax).map(CppExpr::GenericSelectionExpr)
}
CppSyntaxKind::NewExpr => CppNewExpr::cast(syntax).map(CppExpr::NewExpr),
CppSyntaxKind::ThrowExpr => CppThrowExpr::cast(syntax).map(CppExpr::ThrowExpr),
CppSyntaxKind::SizeofExpr => CppSizeofExpr::cast(syntax).map(CppExpr::SizeofExpr),
CppSyntaxKind::TypeidExpr => CppTypeidExpr::cast(syntax).map(CppExpr::TypeidExpr),
CppSyntaxKind::FoldExpr => CppFoldExpr::cast(syntax).map(CppExpr::FoldExpr),
CppSyntaxKind::PackExpansionExpr => {
CppPackExpansionExpr::cast(syntax).map(CppExpr::PackExpansionExpr)
}
CppSyntaxKind::RequiresExpr => CppRequiresExpr::cast(syntax).map(CppExpr::RequiresExpr),
CppSyntaxKind::ReflectExpr => CppReflectExpr::cast(syntax).map(CppExpr::ReflectExpr),
CppSyntaxKind::SpliceExpr => CppSpliceExpr::cast(syntax).map(CppExpr::SpliceExpr),
CppSyntaxKind::ErrorNode => CppUnknownExpr::cast(syntax).map(CppExpr::ErrorNode),
_ => None,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CppNewExpr {
syntax: CppSyntaxNode,
}
impl CppAstNode for CppNewExpr {
fn syntax(&self) -> &CppSyntaxNode {
&self.syntax
}
fn can_cast(kind: CppSyntaxKind) -> bool {
kind == CppSyntaxKind::NewExpr
}
fn cast(syntax: CppSyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind().into()).then_some(Self { syntax })
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CppThrowExpr {
syntax: CppSyntaxNode,
}
impl CppAstNode for CppThrowExpr {
fn syntax(&self) -> &CppSyntaxNode {
&self.syntax
}
fn can_cast(kind: CppSyntaxKind) -> bool {
kind == CppSyntaxKind::ThrowExpr
}
fn cast(syntax: CppSyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind().into()).then_some(Self { syntax })
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CppSizeofExpr {
syntax: CppSyntaxNode,
}
impl CppAstNode for CppSizeofExpr {
fn syntax(&self) -> &CppSyntaxNode {
&self.syntax
}
fn can_cast(kind: CppSyntaxKind) -> bool {
kind == CppSyntaxKind::SizeofExpr
}
fn cast(syntax: CppSyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind().into()).then_some(Self { syntax })
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CppTypeidExpr {
syntax: CppSyntaxNode,
}
impl CppAstNode for CppTypeidExpr {
fn syntax(&self) -> &CppSyntaxNode {
&self.syntax
}
fn can_cast(kind: CppSyntaxKind) -> bool {
kind == CppSyntaxKind::TypeidExpr
}
fn cast(syntax: CppSyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind().into()).then_some(Self { syntax })
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CppPackExpansionExpr {
syntax: CppSyntaxNode,
}
impl CppAstNode for CppPackExpansionExpr {
fn syntax(&self) -> &CppSyntaxNode {
&self.syntax
}
fn can_cast(kind: CppSyntaxKind) -> bool {
kind == CppSyntaxKind::PackExpansionExpr
}
fn cast(syntax: CppSyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind().into()).then_some(Self { syntax })
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum CppVarExpr {
NameExpr(CppNameExpr),
IndexExpr(CppIndexExpr),
MemberExpr(CppMemberExpr),
}
impl CppAstNode for CppVarExpr {
fn syntax(&self) -> &CppSyntaxNode {
match self {
CppVarExpr::NameExpr(node) => node.syntax(),
CppVarExpr::IndexExpr(node) => node.syntax(),
CppVarExpr::MemberExpr(node) => node.syntax(),
}
}
fn can_cast(kind: CppSyntaxKind) -> bool {
matches!(
kind,
CppSyntaxKind::IdentifierExpr
| CppSyntaxKind::NameExpr
| CppSyntaxKind::IndexExpr
| CppSyntaxKind::MemberExpr
| CppSyntaxKind::ArrowExpr
)
}
fn cast(syntax: CppSyntaxNode) -> Option<Self> {
match CppSyntaxKind::from(syntax.kind()) {
CppSyntaxKind::IdentifierExpr | CppSyntaxKind::NameExpr => {
CppNameExpr::cast(syntax).map(CppVarExpr::NameExpr)
}
CppSyntaxKind::IndexExpr => CppIndexExpr::cast(syntax).map(CppVarExpr::IndexExpr),
CppSyntaxKind::MemberExpr | CppSyntaxKind::ArrowExpr => {
CppMemberExpr::cast(syntax).map(CppVarExpr::MemberExpr)
}
_ => None,
}
}
}
impl From<CppVarExpr> for CppExpr {
fn from(expr: CppVarExpr) -> Self {
match expr {
CppVarExpr::NameExpr(node) => CppExpr::NameExpr(node),
CppVarExpr::IndexExpr(node) => CppExpr::IndexExpr(node),
CppVarExpr::MemberExpr(node) => CppExpr::MemberExpr(node),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CppLiteralExpr {
syntax: CppSyntaxNode,
}
impl CppAstNode for CppLiteralExpr {
fn syntax(&self) -> &CppSyntaxNode {
&self.syntax
}
fn can_cast(kind: CppSyntaxKind) -> bool {
kind == CppSyntaxKind::LiteralExpr
}
fn cast(syntax: CppSyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind().into()).then_some(Self { syntax })
}
}
impl CppLiteralExpr {
pub fn get_literal_token(&self) -> Option<CppLiteralToken> {
self.token()
}
pub fn get_literal_text(&self) -> Option<String> {
self.get_literal_token()
.map(|it| it.get_literal_text().to_string())
}
pub fn is_null_literal(&self) -> bool {
self.syntax()
.children_with_tokens()
.filter_map(|it| it.into_token())
.any(|token| {
matches!(
token.kind(),
CppKind::Token(CppTokenKind::NullptrKeyword)
| CppKind::Token(CppTokenKind::NullptrLiteral)
)
})
}
pub fn is_bool_literal(&self) -> bool {
self.syntax()
.children_with_tokens()
.filter_map(|it| it.into_token())
.any(|token| {
matches!(
token.kind(),
CppKind::Token(CppTokenKind::TrueKeyword)
| CppKind::Token(CppTokenKind::FalseKeyword)
| CppKind::Token(CppTokenKind::BoolLiteral)
)
})
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CppNameExpr {
syntax: CppSyntaxNode,
}
impl CppAstNode for CppNameExpr {
fn syntax(&self) -> &CppSyntaxNode {
&self.syntax
}
fn can_cast(kind: CppSyntaxKind) -> bool {
matches!(
kind,
CppSyntaxKind::IdentifierExpr | CppSyntaxKind::NameExpr
)
}
fn cast(syntax: CppSyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind().into()).then_some(Self { syntax })
}
}
impl CppNameExpr {
pub fn get_name_token(&self) -> Option<CppNameToken> {
self.token()
}
pub fn get_last_name_token(&self) -> Option<CppNameToken> {
self.syntax()
.children_with_tokens()
.filter_map(|it| it.into_token())
.filter_map(CppNameToken::cast)
.last()
}
pub fn get_name_text(&self) -> Option<String> {
self.get_name_token()
.map(|it| it.get_name_text().to_string())
}
pub fn get_qualified_name(&self) -> String {
self.syntax()
.text()
.to_string()
.chars()
.filter(|it| !it.is_whitespace())
.collect()
}
pub fn get_identifier_token(&self, spelling: &str) -> Option<CppNameToken> {
self.syntax()
.descendants_with_tokens()
.filter_map(|element| element.into_token())
.filter_map(CppNameToken::cast)
.filter(|token| token.get_name_text() == spelling)
.last()
}
pub fn is_qualified(&self) -> bool {
self.syntax()
.children_with_tokens()
.filter_map(|it| it.into_token())
.any(|token| token.kind() == CppKind::Token(CppTokenKind::Scope))
}
pub fn get_template_arg_lists(&self) -> CppAstChildren<super::CppTemplateArgList> {
self.children()
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CppParenExpr {
syntax: CppSyntaxNode,
}
impl CppAstNode for CppParenExpr {
fn syntax(&self) -> &CppSyntaxNode {
&self.syntax
}
fn can_cast(kind: CppSyntaxKind) -> bool {
kind == CppSyntaxKind::ParenExpr
}
fn cast(syntax: CppSyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind().into()).then_some(Self { syntax })
}
}
impl CppParenExpr {
pub fn get_expr(&self) -> Option<CppExpr> {
self.child()
}
pub fn get_declaration(&self) -> Option<CppDeclaration> {
self.child()
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CppCastExpr {
syntax: CppSyntaxNode,
}
impl CppAstNode for CppCastExpr {
fn syntax(&self) -> &CppSyntaxNode {
&self.syntax
}
fn can_cast(kind: CppSyntaxKind) -> bool {
kind == CppSyntaxKind::CastExpr
}
fn cast(syntax: CppSyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind().into()).then_some(Self { syntax })
}
}
impl CppCastExpr {
pub fn get_operand(&self) -> Option<CppExpr> {
self.children::<CppExpr>().next()
}
pub fn get_type_id(&self) -> Option<CppTypeId> {
self.child()
}
pub fn is_a_c_style_cast(&self) -> bool {
self.syntax()
.children_with_tokens()
.filter_map(|element| element.into_token())
.find(|token| !crate::syntax::is_trivia(crate::CppTokenKind::from(token.kind())))
.is_some_and(|token| {
crate::CppTokenKind::from(token.kind()) == crate::CppTokenKind::LeftParen
})
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CppUnaryExpr {
syntax: CppSyntaxNode,
}
impl CppAstNode for CppUnaryExpr {
fn syntax(&self) -> &CppSyntaxNode {
&self.syntax
}
fn can_cast(kind: CppSyntaxKind) -> bool {
kind == CppSyntaxKind::UnaryExpr
}
fn cast(syntax: CppSyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind().into()).then_some(Self { syntax })
}
}
impl CppUnaryExpr {
pub fn get_operator_token(&self) -> Option<CppOperatorToken> {
self.token()
}
pub fn get_operator_text(&self) -> Option<String> {
self.get_operator_token()
.map(|it| it.get_operator_text().to_string())
}
pub fn get_operand(&self) -> Option<CppExpr> {
self.child()
}
pub fn is_delete(&self) -> bool {
self.token_by_kind(CppTokenKind::DeleteKeyword).is_some()
}
pub fn is_prefix(&self) -> bool {
let Some(operator) = self
.syntax()
.children_with_tokens()
.filter_map(|it| it.into_token())
.find(|token| !crate::syntax::node::traits::is_trivia(token.kind().into()))
else {
return true;
};
let Some(operand) = self.get_operand() else {
return true;
};
operator.text_range().start() < operand.syntax().text_range().start()
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CppBinaryExpr {
syntax: CppSyntaxNode,
}
impl CppAstNode for CppBinaryExpr {
fn syntax(&self) -> &CppSyntaxNode {
&self.syntax
}
fn can_cast(kind: CppSyntaxKind) -> bool {
kind == CppSyntaxKind::BinaryExpr
}
fn cast(syntax: CppSyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind().into()).then_some(Self { syntax })
}
}
impl CppBinaryExpr {
pub fn get_lhs(&self) -> Option<CppExpr> {
self.children().next()
}
pub fn get_rhs(&self) -> Option<CppExpr> {
self.children().nth(1)
}
pub fn get_operator_token(&self) -> Option<CppOperatorToken> {
self.token()
}
pub fn get_operator_text(&self) -> Option<String> {
self.get_operator_token()
.map(|it| it.get_operator_text().to_string())
}
pub fn get_fold(&self) -> Option<CppFoldExpr> {
self.children::<CppFoldExpr>().next()
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CppFoldExpr {
syntax: CppSyntaxNode,
}
impl CppAstNode for CppFoldExpr {
fn syntax(&self) -> &CppSyntaxNode {
&self.syntax
}
fn can_cast(kind: CppSyntaxKind) -> bool {
kind == CppSyntaxKind::FoldExpr
}
fn cast(syntax: CppSyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind().into()).then_some(Self { syntax })
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CppTernaryExpr {
syntax: CppSyntaxNode,
}
impl CppAstNode for CppTernaryExpr {
fn syntax(&self) -> &CppSyntaxNode {
&self.syntax
}
fn can_cast(kind: CppSyntaxKind) -> bool {
kind == CppSyntaxKind::TernaryExpr
}
fn cast(syntax: CppSyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind().into()).then_some(Self { syntax })
}
}
impl CppTernaryExpr {
pub fn get_condition(&self) -> Option<CppExpr> {
self.children().next()
}
pub fn get_then_expr(&self) -> Option<CppExpr> {
self.children().nth(1)
}
pub fn get_else_expr(&self) -> Option<CppExpr> {
self.children().nth(2)
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CppCallExpr {
syntax: CppSyntaxNode,
}
impl CppAstNode for CppCallExpr {
fn syntax(&self) -> &CppSyntaxNode {
&self.syntax
}
fn can_cast(kind: CppSyntaxKind) -> bool {
kind == CppSyntaxKind::CallExpr
}
fn cast(syntax: CppSyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind().into()).then_some(Self { syntax })
}
}
impl CppCallExpr {
pub fn get_callee(&self) -> Option<CppExpr> {
self.children().next()
}
pub fn get_arg_list(&self) -> Option<CppArgList> {
self.child()
}
pub fn get_args(&self) -> Vec<CppExpr> {
if let Some(list) = self.get_arg_list() {
return list.get_args().collect();
}
self.children::<CppExpr>().skip(1).collect()
}
pub fn has_a_pack_expansion(&self) -> bool {
self.syntax()
.descendants()
.any(|node| CppSyntaxKind::from(node.kind()) == CppSyntaxKind::PackExpansionExpr)
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CppArgList {
syntax: CppSyntaxNode,
}
impl CppAstNode for CppArgList {
fn syntax(&self) -> &CppSyntaxNode {
&self.syntax
}
fn can_cast(kind: CppSyntaxKind) -> bool {
matches!(
kind,
CppSyntaxKind::ArgumentList | CppSyntaxKind::CallArgList
)
}
fn cast(syntax: CppSyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind().into()).then_some(Self { syntax })
}
}
impl CppArgList {
pub fn get_args(&self) -> CppAstChildren<CppExpr> {
self.children()
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CppIndexExpr {
syntax: CppSyntaxNode,
}
impl CppAstNode for CppIndexExpr {
fn syntax(&self) -> &CppSyntaxNode {
&self.syntax
}
fn can_cast(kind: CppSyntaxKind) -> bool {
kind == CppSyntaxKind::IndexExpr
}
fn cast(syntax: CppSyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind().into()).then_some(Self { syntax })
}
}
impl CppIndexExpr {
pub fn get_object(&self) -> Option<CppExpr> {
self.children().next()
}
pub fn get_index(&self) -> Option<CppExpr> {
self.children().nth(1)
}
pub fn is_a_member_access(&self) -> bool {
self.syntax()
.children_with_tokens()
.filter_map(|element| element.into_token())
.any(|token| {
matches!(
CppTokenKind::from(token.kind()),
CppTokenKind::Dot | CppTokenKind::Arrow
)
})
}
pub fn is_a_subscript(&self) -> bool {
self.syntax()
.children_with_tokens()
.filter_map(|element| element.into_token())
.any(|token| CppTokenKind::from(token.kind()) == CppTokenKind::LeftBracket)
}
pub fn get_member_name(&self) -> Option<CppNameToken> {
if !self.is_a_member_access() {
return None;
}
let mut after_the_operator = false;
let mut found = None;
for element in self.syntax().children_with_tokens() {
let Some(token) = element.into_token() else {
continue;
};
match CppTokenKind::from(token.kind()) {
CppTokenKind::Dot | CppTokenKind::Arrow => after_the_operator = true,
_ if after_the_operator => {
if let Some(name) = CppNameToken::cast(token) {
found = Some(name);
}
}
_ => {}
}
}
found
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CppMemberExpr {
syntax: CppSyntaxNode,
}
impl CppAstNode for CppMemberExpr {
fn syntax(&self) -> &CppSyntaxNode {
&self.syntax
}
fn can_cast(kind: CppSyntaxKind) -> bool {
matches!(kind, CppSyntaxKind::MemberExpr | CppSyntaxKind::ArrowExpr)
}
fn cast(syntax: CppSyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind().into()).then_some(Self { syntax })
}
}
impl CppMemberExpr {
pub fn get_object(&self) -> Option<CppExpr> {
self.children().next()
}
pub fn get_member_name(&self) -> Option<CppNameToken> {
self.token()
}
pub fn is_arrow(&self) -> bool {
self.syntax()
.children_with_tokens()
.filter_map(|it| it.into_token())
.any(|token| token.kind() == CppKind::Token(CppTokenKind::Arrow))
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CppInitListExpr {
syntax: CppSyntaxNode,
}
impl CppAstNode for CppInitListExpr {
fn syntax(&self) -> &CppSyntaxNode {
&self.syntax
}
fn can_cast(kind: CppSyntaxKind) -> bool {
matches!(
kind,
CppSyntaxKind::InitListExpr
| CppSyntaxKind::TableArrayExpr
| CppSyntaxKind::TableEmptyExpr
)
}
fn cast(syntax: CppSyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind().into()).then_some(Self { syntax })
}
}
impl CppInitListExpr {
pub fn get_elements(&self) -> CppAstChildren<CppExpr> {
self.children()
}
pub fn get_designators(&self) -> CppAstChildren<CppDesignatedInitExpr> {
self.children()
}
pub fn get_constructed_type(&self) -> Option<CppNameExpr> {
self.children::<CppNameExpr>().next()
}
pub fn is_empty(&self) -> bool {
self.get_elements().next().is_none()
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CppDesignatedInitExpr {
syntax: CppSyntaxNode,
}
impl CppAstNode for CppDesignatedInitExpr {
fn syntax(&self) -> &CppSyntaxNode {
&self.syntax
}
fn can_cast(kind: CppSyntaxKind) -> bool {
kind == CppSyntaxKind::DesignatedInitExpr
}
fn cast(syntax: CppSyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind().into()).then_some(Self { syntax })
}
}
impl CppDesignatedInitExpr {
pub fn get_designator(&self) -> Option<CppNameToken> {
self.token()
}
pub fn get_value(&self) -> Option<CppExpr> {
self.child()
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CppLambdaExpr {
syntax: CppSyntaxNode,
}
impl CppAstNode for CppLambdaExpr {
fn syntax(&self) -> &CppSyntaxNode {
&self.syntax
}
fn can_cast(kind: CppSyntaxKind) -> bool {
matches!(kind, CppSyntaxKind::LambdaExpr | CppSyntaxKind::ClosureExpr)
}
fn cast(syntax: CppSyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind().into()).then_some(Self { syntax })
}
}
impl CppLambdaExpr {
pub fn get_param_list(&self) -> Option<super::CppParamList> {
self.child()
}
pub fn get_body(&self) -> Option<super::CppCompoundStat> {
self.child()
}
pub fn get_trailing_return_type(&self) -> Option<super::CppTypeId> {
crate::syntax::node::traits::first_child_of_kind(
self.syntax(),
&[CppSyntaxKind::TrailingReturnType],
)
.and_then(CppTypeId::cast)
}
pub fn get_captures(&self) -> Option<CppLambdaCaptureList> {
self.child()
}
pub fn get_params(&self) -> Option<super::CppParamList> {
self.get_param_list()
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CppLambdaCaptureList {
syntax: CppSyntaxNode,
}
impl CppAstNode for CppLambdaCaptureList {
fn syntax(&self) -> &CppSyntaxNode {
&self.syntax
}
fn can_cast(kind: CppSyntaxKind) -> bool {
kind == CppSyntaxKind::LambdaCaptureList
}
fn cast(syntax: CppSyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind().into()).then_some(Self { syntax })
}
}
impl CppLambdaCaptureList {
pub fn get_captures(&self) -> CppAstChildren<CppLambdaCapture> {
self.children()
}
pub fn is_empty(&self) -> bool {
self.get_captures().next().is_none()
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CppLambdaCapture {
syntax: CppSyntaxNode,
}
impl CppAstNode for CppLambdaCapture {
fn syntax(&self) -> &CppSyntaxNode {
&self.syntax
}
fn can_cast(kind: CppSyntaxKind) -> bool {
kind == CppSyntaxKind::LambdaCapture
}
fn cast(syntax: CppSyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind().into()).then_some(Self { syntax })
}
}
impl CppLambdaCapture {
pub fn get_name(&self) -> Option<CppNameToken> {
self.token()
}
pub fn get_name_text(&self) -> Option<String> {
self.get_name().map(|name| name.get_name_text().to_string())
}
pub fn get_initializer(&self) -> Option<CppExpr> {
self.child()
}
pub fn is_by_reference(&self) -> bool {
self.token_by_kind(CppTokenKind::Ampersand).is_some()
}
pub fn is_this(&self) -> bool {
self.token_by_kind(CppTokenKind::ThisKeyword).is_some()
}
pub fn captures_everything(&self) -> bool {
self.get_name().is_none() && !self.is_this()
}
pub fn is_pack_expansion(&self) -> bool {
self.token_by_kind(CppTokenKind::Ellipsis).is_some()
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CppThisExpr {
syntax: CppSyntaxNode,
}
impl CppAstNode for CppThisExpr {
fn syntax(&self) -> &CppSyntaxNode {
&self.syntax
}
fn can_cast(kind: CppSyntaxKind) -> bool {
kind == CppSyntaxKind::ThisExpr || kind == CppSyntaxKind::IdentifierExpr
}
fn cast(syntax: CppSyntaxNode) -> Option<Self> {
let is_this = syntax
.children_with_tokens()
.filter_map(|it| it.into_token())
.any(|token| token.kind() == CppKind::Token(CppTokenKind::ThisKeyword));
(Self::can_cast(syntax.kind().into()) && is_this).then_some(Self { syntax })
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CppGenericSelectionExpr {
syntax: CppSyntaxNode,
}
impl CppAstNode for CppGenericSelectionExpr {
fn syntax(&self) -> &CppSyntaxNode {
&self.syntax
}
fn can_cast(kind: CppSyntaxKind) -> bool {
kind == CppSyntaxKind::GenericSelectionExpr
}
fn cast(syntax: CppSyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind().into()).then_some(Self { syntax })
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CppUnknownExpr {
syntax: CppSyntaxNode,
}
impl CppAstNode for CppUnknownExpr {
fn syntax(&self) -> &CppSyntaxNode {
&self.syntax
}
fn can_cast(kind: CppSyntaxKind) -> bool {
kind == CppSyntaxKind::ErrorNode
}
fn cast(syntax: CppSyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind().into()).then_some(Self { syntax })
}
}
pub type CppExprDeclarator = CppDeclarator;
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CppReflectExpr {
syntax: CppSyntaxNode,
}
impl CppAstNode for CppReflectExpr {
fn syntax(&self) -> &CppSyntaxNode {
&self.syntax
}
fn can_cast(kind: CppSyntaxKind) -> bool {
kind == CppSyntaxKind::ReflectExpr
}
fn cast(syntax: CppSyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind().into()).then_some(Self { syntax })
}
}
impl CppReflectExpr {
pub fn get_operand(&self) -> Option<CppSyntaxNode> {
self.syntax.children().next()
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CppSpliceExpr {
syntax: CppSyntaxNode,
}
impl CppAstNode for CppSpliceExpr {
fn syntax(&self) -> &CppSyntaxNode {
&self.syntax
}
fn can_cast(kind: CppSyntaxKind) -> bool {
kind == CppSyntaxKind::SpliceExpr
}
fn cast(syntax: CppSyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind().into()).then_some(Self { syntax })
}
}
impl CppSpliceExpr {
pub fn get_operand(&self) -> Option<CppSyntaxNode> {
self.syntax.children().next()
}
}