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

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

@@ -0,0 +1,11 @@
+/**
+ * Resolve an Objective-C `#import` / `#include` / `@import` to a workspace file.
+ *
+ * Quoted imports keep the suffix-index first-path tie-break used before the
+ * workspace config existed. Angle-bracket imports never suffix-match the
+ * source tree — they only hit in-repo frameworks and HEADER_SEARCH_PATHS —
+ * so `<Foundation/Foundation.h>` stays unresolved even when a decoy
+ * `Foundation.h` exists. `@import` names resolve only through a scanned
+ * module map.
+ */
+export declare function resolveObjectiveCImportTarget(targetRaw: string, fromFile: string, allFilePaths: ReadonlySet<string>, resolutionConfig?: unknown): string | null;

package/dist/core/ingestion/languages/objective-c/import-target.js

@@ -0,0 +1,122 @@
+/**
+ * Resolve an Objective-C `#import` / `#include` / `@import` to a workspace file.
+ *
+ * Quoted imports keep the suffix-index first-path tie-break used before the
+ * workspace config existed. Angle-bracket imports never suffix-match the
+ * source tree — they only hit in-repo frameworks and HEADER_SEARCH_PATHS —
+ * so `<Foundation/Foundation.h>` stays unresolved even when a decoy
+ * `Foundation.h` exists. `@import` names resolve only through a scanned
+ * module map.
+ */
+import path from 'path';
+import { perFileSet } from '../../import-resolvers/per-file-set.js';
+import { coerceObjectiveCResolutionConfig, normalizeRepoPath, } from './resolution-config.js';
+/**
+ * Per-pass memo of `allFilePaths ∪ scanned headers`. Identity is load-bearing
+ * for `getObjectiveCImportIndex` (same rule as C/C++ `augmentedFilePathsFor`).
+ * This memo stays private to Objective-C — sharing it with C would hand each
+ * language the other's suffix index.
+ */
+const augmentedFilePathsFor = perFileSet((allFilePaths) => perFileSet((headerPaths) => {
+    const set = new Set(allFilePaths);
+    for (const header of headerPaths)
+        set.add(header);
+    return set;
+}));
+const getObjectiveCImportIndex = perFileSet((allFilePaths) => {
+    const filePaths = [...allFilePaths];
+    const suffixMatches = new Map();
+    for (const [order, filePath] of filePaths.entries()) {
+        const segments = normalizeRepoPath(filePath).split('/');
+        for (let start = 1; start < segments.length; start++) {
+            const suffix = segments.slice(start).join('/');
+            if (!suffixMatches.has(suffix))
+                suffixMatches.set(suffix, { filePath, order });
+        }
+    }
+    return { filePathSet: new Set(filePaths), suffixMatches };
+});
+export function resolveObjectiveCImportTarget(targetRaw, fromFile, allFilePaths, resolutionConfig) {
+    const target = targetRaw.trim();
+    if (target.length === 0)
+        return null;
+    const config = coerceObjectiveCResolutionConfig(resolutionConfig);
+    const searchPaths = config !== undefined && config.headers.size > 0
+        ? augmentedFilePathsFor(allFilePaths)(config.headers)
+        : allFilePaths;
+    if (target.startsWith('<') && target.endsWith('>')) {
+        return resolveAngleImport(target.slice(1, -1), searchPaths, config);
+    }
+    const looksLikeFileImport = target.startsWith('.') || target.includes('/') || path.posix.extname(target).length > 0;
+    if (!looksLikeFileImport) {
+        return resolveModuleImport(target, searchPaths, config);
+    }
+    return findImportCandidate(target, fromFile, getObjectiveCImportIndex(searchPaths), config);
+}
+function resolveAngleImport(inner, searchPaths, config) {
+    const normalized = normalizeRepoPath(inner);
+    if (normalized.length === 0 || config === undefined)
+        return null;
+    const slash = normalized.indexOf('/');
+    if (slash > 0) {
+        const framework = normalized.slice(0, slash);
+        const rest = normalized.slice(slash + 1);
+        const headersDir = config.frameworks.get(framework);
+        if (headersDir !== undefined) {
+            const framed = normalizeRepoPath(`${headersDir}/${rest}`);
+            if (searchPaths.has(framed))
+                return framed;
+        }
+    }
+    for (const searchPath of config.headerSearchPaths) {
+        const candidate = normalizeRepoPath(`${searchPath}/${normalized}`);
+        if (searchPaths.has(candidate))
+            return candidate;
+    }
+    return null;
+}
+function resolveModuleImport(moduleName, searchPaths, config) {
+    if (config === undefined)
+        return null;
+    const exact = config.modules.get(moduleName);
+    if (exact !== undefined && searchPaths.has(exact))
+        return exact;
+    const root = moduleName.split('.')[0];
+    if (root === undefined || root === moduleName)
+        return null;
+    const fallback = config.modules.get(root);
+    return fallback !== undefined && searchPaths.has(fallback) ? fallback : null;
+}
+function findImportCandidate(targetRaw, fromFile, importIndex, config) {
+    const normalizedTarget = normalizeRepoPath(targetRaw);
+    const fromDir = normalizeRepoPath(path.posix.dirname(normalizeRepoPath(fromFile)));
+    const spelledCandidates = new Set([
+        normalizeRepoPath(path.posix.join(fromDir, normalizedTarget)),
+        normalizedTarget,
+    ]);
+    if (config !== undefined) {
+        for (const searchPath of [...config.userHeaderSearchPaths, ...config.headerSearchPaths]) {
+            spelledCandidates.add(normalizeRepoPath(`${searchPath}/${normalizedTarget}`));
+        }
+    }
+    const ext = path.posix.extname(normalizedTarget);
+    if (ext.length === 0) {
+        for (const base of [...spelledCandidates]) {
+            spelledCandidates.add(`${base}.h`);
+            spelledCandidates.add(`${base}.m`);
+            spelledCandidates.add(`${base}.mm`);
+        }
+    }
+    for (const candidate of spelledCandidates) {
+        if (importIndex.filePathSet.has(candidate))
+            return candidate;
+    }
+    let suffixMatch;
+    for (const candidate of spelledCandidates) {
+        const match = importIndex.suffixMatches.get(candidate);
+        if (match !== undefined && (suffixMatch === undefined || match.order < suffixMatch.order)) {
+            suffixMatch = match;
+        }
+    }
+    return suffixMatch?.filePath ?? null;
+}

