code-gauge 4.7.1 → 5.0.0

package/native/src/complexity.rs

@@ -11,6 +11,7 @@ pub struct LanguageSets {
     pub nesting_nodes: FxHashSet<&'static str>,
     pub ncss_nodes: FxHashSet<&'static str>,
     pub ncss_containers: FxHashSet<&'static str>,
+    pub ncss_bare_body_parents: FxHashSet<&'static str>,
 }
 
 impl LanguageSets {
@@ -21,6 +22,11 @@ impl LanguageSets {
             nesting_nodes: language.nesting_node_types.iter().copied().collect(),
             ncss_nodes: language.ncss_node_types.iter().copied().collect(),
             ncss_containers: language.ncss_container_node_types.iter().copied().collect(),
+            ncss_bare_body_parents: language
+                .ncss_bare_body_parent_node_types
+                .iter()
+                .copied()
+                .collect(),
         }
     }
 }
@@ -31,8 +37,6 @@ const BOOLEAN_OPERATOR_PARENT_TYPES: &[&str] = &[
     "binary_expression",
     "binary",
     "boolean_operator",
-    "conjunction_expression",
-    "disjunction_expression",
     // C# pattern combinators (`is > 0 and <= 10`) sequence like `&&`/`||` (SonarC#).
     "and_pattern",
     "or_pattern",
@@ -306,6 +310,7 @@ impl FunctionBodyPass<'_, '_, '_> {
             parent,
             &self.sets.ncss_nodes,
             &self.sets.ncss_containers,
+            &self.sets.ncss_bare_body_parents,
         );
         let ncss_frame = self.top_frame();
         ncss_frame.ncss += own_ncss;
@@ -313,6 +318,9 @@ impl FunctionBodyPass<'_, '_, '_> {
             ncss_frame.has_own_ncss_contribution = true;
         }
 
+        // Kotlin accessors hang off their property, yet are members of the class body.
+        let is_charged_property =
+            inside_charged_class_body && current.kind_name() == "property_declaration";
         for child in all_children(current) {
             self.visit(
                 child,
@@ -324,7 +332,8 @@ impl FunctionBodyPass<'_, '_, '_> {
                 } else {
                     inside_nested_region
                 },
-                is_charged_class_body,
+                is_charged_class_body
+                    || (is_charged_property && matches!(child.kind_name(), "getter" | "setter")),
             );
         }
 
@@ -358,7 +367,7 @@ impl FunctionBodyPass<'_, '_, '_> {
 }
 
 /// Plain else branches attached to `current`: an `else_clause`/Ruby `else` whose branch is not an
