carrick 0.3.104 → 0.3.105

package/sidecar/dist/src/type-inferrer.js

@@ -21,6 +21,7 @@ import * as path from 'node:path';
 import { Node, SyntaxKind, ts, } from 'ts-morph';
 import { validateInferRequestItem } from './validators.js';
 import { externalImportsOf, isExternalOrigin } from './origin.js';
+import { reachedOnlyOnFailure } from './failure-path.js';
 import { addedDiagnostics, applyInsertions, fileDiagnostics, literalInsertions, mapBack, mapForward, normalise, pathOf, } from './unwidened.js';
 import { expandTypeStructural, } from './type-structural-expander.js';
 /**
@@ -1813,6 +1814,16 @@ export class TypeInferrer {
             for (const expr of candidates) {
                 if (expr.getStart() <= startPos)
                     continue;
+                // carrick#1796: what the source does with the response once it has
+                // FAILED describes the failure, not the payload. `if (res.ok) {
+                // return ... } const errorText = await res.text()` published the error
+                // text as the response contract because the walk keeps the LAST whole
+                // read, and the failure path's read comes after the success path's
+                // return. A read there is neither the payload nor a part of it.
+                if (this.usesTrackedNames(expr, currentNames) &&
+                    reachedOnlyOnFailure(expr, func, (node) => this.isIdentifierUsage(node, currentNames))) {
+                    continue;
+                }
                 // carrick#1017: a comparison is `boolean` by construction, so it is
                 // never the payload a call yields. `const res = await fetch(url); if
                 // (res.status === 404) return null; return await res.json() as Entry`
@@ -2361,6 +2372,12 @@ export class TypeInferrer {
         const identifiers = expr.getDescendantsOfKind(SyntaxKind.Identifier);
         return identifiers.some((id) => this.isIdentifierUsage(id, names));
     }
+    /** `expr` is a use of a tracked name, or contains one. */
+    usesTrackedNames(expr, names) {
+        return Node.isIdentifier(expr)
+            ? this.isIdentifierUsage(expr, names)
+            : this.expressionUsesNames(expr, names);
+    }
     isIdentifierUsage(id, names) {
         if (!Node.isIdentifier(id)) {
             return false;