gitnexus 1.6.6-rc.99 → 1.6.6

package/dist/core/ingestion/languages/dart/scope-resolver.js

@@ -0,0 +1,194 @@
+/**
+ * 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 { SupportedLanguages } from '../../../../_shared/index.js';
+import { buildMro, defaultLinearize } from '../../scope-resolution/passes/mro.js';
+import { populateClassOwnedMembers, isClassLike } from '../../scope-resolution/scope/walkers.js';
+import { resolveDefGraphId } from '../../scope-resolution/graph-bridge/ids.js';
+import { generateId } from '../../../../lib/utils.js';
+import { dartProvider } from '../dart.js';
+import { dartArityCompatibility, dartMergeBindings, resolveDartImportTarget } from './index.js';
+import { decodeMarker } from '../../utils/heritage-marker.js';
+import { expandDartWildcardNames } from './expand-wildcards.js';
+/**
+ * Resolve a class simple name to a graph id with FILE AFFINITY: prefer a
+ * definition in `preferredFile`, then a workspace-unique match, otherwise
+ * refuse to guess (return undefined). This avoids the cross-file simple-name
+ * collision a global last-write-wins map produces — two files each declaring
+ * `Logger` where one `implements Logger` must bind its OWN file's `Logger`.
+ */
+function pickClassByName(name, preferredFile, defsByName) {
+    const cands = defsByName.get(name);
+    if (cands === undefined || cands.length === 0)
+        return undefined;
+    const sameFile = cands.find((c) => c.filePath === preferredFile);
+    if (sameFile !== undefined)
+        return sameFile.graphId;
+    if (cands.length === 1)
+        return cands[0].graphId;
+    return undefined; // ambiguous across files, none same-file — don't emit a wrong edge
+}
+/**
+ * Emit IMPLEMENTS edges for Dart `implements`/`with` clauses, carried from
+ * `captures.ts` as `__heritage__:<kind>:<base>:<child>` side-effect imports.
+ * The marker lives in the implementing class's `ParsedFile`, so both the child
+ * and base names are resolved with same-file affinity (see `pickClassByName`),
+ * which keeps cross-file same-name classes from collapsing (mirror of Ruby's
+ * `emitRubyMixinEdges`, with the #1951-style file-affinity hardening).
+ */
+function emitDartHeritageEdges(graph, parsedFiles, nodeLookup) {
+    const defsByName = new Map();
+    for (const parsed of parsedFiles) {
+        for (const def of parsed.localDefs) {
+            if (!isClassLike(def.type))
+                continue;
+            const graphId = resolveDefGraphId(parsed.filePath, def, nodeLookup);
+            if (graphId === undefined)
+                continue;
+            const simpleName = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
+            if (simpleName === '')
+                continue;
+            let list = defsByName.get(simpleName);
+            if (list === undefined) {
+                list = [];
+                defsByName.set(simpleName, list);
+            }
+            list.push({ graphId, filePath: parsed.filePath });
+        }
+    }
+    // Pre-seed with existing IMPLEMENTS edges (reason-qualified) so a class that
+    // both `implements X` and `with X` keeps both distinct edges.
+    const emitted = new Set();
+    for (const rel of graph.iterRelationshipsByType('IMPLEMENTS')) {
+        emitted.add(`${rel.sourceId}->${rel.targetId}:${rel.reason}`);
+    }
+    for (const parsed of parsedFiles) {
+        for (const imp of parsed.parsedImports) {
+            const raw = imp.targetRaw;
+            if (typeof raw !== 'string')
+                continue;
+            const decoded = decodeMarker(raw);
+            if (decoded?.kind !== 'heritage')
+                continue;
+            const parts = decoded.fields;
+            if (parts.length < 3)
+                continue;
+            const [kind, baseName, childName] = parts;
+            const childId = pickClassByName(childName, parsed.filePath, defsByName);
+            const baseId = pickClassByName(baseName, parsed.filePath, defsByName);
+            if (childId === undefined || baseId === undefined || childId === baseId)
+                continue;
+            const key = `${childId}->${baseId}:${kind}`;
+            if (emitted.has(key))
+                continue;
+            emitted.add(key);
+            graph.addRelationship({
+                id: generateId('IMPLEMENTS', key),
+                sourceId: childId,
+                targetId: baseId,
+                type: 'IMPLEMENTS',
+                confidence: 0.9,
+                reason: kind,
+            });
+        }
+    }
+}
+/**
+ * Dart MRO: the EXTENDS superclass chain (`defaultLinearize`) augmented with
+ * mixin / interface ancestors discovered via IMPLEMENTS edges, so mixed-in and
+ * interface-default members participate in method lookup. Mixins are appended
+ * after the superclass chain (first-seen approximates Dart linearization for
+ * dispatch purposes).
+ */
+function buildDartMro(graph, parsedFiles, nodeLookup) {
+    const mro = buildMro(graph, parsedFiles, nodeLookup, defaultLinearize);
+    const defIdByGraphId = new Map();
+    for (const parsed of parsedFiles) {
+        for (const def of parsed.localDefs) {
+            if (!isClassLike(def.type))
+                continue;
+            const graphId = resolveDefGraphId(parsed.filePath, def, nodeLookup);
+            if (graphId !== undefined)
+                defIdByGraphId.set(graphId, def.nodeId);
+        }
+    }
+    const implsByChild = new Map();
+    for (const rel of graph.iterRelationshipsByType('IMPLEMENTS')) {
+        const child = defIdByGraphId.get(rel.sourceId);
+        const base = defIdByGraphId.get(rel.targetId);
+        if (child === undefined || base === undefined)
+            continue;
+        let set = implsByChild.get(child);
+        if (set === undefined) {
+            set = new Set();
+            implsByChild.set(child, set);
+        }
+        set.add(base);
+    }
+    for (const [childDefId, impls] of implsByChild) {
+        const extendsChain = mro.get(childDefId) ?? [];
+        const seen = new Set(extendsChain);
+        const merged = [...extendsChain];
+        for (const base of impls) {
+            if (!seen.has(base)) {
+                seen.add(base);
+                merged.push(base);
+            }
+        }
+        mro.set(childDefId, merged);
+    }
+    return mro;
+}
+export const dartScopeResolver = {
+    language: SupportedLanguages.Dart,
+    languageProvider: dartProvider,
+    importEdgeReason: 'dart-scope: import',
+    resolveImportTarget: (targetRaw, fromFile, allFilePaths) => resolveDartImportTarget(targetRaw, fromFile, allFilePaths),
+    // Dart `import` is whole-library: every public top-level symbol of the
+    // target enters scope. Enumerating them lets `propagateImportedReturnTypes`
+    // mirror imported functions' return types into the importer.
+    expandsWildcardTo: (targetModuleScope, parsedFiles) => expandDartWildcardNames(targetModuleScope, parsedFiles),
+    // Dart shadowing: local declarations hide imports.
+    mergeBindings: (existing, incoming) => [...dartMergeBindings([...existing, ...incoming])],
+    // Adapter: dartArityCompatibility uses (def, callsite); contract is (callsite, def).
+    arityCompatibility: (callsite, def) => dartArityCompatibility(def, callsite),
+    buildMro: (graph, parsedFiles, nodeLookup) => buildDartMro(graph, parsedFiles, nodeLookup),
+    // Methods/fields are owned by their enclosing class/mixin/extension.
+    populateOwners: (parsed) => populateClassOwnedMembers(parsed),
+    // `super.method()` dispatches through the superclass + mixin chain.
+    isSuperReceiver: (text) => text.trim() === 'super',
+    // `implements` / `with` IMPLEMENTS edges (extends rides the generic
+    // inherits pre-pass; these need an explicit, kind-independent edge type).
+    emitHeritageEdges: (graph, parsedFiles, nodeLookup) => emitDartHeritageEdges(graph, parsedFiles, nodeLookup),
+    // Dart is statically typed — the field-fallback heuristic over-connects.
+    fieldFallbackOnMethodLookup: false,
+    propagatesReturnTypesAcrossImports: true,
+    // No `new`: bare `Foo()` resolves to the type; with cross-file imports the
+    // callee is reachable workspace-wide.
+    allowGlobalFreeCallFallback: true,
+    constructorCallTargetsClass: true,
+};

