cairo_lang_syntax/node/

helpers.rs

use std::ops::ControlFlow;

use cairo_lang_filesystem::ids::{FileLongId, SmolStrId, Tracked};
use cairo_lang_utils::ordered_hash_map::OrderedHashMap;
use cairo_lang_utils::require;
use cairo_lang_utils::unordered_hash_map::UnorderedHashMap;
use itertools::{Itertools, chain};
use salsa::Database;

use super::ast::{
    self, FunctionDeclaration, FunctionDeclarationGreen, FunctionWithBody, FunctionWithBodyPtr,
    ImplItem, ItemConstant, ItemEnum, ItemExternFunction, ItemExternFunctionPtr, ItemExternType,
    ItemImpl, ItemImplAlias, ItemInlineMacro, ItemMacroDeclaration, ItemModule, ItemStruct,
    ItemTrait, ItemTypeAlias, ItemUse, Member, Modifier, ModuleItem, OptionArgListParenthesized,
    Statement, StatementBreak, StatementContinue, StatementExpr, StatementLet, StatementReturn,
    TerminalIdentifier, TerminalIdentifierGreen, TokenIdentifierGreen, TraitItem,
    TraitItemConstant, TraitItemFunction, TraitItemFunctionPtr, TraitItemImpl, TraitItemType,
    UsePathLeaf, Variant, WrappedArgList,
};
use super::ids::SyntaxStablePtrId;
use super::kind::SyntaxKind;
use super::{SyntaxNode, Terminal, TypedStablePtr, TypedSyntaxNode};
use crate::node::ast::{Attribute, AttributeList};
use crate::node::green::GreenNodeDetails;

#[cfg(test)]
#[path = "helpers_test.rs"]
mod test;

pub trait GetIdentifier<'a> {
    fn identifier(&self, db: &'a dyn Database) -> SmolStrId<'a>;
}
impl<'a> ast::UsePathLeafPtr<'a> {
    pub fn name_green(&self, _syntax_db: &dyn Database) -> Self {
        *self
    }
}
impl<'a> GetIdentifier<'a> for ast::UsePathLeafPtr<'a> {
    fn identifier(&self, db: &'a dyn Database) -> SmolStrId<'a> {
        let alias_clause_green = self.alias_clause_green(db).0;
        let green_node = alias_clause_green.long(db);
        let children = match &green_node.details {
            GreenNodeDetails::Node { children, width: _ } => children,
            _ => panic!("Unexpected token"),
        };
        if !children.is_empty() {
            return ast::TerminalIdentifierGreen(children[ast::AliasClause::INDEX_ALIAS])
                .identifier(db);
        }
        let ident_green = self.ident_green(db);
        let ident = ident_green.identifier(db);
        if ident.long(db) != "self" {
            return ident;
        }
        let mut node = self.0.lookup(db);
        loop {
            node = if let Some(parent) = node.parent(db) {
                parent
            } else {
                return ident;
            };
            if matches!(node.kind(db), SyntaxKind::UsePathSingle) {
                return ast::UsePathSingle::from_syntax_node(db, node).ident(db).identifier(db);
            }
        }
    }
}
impl<'a> GetIdentifier<'a> for ast::PathSegmentGreen<'a> {
    /// Retrieves the text of the last identifier in the path.
    fn identifier(&self, db: &'a dyn Database) -> SmolStrId<'a> {
        let green_node = self.0.long(db);
        let children = match &green_node.details {
            GreenNodeDetails::Node { children, width: _ } => children,
            _ => panic!("Unexpected token"),
        };
        let identifier = ast::TerminalIdentifierGreen(children[0]);
        identifier.identifier(db)
    }
}
impl<'a> GetIdentifier<'a> for ast::ExprPathGreen<'a> {
    /// Retrieves the text of the last identifier in the path.
    fn identifier(&self, db: &'a dyn Database) -> SmolStrId<'a> {
        let green_node = self.0.long(db);
        let children = match &green_node.details {
            GreenNodeDetails::Node { children, width: _ } => children,
            _ => panic!("Unexpected token"),
        };
        let segment_green = ast::ExprPathInnerGreen(*children.last().unwrap());
        segment_green.identifier(db)
    }
}

impl<'a> GetIdentifier<'a> for ast::ExprPathInnerGreen<'a> {
    /// Retrieves the text of the last identifier in the path.
    fn identifier(&self, db: &'a dyn Database) -> SmolStrId<'a> {
        let green_node = self.0.long(db);
        let children = match &green_node.details {
            GreenNodeDetails::Node { children, width: _ } => children,
            _ => panic!("Unexpected token"),
        };
        assert_eq!(children.len() & 1, 1, "Expected an odd number of elements in the path.");
        let segment_green = ast::PathSegmentGreen(*children.last().unwrap());
        segment_green.identifier(db)
    }
}
impl<'a> GetIdentifier<'a> for ast::TerminalIdentifierGreen<'a> {
    fn identifier(&self, db: &'a dyn Database) -> SmolStrId<'a> {
        match &self.0.long(db).details {
            GreenNodeDetails::Token(_) => panic!("Unexpected token"),
            GreenNodeDetails::Node { children, width: _ } => {
                TokenIdentifierGreen(children[1]).text(db)
            }
        }
    }
}
impl<'a> GetIdentifier<'a> for ast::ExprPath<'a> {
    /// Retrieves the identifier of the last segment of the path.
    fn identifier(&self, db: &'a dyn Database) -> SmolStrId<'a> {
        self.segments(db).elements(db).next_back().unwrap().identifier(db)
    }
}

