code-gauge 4.7.1 → 5.0.0

package/native/src/functions.rs

@@ -37,8 +37,8 @@ pub fn is_implemented_function(node: Node<'_>) -> bool {
             .is_some_and(|value| value.kind_name() == "arrow_expression_clause");
     }
 
-    // The Kotlin grammar has no fields; an implemented function or accessor holds a
-    // `function_body` child.
+    // Kotlin has no `body` field; an implemented function or accessor holds a `function_body`
+    // child.
     if node.kind_name() == "getter"
         || node.kind_name() == "setter"
         || node.kind_name() == "function_declaration"
@@ -175,7 +175,7 @@ fn find_parameters_node(node: Node<'_>) -> Option<Node<'_>> {
     if node.kind_name() == "setter"
         && named_children(node)
             .iter()
-            .any(|child| child.kind_name() == "parameter_with_optional_type")
+            .any(|child| child.kind_name() == "identifier")
     {
         return Some(node);
     }
@@ -343,14 +343,17 @@ pub fn find_function_name(node: Node<'_>, code: &Source<'_>) -> Option<String> {
     // (`run = { ... }`, `obj.run = { ... }`) takes the assigned name.
     if node.kind_name() == "lambda_literal" || node.kind_name() == "anonymous_function" {
         let mut holder = parent;
-        while holder.kind_name() == "prefix_expression" {
+        while matches!(
+            holder.kind_name(),
+            "labeled_expression" | "annotated_expression"
+        ) {
             holder = holder.parent_node()?;
         }
         if holder.kind_name() == "property_declaration" {
             return find_kotlin_property_name(holder, code);
         }
         if holder.kind_name() == "assignment" {
-            return find_kotlin_assignment_name(holder, code);
+            return find_assignment_target_name(holder, code);
         }
     }
     // A `lambda { }` / `proc { }` block is measured, but the call around it is what gets bound.
@@ -852,8 +855,8 @@ fn find_string_literal_content(literal: Node<'_>, code: &Source<'_>) -> Option<S
 }
 
 /// A compound assignment (`x += f`) does not bind the function to its target, so only a plain `=`
-/// names it. Grammars with an `operator` field (C/C++, C#, Java) expose it directly; Go and Kotlin
-/// have none, so the operator is the assignment's own anonymous token child.
+/// names it. Grammars with an `operator` field (C/C++, C#, Java, Kotlin) expose it directly; Go has
+/// none, so the operator is the assignment's own anonymous token child.
 fn is_plain_assignment(assignment: Node<'_>, code: &Source<'_>) -> bool {
     match assignment.child_by_field_name("operator") {
         Some(operator) => node_text(operator, code) == "=",
@@ -863,9 +866,9 @@ fn is_plain_assignment(assignment: Node<'_>, code: &Source<'_>) -> bool {
     }
 }
 
-/// The assigned identifier, or the member name of a JS member, Rust/C++ field, C# member, or Java
-/// field access (`a.b.run` names `run`) or a C++ qualified name (`N::run`); subscripts (`o["run"]`)
-/// name nothing.
+/// The assigned identifier, or the member name of a JS member, Rust/C++ field, C# member, Java
+/// field access, or Kotlin navigation (`a.b.run` names `run`) or a C++ qualified name (`N::run`);
+/// subscripts (`o["run"]`) name nothing.
 fn find_assignment_target_name(assignment: Node<'_>, code: &Source<'_>) -> Option<String> {
     if !is_plain_assignment(assignment, code) {
         return None;
@@ -877,34 +880,17 @@ fn find_assignment_target_name(assignment: Node<'_>, code: &Source<'_>) -> Optio
         "field_expression" => target.child_by_field_name("field")?,
         "member_access_expression" => target.child_by_field_name("name")?,
         "field_access" => target.child_by_field_name("field")?,
+        "navigation_expression" => target.named_child(target.named_child_count() - 1)?,
         "qualified_identifier" => return unwrap_declarator_name(Some(target), code),
         _ => return None,
     };
     Some(node_text(name, code).to_string())
 }
 
-/// The Kotlin assignment target: the variable itself or the member of a trailing navigation suffix
-/// (`obj.run` names `run`); a trailing indexing suffix (`arr[0] = { }`) names nothing, like
-/// subscripts in the other languages.
-fn find_kotlin_assignment_name(assignment: Node<'_>, code: &Source<'_>) -> Option<String> {
-    if !is_plain_assignment(assignment, code) {
-        return None;
-    }
-    let target = first_named_child_of_kind(assignment, "directly_assignable_expression")?;
-    let children = named_children(target);
-    let holder = match children.last()? {
-        last if last.kind_name() == "navigation_suffix" => *last,
-        last if last.kind_name() == "simple_identifier" && children.len() == 1 => target,
-        _ => return None,
-    };
-    first_named_child_of_kind(holder, "simple_identifier")
-        .map(|name| node_text(name, code).to_string())
-}
-
 /// Names of C# and Kotlin members whose grammars carry no usable `name` field: accessors are
 /// named after their property (`Count.get`; an expression-bodied property is its own getter),
-/// Kotlin functions by their identifier child, Kotlin secondary constructors and C# destructors
-/// after their class, and C# operators like C++ ones.
+/// Kotlin secondary constructors and C# destructors after their class, and C# operators like C++
+/// ones.
 fn find_member_function_name(node: Node<'_>, code: &Source<'_>) -> Option<String> {
     match node.kind_name() {
         "accessor_declaration" => {
@@ -923,20 +909,17 @@ fn find_member_function_name(node: Node<'_>, code: &Source<'_>) -> Option<String
             };
             Some(format!(
                 "{}.{keyword}",
-                find_kotlin_accessor_owner_name(node, code)?
+                find_kotlin_property_name(node.parent_node()?, code)?
             ))
         }
-        "function_declaration" if node.child_by_field_name("name").is_none() => {
-            first_named_child_of_kind(node, "simple_identifier")
-                .map(|name| node_text(name, code).to_string())
-        }
         "secondary_constructor" => {
             let mut ancestor = node.parent_node();
             while let Some(current) = ancestor {
                 if current.kind_name() == "class_declaration"
                     || current.kind_name() == "object_declaration"
                 {
-                    return first_named_child_of_kind(current, "type_identifier")
+                    return current
+                        .child_by_field_name("name")
                         .map(|name| node_text(name, code).to_string());
                 }
                 ancestor = current.parent_node();
@@ -967,38 +950,13 @@ fn csharp_property_name(owner: Node<'_>, code: &Source<'_>) -> Option<String> {
     }
 }
 
-/// The property a Kotlin accessor belongs to: its parent when the accessor follows the initializer
-/// on the same line, otherwise (accessor on its own line) the grammar emits it as a class-body
-/// sibling after the property, any preceding accessor, and any comments between them.
-fn find_kotlin_accessor_owner_name(accessor: Node<'_>, code: &Source<'_>) -> Option<String> {
-    if let Some(name) = accessor
-        .parent_node()
-        .and_then(|parent| find_kotlin_property_name(parent, code))
-    {
-        return Some(name);
-    }
-    let mut sibling = accessor.prev_named_sibling();
-    while let Some(current) = sibling {
-        if current.kind_name() == "property_declaration" {
-            return find_kotlin_property_name(current, code);
-        }
-        if !matches!(current.kind_name(), "getter" | "setter")
-            && !crate::ncss::COMMENT_NODE_TYPES.contains(&current.kind_name())
-        {
-            return None;
-        }
-        sibling = current.prev_named_sibling();
-    }
-    None
-}
-
 /// The declared name of a Kotlin `property_declaration` (`val name: T`), if it declares one.
 fn find_kotlin_property_name(property: Node<'_>, code: &Source<'_>) -> Option<String> {
     if property.kind_name() != "property_declaration" {
         return None;
     }
     let declaration = first_named_child_of_kind(property, "variable_declaration")?;
-    first_named_child_of_kind(declaration, "simple_identifier")
+    first_named_child_of_kind(declaration, "identifier")
         .map(|name| node_text(name, code).to_string())
 }
 

package/native/src/languages.rs

@@ -15,6 +15,9 @@ pub struct LanguageDefinition {
     pub nesting_node_types: &'static [&'static str],
     pub ncss_node_types: &'static [&'static str],
     pub ncss_container_node_types: &'static [&'static str],
+    /// Parents whose braceless `consequence`/`alternative`/`body` child counts like the single
+    /// statement of a braced body, for grammars that wrap it in no statement node.
+    pub ncss_bare_body_parent_node_types: &'static [&'static str],
 }
 
 #[derive(Clone, Copy)]
@@ -43,8 +46,8 @@ impl LanguageDefinition {
             GrammarId::CSharp => tree_sitter_c_sharp::language(),
             GrammarId::Go => tree_sitter_go::language(),
             GrammarId::Java => tree_sitter_java::language(),
-            GrammarId::JavaScript => tree_sitter_javascript::language(),
-            GrammarId::Kotlin => tree_sitter_kotlin::language(),
+            GrammarId::JavaScript => tree_sitter_javascript::LANGUAGE.into(),
+            GrammarId::Kotlin => tree_sitter_kotlin::LANGUAGE.into(),
             GrammarId::Python => tree_sitter_python::language(),
             GrammarId::Ruby => tree_sitter_ruby::language(),
             GrammarId::Rust => tree_sitter_rust::language(),
@@ -661,16 +664,21 @@ const KOTLIN_NCSS_NODES: &[&str] = &[
     "getter",
     "setter",
 ];
-// `control_structure_body` holds a braceless branch/loop body (`if (x) foo()`), which counts like
-// the single statement of a braced one; `function_body` holds an expression body (`fun f() = x`).
+// `function_body` holds an expression body (`fun f() = x`).
 const KOTLIN_NCSS_CONTAINERS: &[&str] = &[
     "source_file",
-    "import_list",
-    "statements",
+    "block",
     "class_body",
     "enum_class_body",
-    "control_structure_body",
     "function_body",
+    "lambda_literal",
+];
+const KOTLIN_NCSS_BARE_BODY_PARENTS: &[&str] = &[
+    "if_expression",
+    "for_statement",
+    "while_statement",
+    "do_while_statement",
+    "when_entry",
 ];
 
 pub const LANGUAGES: &[LanguageDefinition] = &[
@@ -684,6 +692,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         nesting_node_types: COMMON_NESTING_NODES,
         ncss_node_types: JS_NCSS_NODES,
         ncss_container_node_types: &[],
+        ncss_bare_body_parent_node_types: &[],
     },
     LanguageDefinition {
         name: "jsx",
@@ -695,6 +704,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         nesting_node_types: COMMON_NESTING_NODES,
         ncss_node_types: JS_NCSS_NODES,
         ncss_container_node_types: &[],
+        ncss_bare_body_parent_node_types: &[],
     },
     LanguageDefinition {
         name: "typescript",
@@ -706,6 +716,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         nesting_node_types: COMMON_NESTING_NODES,
         ncss_node_types: JS_NCSS_NODES,
         ncss_container_node_types: &[],
+        ncss_bare_body_parent_node_types: &[],
     },
     LanguageDefinition {
         name: "tsx",
@@ -717,6 +728,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         nesting_node_types: COMMON_NESTING_NODES,
         ncss_node_types: JS_NCSS_NODES,
         ncss_container_node_types: &[],
+        ncss_bare_body_parent_node_types: &[],
     },
     LanguageDefinition {
         name: "python",
@@ -728,6 +740,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         nesting_node_types: COMMON_NESTING_NODES,
         ncss_node_types: PYTHON_NCSS_NODES,
         ncss_container_node_types: &[],
+        ncss_bare_body_parent_node_types: &[],
     },
     LanguageDefinition {
         name: "go",
@@ -739,6 +752,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         nesting_node_types: GO_NESTING_NODES,
         ncss_node_types: GO_NCSS_NODES,
         ncss_container_node_types: &[],
+        ncss_bare_body_parent_node_types: &[],
     },
     LanguageDefinition {
         name: "rust",
@@ -750,6 +764,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         nesting_node_types: COMMON_NESTING_NODES,
         ncss_node_types: RUST_NCSS_NODES,
         ncss_container_node_types: RUST_NCSS_CONTAINERS,
+        ncss_bare_body_parent_node_types: &[],
     },
     LanguageDefinition {
         name: "java",
@@ -761,6 +776,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         nesting_node_types: JAVA_DECISION_NODES,
         ncss_node_types: JAVA_NCSS_NODES,
         ncss_container_node_types: &[],
+        ncss_bare_body_parent_node_types: &[],
     },
     LanguageDefinition {
         name: "ruby",
@@ -772,6 +788,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         nesting_node_types: RUBY_DECISION_NODES,
         ncss_node_types: RUBY_NCSS_NODES,
         ncss_container_node_types: RUBY_NCSS_CONTAINERS,
+        ncss_bare_body_parent_node_types: &[],
     },
     LanguageDefinition {
         name: "c",
@@ -783,6 +800,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         nesting_node_types: C_DECISION_NODES,
         ncss_node_types: C_NCSS_NODES,
         ncss_container_node_types: &[],
+        ncss_bare_body_parent_node_types: &[],
     },
     LanguageDefinition {
         name: "cpp",
@@ -794,6 +812,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         nesting_node_types: CPP_DECISION_NODES,
         ncss_node_types: CPP_NCSS_NODES,
         ncss_container_node_types: &[],
+        ncss_bare_body_parent_node_types: &[],
     },
     LanguageDefinition {
         name: "csharp",
@@ -805,6 +824,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         nesting_node_types: CSHARP_DECISION_NODES,
         ncss_node_types: CSHARP_NCSS_NODES,
         ncss_container_node_types: &[],
+        ncss_bare_body_parent_node_types: &[],
     },
     LanguageDefinition {
         name: "kotlin",
@@ -816,6 +836,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         nesting_node_types: KOTLIN_DECISION_NODES,
         ncss_node_types: KOTLIN_NCSS_NODES,
         ncss_container_node_types: KOTLIN_NCSS_CONTAINERS,
+        ncss_bare_body_parent_node_types: KOTLIN_NCSS_BARE_BODY_PARENTS,
     },
 ];
 

package/native/src/measure.rs

@@ -16,10 +16,7 @@ use crate::tree_index::{NodeExt, TreeIndex};
 use crate::types::{
     CrossFileFileData, FunctionMetrics, HalsteadCounts, LineMetrics, NativeMetrics,
 };
-use crate::util::{
-    all_children, is_identifier_leaf, is_js_whitespace, named_children, node_text, split_lines,
-    Source,
-};
+use crate::util::{all_children, is_js_whitespace, named_children, node_text, split_lines, Source};
 
 pub fn measure(
     code: &str,
@@ -166,23 +163,20 @@ fn is_csharp_top_level_statement(node: Node<'_>) -> bool {
 fn has_top_level_statements(root: Node<'_>, language: &LanguageDefinition) -> bool {
     const KOTLIN_DECLARATIONS: &[&str] = &[
         "package_header",
-        "import_list",
+        "import",
         "class_declaration",
         "object_declaration",
         "function_declaration",
         "property_declaration",
         "type_alias",
-        "shebang_line",
+        "shebang",
         "file_annotation",
-        "getter",
-        "setter",
     ];
     let children = named_children(root);
     match language.name {
         "csharp" => children.into_iter().any(is_csharp_top_level_statement),
-        // The grammar mis-parses some valid declarations (non-empty companion objects, `fun
-        // interface`) and leaves recovery residue at the top level, so a file with parse errors is
-        // never taken for a script.
+        // Error recovery leaves residue at the top level, so a file with parse errors is never taken
+        // for a script.
         "kotlin" => {
             !root.has_error()
                 && children.iter().any(|child| {
@@ -233,8 +227,6 @@ fn to_cross_file_data(
 /// Name-carrying leaf types anonymized by tokenize_function so consistent renames still match.
 const IDENTIFIER_LEAF_NODE_TYPES: &[&str] = &[
     "identifier",
-    "simple_identifier",
-    "interpolated_identifier",
     "implicit_parameter",
     "property_identifier",
     "field_identifier",
@@ -278,7 +270,7 @@ fn collect_token_symbols(
 ) {
     if matches!(
         node.kind_name(),
-        "comment" | "line_comment" | "block_comment" | "multiline_comment"
+        "comment" | "line_comment" | "block_comment"
     ) {
         return;
     }
@@ -286,12 +278,16 @@ fn collect_token_symbols(
         symbols.push(hash_text(node.kind_name()));
         return;
     }
-    if !is_identifier_leaf(node) {
+    if node.child_count() != 0 {
         for child in all_children(node) {
             collect_token_symbols(child, code, symbols, id_index_by_name);
         }
         return;
     }
+    if crate::util::is_kotlin_keyword_literal(node, code) {
+        symbols.push(hash_text(node_text(node, code)));
+        return;
+    }
     if IDENTIFIER_LEAF_NODE_TYPES.contains(&node.kind_name()) {
         let next_index = id_index_by_name.len();
         let index = *id_index_by_name
@@ -322,7 +318,7 @@ fn parse_source(
         .set_language(&language.grammar())
         .map_err(|error| error.to_string())?;
     parser
-        .parse_utf16(source.to_utf16(), None)
+        .parse_utf16_le(source.to_utf16(), None)
         .ok_or_else(|| "parse failed".to_string())
 }
 
@@ -380,7 +376,7 @@ fn collect_comment_spans(root: Node<'_>) -> Vec<CommentSpan> {
     fn visit(node: Node<'_>, spans: &mut Vec<CommentSpan>) {
         if matches!(
             node.kind_name(),
-            "comment" | "line_comment" | "block_comment" | "multiline_comment"
+            "comment" | "line_comment" | "block_comment"
         ) {
             for row in node.start_position().row..=node.end_position().row {
                 // Node columns are UTF-16 code units x 2 (the tree is parsed from UTF-16);
@@ -549,8 +545,6 @@ const OPERATOR_TEXTS: &[&str] = &[
 
 const OPERAND_NODE_TYPES: &[&str] = &[
     "identifier",
-    "simple_identifier",
-    "interpolated_identifier",
     "implicit_parameter",
     "property_identifier",
     "field_identifier",
@@ -578,8 +572,6 @@ const OPERAND_NODE_TYPES: &[&str] = &[
     "integer_literal",
     "float_literal",
     "real_literal",
-    "hex_literal",
-    "bin_literal",
     "int_literal",
     "rune_literal",
     "imaginary_literal",
@@ -614,13 +606,10 @@ const OPERAND_NODE_TYPES: &[&str] = &[
 ];
 
 /// Non-leaf literals counted as one Halstead operand without descending.
-/// `character_literal` is a leaf in Java and Kotlin but wraps a content node in C#; Kotlin's
-/// suffixed numbers (`1L`, `1u`) wrap the bare literal, so `1` and `1L` stay distinct.
+/// `character_literal` is a leaf in Java but wraps its content in C# and Kotlin.
 const ATOMIC_OPERAND_NODE_TYPES: &[&str] = &[
     "interpreted_string_literal",
     "character_literal",
-    "long_literal",
-    "unsigned_literal",
     "regex",
     "user_defined_literal",
     "integral_type",
@@ -656,7 +645,7 @@ fn measure_halstead(root: Node<'_>, code: &Source<'_>) -> HalsteadCounts {
     ) {
         if matches!(
             node.kind_name(),
-            "comment" | "line_comment" | "block_comment" | "multiline_comment"
+            "comment" | "line_comment" | "block_comment"
         ) {
             return;
         }
@@ -668,7 +657,7 @@ fn measure_halstead(root: Node<'_>, code: &Source<'_>) -> HalsteadCounts {
 
         // Operators are counted from leaf tokens only: keyword-named nodes always contain a
         // same-text anonymous keyword leaf, so counting the named node as well would double-count.
-        if is_identifier_leaf(node) {
+        if node.child_count() == 0 {
             let text = node_text(node, code);
             // Operands win over text matches so identifiers spelled like word operators stay operands;
             // C# `nameof(x)` is the one keyword operator the grammar parses as a plain callee.

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("");
     }
 }