code-gauge 3.1.0 → 4.1.0

package/native/src/functions.rs

@@ -0,0 +1,345 @@
+use std::collections::HashSet;
+use tree_sitter::Node;
+
+use crate::util::{all_children, find_children_by_field_name, named_children, node_text, Source};
+
+/// C++ `function_definition` also covers pure-virtual/`= default`/`= delete` members; those have no
+/// `body` and are signatures, not implementations, matching how TypeScript method signatures are
+/// excluded. Java `method_declaration` is NOT here: PMD reports abstract/interface methods as
+/// methods (NCSS 1), so bodyless Java methods stay in the function list.
+const BODY_REQUIRED_FUNCTION_TYPES: &[&str] = &[
+    "function_definition",
+    "constructor_declaration",
+    "compact_constructor_declaration",
+    "function_signature_item",
+];
+
+pub fn is_implemented_function(node: Node<'_>) -> bool {
+    if !BODY_REQUIRED_FUNCTION_TYPES.contains(&node.kind())
+        || node.child_by_field_name("body").is_some()
+    {
+        return true;
+    }
+
+    // C++ constructor/destructor function-try-blocks carry their `try_statement` outside the
+    // `body` field; they are implementations, unlike `= 0`/`= default`/`= delete` members.
+    named_children(node)
+        .iter()
+        .any(|child| child.kind() == "try_statement")
+}
+
+/// Counts declared parameters of a function/method, ignoring punctuation and comments.
+pub fn count_parameters(node: Node<'_>, code: &Source<'_>) -> usize {
+    // An unparenthesized arrow-function parameter (`x => x + 1`) is a bare `parameter` field.
+    if node.child_by_field_name("parameter").is_some() {
+        return 1;
+    }
+
+    let Some(parameters_node) = find_parameters_node(node) else {
+        return 0;
+    };
+
+    // A Java bare lambda parameter (`x -> x + 1`) puts a lone identifier in the `parameters` field.
+    if parameters_node.kind() == "identifier" {
+        return 1;
+    }
+
+    // Ruby block-locals after `;` (`{ |x; memo| ... }`) occupy `locals` fields and receive no arguments.
+    let block_local_ids: HashSet<usize> = find_children_by_field_name(parameters_node, "locals")
+        .iter()
+        .map(|child| child.id())
+        .collect();
+    let mut count = 0usize;
+    // Rust's `self` and Java's explicit receiver (`void f(X this)`) are not declared parameters,
+    // C/C++ `f(void)` declares none, and a Ruby block parameter (`&blk`) binds the block, which
+    // call sites pass outside the argument list.
+    for child in named_children(parameters_node) {
+        if child.kind() == "comment"
+            || child.kind() == "self_parameter"
+            || child.kind() == "receiver_parameter"
+            || child.kind() == "block_parameter"
+            // Python's PEP 570/3102 markers (`/`, `*`) separate parameter kinds but bind nothing.
+            || child.kind() == "positional_separator"
+            || child.kind() == "keyword_separator"
+            || block_local_ids.contains(&child.id())
+            || is_void_parameter(child, code)
+        {
+            continue;
+        }
+        // Go declares several names per declaration (`a, b int`); each name is a parameter.
+        count += if child.kind() == "parameter_declaration" {
+            find_children_by_field_name(child, "name").len().max(1)
+        } else {
+            1
+        };
+    }
+    // C++ C-style varargs (`int f(int a, ...)`) leave `...` as an anonymous token.
+    let anonymous_variadic_count = all_children(parameters_node)
+        .iter()
+        .filter(|child| !child.is_named() && node_text(**child, code) == "...")
+        .count();
+    count + anonymous_variadic_count
+}
+
+/// C/C++ `int f(void)` has a `parameter_declaration` whose type is a bare `void` with no declarator.
+fn is_void_parameter(node: Node<'_>, code: &Source<'_>) -> bool {
+    node.kind() == "parameter_declaration"
+        && node.child_by_field_name("declarator").is_none()
+        && node
+            .child_by_field_name("type")
+            .is_some_and(|type_node| node_text(type_node, code) == "void")
+}
+
+fn find_parameters_node(node: Node<'_>) -> Option<Node<'_>> {
+    if let Some(direct) = node.child_by_field_name("parameters") {
+        return Some(direct);
+    }
+
+    // A Java compact constructor implicitly takes the record's components, declared on the
+    // `record_declaration` two levels up (via `class_body`).
+    if node.kind() == "compact_constructor_declaration" {
+        return node
+            .parent()
+            .and_then(|parent| parent.parent())
+            .and_then(|grandparent| grandparent.child_by_field_name("parameters"));
+    }
+
+    // C/C++ parameters hang off the (possibly pointer/reference-wrapped) declarator.
+    let mut declarator = node.child_by_field_name("declarator");
+    while let Some(current) = declarator {
+        if let Some(parameters) = current.child_by_field_name("parameters") {
+            return Some(parameters);
+        }
+        declarator = next_declarator(current);
+    }
+
+    named_children(node)
+        .into_iter()
+        .find(|child| child.kind() == "formal_parameters" || child.kind() == "parameter_list")
+}
+
+pub fn collect_nodes<'t>(root: Node<'t>, node_types: &HashSet<&'static str>) -> Vec<Node<'t>> {
+    let mut nodes = Vec::new();
+
+    fn visit<'t>(node: Node<'t>, node_types: &HashSet<&'static str>, nodes: &mut Vec<Node<'t>>) {
+        if node_types.contains(node.kind()) {
+            nodes.push(node);
+        }
+
+        for child in named_children(node) {
+            visit(child, node_types, nodes);
+        }
+    }
+
+    visit(root, node_types, &mut nodes);
+    nodes
+}
+
+pub fn find_function_name(node: Node<'_>, code: &Source<'_>) -> Option<String> {
+    // JS truthiness: empty strings from MISSING nodes act like "no name" at every `if (name)`.
+    if let Some(wrapped_name) =
+        find_wrapped_component_name(node, code).filter(|name| !name.is_empty())
+    {
+        return Some(wrapped_name);
+    }
+
+    if let Some(name_node) = node.child_by_field_name("name") {
+        return Some(node_text(name_node, code).to_string());
+    }
+
+    // C/C++ definitions name the function inside the (possibly pointer-wrapped) declarator chain.
+    if let Some(declarator_name) =
+        unwrap_declarator_name(node.child_by_field_name("declarator"), code)
+            .filter(|name| !name.is_empty())
+    {
+        return Some(declarator_name);
+    }
+
+    let parent = node.parent()?;
+
+    // A Rust closure bound to a simple `let` identifier takes that identifier as its name.
+    if node.kind() == "closure_expression" && parent.kind() == "let_declaration" {
+        let pattern_node = parent.child_by_field_name("pattern");
+        return match pattern_node {
+            Some(pattern) if pattern.kind() == "identifier" => {
+                Some(node_text(pattern, code).to_string())
+            }
+            _ => None,
+        };
+    }
+
+    // A C++ lambda assigned to a variable (`auto f = [](int x) { ... };`) takes the variable name.
+    if node.kind() == "lambda_expression" && parent.kind() == "init_declarator" {
+        return unwrap_declarator_name(parent.child_by_field_name("declarator"), code);
+    }
+
+    // A Go func literal bound via `add := func...` or `var add = func...` takes the identifier at
+    // the same list position.
+    if node.kind() == "func_literal" && parent.kind() == "expression_list" {
+        return find_go_func_literal_name(node, parent, code);
+    }
+
+    // Ruby lambdas assigned to a name take that name.
+    if node.kind() == "lambda" && parent.kind() == "assignment" {
+        return find_ruby_assignment_name(parent, code);
+    }
+    if (node.kind() == "block" || node.kind() == "do_block") && is_ruby_lambda_call(parent, code) {
+        return match parent.parent() {
+            Some(grandparent) if grandparent.kind() == "assignment" => {
+                find_ruby_assignment_name(grandparent, code)
+            }
+            _ => None,
+        };
+    }
+
+    parent
+        .child_by_field_name("name")
+        .map(|name| node_text(name, code).to_string())
+}
+
+fn find_ruby_assignment_name(assignment: Node<'_>, code: &Source<'_>) -> Option<String> {
+    let left_node = assignment.child_by_field_name("left")?;
+    if left_node.kind() == "identifier" || left_node.kind() == "constant" {
+        Some(node_text(left_node, code).to_string())
+    } else {
+        None
+    }
+}
+
+fn is_ruby_lambda_call(node: Node<'_>, code: &Source<'_>) -> bool {
+    if node.kind() != "call" || node.child_by_field_name("receiver").is_some() {
+        return false;
+    }
+    node.child_by_field_name("method").is_some_and(|method| {
+        method.kind() == "identifier"
+            && (node_text(method, code) == "lambda" || node_text(method, code) == "proc")
+    })
+}
+
+fn find_go_func_literal_name(
+    node: Node<'_>,
+    expression_list: Node<'_>,
+    code: &Source<'_>,
+) -> Option<String> {
+    let holder = expression_list.parent()?;
+    // Comments interleave with expressions in the list but have no matching binding target.
+    let values: Vec<Node<'_>> = named_children(expression_list)
+        .into_iter()
+        .filter(|child| child.kind() != "comment")
+        .collect();
+    let value_index = values.iter().position(|child| child.id() == node.id())?;
+
+    if holder.kind() == "short_var_declaration" {
+        let targets = holder.child_by_field_name("left").map(|left| {
+            named_children(left)
+                .into_iter()
+                .filter(|child| child.kind() != "comment")
+                .collect::<Vec<_>>()
+        });
+        return as_go_binding_name(
+            targets
+                .as_ref()
+                .and_then(|targets| targets.get(value_index))
+                .copied(),
+            code,
+        );
+    }
+
+    if holder.kind() == "var_spec" {
+        let target = find_children_by_field_name(holder, "name")
+            .get(value_index)
+            .copied();
+        return as_go_binding_name(target, code);
+    }
+
+    None
+}
+
+/// Go's blank identifier `_` discards the value and creates no callable binding.
+fn as_go_binding_name(target: Option<Node<'_>>, code: &Source<'_>) -> Option<String> {
+    match target {
+        Some(target) if target.kind() == "identifier" && node_text(target, code) != "_" => {
+            Some(node_text(target, code).to_string())
+        }
+        _ => None,
+    }
+}
+
+fn find_wrapped_component_name(node: Node<'_>, code: &Source<'_>) -> Option<String> {
+    let mut current = node;
+    loop {
+        let arguments_node = current.parent();
+        let call_node = arguments_node.and_then(|arguments| arguments.parent());
+        let (Some(arguments_node), Some(call_node)) = (arguments_node, call_node) else {
+            return None;
+        };
+        if arguments_node.kind() != "arguments" || call_node.kind() != "call_expression" {
+            return None;
+        }
+
+        if !is_react_component_wrapper_call(call_node, code) {
+            return None;
+        }
+
+        if let Some(declarator_node) = call_node.parent() {
+            if declarator_node.kind() == "variable_declarator" {
+                return declarator_node
+                    .child_by_field_name("name")
+                    .map(|name| node_text(name, code).to_string());
+            }
+        }
+
+        current = call_node;
+    }
+}
+
+fn is_react_component_wrapper_call(node: Node<'_>, code: &Source<'_>) -> bool {
+    let callee_node = node
+        .child_by_field_name("function")
+        .or_else(|| node.named_child(0));
+    callee_node.is_some_and(|callee| {
+        let text = node_text(callee, code);
+        text == "memo" || text == "React.memo" || text == "forwardRef" || text == "React.forwardRef"
+    })
+}
+
+/// Unwraps a C/C++ declarator chain to the declared name; see unwrapDeclaratorName in metrics.ts.
+fn unwrap_declarator_name(declarator: Option<Node<'_>>, code: &Source<'_>) -> Option<String> {
+    let mut current = declarator;
+    while let Some(node) = current {
+        match node.kind() {
+            "identifier" | "field_identifier" | "type_identifier" | "destructor_name"
+            | "operator_name" => {
+                return Some(node_text(node, code).to_string());
+            }
+            // A C++ conversion operator (`operator int()`) is its own declarator node.
+            "operator_cast" => {
+                let type_text = node
+                    .child_by_field_name("type")
+                    .map(|type_node| node_text(type_node, code))
+                    .unwrap_or("");
+                return Some(format!("operator {type_text}").trim_end().to_string());
+            }
+            // Template specializations (`id<int>`) and qualified names both carry a `name` field.
+            "template_function" | "qualified_identifier" => {
+                current = node.child_by_field_name("name");
+            }
+            _ => {
+                current = next_declarator(node);
+            }
+        }
+    }
+    None
+}
+
+/// Steps into the inner declarator; `reference_declarator` and `parenthesized_declarator` do not
+/// expose a `declarator` field in tree-sitter-cpp, so their sole named child is the inner node.
+fn next_declarator(node: Node<'_>) -> Option<Node<'_>> {
+    if let Some(direct) = node.child_by_field_name("declarator") {
+        return Some(direct);
+    }
+    if node.kind() == "reference_declarator" || node.kind() == "parenthesized_declarator" {
+        return node.named_child(0);
+    }
+    None
+}