code-gauge 4.8.0 → 5.1.0

package/native/Cargo.lock

@@ -45,18 +45,18 @@ dependencies = [
  "rustc-hash",
  "serde",
  "serde_json",
- "tree-sitter",
- "tree-sitter-c",
- "tree-sitter-c-sharp",
- "tree-sitter-cpp",
  "tree-sitter-go",
  "tree-sitter-java",
- "tree-sitter-javascript",
  "tree-sitter-python",
  "tree-sitter-ruby",
- "tree-sitter-rust",
- "tree-sitter-typescript",
+ "willbooster-tree-sitter",
+ "willbooster-tree-sitter-c",
+ "willbooster-tree-sitter-c-sharp",
+ "willbooster-tree-sitter-cpp",
+ "willbooster-tree-sitter-javascript",
  "willbooster-tree-sitter-kotlin",
+ "willbooster-tree-sitter-rust",
+ "willbooster-tree-sitter-typescript",
 ]
 
 [[package]]
@@ -425,141 +425,141 @@ dependencies = [
 ]
 
 [[package]]
-name = "tree-sitter"
-version = "0.25.10"
+name = "tree-sitter-go"
+version = "0.25.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78f873475d258561b06f1c595d93308a7ed124d9977cb26b148c2084a4a3cc87"
+checksum = "c8560a4d2f835cc0d4d2c2e03cbd0dde2f6114b43bc491164238d333e28b16ea"
 dependencies = [
  "cc",
- "regex",
- "regex-syntax",
- "serde_json",
- "streaming-iterator",
  "tree-sitter-language",
 ]
 
 [[package]]
-name = "tree-sitter-c"
-version = "0.21.4"
+name = "tree-sitter-java"
+version = "0.23.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f956d5351d62652864a4ff3ae861747e7a1940dc96c9998ae400ac0d3ce30427"
+checksum = "0aa6cbcdc8c679b214e616fd3300da67da0e492e066df01bcf5a5921a71e90d6"
 dependencies = [
  "cc",
- "tree-sitter",
+ "tree-sitter-language",
 ]
 
 [[package]]
-name = "tree-sitter-c-sharp"
-version = "0.21.3"
+name = "tree-sitter-language"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8997ad04502208449025114e434c9024a33a74e700513c702a9d2cac6522a771"
-dependencies = [
- "cc",
- "tree-sitter",
-]
+checksum = "ca0d1bf6fdd806e43ae5198f82f527056d359def39e54e67a0f478ac09dac081"
 
 [[package]]
-name = "tree-sitter-cpp"
-version = "0.22.3"
+name = "tree-sitter-python"
+version = "0.25.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d509a22a992790d38f2c291961ff8a1ff016c437c7ec6befc9220b8eec8918c"
+checksum = "6bf85fd39652e740bf60f46f4cda9492c3a9ad75880575bf14960f775cb74a1c"
 dependencies = [
  "cc",
- "tree-sitter",
+ "tree-sitter-language",
 ]
 
 [[package]]
-name = "tree-sitter-go"
-version = "0.21.2"
+name = "tree-sitter-ruby"
+version = "0.23.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8d702a98d3c7e70e466456e58ff2b1ac550bf1e29b97e5770676d2fdabec00d"
+checksum = "be0484ea4ef6bb9c575b4fdabde7e31340a8d2dbc7d52b321ac83da703249f95"
 dependencies = [
  "cc",
- "tree-sitter",
+ "tree-sitter-language",
 ]
 
 [[package]]
-name = "tree-sitter-java"
-version = "0.21.0"
+name = "unicode-ident"
+version = "1.0.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33bc21adf831a773c075d9d00107ab43965e6a6ea7607b47fd9ec6f3db4b481b"
-dependencies = [
- "cc",
- "tree-sitter",
-]
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
 
 [[package]]
-name = "tree-sitter-javascript"
-version = "0.25.0"
+name = "unicode-segmentation"
+version = "1.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68204f2abc0627a90bdf06e605f5c470aa26fdcb2081ea553a04bdad756693f5"
+checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8"
+
+[[package]]
+name = "willbooster-tree-sitter"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c6ca3007235ade028b793d6090a5ea16618ea3ab9b53427d1f782b15bf64064"
 dependencies = [
  "cc",
+ "regex",
+ "serde_json",
+ "streaming-iterator",
  "tree-sitter-language",
 ]
 
 [[package]]
