Method visit_function

src/extraction/kotlin_extractor.rs:923–1008

Extract a function or method declaration.

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

    /// Extract a function or method declaration.
    fn visit_function(state: &mut ExtractionState, node: TsNode<'_>) {
        let name = find_direct_child_by_kind(node, "simple_identifier")
            .map_or_else(|| "<anonymous>".to_string(), |n| state.node_text(n));

        // Check if this is an extension function (has a receiver type before the dot and name).
        let is_extension = Self::is_extension_function(node);

        let visibility = Self::extract_visibility(node, state);
        let docstring = Self::extract_kdoc(state, node);
        let signature = Some(Self::extract_declaration_signature(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;
        let qualified_name = format!("{}::{}", state.qualified_prefix(), name);

        // Check for suspend modifier.
        let is_async = Self::has_modifier_keyword(node, state, "suspend");

        // Determine if this is a function without a body (abstract) inside an interface.
        let has_body = find_direct_child_by_kind(node, "function_body").is_some();

        let kind = if state.inside_trait && !has_body {
            NodeKind::AbstractMethod
        } else if state.class_depth > 0 {
            NodeKind::Method
        } else {
            NodeKind::Function
        };

        let id = generate_node_id(&state.file_path, &kind, &name, start_line);
        let metrics = count_complexity(node, &KOTLIN_COMPLEXITY, &state.source);

        // For extension functions, build a richer signature including the receiver type.
        let final_signature = if is_extension {
            Some(Self::extract_extension_signature(state, node))
        } else {
            signature
        };

        let graph_node = Node {
            id: id.clone(),
            kind,
            name: name.clone(),
            qualified_name,
            file_path: state.file_path.clone(),
            start_line,
            attrs_start_line: start_line,
            end_line,
            start_column,
            end_column,
            signature: final_signature,
            docstring,
            visibility,
            is_async,
            branches: metrics.branches,
            loops: metrics.loops,
            returns: metrics.returns,