/// Helper trait for ast::PathSegment.
pub trait PathSegmentEx<'a> {
    fn identifier_ast(&self, db: &'a dyn Database) -> ast::TerminalIdentifier<'a>;
    fn generic_args(&self, db: &'a dyn Database) -> Option<Vec<ast::GenericArg<'a>>>;
}
impl<'a> PathSegmentEx<'a> for ast::PathSegment<'a> {
    /// Retrieves the identifier ast of a path segment.
    fn identifier_ast(&self, db: &'a dyn Database) -> ast::TerminalIdentifier<'a> {
        match self {
            ast::PathSegment::Simple(segment) => segment.ident(db),
            ast::PathSegment::WithGenericArgs(segment) => segment.ident(db),
        }
    }
    fn generic_args(&self, db: &'a dyn Database) -> Option<Vec<ast::GenericArg<'a>>> {
        match self {
            ast::PathSegment::Simple(_) => None,
            ast::PathSegment::WithGenericArgs(segment) => {
                Some(segment.generic_args(db).generic_args(db).elements_vec(db))
            }
        }
    }
}
impl<'a> GetIdentifier<'a> for ast::PathSegment<'a> {
    /// Retrieves the text of the segment (without the generic args).
    fn identifier(&self, db: &'a dyn Database) -> SmolStrId<'a> {
        match self {
            ast::PathSegment::Simple(segment) => segment.identifier(db),
            ast::PathSegment::WithGenericArgs(segment) => segment.identifier(db),
        }
    }
}
impl<'a> GetIdentifier<'a> for ast::PathSegmentSimple<'a> {
    fn identifier(&self, db: &'a dyn Database) -> SmolStrId<'a> {
        let green_node = self.as_syntax_node().green_node(db);
        let GreenNodeDetails::Node { children, .. } = &green_node.details else {
            panic!("Unexpected token");
        };
        TerminalIdentifierGreen(children[0]).identifier(db)
    }
}
impl<'a> GetIdentifier<'a> for ast::PathSegmentWithGenericArgs<'a> {
    fn identifier(&self, db: &'a dyn Database) -> SmolStrId<'a> {
        let green_node = self.as_syntax_node().green_node(db);
        let GreenNodeDetails::Node { children, .. } = &green_node.details else {
            panic!("Unexpected token");
        };
        TerminalIdentifierGreen(children[0]).identifier(db)
    }
}

impl<'a> GetIdentifier<'a> for ast::Modifier<'a> {
    fn identifier(&self, db: &'a dyn Database) -> SmolStrId<'a> {
        match self {
            Modifier::Ref(r) => r.text(db),
            Modifier::Mut(m) => m.text(db),
        }
    }
}

/// Trait for ast object with a name terminal.
pub trait NameGreen<'a> {
    /// Returns the TerminalIdentifierGreen of the `name` node.
    fn name_green(self, db: &'a dyn Database) -> TerminalIdentifierGreen<'a>;
}

impl<'a> NameGreen<'a> for FunctionDeclarationGreen<'a> {
    fn name_green(self, db: &'a dyn Database) -> TerminalIdentifierGreen<'a> {
        TerminalIdentifierGreen(self.0.long(db).children()[FunctionDeclaration::INDEX_NAME])
    }
}

impl<'a> NameGreen<'a> for FunctionWithBodyPtr<'a> {
    fn name_green(self, db: &'a dyn Database) -> TerminalIdentifierGreen<'a> {
        self.declaration_green(db).name_green(db)
    }
}

impl<'a> NameGreen<'a> for ItemExternFunctionPtr<'a> {
    fn name_green(self, db: &'a dyn Database) -> TerminalIdentifierGreen<'a> {
        self.declaration_green(db).name_green(db)
    }
}

impl<'a> NameGreen<'a> for TraitItemFunctionPtr<'a> {
    fn name_green(self, db: &'a dyn Database) -> TerminalIdentifierGreen<'a> {
        self.declaration_green(db).name_green(db)
    }
}

/// Provides methods to extract a _name_ of AST objects.
pub trait HasName<'a> {
    /// Gets a [`TerminalIdentifier`] that represents a _name_ of this AST object.
    fn name(&self, db: &'a dyn Database) -> ast::TerminalIdentifier<'a>;
}

impl<'a> HasName<'a> for FunctionWithBody<'a> {
    fn name(&self, db: &'a dyn Database) -> TerminalIdentifier<'a> {
        self.declaration(db).name(db)
    }
}

impl<'a> HasName<'a> for ItemExternFunction<'a> {
    fn name(&self, db: &'a dyn Database) -> TerminalIdentifier<'a> {
        self.declaration(db).name(db)
    }
}

impl<'a> HasName<'a> for TraitItemFunction<'a> {
    fn name(&self, db: &'a dyn Database) -> TerminalIdentifier<'a> {
        self.declaration(db).name(db)
    }
}

impl<'a> HasName<'a> for UsePathLeaf<'a> {
    fn name(&self, db: &'a dyn Database) -> TerminalIdentifier<'a> {
        match self.alias_clause(db) {
            ast::OptionAliasClause::Empty(_) => self.ident(db).identifier_ast(db),
            ast::OptionAliasClause::AliasClause(alias) => alias.alias(db),
        }
    }
}

pub trait GenericParamEx<'a> {
    /// Returns the name of a generic param if one exists.
    fn name(&self, db: &'a dyn Database) -> Option<ast::TerminalIdentifier<'a>>;
}
impl<'a> GenericParamEx<'a> for ast::GenericParam<'a> {
    fn name(&self, db: &'a dyn Database) -> Option<ast::TerminalIdentifier<'a>> {
        match self {
            ast::GenericParam::Type(t) => Some(t.name(db)),
            ast::GenericParam::Const(c) => Some(c.name(db)),
            ast::GenericParam::ImplNamed(i) => Some(i.name(db)),
            ast::GenericParam::ImplAnonymous(_) => None,
            ast::GenericParam::NegativeImpl(_) => None,
        }
    }
}

/// Checks if the given attribute has a single argument with the given name.
pub fn is_single_arg_attr(db: &dyn Database, attr: &Attribute<'_>, arg_name: &str) -> bool {
    match attr.arguments(db) {
        OptionArgListParenthesized::ArgListParenthesized(args) => {
            matches!(args.arguments(db).elements(db).exactly_one(),
                    Ok(arg) if arg.as_syntax_node().get_text_without_trivia(db).long(db) == arg_name)
        }
        OptionArgListParenthesized::Empty(_) => false,
    }
}

/// Trait for querying attributes of AST items.
pub trait QueryAttrs<'a> {
    /// Generic call `self.attributes(db).elements(db)`, wrapped with `Option` for cases where the
    /// type does not support attributes.
    ///
    /// Implementation detail, should not be used by this trait's users.
    #[doc(hidden)]
    fn try_attributes(&self, db: &'a dyn Database) -> Option<AttributeList<'a>>;

    /// Generic call to `self.attributes(db).elements(db)`.
    fn attributes_elements(&self, db: &'a dyn Database) -> impl Iterator<Item = Attribute<'a>> {
        self.try_attributes(db).into_iter().flat_map(move |attrs| attrs.elements(db))
    }

    /// Collect all attributes named exactly `attr` attached to this node.
    fn query_attr(
        &self,
        db: &'a dyn Database,
        attr: &'a str,
    ) -> impl Iterator<Item = Attribute<'a>> {
        self.attributes_elements(db).filter(move |a| {
            a.attr(db).as_syntax_node().get_text_without_trivia(db).long(db) == attr
        })
    }

    /// Find first attribute named exactly `attr` attached to this node.
    fn find_attr(&self, db: &'a dyn Database, attr: &'a str) -> Option<Attribute<'a>> {
        self.query_attr(db, attr).next()
    }

    /// Checks if this node has an attribute named exactly `attr`.
    fn has_attr(&self, db: &'a dyn Database, attr: &'a str) -> bool {
        self.find_attr(db, attr).is_some()
    }

    /// Checks if the given object has an attribute with the given name and argument.
    fn has_attr_with_arg(&self, db: &'a dyn Database, attr_name: &'a str, arg_name: &str) -> bool {
        self.query_attr(db, attr_name).any(|attr| is_single_arg_attr(db, &attr, arg_name))
    }
}

impl<'a> QueryAttrs<'a> for ItemConstant<'a> {
    fn try_attributes(&self, db: &'a dyn Database) -> Option<AttributeList<'a>> {
        Some(self.attributes(db))
    }
}
impl<'a> QueryAttrs<'a> for ItemModule<'a> {
    fn try_attributes(&self, db: &'a dyn Database) -> Option<AttributeList<'a>> {
        Some(self.attributes(db))
    }
}
impl<'a> QueryAttrs<'a> for FunctionWithBody<'a> {
    fn try_attributes(&self, db: &'a dyn Database) -> Option<AttributeList<'a>> {
        Some(self.attributes(db))
    }
}
impl<'a> QueryAttrs<'a> for ItemUse<'a> {
    fn try_attributes(&self, db: &'a dyn Database) -> Option<AttributeList<'a>> {
        Some(self.attributes(db))
    }
}
impl<'a> QueryAttrs<'a> for ItemExternFunction<'a> {
    fn try_attributes(&self, db: &'a dyn Database) -> Option<AttributeList<'a>> {
        Some(self.attributes(db))
    }
}
impl<'a> QueryAttrs<'a> for ItemExternType<'a> {
    fn try_attributes(&self, db: &'a dyn Database) -> Option<AttributeList<'a>> {
        Some(self.attributes(db))
    }
}
impl<'a> QueryAttrs<'a> for ItemTrait<'a> {
    fn try_attributes(&self, db: &'a dyn Database) -> Option<AttributeList<'a>> {
        Some(self.attributes(db))
    }
}
impl<'a> QueryAttrs<'a> for ItemImpl<'a> {
    fn try_attributes(&self, db: &'a dyn Database) -> Option<AttributeList<'a>> {
        Some(self.attributes(db))
    }
}
impl<'a> QueryAttrs<'a> for ItemImplAlias<'a> {
    fn try_attributes(&self, db: &'a dyn Database) -> Option<AttributeList<'a>> {
        Some(self.attributes(db))
    }
}
impl<'a> QueryAttrs<'a> for ItemStruct<'a> {
    fn try_attributes(&self, db: &'a dyn Database) -> Option<AttributeList<'a>> {
        Some(self.attributes(db))
    }
}
impl<'a> QueryAttrs<'a> for ItemEnum<'a> {
    fn try_attributes(&self, db: &'a dyn Database) -> Option<AttributeList<'a>> {
        Some(self.attributes(db))
    }
}
impl<'a> QueryAttrs<'a> for ItemTypeAlias<'a> {
    fn try_attributes(&self, db: &'a dyn Database) -> Option<AttributeList<'a>> {
        Some(self.attributes(db))
    }
}
impl<'a> QueryAttrs<'a> for ItemMacroDeclaration<'a> {
    fn try_attributes(&self, db: &'a dyn Database) -> Option<AttributeList<'a>> {
        Some(self.attributes(db))
    }
}
impl<'a> QueryAttrs<'a> for TraitItemFunction<'a> {
    fn try_attributes(&self, db: &'a dyn Database) -> Option<AttributeList<'a>> {
        Some(self.attributes(db))
    }
}
impl<'a> QueryAttrs<'a> for TraitItemType<'a> {
    fn try_attributes(&self, db: &'a dyn Database) -> Option<AttributeList<'a>> {
        Some(self.attributes(db))
    }
}
impl<'a> QueryAttrs<'a> for TraitItemConstant<'a> {
    fn try_attributes(&self, db: &'a dyn Database) -> Option<AttributeList<'a>> {
        Some(self.attributes(db))
    }
}
impl<'a> QueryAttrs<'a> for TraitItemImpl<'a> {
    fn try_attributes(&self, db: &'a dyn Database) -> Option<AttributeList<'a>> {
        Some(self.attributes(db))
    }
}
impl<'a> QueryAttrs<'a> for TraitItem<'a> {
    fn try_attributes(&self, db: &'a dyn Database) -> Option<AttributeList<'a>> {
        match self {
            TraitItem::Function(item) => Some(item.attributes(db)),
            TraitItem::Type(item) => Some(item.attributes(db)),
            TraitItem::Constant(item) => Some(item.attributes(db)),
            TraitItem::Impl(item) => Some(item.attributes(db)),
            TraitItem::Missing(_) => None,
        }
    }
}

impl<'a> QueryAttrs<'a> for ItemInlineMacro<'a> {
    fn try_attributes(&self, db: &'a dyn Database) -> Option<AttributeList<'a>> {
        Some(self.attributes(db))
    }
}

impl<'a> QueryAttrs<'a> for ModuleItem<'a> {
    fn try_attributes(&self, db: &'a dyn Database) -> Option<AttributeList<'a>> {
        match self {
            ModuleItem::Constant(item) => Some(item.attributes(db)),
            ModuleItem::Module(item) => Some(item.attributes(db)),
            ModuleItem::FreeFunction(item) => Some(item.attributes(db)),
            ModuleItem::Use(item) => Some(item.attributes(db)),
            ModuleItem::ExternFunction(item) => Some(item.attributes(db)),
            ModuleItem::ExternType(item) => Some(item.attributes(db)),
            ModuleItem::Trait(item) => Some(item.attributes(db)),
            ModuleItem::Impl(item) => Some(item.attributes(db)),
            ModuleItem::ImplAlias(item) => Some(item.attributes(db)),
            ModuleItem::Struct(item) => Some(item.attributes(db)),
            ModuleItem::Enum(item) => Some(item.attributes(db)),
            ModuleItem::TypeAlias(item) => Some(item.attributes(db)),
            ModuleItem::InlineMacro(item) => Some(item.attributes(db)),
            ModuleItem::MacroDeclaration(macro_declaration) => {
                Some(macro_declaration.attributes(db))
            }
            ModuleItem::Missing(_) => None,
            ModuleItem::HeaderDoc(_) => None,
        }
    }
}

impl<'a> QueryAttrs<'a> for ImplItem<'a> {
    fn try_attributes(&self, db: &'a dyn Database) -> Option<AttributeList<'a>> {
        match self {
            ImplItem::Function(item) => Some(item.attributes(db)),
            ImplItem::Type(item) => Some(item.attributes(db)),
            ImplItem::Constant(item) => Some(item.attributes(db)),
            ImplItem::Impl(item) => Some(item.attributes(db)),
            ImplItem::Module(item) => Some(item.attributes(db)),
            ImplItem::Use(item) => Some(item.attributes(db)),
            ImplItem::ExternFunction(item) => Some(item.attributes(db)),
            ImplItem::ExternType(item) => Some(item.attributes(db)),
            ImplItem::Trait(item) => Some(item.attributes(db)),
            ImplItem::Struct(item) => Some(item.attributes(db)),
            ImplItem::Enum(item) => Some(item.attributes(db)),
            ImplItem::Missing(_) => None,
        }
    }
}

impl<'a> QueryAttrs<'a> for AttributeList<'a> {
    fn try_attributes(&self, _db: &'a dyn Database) -> Option<AttributeList<'a>> {
        Some(self.clone())
    }
}
impl<'a> QueryAttrs<'a> for Member<'a> {
    fn try_attributes(&self, db: &'a dyn Database) -> Option<AttributeList<'a>> {
        Some(self.attributes(db))
    }
}

impl<'a> QueryAttrs<'a> for Variant<'a> {
    fn try_attributes(&self, db: &'a dyn Database) -> Option<AttributeList<'a>> {
        Some(self.attributes(db))
    }
}

impl<'a> QueryAttrs<'a> for StatementBreak<'a> {
    fn try_attributes(&self, db: &'a dyn Database) -> Option<AttributeList<'a>> {
        Some(self.attributes(db))
    }
}

impl<'a> QueryAttrs<'a> for StatementContinue<'a> {
    fn try_attributes(&self, db: &'a dyn Database) -> Option<AttributeList<'a>> {
        Some(self.attributes(db))
    }
}

impl<'a> QueryAttrs<'a> for StatementReturn<'a> {
    fn try_attributes(&self, db: &'a dyn Database) -> Option<AttributeList<'a>> {
        Some(self.attributes(db))
    }
}

impl<'a> QueryAttrs<'a> for StatementLet<'a> {
    fn try_attributes(&self, db: &'a dyn Database) -> Option<AttributeList<'a>> {
        Some(self.attributes(db))
    }
}

impl<'a> QueryAttrs<'a> for StatementExpr<'a> {
    fn try_attributes(&self, db: &'a dyn Database) -> Option<AttributeList<'a>> {
        Some(self.attributes(db))
    }
}

/// Allows querying attributes of a syntax node, any typed node which QueryAttrs is implemented for
/// should be added here.
impl<'a> QueryAttrs<'a> for SyntaxNode<'a> {
    fn try_attributes(&self, db: &'a dyn Database) -> Option<AttributeList<'a>> {
        match self.kind(db) {
            SyntaxKind::ItemConstant => {
                Some(ast::ItemConstant::from_syntax_node(db, *self).attributes(db))
            }
            SyntaxKind::ItemModule => {
                Some(ast::ItemModule::from_syntax_node(db, *self).attributes(db))
            }
            SyntaxKind::FunctionWithBody => {
                Some(ast::FunctionWithBody::from_syntax_node(db, *self).attributes(db))
            }
            SyntaxKind::ItemUse => Some(ast::ItemUse::from_syntax_node(db, *self).attributes(db)),
            SyntaxKind::ItemExternFunction => {
                Some(ast::ItemExternFunction::from_syntax_node(db, *self).attributes(db))
            }
            SyntaxKind::ItemExternType => {
                Some(ast::ItemExternType::from_syntax_node(db, *self).attributes(db))
            }
            SyntaxKind::ItemTrait => {
                Some(ast::ItemTrait::from_syntax_node(db, *self).attributes(db))
            }
            SyntaxKind::ItemImpl => Some(ast::ItemImpl::from_syntax_node(db, *self).attributes(db)),
            SyntaxKind::ItemImplAlias => {
                Some(ast::ItemImplAlias::from_syntax_node(db, *self).attributes(db))
            }
            SyntaxKind::ItemStruct => {
                Some(ast::ItemStruct::from_syntax_node(db, *self).attributes(db))
            }
            SyntaxKind::ItemEnum => Some(ast::ItemEnum::from_syntax_node(db, *self).attributes(db)),
            SyntaxKind::ItemTypeAlias => {
                Some(ast::ItemTypeAlias::from_syntax_node(db, *self).attributes(db))
            }
            SyntaxKind::TraitItemFunction => {
                Some(ast::TraitItemFunction::from_syntax_node(db, *self).attributes(db))
            }
            SyntaxKind::TraitItemType => {
                Some(ast::TraitItemType::from_syntax_node(db, *self).attributes(db))
            }
            SyntaxKind::TraitItemConstant => {
                Some(ast::TraitItemConstant::from_syntax_node(db, *self).attributes(db))
            }
            SyntaxKind::TraitItemImpl => {
                Some(ast::TraitItemImpl::from_syntax_node(db, *self).attributes(db))
            }
            SyntaxKind::ItemMacroDeclaration => {
                Some(ast::ItemMacroDeclaration::from_syntax_node(db, *self).attributes(db))
            }
            SyntaxKind::ItemInlineMacro => {
                Some(ast::ItemInlineMacro::from_syntax_node(db, *self).attributes(db))
            }
            SyntaxKind::AttributeList => Some(ast::AttributeList::from_syntax_node(db, *self)),
            SyntaxKind::Member => Some(ast::Member::from_syntax_node(db, *self).attributes(db)),
            SyntaxKind::Variant => Some(ast::Variant::from_syntax_node(db, *self).attributes(db)),
            SyntaxKind::StatementBreak => {
                Some(ast::StatementBreak::from_syntax_node(db, *self).attributes(db))
            }
            SyntaxKind::StatementContinue => {
                Some(ast::StatementContinue::from_syntax_node(db, *self).attributes(db))
            }
            SyntaxKind::StatementReturn => {
                Some(ast::StatementReturn::from_syntax_node(db, *self).attributes(db))
            }
            SyntaxKind::StatementLet => {
                Some(ast::StatementLet::from_syntax_node(db, *self).attributes(db))
            }
            SyntaxKind::StatementExpr => {
                Some(ast::StatementExpr::from_syntax_node(db, *self).attributes(db))
            }
            _ => None,
        }
    }
}

impl<'a> QueryAttrs<'a> for Statement<'a> {
    fn try_attributes(&self, db: &'a dyn Database) -> Option<AttributeList<'a>> {
        match self {
            Statement::Break(statement) => Some(statement.attributes(db)),
            Statement::Continue(statement) => Some(statement.attributes(db)),
            Statement::Return(statement) => Some(statement.attributes(db)),
            Statement::Let(statement) => Some(statement.attributes(db)),
            Statement::Expr(statement) => Some(statement.attributes(db)),
            Statement::Item(statement) => statement.item(db).try_attributes(db),
            Statement::Missing(_) => None,
        }
    }
}
pub trait WrappedArgListHelper<'a> {
    /// Pulls the wrapping brackets to get the argument list. Returns None if `self` is `Missing`.
    fn arg_list(&self, db: &'a dyn Database) -> Option<ast::ArgList<'a>>;
    /// Gets the syntax node of the right wrapping bracket.
    fn right_bracket_syntax_node(&self, db: &'a dyn Database) -> SyntaxNode<'a>;
    /// Gets the syntax node of the left wrapping bracket.
    fn left_bracket_syntax_node(&self, db: &'a dyn Database) -> SyntaxNode<'a>;
    /// Gets a stable pointer to the left wrapping bracket.
    fn left_bracket_stable_ptr(&self, db: &'a dyn Database) -> SyntaxStablePtrId<'a>;
}
impl<'a> WrappedArgListHelper<'a> for WrappedArgList<'a> {
    fn arg_list(&self, db: &'a dyn Database) -> Option<ast::ArgList<'a>> {
        match self {
            WrappedArgList::ParenthesizedArgList(args) => Some(args.arguments(db)),
            WrappedArgList::BracketedArgList(args) => Some(args.arguments(db)),
            WrappedArgList::BracedArgList(args) => Some(args.arguments(db)),
            WrappedArgList::Missing(_) => None,
        }
    }

    fn right_bracket_syntax_node(&self, db: &'a dyn Database) -> SyntaxNode<'a> {
        match self {
            WrappedArgList::ParenthesizedArgList(args) => args.rparen(db).as_syntax_node(),
            WrappedArgList::BracketedArgList(args) => args.rbrack(db).as_syntax_node(),
            WrappedArgList::BracedArgList(args) => args.rbrace(db).as_syntax_node(),
            WrappedArgList::Missing(_) => self.as_syntax_node(),
        }
    }

    fn left_bracket_syntax_node(&self, db: &'a dyn Database) -> SyntaxNode<'a> {
        match self {
            WrappedArgList::ParenthesizedArgList(args) => args.lparen(db).as_syntax_node(),
            WrappedArgList::BracketedArgList(args) => args.lbrack(db).as_syntax_node(),
            WrappedArgList::BracedArgList(args) => args.lbrace(db).as_syntax_node(),
            WrappedArgList::Missing(_) => self.as_syntax_node(),
        }
    }

    fn left_bracket_stable_ptr(&self, db: &'a dyn Database) -> SyntaxStablePtrId<'a> {
        match self {
            WrappedArgList::ParenthesizedArgList(args) => args.lparen(db).stable_ptr(db).untyped(),
            WrappedArgList::BracketedArgList(args) => args.lbrack(db).stable_ptr(db).untyped(),
            WrappedArgList::BracedArgList(args) => args.lbrace(db).stable_ptr(db).untyped(),
            WrappedArgList::Missing(_) => self.stable_ptr(db).untyped(),
        }
    }
}

pub trait WrappedGenericParamListHelper<'a> {
    /// Checks whether there are 0 generic parameters.
    fn is_empty(&'a self, db: &'a dyn Database) -> bool;
}
impl<'a> WrappedGenericParamListHelper<'a> for ast::WrappedGenericParamList<'a> {
    fn is_empty(&'a self, db: &'a dyn Database) -> bool {
        self.generic_params(db).elements(db).len() == 0
    }
}

pub trait OptionWrappedGenericParamListHelper<'a> {
    /// Checks whether there are 0 generic parameters. True either when the generic params clause
    /// doesn't exist or when it's empty.
    fn is_empty(&'a self, db: &'a dyn Database) -> bool;
}
impl<'a> OptionWrappedGenericParamListHelper<'a> for ast::OptionWrappedGenericParamList<'a> {
    fn is_empty(&'a self, db: &'a dyn Database) -> bool {
        match self {
            ast::OptionWrappedGenericParamList::Empty(_) => true,
            ast::OptionWrappedGenericParamList::WrappedGenericParamList(
                wrapped_generic_param_list,
            ) => wrapped_generic_param_list.is_empty(db),
        }
    }
}

/// Trait for getting the items of a body-item (an item that contains items), as an iterator.
pub trait BodyItems<'a> {
    /// The type of an Item.
    type Item: 'a;
    /// Returns the items of the body-item as an iterator.
    /// Use with caution, as this includes items that may be filtered out by plugins.
    /// Do note that plugins that directly run on this body-item without going/checking up on the
    /// syntax tree may assume that e.g. out-of-config items were already filtered out.
    /// Don't use on an item that is not the original plugin's context, unless you are sure that
    /// while traversing the AST to get to it from the original plugin's context, you did not go
    /// through another submodule.
    fn iter_items(&self, db: &'a dyn Database) -> impl Iterator<Item = Self::Item> + 'a;
}

impl<'a> BodyItems<'a> for ast::ModuleBody<'a> {
    type Item = ModuleItem<'a>;
    fn iter_items(&self, db: &'a dyn Database) -> impl Iterator<Item = Self::Item> + 'a {
        self.items(db).elements(db)
    }
}

impl<'a> BodyItems<'a> for ast::TraitBody<'a> {
    type Item = TraitItem<'a>;
    fn iter_items(&self, db: &'a dyn Database) -> impl Iterator<Item = Self::Item> + 'a {
        self.items(db).elements(db)
    }
}

impl<'a> BodyItems<'a> for ast::ImplBody<'a> {
    type Item = ImplItem<'a>;
    fn iter_items(&self, db: &'a dyn Database) -> impl Iterator<Item = Self::Item> + 'a {
        self.items(db).elements(db)
    }
}

/// Helper trait for ast::UsePath.
pub trait UsePathEx<'a> {
    /// Retrieves the item of a use path.
    fn get_item(&self, db: &'a dyn Database) -> ast::ItemUse<'a>;
}
impl<'a> UsePathEx<'a> for ast::UsePath<'a> {
    fn get_item(&self, db: &'a dyn Database) -> ast::ItemUse<'a> {
        let mut node = self.as_syntax_node();
        loop {
            let Some(parent) = node.parent(db) else {
                unreachable!("UsePath is not under an ItemUse.");
            };
            match parent.kind(db) {
                SyntaxKind::ItemUse => {
                    break ast::ItemUse::from_syntax_node(db, parent);
                }
                _ => node = parent,
            }
        }
    }
}

impl<'a> UsePathLeaf<'a> {
    /// Retrieves the stable pointer of the name of the leaf.
    pub fn name_stable_ptr(&self, db: &'a dyn Database) -> SyntaxStablePtrId<'a> {
        self.name(db).stable_ptr(db).untyped()
    }
}

/// Helper trait for check syntactically if a type is dependent on a given identifier.
pub trait IsDependentType<'db> {
    /// Returns true if `self` is dependent on `identifier` in an internal type.
    /// For example given identifier `T` will return true for:
    /// `T`, `Array<T>`, `Array<Array<T>>`, `(T, felt252)`, `T::AssocType`.
    /// Does not resolve type aliases or named generics. A multi-segment path is considered
    /// dependent when its head segment is one of the identifiers (e.g. the associated type
    /// `T::AssocType`), which is a purely syntactic check (no path resolution).
    fn is_dependent_type(&self, db: &'db dyn Database, identifiers: &[SmolStrId<'db>]) -> bool;
}

impl<'a> IsDependentType<'a> for ast::ExprPath<'a> {
    fn is_dependent_type(&self, db: &'a dyn Database, identifiers: &[SmolStrId<'a>]) -> bool {
        let mut segments = self.segments(db).elements(db);
        match segments.next() {
            None => false,
            Some(ast::PathSegment::Simple(simple)) if segments.len() == 0 => {
                identifiers.contains(&simple.identifier(db))
            }
            Some(first) => {
                // A path whose head segment is one of the identifiers (e.g. the associated type
                // `T::AssocType`) depends on that identifier. Only the head segment can be a
                // generic param; a later segment with the same name is an associated-item name.
                identifiers.contains(&first.identifier(db))
                    || chain!([first], segments).any(|segment| {
                        let ast::PathSegment::WithGenericArgs(with_generics) = segment else {
                            return false;
                        };
                        with_generics.generic_args(db).generic_args(db).elements(db).any(|arg| {
                            match arg {
                                ast::GenericArg::Named(named) => named.value(db),
                                ast::GenericArg::Unnamed(unnamed) => unnamed.value(db),
                            }
                            .is_dependent_type(db, identifiers)
                        })
                    })
            }
        }
    }
}