package/dist/core/ingestion/languages/dart/signature-bindings.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Synthesize parameter-type and return-type bindings for a Dart function /
+ * method. Mirror of `languages/swift/signature-bindings.ts`:
+ *
+ *   - Parameter bindings (`@type-binding.parameter`) are anchored on the
+ *     `function_body` node so they land in the (synthesized) Function scope
+ *     — the receiver of `param.method()` resolves against the param's type.
+ *   - The return-type binding (`@type-binding.return`) is anchored on the
+ *     declaration node and carries the function name → return type; the
+ *     `bindingScopeFor` hook hoists it to the Module scope so callers (and
+ *     `propagateImportedReturnTypes`) see `var u = getUser(); u.m()` resolve.
+ *
+ * Reuses `dartMethodConfig.extractParameters/extractName/extractReturnType`,
+ * which descend the `method_signature`/`declaration` wrapper internally.
+ */
+import { type SyntaxNode } from '../../utils/ast-helpers.js';
+import type { CaptureMatch } from '../../../../_shared/index.js';
+/**
+ * `declNode` is the declaration wrapper. `bodyNode` is the resolved sibling
+ * `function_body` (or `null` for a bodyless/abstract declaration, in which
+ * case only the return binding is emitted).
+ */
+export declare function synthesizeDartSignatureBindings(declNode: SyntaxNode, bodyNode: SyntaxNode | null): CaptureMatch[];

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

