cgraphx 2.0.2 → 2.0.3

package/dist/core/code/engine/core/ingestion/languages/dart/expand-wildcards.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * Enumerate the names a Dart `import '...'` brings into scope — every PUBLIC
+ * top-level symbol of the target library. Dart imports are whole-library
+ * (wildcard) and library-private (leading-underscore) members are not
+ * exported, so they are filtered out. Mirror of Ruby's
+ * `expandRubyWildcardNames`.
+ *
+ * Without this hook the shared `propagateImportedReturnTypes` pass has no
+ * importer-scope binding to hang an imported function's return type on, so a
+ * cross-file `var u = getUser(); u.save()` never resolves `u`'s type.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandDartWildcardNames = expandDartWildcardNames;
+function expandDartWildcardNames(targetModuleScope, parsedFiles) {
+    const target = parsedFiles.find((p) => p.moduleScope === targetModuleScope);
+    if (target === undefined)
+        return [];
+    const seen = new Set();
+    const names = [];
+    for (const def of target.localDefs) {
+        const qn = def.qualifiedName;
+        if (qn === undefined || qn.length === 0)
+            continue;
+        const name = qn.split('.').pop() ?? qn;
+        if (name === '' || name.startsWith('_'))
+            continue; // library-private
+        if (seen.has(name))
+            continue;
+        seen.add(name);
+        names.push(name);
+    }
+    return names;
+}

package/dist/core/code/engine/core/ingestion/languages/dart/extension-type-preprocess.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preprocessDartExtensionTypes = preprocessDartExtensionTypes;
+const DART_EXTENSION_TYPE_HEADER = /\b(extension)([ \t]+type[ \t]+(?:const[ \t]+)?)([A-Za-z_$][A-Za-z0-9_$]*)([ \t]*<[^()\r\n]*>)?([ \t]*)\(([^()\r\n]*)\)/g;
+function representationType(representation) {
+    const trimmed = representation.trim();
+    const match = /^(.*\S)\s+[A-Za-z_$][A-Za-z0-9_$]*$/.exec(trimmed);
+    const typeName = match?.[1]?.trim();
+    return typeName && typeName.length > 0 ? typeName : null;
+}
+/**
+ * Rewrites Dart 3.3 `extension type Name(Type value)` headers into ordinary
+ * extension headers before tree-sitter sees the source. The vendored grammar
+ * currently recovers these declarations through an ERROR subtree, while the
+ * existing Dart ingestion path already handles `extension Name on Type`.
+ */
+function preprocessDartExtensionTypes(sourceText) {
+    return sourceText.replace(DART_EXTENSION_TYPE_HEADER, (match, extensionKeyword, extensionTypeGap, name, typeParameters, beforeRepresentation, representation) => {
+        const typeName = representationType(representation);
+        if (typeName === null)
+            return match;
+        const representationSpanLength = beforeRepresentation.length + representation.length + 2;
+        const rewrittenRepresentation = ` on ${typeName}`;
+        if (rewrittenRepresentation.length > representationSpanLength)
+            return match;
+        return (extensionKeyword +
+            ' '.repeat(extensionTypeGap.length) +
+            name +
+            (typeParameters ?? '') +
+            rewrittenRepresentation +
+            ' '.repeat(representationSpanLength - rewrittenRepresentation.length));
+    });
+}

package/dist/core/code/engine/core/ingestion/languages/dart/import-target.js

