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

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
@@ -66,8 +67,14 @@ export function resolveReferenceSites(input) {
     let referencesEmitted = 0;
     let unresolved = 0;
     for (const site of scopes.referenceSites) {
+        // value-ref sites resolve post-finalize (imports live in finalized
+        // bindings the registries can't see — same reason free calls need
+        // `emitFreeCallFallback`). `emitPropertyDispatchCalls` owns their
+        // resolution and emission entirely (#2437).
+        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;
@@ -110,9 +117,10 @@ 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` |
  *   | `macro`          | MacroRegistry     | MACRO_KINDS (`Macro` only)   |
  *
  * `macro` has its own single-kind registry so a macro invocation
@@ -126,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 = {
@@ -135,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':
@@ -147,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;
@@ -166,6 +233,11 @@ function lookupForSite(site, classRegistry, methodRegistry, fieldRegistry, macro
                 return methodHits;
             return fieldRegistry.lookup(site.name, site.inScope);
         }
+        case 'value-ref': {
+            // Unreachable — filtered before lookup (post-finalize resolution in
+            // `emitPropertyDispatchCalls`, #2437). Kept for switch exhaustiveness.
+            return [];
+        }
         case 'macro': {
             // Macro-only namespace: resolves against `Macro`-labeled defs, never
             // functions. No receiver, no arity — see `MacroRegistry`.

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

@@ -0,0 +1,25 @@
+/**
+ * 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 { 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;
+}
+/** 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[];