package/dist/core/ingestion/languages/objective-c/macro-marker-preprocess.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Normalize bare file-scope Objective-C macro markers before parsing.
+ *
+ * Headers commonly use macro pairs such as `RCT_EXTERN_C_BEGIN` and
+ * `RCT_EXTERN_C_END` around C declarations. tree-sitter-objc does not expand
+ * those macros; a bare invocation can put the parser into error recovery and
+ * hide every Objective-C declaration that follows it. These markers do not
+ * contribute syntax on their own, so we replace only the narrow, generic form
+ * with spaces before parsing.
+ *
+ * This is deliberately not macro expansion or a framework-specific allowlist:
+ * a candidate must be a whole, all-caps identifier at file scope. Function-like
+ * macros, directives, statements, strings, and comments remain untouched.
+ * Replacement preserves UTF-16 length and line endings exactly. Candidates are
+ * ASCII-only, so their byte offsets are preserved as well.
+ */
+/**
+ * Elide bare, file-scope macro markers while preserving source positions.
+ *
+ * `_filePath` is accepted for the LanguageProvider hook signature. The
+ * transform is based only on source syntax and deliberately has no framework
+ * or repository-specific configuration.
+ */
+export declare function preprocessObjectiveCMacroMarkers(source: string, _filePath?: string): string;

package/dist/core/ingestion/languages/objective-c/macro-marker-preprocess.js