@@ -0,0 +1,51 @@
+/**
+ * Synthesize parameter-type and return-type bindings for a Dart function /
+ * method. Mirror of `languages/swift/signature-bindings.ts`:
+ *
+ *   - Parameter bindings (`@type-binding.parameter`) are anchored on the
+ *     `function_body` node so they land in the (synthesized) Function scope
+ *     — the receiver of `param.method()` resolves against the param's type.
+ *   - The return-type binding (`@type-binding.return`) is anchored on the
+ *     declaration node and carries the function name → return type; the
+ *     `bindingScopeFor` hook hoists it to the Module scope so callers (and
+ *     `propagateImportedReturnTypes`) see `var u = getUser(); u.m()` resolve.
+ *
+ * Reuses `dartMethodConfig.extractParameters/extractName/extractReturnType`,
+ * which descend the `method_signature`/`declaration` wrapper internally.
+ */
+import { nodeToCapture, syntheticCapture } from '../../utils/ast-helpers.js';
+import { dartMethodConfig } from '../../method-extractors/configs/dart.js';
+function buildBindingMatch(anchor, sourceTag, name, typeText) {
+    return {
+        [sourceTag]: nodeToCapture(sourceTag, anchor),
+        '@type-binding.name': syntheticCapture('@type-binding.name', anchor, name),
+        '@type-binding.type': syntheticCapture('@type-binding.type', anchor, typeText),
+    };
+}
+/**
+ * `declNode` is the declaration wrapper. `bodyNode` is the resolved sibling
+ * `function_body` (or `null` for a bodyless/abstract declaration, in which
+ * case only the return binding is emitted).
+ */
+export function synthesizeDartSignatureBindings(declNode, bodyNode) {
+    const out = [];
+    if (bodyNode !== null) {
+        const params = dartMethodConfig.extractParameters?.(declNode) ?? [];
+        for (const p of params) {
+            if (p.type === null || p.name === '')
+                continue;
+            out.push(buildBindingMatch(bodyNode, '@type-binding.parameter', p.name, p.type));
+        }
+    }
+    const returnType = dartMethodConfig.extractReturnType?.(declNode);
+    const funcName = dartMethodConfig.extractName?.(declNode);
+    if (funcName !== undefined &&
+        funcName !== '' &&
+        returnType !== undefined &&
+        returnType !== '' &&
+        returnType !== 'void' &&
+        returnType !== 'dynamic') {
+        out.push(buildBindingMatch(declNode, '@type-binding.return', funcName, returnType));
+    }
+    return out;
+}

package/dist/core/ingestion/languages/dart/simple-hooks.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Small explicit Dart scope-resolution hooks:
+ *
+ *   - `dartBindingScopeFor` — (1) hoists `@type-binding.return` bindings to
+ *     the Module scope so chain-follow + `propagateImportedReturnTypes` see
+ *     them; (2) hoists function/method/constructor declaration NAMES to the
+ *     enclosing parent scope. The second case is Dart-specific: because
+ *     `function_signature`/`function_body` are siblings, the synthesized
+ *     Function scope starts AT the declaration, so the central auto-hoist
+ *     (which fires only when the declaration anchor range equals the scope
+ *     range) does not trigger; without this the function name would bind
+ *     inside its own body instead of being visible to callers/siblings.
+ *   - `dartImportOwningScope` — imports attach to the Module scope only.
+ *   - `dartReceiverBinding` — the implicit `this`/`super` receiver of a
+ *     Function scope.
+ */
+import type { ParsedImport, Scope, ScopeId, ScopeTree, TypeRef, CaptureMatch } from '../../../../_shared/index.js';
+export declare function dartBindingScopeFor(decl: CaptureMatch, innermost: Scope, tree: ScopeTree): ScopeId | null;
+export declare function dartImportOwningScope(_imp: ParsedImport, innermost: Scope, _tree: ScopeTree): ScopeId | null;
+export declare function dartReceiverBinding(functionScope: Scope): TypeRef | null;

