gitnexus 1.6.10-rc.21 → 1.6.10-rc.211

package/dist/core/ingestion/languages/swift/conditional-directive-preprocess.js

@@ -0,0 +1,253 @@
+/**
+ * A conditional-compilation directive occupying a whole line.
+ *
+ * `[^\S\r\n]` (horizontal whitespace) rather than `[ \t]` so NBSP /
+ * ideographic-space indentation and a leading BOM are recognized too. Leading
+ * whitespace is *not* required: nesting is decided from the scanner's brace
+ * depth, not from indentation (a column-0 `#if` inside a class body is exactly
+ * the shape that loses its enclosing declaration).
+ */
+const SWIFT_CONDITIONAL_DIRECTIVE_RE = /^[^\S\r\n]*#(if|elseif|else|endif)\b[^\r\n]*$/;
+/**
+ * Cheap whole-file precondition, mirroring `stripUeMacros`'s `HAS_UE_HINT`.
+ * Derived from the line pattern so the two can never drift apart.
+ */
+const HAS_CONDITIONAL_DIRECTIVE_HINT = new RegExp(SWIFT_CONDITIONAL_DIRECTIVE_RE.source, 'm');
+function hasTripleQuoteAt(line, index) {
+    return line.startsWith('"""', index);
+}
+/**
+ * Length of the multiline terminator at `index`, or 0.
+ *
+ * A plain `"""` string always closes at `"""`, whatever follows it — an
+ * adjacent `#` is the next token, not part of the delimiter. A raw `#"""`
+ * string closes at `"""` followed by *at least* its own pound count.
+ */
+function matchingMultilineCloseLength(line, index, poundCount) {
+    if (!hasTripleQuoteAt(line, index))
+        return 0;
+    if (poundCount === 0)
+        return 3;
+    return line.startsWith('#'.repeat(poundCount), index + 3) ? 3 + poundCount : 0;
+}
+function skipRegularString(line, startIndex, rawPoundCount) {
+    const endPounds = '#'.repeat(rawPoundCount);
+    let index = startIndex + (rawPoundCount > 0 ? rawPoundCount + 1 : 1);
+    while (index < line.length) {
+        if (line[index] === '"') {
+            if (rawPoundCount === 0)
+                return index + 1;
+            if (line.startsWith(endPounds, index + 1))
+                return index + 1 + rawPoundCount;
+        }
+        if (rawPoundCount === 0 && line[index] === '\\')
+            index++;
+        index++;
+    }
+    return line.length;
+}
+/**
+ * Skip an extended regex literal (`#/…/#`), whose body may legally contain
+ * `/*` — which would otherwise open a block comment that never closes.
+ * `slashIndex` points at the `/` that follows the opening pound run.
+ */
+function skipExtendedRegexLiteral(line, slashIndex, poundCount) {
+    const closePounds = '#'.repeat(poundCount);
+    let index = slashIndex + 1;
+    while (index < line.length) {
+        if (line[index] === '\\') {
+            index += 2;
+            continue;
+        }
+        if (line[index] === '/' && line.startsWith(closePounds, index + 1)) {
+            return index + 1 + poundCount;
+        }
+        index++;
+    }
+    return line.length;
+}
+function scanSwiftLine(line, state) {
+    let index = 0;
+    while (index < line.length) {
+        if (state.blockCommentDepth > 0) {
+            if (line.startsWith('/*', index)) {
+                state.blockCommentDepth++;
+                index += 2;
+            }
+            else if (line.startsWith('*/', index)) {
+                state.blockCommentDepth--;
+                index += 2;
+            }
+            else {
+                index++;
+            }
+            continue;
+        }
+        if (state.multilineStringPounds !== null) {
+            const closeLength = matchingMultilineCloseLength(line, index, state.multilineStringPounds);
+            if (closeLength > 0) {
+                state.multilineStringPounds = null;
+                index += closeLength;
+                continue;
+            }
+            // Non-raw multiline strings honour backslash escapes, so `\"""` is string
+            // data and not a terminator. Raw strings escape with `\#`, so a bare
+            // backslash there is literal.
+            index += state.multilineStringPounds === 0 && line[index] === '\\' ? 2 : 1;
+            continue;
+        }
+        if (line.startsWith('//', index))
+            return;
+        if (line.startsWith('/*', index)) {
+            state.blockCommentDepth = 1;
+            index += 2;
+            continue;
+        }
+        if (line[index] === '#') {
+            // Count the pound run exactly once and always advance past it, so a long
+            // run of bare `#` stays linear instead of being re-walked per character.
+            let poundCount = 1;
+            while (line[index + poundCount] === '#')
+                poundCount++;
+            const afterPounds = index + poundCount;
+            if (hasTripleQuoteAt(line, afterPounds)) {
+                state.multilineStringPounds = poundCount;
+                index = afterPounds + 3;
+            }
+            else if (line[afterPounds] === '"') {
+                index = skipRegularString(line, index, poundCount);
+            }
+            else if (line[afterPounds] === '/') {
+                index = skipExtendedRegexLiteral(line, afterPounds, poundCount);
+            }
+            else {
+                index = afterPounds;
+            }
+            continue;
+        }
+        if (hasTripleQuoteAt(line, index)) {
+            state.multilineStringPounds = 0;
+            index += 3;
+            continue;
+        }
+        if (line[index] === '"') {
+            index = skipRegularString(line, index, 0);
+            continue;
+        }
+        if (line[index] === '{')
+            state.braceDepth++;
+        else if (line[index] === '}')
+            state.braceDepth--;
+        index++;
+    }
+}
+/**
+ * Blank nested Swift conditional-compilation directives before parsing.
+ *
+ * tree-sitter-swift 0.7.1 does not admit `directive` as a `class_body` child
+ * (`vendor/tree-sitter-swift/src/node-types.json`), so error recovery can
+ * discard the enclosing declaration. Replacing only the directive text with
+ * spaces preserves `.length`, line endings, and every declaration offset.
+ *
+ * ponytail: delete this file (and the `preprocessSource` wiring in `swift.ts`)
+ * once a vendored tree-sitter-swift release includes upstream PR #583 ("Allow
+ * #if/#elseif/#else/#endif directives inside type bodies"); see also upstream
+ * issue #298 and PR #599. `.github/vendored-grammars.json` has no `"hold"` on
+ * swift, so the bump bot will land that release on its own.
+ *
+ * A directive group is blanked only when **all** of these hold:
+ *
+ *   - it opens at `braceDepth > 0` — nesting, not indentation, is what the
+ *     grammar rejects; top-level directives are valid source-file members and
+ *     are left intact
+ *   - it is not inside a multiline string literal or a block comment — blanking
+ *     a line that carries a block-comment terminator would un-terminate the
+ *     comment and swallow the rest of the file, and blanking inside a literal
+ *     would rewrite program data
+ *   - every branch is brace-balanced. A group that splits a declaration header
+ *     (`#if` … `func f() async {` … `#else` … `func f() {` … `#endif`) leaves
+ *     one unmatched `{` once both branches survive, which re-parents every
+ *     later top-level declaration. Such a group degrades to the pre-fix
+ *     behavior instead.
+ *
+ * Known residuals, all of which degrade to "directive left in place" rather
+ * than to corrupted output: string interpolation is not parsed with full Swift
+ * expression fidelity, so a nested multiline string inside an interpolation can
+ * confuse the scanner; a bare `/…/` regex literal containing `/*` opens a
+ * phantom block comment; and a multiline extended regex literal is treated as
+ * ending at its first line.
+ *
+ * Byte length is *not* preserved when a blanked directive line carries
+ * non-ASCII trailing text (`  #if os(iOS) // 日本語 🔥` is 23 UTF-16 code units
+ * either way, but shrinks from 31 UTF-8 bytes to 23). C++ sidesteps this
+ * because UE macro tokens are ASCII-only; a Swift directive line can carry any
+ * trailing comment. Per the `LanguageProvider.preprocessSource` contract this is
+ * safe only while no consumer slices the original UTF-8 bytes by `startIndex`:
+ * node-tree-sitter reports UTF-16 code-unit indices, and every in-process
+ * consumer slices the JS string, whose `.length` *is* preserved.
+ *
+ * Must stay pure and idempotent — see `LanguageProvider.preprocessSource`.
+ */
+export function preprocessSwiftConditionalDirectives(sourceText) {
+    if (!HAS_CONDITIONAL_DIRECTIVE_HINT.test(sourceText))
+        return sourceText;
+    // Alternating [line, terminator, line, terminator, …, line]; joining it back
+    // reproduces the input byte for byte, including bare-`\r` endings.
+    const parts = sourceText.split(/(\r\n|\n|\r)/);
+    const state = {
+        blockCommentDepth: 0,
+        multilineStringPounds: null,
+        braceDepth: 0,
+    };
+    const openGroups = [];
+    let blankedAny = false;
+    for (let index = 0; index < parts.length; index += 2) {
+        const text = parts[index];
+        const insideLiteralOrComment = state.multilineStringPounds !== null || state.blockCommentDepth > 0;
+        const match = insideLiteralOrComment ? null : SWIFT_CONDITIONAL_DIRECTIVE_RE.exec(text);
+        const braceDepthAtStart = state.braceDepth;
+        scanSwiftLine(text, state);
+        const braceDelta = state.braceDepth - braceDepthAtStart;
+        const openGroup = openGroups[openGroups.length - 1];
+        if (match === null) {
+            if (openGroup !== undefined)
+                openGroup.currentBranchDelta += braceDelta;
+            continue;
+        }
+        // Directive lines are blanked as a unit, so their own braces (if any) never
+        // reach the parser and must not count toward a branch's balance.
+        if (match[1] === 'if') {
+            openGroups.push({
+                braceDepthAtStart,
+                directiveLines: [index],
+                totalDelta: 0,
+                allBranchesBalanced: true,
+                currentBranchDelta: 0,
+            });
+            continue;
+        }
+        // A `#else`/`#endif` with no open `#if` is malformed source — leave it be.
+        if (openGroup === undefined)
+            continue;
+        openGroup.directiveLines.push(index);
+        openGroup.totalDelta += openGroup.currentBranchDelta;
+        openGroup.allBranchesBalanced &&= openGroup.currentBranchDelta === 0;
+        openGroup.currentBranchDelta = 0;
+        if (match[1] !== 'endif')
+            continue;
+        openGroups.pop();
+        const parentGroup = openGroups[openGroups.length - 1];
+        // Every branch survives preprocessing, so the enclosing branch sees the sum
+        // — not one branch's delta.
+        if (parentGroup !== undefined)
+            parentGroup.currentBranchDelta += openGroup.totalDelta;
+        if (openGroup.braceDepthAtStart > 0 && openGroup.allBranchesBalanced) {
+            // Safe to mutate in place: every line of this group has already been
+            // scanned, and the decision never reopens.
+            for (const line of openGroup.directiveLines)
+                parts[line] = ' '.repeat(parts[line].length);
+            blankedAny = true;
+        }
+    }
+    return blankedAny ? parts.join('') : sourceText;
+}

