Method visit_binding

src/extraction/nix_extractor.rs:198–435

Visit a binding node. Classify as Function, Module, or Const based on the value.

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

    /// Visit a binding node. Classify as Function, Module, or Const based on the value.
    fn visit_binding(state: &mut ExtractionState, node: TsNode<'_>) {
        // Extract name from attrpath child
        let name = Self::extract_binding_name(state, node);
        let Some(name) = name else {
            return;
        };

        // Get the expression (value) child
        let expr = node.child_by_field_name("expression");

        let docstring = Self::extract_docstring(state, node);
        let start_line = node.start_position().row as u32;
        let end_line = node.end_position().row as u32;
        let start_column = node.start_position().column as u32;
        let end_column = node.end_position().column as u32;

        // Enhancement 3: Flake output schema awareness.
        // In flake.nix files, known output attrs are forced to Module classification.
        let force_module = Self::is_flake_file(state) && Self::is_flake_output_attr(&name);

        // Enhancement 1: Check if the expression is a builder call (derivation).
        // We store the builder info before classifying to avoid borrow issues.
        let builder_info: Option<(String, usize)> = expr.and_then(|e| {
            Self::is_builder_call(state, e).map(|(_callee, attrset)| {
                // Store the attrset node id so we can find it again
                (String::new(), attrset.id())
            })
        });
        let is_builder = builder_info.is_some();

        // Classify based on value expression type
        let classification = if force_module {
            Some(BindingKind::Module)
        } else {
            expr.map(|e| Self::classify_expression(e))
        };

        match classification {
            Some(BindingKind::Function) => {
                let kind = NodeKind::Function;
                let qualified_name = format!("{}::{}", state.qualified_prefix(), name);
                let id = generate_node_id(&state.file_path, &kind, &name, start_line);
                let signature = Self::extract_function_signature(state, node);
                let metrics = if let Some(expr_node) = expr {
                    if expr_node.child_count() > 0 {
                        count_complexity(expr_node, &NIX_COMPLEXITY, &state.source)
                    } else {
                        ComplexityMetrics::default()
                    }
                } else {
                    ComplexityMetrics::default()
                };

                let graph_node = Node {
                    id: id.clone(),
                    kind,
                    name: name.clone(),
                    qualified_name,