Method visit_variable_declaration

src/extraction/lua_extractor.rs:273–376

Extract a variable declaration (`local name = value`). Handles: - `local x = require("mod")` → Use node - `local CONST = ` → Const node (uppercase names)

(state: &mut ExtractionState, node: TsNode<'_>)

    /// - `local x = require("mod")` → Use node
    /// - `local CONST = <literal>` → Const node (uppercase names)
    fn visit_variable_declaration(state: &mut ExtractionState, node: TsNode<'_>) {
        // variable_declaration contains an assignment_statement child.
        let Some(assignment) = find_direct_child_by_kind(node, "assignment_statement") else {
            return;
        };

        // Get the variable name from the variable_list.
        let var_list = assignment
            .child_by_field_name("variable_list")
            .or_else(|| find_direct_child_by_kind(assignment, "variable_list"));
        let name_node = var_list.and_then(|vl| {
            // The first named child of variable_list should be the identifier.
            find_direct_child_by_kind(vl, "identifier")
        });
        let Some(n) = name_node else {
            return;
        };
        let name = state.node_text(n);

        // Get the value from the expression_list.
        let expr_list = assignment
            .child_by_field_name("expression_list")
            .or_else(|| find_direct_child_by_kind(assignment, "expression_list"));
        let value_node = expr_list.and_then(|el| el.named_child(0));

        let Some(value_node) = value_node else {
            return;
        };

        // Check if this is a require call → Use node.
        if value_node.kind() == "function_call" {
            let call_name = value_node
                .child_by_field_name("name")
                .map(|n| state.node_text(n));
            if call_name.as_deref() == Some("require") {
                // Extract the module name from the arguments.
                let mod_name =
                    Self::extract_require_module(state, value_node).unwrap_or(name.clone());
                Self::emit_use_node(state, node, &mod_name);
                return;
            }
        }

        // Check if the value is a table constructor → skip (table declaration, not a const).
        if value_node.kind() == "table_constructor" {
            return;
        }

        // Treat as Const node (Lua convention: uppercase names are constants,
        // but we emit all local variable declarations with literal values as Const).
        let is_literal = matches!(
            value_node.kind(),
            "number" | "string" | "true" | "false" | "nil"
        );
        if !is_literal {
            return;
        }