package/dist/core/ingestion/languages/swift/import-target.js

@@ -23,11 +23,8 @@
  * in a run), so it is built once per run — NOT once per import. Mirrors
  * Python's `getPythonFileIndex` WeakMap pattern (PR #1918).
  */
-const SWIFT_MODULE_INDEX_CACHE = new WeakMap();
-function getSwiftModuleIndex(allFilePaths) {
-    const cached = SWIFT_MODULE_INDEX_CACHE.get(allFilePaths);
-    if (cached !== undefined)
-        return cached;
+import { perFileSet } from '../../import-resolvers/per-file-set.js';
+const getSwiftModuleIndex = perFileSet((allFilePaths) => {
     const byModule = new Map();
     for (const raw of allFilePaths) {
         const norm = raw.replace(/\\/g, '/');
@@ -50,10 +47,8 @@ function getSwiftModuleIndex(allFilePaths) {
             bucket.push(raw);
         }
     }
-    const index = { byModule };
-    SWIFT_MODULE_INDEX_CACHE.set(allFilePaths, index);
-    return index;
-}
+    return { byModule };
+});
 export function resolveSwiftImportTarget(parsedImport, workspaceIndex) {
     const ctx = workspaceIndex;
     // Duck-type the set (PR #1918 P2: don't `instanceof Set`).

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

@@ -105,6 +105,23 @@ const SWIFT_SCOPE_QUERY = `
   (type_annotation
     (user_type (type_identifier) @type-binding.type))) @type-binding.annotation
 
+;; Optional property annotations: \`var owner: Owner?\` (#2807). The pattern
+;; above requires the \`user_type\` to be a DIRECT child of the annotation;
+;; an optional inserts an \`optional_type\` level between them, so an optional
+;; field was never typed at all and \`self.owner!.method()\` could not resolve
+;; its receiver. Declaring a field optional and assigning it later is the
+;; idiomatic Swift way to express a field that has no value at init time, so
+;; this is the common shape, not an edge case.
+;;
+;; The INNER \`type_identifier\` is captured, so the binding is \`Owner\` with no
+;; reliance on \`stripOptional\` reducing a \`Owner?\` spelling.
+(property_declaration
+  name: (pattern
+    bound_identifier: (simple_identifier) @type-binding.name)
+  (type_annotation
+    (optional_type
+      (user_type (type_identifier) @type-binding.type)))) @type-binding.annotation
+
 ;; ── Type bindings — stored / local-var constructor inference:
 ;; \`let p = Product(...)\` (constructor) and \`let u = getUser()\`
 ;; (free-call result; chain-follow resolves getUser → its return type).

package/dist/core/ingestion/languages/swift/receiver-binding.d.ts

@@ -25,6 +25,14 @@
  */
 import type { CaptureMatch } from '../../../../_shared/index.js';
 import { type SyntaxNode } from '../../utils/ast-helpers.js';
+/** Walk up to the enclosing type declaration (class/struct/extension/
+ *  protocol). Nested local functions still see `self` from the enclosing
+ *  type, so don't stop at function-like nodes.
+ *
+ *  Exported so `swiftEnclosingTypeName` (captures.ts) asks the same question
+ *  the same way — the two must agree on what "the enclosing type" is or a
+ *  method's owner qualifier and its `self` binding name different types. */
+export declare function findEnclosingTypeDeclaration(node: SyntaxNode): SyntaxNode | null;
 /**
  * Build zero, one, or two `@type-binding.self` matches for `fnNode`:
  *  - `null`/`[]` if the function is free (no enclosing type), static, or

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

@@ -34,8 +34,12 @@ const FUNCTION_NODE_TYPES = new Set([
 ]);
 /** Walk up to the enclosing type declaration (class/struct/extension/
  *  protocol). Nested local functions still see `self` from the enclosing
- *  type, so don't stop at function-like nodes. */
-function findEnclosingTypeDeclaration(node) {
+ *  type, so don't stop at function-like nodes.
+ *
+ *  Exported so `swiftEnclosingTypeName` (captures.ts) asks the same question
+ *  the same way — the two must agree on what "the enclosing type" is or a
+ *  method's owner qualifier and its `self` binding name different types. */
+export function findEnclosingTypeDeclaration(node) {
     let cur = node.parent;
     while (cur !== null) {
         if (TYPE_DECL_NODE_TYPES.has(cur.type))

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

@@ -24,6 +24,7 @@ import { createCallExtractor } from '../call-extractors/generic.js';
 import { swiftCallConfig } from '../call-extractors/configs/swift.js';
 import { createSwiftCfgVisitor } from '../cfg/visitors/swift.js';
 import { emitSwiftScopeCaptures, interpretSwiftImport, interpretSwiftTypeBinding, swiftBindingScopeFor, swiftImportOwningScope, swiftReceiverBinding, swiftMergeBindings, swiftArityCompatibility, } from './swift/index.js';
+import { preprocessSwiftConditionalDirectives } from './swift/conditional-directive-preprocess.js';
 /** Swift init/deinit declarations have special names and Constructor label. */
 const swiftExtractFunctionName = (node) => {
     if (node.type === 'init_declaration')
@@ -157,6 +158,7 @@ const BUILT_INS = new Set([
 export const swiftProvider = defineLanguage({
     id: SupportedLanguages.Swift,
     extensions: ['.swift'],
+    preprocessSource: preprocessSwiftConditionalDirectives,
     entryPointPatterns: [
         /^viewDidLoad$/,
         /^viewWillAppear$/,

package/dist/core/ingestion/languages/typescript/captures.d.ts

@@ -6,7 +6,7 @@
  * synthesized streams on top:
  *
  *   1. **Import decomposition** — each `import_statement` / re-export is
- *      re-emitted with `@import.kind/source/name/alias/typeOnly` markers so
+ *      re-emitted with `@import.kind/source/name/alias/type-only` markers so
  *      `interpretTsImport` can recover the `ParsedImport` shape without
  *      re-parsing raw text (see `import-decomposer.ts`). Unit 2 adds this;
  *      until then, raw `@import.statement` matches flow through as-is.
@@ -25,4 +25,93 @@
  * Pure given the input source text. No I/O, no globals consulted.
  */
 import type { CaptureMatch } from '../../../../_shared/index.js';
+import { type SyntaxNode } from '../../utils/ast-helpers.js';
+/** tree-sitter-typescript node types for function-like scopes that may
+ *  carry a synthesized `this` binding. Kept in sync with the
+ *  `@scope.function` patterns in `query.ts`. */
+export declare const FUNCTION_NODE_TYPES: readonly ["method_definition", "method_signature", "abstract_method_signature", "arrow_function", "function_expression", "function_declaration", "generator_function_declaration", "generator_function", "function_signature"];
+/** The class-field declaration node a field `@type-binding.*` match anchors on
+ *  in TypeScript/TSX. JavaScript spells the same construct `field_definition`
+ *  and passes its own set in — the predicate below is shared because both
+ *  grammars carry `static` identically, but each language must NAME its own
+ *  node type. Listing both here made `field_definition` a dead literal in the
+ *  typescript grammar, which `grammar-literal-validation` fails on: the gate
+ *  checks every literal against the grammar of the FILE it appears in, and a
+ *  node type that is dead there is exactly how a guard silently stops firing. */
+export declare const TS_CLASS_FIELD_DEFINITION_TYPES: ReadonlySet<string>;
+/**
+ * Is this type-binding anchored on a **`static`** class field?
+ *
+ * A static member belongs to the CLASS OBJECT; an instance field belongs to
+ * instances. JavaScript and TypeScript keep the two in separate namespaces, so
+ * one class may legally declare both under one name:
+ *
+ *     class Host {
+ *       p = new Right();
+ *       static p = new Wrong();      // legal — a different member
+ *       hit() { return this.p.hit(); }   // `this.p` is Right
+ *     }
+ *
+ * Both field patterns anchor their binding on the same CLASS scope with the
+ * same `constructor-inferred` source, and `scope-extractor` breaks a
+ * same-strength tie with `>=` — last match wins. So the static field silently
+ * RETYPED the instance field of that name and `this.p.hit()` resolved to
+ * `Wrong.hit`: not a missing edge but a wrong one, the failure mode
+ * `scope-resolution/passes/compound-receiver.ts` exists to avoid. The scope
+ * tree has one `typeBindings` map per scope with no static/instance split, so a
+ * static field cannot be recorded separately — it is dropped instead.
+ *
+ * WHAT THAT COSTS, MEASURED rather than assumed (#2807 review, S7). An earlier
+ * version of this comment called the cost "a missed edge beats a wrong one".
+ * Only half of that is true, and the false half is the one that matters:
+ *
+ *   shape                       with the drop     without it
+ *   --------------------------  ----------------  ----------------
+ *   `this.p` (instance twin)    Right  ✓          Wrong  ✗
+ *   `Host.p` (static twin)      Right  ✗ WRONG    Wrong  ✓
+ *   `Host.q` (static, no twin)  — none, missed    Wrong  ✓
+ *
+ * For a class declaring BOTH twins the wrong edge does not disappear, it MOVES:
+ * `Host.p` now reads the INSTANCE twin's binding, because that is what is left
+ * in the map under that name. Only the no-twin case — the common static shape —
+ * is a true missed edge.
+ *
+ * The trade is still the right one, since `this.p` is overwhelmingly the more
+ * common access and a `Host.p` static chain is the cheaper place to be wrong.
+ * It is recorded here as a wrong edge rather than described as a missing one so
+ * that the next person weighing it is weighing the real thing. Closing it
+ * properly needs a static/instance split that the shared receiver fold cannot
+ * express today — `foldReceiverChain` in
+ * `scope-resolution/passes/compound-receiver.ts` explicitly discards whether a
+ * chain's base was a class reference or a value — so it is a separate change
+ * with a `SCHEMA_BUMP`, not a tweak here. Both shapes are pinned by rows in
+ * `test/integration/resolvers/inferred-field-receiver-matrix.test.ts`
+ * (`static-read-of-a-same-name-twin-picks-up-the-instance-type`,
+ * `static-read-without-a-twin-loses-its-type`), so the cost moves visibly.
+ *
+ * Sibling of {@link isStaticMethodThis}, which drops the ASSIGNMENT form
+ * (`this.x = new Y()` inside a static method). Together they cover both ways a
+ * static member can reach the field-typing path. This is an emit-side filter
+ * for the same reason that one is: `static` is an ANONYMOUS token on the
+ * declaration node, and a tree-sitter pattern cannot negate one.
+ *
+ * Detection is the shared `hasKeyword` — matching on child TEXT, never
+ * `child.type === 'static'`, because the token reaches the tree as an anonymous
+ * token in some grammar versions and a keyword node in others (see
+ * `isStaticMember` in `receiver-binding.ts`); a node-type test silently stops
+ * firing on a grammar bump and every static field starts retyping its instance
+ * twin again. Verified against both grammars in use here: `static` is an
+ * anonymous direct child of the caller's field-definition node —
+ * `public_field_definition` in TypeScript, `field_definition` in JavaScript —
+ * ahead of the name. Each language passes its OWN node-type set rather than the
+ * predicate holding both: a literal is only valid in the grammar of the file it
+ * appears in, and `grammar-literal-validation` fails a dead one.
+ *
+ * One deliberate over-fire: `hasKeyword` skips the node's `name` FIELD, and the
+ * JavaScript grammar names a field's name `property:`, not `name:` — so the
+ * legal-but-rare JavaScript field literally called `static`
+ * (`class C { static = new Right(); }`) reads as static and goes untyped. That
+ * is a declined binding, the safe direction of the same trade.
+ */
+export declare function isStaticClassFieldBinding(anchorNode: SyntaxNode | undefined, fieldDefinitionTypes: ReadonlySet<string>): boolean;
 export declare function emitTsScopeCaptures(sourceText: string, filePath: string, cachedTree?: unknown): readonly CaptureMatch[];