code-gauge 4.1.3 → 4.2.1

package/native/src/dep_degree.rs

@@ -1,12 +1,15 @@
 use std::collections::{HashMap, HashSet};
 use tree_sitter::Node;
 
-use crate::complexity::is_lambda_body_block;
-use crate::util::{node_text, Source};
+use crate::complexity::is_function_boundary;
+use crate::util::{is_identifier_leaf, node_text, Source};
 
 /// Leaf node types treated as variable references by the def-use approximation.
 const VARIABLE_NODE_TYPES: &[&str] = &[
     "identifier",
+    "simple_identifier",
+    "interpolated_identifier",
+    "implicit_parameter",
     "instance_variable",
     "class_variable",
     "global_variable",
@@ -36,6 +39,37 @@ const DEFINITION_FIELD_BY_PARENT_TYPE: &[(&str, &str)] = &[
     ("for_in_clause", "left"),
     ("for_range_loop", "declarator"),
     ("for_expression", "pattern"),
+    ("for", "pattern"),
+    ("foreach_statement", "left"),
+    ("catch_declaration", "name"),
+    ("declaration_pattern", "name"),
+    ("declaration_expression", "name"),
+    ("recursive_pattern", "name"),
+    ("var_pattern", "name"),
+    ("tuple_pattern", "name"),
+    ("parenthesized_variable_designation", "name"),
+    ("from_clause", "name"),
+];
+
+/// Kotlin has no grammar fields: an identifier directly under one of these declares a binding
+/// (`val x`, `for (x in xs)`, lambda parameters, and the `catch (e: T)` exception name).
+const KOTLIN_DEFINITION_PARENT_TYPES: &[&str] = &["variable_declaration", "catch_block"];
+
+/// Kotlin parameter nodes whose identifier child is the declared name; the parameter LIST nodes
+/// (`function_value_parameters`) also hold default-value expressions, which are reads.
+const KOTLIN_PARAMETER_TYPES: &[&str] = &[
+    "parameter",
+    "parameter_with_optional_type",
+    "class_parameter",
+];
+
+/// C# LINQ clauses that bind a range variable as their first identifier child (no grammar field):
+/// `join y in ...`, `into ys`, `let z = ...`, and a query continuation `into g`.
+const CSHARP_QUERY_BINDING_PARENT_TYPES: &[&str] = &[
+    "join_clause",
+    "join_into_clause",
+    "let_clause",
+    "query_expression",
 ];
 
 /// Multi-target lists (`a, b = ...`, `a, b := ...`) whose holder's `left` field marks definitions.
@@ -79,10 +113,15 @@ pub fn measure_dep_degree(
         true,
     );
     let mut definition_scopes_by_name: HashMap<&str, Vec<String>> = HashMap::new();
+    for name in implicit_accessor_definitions(function_node, code) {
+        add_definition(&mut definition_scopes_by_name, name, "");
+    }
     let mut pairs = 0u64;
     for index in 0..leaves.len() {
         let leaf = &leaves[index];
-        if !VARIABLE_NODE_TYPES.contains(&leaf.node.kind()) {
+        if !VARIABLE_NODE_TYPES.contains(&leaf.node.kind())
+            && !crate::util::is_kotlin_callable_receiver(leaf.node)
+        {
             continue;
         }
         let name = node_text(leaf.node, code);
@@ -108,6 +147,36 @@ pub fn measure_dep_degree(
     pairs
 }
 
+/// Names a C# accessor body can read without declaring them in its own subtree: the owning
+/// indexer's parameters (including a `params` array, which the grammar names directly on the
+/// parameter list) and, in a setter, initializer, or event accessor, the implicit `value`.
+fn implicit_accessor_definitions<'a>(function_node: Node<'_>, code: &Source<'a>) -> Vec<&'a str> {
+    if function_node.kind() != "accessor_declaration" {
+        return Vec::new();
+    }
+    let mut names = Vec::new();
+    if function_node
+        .child_by_field_name("name")
+        .is_some_and(|keyword| {
+            matches!(node_text(keyword, code), "set" | "init" | "add" | "remove")
+        })
+    {
+        names.push("value");
+    }
+    let owner = function_node.parent().and_then(|list| list.parent());
+    if let Some(parameters) = owner
+        .filter(|owner| owner.kind() == "indexer_declaration")
+        .and_then(|owner| owner.child_by_field_name("parameters"))
+    {
+        let declared = crate::util::named_children(parameters)
+            .into_iter()
+            .filter_map(|parameter| parameter.child_by_field_name("name"))
+            .chain(parameters.child_by_field_name("name"));
+        names.extend(declared.map(|name| node_text(name, code)));
+    }
+    names
+}
+
 /// Collects non-comment leaves with their parent field (one cursor pass, so children of
 /// high-arity nodes cost O(1)) and function-scope chain; mirrors collectDepDegreeLeaves.
 #[allow(clippy::too_many_arguments)]
@@ -120,10 +189,13 @@ fn collect_dep_degree_leaves<'t>(
     leaves: &mut Vec<DepDegreeLeaf<'t>>,
     is_measured_root: bool,
 ) {
-    if matches!(node.kind(), "comment" | "line_comment" | "block_comment") {
+    if matches!(
+        node.kind(),
+        "comment" | "line_comment" | "block_comment" | "multiline_comment"
+    ) {
         return;
     }
-    if node.child_count() == 0 {
+    if is_identifier_leaf(node) {
         leaves.push(DepDegreeLeaf {
             node,
             field_name,
@@ -157,10 +229,6 @@ fn collect_dep_degree_leaves<'t>(
     }
 }
 
-fn is_function_boundary(node: Node<'_>, function_nodes: &HashSet<&'static str>) -> bool {
-    function_nodes.contains(node.kind()) && !is_lambda_body_block(node)
-}
-
 fn add_definition<'a>(
     definition_scopes_by_name: &mut HashMap<&'a str, Vec<String>>,
     name: &'a str,
@@ -188,6 +256,20 @@ fn is_structural_definition(leaf: &DepDegreeLeaf<'_>) -> bool {
     let Some(parent) = leaf.node.parent() else {
         return false;
     };
+    if leaf.node.kind() == "simple_identifier"
+        && KOTLIN_DEFINITION_PARENT_TYPES.contains(&parent.kind())
+    {
+        return true;
+    }
+    if leaf.node.kind() == "identifier"
+        && CSHARP_QUERY_BINDING_PARENT_TYPES.contains(&parent.kind())
+        && crate::util::named_children(parent)
+            .into_iter()
+            .find(|child| child.kind() == "identifier")
+            .is_some_and(|first| first.id() == leaf.node.id())
+    {
+        return true;
+    }
     if DEFINITION_FIELD_BY_PARENT_TYPE
         .iter()
         .any(|(parent_type, definition_field)| {
@@ -210,6 +292,18 @@ fn is_structural_definition(leaf: &DepDegreeLeaf<'_>) -> bool {
 /// (C/C++ function-pointer or array parameters) is a parameter-ish node, or the identifier
 /// directly occupies a parameter field; type annotations and default values bind nothing.
 fn is_parameter_definition(leaf: &DepDegreeLeaf<'_>) -> bool {
+    // Kotlin has no `type`/`value` fields to veto default values: a function parameter's default
+    // sits in the parameter list (`fun f(b: Int = a)`), a class parameter's inside the parameter
+    // node (`class A(val y: Int = a)`), so only a parameter node's first identifier child binds.
+    if leaf.node.kind() == "simple_identifier" {
+        return leaf.node.parent().is_some_and(|parent| {
+            KOTLIN_PARAMETER_TYPES.contains(&parent.kind())
+                && crate::util::named_children(parent)
+                    .into_iter()
+                    .find(|child| child.kind() == "simple_identifier")
+                    .is_some_and(|first| first.id() == leaf.node.id())
+        });
+    }
     let mut current = leaf.node;
     let mut depth = 0usize;
     loop {

package/native/src/duplication.rs

@@ -8,7 +8,7 @@ use crate::types::{
     CrossFileCandidate, CrossFileToken, CrossFileTokenRange, DuplicateBlockOccurrence,
     DuplicationMetrics,
 };
-use crate::util::{all_children, named_children, node_text, to_int32, Source};
+use crate::util::{all_children, is_identifier_leaf, named_children, node_text, to_int32, Source};
 
 /// Block-like nodes considered as whole-subtree duplicate candidates; see duplication.ts.
 const DUPLICATE_BLOCK_TYPES: &[&str] = &[
@@ -50,6 +50,20 @@ const DUPLICATE_BLOCK_TYPES: &[&str] = &[
     "while_expression",
     "loop_expression",
     "match_expression",
+    "foreach_statement",
+    "switch_section",
+    "switch_expression_arm",
+    "using_statement",
+    "lock_statement",
+    "when_expression",
+    "when_entry",
+    "do_while_statement",
+    "catch_block",
+    "finally_block",
+    "statements",
+    "control_structure_body",
+    "function_body",
+    "jump_expression",
     "jsx_element",
     "jsx_self_closing_element",
     "if",
@@ -88,11 +102,54 @@ const STATEMENT_CONTAINER_TYPES: &[&str] = &[
     "type_case",
     "communication_case",
     "default_case",
+    "compilation_unit",
+    "switch_section",
+    "statements",
+    "enum_class_body",
+    "control_structure_body",
+    "function_body",
 ];
 
+/// C# type bodies are `declaration_list`s, a name Rust also uses for `mod`/`impl`/`trait` bodies;
+/// only the C# ones (under these parents) hold member runs scanned like Java's `class_body`.
+const CSHARP_DECLARATION_LIST_PARENT_TYPES: &[&str] = &[
+    "class_declaration",
+    "struct_declaration",
+    "interface_declaration",
+    "record_declaration",
+    "namespace_declaration",
+];
+
+/// Whole-subtree duplicate candidates: DUPLICATE_BLOCK_TYPES plus Kotlin's `try_expression`,
+/// distinguished by its clause children from Rust's `try_expression` (the `?` operator).
+fn is_duplicate_block(node: Node<'_>) -> bool {
+    if !node.is_named() {
+        return false;
+    }
+    if node.kind() == "try_expression" {
+        return crate::util::is_kotlin_try_expression(node);
+    }
+    DUPLICATE_BLOCK_TYPES.contains(&node.kind())
+}
+
+fn is_statement_container(node: Node<'_>) -> bool {
+    if !node.is_named() {
+        return false;
+    }
+    if node.kind() == "declaration_list" {
+        return node
+            .parent()
+            .is_some_and(|parent| CSHARP_DECLARATION_LIST_PARENT_TYPES.contains(&parent.kind()));
+    }
+    STATEMENT_CONTAINER_TYPES.contains(&node.kind())
+}
+
 /// Identifier leaves anonymized by occurrence order so consistently renamed copies still match.
 const ANONYMIZED_IDENTIFIER_TYPES: &[&str] = &[
     "identifier",
+    "simple_identifier",
+    "interpolated_identifier",
+    "implicit_parameter",
     "constant",
     "instance_variable",
     "class_variable",
@@ -112,6 +169,9 @@ const LITERAL_KIND_BY_TYPE: &[(&str, &str)] = &[
     ("float", "#num"),
     ("integer_literal", "#num"),
     ("float_literal", "#num"),
+    ("real_literal", "#num"),
+    ("hex_literal", "#num"),
+    ("bin_literal", "#num"),
     ("int_literal", "#num"),
     ("rune_literal", "#char"),
     ("imaginary_literal", "#num"),
@@ -124,6 +184,11 @@ const LITERAL_KIND_BY_TYPE: &[(&str, &str)] = &[
     ("string_fragment", "#str"),
     ("multiline_string_fragment", "#str"),
     ("string_content", "#str"),
+    ("string_literal_content", "#str"),
+    ("character_literal_content", "#char"),
+    ("character_escape_seq", "#char"),
+    ("verbatim_string_literal", "#str"),
+    ("interpolated_string_expression", "#str"),
     ("raw_string_content", "#str"),
     ("heredoc_content", "#str"),
     ("heredoc_beginning", "#heredoc"),
@@ -141,18 +206,31 @@ const LITERAL_KIND_BY_TYPE: &[(&str, &str)] = &[
     ("regex_pattern", "#regex"),
 ];
 
-const COMMENT_TYPES: &[&str] = &["comment", "line_comment", "block_comment"];
+const COMMENT_TYPES: &[&str] = &[
+    "comment",
+    "line_comment",
+    "block_comment",
+    "multiline_comment",
+];
 
 /// Children of a string node that carry only literal content; anything else is interpolation.
 const STRING_FRAGMENT_TYPES: &[&str] = &[
     "string_fragment",
     "multiline_string_fragment",
     "string_content",
+    "string_literal_content",
+    "character_literal_content",
+    "character_escape_seq",
     "raw_string_content",
+    "raw_string_start",
+    "raw_string_end",
     "escape_sequence",
     "heredoc_content",
     "string_start",
     "string_end",
+    "string_literal_encoding",
+    "interpolation_start",
+    "interpolation_quote",
 ];
 
 /// Grammar fields whose plain-`identifier` leaves are semantic API names, kept verbatim.
@@ -168,6 +246,32 @@ const SEMANTIC_NAME_FIELD_BY_PARENT_TYPE: &[(&str, &str)] = &[
     ("element_value_pair", "key"),
     ("generic_function", "function"),
     ("template_function", "name"),
+    ("invocation_expression", "function"),
+    ("member_access_expression", "name"),
+    ("member_binding_expression", "name"),
+    ("argument", "name"),
+];
+
+/// Rust's `Some(x)` variant patterns and Java's `uses Foo;` also put a plain identifier in a `type`
+/// field; they stay anonymized as before C# support. Rust's `generic_type` head is normally a
+/// `type_identifier` (kept verbatim like every type name); the entry covers the reserved-word
+/// heads the grammar spells as a plain identifier.
+const NON_CSHARP_TYPE_FIELD_PARENT_TYPES: &[&str] = &[
+    "tuple_struct_pattern",
+    "generic_type",
+    "uses_module_directive",
+];
+
+/// C# spells type names as plain `identifier`s (Java has `type_identifier`); an identifier under
+/// one of these parents, or in any other parent's `type` field, names a type and stays verbatim.
+const CSHARP_TYPE_PARENT_TYPES: &[&str] = &[
+    "generic_name",
+    "qualified_name",
+    "alias_qualified_name",
+    "type_argument_list",
+    "base_list",
+    "explicit_interface_specifier",
+    "using_directive",
 ];
 
 /// Kind tags whose raw source text re-enters the fingerprint in literal-dense (data-like) regions.
@@ -178,6 +282,9 @@ const STRING_CONTENT_FRAGMENT_TYPES: &[&str] = &[
     "string_fragment",
     "multiline_string_fragment",
     "string_content",
+    "string_literal_content",
+    "character_literal_content",
+    "character_escape_seq",
     "raw_string_content",
     "escape_sequence",
     "heredoc_content",
@@ -438,12 +545,12 @@ fn collect_tokens<'a>(
         container_statement_ranges: &mut Vec<Vec<TokenRange>>,
     ) -> TokenRange {
         let start_token_index = tokens.len();
-        let atomic_kind = if node.child_count() == 0 {
+        let atomic_kind = if is_identifier_leaf(node) {
             None
         } else {
             atomic_literal_kind(node)
         };
-        if node.child_count() == 0 {
+        if is_identifier_leaf(node) {
             append_leaf_token(node, code, tokens);
         } else if let Some(atomic_kind) = atomic_kind {
             // Interpolation-free strings collapse to their kind tag so copies differing only in
@@ -457,7 +564,7 @@ fn collect_tokens<'a>(
             ));
         } else if !COMMENT_TYPES.contains(&node.kind()) {
             let mut statement_ranges: Vec<TokenRange> = Vec::new();
-            let is_container = node.is_named() && STATEMENT_CONTAINER_TYPES.contains(&node.kind());
+            let is_container = is_statement_container(node);
             for child in all_children(node) {
                 let child_range = visit(
                     child,
@@ -485,7 +592,7 @@ fn collect_tokens<'a>(
             start_line: node.start_position().row + 1,
             end_line: node.end_position().row + 1,
         };
-        if node.is_named() && DUPLICATE_BLOCK_TYPES.contains(&node.kind()) {
+        if is_duplicate_block(node) {
             block_ranges.push(TokenRange { ..range });
         }
         range
@@ -549,9 +656,14 @@ fn append_leaf_token<'a>(node: Node<'_>, code: &Source<'a>, tokens: &mut Vec<Tok
         return;
     }
 
+    // A Kotlin bound callable-reference receiver (`xs::size`) renames like a variable unless it is
+    // PascalCase, the discriminator used for static receivers everywhere else.
+    let is_variable_receiver = crate::util::is_kotlin_callable_receiver(node)
+        && !pascal_case_regex().is_match(node_text(node, code));
     if node.is_named()
-        && ANONYMIZED_IDENTIFIER_TYPES.contains(&node.kind())
-        && !is_semantic_name_leaf(node, code)
+        && (is_variable_receiver
+            || (ANONYMIZED_IDENTIFIER_TYPES.contains(&node.kind())
+                && !is_semantic_name_leaf(node, code)))
     {
         tokens.push(Token {
             is_id: true,
@@ -637,7 +749,14 @@ fn literal_value_text<'a>(node: Node<'_>, kind: &str, code: &Source<'a>) -> Cow<
     if !fragments.is_empty() {
         return Cow::Owned(fragments.concat());
     }
-    Cow::Borrowed(strip_matching_quotes(node_text(node, code)))
+    // A C# verbatim string (`@"..."`) carries the same value as its ordinary spelling.
+    let text = node_text(node, code);
+    let text = if node.kind() == "verbatim_string_literal" {
+        text.strip_prefix('@').unwrap_or(text)
+    } else {
+        text
+    };
+    Cow::Borrowed(strip_matching_quotes(text))
 }
 
 /// Strips one matching pair of surrounding ASCII quotes, matching stripMatchingQuotes in
@@ -667,11 +786,63 @@ fn is_semantic_name_leaf(node: Node<'_>, code: &Source<'_>) -> bool {
         return false;
     };
 
-    // Java method references (`Foo::bar`) name their identifiers without grammar fields.
-    if parent.kind() == "method_reference" {
+    // Java method references (`Foo::bar`) and Kotlin callable references (`::bar`) name their
+    // identifiers without grammar fields.
+    if parent.kind() == "method_reference" || parent.kind() == "callable_reference" {
         return true;
     }
 
+    // C# type positions (see CSHARP_TYPE_PARENT_TYPES, plus any parent's `type` field, e.g.
+    // `new Foo()`) and attribute names (`[Obsolete]`, an `attribute` inside an `attribute_list`, or
+    // `[assembly: Foo]` inside a `global_attribute`; C/C++ attributes hang off other parents and
+    // Python's `attribute` has no `name` field).
+    if node.kind() == "identifier" {
+        let occupies = |field: &str| {
+            parent
+                .child_by_field_name(field)
+                .is_some_and(|field_node| field_node.id() == node.id())
+        };
+        let is_csharp_attribute = parent.kind() == "attribute"
+            && parent
+                .parent()
+                .is_some_and(|list| matches!(list.kind(), "attribute_list" | "global_attribute"));
+        if CSHARP_TYPE_PARENT_TYPES.contains(&parent.kind())
+            || (occupies("type") && !NON_CSHARP_TYPE_FIELD_PARENT_TYPES.contains(&parent.kind()))
+            || (is_csharp_attribute && occupies("name"))
+        {
+            return true;
+        }
+    }
+
+    // Kotlin (no grammar fields): a callee (`foo(...)`), a member name (`a.foo`), an infix function
+    // (`a shl b`), and a named argument (`foo(name = x)`) are API names.
+    if node.kind() == "simple_identifier" {
+        if parent.kind() == "navigation_suffix" {
+            return true;
+        }
+        let is_first_named = parent
+            .named_child(0)
+            .is_some_and(|first| first.id() == node.id());
+        if parent.kind() == "call_expression" && is_first_named {
+            return true;
+        }
+        if parent.kind() == "infix_expression"
+            && parent
+                .named_child(1)
+                .is_some_and(|operator| operator.id() == node.id())
+        {
+            return true;
+        }
+        if parent.kind() == "value_argument"
+            && is_first_named
+            && node
+                .next_sibling()
+                .is_some_and(|next| !next.is_named() && next.kind() == "=")
+        {
+            return true;
+        }
+    }
+
     // `call` names its callee `method` in Ruby but `function` in Python; accept both fields.
     if parent.kind() == "call"
         && parent
@@ -691,14 +862,22 @@ fn is_semantic_name_leaf(node: Node<'_>, code: &Source<'_>) -> bool {
         return true;
     }
 
-    // Java static receivers (`Alpha.run(...)`) name the invoked type; PascalCase is the
-    // discriminator because the tokenizer has no symbol table.
-    if parent.kind() == "method_invocation"
-        && parent
+    // Java/C# static receivers (`Alpha.run(...)`, `Console.WriteLine(...)`) name the invoked type;
+    // PascalCase is the discriminator because the tokenizer has no symbol table.
+    let is_static_receiver = match parent.kind() {
+        "method_invocation" => parent
             .child_by_field_name("object")
-            .is_some_and(|object| object.id() == node.id())
-        && pascal_case_regex().is_match(node_text(node, code))
-    {
+            .is_some_and(|object| object.id() == node.id()),
+        "member_access_expression" => parent
+            .child_by_field_name("expression")
+            .is_some_and(|receiver| receiver.id() == node.id()),
+        // Kotlin has no fields: the receiver is the first child of `navigation_expression`.
+        "navigation_expression" => parent
+            .named_child(0)
+            .is_some_and(|first| first.id() == node.id()),
+        _ => false,
+    };
+    if is_static_receiver && pascal_case_regex().is_match(node_text(node, code)) {
         return true;
     }