code-gauge 4.1.3 → 4.2.0

package/native/src/ncss.rs

@@ -3,17 +3,31 @@ use tree_sitter::Node;
 
 use crate::util::{all_children, find_children_by_field_name};
 
-pub const COMMENT_NODE_TYPES: &[&str] = &["comment", "line_comment", "block_comment"];
+pub const COMMENT_NODE_TYPES: &[&str] = &[
+    "comment",
+    "line_comment",
+    "block_comment",
+    "multiline_comment",
+];
 
 /// Nodes never counted positionally inside NCSS containers: metadata, empty statements, Ruby
 /// heredoc bodies (tree-sitter emits them as siblings of the statement that opened the heredoc),
-/// and Ruby statement parentheses (transparent wrappers whose children count instead).
+/// Ruby statement parentheses (transparent wrappers whose children count instead), Kotlin
+/// annotations (siblings of the statement they decorate), and Kotlin enum entries (Java enum
+/// constants are not counted either). Two Kotlin kinds are excluded contextually below because
+/// Rust shares their names: `try_expression` (Rust's `?` operator must keep counting as a tail
+/// expression) and `label` (a Rust block label `'outer:` stands for the labeled statement the
+/// other languages count, while a Kotlin `outer@` is a childless token beside its statement).
 const POSITIONAL_EXCLUSION_TYPES: &[&str] = &[
     "attribute_item",
     "inner_attribute_item",
     "empty_statement",
     "heredoc_body",
     "parenthesized_statements",
+    "annotation",
+    "file_annotation",
+    "shebang_line",
+    "enum_entry",
 ];
 
 /// TypeScript interface members count like Java interface members, but the same node types appear
@@ -75,21 +89,32 @@ pub fn ncss_contribution(
     if !node.is_named() || COMMENT_NODE_TYPES.contains(&node.kind()) || is_for_header_node(node) {
         return 0;
     }
+    // A Kotlin accessor without a body (`private set`) only changes visibility and declares
+    // nothing of its own; it parses as a sibling of its property and must not count positionally.
+    if (node.kind() == "getter" || node.kind() == "setter")
+        && !crate::functions::is_implemented_function(node)
+    {
+        return 0;
+    }
 
     let mut contribution = 0;
     let positional = is_in_container_position(node, containers)
         && !containers.contains(node.kind())
-        && !POSITIONAL_EXCLUSION_TYPES.contains(&node.kind());
+        && !POSITIONAL_EXCLUSION_TYPES.contains(&node.kind())
+        && !crate::util::is_kotlin_try_expression(node)
+        && !(node.kind() == "label" && node.child_count() == 0);
     if (counts_through_node_type(node, countable) || positional || counts_contextually(node))
         && !is_declaration_wrapper(node, countable)
     {
         contribution += 1;
     }
 
-    // A bare else branch (Java/Go `alternative:` without an else-clause wrapper) counts 1 like the
-    // `else` keyword does in PMD; an `else if` chain charges the nested if separately on top.
+    // A bare else branch (Java/Go `alternative:` without an else-clause wrapper, or Kotlin's bare
+    // `else` keyword) counts 1 like the `else` keyword does in PMD; an `else if` chain charges the
+    // nested if separately on top.
     if IF_NODE_TYPES.contains(&node.kind()) {
-        contribution += count_bare_alternatives(node);
+        contribution += count_bare_alternatives(node)
+            + u64::from(crate::util::kotlin_else_body(node).is_some());
     }
 
     contribution

package/native/src/util.rs

@@ -51,6 +51,32 @@ pub fn node_text<'a>(node: Node<'_>, code: &Source<'a>) -> &'a str {
     &code.code[code.utf8_offset(node.start_byte())..code.utf8_offset(node.end_byte())]
 }
 
+/// Kotlin spells the bound receiver of a callable reference (`xs::size`) as a `type_identifier`,
+/// the same kind as an unbound type (`List::size`); the receiver position is what distinguishes
+/// it, and only a visible definition then tells a variable from a type.
+pub fn is_kotlin_callable_receiver(node: Node<'_>) -> bool {
+    node.kind() == "type_identifier"
+        && node.parent().is_some_and(|parent| {
+            parent.kind() == "callable_reference"
+                && parent
+                    .named_child(0)
+                    .is_some_and(|first| first.id() == node.id())
+        })
+}
+
+/// Whether the node is a leaf for token-level walks. Kotlin soft keywords used as names (`value`,
+/// `data`, `get`, ...) parse as a `simple_identifier` — or its aliases `interpolated_identifier`
+/// (`"$value"`) and `type_identifier` (`value::size`) — wrapping an anonymous keyword token, so a
+/// plain leaf check would see the keyword instead of the identifier. Every other grammar's
+/// identifier kinds are already leaves.
+pub fn is_identifier_leaf(node: Node<'_>) -> bool {
+    node.child_count() == 0
+        || matches!(
+            node.kind(),
+            "simple_identifier" | "interpolated_identifier" | "type_identifier"
+        )
+}
+
 pub fn named_children<'t>(node: Node<'t>) -> Vec<Node<'t>> {
     let mut cursor = node.walk();
     node.named_children(&mut cursor).collect()
