gitnexus 1.6.6-rc.98 → 1.6.6

package/dist/core/ingestion/languages/csharp/namespace-siblings.js

@@ -18,11 +18,20 @@
  * The orchestrator hands us its `treeCache` so files already parsed
  * by `extractParsedFile` are re-used instead of re-parsed —
  * `ParsedFile`'s underlying tree is the single source of truth.
- * Group classes by namespace, and append cross-file sibling classes
- * into each Namespace scope's `bindingAugmentations` bucket with
- * `origin: 'namespace'`. Finalized bindings remain first in
- * `lookupBindingsAt`, and local lexical `Scope.bindings` remains the
- * first-tier shadowing channel.
+ * Group classes by namespace, then route cross-file sibling classes
+ * (and method return-type bindings) through SHARED, per-namespace
+ * channels — `namespaceFqnBindings` / `namespaceTypeBindings`, keyed by
+ * namespace name — populated ONCE per bucket with `origin: 'namespace'`,
+ * rather than copied into every sibling's per-scope `bindingAugmentations`
+ * / `Scope.typeBindings`. That per-file copy was O(files²) for a
+ * concentrated namespace and OOM'd large solutions (#1871; the global
+ * twin was fixed in #1905/#1954). The walkers consult these channels
+ * gated by `accessibleNamespacesByScope` (a file's own namespace +
+ * `using` targets), so visibility is unchanged — only the storage is
+ * shared. Finalized bindings remain first in `lookupBindingsAt`, and
+ * local lexical `Scope.bindings` remains the first-tier shadowing
+ * channel. (`using static` member exposure still uses the per-scope
+ * augmentation channel — it is per-import and not part of the blow-up.)
  *
  * The tree-sitter walk is authoritative: it sees `global using static`,
  * aliased `using static X = Y.Z;`, attributed namespace declarations,