-/// `else if` continuation, or a bare Java/Go `alternative:` statement without a clause wrapper.
+/// `else if` continuation, or a bare Java/Go/Kotlin `alternative:` branch without a clause wrapper.
 fn count_plain_else_branches(current: Node<'_>, parent: Option<Node<'_>>) -> u64 {
     if !current.is_named() {
         return 0;
@@ -379,11 +388,6 @@ fn count_plain_else_branches(current: Node<'_>, parent: Option<Node<'_>>) -> u64
     if kind != "if_statement" && kind != "if_expression" {
         return 0;
     }
-    // Kotlin's `else` is a bare keyword token followed by the branch body (no clause wrapper and
-    // no grammar field); an `else if` continuation is charged on the nested if instead.
-    if let Some(else_body) = crate::util::kotlin_else_body(current) {
-        return u64::from(!crate::util::is_kotlin_else_if_body(else_body));
-    }
     // Extras (comments) inherit the preceding sibling's field in find_children_by_field_name, so a
     // comment between an `elif_clause` and `else_clause` must not be miscounted as a bare branch.
     crate::util::find_children_by_field_name(current, "alternative")
@@ -397,7 +401,10 @@ fn count_plain_else_branches(current: Node<'_>, parent: Option<Node<'_>>) -> u64
         .count() as u64
 }
 
-/// goto, and break/continue that jump to a label (their only named child is the label).
+/// goto, and break/continue that jump to a label.
+// Inlined into the recursive visit, its field lookup enlarges every frame enough to cut the depth the
+// Workers runtime's stack can measure by ~5%.
+#[inline(never)]
 fn is_flow_breaking_jump(node: Node<'_>) -> bool {
     if !node.is_named() {
         return false;
@@ -405,19 +412,13 @@ fn is_flow_breaking_jump(node: Node<'_>) -> bool {
     if node.kind_name() == "goto_statement" {
         return true;
     }
-    // Rust jumps are expressions; `break value` carries a named expression child, so only an
-    // explicit `label` child marks a labeled jump.
+    // Rust and Kotlin jumps are expressions; a Rust `break value` carries a named expression child,
+    // so only an explicit Rust `label` child or Kotlin `label` field marks a labeled jump.
     if node.kind_name() == "break_expression" || node.kind_name() == "continue_expression" {
-        return crate::util::named_children(node)
-            .iter()
-            .any(|child| child.kind_name() == "label" || child.kind_name() == "loop_label");
-    }
-    // Kotlin folds every jump into `jump_expression`; the grammar tokenizes a labeled break or
-    // continue as `break@`/`continue@` followed by the label (`return@label` is a plain return).
-    if node.kind_name() == "jump_expression" {
-        return node.child(0).is_some_and(|keyword| {
-            keyword.kind_name() == "break@" || keyword.kind_name() == "continue@"
-        });
+        return node.child_by_field_name("label").is_some()
+            || crate::util::named_children(node)
+                .iter()
+                .any(|child| child.kind_name() == "label" || child.kind_name() == "loop_label");
     }
     // Comments are named children too (`break /* done */;`), so only non-comment children mark a
     // label.
@@ -519,14 +520,8 @@ fn is_flat_chain_continuation(node: Node<'_>, parent: Option<Node<'_>>) -> bool
     let Some(parent) = parent else {
         return false;
     };
-    // Kotlin puts a braceless `else if` directly in the else branch's control_structure_body.
-    if parent.kind_name() == "control_structure_body" {
-        return parent
-            .parent_node()
-            .and_then(crate::util::kotlin_else_body)
-            .is_some_and(|else_body| else_body.id() == parent.id());
-    }
-    // JS/C/C++/Rust/C# wrap `else if` in an else clause or put it directly in `alternative`.
+    // 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"
         || parent
             .child_by_field_name("alternative")
@@ -638,9 +633,7 @@ fn is_default_switch_branch(node: Node<'_>, code: &Source<'_>) -> bool {
             .is_some_and(|first| is_csharp_catch_all_pattern(*first));
     }
     if kind == "when_entry" {
-        return !crate::util::named_children(node)
-            .iter()
-            .any(|child| child.kind_name() == "when_condition");
+        return node.child_by_field_name("condition").is_none();
     }
 
     // Python arms with an irrefutable pattern are unconditional like `default`.

package/native/src/dep_degree.rs

@@ -3,13 +3,11 @@ use tree_sitter::Node;
 
 use crate::complexity::is_function_boundary;
 use crate::tree_index::NodeExt;
-use crate::util::{is_identifier_leaf, node_text, Source};
+use crate::util::{node_text, Source};
 
 /// Leaf node types treated as variable references by the def-use approximation.
 const VARIABLE_NODE_TYPES: &[&str] = &[
     "identifier",
-    "simple_identifier",
-    "interpolated_identifier",
     "implicit_parameter",
     "instance_variable",
     "class_variable",
@@ -51,18 +49,10 @@ const DEFINITION_FIELD_BY_PARENT_TYPE: &[(&str, &str)] = &[
     ("from_clause", "name"),
 ];
 
-/// Kotlin has no grammar fields: an identifier directly under one of these declares a binding
+/// Kotlin marks no binding fields: an identifier directly under one of these declares a binding
 /// (`val x`, `for (x in xs)`, lambda parameters, and the `catch (e: T)` exception name).
 const KOTLIN_DEFINITION_PARENT_TYPES: &[&str] = &["variable_declaration", "catch_block"];
 
-/// Kotlin parameter nodes whose identifier child is the declared name; the parameter LIST nodes
-/// (`function_value_parameters`) also hold default-value expressions, which are reads.
-const KOTLIN_PARAMETER_TYPES: &[&str] = &[
-    "parameter",
-    "parameter_with_optional_type",
-    "class_parameter",
-];
-
 /// C# LINQ clauses that bind a range variable as their first identifier child (no grammar field):
 /// `join y in ...`, `into ys`, `let z = ...`, and a query continuation `into g`.
 const CSHARP_QUERY_BINDING_PARENT_TYPES: &[&str] = &[
@@ -133,7 +123,7 @@ pub fn measure_dep_degree(
     let mut pairs = 0u64;
     for index in 0..leaves.len() {
         let leaf = &leaves[index];
-        if !is_variable_leaf(leaf.node) {
+        if !is_variable_leaf(leaf) {
             continue;
         }
         let name = node_text(leaf.node, code);
@@ -161,11 +151,19 @@ pub fn measure_dep_degree(
 
 /// A C++ member-pointer variable (`int C::* p`, also `int C::* arr[1]`) is declared as a
 /// `type_identifier` under the `pointer_type_declarator` spelling `C::*`, possibly through further
-/// declarator wrappers; every other `type_identifier` names a type, not a variable.
-fn is_variable_leaf(node: Node<'_>) -> bool {
+/// declarator wrappers; every other `type_identifier` names a type, not a variable. Kotlin spells
+/// type names as identifiers: in a `user_type`, or as a type parameter's fieldless name (C# puts its
+/// type parameter in a `name` field).
+fn is_variable_leaf(leaf: &DepDegreeLeaf<'_>) -> bool {
+    let node = leaf.node;
+    if node.kind_name() == "type_identifier" {
+        return is_member_pointer_name(node);
+    }
     VARIABLE_NODE_TYPES.contains(&node.kind_name())
-        || crate::util::is_kotlin_callable_receiver(node)
-        || (node.kind_name() == "type_identifier" && is_member_pointer_name(node))
+        && !node.parent_node().is_some_and(|parent| {
+            parent.kind_name() == "user_type"
+                || (parent.kind_name() == "type_parameter" && leaf.field_name.is_none())
+        })
 }
 
 fn is_member_pointer_name(node: Node<'_>) -> bool {
@@ -232,11 +230,11 @@ fn collect_dep_degree_leaves<'t>(
 ) {
     if matches!(
         node.kind_name(),
-        "comment" | "line_comment" | "block_comment" | "multiline_comment"
+        "comment" | "line_comment" | "block_comment"
     ) {
         return;
     }
-    if is_identifier_leaf(node) {
+    if node.child_count() == 0 {
         leaves.push(DepDegreeLeaf {
             node,
             field_name,
@@ -297,7 +295,9 @@ fn is_structural_definition(leaf: &DepDegreeLeaf<'_>) -> bool {
     let Some(parent) = leaf.node.parent_node() else {
         return false;
     };
-    if leaf.node.kind_name() == "simple_identifier"
+    // C#'s `variable_declaration` holds its type in the `type` field; Kotlin's bound name has none.
+    if leaf.node.kind_name() == "identifier"
+        && leaf.field_name.is_none()
         && KOTLIN_DEFINITION_PARENT_TYPES.contains(&parent.kind_name())
     {
         return true;
@@ -368,18 +368,6 @@ fn unwrap_declarator_wrappers<'t>(leaf: &DepDegreeLeaf<'t>) -> (Node<'t>, Option
 /// (C/C++ function-pointer or array parameters) is a parameter-ish node, or the identifier
 /// directly occupies a parameter field; type annotations and default values bind nothing.
 fn is_parameter_definition(leaf: &DepDegreeLeaf<'_>) -> bool {
-    // Kotlin has no `type`/`value` fields to veto default values: a function parameter's default
-    // sits in the parameter list (`fun f(b: Int = a)`), a class parameter's inside the parameter
-    // node (`class A(val y: Int = a)`), so only a parameter node's first identifier child binds.
-    if leaf.node.kind_name() == "simple_identifier" {
-        return leaf.node.parent_node().is_some_and(|parent| {
-            KOTLIN_PARAMETER_TYPES.contains(&parent.kind_name())
-                && crate::util::named_children(parent)
-                    .into_iter()
-                    .find(|child| child.kind_name() == "simple_identifier")
-                    .is_some_and(|first| first.id() == leaf.node.id())
-        });
-    }
     let mut current = leaf.node;
     let mut depth = 0usize;
     // Only the member pointer's own declared name may climb past its qualified name; a size or
@@ -390,6 +378,19 @@ fn is_parameter_definition(leaf: &DepDegreeLeaf<'_>) -> bool {
         let Some(parent) = current.parent_node() else {
             return false;
         };
+        // Kotlin has no `type`/`value` fields to veto default values: a function parameter's default
+        // sits in the parameter list (`fun f(b: Int = a)`), a class parameter's inside the parameter
+        // node (`class A(val y: Int = a)`), so only such a node's first identifier child binds.
+        if parent.kind_name() == "function_value_parameters" {
+            return false;
+        }
+        if is_kotlin_parameter(parent) {
+            return depth == 0
+                && crate::util::named_children(parent)
+                    .into_iter()
+                    .find(|child| child.kind_name() == "identifier")
+                    .is_some_and(|first| first.id() == leaf.node.id());
+        }
         let parent_is_parameterish = parent.kind_name().contains("parameter");
         // Beyond the grandparent, only declarator wrappers keep climbing, plus the
         // `qualified_identifier` nodes that spell a member-pointer parameter's class (`int C::* q`,
@@ -427,6 +428,16 @@ fn is_parameter_definition(leaf: &DepDegreeLeaf<'_>) -> bool {
     }
 }
 
+/// A Kotlin class parameter, or a setter's parameter list (`set(value)`; Ruby's `setter` is a method
+/// name, never under a property).
+fn is_kotlin_parameter(node: Node<'_>) -> bool {
+    node.kind_name() == "class_parameter"
+        || (node.kind_name() == "setter"
+            && node
+                .parent_node()
+                .is_some_and(|property| property.kind_name() == "property_declaration"))
+}
+
 /// Only called with small-arity parents (declarator wrappers, definition-list holders).
 fn field_name_in_parent(node: Node<'_>, parent: Node<'_>) -> Option<&'static str> {
     for index in 0..parent.child_count() {

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,13 +199,28 @@ 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"];
+
+/// Declaration kinds that only name dependencies (imports, package clauses, includes).
+const DEPENDENCY_DECLARATION_TYPES: &[&str] = &[
+    "import_statement",
+    "import_from_statement",
+    "future_import_statement",
+    "import_alias",
+    "import_declaration",
+    "package_clause",
+    "package_declaration",
+    "package_header",
+    "use_declaration",
+    "extern_crate_declaration",
+    "using_directive",
+    "extern_alias_directive",
+    "preproc_include",
 ];
 
+/// Ruby methods that load another file, called without a receiver.
+const RUBY_REQUIRE_METHODS: &[&str] = &["require", "require_relative"];
+
 /// Children of a string node that carry only literal content; anything else is interpolation.
 const STRING_FRAGMENT_TYPES: &[&str] = &[
     "string_fragment",
@@ -222,7 +228,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 +291,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 +556,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
@@ -569,7 +573,7 @@ fn collect_tokens<'a>(
                 node.start_position().row,
                 node.end_position().row,
             ));
-        } else if !COMMENT_TYPES.contains(&node.kind_name()) {
+        } else if !is_tokenless(node, code) {
             let mut statement_ranges: Vec<TokenRange> = Vec::new();
             let is_container = is_statement_container(node);
             for child in all_children(node) {
@@ -580,7 +584,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()
+                    && !is_tokenless(child, code)
+                    && child.kind_name() != "lambda_parameters"
+                {
                     statement_ranges.push(child_range);
                 }
             }
@@ -609,6 +618,89 @@ fn collect_tokens<'a>(
     visit(root, code, tokens, block_ranges, container_statement_ranges);
 }
 
+/// 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 {
+    COMMENT_TYPES.contains(&node.kind_name()) || is_dependency_declaration(node, code)
+}
+
+/// Every module must spell out its own dependencies, so a clone made of them has no refactoring
+/// that could remove it; they are left out of clone detection entirely.
+fn is_dependency_declaration(node: Node<'_>, code: &Source<'_>) -> bool {
+    if !node.is_named() {
+        return false;
+    }
+    let kind = node.kind_name();
+    if DEPENDENCY_DECLARATION_TYPES.contains(&kind) {
+        return true;
+    }
+    match (crate::tree_index::language_name(), kind) {
+        // JavaScript's dynamic `import(...)` is a named `import` node too.
+        ("kotlin", "import") => true,
+        ("cpp", "using_declaration") => true,
+        // `mod name;` loads a file; a `mod name { ... }` with a body is code.
+        ("rust", "mod_item") => node.child_by_field_name("body").is_none(),
+        // Re-exports (`export { a } from './a'`); other exports wrap declarations.
+        ("javascript" | "jsx" | "typescript" | "tsx", "export_statement") => {
+            node.child_by_field_name("source").is_some()
+        }
+        (
+            "javascript" | "jsx" | "typescript" | "tsx",
+            "lexical_declaration" | "variable_declaration",
+        ) => is_require_declaration(node, code),
+        // `require('a');` and CommonJS re-exports such as `module.exports = require('a');`.
+        ("javascript" | "jsx" | "typescript" | "tsx", "expression_statement") => {
+            named_children(node).first().is_some_and(|expression| {
+                if expression.kind_name() == "assignment_expression" {
+                    expression
+                        .child_by_field_name("right")
+                        .is_some_and(|right| is_require_value(right, code))
+                } else {
+                    is_require_value(*expression, code)
+                }
+            })
+        }
+        ("ruby", "call") => {
+            node.child_by_field_name("receiver").is_none()
+                && node
+                    .child_by_field_name("method")
+                    .is_some_and(|method| RUBY_REQUIRE_METHODS.contains(&node_text(method, code)))
+        }
+        _ => false,
+    }
+}
+
+/// `const a = require('a')` (including destructuring and `require('a').b`) in every declarator.
+fn is_require_declaration(node: Node<'_>, code: &Source<'_>) -> bool {
+    let declarators: Vec<Node<'_>> = named_children(node)
+        .into_iter()
+        .filter(|child| child.kind_name() == "variable_declarator")
+        .collect();
+    !declarators.is_empty()
+        && declarators.iter().all(|declarator| {
+            declarator
+                .child_by_field_name("value")
+                .is_some_and(|value| is_require_value(value, code))
+        })
+}
+
+/// `require('a')` or a property read from it (`require('a').b`), but not a call on the module.
+fn is_require_value(node: Node<'_>, code: &Source<'_>) -> bool {
+    let mut value = node;
+    while value.kind_name() == "member_expression" {
+        let Some(object) = value.child_by_field_name("object") else {
+            return false;
+        };
+        value = object;
+    }
+    value.kind_name() == "call_expression"
+        && value
+            .child_by_field_name("function")
+            .is_some_and(|function| {
+                function.kind_name() == "identifier" && node_text(function, code) == "require"
+            })
+}
+
 /// The kind tag of a string-like node with no interpolation, or None to descend normally.
 fn atomic_literal_kind(node: Node<'_>) -> Option<&'static str> {
     let kind = if node.is_named() {
@@ -664,14 +756,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 +892,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 +927,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"