cgraphx 2.0.2 → 2.0.3

package/dist/core/code/engine/core/ingestion/languages/cpp/two-phase-lookup.js

@@ -0,0 +1,348 @@
+"use strict";
+/**
+ * C++ two-phase template lookup support.
+ *
+ * Inside a class template body, names from a dependent base class are NOT
+ * found by ordinary unqualified lookup. The standard requires the
+ * `this->name` or `Base<T>::name` forms to make the lookup dependent.
+ * GitNexus's global free-call fallback otherwise binds such names to the
+ * dependent base's members, producing CALLS edges the compiler would
+ * reject.
+ *
+ * This module records — during `emitCppScopeCaptures` — which template
+ * class declarations have which dependent base class names (per file).
+ * `populateCppDependentBases` then resolves those names to class nodeIds
+ * using a workspace-wide registry, building the per-class set the
+ * `isCppDependentBaseMember` predicate consumes.
+ *
+ * Cross-file resolution: `Base<T>` may be declared in a different header
+ * than `Derived<T>`. `populateCppDependentBases` therefore runs as a
+ * workspace-wide pass (`populateWorkspaceOwners` hook) after every file
+ * has had `populateOwners` applied, so all class defs are reachable.
+ *
+ * Namespace disambiguation: when multiple classes share a simple name
+ * (e.g., `Box` in two namespaces), the resolver prefers the candidate
+ * whose qualified-name prefix (namespace path) matches the deriving
+ * class's prefix. If no namespace match is found, a unique simple-name
+ * match is accepted; ambiguous matches (multiple candidates, no
+ * namespace winner) are skipped conservatively.
+ *
+ * NOTE: module-level state, single-process-single-repo use only.
+ * `clearFileLocalNames()` clears this state alongside file-local linkage
+ * (see `file-local-linkage.ts`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.markCppDependentBase = markCppDependentBase;
+exports.markCppDependentPackBase = markCppDependentPackBase;
+exports.collectCppTwoPhaseSideChannel = collectCppTwoPhaseSideChannel;
+exports.applyCppTwoPhaseSideChannel = applyCppTwoPhaseSideChannel;
+exports.clearCppDependentBases = clearCppDependentBases;
+exports.populateCppDependentBases = populateCppDependentBases;
+exports.isCppDependentBaseMember = isCppDependentBaseMember;
+const walkers_js_1 = require("../../scope-resolution/scope/walkers.js");
+/**
+ * Capture-time record: for each template class declaration in a file,
+ * the simple names of its dependent base classes and their syntactic
+ * qualifiers (e.g., `detail` for `detail::Inner<T>`).
+ *
+ * Key: filePath
+ * Value: Map<className, Map<baseName, qualifier>>
+ *   qualifier is '' when the base was unqualified.
+ */
+const dependentBasesByFile = new Map();
+/**
+ * Class templates with pack-expanded bases (`struct Mix : Bases...`) have
+ * an unknown set of base classes. Unqualified member lookup inside the class
+ * cannot safely bind to class-owned methods outside the current class.
+ */
+const dependentPackBaseClassesByFile = new Map();
+/**
+ * Post-`populateOwners` resolution: per-class-nodeId, the set of
+ * dependent-base-class nodeIds. Built by `populateCppDependentBases`
+ * from `dependentBasesByFile` + the workspace registry.
+ */
+const dependentBaseNodeIds = new Map();
+/**
+ * Record a dependent-base relationship discovered during scope-capture
+ * emission. `className` is the simple name of the template class;
+ * `baseName` is the simple name of the dependent base class.
+ * `qualifier` is the syntactic namespace qualifier (e.g. `detail` for
+ * `detail::Inner<T>`), or '' for unqualified bases.
+ *
+ * The capture-time recorder uses simple names because the registry
+ * resolution that maps names → nodeIds runs later (in
+ * `populateCppDependentBases`).
+ */
+function markCppDependentBase(filePath, className, baseName, qualifier = '') {
+    let perFile = dependentBasesByFile.get(filePath);
+    if (perFile === undefined) {
+        perFile = new Map();
+        dependentBasesByFile.set(filePath, perFile);
+    }
+    let bases = perFile.get(className);
+    if (bases === undefined) {
+        bases = new Map();
+        perFile.set(className, bases);
+    }
+    let quals = bases.get(baseName);
+    if (quals === undefined) {
+        quals = new Set();
+        bases.set(baseName, quals);
+    }
+    quals.add(qualifier);
+}
+function markCppDependentPackBase(filePath, className) {
+    let perFile = dependentPackBaseClassesByFile.get(filePath);
+    if (perFile === undefined) {
+        perFile = new Set();
+        dependentPackBaseClassesByFile.set(filePath, perFile);
+    }
+    perFile.add(className);
+}
+/** Snapshot this file's two-phase-lookup capture state for the side-channel. */
+function collectCppTwoPhaseSideChannel(filePath) {
+    const perFile = dependentBasesByFile.get(filePath);
+    const dependentBases = [];
+    if (perFile !== undefined) {
+        for (const [className, bases] of perFile) {
+            const baseEntries = [];
+            for (const [baseName, quals] of bases) {
+                baseEntries.push([baseName, [...quals]]);
+            }
+            dependentBases.push([className, baseEntries]);
+        }
+    }
+    const pack = dependentPackBaseClassesByFile.get(filePath);
+    return {
+        dependentBases,
+        dependentPackBaseClasses: pack === undefined ? [] : [...pack],
+    };
+}
+/** Restore this file's two-phase-lookup capture state from the side-channel. */
+function applyCppTwoPhaseSideChannel(filePath, data) {
+    for (const [className, baseEntries] of data.dependentBases) {
+        for (const [baseName, quals] of baseEntries) {
+            for (const qualifier of quals) {
+                markCppDependentBase(filePath, className, baseName, qualifier);
+            }
+        }
+    }
+    for (const className of data.dependentPackBaseClasses) {
+        markCppDependentPackBase(filePath, className);
+    }
+}
+/** Clear two-phase-lookup state. Called from `clearFileLocalNames`. */
+function clearCppDependentBases() {
+    dependentBasesByFile.clear();
+    dependentPackBaseClassesByFile.clear();
+    dependentBaseNodeIds.clear();
+}
+/**
+ * Resolve recorded dependent-base simple names to class nodeIds using a
+ * workspace-wide index. Run as `populateWorkspaceOwners` after every
+ * file has had `populateOwners` applied, so class defs from ALL files
+ * are reachable.
+ *
+ * Disambiguation strategy (multiple classes sharing a simple name):
+ *  1. Prefer the candidate whose qualified-name namespace prefix matches
+ *     the deriving class's namespace prefix (same-namespace bias).
+ *  2. When a syntactic qualifier is available (`detail` in
+ *     `detail::Inner<T>`), target the exact namespace derived from it.
+ *  3. Fall back to accepting a unique simple-name match.
+ *  4. Skip when multiple candidates exist and no namespace match is
+ *     found (conservative: avoids false associations).
+ */
+function populateCppDependentBases(parsedFiles) {
+    if (dependentBasesByFile.size === 0 && dependentPackBaseClassesByFile.size === 0)
+        return;
+    // Build workspace-wide index: simpleName → {nodeId, nsPrefix}[]
+    // nsPrefix is the dot-joined namespace path (qualifiedName without the
+    // last segment). Classes at global scope have nsPrefix = ''.
+    // Dedup by nodeId, keeping the LAST occurrence: parsed.localDefs may
+    // list the same class def multiple times — the scope-extractor creates
+    // a def with simple-name qualifiedName first, then the class extractor
+    // replaces it with the correct fully-qualified qualifiedName. Keeping
+    // the later entry ensures we capture the full namespace path.
+    const classesBySimpleName = new Map();
+    const entryByNodeId = new Map();
+    for (const parsed of parsedFiles) {
+        for (const def of parsed.localDefs) {
+            if (def.type !== 'Class' && def.type !== 'Struct' && def.type !== 'Interface')
+                continue;
+            const qn = def.qualifiedName ?? '';
+            const lastDot = qn.lastIndexOf('.');
+            const simple = lastDot >= 0 ? qn.slice(lastDot + 1) : qn;
+            if (simple === '')
+                continue;
+            const nsPrefix = lastDot >= 0 ? qn.slice(0, lastDot) : '';
+            entryByNodeId.set(def.nodeId, { nodeId: def.nodeId, nsPrefix, simple });
+        }
+    }
+    for (const entry of entryByNodeId.values()) {
+        let entries = classesBySimpleName.get(entry.simple);
+        if (entries === undefined) {
+            entries = [];
+            classesBySimpleName.set(entry.simple, entries);
+        }
+        entries.push({ nodeId: entry.nodeId, nsPrefix: entry.nsPrefix });
+    }
+    // Build a filePath → ParsedFile lookup for fast per-file access.
+    const parsedByFile = new Map();
+    for (const parsed of parsedFiles)
+        parsedByFile.set(parsed.filePath, parsed);
+    for (const [filePath, perFile] of dependentBasesByFile) {
+        const parsed = parsedByFile.get(filePath);
+        if (parsed === undefined)
+            continue;
+        // Build a simple-name → {nodeId, nsPrefix} map for THIS file's
+        // class-like defs so we can identify each template class precisely
+        // (avoids cross-file name collisions for the deriving class itself).
+        const localClassByName = new Map();
+        for (const def of parsed.localDefs) {
+            if (def.type !== 'Class' && def.type !== 'Struct' && def.type !== 'Interface')
+                continue;
+            const qn = def.qualifiedName ?? '';
+            const lastDot = qn.lastIndexOf('.');
+            const simple = lastDot >= 0 ? qn.slice(lastDot + 1) : qn;
+            if (simple === '')
+                continue;
+            const nsPrefix = lastDot >= 0 ? qn.slice(0, lastDot) : '';
+            localClassByName.set(simple, { nodeId: def.nodeId, nsPrefix });
+        }
+        const packBaseClasses = dependentPackBaseClassesByFile.get(filePath);
+        if (packBaseClasses !== undefined) {
+            for (const className of packBaseClasses) {
+                const classEntry = localClassByName.get(className);
+                if (classEntry !== undefined) {
+                    dependentBaseNodeIds.set(classEntry.nodeId, new Set(['*pack-expansion*']));
+                }
+            }
+        }
+        // V3: qualifier-based exact targeting. When the base specifier carries
+        // a syntactic qualifier (e.g., `detail` in `detail::Inner<T>`), compute
+        // the expected namespace prefix and use exact (===) match. Falls back to
+        // the V2 prefix-contains heuristic when the qualifier isn't available or
+        // the exact match fails (absolute qualifier edge cases like `::std`).
+        for (const [className, baseEntries] of perFile) {
+            const classEntry = localClassByName.get(className);
+            if (classEntry === undefined)
+                continue;
+            let bases = dependentBaseNodeIds.get(classEntry.nodeId);
+            if (bases === undefined) {
+                bases = new Set();
+                dependentBaseNodeIds.set(classEntry.nodeId, bases);
+            }
+            for (const [baseName, qualsSet] of baseEntries) {
+                for (const baseQualifier of qualsSet) {
+                    const candidates = classesBySimpleName.get(baseName);
+                    if (candidates === undefined || candidates.length === 0)
+                        continue;
+                    // Compute the expected namespace prefix from the qualifier.
+                    // Relative qualifier (e.g. `inner`): prepend deriving class's prefix.
+                    // Absolute qualifiers (`::std`, `ns::other`) will fail the relative
+                    // lookup and fall through to the prefix-heuristic below.
+                    const normalizedQualifier = baseQualifier.replace(/::/g, '.');
+                    const expectedNs = baseQualifier && classEntry.nsPrefix
+                        ? classEntry.nsPrefix + '.' + normalizedQualifier
+                        : normalizedQualifier;
+                    if (candidates.length === 1) {
+                        // Unqualified base: accept unique match (pre-existing behavior).
+                        if (!baseQualifier) {
+                            bases.add(candidates[0].nodeId);
+                            continue;
+                        }
+                        // Qualified base: verify namespace before accepting.
+                        if (candidates[0].nsPrefix === expectedNs ||
+                            candidates[0].nsPrefix === normalizedQualifier) {
+                            bases.add(candidates[0].nodeId);
+                        }
+                        // else: suppress — qualifier doesn't match. #1564 policy.
+                        continue;
+                    }
+                    // V3: qualifier-based exact targeting. When the base specifier
+                    // carries a syntactic qualifier, compute the expected namespace
+                    // prefix and attempt an exact (===) match using the deduplicated
+                    // nsPrefix. Dedup by nodeId removes broken entries from the
+                    // classesBySimpleName index, making the surviving nsPrefix reliable.
+                    if (baseQualifier) {
+                        const qualifierMatch = candidates.find((c) => c.nsPrefix === expectedNs || c.nsPrefix === normalizedQualifier);
+                        if (qualifierMatch !== undefined) {
+                            bases.add(qualifierMatch.nodeId);
+                            continue;
+                        }
+                        continue; // qualifier was explicit but no match — suppress, don't fall through to V2
+                    }
+                    // V2 fallback: filter by prefix-match capped at one level deeper,
+                    // then accept only if exactly one candidate survives.
+                    const nsMatches = candidates.filter((c) => {
+                        if (c.nsPrefix === classEntry.nsPrefix)
+                            return true;
+                        if (classEntry.nsPrefix === '') {
+                            return c.nsPrefix !== '' && !c.nsPrefix.includes('.');
+                        }
+                        if (c.nsPrefix.startsWith(classEntry.nsPrefix + '.')) {
+                            const suffix = c.nsPrefix.slice(classEntry.nsPrefix.length + 1);
+                            return !suffix.includes('.');
+                        }
+                        return false;
+                    });
+                    const nsMatch = nsMatches.length === 1 ? nsMatches[0] : undefined;
+                    if (nsMatch !== undefined) {
+                        bases.add(nsMatch.nodeId);
+                    }
+                    // else: ambiguous (multiple candidates, no namespace match) → skip.
+                }
+            }
+        }
+    }
+}
+/**
+ * Two-phase lookup predicate: is the candidate def a member of a
+ * dependent base of the caller's enclosing template class?
+ *
+ * Used as an additional reject-filter in `pickUniqueGlobalCallable` and
+ * the receiver-bound member chain walk. ONLY apply for unqualified
+ * call forms — `this->name` and `Base<T>::name` are dependent lookup
+ * forms that the standard allows.
+ *
+ * Conservative bias: when the caller's enclosing class can't be
+ * identified, return `false` (let normal resolution proceed). Over-
+ * rejection is acceptable for the template case because the standard
+ * itself requires `this->` or qualified forms for dependent base
+ * access; missing edges here match the compiler's diagnostic shape.
+ */
+function isCppDependentBaseMember(callerScopeId, candidateDef, scopes) {
+    const enclosing = (0, walkers_js_1.findEnclosingClassDef)(callerScopeId, scopes);
+    if (enclosing === undefined)
+        return false;
+    const bases = dependentBaseNodeIds.get(enclosing.nodeId);
+    if (bases === undefined)
+        return false;
+    if (bases.has('*pack-expansion*')) {
+        if (candidateDef.ownerId !== undefined)
+            return candidateDef.ownerId !== enclosing.nodeId;
+        if (candidateDef.type !== 'Method' && candidateDef.type !== 'Constructor')
+            return false;
+        const ownerName = getQualifiedParentName(candidateDef.qualifiedName);
+        const enclosingName = getQualifiedSimpleName(enclosing.qualifiedName);
+        return ownerName !== undefined && ownerName !== enclosingName;
+    }
+    if (candidateDef.ownerId === undefined)
+        return false;
+    return bases.has(candidateDef.ownerId);
+}
+function getQualifiedParentName(qualifiedName) {
+    if (qualifiedName === undefined)
+        return undefined;
+    const lastDot = qualifiedName.lastIndexOf('.');
+    if (lastDot < 0)
+        return undefined;
+    const parent = qualifiedName.slice(0, lastDot);
+    return getQualifiedSimpleName(parent);
+}
+function getQualifiedSimpleName(qualifiedName) {
+    if (qualifiedName === undefined)
+        return undefined;
+    const lastDot = qualifiedName.lastIndexOf('.');
+    return lastDot >= 0 ? qualifiedName.slice(lastDot + 1) : qualifiedName;
+}