impl<'a> IsDependentType<'a> for ast::Expr<'a> {
    fn is_dependent_type(&self, db: &dyn Database, identifiers: &[SmolStrId<'a>]) -> bool {
        match self {
            ast::Expr::Path(type_path) => type_path.is_dependent_type(db, identifiers),
            ast::Expr::Unary(unary) => unary.expr(db).is_dependent_type(db, identifiers),
            ast::Expr::Binary(binary) => {
                binary.lhs(db).is_dependent_type(db, identifiers)
                    || binary.rhs(db).is_dependent_type(db, identifiers)
            }
            ast::Expr::Tuple(tuple) => tuple
                .expressions(db)
                .elements(db)
                .any(|expr| expr.is_dependent_type(db, identifiers)),
            ast::Expr::FixedSizeArray(arr) => {
                arr.exprs(db).elements(db).any(|expr| expr.is_dependent_type(db, identifiers))
                    || match arr.size(db) {
                        ast::OptionFixedSizeArraySize::Empty(_) => false,
                        ast::OptionFixedSizeArraySize::FixedSizeArraySize(size) => {
                            size.size(db).is_dependent_type(db, identifiers)
                        }
                    }
            }
            ast::Expr::Literal(_)
            | ast::Expr::ShortString(_)
            | ast::Expr::String(_)
            | ast::Expr::False(_)
            | ast::Expr::True(_)
            | ast::Expr::Parenthesized(_)
            | ast::Expr::FunctionCall(_)
            | ast::Expr::StructCtorCall(_)
            | ast::Expr::Block(_)
            | ast::Expr::Match(_)
            | ast::Expr::If(_)
            | ast::Expr::Loop(_)
            | ast::Expr::While(_)
            | ast::Expr::For(_)
            | ast::Expr::Closure(_)
            | ast::Expr::ErrorPropagate(_)
            | ast::Expr::FieldInitShorthand(_)
            | ast::Expr::Indexed(_)
            | ast::Expr::InlineMacro(_)
            | ast::Expr::Missing(_)
            | ast::Expr::Underscore(_) => false,
        }
    }
}