@@ -0,0 +1,261 @@
+/**
+ * Normalize bare file-scope Objective-C macro markers before parsing.
+ *
+ * Headers commonly use macro pairs such as `RCT_EXTERN_C_BEGIN` and
+ * `RCT_EXTERN_C_END` around C declarations. tree-sitter-objc does not expand
+ * those macros; a bare invocation can put the parser into error recovery and
+ * hide every Objective-C declaration that follows it. These markers do not
+ * contribute syntax on their own, so we replace only the narrow, generic form
+ * with spaces before parsing.
+ *
+ * This is deliberately not macro expansion or a framework-specific allowlist:
+ * a candidate must be a whole, all-caps identifier at file scope. Function-like
+ * macros, directives, statements, strings, and comments remain untouched.
+ * Replacement preserves UTF-16 length and line endings exactly. Candidates are
+ * ASCII-only, so their byte offsets are preserved as well.
+ */
+function isPreprocessorWhitespace(code) {
+    // C preprocessing whitespace includes space, horizontal tab, vertical tab,
+    // and form feed. Newlines are split before this scanner sees a line.
+    return code === 0x20 || code === 0x09 || code === 0x0b || code === 0x0c;
+}
+function isBareMarkerIdentifier(line) {
+    let index = 0;
+    while (index < line.length && isPreprocessorWhitespace(line.charCodeAt(index)))
+        index++;
+    const identifierStart = index;
+    const first = line.charCodeAt(index);
+    if (!((first >= 0x41 && first <= 0x5a) || first === 0x5f))
+        return false;
+    let hasUppercaseLetter = false;
+    while (index < line.length) {
+        const code = line.charCodeAt(index);
+        if (code >= 0x41 && code <= 0x5a) {
+            hasUppercaseLetter = true;
+            index++;
+            continue;
+        }
+        if ((code >= 0x30 && code <= 0x39) || code === 0x5f) {
+            index++;
+            continue;
+        }
+        break;
+    }
+    if (index === identifierStart || !hasUppercaseLetter)
+        return false;
+    while (index < line.length && isPreprocessorWhitespace(line.charCodeAt(index)))
+        index++;
+    return index === line.length;
+}
+function isIdentifierContinue(line, index) {
+    if (index >= line.length)
+        return false;
+    const code = line.charCodeAt(index);
+    return ((code >= 0x41 && code <= 0x5a) ||
+        (code >= 0x61 && code <= 0x7a) ||
+        (code >= 0x30 && code <= 0x39) ||
+        code === 0x5f);
+}
+function leadingObjCDeclKeyword(line, inBlockComment = false) {
+    let index = 0;
+    if (inBlockComment) {
+        const blockCommentEnd = line.indexOf('*/');
+        if (blockCommentEnd < 0)
+            return null;
+        index = blockCommentEnd + 2;
+    }
+    while (index < line.length) {
+        while (index < line.length && isPreprocessorWhitespace(line.charCodeAt(index)))
+            index++;
+        if (line.startsWith('//', index))
+            return null;
+        if (line.startsWith('/*', index)) {
+            const blockCommentEnd = line.indexOf('*/', index + 2);
+            if (blockCommentEnd < 0)
+                return null;
+            index = blockCommentEnd + 2;
+            continue;
+        }
+        break;
+    }
+    if (line.startsWith('@end', index) && !isIdentifierContinue(line, index + 4))
+        return 'end';
+    for (const keyword of ['@interface', '@protocol', '@implementation']) {
+        if (line.startsWith(keyword, index) && !isIdentifierContinue(line, index + keyword.length)) {
+            return 'begin';
+        }
+    }
+    return null;
+}
+function hasEscapedLineEnding(line) {
+    let trailingBackslashes = 0;
+    for (let index = line.length - 1; index >= 0 && line.charCodeAt(index) === 0x5c; index--) {
+        trailingBackslashes++;
+    }
+    return trailingBackslashes % 2 === 1;
+}
+function startsPreprocessorDirective(line, state) {
+    let index = 0;
+    let inBlockComment = state.inBlockComment;
+    while (index < line.length) {
+        if (inBlockComment) {
+            const blockCommentEnd = line.indexOf('*/', index);
+            if (blockCommentEnd < 0)
+                return false;
+            inBlockComment = false;
+            index = blockCommentEnd + 2;
+            continue;
+        }
+        while (index < line.length && isPreprocessorWhitespace(line.charCodeAt(index)))
+            index++;
+        if (line.startsWith('/*', index)) {
+            inBlockComment = true;
+            index += 2;
+            continue;
+        }
+        if (line.startsWith('//', index))
+            return false;
+        if (line.charCodeAt(index) !== 0x23)
+            return false;
+        state.inBlockComment = false;
+        return true;
+    }
+    return false;
+}
+function scanBalancedDelimiters(code, state) {
+    if (code === 0x28)
+        state.parenDepth++;
+    else if (code === 0x29)
+        state.parenDepth = Math.max(0, state.parenDepth - 1);
+    else if (code === 0x7b)
+        state.braceDepth++;
+    else if (code === 0x7d)
+        state.braceDepth = Math.max(0, state.braceDepth - 1);
+}
+function scanLineBody(line, state, startIndex, trackDelimiters) {
+    for (let index = startIndex; index < line.length; index++) {
+        const code = line.charCodeAt(index);
+        const next = line.charCodeAt(index + 1);
+        if (state.inBlockComment) {
+            if (code === 0x2a && next === 0x2f) {
+                state.inBlockComment = false;
+                index++;
+            }
+            continue;
+        }
+        if (state.quote !== undefined) {
+            if (code === 0x5c) {
+                index++;
+            }
+            else if (line[index] === state.quote) {
+                state.quote = undefined;
+            }
+            continue;
+        }
+        if (code === 0x2f && next === 0x2f) {
+            state.inLineCommentContinuation = hasEscapedLineEnding(line);
+            return;
+        }
+        if (code === 0x2f && next === 0x2a) {
+            state.inBlockComment = true;
+            index++;
+            continue;
+        }
+        if (code === 0x22 || code === 0x27) {
+            state.quote = line[index];
+            continue;
+        }
+        // Directive replacement text is tokens, not C scopes. `{` in
+        // `#define WRAP {` must not pin braceDepth for later file-scope markers.
+        if (trackDelimiters)
+            scanBalancedDelimiters(code, state);
+    }
+}
+function scanDirectiveLine(line, state) {
+    const continued = hasEscapedLineEnding(line);
+    scanLineBody(line, state, 0, false);
+    state.inPreprocessorDirective = continued;
+    // A quote opened in replacement text does not survive past the directive.
+    if (!continued)
+        state.quote = undefined;
+}
+function scanLine(line, state) {
+    if (state.inLineCommentContinuation) {
+        state.inLineCommentContinuation = hasEscapedLineEnding(line);
+        // A `// ... \` splice keeps the next physical line in the comment, but the
+        // directive ends unless that line is itself backslash-continued.
+        if (state.inPreprocessorDirective) {
+            state.inPreprocessorDirective = state.inLineCommentContinuation;
+        }
+        return;
+    }
+    if (state.inPreprocessorDirective) {
+        scanDirectiveLine(line, state);
+        return;
+    }
+    if (startsPreprocessorDirective(line, state)) {
+        // Directives can open a block comment (`#define X /*`) that continues
+        // onto the next physical line. Scan comment/quote state only.
+        scanDirectiveLine(line, state);
+        return;
+    }
+    if (state.inCodeLineContinuation) {
+        scanLineBody(line, state, 0, true);
+        if (state.quote !== undefined && !hasEscapedLineEnding(line))
+            state.quote = undefined;
+        state.inCodeLineContinuation =
+            !state.inLineCommentContinuation && !state.inBlockComment && hasEscapedLineEnding(line);
+        return;
+    }
+    const keyword = leadingObjCDeclKeyword(line, state.inBlockComment);
+    if (keyword === 'begin')
+        state.objcDeclDepth++;
+    else if (keyword === 'end')
+        state.objcDeclDepth = Math.max(0, state.objcDeclDepth - 1);
+    scanLineBody(line, state, 0, true);
+    if (state.quote !== undefined && !hasEscapedLineEnding(line))
+        state.quote = undefined;
+    // Line-comment `\` continuation is not a C splice; it must not suppress
+    // the next physical line's file-scope marker test.
+    state.inCodeLineContinuation =
+        !state.inLineCommentContinuation && !state.inBlockComment && hasEscapedLineEnding(line);
+}
+/**
+ * Elide bare, file-scope macro markers while preserving source positions.
+ *
+ * `_filePath` is accepted for the LanguageProvider hook signature. The
+ * transform is based only on source syntax and deliberately has no framework
+ * or repository-specific configuration.
+ */
+export function preprocessObjectiveCMacroMarkers(source, _filePath) {
+    const state = {
+        inBlockComment: false,
+        inLineCommentContinuation: false,
+        inCodeLineContinuation: false,
+        inPreprocessorDirective: false,
+        quote: undefined,
+        braceDepth: 0,
+        parenDepth: 0,
+        objcDeclDepth: 0,
+    };
+    const segments = source.split(/(\r\n|\n|\r)/);
+    let changed = false;
+    for (let index = 0; index < segments.length; index += 2) {
+        const line = segments[index];
+        if (!state.inBlockComment &&
+            !state.inLineCommentContinuation &&
+            !state.inCodeLineContinuation &&
+            !state.inPreprocessorDirective &&
+            state.quote === undefined &&
+            state.braceDepth === 0 &&
+            state.parenDepth === 0 &&
+            state.objcDeclDepth === 0 &&
+            isBareMarkerIdentifier(line)) {
+            segments[index] = ' '.repeat(line.length);
+            changed = true;
+            continue;
+        }
+        scanLine(line, state);
+    }
+    return changed ? segments.join('') : source;
+}

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

