feat(indexer): implement Dart call-edge extraction (C3)

tree-sitter-dart has no dedicated call-expression node kind — a call
(`a.b.c(x)`) and a call-less field access (`a.b.c`) parse as the exact
same flat `member_access` node shape: [primary, selector, selector, ...],
where the last selector wraps either a dotted name (.foo/?.foo) or an
argument_part (the call parens). This is structural, not expressible via
the generic call_node_types/call_function_field field-lookup walk_calls
uses for every other language.

Added dart_call_from_member_access (parser.rs), verified against a real
tree-sitter-dart 0.0.4 parse (scratch AST dump this session confirmed
the exact shapes for bare print(x), this.foo(x), g.greet(), chained
a.b.c(), and the no-call a.b.c case). Wired in as its own language-gated
branch in walk_calls (threaded `language: &str` through, mirroring
walk_symbols) — mutually exclusive with the generic path since Dart's
call_node_types stays empty, so zero behavior change for every other
language.

Measured on the real dart-lang/args benchmark corpus: 0 -> 2,166 call
edges (178 symbols unchanged). Deliberately not covered this pass:
constructor_invocation (List<int>.filled(...)-style explicit-type-arg
named-constructor calls) and a call through an index_selector mid-chain
(list[0].foo()) — both bail rather than guess wrong.

Verified: full workspace test suite (849 calm-core + 264 calm-server +
integration tests, 0 failed), clippy -D warnings clean, cargo fmt
--check clean.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: Your Name

benchmarks/resolution/README.md

@@ -128,10 +128,41 @@ trong `CORPORA`, ghi đè `results.json` với bộ đầy đủ):
 | powershell | 142 | 156 | 52.6% | 0.0% | 46.2% | 1.3% | 5.6 | bbc5ac3 |
 | groovy | 59 | 19 | 84.2% | 0.0% | 5.3% | 10.5% | 13.2 | 3f97e22 |
 
