code-gauge 4.7.1 → 4.8.0

package/native/src/ncss.rs

@@ -4,21 +4,14 @@ use tree_sitter::Node;
 use crate::tree_index::NodeExt;
 use crate::util::find_children_by_field_name;
 
-pub const COMMENT_NODE_TYPES: &[&str] = &[
-    "comment",
-    "line_comment",
-    "block_comment",
-    "multiline_comment",
-];
+pub const COMMENT_NODE_TYPES: &[&str] = &["comment", "line_comment", "block_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),
-/// 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).
+/// Ruby statement parentheses (transparent wrappers whose children count instead), Kotlin enum
+/// entries (Java enum constants are not counted either), and Kotlin lambda parameters (siblings of
+/// the lambda's statements). Kotlin's `try_expression` is excluded contextually below because Rust
+/// shares its name: Rust's `?` operator must keep counting as a tail expression.
 const POSITIONAL_EXCLUSION_TYPES: &[&str] = &[
     "attribute_item",
     "inner_attribute_item",
@@ -27,8 +20,9 @@ const POSITIONAL_EXCLUSION_TYPES: &[&str] = &[
     "parenthesized_statements",
     "annotation",
     "file_annotation",
-    "shebang_line",
+    "shebang",
     "enum_entry",
+    "lambda_parameters",
 ];
 
 /// TypeScript interface members count like Java interface members, but the same node types appear
@@ -66,6 +60,7 @@ pub fn ncss_contribution(
     parent: Option<Node<'_>>,
     countable: &FxHashSet<&'static str>,
     containers: &FxHashSet<&'static str>,
+    bare_body_parents: &FxHashSet<&'static str>,
 ) -> u64 {
     if !node.is_named()
         || COMMENT_NODE_TYPES.contains(&node.kind_name())
@@ -74,7 +69,7 @@ pub fn ncss_contribution(
         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.
+    // nothing of its own, so it must not count through its node type.
     if (node.kind_name() == "getter" || node.kind_name() == "setter")
         && !crate::functions::is_implemented_function(node)
     {
@@ -82,11 +77,13 @@ pub fn ncss_contribution(
     }
 
     let mut contribution = 0;
-    let positional = is_in_container_position(parent, containers)
-        && !containers.contains(node.kind_name())
+    // A Kotlin lambda holds its statements directly, so it is a container, yet it still counts where
+    // it stands like any other expression.
+    let positional = (is_in_container_position(parent, containers)
+        || is_bare_body(node, parent, bare_body_parents))
+        && (!containers.contains(node.kind_name()) || node.kind_name() == "lambda_literal")
         && !POSITIONAL_EXCLUSION_TYPES.contains(&node.kind_name())
-        && !crate::util::is_kotlin_try_expression(node)
-        && !(node.kind_name() == "label" && node.child_count() == 0);
+        && !crate::util::is_kotlin_try_expression(node);
     if (counts_through_node_type(node, countable)
         || positional
         || counts_contextually(node, parent))
@@ -95,12 +92,11 @@ pub fn ncss_contribution(
         contribution += 1;
     }
 
-    // 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.
+    // A bare else branch (Java/Go/Kotlin `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.
     if IF_NODE_TYPES.contains(&node.kind_name()) {
-        contribution += count_bare_alternatives(node)
-            + u64::from(crate::util::kotlin_else_body(node).is_some());
+        contribution += count_bare_alternatives(node);
     }
 
     contribution
@@ -137,6 +133,19 @@ fn is_in_container_position(
     false
 }
 
+/// A braceless branch or loop body (`if (x) foo()`) stands for the single statement a braced body
+/// would hold.
+fn is_bare_body(
+    node: Node<'_>,
+    parent: Option<Node<'_>>,
+    bare_body_parents: &FxHashSet<&'static str>,
+) -> bool {
+    parent.is_some_and(|parent| bare_body_parents.contains(parent.kind_name()))
+        && ["consequence", "alternative", "body"]
+            .iter()
+            .any(|field_name| is_field_of_parent(node, parent, field_name))
+}
+
 /// `export const x = 1` nests a countable declaration inside `export_statement`; only the inner
 /// declaration counts, mirroring how PMD counts one statement per declared entity.
 fn is_declaration_wrapper(node: Node<'_>, countable: &FxHashSet<&'static str>) -> bool {

package/native/src/tree_index.rs

@@ -12,6 +12,13 @@ thread_local! {
     static PARENTS: RefCell<FxHashMap<usize, Node<'static>>> = RefCell::new(FxHashMap::default());
     /// Node kind names of the indexed tree's language, indexed by kind id.
     static KIND_NAMES: Cell<&'static [&'static str]> = const { Cell::new(&[]) };
+    /// Name of the indexed tree's language.
+    static LANGUAGE_NAME: Cell<&'static str> = const { Cell::new("") };
+}
+
+/// The language of the tree indexed on this thread, or "" when none is.
+pub fn language_name() -> &'static str {
+    LANGUAGE_NAME.get()
 }
 
 /// Makes NodeExt lookups O(1) while the tree is being measured: tree-sitter's `Node::parent`
@@ -30,6 +37,7 @@ impl<'t> TreeIndex<'t> {
         // Constructed first so that the depth error below also clears the partial index on drop.
         let index = TreeIndex { tree: PhantomData };
         KIND_NAMES.set(language.kind_names());
+        LANGUAGE_NAME.set(language.name);
         PARENTS.with_borrow_mut(|parents| {
             assert!(
                 parents.is_empty(),
@@ -65,6 +73,7 @@ impl Drop for TreeIndex<'_> {
     fn drop(&mut self) {
         PARENTS.with_borrow_mut(|parents| parents.clear());
         KIND_NAMES.set(&[]);
+        LANGUAGE_NAME.set("");
     }
 }
 

package/native/src/util.rs

@@ -53,30 +53,12 @@ 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_name() == "type_identifier"
-        && node.parent_node().is_some_and(|parent| {
-            parent.kind_name() == "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_name(),
-            "simple_identifier" | "interpolated_identifier" | "type_identifier"
-        )
+/// Kotlin spells `true`, `false`, and `null` as plain identifiers, which the other grammars give
+/// literal node kinds of their own (an identifier with that text, e.g. Go's `null`, is a variable).
+pub fn is_kotlin_keyword_literal(node: Node<'_>, code: &Source<'_>) -> bool {
+    crate::tree_index::language_name() == "kotlin"
+        && node.kind_name() == "identifier"
+        && matches!(node_text(node, code), "true" | "false" | "null")
 }
 
 pub fn named_children<'t>(node: Node<'t>) -> Vec<Node<'t>> {
@@ -91,8 +73,8 @@ pub fn all_children<'t>(node: Node<'t>) -> Vec<Node<'t>> {
 
 /// Children carrying the field, with node-tree-sitter's vendored-core semantics: extra children
 /// (error-recovery nodes, comments) inherit the field of the preceding structural sibling.
-/// tree-sitter 0.22.6 instead reports no field for extras (ts_node_field_name_for_child gained an
-/// is_extra early return), which would desynchronize field-based extraction on malformed source.
+/// The core instead reports no field for extras (ts_node_field_name_for_child returns early for
+/// them), which would desynchronize field-based extraction on malformed source.
 pub fn find_children_by_field_name<'t>(node: Node<'t>, field_name: &str) -> Vec<Node<'t>> {
     let mut children = Vec::new();
     let mut preceding_structural_field: Option<&'static str> = None;
@@ -166,38 +148,11 @@ 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_name() != "if_expression" {
-        return None;
-    }
-    let children = all_children(if_node);
-    let else_index = children
-        .iter()
-        .position(|child| !child.is_named() && child.kind_name() == "else")?;
-    children[else_index + 1..]
-        .iter()
-        .copied()
-        .find(|child| child.kind_name() == "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.
+/// starts with the `try` keyword.
 pub fn is_kotlin_try_expression(node: Node<'_>) -> bool {
     node.kind_name() == "try_expression"
-        && named_children(node).iter().any(|child| {
-            matches!(
-                child.kind_name(),
-                "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_name() == "if_expression")
+        && node
+            .child(0)
+            .is_some_and(|keyword| !keyword.is_named() && keyword.kind_name() == "try")
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-gauge",
-  "version": "4.7.1",
+  "version": "4.8.0",
   "description": "Measure code metrics with tree-sitter.",
   "keywords": [
     "cli",
@@ -73,8 +73,8 @@
     "@types/node": "25.9.4",
     "@willbooster/oxfmt-config": "1.2.2",
     "@willbooster/oxlint-config": "1.4.8",
-    "@willbooster/wb": "22.7.1",
-    "build-ts": "21.0.16",
+    "@willbooster/wb": "22.8.0",
+    "build-ts": "21.0.19",
     "conventional-changelog-conventionalcommits": "9.3.1",
     "lefthook": "2.1.14",
     "oxfmt": "0.68.0",
@@ -94,12 +94,12 @@
     "registry": "https://registry.npmjs.org/"
   },
   "optionalDependencies": {
-    "code-gauge-linux-x64-gnu": "4.7.1",
-    "code-gauge-linux-arm64-gnu": "4.7.1",
-    "code-gauge-linux-x64-musl": "4.7.1",
-    "code-gauge-linux-arm64-musl": "4.7.1",
-    "code-gauge-darwin-x64": "4.7.1",
-    "code-gauge-darwin-arm64": "4.7.1",
-    "code-gauge-win32-x64-msvc": "4.7.1"
+    "code-gauge-linux-x64-gnu": "4.8.0",
+    "code-gauge-linux-arm64-gnu": "4.8.0",
+    "code-gauge-linux-x64-musl": "4.8.0",
+    "code-gauge-linux-arm64-musl": "4.8.0",
+    "code-gauge-darwin-x64": "4.8.0",
+    "code-gauge-darwin-arm64": "4.8.0",
+    "code-gauge-win32-x64-msvc": "4.8.0"
   }
 }