@@ -0,0 +1,41 @@
+/**
+ * Per-workspace Objective-C import config — the analog of TypeScript's
+ * tsconfig, C#'s csproj scan, and C/C++'s header scan.
+ *
+ * Loaded once per analyze pass via `objectiveCScopeResolver.loadResolutionConfig`
+ * and threaded into `resolveObjectiveCImportTarget`. `.h` files are usually
+ * classified as C++ unless they contain Objective-C syntax, so the ObjC
+ * resolver's `allFilePaths` can miss headers that `#import` / `#include`
+ * still name. This scan is what makes those paths visible.
+ */
+export interface ObjectiveCResolutionConfig {
+    /** Repo-relative `.h` paths discovered on disk (C/C++ header-scan analog). */
+    readonly headers: ReadonlySet<string>;
+    /**
+     * xcconfig `HEADER_SEARCH_PATHS`. Used for both quoted and angle-bracket
+     * imports — clang's system/project include path.
+     */
+    readonly headerSearchPaths: readonly string[];
+    /**
+     * xcconfig `USER_HEADER_SEARCH_PATHS` plus in-repo `Headers` / `include`
+     * roots. Quoted `#import "…"` only. Angle-bracket imports must not use
+     * these, or `<Foundation/Foundation.h>` would bind a local decoy.
+     */
+    readonly userHeaderSearchPaths: readonly string[];
+    /** Framework name → repo-relative `*.framework/Headers` directory. */
+    readonly frameworks: ReadonlyMap<string, string>;
+    /** `@import` module name → umbrella / first header path. */
+    readonly modules: ReadonlyMap<string, string>;
+}
+export declare function emptyObjectiveCResolutionConfig(): ObjectiveCResolutionConfig;
+export declare function coerceObjectiveCResolutionConfig(value: unknown): ObjectiveCResolutionConfig | undefined;
+export declare function loadObjectiveCResolutionConfig(repoPath: string): ObjectiveCResolutionConfig;
+export declare function scanObjectiveCWorkspace(repoPath: string): ObjectiveCResolutionConfig;
+export declare function parseXcconfigSearchPaths(source: string): {
+    readonly headerSearchPaths: string[];
+    readonly userHeaderSearchPaths: string[];
+};
+export declare function parseModuleMap(source: string, mapDir: string): ReadonlyArray<readonly [string, string]>;
+export declare function normalizeRepoPath(value: string): string;
+/** Collapse `.` / `..` in scanned config paths. Import targets stay raw. */
+export declare function collapseRepoPath(value: string): string;