/// A kind of function the compiler generates for an expression in a function's body.
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
enum GeneratedFunctionKind {
    Closure,
    Loop,
}
impl GeneratedFunctionKind {
    /// Returns the kind of function generated for an expression of the given syntax kind, if any.
    fn of(kind: SyntaxKind) -> Option<Self> {
        match kind {
            SyntaxKind::ExprClosure => Some(Self::Closure),
            SyntaxKind::ExprLoop | SyntaxKind::ExprWhile | SyntaxKind::ExprFor => Some(Self::Loop),
            _ => None,
        }
    }

    /// Returns the name of the kind, as it appears in the path of a generated function.
    fn name(self) -> &'static str {
        match self {
            Self::Closure => "closure",
            Self::Loop => "loop",
        }
    }
}

/// The syntax kinds of the items owning the generated functions defined in their body.
const GENERATED_FUNCTION_OWNER_KINDS: [SyntaxKind; 2] =
    [SyntaxKind::FunctionWithBody, SyntaxKind::TraitItemFunction];

/// Returns whether an expression of the given syntax kind opens a scope for the generated
/// functions defined in it - either by being a generated function itself, or by being a function.
fn opens_generated_function_scope(kind: SyntaxKind) -> bool {
    GeneratedFunctionKind::of(kind).is_some() || GENERATED_FUNCTION_OWNER_KINDS.contains(&kind)
}