package/dist/core/code/engine/core/ingestion/languages/cpp/type-classifier.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * Coarse-grained type classifier for C++ constraint evaluation
+ * (`<https://en.cppreference.com/w/cpp/types/is_integral>`,
+ *  `<https://en.cppreference.com/w/cpp/types/is_floating_point>`).
+ *
+ * Maps a normalized type token (as produced by `normalizeCppParamType` /
+ * the call-site inference in `captures.ts`) to one of the categories
+ * the `<type_traits>` predicate registry uses for SFINAE filtering.
+ *
+ * `argumentTypes` remain normalized for overload narrowing, while
+ * constraint predicates that need cv/ref/pointer shape read the parallel
+ * `argumentTypeClasses` sidecar. Unknown shapes must stay unknown rather
+ * than being guessed as incompatible.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyType = classifyType;
+/**
+ * Classify a normalized C++ type token. The mapping mirrors the literal-
+ * inference table in `captures.ts:inferCppLiteralType` plus the std::
+ * normalization in `arity-metadata.ts:normalizeCppParamType`.
+ *
+ * Caller note: token should be normalized for overload matching. Enum
+ * tokens produced by the C++ adapter use the internal `enum:<Name>`
+ * prefix so `is_enum_v` does not have to guess that every user token is
+ * class-like.
+ */
+function classifyType(token) {
+    if (token.length === 0)
+        return 'unknown';
+    if (token.startsWith('enum:'))
+        return 'enum';
+    switch (token) {
+        case 'void':
+            return 'void';
+        case 'int':
+            return 'integral';
+        case 'double':
+        case 'float':
+            return 'floating';
+        case 'bool':
+            return 'bool';
+        case 'char':
+            return 'char';
+        case 'string':
+            return 'string';
+        case 'null':
+            return 'null';
+        default:
+            // After normalization, anything that isn't a recognized primitive
+            // is assumed to be a class-like type. The Tier-A predicate registry
+            // doesn't introspect class types — `is_integral_v` etc. simply
+            // returns `false` for `'class'`, matching ISO behavior.
+            return 'class';
+    }
+}

