code-gauge 10.0.0 → 10.2.0

package/native/Cargo.lock

@@ -484,9 +484,9 @@ checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8"
 
 [[package]]
 name = "willbooster-tree-sitter"
-version = "1.0.5"
+version = "1.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c6ca3007235ade028b793d6090a5ea16618ea3ab9b53427d1f782b15bf64064"
+checksum = "334d00dd58bc471ce142f80bd05c8dde5d6a5961d23527aa4b3ad640793550ef"
 dependencies = [
  "cc",
  "regex",
@@ -497,9 +497,9 @@ dependencies = [
 
 [[package]]
 name = "willbooster-tree-sitter-c"
-version = "1.1.0"
+version = "4.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5cee6f1a4e0f64f337d28aeaed73879d7e8a87d77c287afb989ce29adea54700"
+checksum = "5eb6af34735987dd02518fced2bd8f6a0b81aff19220290020787c1e12c19e7f"
 dependencies = [
  "cc",
  "tree-sitter-language",
@@ -507,9 +507,9 @@ dependencies = [
 
 [[package]]
 name = "willbooster-tree-sitter-c-sharp"
-version = "1.0.3"
+version = "3.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99b224dcd59cda9b24b588557cca3827abaccaf10da72d125c31e7cdb2e6f7fb"
+checksum = "8c5aa3c4b1bfcdad92d0703c77964c8b805800d3ee8087dddae1d336da96e495"
 dependencies = [
  "cc",
  "tree-sitter-language",
@@ -517,9 +517,9 @@ dependencies = [
 
 [[package]]
 name = "willbooster-tree-sitter-cpp"
-version = "1.1.1"
+version = "2.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72b92a9fcb0dc27bd4af18e06fe6c085dd14d91f009f60ecd92c0308b9cbd068"
+checksum = "fff5f9f592d51e52f1701438c8ee8b91376e15f42584e4e01f4ecb1120b1f354"
 dependencies = [
  "cc",
  "tree-sitter-language",
@@ -527,9 +527,9 @@ dependencies = [
 
 [[package]]
 name = "willbooster-tree-sitter-javascript"
-version = "1.0.3"
+version = "4.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6c40d41b303b525194daa503a71ec94d8269fe8d1648b2d9138fe902623beff"
+checksum = "60a035c947e2036a42ef8060872a213dc76489b3a82f2e4730b6ed54bd10a7bb"
 dependencies = [
  "cc",
  "tree-sitter-language",
@@ -537,9 +537,9 @@ dependencies = [
 
 [[package]]
 name = "willbooster-tree-sitter-kotlin"
-version = "1.4.0"
+version = "4.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "529ae914939b559754e6dd8b34d2705f04d6dcb73f09cb52f024b49eda9b5b88"
+checksum = "58fb49a0177bad0032df8ff897e5c6b66f3ed044e3133a81ebc1583303f6c7aa"
 dependencies = [
  "cc",
  "tree-sitter-language",
@@ -547,9 +547,9 @@ dependencies = [
 
 [[package]]
 name = "willbooster-tree-sitter-rust"
-version = "1.1.1"
+version = "2.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "324c9f18cfc29e4da7335ad8cb76beb6ac1ae91a8037a44724bc55fce04f26f7"
+checksum = "740d80b0a761326575e52bf678749e1d08430e988b45d18f5db71bc20ad3a128"
 dependencies = [
  "cc",
  "tree-sitter-language",
@@ -557,9 +557,9 @@ dependencies = [
 
 [[package]]
 name = "willbooster-tree-sitter-typescript"
-version = "1.1.1"
+version = "7.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8c51b6c9e10d6ae34c2f84c4d44fff79a0210890ede63fda558a6a0f042eb28"
+checksum = "289945de1713b7f13625e2d9646e138f37be74d38d8f58de0cfe669d9fe9ba0c"
 dependencies = [
  "cc",
  "tree-sitter-language",

package/native/Cargo.toml

@@ -20,18 +20,18 @@ rustc-hash = "2"
 # `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 = { package = "willbooster-tree-sitter", version = "1.4.3" }
+tree-sitter-c = { package = "willbooster-tree-sitter-c", version = "=4.0.2" }
+tree-sitter-c-sharp = { package = "willbooster-tree-sitter-c-sharp", version = "=3.0.1" }
+tree-sitter-cpp = { package = "willbooster-tree-sitter-cpp", version = "=2.0.2" }
 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-javascript = { package = "willbooster-tree-sitter-javascript", version = "=4.0.2" }
+tree-sitter-kotlin = { package = "willbooster-tree-sitter-kotlin", version = "=4.0.2" }
 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" }
+tree-sitter-rust = { package = "willbooster-tree-sitter-rust", version = "=2.0.2" }
+tree-sitter-typescript = { package = "willbooster-tree-sitter-typescript", version = "=7.0.0" }
 
 # 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/complexity.rs

@@ -639,7 +639,8 @@ fn find_boolean_operator_text<'a>(binary_node: Node<'_>, code: &Source<'a>) -> O
 }
 
 /// Java `guard`, C# `when_clause`, Ruby `if_guard`, a Python `case` guard (an `if_clause` under a
-/// `case_clause`), and Rust guards inside `match_pattern`. A Python comprehension filter shares
+/// `case_clause`), a Kotlin guard (the `guard` field of a `when_entry`), and Rust guards inside
+/// `match_pattern`. A Python comprehension filter shares
 /// the `if_clause` type but is a per-element predicate of one expression, not an extra execution
 /// path: Sonar ports differ on it (complexipy charges it), and code-gauge does not, unlike
 /// ternaries and conditions, which are charged. A C# exception filter (`catch (E e) when (...)`, a `catch_filter_clause`) is
@@ -656,6 +657,14 @@ fn is_pattern_guard(node: Node<'_>, parent: Option<Node<'_>>) -> bool {
     if kind == "if_clause" {
         return parent.is_some_and(|parent| parent.kind_name() == "case_clause");
     }
+    if parent.is_some_and(|parent| {
+        parent.kind_name() == "when_entry"
+            && parent
+                .child_by_field_name("guard")
+                .is_some_and(|guard| guard.id() == node.id())
+    }) {
+        return true;
+    }
     kind == "match_pattern"
         && all_children(node)
             .iter()

package/native/src/container.rs

@@ -1,7 +1,11 @@
 use rustc_hash::FxHashSet;
 use tree_sitter::Node;
 
-use crate::functions::next_declarator;
+use crate::functions::{
+    find_pair_key_name, find_parallel_assignment_target, find_single_assignment_target,
+    find_string_literal_content, find_value_binding, is_value_group, next_declarator,
+    unwrap_transparent_value_wrappers,
+};
 use crate::tree_index::NodeExt;
 use crate::util::{named_children, node_text, Source};
 
@@ -88,20 +92,57 @@ fn explicit_ruby_owner(object: Option<Node<'_>>, code: &Source<'_>) -> Option<St
     (text != "self").then(|| text.to_string())
 }
 
-/// The name of the declaration whose member a declared function is: the nearest class-like
-/// declaration enclosing it, or the owner the function names itself (a Go receiver, a C++ qualified
-/// declarator, the object of a Ruby singleton method).
+/// The name of the declaration whose member a function is: the nearest class-like declaration
+/// enclosing it or, for a function written as a value, the declaration binding it; the owner the
+/// function names itself (a Go receiver, a C++ qualified declarator, the object of a Ruby singleton
+/// method); or the path a JavaScript object literal holding it is bound to.
 pub fn find_container_name(
     node: Node<'_>,
     function_nodes: &FxHashSet<&'static str>,
     code: &Source<'_>,
     inline_namespaces: &InlineNamespaces<'_>,
 ) -> Option<String> {
-    // A function written as a value belongs to whatever it is passed or assigned to, which the
-    // syntax cannot follow reliably; it keeps the name of what it is bound to and has no owner.
-    if !is_function_declaration(node) {
+    let is_declared = is_function_declaration(node);
+    // A function expression with a name of its own (`pick = function impl() {}`) is reported
+    // under that name, which is no member of what binds the expression.
+    if !is_declared && node.child_by_field_name("name").is_some() {
         return None;
     }
+    let (holder, bound) = find_value_binding(node, code)?;
+    let member = if holder.kind_name() == "pair" {
+        holder
+    } else {
+        bound
+    };
+    if let Some(object) = member
+        .parent_node()
+        .filter(|parent| parent.kind_name() == "object")
+    {
+        return object_owner(object, function_nodes, code, inline_namespaces);
+    }
+    // A function written as a value belongs to whatever it is passed or assigned to, which the
+    // syntax can follow only where a declaration binds it (a class field, a constant of a
+    // namespace); elsewhere it keeps the name of what it is bound to and has no owner.
+    if !is_declared {
+        // A parallel assignment binds the value to the target at its position.
+        if is_value_group(holder) {
+            let (assignment, target) = find_parallel_assignment_target(bound)?;
+            return assigns_attribute(assignment, target)
+                .then(|| enclosing_owner(assignment, function_nodes, code, inline_namespaces))
+                .flatten();
+        }
+        if !declares_binding(holder, bound) {
+            return None;
+        }
+        // A C++ variable defined outside its class (`int (*Rules::pick)(int) = [] {}`) spells
+        // its owner, as a function defined there does.
+        return match find_qualified_declarator(holder) {
+            Some(qualified) => {
+                cpp_spelled_owner(holder, qualified, function_nodes, code, inline_namespaces)
+            }
+            None => enclosing_owner(holder, function_nodes, code, inline_namespaces),
+        };
+    }
     if let Some(receiver) = node.child_by_field_name("receiver") {
         return go_receiver_type(receiver, code);
     }
@@ -113,6 +154,116 @@ pub fn find_container_name(
         .or_else(|| enclosing_owner(node, function_nodes, code, inline_namespaces))
 }
 
+/// Whether `holder` declares the name its value `bound` is bound to, as a field, a property, or a
+/// variable does.
+fn declares_binding(holder: Node<'_>, bound: Node<'_>) -> bool {
+    let kind = holder.kind_name();
+    if kind == "assignment" {
+        return find_single_assignment_target(holder)
+            .is_some_and(|target| assigns_attribute(holder, target))
+            && holder
+                .child_by_field_name("right")
+                .is_some_and(|value| value.id() == bound.id());
+    }
+    kind.ends_with("_declarator")
+        || kind.ends_with("_declaration")
+        || kind.ends_with("_definition")
+        || matches!(kind, "const_item" | "static_item")
+}
+
+/// Whether an assignment declares `target` as an attribute of the class around it: a Python class
+/// does by assigning to a plain name and a Ruby one a constant, while a plain name assigned in a
+/// Ruby class body is a local variable of that body.
+fn assigns_attribute(assignment: Node<'_>, target: Node<'_>) -> bool {
+    match target.kind_name() {
+        // Only Python wraps an assignment in an `expression_statement`, a chain (`e = f = ...`)
+        // in that of its outermost assignment.
+        "identifier" => {
+            let mut outermost = assignment;
+            while let Some(outer) = outermost
+                .parent_node()
+                .filter(|outer| outer.kind_name() == "assignment")
+            {
+                outermost = outer;
+            }
+            outermost
+                .parent_node()
+                .is_some_and(|statement| statement.kind_name() == "expression_statement")
+        }
+        "constant" => true,
+        _ => false,
+    }
+}
+
+/// The path a JavaScript object literal is bound to, which its members are reached through:
+/// `api` for `const api = { ... }`, `Rules.handlers` for a field of a class, `api.admin` for the
+/// value of a property, `module.exports` for an assignment. An object passed or returned is bound
+/// to nothing the syntax names.
+fn object_owner(
+    object: Node<'_>,
+    function_nodes: &FxHashSet<&'static str>,
+    code: &Source<'_>,
+    inline_namespaces: &InlineNamespaces<'_>,
+) -> Option<String> {
+    let bound = unwrap_transparent_value_wrappers(object);
+    let holder = bound.parent_node()?;
+    let is_value = |field: &str| {
+        holder
+            .child_by_field_name(field)
+            .is_some_and(|value| value.id() == bound.id())
+    };
+    match holder.kind_name() {
+        "variable_declarator" | "field_definition" | "public_field_definition"
+            if is_value("value") =>
+        {
+            let name = holder
+                .child_by_field_name("name")
+                .or_else(|| holder.child_by_field_name("property"))?;
+            // A field may be named by a literal (`"handlers" = {}`); a computed name or a
+            // destructuring pattern names nothing.
+            let name = match name.kind_name() {
+                "string" => find_string_literal_content(name, code)?,
+                "number" => node_text(name, code).to_string(),
+                kind if kind.ends_with("identifier") => node_text(name, code).to_string(),
+                _ => return None,
+            };
+            Some(
+                match enclosing_owner(holder, function_nodes, code, inline_namespaces) {
+                    Some(owner) => format!("{owner}.{name}"),
+                    None => name,
+                },
+            )
+        }
+        "pair" if is_value("value") => {
+            let outer = holder
+                .parent_node()
+                .filter(|outer| outer.kind_name() == "object")?;
+            let owner = object_owner(outer, function_nodes, code, inline_namespaces)?;
+            Some(format!("{owner}.{}", find_pair_key_name(holder, code)?))
+        }
+        "assignment_expression" if is_value("right") => holder
+            .child_by_field_name("left")
+            .and_then(|target| member_path(target, code)),
+        _ => None,
+    }
+}
+
+/// A name or a chain of property accesses on one (`exports`, `Rules.prototype`, `this.handlers`),
+/// spelled without the comments and line breaks its source may hold.
+fn member_path(node: Node<'_>, code: &Source<'_>) -> Option<String> {
+    match node.kind_name() {
+        "identifier" | "this" => Some(node_text(node, code).to_string()),
+        "member_expression" => {
+            let object = member_path(node.child_by_field_name("object")?, code)?;
+            let property = node
+                .child_by_field_name("property")
+                .filter(|property| property.kind_name() == "property_identifier")?;
+            Some(format!("{object}.{}", node_text(property, code)))
+        }
+        _ => None,
+    }
+}
+
 /// A Go method is declared outside its type and names it as its receiver, `(r *Rules)` or
 /// `(r Rules[T])`.
 fn go_receiver_type(receiver: Node<'_>, code: &Source<'_>) -> Option<String> {

package/native/src/dep_degree.rs

@@ -72,7 +72,6 @@ const DECLARATOR_WRAPPER_TYPES: &[&str] = &[
     "parenthesized_declarator",
     "function_declarator",
     "attributed_declarator",
-    "pointer_type_declarator",
     "qualified_identifier",
 ];
 
@@ -149,16 +148,10 @@ pub fn measure_dep_degree(
     pairs
 }
 
-/// 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. 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).
+/// 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())
         && !node.parent_node().is_some_and(|parent| {
             parent.kind_name() == "user_type"
@@ -166,15 +159,21 @@ fn is_variable_leaf(leaf: &DepDegreeLeaf<'_>) -> bool {
         })
 }
 
+/// Whether the identifier is the name a C++ member pointer declares (`int C::* p`, also
+/// `int C::* arr[1]`): its `pointer_declarator`, possibly around further declarator wrappers, is
+/// the `name` of the `qualified_identifier` spelling the class.
 fn is_member_pointer_name(node: Node<'_>) -> bool {
     let mut current = node;
     while let Some(parent) = current.parent_node() {
-        if parent.kind_name() == "pointer_type_declarator" {
-            return true;
+        // The kind is tested before the field is looked up: this runs for every variable read,
+        // and scanning the children of a high-arity parent (a list of arguments) each time would
+        // cost the square of its length.
+        if parent.kind_name() == "qualified_identifier" {
+            return current.kind_name() == "pointer_declarator"
+                && field_name_in_parent(current, parent) == Some("name");
         }
         // The climb follows the declared-name position only, exactly like unwrap_declarator_wrappers.
         if !DECLARATOR_WRAPPER_TYPES.contains(&parent.kind_name())
-            || parent.kind_name() == "qualified_identifier"
             || field_name_in_parent(current, parent).is_some_and(|field| field != "declarator")
         {
             return false;
@@ -338,7 +337,7 @@ fn is_definition_field(holder: Node<'_>, field_name: Option<&str>) -> bool {
 
 /// Climbs from the identifier through the C/C++ declarator wrappers it is the declared name of
 /// (`reference_declarator` and `parenthesized_declarator` expose no field, so their name is the
-/// fieldless child; a member pointer's `pointer_type_declarator` is the `name` of a
+/// fieldless child; a member pointer's `pointer_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<&'t str>) {
@@ -400,7 +399,7 @@ fn is_parameter_definition(leaf: &DepDegreeLeaf<'_>) -> bool {
         // O(1).
         let continues_member_pointer = declares_member_pointer
             && parent.kind_name() == "qualified_identifier"
-            && (current.kind_name() == "pointer_type_declarator" || in_member_pointer)
+            && (current.kind_name() == "pointer_declarator" || in_member_pointer)
             && field_name_in_parent(current, parent) == Some("name");
         in_member_pointer = continues_member_pointer;
         if depth >= 1