package/dist/core/ingestion/languages/dart/simple-hooks.js

@@ -0,0 +1,47 @@
+/**
+ * Small explicit Dart scope-resolution hooks:
+ *
+ *   - `dartBindingScopeFor` — (1) hoists `@type-binding.return` bindings to
+ *     the Module scope so chain-follow + `propagateImportedReturnTypes` see
+ *     them; (2) hoists function/method/constructor declaration NAMES to the
+ *     enclosing parent scope. The second case is Dart-specific: because
+ *     `function_signature`/`function_body` are siblings, the synthesized
+ *     Function scope starts AT the declaration, so the central auto-hoist
+ *     (which fires only when the declaration anchor range equals the scope
+ *     range) does not trigger; without this the function name would bind
+ *     inside its own body instead of being visible to callers/siblings.
+ *   - `dartImportOwningScope` — imports attach to the Module scope only.
+ *   - `dartReceiverBinding` — the implicit `this`/`super` receiver of a
+ *     Function scope.
+ */
+export function dartBindingScopeFor(decl, innermost, tree) {
+    // (1) Return-type bindings hoist to the Module scope.
+    if (decl['@type-binding.return'] !== undefined) {
+        let cur = innermost;
+        while (cur !== undefined && cur.kind !== 'Module') {
+            const parentId = cur.parent;
+            if (parentId === null)
+                break;
+            cur = tree.getScope(parentId);
+        }
+        if (cur !== undefined && cur.kind === 'Module')
+            return cur.id;
+        return null;
+    }
+    // (2) Function/method/constructor names are visible in the enclosing scope.
+    if (decl['@declaration.function'] !== undefined ||
+        decl['@declaration.method'] !== undefined ||
+        decl['@declaration.constructor'] !== undefined) {
+        if (innermost.kind === 'Function' && innermost.parent !== null)
+            return innermost.parent;
+    }
+    return null;
+}
+export function dartImportOwningScope(_imp, innermost, _tree) {
+    return innermost.kind === 'Module' ? innermost.id : null;
+}
+export function dartReceiverBinding(functionScope) {
+    if (functionScope.kind !== 'Function')
+        return null;
+    return functionScope.typeBindings.get('this') ?? functionScope.typeBindings.get('super') ?? null;
+}

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

@@ -2,7 +2,6 @@
  * Dart Language Provider
  *
  * Dart traits:
- *   - importSemantics: 'wildcard-leaf' (Dart imports bring everything public into scope)
  *   - exportChecker: public if no leading underscore
  *   - Dart SDK imports (dart:*) and external packages are skipped
  *   - enclosingFunctionFinder: Dart's tree-sitter grammar places function_body

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

@@ -2,7 +2,6 @@
  * Dart Language Provider
  *
  * Dart traits:
- *   - importSemantics: 'wildcard-leaf' (Dart imports bring everything public into scope)
  *   - exportChecker: public if no leading underscore
  *   - Dart SDK imports (dart:*) and external packages are skipped
  *   - enclosingFunctionFinder: Dart's tree-sitter grammar places function_body
@@ -27,7 +26,8 @@ import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { dartVariableConfig } from '../variable-extractors/configs/dart.js';
 import { createCallExtractor } from '../call-extractors/generic.js';
 import { dartCallConfig } from '../call-extractors/configs/dart.js';