package/dist/core/code/engine/core/ingestion/languages/cpp/user-defined-conversions.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearCppUserDefinedConversions = clearCppUserDefinedConversions;
+exports.hasCppUserDefinedConversion = hasCppUserDefinedConversion;
+exports.populateCppUserDefinedConversions = populateCppUserDefinedConversions;
+exports.registerCppUserDefinedConversion = registerCppUserDefinedConversion;
+const arity_metadata_js_1 = require("./arity-metadata.js");
+const userDefinedConversions = new Set();
+const pendingUserDefinedConversions = [];
+const classIdentitiesBySimpleName = new Map();
+function clearCppUserDefinedConversions() {
+    userDefinedConversions.clear();
+    pendingUserDefinedConversions.length = 0;
+    classIdentitiesBySimpleName.clear();
+}
+function hasCppUserDefinedConversion(argType, paramType) {
+    return userDefinedConversions.has(conversionKey(argType, paramType));
+}
+function populateCppUserDefinedConversions(parsed) {
+    const scopesById = new Map();
+    for (const scope of parsed.scopes)
+        scopesById.set(scope.id, scope);
+    for (const classScope of parsed.scopes) {
+        if (classScope.kind !== 'Class')
+            continue;
+        const classDef = classScope.ownedDefs.find(isClassLike);
+        if (classDef !== undefined)
+            recordClassIdentity(classDef);
+    }
+    for (const classScope of parsed.scopes) {
+        if (classScope.kind !== 'Class')
+            continue;
+        const classDef = classScope.ownedDefs.find(isClassLike);
+        if (classDef === undefined)
+            continue;
+        const className = normalizedSimpleName(classDef);
+        if (className === '')
+            continue;
+        const methodDefs = collectClassMethodDefs(classScope.id, parsed, scopesById);
+        for (const def of methodDefs) {
+            const simpleName = simpleNameOf(def);
+            if (simpleName === className && def.parameterTypes?.length === 1) {
+                if (def.isExplicit === true)
+                    continue;
+                registerPendingCppUserDefinedConversion(def.parameterTypes[0], className, className);
+            }
+        }
+    }
+    rebuildCppUserDefinedConversions();
+}
+function registerCppUserDefinedConversion(argType, paramType) {
+    if (argType === '' || paramType === '')
+        return;
+    if (argType === paramType)
+        return;
+    userDefinedConversions.add(conversionKey(argType, paramType));
+}
+function collectClassMethodDefs(classScopeId, parsed, scopesById) {
+    const methods = [];
+    const classScope = scopesById.get(classScopeId);
+    if (classScope === undefined)
+        return methods;
+    for (const def of classScope.ownedDefs) {
+        if (isCallableMember(def))
+            methods.push(def);
+    }
+    for (const scope of parsed.scopes) {
+        if (scope.parent !== classScopeId)
+            continue;
+        if (scope.kind === 'Class')
+            continue;
+        for (const def of scope.ownedDefs) {
+            if (isCallableMember(def))
+                methods.push(def);
+        }
+    }
+    return methods;
+}
+function conversionKey(argType, paramType) {
+    return `${argType}\0${paramType}`;
+}
+function registerPendingCppUserDefinedConversion(argType, paramType, ownerClassName) {
+    if (argType === '' || paramType === '')
+        return;
+    if (argType === paramType)
+        return;
+    pendingUserDefinedConversions.push({ argType, paramType, ownerClassName });
+}
+function rebuildCppUserDefinedConversions() {
+    userDefinedConversions.clear();
+    for (const conversion of pendingUserDefinedConversions) {
+        if (isAmbiguousClassName(conversion.ownerClassName))
+            continue;
+        userDefinedConversions.add(conversionKey(conversion.argType, conversion.paramType));
+    }
+}
+function recordClassIdentity(def) {
+    const simpleName = normalizedSimpleName(def);
+    if (simpleName === '')
+        return;
+    const identities = classIdentitiesBySimpleName.get(simpleName) ?? new Set();
+    identities.add(normalizedQualifiedClassName(def));
+    classIdentitiesBySimpleName.set(simpleName, identities);
+}
+function isAmbiguousClassName(simpleName) {
+    return (classIdentitiesBySimpleName.get(simpleName)?.size ?? 0) > 1;
+}
+function normalizedQualifiedClassName(def) {
+    const qualifiedName = def.qualifiedName ?? simpleNameOf(def);
+    if (qualifiedName === '' || !qualifiedName.includes('.'))
+        return `${def.filePath}:${def.nodeId}`;
+    return qualifiedName
+        .split('.')
+        .map((part) => (0, arity_metadata_js_1.normalizeCppParamType)(part))
+        .join('.');
+}
+function normalizedSimpleName(def) {
+    return (0, arity_metadata_js_1.normalizeCppParamType)(simpleNameOf(def));
+}
+function simpleNameOf(def) {
+    return def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
+}
+function isClassLike(def) {
+    return def.type === 'Class' || def.type === 'Struct' || def.type === 'Interface';
+}
+function isCallableMember(def) {
+    return def.type === 'Method' || def.type === 'Constructor';
+}