-name = "tree-sitter-language"
-version = "0.1.8"
+name = "willbooster-tree-sitter-c"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca0d1bf6fdd806e43ae5198f82f527056d359def39e54e67a0f478ac09dac081"
+checksum = "5cee6f1a4e0f64f337d28aeaed73879d7e8a87d77c287afb989ce29adea54700"
+dependencies = [
+ "cc",
+ "tree-sitter-language",
+]
 
 [[package]]
-name = "tree-sitter-python"
-version = "0.21.0"
+name = "willbooster-tree-sitter-c-sharp"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4066c6cf678f962f8c2c4561f205945c84834cce73d981e71392624fdc390a9"
+checksum = "99b224dcd59cda9b24b588557cca3827abaccaf10da72d125c31e7cdb2e6f7fb"
 dependencies = [
  "cc",
- "tree-sitter",
+ "tree-sitter-language",
 ]
 
 [[package]]
-name = "tree-sitter-ruby"
-version = "0.21.0"
+name = "willbooster-tree-sitter-cpp"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0031f687c0772f2dad7b77104c43428611099a1804c81244ada21560f41f0b1"
+checksum = "72b92a9fcb0dc27bd4af18e06fe6c085dd14d91f009f60ecd92c0308b9cbd068"
 dependencies = [
  "cc",
- "tree-sitter",
+ "tree-sitter-language",
 ]
 
 [[package]]
-name = "tree-sitter-rust"
-version = "0.21.2"
+name = "willbooster-tree-sitter-javascript"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "277690f420bf90741dea984f3da038ace46c4fe6047cba57a66822226cde1c93"
+checksum = "e6c40d41b303b525194daa503a71ec94d8269fe8d1648b2d9138fe902623beff"
 dependencies = [
  "cc",
- "tree-sitter",
+ "tree-sitter-language",
 ]
 
 [[package]]
-name = "tree-sitter-typescript"
-version = "0.21.2"
+name = "willbooster-tree-sitter-kotlin"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ecb35d98a688378e56c18c9c159824fd16f730ccbea19aacf4f206e5d5438ed9"
+checksum = "529ae914939b559754e6dd8b34d2705f04d6dcb73f09cb52f024b49eda9b5b88"
 dependencies = [
  "cc",
- "tree-sitter",
+ "tree-sitter-language",
 ]
 
 [[package]]
-name = "unicode-ident"
-version = "1.0.24"
+name = "willbooster-tree-sitter-rust"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+checksum = "324c9f18cfc29e4da7335ad8cb76beb6ac1ae91a8037a44724bc55fce04f26f7"
+dependencies = [
+ "cc",
+ "tree-sitter-language",
+]
 
 [[package]]
