gitnexus 1.6.6-rc.98 → 1.6.6

package/dist/core/ingestion/languages/dart/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 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
+ */
+export { emitDartScopeCaptures } from './captures.js';
+export { getDartCaptureCacheStats, resetDartCaptureCacheStats } from './cache-stats.js';
+export { interpretDartImport, interpretDartTypeBinding, normalizeDartType, DART_HERITAGE_PREFIX, } from './interpret.js';
+export { dartMergeBindings } from './merge-bindings.js';
+export { dartArityCompatibility } from './arity.js';
+export { resolveDartImportTarget } from './import-target.js';
+export { dartBindingScopeFor, dartImportOwningScope, dartReceiverBinding } from './simple-hooks.js';

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

@@ -0,0 +1,28 @@
+/**
+ * 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
+ */
+export { emitDartScopeCaptures } from './captures.js';
+export { getDartCaptureCacheStats, resetDartCaptureCacheStats } from './cache-stats.js';
+export { interpretDartImport, interpretDartTypeBinding, normalizeDartType, DART_HERITAGE_PREFIX, } from './interpret.js';
+export { dartMergeBindings } from './merge-bindings.js';
+export { dartArityCompatibility } from './arity.js';
+export { resolveDartImportTarget } from './import-target.js';
+export { dartBindingScopeFor, dartImportOwningScope, dartReceiverBinding } from './simple-hooks.js';

package/dist/core/ingestion/languages/dart/interpret.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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).
+ */
+import type { CaptureMatch, ParsedImport, ParsedTypeBinding } from '../../../../_shared/index.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`. */
+export declare const DART_HERITAGE_PREFIX: string;
+export declare function interpretDartImport(captures: CaptureMatch): ParsedImport | null;
+export declare function normalizeDartType(text: string): string;
+export declare function interpretDartTypeBinding(captures: CaptureMatch): ParsedTypeBinding | null;

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

@@ -0,0 +1,95 @@
+/**
+ * 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).
+ */
+import { HERITAGE_MARKER_PREFIX } from '../../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`. */
+export const DART_HERITAGE_PREFIX = HERITAGE_MARKER_PREFIX;
+function stripQuotes(s) {
+    return s.replace(/^['"]|['"]$/g, '');
+}
+export 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',
+]);
+export 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;
+}
+export 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/ingestion/languages/dart/merge-bindings.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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.
+ */
+import type { BindingRef } from '../../../../_shared/index.js';
+export declare function dartMergeBindings(bindings: readonly BindingRef[]): readonly BindingRef[];

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

@@ -0,0 +1,39 @@
+/**
+ * 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.
+ */
+// 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;
+    }
+}
+export 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/ingestion/languages/dart/query.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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.
+ */
+import Parser from 'tree-sitter';
+export declare function getDartParser(): Parser;
+export declare function getDartScopeQuery(): Parser.Query;

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

@@ -0,0 +1,142 @@
+/**
+ * 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.
+ */
+import Parser from 'tree-sitter';
+import Dart from 'tree-sitter-dart';
+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 — 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
+
+; ── 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;
+export function getDartParser() {
+    if (_parser === null) {
+        _parser = new Parser();
+        _parser.setLanguage(Dart);
+    }
+    return _parser;
+}
+export function getDartScopeQuery() {
+    if (_query === null) {
+        _query = new Parser.Query(Dart, DART_SCOPE_QUERY);
+    }
+    return _query;
+}

package/dist/core/ingestion/languages/dart/receiver-binding.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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.
+ */
+import { type SyntaxNode } from '../../utils/ast-helpers.js';
+import type { CaptureMatch } from '../../../../_shared/index.js';
+/**
+ * `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).
+ */
+export declare function synthesizeDartReceiverBinding(declNode: SyntaxNode, bodyNode: SyntaxNode): CaptureMatch[];

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

@@ -0,0 +1,87 @@
+/**
+ * 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.
+ */
+import { nodeToCapture, syntheticCapture } from '../../utils/ast-helpers.js';
+import { dartMethodConfig } from '../../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': nodeToCapture('@type-binding.self', anchor),
+        '@type-binding.name': syntheticCapture('@type-binding.name', anchor, name),
+        '@type-binding.type': 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).
+ */
+export function synthesizeDartReceiverBinding(declNode, bodyNode) {
+    if (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;
+}

package/dist/core/ingestion/languages/dart/scope-resolver.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Dart `ScopeResolver` registered in `SCOPE_RESOLVERS` and consumed by the
+ * generic `runScopeResolution` orchestrator (RFC #909 Ring 3, issue #939).
+ *
+ * Closest reference: Swift (`swiftScopeResolver`) — both are statically typed,
+ * have no `new` keyword, and model `Type(...)` as a reference to the type.
+ *
+ * ## Dart specifics
+ *
+ *   - **`implements` / `with`.** Dart can implement (and mixes in) ordinary
+ *     classes, so the edge type cannot be decided from the target's symbol
+ *     kind (the generic `preEmitInheritanceEdges` pre-pass routes
+ *     `Interface`/`Trait` → IMPLEMENTS, everything else → EXTENDS). `extends`
+ *     is captured as `@reference.inherits` and rides the generic pre-pass
+ *     (target is a class → EXTENDS); `implements`/`with` are carried as
+ *     `__heritage__:` side-effect imports and emitted here as IMPLEMENTS by
+ *     `emitDartHeritageEdges`. METHOD_IMPLEMENTS then falls out of the shared
+ *     MRO/interface-dispatch phase.
+ *   - **Mixin MRO.** `buildDartMro` augments the EXTENDS chain with mixin /
+ *     interface ancestors (IMPLEMENTS edges) so mixed-in members participate
+ *     in method lookup (PHP/Ruby trait pattern).
+ *   - **No `new`.** `Type(...)` resolves to the Class node
+ *     (`constructorCallTargetsClass`); the cross-file global free-call
+ *     fallback is allowed (`allowGlobalFreeCallFallback`).
+ *   - **Statically typed** → `fieldFallbackOnMethodLookup: false` (the
+ *     field-walk heuristic over-connects when types are reliable).
+ */
+import type { ScopeResolver } from '../../scope-resolution/contract/scope-resolver.js';
+export declare const dartScopeResolver: ScopeResolver;