@@ -378,39 +387,87 @@ export function populateCsharpNamespaceSiblings(parsedFiles, indexes, inputs) {
     // via `lookupBindingsAt`; we never need to consult or mutate
     // `indexes.bindings`.
     const augmentations = indexes.bindingAugmentations;
-    // Cross-namespace type-binding propagation: for each file, mirror
-    // method return-type bindings from same-namespace sibling files and
-    // from files in namespaces the importer `using`s, into the
-    // importer's Module scope typeBindings. This enables
-    // chain-follow from `var u = svc.GetUser()` → `GetUser → User`
-    // even across files — without it the chain stalls at `GetUser`
-    // because the return binding lives in the defining file's Module
-    // scope, which isn't an ancestor of the importer's scope chain.
+    // Global ('') namespace type-binding propagation (#1871). Types in the C#
+    // unnamed/global namespace form a single declaration space that is
+    // type-visible from EVERY file — including files inside named namespaces
+    // (C# spec: "any identifier in the global namespace is available for use in
+    // a named namespace"). Route their module-scope return-type bindings through
+    // the scope-independent `workspaceTypeBindings` channel ONCE, rather than
+    // copying every global file's bindings into every other file's
+    // `Scope.typeBindings`. That per-file copy was O(files × distinct-names) in
+    // both time and memory and OOM'd large no-namespace solutions (tens of
+    // thousands of files in the global bucket → billions of Map entries). This
+    // mirrors how Roslyn resolves against a single `Compilation.GlobalNamespace`
+    // symbol instead of per-file copies, and is the typeBindings analogue of the
+    // `workspaceFqnBindings` fast-path (#1905). `findReceiverTypeBinding` /
+    // `followChainPostFinalize` consult this channel as a final fallback.
+    const workspaceTypeBindings = indexes.workspaceTypeBindings;
+    const globalBucket = buckets.get('');
+    if (globalBucket !== undefined) {
+        for (const scopeInfo of globalBucket.scopes) {
+            if (scopeInfo.scope.kind !== 'Module')
+                continue;
+            for (const [boundName, typeRef] of scopeInfo.scope.typeBindings) {
+                // First-wins, matching the old per-importer `has(boundName)` skip:
+                // same-name collisions across global files are inherently ambiguous.
+                if (!workspaceTypeBindings.has(boundName)) {
+                    workspaceTypeBindings.set(boundName, typeRef);
+                }
+            }
+        }
+    }
+    // Named-namespace type-binding propagation (#1871). Method return-type
+    // bindings are routed through the per-namespace `namespaceTypeBindings`
+    // channel — populated ONCE per named bucket — instead of copied into every
+    // sibling/importer file's Module `Scope.typeBindings`. That per-file copy was
+    // O(files²) for a concentrated named namespace (the global twin of which #1954
+    // already moved to `workspaceTypeBindings`); a solution with all files under
+    // one `namespace App;` reproduced the same OOM. The chain-walkers
+    // (`findReceiverTypeBinding`, `followChainPostFinalize`) consult this channel
+    // gated by `accessibleNamespacesByScope`, so a file sees exactly the
+    // namespaces it could before (its own + `using`d), just shared not copied.
+    const namespaceTypeBindings = indexes.namespaceTypeBindings;
+    for (const [nsName, bucket] of buckets) {
+        if (nsName === '')
+            continue; // global → workspaceTypeBindings (above)
+        let nsMap = namespaceTypeBindings.get(nsName);
+        for (const scopeInfo of bucket.scopes) {
+            if (scopeInfo.scope.kind !== 'Module')
+                continue;
+            for (const [boundName, typeRef] of scopeInfo.scope.typeBindings) {
+                if (nsMap === undefined) {
+                    nsMap = new Map();
+                    namespaceTypeBindings.set(nsName, nsMap);
+                }
+                // First-wins, matching the old per-importer `has(boundName)` skip.
+                if (!nsMap.has(boundName))
+                    nsMap.set(boundName, typeRef);
+            }
+        }
+    }
+    // Materialize each file's accessible namespaces (its own declared namespaces +
+    // every `using namespace X;` target, plus dotted-path prefixes), keyed by the
+    // file's Module scope id. This is the SAME accessibility set the per-file copy
+    // above used to derive — now stored so the language-neutral walkers can gate
+    // their `namespaceFqnBindings` / `namespaceTypeBindings` lookups to exactly the
+    // namespaces a file can see. The global ('') namespace is excluded: it is
+    // type-visible everywhere and handled by the flat workspace channels.
+    const accessibleNamespacesByScope = indexes.accessibleNamespacesByScope;
     for (const parsed of parsedFiles) {
         const moduleScope = parsed.scopes.find((s) => s.kind === 'Module');
         if (moduleScope === undefined)
             continue;
-        const moduleTypeBindings = moduleScope.typeBindings;
-        // Accessible namespaces = this file's own namespaces + every
-        // `using namespace X;` target. Source of truth is the cached AST
-        // structure captured above.
         const accessibleNamespaces = new Set();
         const struct = structureByFile.get(parsed.filePath);
         if (struct !== undefined) {
             for (const n of struct.namespaces)
                 accessibleNamespaces.add(n);
         }
-        if (accessibleNamespaces.size === 0)
-            accessibleNamespaces.add('');
         for (const imp of parsed.parsedImports) {
             if (imp.kind === 'namespace' && imp.targetRaw !== null) {
                 accessibleNamespaces.add(imp.targetRaw);
             }
         }
-        // For each accessible namespace, also walk up the dotted path —
-        // `using static X.Y.Z;` targets a type, so the real namespace is
-        // `X.Y`. Both parse into `accessibleNamespaces` as-is; we probe
-        // the bucket map with every prefix.
         const expandedNamespaces = new Set(accessibleNamespaces);
         for (const ns of accessibleNamespaces) {
             const segments = ns.split('.');
@@ -418,21 +475,9 @@ export function populateCsharpNamespaceSiblings(parsedFiles, indexes, inputs) {
                 expandedNamespaces.add(segments.slice(0, i).join('.'));
             }
         }
-        for (const nsName of expandedNamespaces) {
-            const bucket = buckets.get(nsName);
-            if (bucket === undefined)
-                continue;
-            for (const scopeInfo of bucket.scopes) {
-                if (scopeInfo.filePath === parsed.filePath)
-                    continue;
-                if (scopeInfo.scope.kind !== 'Module')
-                    continue;
-                for (const [boundName, typeRef] of scopeInfo.scope.typeBindings) {
-                    if (moduleTypeBindings.has(boundName))
-                        continue;
-                    moduleTypeBindings.set(boundName, typeRef);
-                }
-            }
+        expandedNamespaces.delete(''); // global handled by the flat workspace channels
+        if (expandedNamespaces.size > 0) {
+            accessibleNamespacesByScope.set(moduleScope.id, [...expandedNamespaces]);
         }
     }
     // `using static X.Y.Z;` — expose every public static method of
@@ -504,51 +549,14 @@ export function populateCsharpNamespaceSiblings(parsedFiles, indexes, inputs) {
             }
         }
     }