-**`dart` = 0 edges, đúng là 0 thật, không phải lỗi đo** — tài liệu hoá từ Phase C
-([[calm-25-language-expansion-research]]): grammar Dart không có node kind cho call-expression, nên
-`walk_calls` không có gì để trích xuất — 178 symbols (class/method) vẫn được index đầy đủ, chỉ riêng
-call-graph là khoảng trống đã biết trước, có chủ đích (deliberate scope cut, không phải bug).
+**`dart` = 0 edges lúc đo lần này (2026-07-11), đúng là 0 thật, không phải lỗi đo** — tài liệu hoá
+từ Phase C ([[calm-25-language-expansion-research]]): grammar Dart không có node kind cho
+call-expression, nên `walk_calls` không có gì để trích xuất — 178 symbols (class/method) vẫn được
+index đầy đủ, chỉ riêng call-graph là khoảng trống đã biết trước, có chủ đích (deliberate scope cut,
+không phải bug). **SUPERSEDED 2026-07-28 — xem cập nhật ngay bên dưới: đã cài đặt Dart call-edge
+extraction (C3, Tier B audit); số 0 edges này không còn đúng ở build hiện tại.**
+
+**Cập nhật 2026-07-28 — Dart call-edge extraction (C3), đo thật lại trên cùng corpus:**
+tree-sitter-dart thật ra không thiếu node kind cho call — nó dùng chung `member_access`/`selector`/
+`argument_part` cho CẢ call lẫn field access thuần (`a.b.c()` và `a.b.c` parse ra cùng shape,
+khác nhau ở việc selector cuối có bọc `argument_part` hay không) — không phải "không có node
+cho call" như ghi chú Phase C phía trên (giả định ban đầu đó sai, đã sửa). Cài một nhánh trích
+xuất riêng cho Dart trong `walk_calls` (`dart_call_from_member_access`, `parser.rs`) thay vì cơ
+chế `call_node_types`/`call_function_field` chung (không biểu đạt được luật "selector cuối có
+phải call hay không"). Đo lại trên cùng corpus `dart-lang/args` (build release, cùng lệnh ở trên):
+
+| | trước (0 edges) | sau (C3) |
+|---|---:|---:|
+| symbols | 178 | 178 (không đổi — extraction symbol vẫn luôn đúng) |
+| edges | 0 | **2,166** |
+| resolved% | — | 7.8% |
+| textual% | — | 11.2% |
+| **ambiguous%** | — | **80.9%** |
+
+Không có `formal`/`inferred` (0% cả hai — Dart chưa có SCIP provider, và Tier-2 type_map chỉ có cho
+5 ngôn ngữ Tier-0 gốc). `ambiguous%` cao (80.9%) cùng nguyên nhân gốc đã thấy ở Kotlin/OCaml/C++:
+corpus args là 1 lib CLI-parser nhỏ với nhiều method tên phổ biến (`parse`, `format`, …) trùng lặp,
+fan-out `MAX_CALLEE_CANDIDATES` cao — không phải lỗi của lần cài đặt này, mà là giới hạn chung của
+mọi ngôn ngữ Tier-0.5 chưa có SCIP provider thật, giống mọi dòng khác trong bảng Phase B/C ở trên.
+
+**Nợ ghi nhận, chưa cài trong lượt này:** `constructor_invocation` (dạng `List<int>.filled(...)`,
+có type argument tường minh trước dot-named-constructor) — hình dạng node RIÊNG, hiếm hơn
+`member_access`, cố ý bỏ qua cho lượt đầu này (xem doc comment của `dart_call_from_member_access`).
+Cũng bỏ qua có chủ đích: 1 call đi qua `index_selector` giữa chuỗi (vd `list[0].foo()`) — bail
+thay vì đoán sai, không silently miscount.
 
 **`inferred%` = 0.0% cho toàn bộ 11 ngôn ngữ mới** — hợp lý, không phải lỗi: Tier-2 (`type_map`
 receiver inference) hiện chỉ implement cho các ngôn ngữ Tier-0 gốc (Python/JS/TS/Java/C#) — 11 ngôn

crates/calm-core/src/indexer/lang_constants.rs

@@ -1047,10 +1047,20 @@ pub static LANGUAGES: &[LanguageSpec] = &[
     // guessed:
     // - No dedicated call-expression node kind at all (calls are a generic
     //   member_access/selector/argument_part postfix chain shared with
-    //   plain field access) — call-graph extraction is a DELIBERATE,
-    //   documented scope cut for this first pass (`call_node_types` is
-    //   empty), not an oversight. See `test_dart_real_grammar_symbols_are_
-    //   accurate` in parser.rs, which locks this gap in place.
+    //   plain field access) — `call_node_types` stays EMPTY on purpose
+    //   (C3, Tier B audit: call extraction is handled by a dedicated
+    //   `language == "dart"` branch in `walk_calls`/`dart_call_from_
+    //   member_access` instead, since the generic `call_node_types`/
+    //   `call_function_field` mechanism can't express "a member_access is
+    //   only a call when its LAST selector wraps an argument_part" — see
+    //   that function's doc comment). Recognized: bare `foo(x)`,
+    //   `this.foo(x)`, `recv.foo(x)`, chained `a.b.c(x)`. Deliberately NOT
+    //   covered (bails rather than guessing): a call through an
+    //   `index_selector` in the chain (`list[0].foo()`), and the narrower
+    //   `constructor_invocation` shape (`List<int>.filled(...)`, an
+    //   explicit-type-argument named-constructor call) — both real but
+    //   comparatively rare shapes left for a follow-up pass. See
+    //   `test_dart_real_grammar_symbols_and_calls_are_accurate` in parser.rs.
     // - A method/constructor's name sits 2 levels deep with no field path
     //   all the way down (`class_member_definition` wraps `method_signature`
     //   or `declaration`, which in turn wraps an unnamed `function_signature`/

crates/calm-core/src/indexer/parser.rs

@@ -523,6 +523,92 @@ fn elixir_def_arity(def_call_node: tree_sitter::Node) -> Option<i64> {
     }
 }
 
+/// Dart (C3, Tier B audit): tree-sitter-dart has no dedicated call-expression
+/// node kind — a call like `a.b.c(x)` and a call-less field access `a.b.c`
+/// parse as the SAME flat `member_access` node shape: `[primary, selector,
+/// selector, ...]`, where each `selector` wraps either a dotted-name
+/// (`unconditional_assignable_selector`/`conditional_assignable_selector`,
+/// i.e. `.foo`/`?.foo`) or an `argument_part` (the call parens). Recognizing
+/// a call is therefore structural — "does the LAST selector wrap an
+/// `argument_part`?" — not expressible via the generic `call_node_types`/
+/// `call_function_field` field-lookup `walk_calls` uses for every other
+/// language, so it's handled as its own language-gated branch there instead
+/// (same precedent as `go_receiver_type`/`elixir_def_arity` for other
+/// grammar shapes the generic path can't cover). Verified against a real
+/// parse of tree-sitter-dart 0.0.4 (bare `print(x)`, `this.foo(x)`,
+/// `g.greet()`, `Greeter("world")`, chained `a.b.c()`, and the no-call
+/// `a.b.c` field access — see `test_dart_real_grammar_symbols_and_calls_are_
+/// accurate`), not guessed.
+///
+/// Returns `(receiver, callee, arg_count)` when `node` (a `member_access`)
+/// is really a call site; `None` when it's a call-less field/index-access
+/// chain, or a shape this first pass doesn't cover (a call on a
+/// parenthesized/function-literal primary, or an `index_selector` — e.g.
+/// `list[0]` — in the middle of the chain) — deliberately bails rather than
+/// guessing wrong, same risk tolerance `split_receiver_callee` already
+/// applies for every other language.
+fn dart_call_from_member_access(
+    node: tree_sitter::Node,
+    source: &str,
+) -> Option<(Option<String>, String, Option<i64>)> {
+    let mut cursor = node.walk();
+    let named: Vec<tree_sitter::Node> = node.named_children(&mut cursor).collect();
+    if named.len() < 2 {
+        return None;
+    }
+    let last = named[named.len() - 1];
+    if last.kind() != "selector" {
+        return None;
+    }
+    let argument_part = last.named_child(0)?;
+    if argument_part.kind() != "argument_part" {
+        return None; // last selector isn't a call — plain field/index access chain
+    }
+    let arg_count = count_arguments_node(argument_part);
+
+    // Dotted-name selector (`.foo`/`?.foo`) -> the identifier's own text, or
+    // `None` for an `index_selector` (`[i]`) — a shape this pass skips.
+    fn dotted_name(sel: tree_sitter::Node, source: &str) -> Option<String> {
+        let inner = sel.named_child(0)?;
+        match inner.kind() {
+            "unconditional_assignable_selector" | "conditional_assignable_selector" => {
+                let ident = inner.named_child(0)?;
+                (ident.kind() == "identifier").then(|| source[ident.byte_range()].to_string())
+            }
+            _ => None,
+        }
+    }
+
+    // Everything before the call selector: primary + zero or more dotted
+    // selectors. The callee is the last dotted segment (or the primary
+    // itself for a bare call); the receiver, if any, is the segment right
+    // before that — the same "receiver = last segment" convention
+    // `split_receiver_callee` already uses for every other language's
+    // chained access (e.g. `a.b.c()` gets receiver "b", not the full "a.b").
+    let pre = &named[..named.len() - 1];
+    if pre.len() == 1 {
+        let prim = pre[0];
+        if !matches!(prim.kind(), "identifier" | "this" | "super") {
+            return None;
+        }
+        return Some((None, source[prim.byte_range()].to_string(), arg_count));
+    }
+
+    let callee_sel = pre[pre.len() - 1];
+    if callee_sel.kind() != "selector" {
+        return None;
+    }
+    let callee = dotted_name(callee_sel, source)?;
+
+    let receiver_node = pre[pre.len() - 2];
+    let receiver = if receiver_node.kind() == "selector" {
+        dotted_name(receiver_node, source)
+    } else {
+        Some(source[receiver_node.byte_range()].to_string())
+    };
+    Some((receiver, callee, arg_count))
+}
+
 /// Walks backward through contiguous same-kind comment siblings immediately
 /// preceding `node` — no blank-line gap between any two, nor between the
 /// last one and `node` itself — and joins them in source order. Line-
@@ -1416,6 +1502,7 @@ fn walk_calls(
     node: tree_sitter::Node,
     source: &str,
     consts: &crate::indexer::lang_constants::LangConstants,
+    language: &str,
     enclosing: Option<(String, usize)>,
     enclosing_class: Option<String>,
     out: &mut Vec<RawCall>,
@@ -1444,7 +1531,33 @@ fn walk_calls(
         enclosing_class.clone()
     };
 
-    if consts.call_node_types.contains(&node.kind())
+    // Dart (C3, Tier B audit): no dedicated call-expression node kind exists
+    // in this grammar at all (see `dart_call_from_member_access`'s doc
+    // comment) — handled as its own language-gated branch rather than
+    // through `call_node_types`/`call_function_field` below, which assumes a
+    // call node names its callee via one fixed field or first-child
+    // position. `call_node_types` stays empty for Dart in `lang_constants.rs`
+    // on purpose, so the generic branch below can never also fire for a
+    // `member_access` node — the two paths are mutually exclusive by
+    // construction, not just by this `else`.
+    if language == "dart"
+        && node.kind() == "member_access"
+        && let Some((enc_name, enc_line)) = &current
+        && let Some((receiver, callee, arg_count)) = dart_call_from_member_access(node, source)
+    {
+        out.push(RawCall {
+            enclosing_name: enc_name.clone(),
+            enclosing_line: *enc_line,
+            enclosing_class: child_class.clone(),
+            callee,
+            receiver_is_type_path: receiver.as_deref().is_some_and(is_type_like),
+            receiver,
+            module_hint: None,
+            looks_option_or_result_chained: looks_option_or_result_chained(node, source),
+            line: node.start_position().row + 1,
+            arg_count,
+        });
+    } else if consts.call_node_types.contains(&node.kind())
         && !is_definition_macro_call(node, source, consts)
         && let Some((enc_name, enc_line)) = &current
         && let field_name = consts
@@ -1562,6 +1675,7 @@ fn walk_calls(
             child,
             source,
             consts,
+            language,
             current.clone(),
             child_class.clone(),
             out,
@@ -1599,7 +1713,15 @@ pub fn extract_calls_from_tree(
         return Vec::new();
     };
     let mut out = Vec::new();
-    walk_calls(tree.root_node(), source, &consts, None, None, &mut out);
+    walk_calls(
+        tree.root_node(),
+        source,
+        &consts,
+        language,
+        None,
+        None,
+        &mut out,
+    );
     out
 }
 
@@ -4448,16 +4570,16 @@ class Foo {
 
     #[test]
     #[cfg(feature = "lang-dart")]
-    fn test_dart_real_grammar_symbols_are_accurate() {
+    fn test_dart_real_grammar_symbols_and_calls_are_accurate() {
         // tree-sitter-dart 0.0.4 (an older, hand-written grammar — see
         // lang_constants.rs's Dart entry) has no dedicated call-expression
-        // node kind at all (calls are a generic member_access/selector/
-        // argument_part postfix chain shared with plain field access) —
-        // call-graph extraction is a documented scope cut, not an oversight.
-        // This test locks that gap in place (asserts calls stay empty) so a
-        // future accidental `call_node_types` entry that doesn't actually
-        // work correctly gets caught instead of silently shipping partial
-        // call edges.
+        // node kind at all — a call and a call-less field access share the
+        // same `member_access`/`selector`/`argument_part` postfix-chain
+        // shape. Call extraction (C3, Tier B audit) is handled by a
+        // dedicated `dart_call_from_member_access` branch in `walk_calls`,
+        // not the generic `call_node_types` mechanism — see that function's
+        // doc comment for why, and its own scratch-verified real-grammar
+        // shapes.
         let code = "class Greeter {\n  String name;\n\n  Greeter(this.name);\n\n  String greet() {\n    print(\"hello\");\n    return this.formatGreeting(name);\n  }\n\n  String formatGreeting(String n) {\n    return \"Hello, \" + n;\n  }\n}\n\nabstract class Named {\n  String getName();\n}\n\nvoid main() {\n  var g = Greeter(\"world\");\n  g.greet();\n}\n";
         let symbols = extract_symbols(code, "dart", "a.dart").unwrap();
         let names = shallow_names(&symbols);
@@ -4503,12 +4625,49 @@ class Foo {
         );
 
         let calls = extract_calls(code, "dart", "a.dart").unwrap();
-        assert!(
-            calls.is_empty(),
-            "Dart call-graph extraction is a documented scope cut (no clean \
-             call-expression node in this grammar) — see this test's doc comment; \
-             calls: {calls:?}"
+        assert_eq!(
+            calls.len(),
+            4,
+            "expected print(\"hello\"), this.formatGreeting(name), Greeter(\"world\"), \
+             g.greet() — the constructor DECLARATION `Greeter(this.name);` must NOT \
+             itself count as a 5th call; calls: {calls:?}"
+        );
+
+        let print_call = calls
+            .iter()
+            .find(|c| c.callee == "print")
+            .expect("bare print(\"hello\") call should be found");
+        assert_eq!(print_call.enclosing_name, "greet");
+        assert_eq!(print_call.receiver, None);
+        assert_eq!(print_call.arg_count, Some(1));
+
+        let format_greeting_call = calls
+            .iter()
+            .find(|c| c.callee == "formatGreeting")
+            .expect("this.formatGreeting(name) call should be found");
+        assert_eq!(format_greeting_call.enclosing_name, "greet");
+        assert_eq!(
+            format_greeting_call.receiver.as_deref(),
+            Some("this"),
+            "receiver should be \"this\""
         );
+        assert_eq!(format_greeting_call.arg_count, Some(1));
+
+        let greeter_call = calls
+            .iter()
+            .find(|c| c.callee == "Greeter")
+            .expect("Greeter(\"world\") constructor call should be found");
+        assert_eq!(greeter_call.enclosing_name, "main");
+        assert_eq!(greeter_call.receiver, None);
+        assert_eq!(greeter_call.arg_count, Some(1));
+
+        let greet_call = calls
+            .iter()
+            .find(|c| c.callee == "greet")
+            .expect("g.greet() call should be found");
+        assert_eq!(greet_call.enclosing_name, "main");
+        assert_eq!(greet_call.receiver.as_deref(), Some("g"));
+        assert_eq!(greet_call.arg_count, Some(0));
     }
 
     #[test]