package/dist/core/code/engine/core/ingestion/languages/csharp/accessor-unwrap.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unwrapCsharpElementType = unwrapCsharpElementType;
+const shared_js_1 = require("../../type-extractors/shared.js");
+/**
+ * C# container element-type unwrapping.
+ *
+ * When the compound-receiver resolver encounters a trailing
+ * `.Values` / `.Keys` on a dotted member-access chain, it calls the
+ * provider's `elementTypeOf` hook to find the element
+ * type. This module supplies the C# implementation — recognizing
+ * Dictionary-family generics and returning the value or key type.
+ *
+ * Other languages (Python, Java, TypeScript) use method-call syntax for the
+ * same access (`.values()` / `.keys()`), which the compound-receiver's
+ * call-expression branch already handles; they answer only the `index` route.
+ */
+/** Extract (K, V) from `Dictionary<K, V>` / `IDictionary<K, V>` /
+ *  `IReadOnlyDictionary<K, V>` / `SortedDictionary<K, V>` /
+ *  `ConcurrentDictionary<K, V>` / `ImmutableDictionary<K, V>`.
+ *  Returns undefined if the type name doesn't match or the argument
+ *  list isn't exactly two top-level args. */
+function extractDictionaryArgs(rawName) {
+    const match = rawName.match(/^(?:[A-Za-z_][A-Za-z0-9_.]*\.)?(?:Dictionary|IDictionary|IReadOnlyDictionary|SortedDictionary|ConcurrentDictionary|ImmutableDictionary)<(.+)>$/);
+    if (match === null)
+        return undefined;
+    const inner = match[1];
+    // Split on the top-level comma (tolerate nested `<...>`).
+    let depth = 0;
+    let commaIdx = -1;
+    for (let i = 0; i < inner.length; i++) {
+        const ch = inner[i];
+        if (ch === '<')
+            depth++;
+        else if (ch === '>')
+            depth--;
+        else if (ch === ',' && depth === 0) {
+            commaIdx = i;
+            break;
+        }
+    }
+    if (commaIdx === -1)
+        return undefined;
+    return { key: inner.slice(0, commaIdx).trim(), value: inner.slice(commaIdx + 1).trim() };
+}
+/**
+ * Resolve `data.Values` / `data.Keys` on a Dictionary-like receiver
+ * to its element-type simple name. Returns `undefined` for any
+ * receiver / accessor combination we don't recognize, letting the
+ * compound-receiver pass fall through to the regular field walk.
+ */
+function unwrapCsharpElementType(containerType, via) {
+    const args = extractDictionaryArgs(containerType);
+    // Subscript on a dictionary yields the VALUE type — `dict["k"]` is a V, never
+    // a K. Previously this route returned nothing at all for C#, because the
+    // dictionary parse below was reachable only from the accessor hook.
+    if (via.kind === 'index') {
+        if (args !== undefined)
+            return args.value;
+        return (0, shared_js_1.extractElementTypeFromString)(containerType);
+    }
+    if (via.name !== 'Values' && via.name !== 'Keys')
+        return undefined;
+    if (args === undefined)
+        return undefined;
+    return via.name === 'Values' ? args.value : args.key;
+}

