Ask the awaited value whether it is a thenable, instead of scanning the source for `then`

Stacked on #3133 (the registry of whole-program facts); this PR removes one entry from it. It is the only one of the four spelling PRs that changes lowering.

The cliff, and a silent divergence under it

Whether await v adopts a thenable was decided for the whole program by a regular expression over the raw text of its sources (programMayDefineThenables): if some file's text looked like it defined a then member, every await of a checked-dynamic value took PromiseResolve; otherwise none did.

A comment is enough to flip it:

async function settle(value: unknown): Promise<unknown> {
  return await value;
}
settle({ n: 1 }).then((v) => console.log(JSON.stringify(v)));
// a note that mentions them: in prose

Change them: to then: in the comment and, on main, the IR of the await changes (18,065 to 24,272 bytes of IR for this file, and a different executable). And because the text decides, a thenable the text does not spell is silently not adopted:

const key = ["th", "en"].join("");
const box: any = {};
box[key] = (resolve: (v: number) => void) => resolve(42);
async function settle(value: unknown): Promise<unknown> {
  return await value;
}
settle(box).then((v) => console.log(typeof v, String(v)));

Node prints number 42; main prints object [object Object], with no diagnostic.

The fact, and the rule now

Whether a value is a thenable is a fact about that value when the await runs, however its then got there (a literal key, a computed one, a class method, a proxy trap). So the rule is per site and there is no program-wide switch:

• await v where v is checked-dynamic lowers to awaitExpr(dyn.promiseResolve(v, thenReader)), the form thenable programs already used, and the value decides at run time.
• Unless its static type already answers: a value typed as the standard library's Promise or as a primitive has no thenable to adopt, and keeps async.awaitDyn, which awaits a promise and hops once for anything else. any, unknown, type parameters and object types ask the value.

The same fact read from the static type closes the typed counterpart (finding 5 of the silent-divergence scout): await t where t's static type has a callable then (an object literal, a class instance, a union arm) now calls it, whether or not the awaited value is used. On main the statement form skipped the call silently:

const t = { then(r: (v: number) => void): void { console.log("then called"); r(42); } };
await t;                    // Node: "then called". main: nothing.
const x = await t;          // main: SC2002. Now 42, checked into `number`.

The typed value is boxed and takes the same PromiseResolve; what the thenable resolves with is checked into the awaited type where it is used. A type whose then cannot be called ({ then: 5 }), and a type with none, keep exactly their lowering. The call goes through the value's checked-dynamic form, so the form has to carry the member: records and class instances do (Error and Date subclasses and an inherited then included). An instance of a class that extends Array boxes as the array, and a function with a then property as the function, so those two are refused by name at compile time (SC1090, pinned by tests/diagnostics/await-thenable-fences.ts).

programMayDefineThenables, its lowerer cache and its registry entry are deleted.

What is deliberately not in this PR

• A typed thenable returned from an async function, resolved by an executor, passed to Promise.resolve or Promise.all, or typed PromiseLike is still refused at compile time (SC2002 / SC2020), as on main. None of these is silent. Exact adoption there means resolving the function's own promise with the thenable, one turn earlier than return await, which is a change to promise resolution rather than to await.
• Promise resolution with a checked-dynamic thenable outside await (an async return, an executor's resolve, a then callback's result, Promise.resolve, for await entries) fulfils with the object where Node adopts it. This is silent on main with or without the text scan and is unchanged here; it is logged in FOLLOWUPS.md with repros as the next slice. It needs the runtime's resolution function, which every async program links, so it needs its own gated change.
• A thenable behind a static type without then (a subclass that adds then, awaited through its base type) is still not adopted. Logged.

Proof

• Both pairs above compile to byte-identical IR and executables in either spelling, and the second prints number 42.
• New corpus programs, matching Node on both backends, plain and sanitized:
  • 8921-await-dynamic-thenable.ts: a computed key, a proxy trap and a class instance behind unknown; a then that is not callable, no then, a string, null, a promise; a then that throws, one that rejects, one that settles twice, a thenable resolving with a thenable; and the order of turns against a promise chain.
  • 8922-await-typed-thenable.ts: the two scout repros (r07, r07b) and their neighbours: value used and unused, a class instance, a union with a thenable arm, nesting, throwing and rejecting then, a non-callable then, a plain record, and the order of turns.
  • 8923-await-thenable-never-settles.ts: a then that never calls its resolver, typed and dynamic: the await never continues and the process exits 0.
• 6590-npm-promise-mixin (execa's mixin) and web-stream-callback-thenables.ts still match.
• IR sweep of every corpus, diagnostics and benchmark program (5,507), main against this change: 60 programs change IR, no diagnostics change, nothing starts or stops compiling. Each awaits a checked-dynamic value whose static type does not rule a thenable out (any or unknown in every one I read). The 56 that build without a Node island pack were run against Node on main's runtime: all match on stdout, stderr and exit code. web-stream-callback-thenables.ts is the one program that gets smaller: its await reader.read() is typed Promise and no longer takes the adoption path the text scan switched on.
• Zero-cost gate, --gate-corpus=all --gate-allow='\bawait\b': PASS, 5127 identical, 56 allowed, 96 both-fail, 8 shards; no benchmark differs and there is no runtime-only row. This is the one-time cost the text scan was written to avoid, recorded in DECISIONS.md. Executable size of the 56: 44 grow under 1%, median +0.63%, six grow 6.5 to 8.7%, and two TypeScript programs grow more: 2871-optional-promise-to-unknown.ts (+32.3%, 497,328 to 657,968 B) and 6400-override-any-base.ts (+17.6%). Both read no other dynamic property, so the then lookup is what links the dynamic object model for them. The gate ran with --gate-max-size-growth=100 to measure this. Without the static-type refinement 92 programs differed and eight otherwise typed programs grew 12 to 40%; that is why it is there. The full list with sizes is in the PR comment below.
• The four PRs of the stack were also validated merged together (both test lanes, the plain and sanitized native bootstraps, and a pi build with unchanged diagnostics): the numbers are in a comment on #3133.

🤖 Generated with Claude Code