@@ -0,0 +1,68 @@
+"use strict";
+/**
+ * `resolveImportTarget` adapter for the Dart `ScopeResolver`. Ports the
+ * legacy-DAG Dart import logic (`import-resolvers/configs/dart.ts`):
+ *
+ *   - `dart:` SDK imports          → `null` (external, no edge)
+ *   - `package:pkg/path`           → `lib/path` (or bare `path`) matched
+ *                                     against the workspace file set
+ *   - relative `'foo/bar.dart'`    → resolved against the importer's dir
+ *   - `__heritage__:` markers      → `null` (synthetic heritage carrier,
+ *                                     consumed by `emitDartHeritageEdges`)
+ *
+ * The `ScopeResolver` hook signature is `(targetRaw, fromFile, allFilePaths)`;
+ * `targetRaw` arrives already quote-stripped from `interpretDartImport`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDartImportTarget = resolveDartImportTarget;
+const interpret_js_1 = require("./interpret.js");
+/** Resolve a relative path against the importer's directory, normalizing
+ *  `.`/`..` segments, then confirm it exists in the workspace file set. */
+function resolveRelative(rel, fromFile, allFilePaths) {
+    const normFrom = fromFile.replace(/\\/g, '/');
+    const fromDir = normFrom.includes('/') ? normFrom.slice(0, normFrom.lastIndexOf('/')) : '';
+    const parts = fromDir.length > 0 ? fromDir.split('/') : [];
+    for (const seg of rel.replace(/\\/g, '/').split('/')) {
+        if (seg === '' || seg === '.')
+            continue;
+        if (seg === '..')
+            parts.pop();
+        else
+            parts.push(seg);
+    }
+    const target = parts.join('/');
+    if (allFilePaths.has(target))
+        return target;
+    // Suffix fallback for absolute/rooted workspace paths.
+    for (const fp of allFilePaths) {
+        if (fp === target || fp.endsWith('/' + target))
+            return fp;
+    }
+    return null;
+}
+function resolveDartImportTarget(targetRaw, fromFile, allFilePaths) {
+    if (targetRaw.startsWith(interpret_js_1.DART_HERITAGE_PREFIX))
+        return null;
+    // `targetRaw` already arrives quote-stripped from `interpretDartImport`.
+    if (targetRaw === '')
+        return null;
+    // Dart SDK imports never resolve to a repo file.
+    if (targetRaw.startsWith('dart:'))
+        return null;
+    // `package:pkg/path.dart` → `lib/path.dart` (or bare `path.dart`).
+    if (targetRaw.startsWith('package:')) {
+        const slash = targetRaw.indexOf('/');
+        if (slash === -1)
+            return null;
+        const relPath = targetRaw.slice(slash + 1);
+        for (const candidate of [`lib/${relPath}`, relPath]) {
+            for (const fp of allFilePaths) {
+                if (fp === candidate || fp.endsWith('/' + candidate))
+                    return fp;
+            }
+        }
+        return null; // external package
+    }
+    // Relative import.
+    return resolveRelative(targetRaw, fromFile, allFilePaths);
+}