/// Returns the body of `node` if it is a `for` - the only generated function that is not lowered in
/// its entirety, as its iterable is lowered into the function containing it.
fn for_loop_body<'db>(db: &'db dyn Database, node: SyntaxNode<'db>) -> Option<SyntaxNode<'db>> {
    require(node.kind(db) == SyntaxKind::ExprFor)?;
    Some(ast::ExprFor::from_syntax_node(db, node).body(db).as_syntax_node())
}

/// Returns the scope the generated function of `generated` is defined in - the closest ancestor
/// that is a function, or a generated function whose body contains it.
fn generated_function_scope<'db>(
    db: &'db dyn Database,
    generated: SyntaxNode<'db>,
) -> Option<SyntaxNode<'db>> {
    let mut child = generated;
    for ancestor in generated.ancestors(db) {
        if opens_generated_function_scope(ancestor.kind(db))
            && for_loop_body(db, ancestor).is_none_or(|body| body == child)
        {
            return Some(ancestor);
        }
        child = ancestor;
    }
    // A generated function with no enclosing function is an error, but is still named - index it
    // within the file, so that its name stays unique.
    generated.ancestors(db).last()
}

/// A segment of the path of a generated function - only displayable, as its shape is not meaningful
/// to its callers.
pub struct GeneratedFunctionPathSegment<'db>(GeneratedFunctionPathSegmentKind<'db>);
impl std::fmt::Display for GeneratedFunctionPathSegment<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self.0 {
            GeneratedFunctionPathSegmentKind::Generated { kind, index } => {
                write!(f, "{{{}#{index}}}", kind.name())
            }
            GeneratedFunctionPathSegmentKind::MacroExpansion { name, offset } => {
                write!(f, "{{{name}@{offset}}}")
            }
        }
    }
}