@@ -137,3 +163,36 @@ pub fn is_js_whitespace(character: char) -> bool {
 pub fn to_int32(value: i64) -> i32 {
     value as i32
 }
+
+/// The body following a Kotlin `if_expression`'s bare `else` keyword (the grammar has no else
+/// clause node and no fields), or None for other languages' if nodes and else-less ifs.
+pub fn kotlin_else_body(if_node: Node<'_>) -> Option<Node<'_>> {
+    if if_node.kind() != "if_expression" {
+        return None;
+    }
+    let children = all_children(if_node);
+    let else_index = children
+        .iter()
+        .position(|child| !child.is_named() && child.kind() == "else")?;
+    children[else_index + 1..]
+        .iter()
+        .copied()
+        .find(|child| child.kind() == "control_structure_body")
+}
+
+/// Kotlin's `try { } catch { }` shares its node kind with Rust's `?` operator; only the Kotlin form
+/// holds a body or clause child.
+pub fn is_kotlin_try_expression(node: Node<'_>) -> bool {
+    node.kind() == "try_expression"
+        && named_children(node)
+            .iter()
+            .any(|child| matches!(child.kind(), "statements" | "catch_block" | "finally_block"))
+}
+
+/// Whether a Kotlin else body is a braceless `else if`: the nested if sits directly in the
+/// control_structure_body, whereas a braced `else { if ... }` wraps it in `statements`.
+pub fn is_kotlin_else_if_body(else_body: Node<'_>) -> bool {
+    named_children(else_body)
+        .iter()
+        .any(|child| child.kind() == "if_expression")
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-gauge",
-  "version": "4.1.3",
+  "version": "4.2.0",
   "description": "Measure code metrics with tree-sitter.",
   "keywords": [
     "cli",
@@ -10,6 +10,8 @@
     "cognitive-complexity",
     "ncss",
     "duplication",
+    "csharp",
+    "kotlin",
     "refactoring"
   ],
   "repository": {
@@ -87,12 +89,12 @@
     "registry": "https://registry.npmjs.org/"
   },
   "optionalDependencies": {
-    "code-gauge-linux-x64-gnu": "4.1.3",
-    "code-gauge-linux-arm64-gnu": "4.1.3",
-    "code-gauge-linux-x64-musl": "4.1.3",
-    "code-gauge-linux-arm64-musl": "4.1.3",
-    "code-gauge-darwin-x64": "4.1.3",
-    "code-gauge-darwin-arm64": "4.1.3",
-    "code-gauge-win32-x64-msvc": "4.1.3"
+    "code-gauge-linux-x64-gnu": "4.2.0",
+    "code-gauge-linux-arm64-gnu": "4.2.0",
+    "code-gauge-linux-x64-musl": "4.2.0",
+    "code-gauge-linux-arm64-musl": "4.2.0",
+    "code-gauge-darwin-x64": "4.2.0",
+    "code-gauge-darwin-arm64": "4.2.0",
+    "code-gauge-win32-x64-msvc": "4.2.0"
   }
 }