-name = "unicode-segmentation"
-version = "1.13.3"
+name = "willbooster-tree-sitter-typescript"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8"
-
-[[package]]
-name = "willbooster-tree-sitter-kotlin"
-version = "0.0.0"
-source = "git+https://github.com/WillBooster/tree-sitter-kotlin?tag=v1.1.0#a05912e6f07e2cedd44bfb117940361089d4c3e3"
+checksum = "f8c51b6c9e10d6ae34c2f84c4d44fff79a0210890ede63fda558a6a0f042eb28"
 dependencies = [
  "cc",
  "tree-sitter-language",

package/native/Cargo.toml

@@ -16,27 +16,22 @@ regex = "1"
 rustc-hash = "2"
 
 # Grammar crates are pinned exactly: every metric (and the golden-based test suite) is calibrated
-# against these grammar versions, so upgrades are deliberate, test-verified changes. The Kotlin
-# grammar is WillBooster's fork, which is not on crates.io, pinned to a release tag. Core 0.25 is
-# the first to load that grammar's ABI 15 parser, and tree-sitter-javascript 0.21.x pins
-# `cc ~1.0`, which conflicts with the core's `cc ^1.2`, hence 0.25.0. The core reports no field for
-# extra (error-recovery) children in ts_node_field_name_for_child, which
-# util::find_children_by_field_name compensates for.
-tree-sitter = "=0.25.10"
-tree-sitter-c = "=0.21.4"
-tree-sitter-c-sharp = "=0.21.3"
-tree-sitter-cpp = "=0.22.3"
-tree-sitter-go = "=0.21.2"
-tree-sitter-java = "=0.21.0"
-tree-sitter-kotlin = { package = "willbooster-tree-sitter-kotlin", git = "https://github.com/WillBooster/tree-sitter-kotlin", tag = "v1.1.0" }
-tree-sitter-javascript = "=0.25.0"
-tree-sitter-python = "=0.21.0"
-tree-sitter-ruby = "=0.21.0"
-# 0.21.0 breaks MSVC (its build script passes the GCC-only -Wno-unused-parameter
-# unconditionally; cl.exe fails with D8021); 0.21.2 gates the flag and the golden-based test
-# suite verifies its grammar changes leave every measured metric unchanged.
-tree-sitter-rust = "=0.21.2"
-tree-sitter-typescript = "=0.21.2"
+# against these grammar versions, so upgrades are deliberate, test-verified changes. The
+# `willbooster-*` crates are WillBooster's forks of the runtime and grammars. Every grammar crate
+# depends only on `tree-sitter-language`, never on upstream's `tree-sitter` crate, whose
+# `links = "tree-sitter"` would conflict with the forked runtime's.
+tree-sitter = { package = "willbooster-tree-sitter", version = "1" }
+tree-sitter-c = { package = "willbooster-tree-sitter-c", version = "=1.1.0" }
+tree-sitter-c-sharp = { package = "willbooster-tree-sitter-c-sharp", version = "=1.0.3" }
+tree-sitter-cpp = { package = "willbooster-tree-sitter-cpp", version = "=1.1.1" }
+tree-sitter-go = "=0.25.0"
+tree-sitter-java = "=0.23.5"
+tree-sitter-javascript = { package = "willbooster-tree-sitter-javascript", version = "=1.0.3" }
+tree-sitter-kotlin = { package = "willbooster-tree-sitter-kotlin", version = "=1.4.0" }
+tree-sitter-python = "=0.25.0"
+tree-sitter-ruby = "=0.23.1"
+tree-sitter-rust = { package = "willbooster-tree-sitter-rust", version = "=1.1.1" }
+tree-sitter-typescript = { package = "willbooster-tree-sitter-typescript", version = "=1.1.1" }
 
 # The WebAssembly build (src/wasm.rs) exports a plain C ABI instead of N-API.
 [target.'cfg(not(target_family = "wasm"))'.dependencies]

package/native/src/dep_degree.rs

@@ -93,7 +93,7 @@ const NON_BINDING_PARAMETER_FIELDS: &[&str] = &["type", "value"];
 /// One leaf of the def-use walk: its field in the parent and its function-scope chain.
 struct DepDegreeLeaf<'t> {
     node: Node<'t>,
-    field_name: Option<&'static str>,
+    field_name: Option<&'t str>,
     /// Chain of nested-function scope ids below the measured function: "" for its own body,
     /// then "/0", "/0/1", ...
     scope: String,
@@ -221,7 +221,7 @@ fn implicit_accessor_definitions<'a>(function_node: Node<'_>, code: &Source<'a>)
 #[allow(clippy::too_many_arguments)]
 fn collect_dep_degree_leaves<'t>(
     node: Node<'t>,
-    field_name: Option<&'static str>,
+    field_name: Option<&'t str>,
     scope: &str,
     next_scope_id: &mut usize,
     function_nodes: &FxHashSet<&'static str>,
@@ -234,7 +234,7 @@ fn collect_dep_degree_leaves<'t>(
     ) {
         return;
     }