-    // Cross-namespace imports: for each file's `using X;` directive,
-    // if `X` matches a known namespace bucket, inject that bucket's
-    // classes into the importer's module scope. This is what makes
-    // `new User()` in `namespace App;` resolve to `User` declared in
-    // a sibling file with `namespace Models;` when the importer says
-    // `using Models;`. Legacy uses csproj directory↔namespace mapping;
-    // the scope-resolver layer uses the declared namespace directly.
-    for (const parsed of parsedFiles) {
-        const moduleScope = parsed.scopes.find((s) => s.kind === 'Module');
-        if (moduleScope === undefined)
-            continue;
-        // Per-file de-dup sets keyed by simple name, seeded lazily from the
-        // augmentation bucket — replaces the per-def O(A) `.some` scan below.
-        const seenByName = new Map();
-        for (const imp of parsed.parsedImports) {
-            if (imp.kind !== 'namespace')
-                continue;
-            const targetNs = imp.targetRaw;
-            if (targetNs === null || targetNs === '')
-                continue;
-            const bucket = buckets.get(targetNs);
-            if (bucket === undefined)
-                continue;
-            for (const def of bucket.classDefs) {
-                if (def.filePath === parsed.filePath)
-                    continue;
-                const q = def.qualifiedName ?? '';
-                const simpleName = q.includes('.') ? q.slice(q.lastIndexOf('.') + 1) : q;
-                if (simpleName === '')
-                    continue;
-                const bucketArr = getAugmentationBucket(augmentations, moduleScope.id, simpleName);
-                let seen = seenByName.get(simpleName);
-                if (seen === undefined) {
-                    seen = new Set();
-                    for (const b of bucketArr)
-                        seen.add(b.def.nodeId);
-                    seenByName.set(simpleName, seen);
-                }
-                if (seen.has(def.nodeId))
-                    continue;
-                seen.add(def.nodeId);
-                bucketArr.push({ def, origin: 'namespace' });
-            }
-        }
-    }
+    // Cross-namespace `using X;` class visibility is no longer injected per-file
+    // here (#1871). It is now subsumed by the per-namespace `namespaceFqnBindings`
+    // channel populated below: a file's `using` targets are already in its
+    // `accessibleNamespacesByScope` entry (materialized above), so `lookupBindingsAt`
+    // consults `namespaceFqnBindings[targetNs]` for it. Routing through the shared
+    // channel instead of copying each target bucket's classes into every importer's
+    // augmentation removes an O(importers × bucket-size) fanout on popular
+    // namespaces — the cross-namespace twin of the same-namespace blow-up.
     // Workspace-level binding channel for global-namespace types (see the
     // global fast-path below). `lookupBindingsAt` consults this as a third
     // source after finalized + per-scope augmented bindings. Its inner arrays
