gitnexus 1.6.12-rc.2 → 1.6.12-rc.21

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

@@ -7,7 +7,7 @@
  * 3. Add one line to the `providers` table below
  * 4. Run `tsc --noEmit` to verify
  */
-import { SupportedLanguages, isBladeTemplateFilename } from '../../../_shared/index.js';
+import { SupportedLanguages, getLanguageFromFilename, isBladeTemplateFilename, } from '../../../_shared/index.js';
 import { typescriptProvider, javascriptProvider } from './typescript.js';
 import { pythonProvider } from './python.js';
 import { javaProvider } from './java.js';
@@ -16,6 +16,7 @@ import { goProvider } from './go.js';
 import { rustProvider } from './rust.js';
 import { csharpProvider } from './csharp.js';
 import { cProvider, cppProvider } from './c-cpp.js';
+import { objectiveCProvider } from './objective-c.js';
 import { phpProvider } from './php.js';
 import { rubyProvider } from './ruby.js';
 import { swiftProvider } from './swift.js';
@@ -34,6 +35,7 @@ export const providers = {
     [SupportedLanguages.CSharp]: csharpProvider,
     [SupportedLanguages.C]: cProvider,
     [SupportedLanguages.CPlusPlus]: cppProvider,
+    [SupportedLanguages.ObjectiveC]: objectiveCProvider,
     [SupportedLanguages.PHP]: phpProvider,
     [SupportedLanguages.Ruby]: rubyProvider,
     [SupportedLanguages.Swift]: swiftProvider,
@@ -63,3 +65,30 @@ export function getProviderForFile(filePath) {
     const basename = filePath.slice(filePath.lastIndexOf('/') + 1);
     return extensionMap.get(ext) ?? extensionMap.get(basename) ?? null;
 }
+/** Return the provider whose content classifier confidently claims this file. */
+export function getProviderForFileContent(filePath, content) {
+    if (isBladeTemplateFilename(filePath))
+        return null;
+    for (const provider of Object.values(providers)) {
+        if (provider.classifyFileContent?.(filePath, content) === true)
+            return provider;
+    }
+    const byExtension = getProviderForFile(filePath);
+    if (byExtension)
+        return byExtension;
+    // Filename-only languages (Rakefile, Gemfile, …) live in
+    // getLanguageFromFilename, not provider.extensions.
+    const filenameLang = getLanguageFromFilename(filePath);
+    return filenameLang === null ? null : providers[filenameLang];
+}
+/** True when at least one provider wants source text before language bucketing. */
+export function needsContentLanguageClassification(filePath) {
+    if (isBladeTemplateFilename(filePath))
+        return false;
+    return Object.values(providers).some((provider) => provider.classifyFileContent !== undefined &&
+        provider.shouldClassifyFileContent?.(filePath) === true);
+}
+/** Return the effective language for a file, optionally using source content. */
+export function getLanguageForFileContent(filePath, content) {
+    return getProviderForFileContent(filePath, content)?.id ?? null;
+}

package/dist/core/ingestion/languages/objective-c/analysis-features.d.ts

@@ -0,0 +1,10 @@
+import type { AnalysisFeatureDescriptor } from '../../../analysis-features.js';
+/**
+ * Durable metadata stamp for Objective-C semantic indexing. The feature id
+ * carries provider and grammar versions verbatim so a semantic identity/edge
+ * change records the exact producer in index metadata and forces a full rebuild.
+ *
+ * `.h` is included only as a path-level rebuild predicate; content classification
+ * still decides whether a header is actually parsed as Objective-C.
+ */
+export declare const OBJECTIVE_C_PROVIDER_FEATURE: AnalysisFeatureDescriptor;

package/dist/core/ingestion/languages/objective-c/analysis-features.js

@@ -0,0 +1,19 @@
+import { OBJECTIVE_C_GRAMMAR_PACKAGE, OBJECTIVE_C_GRAMMAR_VERSION, OBJECTIVE_C_PROVIDER_VERSION, } from './facts.js';
+function isObjectiveCProviderCandidatePath(filePath) {
+    const normalized = filePath.replaceAll('\\', '/').toLowerCase();
+    return normalized.endsWith('.m') || normalized.endsWith('.mm') || normalized.endsWith('.h');
+}
+/**
+ * Durable metadata stamp for Objective-C semantic indexing. The feature id
+ * carries provider and grammar versions verbatim so a semantic identity/edge
+ * change records the exact producer in index metadata and forces a full rebuild.
+ *
+ * `.h` is included only as a path-level rebuild predicate; content classification
+ * still decides whether a header is actually parsed as Objective-C.
+ */
+export const OBJECTIVE_C_PROVIDER_FEATURE = {
+    id: `objective-c.provider-${OBJECTIVE_C_PROVIDER_VERSION}.` +
+        `${OBJECTIVE_C_GRAMMAR_PACKAGE}-${OBJECTIVE_C_GRAMMAR_VERSION}`,
+    version: 1,
+    appliesTo: (filePaths) => filePaths.some(isObjectiveCProviderCandidatePath),
+};

package/dist/core/ingestion/languages/objective-c/compilation-unit-siblings.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Header / implementation visibility for `populateNamespaceSiblings`.
+ *
+ * Objective-C has no Java package or C# namespace. The compilation unit is
+ * the workspace analog: `Foo.h` + `Foo.m` in the same directory, and files
+ * that declare or implement the same class / protocol, see each other's
+ * top-level defs without a second `#import` of a sibling they already share.
+ * Bindings go through the append-only `bindingAugmentations` channel
+ * (`origin: 'namespace'`), matching Swift / Go.
+ */
+import type { ParsedFile } from '../../../../_shared/index.js';
+import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
+export declare function populateObjectiveCCompilationUnitSiblings(parsedFiles: readonly ParsedFile[], indexes: ScopeResolutionIndexes): void;

package/dist/core/ingestion/languages/objective-c/compilation-unit-siblings.js

@@ -0,0 +1,124 @@
+/**
+ * Header / implementation visibility for `populateNamespaceSiblings`.
+ *
+ * Objective-C has no Java package or C# namespace. The compilation unit is
+ * the workspace analog: `Foo.h` + `Foo.m` in the same directory, and files
+ * that declare or implement the same class / protocol, see each other's
+ * top-level defs without a second `#import` of a sibling they already share.
+ * Bindings go through the append-only `bindingAugmentations` channel
+ * (`origin: 'namespace'`), matching Swift / Go.
+ */
+import { isInternalObjectiveCFunctionDef, objectiveCFactsFromParsedFiles, } from './facts.js';
+export function populateObjectiveCCompilationUnitSiblings(parsedFiles, indexes) {
+    const groups = new Map();
+    const byPath = new Map();
+    for (const parsed of parsedFiles) {
+        byPath.set(parsed.filePath, parsed);
+        const stemKey = compilationUnitStemKey(parsed.filePath);
+        if (stemKey !== undefined)
+            appendGroup(groups, stemKey, parsed);
+    }
+    const internalFunctionIds = new Set();
+    for (const fact of objectiveCFactsFromParsedFiles(parsedFiles)) {
+        const parsed = byPath.get(fact.filePath);
+        if (parsed !== undefined) {
+            for (const container of fact.containers) {
+                appendGroup(groups, `type:${typeVisibilityKey(container)}`, parsed);
+            }
+        }
+        for (const fn of fact.functions) {
+            if (fn.linkage === 'internal')
+                internalFunctionIds.add(fn.nodeId);
+        }
+    }
+    const augmentations = indexes.bindingAugmentations;
+    for (const group of groups.values()) {
+        if (group.length < 2)
+            continue;
+        const unique = uniqueFiles(group);
+        if (unique.length < 2)
+            continue;
+        for (const receiver of unique) {
+            const receiverModule = indexes.moduleScopes.byFilePath.get(receiver.filePath);
+            if (receiverModule === undefined)
+                continue;
+            for (const source of unique) {
+                if (source.filePath === receiver.filePath)
+                    continue;
+                for (const def of source.localDefs) {
+                    if (internalFunctionIds.has(def.nodeId) || isInternalObjectiveCFunctionDef(def)) {
+                        continue;
+                    }
+                    const name = siblingBindingName(def);
+                    if (name === '')
+                        continue;
+                    const bucket = getAugmentationBucket(augmentations, receiverModule, name);
+                    if (bucket.some((binding) => binding.def.nodeId === def.nodeId))
+                        continue;
+                    bucket.push({ def, origin: 'namespace' });
+                }
+            }
+        }
+    }
+}
+function compilationUnitStemKey(filePath) {
+    const normalized = filePath.replaceAll('\\', '/');
+    const slash = normalized.lastIndexOf('/');
+    const base = slash === -1 ? normalized : normalized.slice(slash + 1);
+    const ext = extensionOf(base);
+    if (ext !== '.h' && ext !== '.m' && ext !== '.mm')
+        return undefined;
+    const dir = slash === -1 ? '' : normalized.slice(0, slash);
+    return `stem:${dir}/${base.slice(0, -ext.length)}`;
+}
+/** Class/category/extension files share one group; a same-named protocol does not. */
+function typeVisibilityKey(container) {
+    if (container.kind === 'category' || container.kind === 'extension') {
+        return `class:${container.hostClass ?? container.name}`;
+    }
+    return `${container.kind}:${container.name}`;
+}
+function siblingBindingName(def) {
+    const qualified = def.qualifiedName ?? '';
+    if (qualified.startsWith('objc:')) {
+        const colon = qualified.lastIndexOf(':');
+        return colon === -1 ? qualified : qualified.slice(colon + 1);
+    }
+    return qualified.split('.').pop() ?? qualified;
+}
+function extensionOf(fileName) {
+    const dot = fileName.lastIndexOf('.');
+    return dot === -1 ? '' : fileName.slice(dot).toLowerCase();
+}
+function appendGroup(groups, key, parsed) {
+    const bucket = groups.get(key);
+    if (bucket === undefined) {
+        groups.set(key, [parsed]);
+        return;
+    }
+    bucket.push(parsed);
+}
+function uniqueFiles(group) {
+    const seen = new Set();
+    const out = [];
+    for (const parsed of group) {
+        if (seen.has(parsed.filePath))
+            continue;
+        seen.add(parsed.filePath);
+        out.push(parsed);
+    }
+    return out;
+}
+function getAugmentationBucket(augmentations, scopeId, name) {
+    let scopeBindings = augmentations.get(scopeId);
+    if (scopeBindings === undefined) {
+        scopeBindings = new Map();
+        augmentations.set(scopeId, scopeBindings);
+    }
+    let bucket = scopeBindings.get(name);
+    if (bucket === undefined) {
+        bucket = [];
+        scopeBindings.set(name, bucket);
+    }
+    return bucket;
+}

package/dist/core/ingestion/languages/objective-c/facts.d.ts

@@ -0,0 +1,148 @@
+import type { CaptureMatch, ParsedFile } from '../../../../_shared/index.js';
+import type Parser from 'tree-sitter';
+import type { ProviderSemanticGraph } from '../../language-provider.js';
+import { type SyntaxNode } from '../../utils/ast-helpers.js';
+export declare const OBJECTIVE_C_PROVIDER_VERSION = "0.1.8";
+export declare const OBJECTIVE_C_GRAMMAR_PACKAGE = "tree-sitter-objc";
+export declare const OBJECTIVE_C_GRAMMAR_VERSION = "3.0.2";
+export type ObjCMethodKind = '-' | '+';
+export type ObjCContainerKind = 'class' | 'protocol' | 'category' | 'extension';
+export interface ObjCTypeInfo {
+    readonly kind: 'class' | 'protocol' | 'dynamic' | 'class-object' | 'unknown';
+    readonly name?: string;
+    readonly raw: string;
+}
+export interface ObjCContainerFact {
+    readonly kind: ObjCContainerKind;
+    readonly declarationRole: 'interface' | 'implementation';
+    readonly name: string;
+    readonly qualifiedName: string;
+    readonly nodeId: string;
+    readonly label: 'Class' | 'Protocol' | 'Category';
+    readonly filePath: string;
+    readonly startLine: number;
+    readonly endLine: number;
+    readonly superclass?: string;
+    readonly protocols: readonly string[];
+    readonly hostClass?: string;
+    readonly categoryName?: string;
+}
+export interface ObjCMethodFact {
+    readonly name: string;
+    readonly selector: string;
+    readonly methodKind: ObjCMethodKind;
+    readonly ownerQualifiedName: string;
+    readonly ownerName: string;
+    readonly ownerKind: ObjCContainerKind;
+    readonly hostClass?: string;
+    readonly qualifiedName: string;
+    readonly nodeId: string;
+    readonly filePath: string;
+    readonly startLine: number;
+    readonly endLine: number;
+    readonly declarationRole: 'declaration' | 'implementation';
+    readonly returnType?: string;
+    readonly parameterTypes: readonly string[];
+    readonly parameterNames: readonly string[];
+}
+export interface ObjCMemberFact {
+    readonly kind: 'property' | 'ivar';
+    readonly name: string;
+    readonly qualifiedName: string;
+    readonly nodeId: string;
+    readonly ownerQualifiedName: string;
+    readonly ownerName: string;
+    readonly ownerKind: ObjCContainerKind;
+    readonly ownerLabel: 'Class' | 'Protocol' | 'Category';
+    readonly hostClass?: string;
+    readonly declaredType?: string;
+    readonly filePath: string;
+    readonly startLine: number;
+    readonly endLine: number;
+}
+export interface ObjCFunctionFact {
+    readonly name: string;
+    readonly linkage: 'external' | 'internal';
+    readonly qualifiedName: string;
+    readonly nodeId: string;
+    readonly filePath: string;
+    readonly startLine: number;
+    readonly endLine: number;
+    readonly returnType?: string;
+    readonly parameterTypes: readonly string[];
+}
+export interface ObjCImportFact {
+    readonly kind: 'import' | 'include' | 'module';
+    readonly raw: string;
+    readonly targetRaw: string;
+    readonly filePath: string;
+    readonly startLine: number;
+    readonly endLine: number;
+}
+export interface ObjCMessageFact {
+    readonly selector: string;
+    readonly receiverText: string;
+    readonly receiverKind: 'self' | 'super' | 'class' | 'local' | 'property' | 'ivar' | 'dynamic' | 'unknown';
+    readonly receiverType?: ObjCTypeInfo;
+    /** Member name retained when its type must be resolved across files. */
+    readonly receiverMemberName?: string;
+    readonly sourceMethodQualifiedName: string;
+    readonly sourceMethodId: string;
+    readonly sourceOwnerQualifiedName: string;
+    readonly sourceOwnerName: string;
+    readonly sourceMethodKind: ObjCMethodKind;
+    readonly filePath: string;
+    readonly startLine: number;
+    readonly startCol: number;
+}
+export interface ObjCUnresolvedMessageFact {
+    readonly selector: string;
+    readonly receiverText: string;
+    readonly reason: string;
+    readonly sourceMethodQualifiedName: string;
+    readonly sourceMethodId: string;
+    readonly filePath: string;
+    readonly startLine: number;
+    readonly startCol: number;
+}
+export interface ObjCFileFacts {
+    readonly providerVersion: string;
+    readonly grammarPackage: string;
+    readonly grammarVersion: string;
+    readonly filePath: string;
+    readonly containers: readonly ObjCContainerFact[];
+    readonly methods: readonly ObjCMethodFact[];
+    readonly members: readonly ObjCMemberFact[];
+    readonly functions: readonly ObjCFunctionFact[];
+    readonly imports: readonly ObjCImportFact[];
+    readonly messages: readonly ObjCMessageFact[];
+    readonly unresolvedMessages: readonly ObjCUnresolvedMessageFact[];
+}
+export interface ObjCCaptureSideChannel {
+    readonly kind: 'objective-c';
+    readonly facts: ObjCFileFacts;
+}
+export declare function setObjectiveCFileFacts(facts: ObjCFileFacts): void;
+export declare function getObjectiveCFileFacts(filePath: string): ObjCFileFacts | undefined;
+/** Drop process-local facts before a new workspace pass (Java/Kotlin analog). */
+export declare function clearObjectiveCFileFacts(): void;
+export declare function collectObjectiveCCaptureSideChannel(filePath: string): ObjCCaptureSideChannel | undefined;
+export declare function applyObjectiveCCaptureSideChannel(parsed: ParsedFile): void;
+export declare function objectiveCFactsFromParsedFiles(parsedFiles: readonly ParsedFile[]): ObjCFileFacts[];
+export declare const objcClassQualifiedName: (name: string) => string;
+export declare const objcProtocolQualifiedName: (name: string) => string;
+export declare const objcCategoryQualifiedName: (hostClass: string, categoryName: string) => string;
+export declare const objcMethodQualifiedName: (ownerQualifiedName: string, methodKind: ObjCMethodKind, selector: string) => string;
+export declare const objcPropertyQualifiedName: (ownerQualifiedName: string, name: string) => string;
+export declare const objcIvarQualifiedName: (ownerQualifiedName: string, name: string) => string;
+export declare const objcFunctionQualifiedName: (name: string, linkage?: "external" | "internal", filePath?: string) => string;
+/** True for C functions this provider models as translation-unit local. */
+export declare function isInternalObjectiveCFunctionDef(def: {
+    readonly nodeId?: string;
+    readonly qualifiedName?: string;
+}): boolean;
+export declare const objcUnresolvedMessageQualifiedName: (filePath: string, startLine: number, startCol: number, selector: string) => string;
+export declare function parseObjCType(raw: string | undefined): ObjCTypeInfo | undefined;
+export declare function collectObjectiveCFacts(tree: Parser.Tree, filePath: string): ObjCFileFacts;
+export declare function buildObjectiveCSemanticGraph(facts: ObjCFileFacts): ProviderSemanticGraph;
+export declare function buildObjectiveCScopeCaptures(facts: ObjCFileFacts, root: SyntaxNode): readonly CaptureMatch[];