code-gauge 10.3.0 → 10.4.0

package/native/src/complexity.rs

@@ -302,11 +302,7 @@ impl FunctionBodyPass<'_, '_, '_> {
         let relative_nesting = current_nesting + function_nesting_bonus - entry_cognitive_nesting;
         let counts_for_own_body = !inside_nested_region && !opens_frame;
 
-        // Anonymous keyword tokens can share a type with named nodes (Ruby's `if` node contains an
-        // `if` keyword token), so only named nodes count as decisions.
-        let is_decision = current.is_named()
-            && self.sets.decision_nodes.contains(current.kind_name())
-            && !is_pathless_switch_branch(current, self.code);
+        let is_decision = self.is_decision(current);
         let is_case_clause =
             current.is_named() && CASE_CLAUSE_NODE_TYPES.contains(&current.kind_name());
         // Ruby's `case ... else` arm is an `else` node; like every other language's default branch
@@ -513,6 +509,15 @@ impl FunctionBodyPass<'_, '_, '_> {
         }
     }
 
+    fn is_decision(&self, node: Node<'_>) -> bool {
+        // Anonymous keyword tokens can share a type with named nodes (Ruby's `if` node contains an
+        // `if` keyword token), so only named nodes count as decisions.
+        node.is_named()
+            && (self.sets.decision_nodes.contains(node.kind_name())
+                || crate::util::is_else_if_clause(node))
+            && !is_pathless_switch_branch(node)
+    }
+
     fn top_frame(&mut self) -> &mut FunctionBodyFrame {
         self.frames
             .last_mut()
@@ -534,6 +539,9 @@ fn count_plain_else_branches(current: Node<'_>, parent: Option<Node<'_>>) -> u64
         return u64::from(!is_case_else_parent(parent));
     }
     if kind == "else_clause" {
+        if crate::util::is_else_if_clause(current) {
+            return 0;
+        }
         let has_if_like_child = crate::util::named_children(current)
             .iter()
             .any(|child| IF_LIKE_NODE_TYPES.contains(&child.kind_name()));
@@ -671,10 +679,11 @@ fn is_pattern_guard(node: Node<'_>, parent: Option<Node<'_>>) -> bool {
             .any(|child| !child.is_named() && child.kind_name() == "if")
 }
 
-/// Ruby `elsif`, Python `elif`, and `else if` (an if node in an else/alternative position).
+/// Ruby `elsif`, Python `elif`, Rust `else if` clauses, and `else if` (an if node in an
+/// else/alternative position).
 fn is_flat_chain_continuation(node: Node<'_>, parent: Option<Node<'_>>) -> bool {
     let kind = node.kind_name();
-    if kind == "elsif" || kind == "elif_clause" {
+    if kind == "elsif" || kind == "elif_clause" || crate::util::is_else_if_clause(node) {
         return true;
     }
     if kind != "if_statement" && kind != "if_expression" && kind != "if" {
@@ -683,9 +692,9 @@ fn is_flat_chain_continuation(node: Node<'_>, parent: Option<Node<'_>>) -> bool
     let Some(parent) = parent else {
         return false;
     };
-    // JS/C/C++/Rust/C# wrap `else if` in an else clause; Java/Go/Kotlin put it directly in
-    // `alternative`.
-    parent.kind_name() == "else_clause"
+    // JS/C/C++/C# wrap `else if` in an else clause; Java/Go/Kotlin put it directly in
+    // `alternative`. An if inside a Rust else-if clause is its condition, not a continuation.
+    (parent.kind_name() == "else_clause" && !crate::util::is_else_if_clause(parent))
         || parent
             .child_by_field_name("alternative")
             .is_some_and(|alternative| alternative.id() == node.id())
@@ -696,7 +705,7 @@ fn is_flat_chain_continuation(node: Node<'_>, parent: Option<Node<'_>>) -> bool
 /// unless one of its stacked labels is an unguarded default or catch-all (`case 3: default: g();`
 /// and `default: case 3: g();` are the default outcome) or all of them are catch-alls. Guards are
 /// charged separately, so a guarded catch-all never absorbs a case stacked with it.
-fn is_pathless_switch_branch(node: Node<'_>, code: &Source<'_>) -> bool {
+fn is_pathless_switch_branch(node: Node<'_>) -> bool {
     if is_label_only_case(node) {
         return true;
     }
@@ -713,10 +722,8 @@ fn is_pathless_switch_branch(node: Node<'_>, code: &Source<'_>) -> bool {
     }
     stacked
         .iter()
-        .any(|label| is_default_switch_branch(*label, code) && !has_pattern_guard(*label))
-        || stacked
-            .iter()
-            .all(|label| is_default_switch_branch(*label, code))
+        .any(|label| is_default_switch_branch(*label) && !has_pattern_guard(*label))
+        || stacked.iter().all(|label| is_default_switch_branch(*label))
 }
 
 /// A guard directly on the arm (C# `when`, Python `if`, Ruby `if`/`unless`) or inside its label or
@@ -754,7 +761,7 @@ fn is_label_only_case(node: Node<'_>) -> bool {
     }
 }
 
-fn is_default_switch_branch(node: Node<'_>, code: &Source<'_>) -> bool {
+fn is_default_switch_branch(node: Node<'_>) -> bool {
     let kind = node.kind_name();
     if kind == "switch_default" {
         return true;
@@ -764,17 +771,16 @@ fn is_default_switch_branch(node: Node<'_>, code: &Source<'_>) -> bool {
     }
 
     // Java `default:` groups and `default ->` rules: a label with no expression or pattern, or a
-    // `case null, default` label, whose `default` the grammar parses as an identifier.
+    // `case null, default` label, which holds the `default` keyword after the `null`.
     if kind == "switch_block_statement_group" || kind == "switch_rule" {
         return non_comment_children(node)
             .into_iter()
             .filter(|child| child.kind_name() == "switch_label")
             .any(|label| {
-                let parts = non_comment_children(label);
-                parts.is_empty()
-                    || parts.iter().any(|part| {
-                        part.kind_name() == "identifier" && node_text(*part, code) == "default"
-                    })
+                non_comment_children(label).is_empty()
+                    || crate::util::all_children(label)
+                        .iter()
+                        .any(|part| !part.is_named() && part.kind_name() == "default")
             });
     }
 

package/native/src/duplication.rs

@@ -234,6 +234,7 @@ const STRING_FRAGMENT_TYPES: &[&str] = &[
     "raw_string_content",
     "interpreted_string_literal_content",
     "raw_string_literal_content",
+    "format_specifier",
     "raw_string_start",
     "raw_string_end",
     "escape_sequence",
@@ -299,6 +300,7 @@ const STRING_CONTENT_FRAGMENT_TYPES: &[&str] = &[
     "raw_string_content",
     "interpreted_string_literal_content",
     "raw_string_literal_content",
+    "format_specifier",
     "escape_sequence",
     "heredoc_content",
 ];
@@ -570,6 +572,9 @@ fn collect_tokens<'a>(
         statement_list_statements: &mut Vec<TokenRange>,
     ) -> TokenRange {
         let start_token_index = tokens.len();
+        // The span of the node's tokens, which can be narrower than the node: a Python block
+        // starts at its header's colon, and a Rust declaration starts at its doc comment.
+        let mut token_span: Option<SourceSpan> = None;
         let is_token = is_token(node);
         let atomic_kind = if is_token {
             None
@@ -602,6 +607,7 @@ fn collect_tokens<'a>(
                     container_statement_ranges,
                     &mut child_statements,
                 );
+                token_span = widen_token_span(token_span, &child_range);
                 // A Kotlin lambda's parameters sit beside its statements.
                 if is_container
                     && child.is_named()
@@ -625,13 +631,19 @@ fn collect_tokens<'a>(
             }
         }
 
-        let range = TokenRange {
-            start_token_index,
-            end_token_index: tokens.len(),
+        let span = token_span.unwrap_or(SourceSpan {
             start_index: node.start_byte(),
             end_index: node.end_byte(),
             start_line: node.start_position().row + 1,
             end_line: node.end_position().row + 1,
+        });
+        let range = TokenRange {
+            start_token_index,
+            end_token_index: tokens.len(),
+            start_index: span.start_index,
+            end_index: span.end_index,
+            start_line: span.start_line,
+            end_line: span.end_line,
         };
         if is_duplicate_block(node) {
             block_ranges.push(TokenRange { ..range });
@@ -649,6 +661,28 @@ fn collect_tokens<'a>(
     );
 }
 
+#[derive(Clone, Copy)]
+struct SourceSpan {
+    start_index: usize,
+    end_index: usize,
+    start_line: usize,
+    end_line: usize,
+}
+
+/// `span` extended to the end of `child`'s tokens, or `child`'s token span when `span` is empty;
+/// a child without tokens leaves it as it is.
+fn widen_token_span(span: Option<SourceSpan>, child: &TokenRange) -> Option<SourceSpan> {
+    if child.start_token_index == child.end_token_index {
+        return span;
+    }
+    Some(SourceSpan {
+        start_index: span.map_or(child.start_index, |span| span.start_index),
+        end_index: child.end_index,
+        start_line: span.map_or(child.start_line, |span| span.start_line),
+        end_line: child.end_line,
+    })
+}
+
 /// Comments and dependency declarations contribute no tokens, so no clone consists of them; the
 /// tokens around them stay adjacent, so a clone may still extend across one.
 fn is_tokenless(node: Node<'_>, code: &Source<'_>) -> bool {

package/native/src/functions.rs

@@ -71,11 +71,13 @@ pub fn count_parameters(node: Node<'_>, code: &Source<'_>) -> usize {
         return 0;
     };
 
-    // A Java bare lambda parameter (`x -> x + 1`) puts a lone identifier in the `parameters` field;
-    // a C# one (`x => x + 1`) is an `implicit_parameter` leaf.
-    if parameters_node.kind_name() == "identifier"
-        || parameters_node.kind_name() == "implicit_parameter"
-    {
+    // A Java bare lambda parameter (`x -> x + 1`, `_ -> 1`) puts a lone identifier or unnamed
+    // `underscore_pattern` in the `parameters` field; a C# one (`x => x + 1`) is an
+    // `implicit_parameter` leaf.
+    if matches!(
+        parameters_node.kind_name(),
+        "identifier" | "underscore_pattern" | "implicit_parameter"
+    ) {
         return 1;
     }
     // Kotlin default values (`x: Int = 0`) are siblings of their `parameter`, not children.
@@ -127,12 +129,7 @@ pub fn count_parameters(node: Node<'_>, code: &Source<'_>) -> usize {
             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 + usize::from(!csharp_params_array_ids.is_empty())
+    count + usize::from(!csharp_params_array_ids.is_empty())
 }
 
 /// C/C++ `int f(void)` has a `parameter_declaration` whose type is a bare `void` with no declarator.
@@ -907,7 +904,8 @@ pub fn find_string_literal_content(literal: Node<'_>, code: &Source<'_>) -> Opti
             "string_content"
             | "string_fragment"
             | "interpreted_string_literal_content"
-            | "raw_string_literal_content" => {
+            | "raw_string_literal_content"
+            | "format_specifier" => {
                 has_content_node = true;
                 content.push_str(node_text(*child, code));
             }

package/native/src/languages.rs

@@ -434,9 +434,8 @@ const RUST_NCSS_NODES: &[&str] = &[
     "else_clause",
     "match_arm",
 ];
-// `else_clause` is a container so `else if` chains count the nested if_expression; a plain
-// `else { ... }` is unaffected because its only child is a `block`, itself a container.
-const RUST_NCSS_CONTAINERS: &[&str] = &["block", "else_clause"];
+
+const RUST_NCSS_CONTAINERS: &[&str] = &["block"];
 
 const JAVA_NCSS_NODES: &[&str] = &[
     "package_declaration",

package/native/src/ncss.rs

@@ -8,9 +8,9 @@ pub const COMMENT_NODE_TYPES: &[&str] = &["comment", "line_comment", "block_comm
 
 /// 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 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
+/// TRANSPARENT_WRAPPER_TYPES (their 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",
@@ -18,6 +18,7 @@ const POSITIONAL_EXCLUSION_TYPES: &[&str] = &[
     "empty_statement",
     "heredoc_body",
     "parenthesized_statements",
+    "attributed_declaration",
     "annotation",
     "file_annotation",
     "shebang",
@@ -92,6 +93,12 @@ pub fn ncss_contribution(
         contribution += 1;
     }
 
+    // A Rust `else if` clause also stands for the `if` that other grammars nest in their else
+    // clause and charge separately.
+    if crate::util::is_else_if_clause(node) {
+        contribution += 1;
+    }
+
     // 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.
@@ -117,15 +124,19 @@ fn counts_through_node_type(node: Node<'_>, countable: &FxHashSet<&'static str>)
     true
 }
 
-/// Direct container children count positionally; Ruby's `(foo; bar)` statement parentheses are
-/// transparent, so their children count when the parentheses themselves sit in a container.
+/// Ruby's `(foo; bar)` statement parentheses and Rust's attributes-plus-declaration pairs: their
+/// children count when the wrapper itself sits in a container.
+const TRANSPARENT_WRAPPER_TYPES: &[&str] = &["parenthesized_statements", "attributed_declaration"];
+
+/// Direct container children count positionally, as do the children of TRANSPARENT_WRAPPER_TYPES
+/// in that position.
 fn is_in_container_position(
     parent: Option<Node<'_>>,
     containers: &FxHashSet<&'static str>,
 ) -> bool {
     let mut ancestor = parent;
     while let Some(current) = ancestor {
-        if current.kind_name() != "parenthesized_statements" {
+        if !TRANSPARENT_WRAPPER_TYPES.contains(&current.kind_name()) {
             return containers.contains(current.kind_name());
         }
         ancestor = current.parent_node();
@@ -238,12 +249,18 @@ fn counts_contextually(node: Node<'_>, parent: Option<Node<'_>>) -> bool {
             child.kind_name() == "declaration" || child.kind_name() == "function_definition"
         });
     }
-    // A Rust item-position macro invocation (`foo! {}` at module level) has no expression_statement
-    // wrapper; the semicolon form does and already counts through it.
-    if node.kind_name() == "macro_invocation"
-        && (parent_kind == Some("source_file") || parent_kind == Some("declaration_list"))
-    {
-        return true;
+    // A Rust item-position macro invocation (`foo! {}` at module level, possibly attributed) has no
+    // expression_statement wrapper; the semicolon form does and already counts through it.
+    if node.kind_name() == "macro_invocation" {
+        let item_parent = match parent {
+            Some(wrapper) if wrapper.kind_name() == "attributed_declaration" => {
+                wrapper.parent_node()
+            }
+            _ => parent,
+        };
+        return item_parent.is_some_and(|item_parent| {
+            matches!(item_parent.kind_name(), "source_file" | "declaration_list")
+        });
     }
     // Go struct fields and interface members count like other languages' member declarations, but
     // only inside a named type declaration; inline anonymous types (`var x struct{ ... }`,

package/native/src/util.rs

@@ -155,6 +155,12 @@ pub fn to_int32(value: i64) -> i32 {
     value as i32
 }
 
+/// A Rust `else if`: tree-sitter-rust flattens the chain into `else_clause`s that hold the
+/// condition of the `if` they continue, while a final `else` holds only its block.
+pub fn is_else_if_clause(node: Node<'_>) -> bool {
+    node.kind_name() == "else_clause" && node.child_by_field_name("condition").is_some()
+}
+
 /// Kotlin's `try { } catch { }` shares its node kind with Rust's `?` operator; only the Kotlin form
 /// starts with the `try` keyword.
 pub fn is_kotlin_try_expression(node: Node<'_>) -> bool {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-gauge",
-  "version": "10.3.0",
+  "version": "10.4.0",
   "description": "Measure code metrics with tree-sitter.",
   "keywords": [
     "cli",
@@ -72,15 +72,15 @@
     "@tsconfig/bun": "1.0.10",
     "@tsconfig/node-lts": "24.0.0",
     "@tsconfig/node-ts": "23.6.4",
-    "@types/bun": "1.4.3",
+    "@types/bun": "1.4.4",
     "@types/node": "25.9.4",
     "@willbooster/oxlint-config": "1.4.9",
-    "@willbooster/wb": "22.29.3",
-    "build-ts": "21.0.29",
+    "@willbooster/wb": "23.0.2",
+    "build-ts": "21.0.31",
     "conventional-changelog-conventionalcommits": "9.3.1",
     "lefthook": "2.2.2",
-    "oxlint": "1.88.0",
-    "oxlint-tsgolint": "7.0.2004",
+    "oxlint": "1.89.0",
+    "oxlint-tsgolint": "7.0.2005",
     "semantic-release": "25.0.5",
     "vitest": "4.1.9",
     "wrangler": "4.135.0"
@@ -89,12 +89,12 @@
     "node": ">=24"
   },
   "optionalDependencies": {
-    "code-gauge-linux-x64-gnu": "10.3.0",
-    "code-gauge-linux-arm64-gnu": "10.3.0",
-    "code-gauge-linux-x64-musl": "10.3.0",
-    "code-gauge-linux-arm64-musl": "10.3.0",
-    "code-gauge-darwin-x64": "10.3.0",
-    "code-gauge-darwin-arm64": "10.3.0",
-    "code-gauge-win32-x64-msvc": "10.3.0"
+    "code-gauge-linux-x64-gnu": "10.4.0",
+    "code-gauge-linux-arm64-gnu": "10.4.0",
+    "code-gauge-linux-x64-musl": "10.4.0",
+    "code-gauge-linux-arm64-musl": "10.4.0",
+    "code-gauge-darwin-x64": "10.4.0",
+    "code-gauge-darwin-arm64": "10.4.0",
+    "code-gauge-win32-x64-msvc": "10.4.0"
   }
 }