gitnexus 1.6.13-rc.64 → 1.6.13-rc.66

package/dist/core/ingestion/languages/swift/callable-visibility.d.ts

@@ -0,0 +1,9 @@
+import type { ParsedFile, ScopeId, SymbolDefinition } from '../../../../_shared/index.js';
+import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
+export declare function swiftIsCallableVisibleFromCaller(ctx: {
+    readonly candidate: SymbolDefinition;
+    readonly callerParsed?: ParsedFile;
+    readonly callArity?: number;
+    readonly callerScope?: ScopeId;
+    readonly scopes?: ScopeResolutionIndexes;
+}): boolean;

package/dist/core/ingestion/languages/swift/callable-visibility.js

@@ -0,0 +1,57 @@
+import { findClassBindingInScope } from '../../scope-resolution/scope/walkers.js';
+export function swiftIsCallableVisibleFromCaller(ctx) {
+    const indexes = ctx.scopes;
+    if (ctx.callerScope === undefined || indexes === undefined || ctx.callArity !== 0)
+        return true;
+    const name = ctx.candidate.qualifiedName?.split('.').at(-1);
+    if (name === undefined)
+        return true;
+    let scopeId = ctx.callerScope;
+    let selfType;
+    while (scopeId !== null) {
+        const scope = indexes.scopeTree.getScope(scopeId);
+        if (scope === undefined)
+            break;
+        // A local function selected inside the caller wins before member lookup.
+        if (scope.kind !== 'Class' &&
+            scope.ownedDefs.some((def) => def.nodeId === ctx.candidate.nodeId))
+            return true;
+        selfType ??= scope.typeBindings.get('self');
+        if (scope.kind === 'Class') {
+            const classDef = scope.ownedDefs.find((def) => def.type === 'Class') ??
+                (selfType === undefined
+                    ? undefined
+                    : findClassBindingInScope(ctx.callerScope, selfType.rawName, indexes, undefined, {
+                        uniqueQualifiedNameFallback: false,
+                    }));
+            const propertyOnOwner = (ownerId, ownerName) => indexes.qualifiedNames.get(`${ownerName}.${name}`).some((defId) => {
+                const def = indexes.defs.get(defId);
+                return def?.type === 'Property' && def.ownerId === ownerId;
+            });
+            const ownProperty = scope.ownedDefs.some((def) => def.type === 'Property' && def.qualifiedName?.split('.').at(-1) === name) ||
+                (classDef !== undefined &&
+                    classDef.qualifiedName !== undefined &&
+                    propertyOnOwner(classDef.nodeId, classDef.qualifiedName));
+            const inheritedProperty = classDef !== undefined &&
+                indexes.methodDispatch.mroFor(classDef.nodeId).some((ownerId) => {
+                    const ownerName = indexes.defs.get(ownerId)?.qualifiedName;
+                    return ownerName !== undefined && propertyOnOwner(ownerId, ownerName);
+                });
+            if (!ownProperty && !inheritedProperty)
+                return true;
+            // Swift's nested function is owned by its own Function scope. A
+            // same-file sibling must not count as a nearer lexical binding.
+            const declarationScope = ctx.callerParsed?.scopes.find((candidateScope) => candidateScope.ownedDefs.some((def) => def.nodeId === ctx.candidate.nodeId));
+            if (declarationScope !== undefined &&
+                declarationScope.kind === 'Function' &&
+                (declarationScope.id === ctx.callerScope ||
+                    indexes.scopeTree.getAncestors(declarationScope.id).includes(ctx.callerScope)))
+                return true;
+            // Scope defs do not carry Swift access modifiers. A method positively
+            // selected on this type must not be vetoed by an uncertain ancestor.
+            return classDef !== undefined && ctx.candidate.ownerId === classDef.nodeId;
+        }
+        scopeId = scope.parent;
+    }
+    return true;
+}

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

@@ -56,6 +56,7 @@ import { swiftArityCompatibility, swiftMergeBindings, interpretSwiftImport, reso
 import { stripSwiftTypePreservingDecoration } from './interpret.js';
 import { groupSwiftFilesByModule } from './target-grouping.js';
 import { swiftIsGlobalNameFallbackPlausible } from './name-fallback-visibility.js';
+import { swiftIsCallableVisibleFromCaller } from './callable-visibility.js';
 const ZERO_RANGE = { startLine: 0, startCol: 0, endLine: 0, endCol: 0 };
 const swiftScopeResolver = {
     language: SupportedLanguages.Swift,
@@ -123,6 +124,7 @@ const swiftScopeResolver = {
     // no-`new` constructor + cross-file free-call shape).
     allowGlobalFreeCallFallback: true,
     isGlobalNameFallbackPlausible: swiftIsGlobalNameFallbackPlausible,
+    isCallableVisibleFromCaller: swiftIsCallableVisibleFromCaller,
     // Swift's call graph models `Type(...)` as a reference to the type
     // itself, not its `init` — both the legacy DAG and this test suite link
     // `Foo()` to the Class node even when an explicit `init` exists.

package/dist/core/ingestion/scope-resolution/contract/scope-resolver.d.ts

@@ -1112,6 +1112,9 @@ export interface ScopeResolver {
     readonly isCallableVisibleFromCaller?: (ctx: {
         readonly callerParsed: ParsedFile;
         readonly candidate: SymbolDefinition;
+        /** Arity of the actual call, when known. A visibility veto must not
+         *  infer applicability from a name match alone. */
+        readonly callArity?: number;
         /** Caller's enclosing scope id. Languages that gate visibility on
          *  caller scope (e.g. C++ two-phase template lookup) consult it;
          *  others ignore. Optional so existing implementations stay valid. */

package/dist/core/ingestion/scope-resolution/passes/free-call-fallback.d.ts

@@ -47,12 +47,7 @@ export declare function emitFreeCallFallback(graph: KnowledgeGraph, scopes: Scop
      *  appended to its reason. See `ScopeResolver.markConstructionSites`. */
     readonly markConstructionSites?: boolean;
     readonly isFileLocalDef?: (def: SymbolDefinition) => boolean;
-    readonly isCallableVisibleFromCaller?: (ctx: {
-        readonly callerParsed: ParsedFile;
-        readonly candidate: SymbolDefinition;
-        readonly callerScope?: ScopeId;
-        readonly scopes?: ScopeResolutionIndexes;
-    }) => boolean;
+    readonly isCallableVisibleFromCaller?: ScopeResolver['isCallableVisibleFromCaller'];
     readonly resolveAdlCandidates?: (site: {
         readonly name: string;
         readonly arity?: number;

package/dist/core/ingestion/scope-resolution/passes/free-call-fallback.js

@@ -447,6 +447,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                     ? (candidate) => options.isCallableVisibleFromCaller({
                         callerParsed: parsed,
                         candidate,
+                        callArity: site.arity,
                         callerScope: site.inScope,
                         scopes,
                     })
@@ -514,6 +515,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                 !options.isCallableVisibleFromCaller({
                     callerParsed: parsed,
                     candidate: fnDef,
+                    callArity: site.arity,
                     callerScope: site.inScope,
                     scopes,
                 })) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.13-rc.64",
+  "version": "1.6.13-rc.66",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",