code-gauge 4.7.1 → 4.8.0

package/native/src/duplication.rs

@@ -10,7 +10,7 @@ use crate::types::{
     CrossFileCandidate, CrossFileToken, CrossFileTokenRange, DuplicateBlockOccurrence,
     DuplicationMetrics,
 };
-use crate::util::{all_children, is_identifier_leaf, named_children, node_text, to_int32, Source};
+use crate::util::{all_children, named_children, node_text, to_int32, Source};
 
 /// Block-like nodes considered as whole-subtree duplicate candidates.
 const DUPLICATE_BLOCK_TYPES: &[&str] = &[
@@ -62,10 +62,7 @@ const DUPLICATE_BLOCK_TYPES: &[&str] = &[
     "do_while_statement",
     "catch_block",
     "finally_block",
-    "statements",
-    "control_structure_body",
     "function_body",
-    "jump_expression",
     "jsx_element",
     "jsx_self_closing_element",
     "if",
@@ -106,10 +103,9 @@ const STATEMENT_CONTAINER_TYPES: &[&str] = &[
     "default_case",
     "compilation_unit",
     "switch_section",
-    "statements",
     "enum_class_body",
-    "control_structure_body",
     "function_body",
+    "lambda_literal",
 ];
 
 /// C# type bodies are `declaration_list`s, a name Rust also uses for `mod`/`impl`/`trait` bodies;
@@ -122,8 +118,8 @@ const CSHARP_DECLARATION_LIST_PARENT_TYPES: &[&str] = &[
     "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).
+/// Whole-subtree duplicate candidates: DUPLICATE_BLOCK_TYPES plus Kotlin's `try_expression`, which
+/// shares its name with Rust's `?` operator (see is_kotlin_try_expression).
 fn is_duplicate_block(node: Node<'_>) -> bool {
     if !node.is_named() {
         return false;
@@ -149,8 +145,6 @@ fn is_statement_container(node: Node<'_>) -> bool {
 /// 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",
@@ -172,8 +166,6 @@ const LITERAL_KIND_BY_TYPE: &[(&str, &str)] = &[
     ("integer_literal", "#num"),
     ("float_literal", "#num"),
     ("real_literal", "#num"),
-    ("hex_literal", "#num"),
-    ("bin_literal", "#num"),
     ("int_literal", "#num"),
     ("rune_literal", "#char"),
     ("imaginary_literal", "#num"),
@@ -188,7 +180,6 @@ const LITERAL_KIND_BY_TYPE: &[(&str, &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"),
@@ -208,12 +199,7 @@ const LITERAL_KIND_BY_TYPE: &[(&str, &str)] = &[
     ("regex_pattern", "#regex"),
 ];
 
-const COMMENT_TYPES: &[&str] = &[
-    "comment",
-    "line_comment",
-    "block_comment",
-    "multiline_comment",
-];
+const COMMENT_TYPES: &[&str] = &["comment", "line_comment", "block_comment"];
 
 /// Children of a string node that carry only literal content; anything else is interpolation.
 const STRING_FRAGMENT_TYPES: &[&str] = &[
@@ -222,7 +208,6 @@ const STRING_FRAGMENT_TYPES: &[&str] = &[
     "string_content",
     "string_literal_content",
     "character_literal_content",
-    "character_escape_seq",
     "raw_string_content",
     "raw_string_start",
     "raw_string_end",
@@ -286,7 +271,6 @@ const STRING_CONTENT_FRAGMENT_TYPES: &[&str] = &[
     "string_content",
     "string_literal_content",
     "character_literal_content",
-    "character_escape_seq",
     "raw_string_content",
     "escape_sequence",
     "heredoc_content",
@@ -552,12 +536,12 @@ fn collect_tokens<'a>(
         container_statement_ranges: &mut Vec<Vec<TokenRange>>,
     ) -> TokenRange {
         let start_token_index = tokens.len();
-        let atomic_kind = if is_identifier_leaf(node) {
+        let atomic_kind = if node.child_count() == 0 {
             None
         } else {
             atomic_literal_kind(node)
         };
-        if is_identifier_leaf(node) {
+        if node.child_count() == 0 {
             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
@@ -580,7 +564,12 @@ fn collect_tokens<'a>(
                     block_ranges,
                     container_statement_ranges,
                 );
-                if is_container && child.is_named() && !COMMENT_TYPES.contains(&child.kind_name()) {
+                // A Kotlin lambda's parameters sit beside its statements.
+                if is_container
+                    && child.is_named()
+                    && !COMMENT_TYPES.contains(&child.kind_name())
+                    && child.kind_name() != "lambda_parameters"
+                {
                     statement_ranges.push(child_range);
                 }
             }
@@ -664,14 +653,19 @@ 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 crate::util::is_kotlin_keyword_literal(node, code) {
+        tokens.push(make_text_token(
+            Cow::Borrowed(node_text(node, code)),
+            None,
+            false,
+            start_row,
+            end_row,
+        ));
+        return;
+    }
     if node.is_named()
-        && (is_variable_receiver
-            || (ANONYMIZED_IDENTIFIER_TYPES.contains(&node.kind_name())
-                && !is_semantic_name_leaf(node, code)))
+        && ANONYMIZED_IDENTIFIER_TYPES.contains(&node.kind_name())
+        && !is_semantic_name_leaf(node, code)
     {
         tokens.push(Token {
             is_id: true,
@@ -795,8 +789,15 @@ fn is_semantic_name_leaf(node: Node<'_>, code: &Source<'_>) -> bool {
     };
 
     // Java method references (`Foo::bar`) and Kotlin callable references (`::bar`) name their
-    // identifiers without grammar fields.
-    if parent.kind_name() == "method_reference" || parent.kind_name() == "callable_reference" {
+    // identifiers without grammar fields, and Kotlin spells type names as identifiers.
+    if matches!(
+        parent.kind_name(),
+        "method_reference" | "callable_reference" | "user_type"
+    ) {
+        return true;
+    }
+    // A Kotlin type parameter's name has no field (C# puts its own in `name`).
+    if parent.kind_name() == "type_parameter" && parent.child_by_field_name("name").is_none() {
         return true;
     }
 
@@ -823,16 +824,30 @@ fn is_semantic_name_leaf(node: Node<'_>, code: &Source<'_>) -> bool {
         }
     }
 
-    // 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_name() == "simple_identifier" {
-        if parent.kind_name() == "navigation_suffix" {
-            return true;
-        }
+    // Kotlin (no callee or member fields): a callee (`foo(...)`, whose call ends in Kotlin's own
+    // argument nodes), a member name (`a.foo`), an infix function (`a shl b`), and a named
+    // argument (`foo(name = x)`) are API names.
+    if node.kind_name() == "identifier" {
         let is_first_named = parent
             .named_child(0)
             .is_some_and(|first| first.id() == node.id());
-        if parent.kind_name() == "call_expression" && is_first_named {
+        let is_last_named = parent
+            .named_child(parent.named_child_count().saturating_sub(1))
+            .is_some_and(|last| last.id() == node.id());
+        if parent.kind_name() == "navigation_expression" && is_last_named && !is_first_named {
+            return true;
+        }
+        if parent.kind_name() == "call_expression"
+            && is_first_named
+            && parent
+                .named_child(parent.named_child_count().saturating_sub(1))
+                .is_some_and(|arguments| {
+                    matches!(
+                        arguments.kind_name(),
+                        "value_arguments" | "annotated_lambda"
+                    )
+                })
+        {
             return true;
         }
         if parent.kind_name() == "infix_expression"

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.