-    if node.child_count() == 0 {
+    if crate::util::is_token(node) {
         leaves.push(DepDegreeLeaf {
             node,
             field_name,
@@ -341,7 +341,7 @@ fn is_definition_field(holder: Node<'_>, field_name: Option<&str>) -> bool {
 /// fieldless child; a member pointer's `pointer_type_declarator` is the `name` of a
 /// `qualified_identifier`; an `array_declarator` size or a nested parameter has another field and
 /// stops the climb) to the outermost wrapper and its field in the declaration.
-fn unwrap_declarator_wrappers<'t>(leaf: &DepDegreeLeaf<'t>) -> (Node<'t>, Option<&'static str>) {
+fn unwrap_declarator_wrappers<'t>(leaf: &DepDegreeLeaf<'t>) -> (Node<'t>, Option<&'t str>) {
     let mut current = leaf.node;
     let mut field_name = leaf.field_name;
     while let Some(parent) = current
@@ -439,11 +439,11 @@ fn is_kotlin_parameter(node: Node<'_>) -> bool {
 }
 
 /// Only called with small-arity parents (declarator wrappers, definition-list holders).
-fn field_name_in_parent(node: Node<'_>, parent: Node<'_>) -> Option<&'static str> {
+fn field_name_in_parent<'t>(node: Node<'_>, parent: Node<'t>) -> Option<&'t str> {
     for index in 0..parent.child_count() {
         if let Some(child) = parent.child(index) {
             if child.id() == node.id() {
-                return parent.field_name_for_child(index as u32);
+                return parent.field_name_for_child(index);
             }
         }
     }

package/native/src/duplication.rs

@@ -10,7 +10,7 @@ use crate::types::{
     CrossFileCandidate, CrossFileToken, CrossFileTokenRange, DuplicateBlockOccurrence,
     DuplicationMetrics,
 };
-use crate::util::{all_children, named_children, node_text, to_int32, Source};
+use crate::util::{all_children, is_token, named_children, node_text, to_int32, Source};
 
 /// Block-like nodes considered as whole-subtree duplicate candidates.
 const DUPLICATE_BLOCK_TYPES: &[&str] = &[
@@ -103,6 +103,7 @@ const STATEMENT_CONTAINER_TYPES: &[&str] = &[
     "default_case",
     "compilation_unit",
     "switch_section",
+    "extension_body",
     "enum_class_body",
     "function_body",
     "lambda_literal",
@@ -201,6 +202,26 @@ const LITERAL_KIND_BY_TYPE: &[(&str, &str)] = &[
 
 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",
@@ -209,6 +230,8 @@ const STRING_FRAGMENT_TYPES: &[&str] = &[
     "string_literal_content",
     "character_literal_content",
     "raw_string_content",
+    "interpreted_string_literal_content",
+    "raw_string_literal_content",
     "raw_string_start",
     "raw_string_end",
     "escape_sequence",
@@ -272,6 +295,8 @@ const STRING_CONTENT_FRAGMENT_TYPES: &[&str] = &[
     "string_literal_content",
     "character_literal_content",
     "raw_string_content",
+    "interpreted_string_literal_content",
+    "raw_string_literal_content",
     "escape_sequence",
     "heredoc_content",
 ];
@@ -528,20 +553,25 @@ fn collect_tokens<'a>(
     block_ranges: &mut Vec<TokenRange>,
     container_statement_ranges: &mut Vec<Vec<TokenRange>>,
 ) {
+    /// `statement_list_statements` receives the statements of a Go `statement_list`, which wraps
+    /// the statements of blocks and case clauses and whose statements belong to the run of the
+    /// enclosing container.
     fn visit<'a>(
         node: Node<'_>,
         code: &Source<'a>,
         tokens: &mut Vec<Token<'a>>,
         block_ranges: &mut Vec<TokenRange>,
         container_statement_ranges: &mut Vec<Vec<TokenRange>>,
+        statement_list_statements: &mut Vec<TokenRange>,
     ) -> TokenRange {
         let start_token_index = tokens.len();
-        let atomic_kind = if node.child_count() == 0 {
+        let is_token = is_token(node);
+        let atomic_kind = if is_token {
             None
         } else {
             atomic_literal_kind(node)
         };
-        if node.child_count() == 0 {
+        if is_token {
             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
@@ -553,30 +583,39 @@ 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);
+            let is_statement_list = node.kind_name() == "statement_list";
+            let is_container = is_statement_list || is_statement_container(node);
             for child in all_children(node) {
+                let mut child_statements = Vec::new();
                 let child_range = visit(
                     child,
                     code,
                     tokens,
                     block_ranges,
                     container_statement_ranges,
+                    &mut child_statements,
                 );
                 // A Kotlin lambda's parameters sit beside its statements.
                 if is_container
                     && child.is_named()
-                    && !COMMENT_TYPES.contains(&child.kind_name())
+                    && !is_tokenless(child, code)
                     && child.kind_name() != "lambda_parameters"
                 {
-                    statement_ranges.push(child_range);
+                    if child.kind_name() == "statement_list" {
+                        statement_ranges.append(&mut child_statements);
+                    } else {
+                        statement_ranges.push(child_range);
+                    }
                 }
             }
-            // Single-statement containers are recorded too: window enumeration needs two
-            // statements and yields nothing for them, but cross-file matching catalogues each
-            // container's full run.
-            if is_container && !statement_ranges.is_empty() {
+            if is_statement_list {
+                *statement_list_statements = statement_ranges;
+            } else if is_container && !statement_ranges.is_empty() {
+                // Single-statement containers are recorded too: window enumeration needs two
+                // statements and yields nothing for them, but cross-file matching catalogues each
+                // container's full run.
                 container_statement_ranges.push(statement_ranges);
             }
         }
@@ -595,7 +634,97 @@ fn collect_tokens<'a>(
         range
     }
 
-    visit(root, code, tokens, block_ranges, container_statement_ranges);
+    visit(
+        root,
+        code,
+        tokens,
+        block_ranges,
+        container_statement_ranges,
+        &mut Vec::new(),
+    );
+}
+
+/// 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.
@@ -832,7 +961,7 @@ fn is_semantic_name_leaf(node: Node<'_>, code: &Source<'_>) -> bool {
             .named_child(0)
             .is_some_and(|first| first.id() == node.id());
         let is_last_named = parent
-            .named_child(parent.named_child_count().saturating_sub(1))
+            .named_child(parent.named_child_count().saturating_sub(1) as u32)
             .is_some_and(|last| last.id() == node.id());
         if parent.kind_name() == "navigation_expression" && is_last_named && !is_first_named {
             return true;
@@ -840,7 +969,7 @@ fn is_semantic_name_leaf(node: Node<'_>, code: &Source<'_>) -> bool {
         if parent.kind_name() == "call_expression"
             && is_first_named
             && parent
-                .named_child(parent.named_child_count().saturating_sub(1))
+                .named_child(parent.named_child_count().saturating_sub(1) as u32)
                 .is_some_and(|arguments| {
                     matches!(
                         arguments.kind_name(),

package/native/src/functions.rs

@@ -821,13 +821,16 @@ fn find_string_literal_content(literal: Node<'_>, code: &Source<'_>) -> Option<S
     {
         return None;
     }
-    // Go exposes no content node at all: it names only the escapes, so the concatenation is
-    // trusted only when the literal really spells its content out.
+    // Escapes alone do not spell the content out, so the concatenation is trusted only when a
+    // content node takes part in it.
     let mut content = String::new();
     let mut has_content_node = false;
     for child in &children {
         match child.kind_name() {
-            "string_content" | "string_fragment" => {
+            "string_content"
+            | "string_fragment"
+            | "interpreted_string_literal_content"
+            | "raw_string_literal_content" => {
                 has_content_node = true;
                 content.push_str(node_text(*child, code));
             }
@@ -838,8 +841,8 @@ fn find_string_literal_content(literal: Node<'_>, code: &Source<'_>) -> Option<S
     if has_content_node && !content.is_empty() {
         return Some(content);
     }
-    // A grammar that exposes no content child (Go's string literals) keeps its delimiters in the
-    // text; an empty literal is left without a name.
+    // A literal without a content child (Go's rune literal) keeps its delimiters in the text; an
+    // empty literal is left without a name.
     let text = node_text(literal, code);
     let quote = text
         .chars()
@@ -880,7 +883,7 @@ 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)?,
+        "navigation_expression" => target.named_child(target.named_child_count() as u32 - 1)?,
         "qualified_identifier" => return unwrap_declarator_name(Some(target), code),
         _ => return None,
     };
@@ -975,7 +978,7 @@ fn is_value_of_parent(node: Node<'_>, parent: Node<'_>) -> bool {
             .is_some_and(|child| child.id() == node.id())
         {
             return matches!(
-                parent.field_name_for_child(index as u32),
+                parent.field_name_for_child(index),
                 None | Some("value")
             );
         }