Method walk_tree_for_references

atomic-semantic/src/parser.rs:75–144

Walk the AST and extract references (function calls, identifier usages)

(
        &self,
        node: &Node,
        source: &str,
        file_path: &str,
        references: &mut Vec<Reference>,
        seen: &mut HashSet<(String, u32)>,
    )

    /// Walk the AST and extract references (function calls, identifier usages)
    fn walk_tree_for_references(
        &self,
        node: &Node,
        source: &str,
        file_path: &str,
        references: &mut Vec<Reference>,
        seen: &mut HashSet<(String, u32)>,
    ) {
        match node.kind() {
            // Function calls: foo(), obj.method(), etc.
            "call_expression" => {
                if let Some(reference) = self.extract_call_reference(node, source, file_path, seen)
                {
                    references.push(reference);
                }
            }

            // Member expressions: obj.property
            "member_expression" => {
                if let Some(reference) =
                    self.extract_member_reference(node, source, file_path, seen)
                {
                    references.push(reference);
                }
            }

            // Identifier usages (variables, type references)
            "identifier" => {
                // Skip if parent is a declaration (we want usages, not definitions)
                if let Some(parent) = node.parent() {
                    let parent_kind = parent.kind();
                    // Skip identifiers that are part of declarations
                    if !matches!(
                        parent_kind,
                        "function_declaration"
                            | "class_declaration"
                            | "interface_declaration"
                            | "type_alias_declaration"
                            | "variable_declarator"
                            | "method_definition"
                            | "property_signature"
                            | "import_specifier"
                            | "import_clause"
                    ) {
                        if let Some(reference) =
                            self.extract_identifier_reference(node, source, file_path, seen)
                        {
                            references.push(reference);
                        }
                    }
                }
            }

            // Type references: User, AuthToken, etc.
            "type_identifier" => {
                if let Some(reference) = self.extract_type_reference(node, source, file_path, seen)
                {
                    references.push(reference);