/// The kinds of [GeneratedFunctionPathSegment].
enum GeneratedFunctionPathSegmentKind<'db> {
    /// A generated function, as `{<kind>#<index>}`.
    Generated { kind: GeneratedFunctionKind, index: usize },
    /// The expansion of a macro, as `{<macro>@<offset of the call>}`.
    MacroExpansion { name: &'db str, offset: u32 },
}

/// Returns a segment for each macro expansion `node` is in, from the outermost inwards.
///
/// A generated function in the expansion of a macro has no path relative to the function it is
/// lowered into, as that function is in another file. The expansions leading to it name it instead,
/// each by the macro and the offset of its call, as the module of a macro call is named.
fn macro_expansion_segments<'db>(
    db: &'db dyn Database,
    node: SyntaxNode<'db>,
) -> Vec<GeneratedFunctionPathSegment<'db>> {
    let mut segments = vec![];
    let mut file_id = node.stable_ptr(db).file_id(db);
    while let FileLongId::Virtual(virtual_file) = file_id.long(db) {
        let Some(parent) = virtual_file.parent else {
            break;
        };
        segments.push(GeneratedFunctionPathSegment(
            GeneratedFunctionPathSegmentKind::MacroExpansion {
                name: virtual_file.name.long(db),
                offset: parent.span.start.as_u32(),
            },
        ));
        file_id = parent.file_id;
    }
    segments.reverse();
    segments
}

