gitnexus 1.6.10-rc.98 → 1.6.10

package/dist/core/ingestion/resolve-references.d.ts

@@ -49,7 +49,12 @@ export interface ResolveReferencesInput {
 export interface ResolveStats {
     readonly sitesProcessed: number;
     readonly referencesEmitted: number;
-    /** Sites where `Registry.lookup` returned no candidates. */
+    /**
+     * Sites that produced no `Reference`. Almost always "the registry returned no
+     * candidates", but it also counts a site declined before lookup because the
+     * name is bound as a type parameter here (#2899) — a shadowed annotation names
+     * no symbol in the graph, so "resolved to nothing" is the honest bucket for it.
+     */
     readonly unresolved: number;
 }
 export interface ResolveReferencesOutput {

package/dist/core/ingestion/resolve-references.js

@@ -38,6 +38,7 @@
  *     branch-on-ambiguity behavior should consume the registries directly.
  */
 import { buildClassRegistry, buildFieldRegistry, buildMacroRegistry, buildMethodRegistry, CLASS_KINDS, FIELD_KINDS, METHOD_KINDS, } from '../../_shared/index.js';
+import { bindsTypeParameter } from './scope-resolution/scope/walkers.js';
 /**
  * Resolve every `ReferenceSite` in `scopes.referenceSites` against the
  * matching registry and produce a `ReferenceIndex` keyed by source scope
@@ -73,7 +74,7 @@ export function resolveReferenceSites(input) {
         if (site.kind === 'value-ref')
             continue;
         sitesProcessed++;
-        const resolutions = lookupForSite(site, classRegistry, methodRegistry, fieldRegistry, macroRegistry);
+        const resolutions = lookupForSite(site, classRegistry, methodRegistry, fieldRegistry, macroRegistry, scopes);
         if (resolutions.length === 0) {
             unresolved++;
             continue;
@@ -116,7 +117,7 @@ export function resolveReferenceSites(input) {
  *   |------------------|-------------------|------------------------------|
  *   | `call`           | MethodRegistry    | METHOD_KINDS (Method/Func/Ctor)
  *   | `inherits`       | ClassRegistry     | CLASS_KINDS                  |
- *   | `type-reference` | ClassRegistry     | CLASS_KINDS                  |
+ *   | `type-reference` | ClassRegistry     | CLASS_KINDS (type-parameter shadow guard, #2899) |
  *   | `read`/`write`   | FieldRegistry     | FIELD_KINDS                  |
  *   | `import-use`     | tiered fallback   | METHOD ∪ CLASS ∪ FIELD       |
  *   | `value-ref`      | (skipped here)    | post-finalize walker in `emitPropertyDispatchCalls` |
@@ -133,7 +134,7 @@ export function resolveReferenceSites(input) {
  * scope's `bindings` (Step 1 lexical hit), so the lookup is correct
  * regardless of which registry surfaces the def.
  */
-function lookupForSite(site, classRegistry, methodRegistry, fieldRegistry, macroRegistry) {
+function lookupForSite(site, classRegistry, methodRegistry, fieldRegistry, macroRegistry, scopes) {
     switch (site.kind) {
         case 'call': {
             const opts = {
@@ -142,8 +143,50 @@ function lookupForSite(site, classRegistry, methodRegistry, fieldRegistry, macro
             };
             return methodRegistry.lookup(site.name, site.inScope, opts);
         }
-        case 'inherits':
+        case 'inherits': {
+            return classRegistry.lookup(site.name, site.inScope);
+        }
         case 'type-reference': {
+            // A TYPE PARAMETER SHADOWS A DECLARED TYPE OF THE SAME NAME (#2899).
+            //
+            // `export function unwrap<Result>(value: Result): Result` names the
+            // parameter, not the `interface Result` next to it — tsc resolves BOTH
+            // annotations to the parameter. Nothing in the type-reference path knew
+            // that a parameter binds a name, so each annotation minted a `USES` edge
+            // into the interface at the same confidence as a real consumer and
+            // indistinguishable from one. Blast radius is every generic whose
+            // parameter name collides with a declared type — `Result`, `Key`,
+            // `Value`, `Item`, `Node`, `Options`, `Config`, `Props`, `State`.
+            //
+            // ASKED HERE, ON `site.name`, BECAUSE SHADOWING IS A PROPERTY OF THE NAME
+            // WRITTEN AT THE SITE. This is the last point that still holds the
+            // spelling — a `Reference` keeps only the resolved def — so a guard placed
+            // after resolution has to substitute the DEF's name for the written one
+            // and is then wrong in BOTH directions from the same substitution. It
+            // deletes a genuine edge wherever the two differ and the def's name
+            // happens to match a parameter (`import { Payload as ApiPayload }` written
+            // inside `pluck<Payload>`), and it keeps a false one wherever the def's
+            // name is qualified or position-suffixed and the written name is the
+            // parameter (`Inner` resolving to `Host.Inner`, or a function-local
+            // `Result@12:4`). Neither failure is recoverable from the resolved id,
+            // because the information the question needs was never in it.
+            //
+            // TYPE REFERENCES ONLY, which is what asking on `kind` rather than on the
+            // emitted EDGE TYPE buys. `mapReferenceKindToEdgeType` folds `value-ref`
+            // (#2437) and `macro` (#1934) into the same `USES` edge, and neither is a
+            // type annotation — a value or a macro whose name collides with an
+            // enclosing type parameter is a different construct in a different
+            // namespace, and dropping it would be a second false-negative class
+            // bought with the fix for the first.
+            //
+            // Reuses the predicate #2833 introduced for the CALL-receiver path, which
+            // stopped a workspace `class T` answering for `<T>` but never reached type
+            // references. Absence is not evidence there and is not here:
+            // `typeParameters` is populated only by languages whose captures were
+            // extended for it, so a POSITIVE match declines and an absent list changes
+            // nothing — which is what keeps every unconverted language unchanged.
+            if (bindsTypeParameter(site.inScope, site.name, scopes))
+                return [];
             return classRegistry.lookup(site.name, site.inScope);
         }
         case 'read':
@@ -154,8 +197,25 @@ function lookupForSite(site, classRegistry, methodRegistry, fieldRegistry, macro
                 ...(site.explicitReceiver !== undefined ? { explicitReceiver: site.explicitReceiver } : {}),
             };
             const fieldHits = fieldRegistry.lookup(site.name, site.inScope, fieldOpts);
-            if (fieldHits.length > 0)
-                return fieldHits;
+            // A BARE IDENTIFIER is not a member access. With no receiver there is no
+            // object whose `Property` this could be, so a hit on one is a false edge:
+            // in JS/TS/Python/Ruby a field read needs `this.` / `self.` / `@`, and the
+            // bare name means the nearest lexical binding instead.
+            //
+            // Observed: `class Box { baseUrl = '...'; pick() { const baseUrl = ...;
+            // return baseUrl; } }` linked the block-local read to `Box.baseUrl`,
+            // duplicating the legitimate `this.baseUrl` edge. That predates the
+            // TypeScript captures added here — JavaScript has emitted bare-identifier
+            // reads since A2 and no class fixture exercised the shadow.
+            //
+            // Callables are deliberately still reachable: `cb = save` naming a
+            // top-level function is a real bare-name reference, which is why the
+            // method/class fallbacks below are untouched.
+            const receiverlessFieldHits = site.explicitReceiver === undefined
+                ? fieldHits.filter((hit) => hit.def?.type !== 'Property')
+                : fieldHits;
+            if (receiverlessFieldHits.length > 0)
+                return receiverlessFieldHits;
             const methodHits = methodRegistry.lookup(site.name, site.inScope);
             if (methodHits.length > 0)
                 return methodHits;

package/dist/core/ingestion/route-extractors/constant-resolver.d.ts

@@ -23,6 +23,12 @@
  * (intra-procedural, function-local, def→use reachability — not module-level
  * cross-file value folding).
  */
+/** Max length of a folded path. Real route paths are well under this; a fold that
+ * exceeds it is a pathological self-multiplying concat (`X = A + A; A = B + B; …`)
+ * whose true value is genuinely huge — building it risks a `RangeError`/heap OOM,
+ * so we floor to `null` (skip) instead (#2393). The depth cap bounds recursion but
+ * NOT output size, which grows multiplicatively; this bounds the output. */
+export declare const MAX_FOLD_LENGTH = 8192;
 /**
  * One term of a constant's right-hand side. A `+`-concatenation
  * (`A + "/b" + C`) becomes an ordered `Operand[]`; a bare literal is a
@@ -74,10 +80,10 @@ export type ImportResolver = (importingFileKey: string, moduleSpec: string, repo
  * value, folding `+` concatenation and following import chains via
  * `resolveImport`, or `null` when it cannot be fully folded.
  */
-export declare function resolveConstant(fileKey: string, name: string, repo: RepoConstants, resolveImport: ImportResolver): string | null;
+export declare function resolveConstant(fileKey: string, name: string, repo: RepoConstants, resolveImport: ImportResolver, repoKeys?: ReadonlySet<string>): string | null;
 /**
  * Resolve an inline operand list (an unnamed `+`-expression captured directly at
  * a decorator/annotation argument, e.g. `@router.get(API_V1 + "/widgets")`)
  * against `fileKey`.
  */
-export declare function resolveOperands(fileKey: string, operands: readonly Operand[], repo: RepoConstants, resolveImport: ImportResolver): string | null;
+export declare function resolveOperands(fileKey: string, operands: readonly Operand[], repo: RepoConstants, resolveImport: ImportResolver, repoKeys?: ReadonlySet<string>): string | null;

package/dist/core/ingestion/route-extractors/constant-resolver.js

@@ -31,7 +31,7 @@ const MAX_RESOLVE_DEPTH = 8;
  * whose true value is genuinely huge — building it risks a `RangeError`/heap OOM,
  * so we floor to `null` (skip) instead (#2393). The depth cap bounds recursion but
  * NOT output size, which grows multiplicatively; this bounds the output. */
-const MAX_FOLD_LENGTH = 8192;
+export const MAX_FOLD_LENGTH = 8192;
 /**
  * Fold an operand list to its concatenated literal, or `null` if any operand is
  * unresolvable (an unknown name, a non-string term, a cycle, or a depth overrun).
@@ -104,10 +104,14 @@ function computeFold(fileKey, name, state, depth) {
     }
     return null;
 }
-function newState(repo, resolveImport) {
+function newState(repo, resolveImport, repoKeys) {
     return {
         repo,
-        repoKeys: new Set(repo.keys()),
+        // Materializing the key set here is O(files), and this runs once per fold —
+        // which is once per import hop, not once per scan. A binding that already
+        // holds the set (every one of them does; it is a projection of the same map
+        // it builds `repo` from) passes it in and skips the copy entirely.
+        repoKeys: repoKeys ?? new Set(repo.keys()),
         resolveImport,
         visited: new Set(),
         memo: new Map(),
@@ -118,14 +122,14 @@ function newState(repo, resolveImport) {
  * value, folding `+` concatenation and following import chains via
  * `resolveImport`, or `null` when it cannot be fully folded.
  */
-export function resolveConstant(fileKey, name, repo, resolveImport) {
-    return foldName(fileKey, name, newState(repo, resolveImport), 0);
+export function resolveConstant(fileKey, name, repo, resolveImport, repoKeys) {
+    return foldName(fileKey, name, newState(repo, resolveImport, repoKeys), 0);
 }
 /**
  * Resolve an inline operand list (an unnamed `+`-expression captured directly at
  * a decorator/annotation argument, e.g. `@router.get(API_V1 + "/widgets")`)
  * against `fileKey`.
  */
-export function resolveOperands(fileKey, operands, repo, resolveImport) {
-    return foldExpr(fileKey, operands, newState(repo, resolveImport), 0);
+export function resolveOperands(fileKey, operands, repo, resolveImport, repoKeys) {
+    return foldExpr(fileKey, operands, newState(repo, resolveImport, repoKeys), 0);
 }

package/dist/core/ingestion/route-extractors/data-route-table.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Conservative extraction for explicit JavaScript-style route tables.
+ *
+ * A generic object containing `path`, `method`, and `handler` can also be an
+ * HTTP client request descriptor. Extraction therefore requires both a
+ * route-named binding and a static `for (... of table)` dispatch loop whose
+ * request guard compares the entry's path and method before directly invoking
+ * its handler.
+ */
+import type Parser from 'tree-sitter';
+import type { SyntaxNode } from 'tree-sitter';
+import type { ExtractedDecoratorRoute } from '../workers/parse-worker.js';
+export declare const DATA_ROUTE_TABLE_SOURCE = "data-route-table";
+export interface DataRouteTableRoute {
+    path: string;
+    method: string;
+    /** Full static handler designator, e.g. `auth.getCurrentUser`. */
+    handlerDesignator: string;
+    handlerName: string;
+    /** Present only for a bare handler identifier, for named-import resolution. */
+    handlerLocalName?: string;
+    line: number;
+}
+/**
+ * A `string`/`template_string` node's decoded value, or `null` when it is not a
+ * readable literal (an interpolated template, an unterminated escape). Shared
+ * with the NestJS extractor so both agree on what a readable literal is —
+ * notably that escapes must be DECODED, not dropped, because tree-sitter splits
+ * a literal around every `escape_sequence`.
+ */
+export declare function plainString(node: SyntaxNode): string | null;
+/**
+ * A property key's name, for the spellings that carry one — `{ path: … }` and
+ * `{ 'path': … }`. A computed key (`{ [KEY]: … }`) has none. Shared with the
+ * NestJS extractor, which reads `@Controller({ path: … })` the same way.
+ */
+export declare function propertyName(node: SyntaxNode): string | null;
+/** Return static route facts shared by ingestion and group contract extraction. */
+export declare function scanDataRouteTables(tree: Parser.Tree): DataRouteTableRoute[];
+export declare function extractDataRouteTableRoutes(tree: Parser.Tree, filePath: string, lineOffset?: number): ExtractedDecoratorRoute[];