package/dist/core/code/engine/core/ingestion/languages/csharp/arity-metadata.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * Extract C# arity metadata from a method-like tree-sitter node —
+ * `method_declaration`, `constructor_declaration`, `destructor_declaration`,
+ * `operator_declaration`, `conversion_operator_declaration`, or
+ * `local_function_statement`.
+ *
+ * Reuses `csharpMethodConfig.extractParameters` so scope-extracted defs
+ * carry the same arity semantics as the legacy parse-worker path:
+ *   - `params` variadic collapses `parameterCount` to `undefined`,
+ *     which `csharpArityCompatibility` then treats as "max unknown" —
+ *     the candidate stays eligible at `argCount >= required`.
+ *   - Defaulted parameters (`= expr`) contribute to `optionalCount`;
+ *     `requiredParameterCount = total − optionalCount`.
+ *   - `parameterTypes` collects declared type names (with `ref`/`out`/
+ *     `in` prefix) for overload narrowing; a literal `'params'` marker
+ *     is appended for variadic methods so `csharpArityCompatibility`
+ *     can detect them without re-reading the AST.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeCsharpArityMetadata = computeCsharpArityMetadata;
+const csharp_js_1 = require("../../method-extractors/configs/csharp.js");
+function computeCsharpArityMetadata(fnNode) {
+    const params = csharp_js_1.csharpMethodConfig.extractParameters?.(fnNode) ?? [];
+    let hasVariadic = false;
+    let optionalCount = 0;
+    const types = [];
+    for (const p of params) {
+        if (p.isVariadic)
+            hasVariadic = true;
+        else if (p.isOptional)
+            optionalCount++;
+        if (p.type !== null)
+            types.push(p.type);
+    }
+    if (hasVariadic)
+        types.push('params');
+    const total = params.length;
+    // `params int[] args` declares one formal param but accepts any arg
+    // count ≥ required — mirror Python's treatment of `*args` and leave
+    // `parameterCount` undefined so the registry treats max as unknown.
+    const parameterCount = hasVariadic ? undefined : total;
+    const requiredParameterCount = hasVariadic ? undefined : total - optionalCount;
+    return {
+        parameterCount,
+        requiredParameterCount,
+        parameterTypes: types.length > 0 ? types : undefined,
+    };
+}