@@ -557,6 +565,13 @@ export function populateCsharpNamespaceSiblings(parsedFiles, indexes, inputs) {
     // ReadonlyMap→Map cast is localized to this one line and all writes go
     // through `getWorkspaceBucket`.
     const workspace = indexes.workspaceFqnBindings;
+    // Per-namespace binding channel for NAMED-namespace class visibility — the
+    // namespace-scoped analogue of `workspace`, populated once per named bucket
+    // (#1871). Replaces the per-scope `bindingAugmentations` fanout (O(scopes ×
+    // defs)) for same-namespace siblings AND the per-file cross-namespace-`using`
+    // injection above. `lookupBindingsAt` consults it gated by
+    // `accessibleNamespacesByScope`.
+    const namespaceFqn = indexes.namespaceFqnBindings;
     for (const [nsName, bucket] of buckets) {
         // Group sibling defs by simple name. Append in place — the previous
         // `[...prev, def]` copy made this O(D²) per bucket, which on the
@@ -604,49 +619,39 @@ export function populateCsharpNamespaceSiblings(parsedFiles, indexes, inputs) {
             }
             continue;
         }
-        // Pre-index the first scope per file once (O(S)) instead of an
-        // O(S) `.find` re-run for every (scope, name) pair, which made the
-        // injection loop O(S²·D) and was the dominant cost on large buckets.
-        // Multiple scopes share a filePath (Module + Namespace); the local
-        // shadow check only needs that file's lexical `Scope.bindings`, which
-        // is identical regardless of which of those scopes we read.
-        const firstScopeByFile = new Map();
-        for (const s of bucket.scopes) {
-            if (!firstScopeByFile.has(s.filePath))
-                firstScopeByFile.set(s.filePath, s.scope);
-        }
-        for (const { scopeId, filePath } of bucket.scopes) {
-            const localScope = firstScopeByFile.get(filePath);
-            for (const [name, defs] of defsByName) {
-                // Skip names already present locally — `origin: 'local'` in
-                // scope.bindings would naturally shadow the cross-file
-                // namespace entry, but we also keep this index lean.
-                const local = localScope?.bindings.get(name);
-                if (local !== undefined && local.some((b) => b.origin === 'local'))
-                    continue;
-                // Bind the augmentation bucket and its seeded de-dup set together
-                // under one nullable lifecycle, so neither needs a non-null
-                // assertion (they are always set or unset as a pair). Stays lazy:
-                // nothing is allocated for a name with no cross-file defs.
-                let inject = null;
-                for (const def of defs) {
-                    if (def.filePath === filePath)
-                        continue; // don't self-reference
-                    if (inject === null) {
-                        const bucket = getAugmentationBucket(augmentations, scopeId, name);
-                        // Seed the de-dup set from any entries an earlier pass
-                        // (using-static / cross-namespace imports) already added,
-                        // replacing the per-def O(A) `.some` scan.
-                        const seen = new Set();
-                        for (const b of bucket)
-                            seen.add(b.def.nodeId);
-                        inject = { bucket, seen };
+        // Named-namespace fast path (#1871) — the namespace-scoped mirror of the
+        // global path above. One `namespaceFqnBindings[nsName]` entry per simple
+        // name, O(D) per bucket, instead of the prior O(scopes × defs) per-scope
+        // augmentation that materialized O(files²) BindingRefs for a concentrated
+        // named namespace. `lookupBindingsAt` consults this gated by
+        // `accessibleNamespacesByScope` and ranks finalized `scope.bindings`
+        // (local declarations) ABOVE it, so local types still shadow — exactly as
+        // `walkScopeChain` shadows the global workspace entries. Dedup by
+        // `def.nodeId` keeps partial-class / duplicate declarations from
+        // double-emitting. (The prior local-shadow and self-reference skips are now
+        // handled by lookup precedence, identical to the global path.)
+        let nsMap = namespaceFqn.get(nsName);
+        for (const [name, defs] of defsByName) {
+            let bucketArr = nsMap?.get(name);
+            let seen = null;
+            for (const def of defs) {
+                if (bucketArr === undefined) {
+                    if (nsMap === undefined) {
+                        nsMap = new Map();
+                        namespaceFqn.set(nsName, nsMap);
                     }
-                    if (inject.seen.has(def.nodeId))
-                        continue;
-                    inject.seen.add(def.nodeId);
-                    inject.bucket.push({ def, origin: 'namespace' });
+                    bucketArr = [];
+                    nsMap.set(name, bucketArr);
                 }
+                if (seen === null) {
+                    seen = new Set();
+                    for (const b of bucketArr)
+                        seen.add(b.def.nodeId);
+                }
+                if (seen.has(def.nodeId))
+                    continue;
+                seen.add(def.nodeId);
+                bucketArr.push({ def, origin: 'namespace' });
             }
         }
     }

package/dist/core/ingestion/languages/csharp/qualified-type-names.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Tag C# file-level type defs with their enclosing-namespace path on the
+ * sidecar `namespacePrefix` field — WITHOUT touching `qualifiedName` (mutating
+ * it corrupts simple-name heritage / base resolution; #2046 regression).
+ *
+ * `tagNamespacePrefixes` (shared) only reaches defs whose scope chain includes
+ * a Namespace scope. C# file-scoped `namespace X;` gives the Namespace scope a
+ * 1-line range, so top-level types land under the Module scope and are missed.
+ * This pass covers both block- and file-scoped namespaces so the qualified
+ * constructor resolver can break a same-tail collision (`new B.Foo()` with both
+ * `A.Foo` and `B.Foo`) by matching the explicit qualifier against the sidecar.
+ */
+import type { ParsedFile } from '../../../../_shared/index.js';
+export declare function populateCsharpNamespacePrefixes(parsed: ParsedFile): void;

package/dist/core/ingestion/languages/csharp/qualified-type-names.js

@@ -0,0 +1,59 @@
+import { isClassLike } from '../../scope-resolution/scope/walkers.js';
+function isTypeDef(def) {
+    return isClassLike(def.type) || def.type === 'Enum';
+}
+export function populateCsharpNamespacePrefixes(parsed) {
+    const scopesById = new Map();
+    for (const scope of parsed.scopes)
+        scopesById.set(scope.id, scope);
+    // The file's declared namespace (file-scoped `namespace X;`). First Namespace
+    // scope's own def qualifiedName; undefined when the file is namespace-free.
+    const fileNamespace = (() => {
+        for (const scope of parsed.scopes) {
+            if (scope.kind !== 'Namespace')
+                continue;
+            const nsDef = scope.ownedDefs.find((d) => d.type === 'Namespace');
+            const q = nsDef?.qualifiedName;
+            if (q !== undefined && q.length > 0)
+                return q;
+        }
+        return undefined;
+    })();
+    // Enclosing namespace path for a scope: nearest ancestor Namespace scope's
+    // full qualifiedName, else the file-scoped namespace (Module-parented types).
+    const namespaceOf = (scope) => {
+        let parentId = scope.parent;
+        while (parentId !== null) {
+            const parent = scopesById.get(parentId);
+            if (parent === undefined)
+                break;
+            if (parent.kind === 'Namespace') {
+                const nsDef = parent.ownedDefs.find((d) => d.type === 'Namespace');
+                const q = nsDef?.qualifiedName;
+                if (q !== undefined && q.length > 0)
+                    return q;
+            }
+            if (parent.kind === 'Module')
+                return fileNamespace;
+            parentId = parent.parent;
+        }
+        return fileNamespace;
+    };
+    for (const scope of parsed.scopes) {
+        if (scope.kind !== 'Class')
+            continue;
+        const prefix = namespaceOf(scope);
+        if (prefix === undefined || prefix.length === 0)
+            continue;
+        for (const def of scope.ownedDefs) {
+            if (!isTypeDef(def))
+                continue;
+            if (def.namespacePrefix !== undefined)
+                continue;
+            const q = def.qualifiedName;
+            if (q === prefix || (q !== undefined && q.startsWith(`${prefix}.`)))
+                continue;
+            def.namespacePrefix = prefix;
+        }
+    }
+}

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

@@ -39,6 +39,12 @@ const CSHARP_SCOPE_QUERY = `
 (namespace_declaration) @scope.namespace
 (file_scoped_namespace_declaration) @scope.namespace
 
+(namespace_declaration
+  name: (_) @declaration.name) @declaration.namespace
+
+(file_scoped_namespace_declaration
+  name: (_) @declaration.name) @declaration.namespace
+
 (class_declaration) @scope.class
 (interface_declaration) @scope.class
 (struct_declaration) @scope.class
@@ -480,6 +486,13 @@ const CSHARP_SCOPE_QUERY = `
 (object_creation_expression
   type: (qualified_name) @reference.call.constructor.qualified) @reference.call.constructor
 
+;; Alias-qualified constructor: \`new MyAlias::Foo()\`, \`new global::Foo()\`. The
+;; top-level type is an alias_qualified_name (a \`global::Ns.Foo\` qualifier nests
+;; under qualified_name instead, covered above). No @reference.name here —
+;; captures.ts derives the simple-name tail via terminalTypeNameNode.
+(object_creation_expression
+  type: (alias_qualified_name) @reference.call.constructor.qualified) @reference.call.constructor
+
 ;; References — field/property writes: \`obj.Name = "x"\` emits a write
 ;; ACCESSES edge from the enclosing method to the field/property on
 ;; obj's class.

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

@@ -43,11 +43,13 @@ function findEnclosingTypeDeclaration(node) {
 function typeName(typeNode) {
     return typeNode.childForFieldName('name')?.text ?? null;
 }
-/** First entry in the type's `base_list`, read as raw text. C# allows
- *  generic and qualified bases (`Foo<T>`, `N.M.Base`); we keep the raw
- *  form so downstream interpret layer can strip generics/qualifiers
- *  the same way as other type-binding captures. Returns null when the
- *  type has no base (or an empty base_list). */
+/** First entry in the type's `base_list`, read as raw type text. C#
+ *  allows generic and qualified bases (`Foo<T>`, `N.M.Base`); we keep
+ *  that form so downstream interpretation can strip generics and
+ *  qualifiers consistently. A record primary-constructor base wraps
+ *  its type and constructor arguments in `primary_constructor_base_type`,
+ *  so read its `type` field instead of leaking `(args)` into the binding.
+ *  Returns null when the type has no base (or an empty base_list). */
 function firstBaseText(typeNode) {
     for (let i = 0; i < typeNode.namedChildCount; i++) {
         const child = typeNode.namedChild(i);
@@ -56,7 +58,9 @@ function firstBaseText(typeNode) {
         const firstBase = child.namedChild(0);
         if (firstBase === null)
             return null;
-        return firstBase.text;
+        return firstBase.type === 'primary_constructor_base_type'
+            ? (firstBase.childForFieldName('type')?.text ?? firstBase.text)
+            : firstBase.text;
     }
     return null;
 }

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

@@ -8,6 +8,7 @@
 import { SupportedLanguages } from '../../../../_shared/index.js';
 import { buildMro, defaultLinearize } from '../../scope-resolution/passes/mro.js';
 import { populateClassOwnedMembers } from '../../scope-resolution/scope/walkers.js';
+import { populateCsharpNamespacePrefixes } from './qualified-type-names.js';
 import { csharpProvider } from '../csharp.js';
 import { csharpArityCompatibility, csharpMergeBindings, resolveCsharpImportTarget, } from './index.js';
 import { populateCsharpNamespaceSiblings } from './namespace-siblings.js';
@@ -38,7 +39,13 @@ const csharpScopeResolver = {
     // contract is (callsite, def).
     arityCompatibility: (callsite, def) => csharpArityCompatibility(def, callsite),
     buildMro: (graph, parsedFiles, nodeLookup) => buildMro(graph, parsedFiles, nodeLookup, defaultLinearize),
-    populateOwners: (parsed) => populateClassOwnedMembers(parsed),
+    populateOwners: (parsed) => {
+        populateClassOwnedMembers(parsed);
+        // Sidecar-only namespace tagging (does NOT touch qualifiedName) so the
+        // qualified constructor resolver can break same-tail collisions like
+        // `new B.Foo()` by matching the explicit qualifier (#2046).
+        populateCsharpNamespacePrefixes(parsed);
+    },
     // C# uses `base` for super-class dispatch, not `super`. Match as a
     // plain identifier (no `()` call like Python's `super(...)`) — `base`
     // is a keyword-like receiver, not a callable.

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

@@ -13,7 +13,6 @@ import { typeConfig as csharpConfig } from '../type-extractors/csharp.js';
 import { csharpExportChecker } from '../export-detection.js';
 import { createImportResolver } from '../import-resolvers/resolver-factory.js';
 import { csharpImportConfig } from '../import-resolvers/configs/csharp.js';
-import { extractCSharpNamedBindings } from '../named-bindings/csharp.js';
 import { CSHARP_QUERIES } from '../tree-sitter-queries.js';
 import { createCallExtractor } from '../call-extractors/generic.js';
 import { csharpCallConfig } from '../call-extractors/configs/csharp.js';
@@ -23,7 +22,6 @@ import { createMethodExtractor } from '../method-extractors/generic.js';
 import { csharpMethodConfig } from '../method-extractors/configs/csharp.js';
 import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { csharpVariableConfig } from '../variable-extractors/configs/csharp.js';
-import { createHeritageExtractor } from '../heritage-extractors/generic.js';
 import { emitCsharpScopeCaptures, interpretCsharpImport, interpretCsharpTypeBinding, csharpBindingScopeFor, csharpImportOwningScope, csharpMergeBindings, csharpReceiverBinding, csharpArityCompatibility, resolveCsharpImportTarget, } from './csharp/index.js';
 const BUILT_INS = new Set([
     'Console',
@@ -175,15 +173,12 @@ export const csharpProvider = defineLanguage({
     typeConfig: csharpConfig,
     exportChecker: csharpExportChecker,
     importResolver: createImportResolver(csharpImportConfig),
-    namedBindingExtractor: extractCSharpNamedBindings,
-    interfaceNamePattern: /^I[A-Z]/,
     mroStrategy: 'implements-split',
     callExtractor: createCallExtractor(csharpCallConfig),
     fieldExtractor: createFieldExtractor(csharpFieldConfig),
     methodExtractor: createMethodExtractor(csharpMethodConfig),
     variableExtractor: createVariableExtractor(csharpVariableConfig),
     classExtractor: createClassExtractor(csharpClassConfig),
-    heritageExtractor: createHeritageExtractor(SupportedLanguages.CSharp),
     builtInNames: BUILT_INS,
     // ── RFC #909 Ring 3: scope-based resolution hooks (RFC §5) ──────────
     // C# is the second migration after Python. See ./csharp/index.ts for

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

@@ -0,0 +1,25 @@
+/**
+ * Compute arity metadata from a Dart function-like node, reusing
+ * `dartMethodConfig.extractParameters` so scope-extracted defs carry the
+ * same semantics as the legacy parse-worker path. Mirror of
+ * `languages/swift/arity-metadata.ts` (and C#'s `computeCsharpArityMetadata`).
+ *
+ * Dart has no variadic parameters, so `parameterCount` is always the param
+ * total and the required count falls out of the optional flag:
+ * `requiredParameterCount = total − optionalCount`, where a non-`required`
+ * named param or an optional positional (`[...]`) param is optional.
+ */
+import type { SyntaxNode } from '../../utils/ast-helpers.js';
+interface DartArityMetadata {
+    parameterCount: number | undefined;
+    requiredParameterCount: number | undefined;
+    parameterTypes: readonly string[] | undefined;
+}
+/**
+ * `fnNode` is the declaration WRAPPER node (`method_signature` /
+ * `declaration` / a top-level `function_signature` / `constructor_signature`).
+ * `dartMethodConfig.extractParameters` descends to the inner signature
+ * internally, so the wrapper is the correct node to pass.
+ */
+export declare function computeDartArityMetadata(fnNode: SyntaxNode): DartArityMetadata;
+export {};

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

@@ -0,0 +1,35 @@
+/**
+ * Compute arity metadata from a Dart function-like node, reusing
+ * `dartMethodConfig.extractParameters` so scope-extracted defs carry the
+ * same semantics as the legacy parse-worker path. Mirror of
+ * `languages/swift/arity-metadata.ts` (and C#'s `computeCsharpArityMetadata`).
+ *
+ * Dart has no variadic parameters, so `parameterCount` is always the param
+ * total and the required count falls out of the optional flag:
+ * `requiredParameterCount = total − optionalCount`, where a non-`required`
+ * named param or an optional positional (`[...]`) param is optional.
+ */
+import { dartMethodConfig } from '../../method-extractors/configs/dart.js';
+/**
+ * `fnNode` is the declaration WRAPPER node (`method_signature` /
+ * `declaration` / a top-level `function_signature` / `constructor_signature`).
+ * `dartMethodConfig.extractParameters` descends to the inner signature
+ * internally, so the wrapper is the correct node to pass.
+ */
+export function computeDartArityMetadata(fnNode) {
+    const params = dartMethodConfig.extractParameters?.(fnNode) ?? [];
+    let optionalCount = 0;
+    const types = [];
+    for (const p of params) {
+        if (p.isOptional)
+            optionalCount++;
+        if (p.type !== null)
+            types.push(p.type);
+    }
+    const total = params.length;
+    return {
+        parameterCount: total,
+        requiredParameterCount: total - optionalCount,
+        parameterTypes: types.length > 0 ? types : undefined,
+    };
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Dart arity compatibility (count-primary, labels soft) — mirror of
+ * `languages/swift/arity.ts`.
+ *
+ * Dart parameters come in four flavours: required positional, optional
+ * positional (`[...]`), named (`{...}`), and required-named
+ * (`{required ...}`). `dartMethodConfig.extractParameters` collapses these
+ * into `isOptional` (a non-`required` named/optional-positional param is
+ * optional), which `computeDartArityMetadata` turns into
+ * `requiredParameterCount = total − optionalCount`. Named arguments are
+ * unordered and matched on COUNT only here — label-precise dispatch is left
+ * to the type-binding layer (Swift's documented "labels soft" decision).
+ * Dart has no variadic parameters, so the max bound always applies.
+ *
+ * NOTE arg order: `(def, callsite)` — matches the `LanguageProvider` hook.
+ * The `ScopeResolver` wires an adapter that flips the order to `(callsite, def)`.
+ */
+import type { Callsite, SymbolDefinition } from '../../../../_shared/index.js';
+export declare function dartArityCompatibility(def: SymbolDefinition, callsite: Callsite): 'compatible' | 'unknown' | 'incompatible';

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

@@ -0,0 +1,31 @@
+/**
+ * Dart arity compatibility (count-primary, labels soft) — mirror of
+ * `languages/swift/arity.ts`.
+ *
+ * Dart parameters come in four flavours: required positional, optional
+ * positional (`[...]`), named (`{...}`), and required-named
+ * (`{required ...}`). `dartMethodConfig.extractParameters` collapses these
+ * into `isOptional` (a non-`required` named/optional-positional param is
+ * optional), which `computeDartArityMetadata` turns into
+ * `requiredParameterCount = total − optionalCount`. Named arguments are
+ * unordered and matched on COUNT only here — label-precise dispatch is left
+ * to the type-binding layer (Swift's documented "labels soft" decision).
+ * Dart has no variadic parameters, so the max bound always applies.
+ *
+ * NOTE arg order: `(def, callsite)` — matches the `LanguageProvider` hook.
+ * The `ScopeResolver` wires an adapter that flips the order to `(callsite, def)`.
+ */
+export function dartArityCompatibility(def, callsite) {
+    const max = def.parameterCount;
+    const min = def.requiredParameterCount;
+    if (max === undefined && min === undefined)
+        return 'unknown';
+    const argCount = callsite.arity;
+    if (argCount === undefined || !Number.isFinite(argCount) || argCount < 0)
+        return 'unknown';
+    if (min !== undefined && argCount < min)
+        return 'incompatible';
+    if (max !== undefined && argCount > max)
+        return 'incompatible';
+    return 'compatible';
+}

package/dist/core/ingestion/languages/dart/built-ins.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Dart built-in / framework names whose calls the legacy DAG suppresses
+ * (Flutter / Dart-SDK members not part of the indexed workspace). The
+ * registry-primary capture walk skips emitting call references for these so
+ * its CALLS graph matches the legacy DAG — which suppresses built-in-named
+ * calls via `isBuiltInName` BEFORE resolution, for both free and member calls.
+ *
+ * Leaf module: shared by the provider (`builtInNames`) and `captures.ts`
+ * without an import cycle (`dart.ts` → `dart/index.ts` → `captures.ts`).
+ */
+export declare const DART_BUILT_INS: ReadonlySet<string>;