/// Calls `handle_segment` for each segment of the path of `node`'s generated function, from the
/// outermost segment inwards. See [generated_function_path].
pub fn for_each_generated_function_path_segment<'db, Break>(
    db: &'db dyn Database,
    node: SyntaxNode<'db>,
    handle_segment: &mut impl FnMut(GeneratedFunctionPathSegment<'db>) -> ControlFlow<Break>,
) -> ControlFlow<Break> {
    let Some((generated, kind)) = node
        .ancestors_with_self(db)
        .find_map(|node| Some((node, GeneratedFunctionKind::of(node.kind(db))?)))
    else {
        return ControlFlow::Continue(());
    };
    let scope = generated_function_scope(db, generated);
    match scope.filter(|scope| opens_generated_function_scope(scope.kind(db))) {
        // Within another generated function - its path is the prefix of this one's.
        Some(outer) if GeneratedFunctionKind::of(outer.kind(db)).is_some() => {
            for_each_generated_function_path_segment(db, outer, handle_segment)?;
        }
        // Directly within a function - the path is relative to it.
        Some(_) => {}
        // Within no function of its own file - it is in the expansion of a macro.
        None => {
            for segment in macro_expansion_segments(db, generated) {
                handle_segment(segment)?;
            }
        }
    }
    let index = scope.map_or(0, |scope| generated_function_indices(db, (), scope)[&generated]);
    handle_segment(GeneratedFunctionPathSegment(GeneratedFunctionPathSegmentKind::Generated {
        kind,
        index,
    }))
}