package/dist/core/code/engine/core/ingestion/languages/dart/index.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * Dart scope-resolution hooks (RFC #909 Ring 3, issue #939).
+ *
+ * Public API barrel. Consumers import from this file rather than the
+ * individual modules.
+ *
+ * Module layout (each file is a single concern):
+ *
+ *   - `query.ts`             — tree-sitter scope query + lazy parser/query
+ *   - `captures.ts`          — `emitDartScopeCaptures` orchestrator
+ *   - `interpret.ts`         — capture-match → `ParsedImport` / `ParsedTypeBinding`
+ *   - `import-target.ts`     — `(targetRaw, fromFile, allFilePaths) → file path`
+ *   - `receiver-binding.ts`  — synthesize `this` / `super` type-bindings
+ *   - `signature-bindings.ts`— synthesize parameter / return type-bindings
+ *   - `arity.ts`             — Dart arity compatibility (count-primary)
+ *   - `arity-metadata.ts`    — synthesize arity metadata from declarations
+ *   - `merge-bindings.ts`    — Dart import-vs-local precedence
+ *   - `simple-hooks.ts`      — `bindingScopeFor` / `importOwningScope` / `receiverBinding`
+ *   - `scope-resolver.ts`    — `ScopeResolver` registered in `SCOPE_RESOLVERS`
+ *   - `cache-stats.ts`       — PROF_SCOPE_RESOLUTION cache hit/miss counters
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dartReceiverBinding = exports.dartImportOwningScope = exports.dartBindingScopeFor = exports.resolveDartImportTarget = exports.dartArityCompatibility = exports.dartMergeBindings = exports.DART_HERITAGE_PREFIX = exports.normalizeDartType = exports.interpretDartTypeBinding = exports.interpretDartImport = exports.resetDartCaptureCacheStats = exports.getDartCaptureCacheStats = exports.dartScopeOwnsReceivers = exports.emitDartScopeCaptures = void 0;
+var captures_js_1 = require("./captures.js");
+Object.defineProperty(exports, "emitDartScopeCaptures", { enumerable: true, get: function () { return captures_js_1.emitDartScopeCaptures; } });
+Object.defineProperty(exports, "dartScopeOwnsReceivers", { enumerable: true, get: function () { return captures_js_1.dartScopeOwnsReceivers; } });
+var cache_stats_js_1 = require("./cache-stats.js");
+Object.defineProperty(exports, "getDartCaptureCacheStats", { enumerable: true, get: function () { return cache_stats_js_1.getDartCaptureCacheStats; } });
+Object.defineProperty(exports, "resetDartCaptureCacheStats", { enumerable: true, get: function () { return cache_stats_js_1.resetDartCaptureCacheStats; } });
+var interpret_js_1 = require("./interpret.js");
+Object.defineProperty(exports, "interpretDartImport", { enumerable: true, get: function () { return interpret_js_1.interpretDartImport; } });
+Object.defineProperty(exports, "interpretDartTypeBinding", { enumerable: true, get: function () { return interpret_js_1.interpretDartTypeBinding; } });
+Object.defineProperty(exports, "normalizeDartType", { enumerable: true, get: function () { return interpret_js_1.normalizeDartType; } });
+Object.defineProperty(exports, "DART_HERITAGE_PREFIX", { enumerable: true, get: function () { return interpret_js_1.DART_HERITAGE_PREFIX; } });
+var merge_bindings_js_1 = require("./merge-bindings.js");
+Object.defineProperty(exports, "dartMergeBindings", { enumerable: true, get: function () { return merge_bindings_js_1.dartMergeBindings; } });
+var arity_js_1 = require("./arity.js");
+Object.defineProperty(exports, "dartArityCompatibility", { enumerable: true, get: function () { return arity_js_1.dartArityCompatibility; } });
+var import_target_js_1 = require("./import-target.js");
+Object.defineProperty(exports, "resolveDartImportTarget", { enumerable: true, get: function () { return import_target_js_1.resolveDartImportTarget; } });
+var simple_hooks_js_1 = require("./simple-hooks.js");
+Object.defineProperty(exports, "dartBindingScopeFor", { enumerable: true, get: function () { return simple_hooks_js_1.dartBindingScopeFor; } });
+Object.defineProperty(exports, "dartImportOwningScope", { enumerable: true, get: function () { return simple_hooks_js_1.dartImportOwningScope; } });
+Object.defineProperty(exports, "dartReceiverBinding", { enumerable: true, get: function () { return simple_hooks_js_1.dartReceiverBinding; } });

package/dist/core/code/engine/core/ingestion/languages/dart/interpret.js

@@ -0,0 +1,101 @@
+"use strict";
+/**
+ * Dart `CaptureMatch` → semantic-shape interpreters.
+ *
+ *   - `interpretDartImport`  — `@import.source` → a whole-library
+ *     `ParsedImport` (Dart `import`/`export` bring every public top-level
+ *     symbol of the target into scope — whole-library / wildcard-leaf semantics).
+ *     `@import.heritage` markers (synthesized by `captures.ts` for
+ *     `implements`/`with` clauses) become side-effect imports carrying a
+ *     `__heritage__:` payload that `emitDartHeritageEdges` consumes; they
+ *     never produce a real IMPORTS edge (`resolveDartImportTarget` returns
+ *     `null` for them).
+ *   - `interpretDartTypeBinding` — `@type-binding.*` → a `ParsedTypeBinding`,
+ *     normalizing the Dart type (strip nullable `?`, unwrap single-arg
+ *     container generics like `Future<X>`/`List<X>`, drop library prefixes).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DART_HERITAGE_PREFIX = void 0;
+exports.interpretDartImport = interpretDartImport;
+exports.normalizeDartType = normalizeDartType;
+exports.interpretDartTypeBinding = interpretDartTypeBinding;
+const heritage_marker_js_1 = require("../../utils/heritage-marker.js");
+/** Marker prefix carried on a side-effect `ParsedImport.targetRaw` for
+ *  `implements`/`with` heritage, consumed by `emitDartHeritageEdges`. Aliased to
+ *  the shared codec prefix (#1994) so the Dart wire prefix has a single source of
+ *  truth and cannot desync from `encodeMarker`/`decodeMarker`. */
+exports.DART_HERITAGE_PREFIX = heritage_marker_js_1.HERITAGE_MARKER_PREFIX;
+function stripQuotes(s) {
+    return s.replace(/^['"]|['"]$/g, '');
+}
+function interpretDartImport(captures) {
+    const heritageCap = captures['@import.heritage'];
+    if (heritageCap !== undefined) {
+        return { kind: 'side-effect', targetRaw: heritageCap.text };
+    }
+    const sourceCap = captures['@import.source'];
+    if (sourceCap === undefined)
+        return null;
+    const raw = stripQuotes(sourceCap.text);
+    // Dart `import '...'` brings every PUBLIC top-level symbol of the target
+    // library directly into scope (no prefix) — wildcard semantics. The
+    // `expandsWildcardTo` hook enumerates those names so cross-file return
+    // types propagate (`var u = importedFn(); u.m()`).
+    return { kind: 'wildcard', targetRaw: raw };
+}
+/** Container generics whose single type argument is the runtime element
+ *  type a receiver resolves against (`Future<User>` → `User`). */
+const SINGLE_ARG_CONTAINERS = /^(?:Future|FutureOr|List|Iterable|Set|Stream|Optional)<(.+)>$/;
+/** Bare container names. When a type normalizes to one of these (e.g. the
+ *  generic args were stripped upstream so `Future<User>` arrived as `Future`),
+ *  binding to it would let a same-named user class capture the receiver — a
+ *  wrong edge. We suppress the binding instead (leaving the call unresolved,
+ *  matching the legacy DAG) rather than bind to the container name. */
+const BARE_CONTAINER_TYPES = new Set([
+    'Future',
+    'FutureOr',
+    'List',
+    'Iterable',
+    'Set',
+    'Stream',
+    'Optional',
+]);
+function normalizeDartType(text) {
+    let s = text.trim();
+    // Strip nullable suffix (`User?` → `User`).
+    s = s.replace(/\?+$/, '');
+    // Unwrap a single-arg container generic once (`Future<User>` → `User`).
+    const gen = SINGLE_ARG_CONTAINERS.exec(s);
+    if (gen !== null && gen[1] !== undefined)
+        s = gen[1].trim().replace(/\?+$/, '');
+    // Drop a library/namespace prefix (`prefix.User` → `User`).
+    const dot = s.lastIndexOf('.');
+    if (dot !== -1)
+        s = s.slice(dot + 1);
+    return s;
+}
+function interpretDartTypeBinding(captures) {
+    const nameCap = captures['@type-binding.name'];
+    const typeCap = captures['@type-binding.type'];
+    if (nameCap === undefined || typeCap === undefined)
+        return null;
+    const rawType = normalizeDartType(typeCap.text);
+    if (rawType === '' ||
+        rawType === 'void' ||
+        rawType === 'dynamic' ||
+        BARE_CONTAINER_TYPES.has(rawType)) {
+        return null;
+    }
+    let source = 'annotation';
+    if (captures['@type-binding.self'] !== undefined)
+        source = 'self';
+    else if (captures['@type-binding.constructor'] !== undefined)
+        source = 'constructor-inferred';
+    else if (captures['@type-binding.parameter'] !== undefined)
+        source = 'parameter-annotation';
+    else if (captures['@type-binding.return'] !== undefined)
+        source = 'return-annotation';
+    else if (captures['@type-binding.annotation'] !== undefined)
+        source = 'annotation';
+    return { boundName: nameCap.text, rawTypeName: rawType, source };
+}

package/dist/core/code/engine/core/ingestion/languages/dart/merge-bindings.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * Shadowing precedence for the Dart `mergeBindings` hook. Three tiers:
+ * 0 local, 1 import/namespace/reexport, 2 wildcard. Keeps only the best
+ * (lowest) tier present, then de-dups survivors by `def.nodeId`
+ * (last-write-wins). Mirror of `languages/swift/merge-bindings.ts` — Dart
+ * imports bring a whole library namespace into scope (wildcard-leaf), so
+ * local declarations always shadow imported names.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dartMergeBindings = dartMergeBindings;
+// Named tiers (lower = stronger), matching `languages/swift/merge-bindings.ts`.
+const TIER_LOCAL = 0;
+const TIER_IMPORT = 1;
+const TIER_WILDCARD = 2;
+const TIER_UNKNOWN = 3;
+function tierOf(b) {
+    switch (b.origin) {
+        case 'local':
+            return TIER_LOCAL;
+        case 'import':
+        case 'namespace':
+        case 'reexport':
+            return TIER_IMPORT;
+        case 'wildcard':
+            return TIER_WILDCARD;
+        default:
+            return TIER_UNKNOWN;
+    }
+}
+function dartMergeBindings(bindings) {
+    if (bindings.length === 0)
+        return bindings;
+    let bestTier = Number.POSITIVE_INFINITY;
+    for (const b of bindings)
+        bestTier = Math.min(bestTier, tierOf(b));
+    const survivors = bindings.filter((b) => tierOf(b) === bestTier);
+    const seen = new Map();
+    for (const b of survivors)
+        seen.set(b.def.nodeId, b);
+    return [...seen.values()];
+}

package/dist/core/code/engine/core/ingestion/languages/dart/query.js

@@ -0,0 +1,246 @@
+"use strict";
+/**
+ * The Dart scope-capture tree-sitter query (`DART_SCOPE_QUERY`) plus lazy
+ * `Parser`/`Query` singletons. Mirror of `languages/swift/query.ts`.
+ *
+ * Verified against tree-sitter-dart 1.0.0 (UserNobody14, commit 80e23c07,
+ * ABI 14) — every node type below also appears in the legacy `DART_QUERIES`,
+ * which is validated against the same grammar.
+ *
+ * NOTE: This query intentionally covers ONLY the constructs that map cleanly
+ * to a single node + the suffix-driven scope-extractor vocabulary:
+ *   - `@scope.module` / `@scope.class` (type bodies)
+ *   - `@declaration.{class,trait,enum,function,method,constructor,property}`
+ *   - `@import.source`
+ *
+ * The hard parts are synthesized in `captures.ts` instead of queried, because
+ * Dart's grammar can't express them as a single node:
+ *   - Function/method SCOPES — `function_signature` and `function_body` are
+ *     SIBLINGS, so the Function scope must span both (range composition).
+ *   - Calls / member reads — Dart's postfix `identifier (selector …)` chains
+ *     have no `call_expression` node; the receiver is a sibling run.
+ *   - Heritage references (`extends`/`implements`/`with`).
+ *   - Parameter / return / receiver type bindings and arity metadata.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDartParser = getDartParser;
+exports.getDartScopeQuery = getDartScopeQuery;
+const tree_sitter_1 = __importDefault(require("tree-sitter"));
+const index_js_1 = require("../../../../../shared/index.js");
+// `tree-sitter-dart` is an optional/vendored grammar that may be absent on a
+// default install. Loaded lazily + guarded via parser-loader rather than
+// statically imported: this module is pulled onto the main thread eagerly by
+// the scope-resolution registry and the language-provider index, so a top-level
+// `import Dart from 'tree-sitter-dart'` would throw ERR_MODULE_NOT_FOUND at
+// module-load and crash `analyze` even for repos with no Dart files (#2091,
+// #2093). The grammar is only ever needed inside the lazy getters below.
+const parser_loader_js_1 = require("../../../tree-sitter/parser-loader.js");
+const DART_SCOPE_QUERY = `
+; ── Scopes ───────────────────────────────────────────────────────────────────
+(program) @scope.module
+(class_definition) @scope.class
+(mixin_declaration) @scope.class
+(extension_declaration) @scope.class
+(enum_declaration) @scope.class
+
+; ── Declarations — types ─────────────────────────────────────────────────────
+(class_definition name: (identifier) @declaration.name) @declaration.class
+(mixin_declaration (identifier) @declaration.name) @declaration.trait
+(extension_declaration name: (identifier) @declaration.name) @declaration.class
+(enum_declaration name: (identifier) @declaration.name) @declaration.enum
+
+; ── Declarations — type aliases (old-style + new-style function typedefs) ────
+; Both forms parse as type_alias; the name position differs, and a generic
+; <T> parameter list intervenes for the generic variants. Per #1919 review CF2,
+; a generic type_parameters node sits between the name and the next anchor, so
+; the non-generic adjacency patterns silently drop the generic forms. Four
+; standalone patterns (NOT one alternation — the tree-sitter 0.21 hazard drops
+; sibling branches) keep the name capture unambiguous and single-match per form:
+;   non-generic old-style  typedef int Cmp(int a, int b);
+;       children: return-type, NAME, formal_parameter_list
+;   generic old-style      typedef int Cmp<T>(T a, T b);          (CF2)
+;       children: return-type, NAME, type_parameters, formal_parameter_list
+;   non-generic new-style  typedef Pred = bool Function(int);
+;       children: NAME, "=", function_type
+;   generic new-style      typedef Mapper<T> = T Function(T);
+;       children: NAME, type_parameters, "=", function_type
+; The alias name is the type_identifier immediately before the param list (old)
+; or before "=" (new); for the generic forms it is the one immediately before
+; the intervening type_parameters. Mirrors Kotlin's @declaration.type_alias
+; rule; the generic scope-extractor maps "type_alias" → TypeAlias.
+(type_alias
+  (type_identifier) @declaration.name
+  .
+  (formal_parameter_list)) @declaration.type_alias
+(type_alias
+  (type_identifier) @declaration.name
+  .
+  (type_parameters)
+  .
+  (formal_parameter_list)) @declaration.type_alias
+(type_alias
+  (type_identifier) @declaration.name
+  .
+  "=") @declaration.type_alias
+(type_alias
+  (type_identifier) @declaration.name
+  .
+  (type_parameters)
+  .
+  "=") @declaration.type_alias
+
+; ── Declarations — top-level functions (parent is program, not method) ───────
+(program
+  (function_signature
+    name: (identifier) @declaration.name) @declaration.function)
+
+; ── Declarations — closure bound to a local ──────────────────────────────────
+;
+; var handler = (int x) => target(x);   /   var blk = (int y) { ... };
+;
+; Anchor discipline (same contract as javascript/query.ts): @declaration.function
+; sits on the INNER function_expression, NOT on the local_variable_declaration
+; wrapper. Dart is the one language that declares NO @scope.function in this
+; file — its function scopes are SYNTHESIZED in captures.ts from
+; declNode + findFunctionBody(declNode). So this rule deliberately does not add
+; a @scope.function of its own: doing that would collide with the synthesized
+; one at identical range, and duplicate scope ids make buildScopeTree throw,
+; which drops the whole file. Instead findFunctionBody now understands a
+; closure's child function_expression_body, so the existing synthesis produces
+; exactly one scope, anchored on the same node as the declaration (#2699 S4).
+;; THREE binding shapes, not one. Dart wraps only the FIRST local declarator in
+;; initialized_variable_definition; a top-level var and every later declarator
+;; are initialized_identifier, and a top-level final/const is
+;; static_final_declaration. Matching only the first shape left idiomatic
+;; top-level closures and the g of "var f = ..., g = ..." with no declaration
+;; capture, so findFunctionBody never synthesized their scope and they could
+;; never be call SOURCES.
+;;
+;; This mirrors DART_CALLABLE_CAPTURE_OPTIONS.bindingNodeTypes in captures.ts,
+;; which already listed all three for callable-flow. The two lists must stay in
+;; step; dart-closure-binding-shapes.test.ts pins that.
+(initialized_variable_definition
+  (identifier) @declaration.name
+  (function_expression) @declaration.function)
+
+(initialized_identifier
+  (identifier) @declaration.name
+  (function_expression) @declaration.function)
+
+(static_final_declaration
+  (identifier) @declaration.name
+  (function_expression) @declaration.function)
+
+; ── Declarations — methods (inside class/mixin/extension bodies) ─────────────
+(method_signature
+  (function_signature
+    name: (identifier) @declaration.name)) @declaration.method
+
+; ── Declarations — abstract methods (bodyless) ───────────────────────────────
+(declaration
+  (function_signature
+    name: (identifier) @declaration.name)) @declaration.method
+
+; ── Declarations — constructors ──────────────────────────────────────────────
+(constructor_signature
+  name: (identifier) @declaration.name) @declaration.constructor
+
+; ── Declarations — getters / setters (Property, like the legacy DAG) ─────────
+(method_signature
+  (getter_signature
+    name: (identifier) @declaration.name)) @declaration.property
+(method_signature
+  (setter_signature
+    name: (identifier) @declaration.name)) @declaration.property
+
+; ── Declarations — class fields ──────────────────────────────────────────────
+(declaration
+  (type_identifier)
+  (initialized_identifier_list
+    (initialized_identifier
+      . (identifier) @declaration.name))) @declaration.property
+(declaration
+  (nullable_type)
+  (initialized_identifier_list
+    (initialized_identifier
+      . (identifier) @declaration.name))) @declaration.property
+
+; Inference-typed fields — \`var b = Outer();\`, \`final b = Outer();\`,
+; \`late final b = Outer();\`, \`static var b = Outer();\` (#2807). The two
+; patterns above require a written type, so a field whose type comes from its
+; initializer produced NO property declaration at all — no Property node, and
+; nothing for captures.ts to hang a type binding on, so \`b.inner()\` could not
+; resolve its receiver while the annotated twin resolved fine.
+;
+; Dart spells the keyword as \`inferred_type\` for \`var\` and \`final_builtin\`
+; for \`final\` / \`late final\`; both are class fields and both are idiomatic,
+; so covering only one would leave the more common Dart style broken.
+(declaration
+  (inferred_type)
+  (initialized_identifier_list
+    (initialized_identifier
+      . (identifier) @declaration.name))) @declaration.property
+(declaration
+  (final_builtin)
+  (initialized_identifier_list
+    (initialized_identifier
+      . (identifier) @declaration.name))) @declaration.property
+
+; ── Declarations — closure bindings (#2693) ──────────────────────────────────
+; \`var f = (x) => x;\` binds a callable. Without a declaration the binding has
+; no SymbolDefinition, so callable-value-flow has nothing to attach its seed to
+; and \`f()\` stays unresolved even though the graph emits a Function node for it.
+;
+; Restricted to a function_expression value on purpose: declaring every Dart
+; variable would mint defs repo-wide for no resolution benefit. The top-level
+; rule is anchored under (program) — the same disambiguation the graph-node
+; query uses — so class-body fields, which reuse initialized_identifier_list
+; and are already @declaration.property, are never matched twice.
+(program
+  (initialized_identifier_list
+    (initialized_identifier
+      (identifier) @declaration.name
+      (function_expression))) @declaration.variable)
+(program
+  (static_final_declaration_list
+    (static_final_declaration
+      (identifier) @declaration.name
+      (function_expression))) @declaration.variable)
+(initialized_variable_definition
+  name: (identifier) @declaration.name
+  value: (function_expression)) @declaration.variable
+; Second and later declarators of \`var f = .., g = ..;\` are nested
+; initialized_identifier children of the same initialized_variable_definition,
+; which the field-based rule above only reaches for the first name.
+(initialized_variable_definition
+  (initialized_identifier
+    (identifier) @declaration.name
+    (function_expression)) @declaration.variable)
+
+; ── Imports / re-exports ─────────────────────────────────────────────────────
+(import_or_export
+  (library_import
+    (import_specification
+      (configurable_uri) @import.source))) @import.statement
+(import_or_export
+  (library_export
+    (configurable_uri) @import.source)) @import.statement
+`;
+let _parser = null;
+let _query = null;
+function getDartParser() {
+    if (_parser === null) {
+        _parser = new tree_sitter_1.default();
+        _parser.setLanguage((0, parser_loader_js_1.getLanguageGrammar)(index_js_1.SupportedLanguages.Dart));
+    }
+    return _parser;
+}
+function getDartScopeQuery() {
+    if (_query === null) {
+        _query = new tree_sitter_1.default.Query((0, parser_loader_js_1.getLanguageGrammar)(index_js_1.SupportedLanguages.Dart), DART_SCOPE_QUERY);
+    }
+    return _query;
+}

package/dist/core/code/engine/core/ingestion/languages/dart/receiver-binding.js

@@ -0,0 +1,90 @@
+"use strict";
+/**
+ * Synthesize the implicit `this` (and `super`) receiver type-binding for a
+ * Dart instance method — tree-sitter can't express the implicit receiver via
+ * a static query pattern. Mirror of `languages/swift/receiver-binding.ts`,
+ * adapted for Dart's grammar:
+ *
+ *   - The receiver name is `this` (Swift's `self`); `super` is the
+ *     superclass receiver.
+ *   - Dart's `function_signature`/`function_body` are SIBLINGS (not a
+ *     `body:` field), so the caller passes the resolved `function_body`
+ *     node explicitly as the anchor — anchoring the binding inside the body
+ *     guarantees it lands in the (synthesized) Function scope, not the
+ *     enclosing Class scope.
+ *   - Static methods (`dartMethodConfig.isStatic`) and bodyless declarations
+ *     get no receiver binding.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.synthesizeDartReceiverBinding = synthesizeDartReceiverBinding;
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+const dart_js_1 = require("../../method-extractors/configs/dart.js");
+const TYPE_DECL_TYPES = new Set([
+    'class_definition',
+    'mixin_declaration',
+    'extension_declaration',
+    'enum_declaration',
+]);
+/** Walk up from a method declaration node to its enclosing type declaration. */
+function findEnclosingTypeDeclaration(node) {
+    let cur = node.parent;
+    while (cur !== null) {
+        if (TYPE_DECL_TYPES.has(cur.type))
+            return cur;
+        cur = cur.parent;
+    }
+    return null;
+}
+/** The bare type name for a type declaration (`class Foo` → `Foo`). */
+function enclosingTypeName(typeNode) {
+    if (typeNode.type === 'mixin_declaration') {
+        // mixin has no `name:` field — first identifier child is the name.
+        for (let i = 0; i < typeNode.namedChildCount; i++) {
+            const c = typeNode.namedChild(i);
+            if (c !== null && c.type === 'identifier')
+                return c.text;
+        }
+        return null;
+    }
+    const nameNode = typeNode.childForFieldName('name');
+    return nameNode !== null ? nameNode.text : null;
+}
+/** The first `extends` superclass type name, if any (for `super`). */
+function firstSuperType(typeNode) {
+    const superclass = typeNode.childForFieldName('superclass');
+    if (superclass === null)
+        return null;
+    for (let i = 0; i < superclass.namedChildCount; i++) {
+        const c = superclass.namedChild(i);
+        if (c !== null && c.type === 'type_identifier')
+            return c.text;
+    }
+    return null;
+}
+function buildReceiverMatch(anchor, name, typeText) {
+    return {
+        '@type-binding.self': (0, ast_helpers_js_1.nodeToCapture)('@type-binding.self', anchor),
+        '@type-binding.name': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.name', anchor, name),
+        '@type-binding.type': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.type', anchor, typeText),
+    };
+}
+/**
+ * `declNode` is the method declaration wrapper (`method_signature` /
+ * `declaration` / top-level `function_signature`). `bodyNode` is the
+ * resolved sibling `function_body` (the anchor for Function-scope landing).
+ */
+function synthesizeDartReceiverBinding(declNode, bodyNode) {
+    if (dart_js_1.dartMethodConfig.isStatic(declNode))
+        return [];
+    const enclosingType = findEnclosingTypeDeclaration(declNode);
+    if (enclosingType === null)
+        return []; // top-level function — no receiver
+    const typeName = enclosingTypeName(enclosingType);
+    if (typeName === null)
+        return [];
+    const out = [buildReceiverMatch(bodyNode, 'this', typeName)];
+    const superType = firstSuperType(enclosingType);
+    if (superType !== null)
+        out.push(buildReceiverMatch(bodyNode, 'super', superType));
+    return out;
+}