-import { createHeritageExtractor } from '../heritage-extractors/generic.js';
+import { emitDartScopeCaptures, interpretDartImport, interpretDartTypeBinding, dartBindingScopeFor, dartImportOwningScope, dartReceiverBinding, dartMergeBindings, dartArityCompatibility, } from './dart/index.js';
+import { DART_BUILT_INS } from './dart/built-ins.js';
 /**
  * Resolve the enclosing function from a `function_body` node by looking at its
  * previous sibling.  In Dart's tree-sitter grammar, function_signature and
@@ -59,30 +59,6 @@ const dartEnclosingFunctionFinder = (node) => {
     const funcName = target.childForFieldName?.('name')?.text ?? null;
     return funcName ? { funcName, label } : null;
 };
-const BUILT_INS = new Set([
-    'setState',
-    'mounted',
-    'debugPrint',
-    'runApp',
-    'showDialog',
-    'showModalBottomSheet',
-    'Navigator',
-    'push',
-    'pushNamed',
-    'pushReplacement',
-    'pop',
-    'maybePop',
-    'ScaffoldMessenger',
-    'showSnackBar',
-    'deactivate',
-    'reassemble',
-    'debugDumpApp',
-    'debugDumpRenderTree',
-    'then',
-    'catchError',
-    'whenComplete',
-    'listen',
-]);
 export const dartProvider = defineLanguage({
     id: SupportedLanguages.Dart,
     extensions: ['.dart'],
@@ -126,13 +102,23 @@ export const dartProvider = defineLanguage({
     typeConfig: dartConfig,
     exportChecker: dartExportChecker,
     importResolver: createImportResolver(dartImportConfig),
-    importSemantics: 'wildcard-leaf',
     callExtractor: createCallExtractor(dartCallConfig),
     fieldExtractor: createFieldExtractor(dartFieldConfig),
     methodExtractor: createMethodExtractor(dartMethodConfig),
     variableExtractor: createVariableExtractor(dartVariableConfig),
     classExtractor: createClassExtractor(dartClassConfig),
-    heritageExtractor: createHeritageExtractor(SupportedLanguages.Dart),
     enclosingFunctionFinder: dartEnclosingFunctionFinder,
-    builtInNames: BUILT_INS,
+    builtInNames: DART_BUILT_INS,
+    // ── Scope-based resolution hooks (RFC #909 Ring 3, issue #939) ──────────────
+    // Parsing-side surface consumed by `ScopeExtractor` once per file. The
+    // emit-side `ScopeResolver` lives in `dart/scope-resolver.ts`; the same
+    // function references flow through both interfaces.
+    emitScopeCaptures: emitDartScopeCaptures,
+    interpretImport: interpretDartImport,
+    interpretTypeBinding: interpretDartTypeBinding,
+    bindingScopeFor: dartBindingScopeFor,
+    importOwningScope: dartImportOwningScope,
+    receiverBinding: dartReceiverBinding,
+    mergeBindings: (_scope, bindings) => dartMergeBindings(bindings),
+    arityCompatibility: dartArityCompatibility,
 });

package/dist/core/ingestion/languages/go/arity-metadata.d.ts

@@ -3,6 +3,7 @@ export interface GoArityMetadata {
     readonly parameterCount?: number;
     readonly requiredParameterCount?: number;
     readonly parameterTypes?: readonly string[];
+    readonly returnType?: string;
 }
 export declare function computeGoDeclarationArity(node: SyntaxNode): GoArityMetadata;
 export declare function computeGoCallArity(callNode: SyntaxNode): number;

package/dist/core/ingestion/languages/go/arity-metadata.js

@@ -1,7 +1,14 @@
 export function computeGoDeclarationArity(node) {
     const params = node.childForFieldName('parameters');
+    const returnType = extractGoReturnType(node);
     if (params === null)
-        return {};
+        return returnType === undefined ? {} : { returnType };
+    return {
+        ...computeGoParameterMetadata(params),
+        ...(returnType === undefined ? {} : { returnType }),
+    };
+}
+function computeGoParameterMetadata(params) {
     let count = 0;
     let required = 0;
     const types = [];
@@ -35,3 +42,26 @@ export function computeGoCallArity(callNode) {
         return 0;
     return args.namedChildCount;
 }
+function extractGoReturnType(node) {
+    const result = node.childForFieldName('result');
+    if (result === null)
+        return undefined;
+    if (result.type !== 'parameter_list')
+        return result.text;
+    const returnTypes = [];
+    for (const child of result.namedChildren) {
+        if (child.type !== 'parameter_declaration')
+            continue;
+        const typeNode = child.childForFieldName('type');
+        if (typeNode === null)
+            continue;
+        const names = child.namedChildren.filter((c) => c.type === 'identifier');
+        const n = Math.max(1, names.length);
+        for (let i = 0; i < n; i++) {
+            returnTypes.push(typeNode.text);
+        }
+    }
+    if (returnTypes.length === 0)
+        return undefined;
+    return returnTypes.length === 1 ? returnTypes[0] : `(${returnTypes.join(', ')})`;
+}