/// Returns the path of the generated function created for `node` - or for its closest ancestor that
/// is lowered into a generated function - relative to the function it is defined in.
///
/// Every level of nesting adds a `{<kind>#<index>}` segment, where the index counts, per kind, the
/// generated functions directly within the enclosing generated function (or within the function
/// itself). So the closures of:
/// ```ignore
/// fn foo() {
///     let outer = |x| {
///         let inner = |y| y;
///         inner(x)
///     };
///     let last = |z| z;
/// }
/// ```
/// are `{closure#0}`, `{closure#0}::{closure#0}` and `{closure#1}`.
///
/// As the path only depends on the code of the containing function, it makes the names of
/// generated functions independent of the path of the file they are defined in, and of any code
/// outside of their containing function.
pub fn generated_function_path<'db>(
    db: &'db dyn Database,
    node: SyntaxNode<'db>,
) -> impl std::fmt::Display + 'db {
    GeneratedFunctionPath { db, node }
}

/// The [std::fmt::Display] of [generated_function_path].
struct GeneratedFunctionPath<'db> {
    db: &'db dyn Database,
    node: SyntaxNode<'db>,
}
impl std::fmt::Display for GeneratedFunctionPath<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut is_first = true;
        for_each_generated_function_path_segment(self.db, self.node, &mut |segment| {
            let separator = if std::mem::take(&mut is_first) { "" } else { "::" };
            match write!(f, "{separator}{segment}") {
                Ok(()) => ControlFlow::Continue(()),
                Err(err) => ControlFlow::Break(err),
            }
        })
        .break_value()
        .map_or(Ok(()), Err)
    }
}

/// Returns the index of each generated function directly within `scope`, counted per kind in the
/// order the functions appear in it.
///
/// Memoized per scope, so naming every generated function of a function costs one pass over its
/// body rather than one per name.
#[salsa::tracked(returns(ref))]
fn generated_function_indices<'db>(
    db: &'db dyn Database,
    _tracked: Tracked,
    scope: SyntaxNode<'db>,
) -> OrderedHashMap<SyntaxNode<'db>, usize> {
    let mut indices = OrderedHashMap::default();
    // Of a `for` scope, only its body is lowered into it.
    let lowered_scope = for_loop_body(db, scope).unwrap_or(scope);
    collect_generated_function_indices(db, lowered_scope, &mut Default::default(), &mut indices);
    indices
}

/// Accumulates into `indices` the index of each generated function directly within `node`'s scope,
/// counting each kind in `counters`.
fn collect_generated_function_indices<'db>(
    db: &'db dyn Database,
    node: SyntaxNode<'db>,
    counters: &mut UnorderedHashMap<GeneratedFunctionKind, usize>,
    indices: &mut OrderedHashMap<SyntaxNode<'db>, usize>,
) {
    for child in node.get_children(db) {
        let child_kind = child.kind(db);
        // A nested function is not a generated function, and its body opens a scope of its own.
        if GENERATED_FUNCTION_OWNER_KINDS.contains(&child_kind) {
            continue;
        }
        // A nested generated function is indexed here, but its body belongs to its own scope -
        // except for the iterable of a `for`, which is lowered into this scope.
        if let Some(kind) = GeneratedFunctionKind::of(child_kind) {
            let counter = counters.entry(kind).or_default();
            indices.insert(*child, *counter);
            *counter += 1;
            if let Some(body) = for_loop_body(db, *child) {
                for part in child.get_children(db).iter().filter(|part| **part != body) {
                    collect_generated_function_indices(db, *part, counters, indices);
                }
            }
            continue;
        }
        collect_generated_function_indices(db, *child, counters, indices);
    }
}