trending/scriptc
1
0
Fork 0
mirror of https://github.com/vercel-labs/scriptc.git synced 2026-10-27 06:43:19 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge main and fix the self-copy key order

Browse Source
This commit is contained in:
Chris Tate
2026-10-23 20:47:40 -05:00
parent 9eddb388e9 0cb681a858
commit 0392a032c5
438 changed files with 17489 additions and 1584 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.github/workflows/ci.yml
+1 -1
View File
@@ -524,7 +524,7 @@ jobs:
if: ${{ needs.validation_scope.outputs.full == 'true' && needs.lanes.outputs.linux == 'true' }}
name: test (tsgo and tsc-ts give the same IR)
runs-on: ubuntu-24.04
timeout-minutes: 30
timeout-minutes: 60
steps:
- uses: actions/checkout@v4
- uses: pnpm/action-setup@v4
CHANGELOG.md
+22 -2
View File
@@ -6,6 +6,28 @@ All notable changes to scriptc will be documented in this file.
<!-- release:start -->
## 0.4.3
### Highlights
- **Faster checking and smaller builds with tsc-ts 0.0.9:** scriptc checks with tsc-ts 0.0.9, and builds reuse the bundled declaration files' diagnostics instead of checking them again. Small IR builds are 10.6 to 16.0% faster and small executable builds 5.5 to 7.6% faster, with identical output. A native build of tsc-ts with this release checks 0.4 to 6.6% faster than with 0.4.2 and peaks 4 to 16% lower.
- **Integer arrays and loops:**
- Number arrays that only hold int32 values use 4-byte slots in locals, across direct calls and in module globals, and loop-carried locals written from their elements stay int32. A workload that walks arrays of cursors runs 54.5% faster.
- Loops with two counters closing in on each other (`for (let i = lo, j = hi; i < j; i++, j--)`) and element copies through `a[i]!` run without per-element checks, and two-counter `while` loops run on integer counters.
- Loops over typed arrays and charAt scans are versioned on their bounds, and ASCII strings are scanned as bytes.
- **Less work for untyped and dynamic code:**
- String-keyed record reads under `??` and `!` no longer allocate: a dictionary-walking workload makes no union boxes instead of 363,359 and runs 12 to 15% faster.
- Checked-dynamic method calls dispatch on method ids, observed class methods call natively while their slot is unchanged, and calls on bag-tracked class instances skip building their views.
- **Node.js parity:**
- `crypto.getCipherInfo`, AES-CCM, AES key wrap, the legacy `createCipheriv` modes, `checkPrime`/`generatePrime`, and Node's argument checks for `generateKeyPair`.
- Streams: `construct`, `writev`, `decodeStrings` and `defaultEncoding`, including `writev` on `Transform` and `PassThrough`.
- `FinalizationRegistry`, `new.target`, `String.prototype.at` on untyped values, `Error.stackTraceLimit`, `spawnSync`'s `env` option, and class constructors called through `call`/`apply` throw Node's TypeError.
- Records enumerate in the key order their object literal wrote, and objects converting to a union with an empty-record arm keep every field.
- **npm packages:** zod 3 compiles natively and zod 4's core runs, minified packages such as marked compile, chalk 5 and hot-shots 8 build from built-in shims, and `@hono/node-server` 2.x is built in. User code types npm package declarations at a checked, identity-preserving boundary.
- **Builds:** the cached build is reused after whitespace and comment edits, function bodies are emitted on forked workers, and the LLVM emitter reads its analyses from one recorded walk of each module.
<!-- release:end -->
## 0.4.2
### Highlights
@@ -159,8 +181,6 @@ All notable changes to scriptc will be documented in this file.
- **The same program compiles to the same executable wherever it sits on disk** and whatever order its functions lower in, and edits outside a declaration do not rename the helpers and closures inside it.
- **Libraries that use untyped byte arrays** link.
<!-- release:end -->
## 0.4.1
### Highlights
docs/content/docs/how-it-works.mdx
+5 -6
View File
@@ -42,17 +42,16 @@ Parsing, type checking, lowering, and LLVM IR generation run one after another o
### Partitions
The LLVM helper divides an executable's LLVM IR into partitions by its size: one partition per 4 MiB of LLVM text, rounded up to a power of two, and at most 64. `--emit=llvm` writes this text, so its file size shows how many partitions a program gets.
The LLVM helper divides an executable's LLVM IR into partitions by its size. Up to 1 MiB of LLVM text is one partition, and up to 2 MiB is four. Larger programs get one partition per 4 MiB of LLVM text, rounded up to a power of two, and at least 8 and at most 64. `--emit=llvm` writes this text, so its file size shows how many partitions a program gets.
<table>
<thead>
<tr><th>LLVM text</th><th>Partitions</th></tr>
</thead>
<tbody>
<tr><td>Up to 4 MiB</td><td>1</td></tr>
<tr><td>Over 4 MiB, up to 8 MiB</td><td>2</td></tr>
<tr><td>Over 8 MiB, up to 16 MiB</td><td>4</td></tr>
<tr><td>Over 16 MiB, up to 32 MiB</td><td>8</td></tr>
<tr><td>Up to 1 MiB</td><td>1</td></tr>
<tr><td>Over 1 MiB, up to 2 MiB</td><td>4</td></tr>
<tr><td>Over 2 MiB, up to 32 MiB</td><td>8</td></tr>
<tr><td>Over 32 MiB, up to 64 MiB</td><td>16</td></tr>
<tr><td>Over 64 MiB, up to 128 MiB</td><td>32</td></tr>
<tr><td>Over 128 MiB</td><td>64</td></tr>
@@ -63,7 +62,7 @@ The count depends only on the size of the LLVM text, so a program has the same p
These builds are not divided into partitions and compile on one thread: `--emit=asm`, `--emit=obj`, and `--print=native-link-info` output, library builds (`--lib`; `dev` library builds are compiled in pieces, one after another), and `--sanitize` builds, which compile the LLVM IR with the C compiler.
The helper compiles partitions on a pool with one thread per hardware thread of the host, so an executable with two partitions uses at most two cores in the backend. A program of one partition is optimized and compiled on one thread.
The helper compiles partitions on a pool with one thread per hardware thread of the host, so an executable with four partitions uses at most four cores in the backend. A program of one partition is optimized and compiled on one thread.
How partitions are compiled depends on `--optimization`:
docs/content/limitations/builtin-apis/asynclocalstorage.mdx
+11 -1
View File
@@ -1,2 +1,12 @@
- **AsyncLocalStorage:** timer, interval, `setImmediate`, `process.nextTick` and `queueMicrotask` callbacks run with the stores that were active when they were scheduled, as in Node.
Completion callbacks of callback-style I/O APIs, such as `fs.readFile` and `crypto.randomBytes`, run with no store, where Node runs them with the stores that were active when the operation started.
The completion callbacks of `fs`, `crypto` and `zlib` callback APIs, `dns.lookup`, `child_process.execFile`, `server.listen`, `net.connect`, `http.request`, `http.get` and `dgram` run with the stores that were active at the call, as in Node.
Events of `net`, `tls`, `http` and `https` sockets, servers, requests and responses run with the stores Node runs them with.
A socket's or client request's events see the context of the call that created it, and a server's events and its requests' and responses' events see the context of its `listen()` call.
Socket `write` and `end` callbacks, `'finish'` and `server.close(callback)` see the context of their call.
Stream events and callbacks run with the stores of the code that triggers them, as in Node.
Stream steps that Node defers with `process.nextTick` see the context that scheduled them, and `stream.finished` and `stream.pipeline` callbacks see the context of their call.
`fs` read and write streams and `zlib` streams run their events and callbacks in the context that created them.
Events of `child_process` children, their standard streams and their IPC channels see the context of the `spawn()` or `fork()` call; stdin's `'finish'` and `send()` callbacks see the context of their call.
A client `http2` session's events see the context of its `http2.connect()` call, and a client stream's events the context of its `request()` call.
An `http2` server's `'session'` and `'stream'` events and the compatibility API's request handler see the context of its `listen()` call; a server stream's own events, and its compatibility request's and response's, run with no store, as in Node.
`AsyncResource` has no lowering yet.
docs/content/limitations/builtin-apis/crypto.mdx
+7 -5
View File
@@ -27,20 +27,22 @@
A call on a DiffieHellman value whose arguments no @types/node overload accepts, or whose output encoding is typed `any`, is refused at compile time, as are its `Object.prototype` methods; other property reads, and property writes, throw a coded SC2020 error.
`Object.keys()` and `in` do not see a DiffieHellman's own `verifyError` property, and `JSON.stringify()` and `instanceof` are refused.
After `createDiffieHellman(primeLength)` throws `Invalid DH parameters`, the next OpenSSL error Node throws can list the failed generation's errors in `opensslErrorStack`; errors in a compiled binary list only their own.
`crypto.diffieHellman`, which takes DH, EC, or X25519 KeyObjects, and the `DiffieHellman` and `DiffieHellmanGroup` constructors are not available.
`crypto.diffieHellman` computes ECDH and X25519 secrets from EC and X25519 keys, given as KeyObjects or in any form `createPrivateKey` and `createPublicKey` read, with Node's errors; DH keys have no KeyObjects here, and the `DiffieHellman` and `DiffieHellmanGroup` constructors are not available.
`checkPrime`, `checkPrimeSync`, `generatePrime`, and `generatePrimeSync` support bigint, ArrayBuffer, typed-array, Buffer, and DataView values and the `checks`, `safe`, `add`, `rem`, and `bigint` options on native targets, with Node's errors; the callback forms compute before they return and call back in a later macrotask.
Candidates and sizes longer than 262144 bits throw a coded SC2020 error, and wasm32-wasi builds are refused.
Node calls their callbacks with `undefined` as the error, which a callback whose error parameter is typed `Error | null`, as @types/node declares it, receives as `null`.
RSA, EC, and Ed25519 private and public KeyObjects come from `generateKeyPairSync`, `generateKeyPair`, `createPrivateKey`, and `createPublicKey`, on native targets.
RSA, EC, Ed25519, and X25519 private and public KeyObjects come from `generateKeyPairSync`, `generateKeyPair`, `createPrivateKey`, and `createPublicKey`, on native targets.
`generateKeyPairSync` and `generateKeyPair` check their arguments in Node's order, with Node's errors, including the OpenSSL errors for RSA modulus lengths below 512 or above 2147483647 bits and for public exponents of 0, 1, or an even number, which `generateKeyPair` passes to its callback.
RSA keys generate with even modulus lengths from 1024 to 8192 bits and public exponents up to 2147483647; other lengths and exponents that Node accepts, the `raw-public`, `raw-private`, and `raw-seed` encodings, and `paramEncoding: 'explicit'` throw a coded SC2020 error.
RSA keys generate with even modulus lengths from 1024 to 8192 bits and public exponents up to 2147483647; other lengths and exponents that Node accepts, and `paramEncoding: 'explicit'`, throw a coded SC2020 error.
The EC curves are prime256v1 (P-256), secp384r1 (P-384), secp521r1 (P-521), and secp256k1.
Keys read and write PEM and DER as PKCS#1, SEC1, PKCS#8, and SubjectPublicKeyInfo, and JWK (Ed25519 keys use PKCS#8, SubjectPublicKeyInfo, and JWK); `createPublicKey` also takes a private key or an X.509 certificate.
Keys read and write PEM and DER as PKCS#1, SEC1, PKCS#8, and SubjectPublicKeyInfo, and JWK (Ed25519 and X25519 keys use PKCS#8, SubjectPublicKeyInfo, and JWK); `createPublicKey` also takes a private key or an X.509 certificate.
EC, Ed25519, and X25519 keys also read and write the `raw-public` and `raw-private` formats, including compressed EC points.
Raw X448, Ed448, and post-quantum keys, EC scalars of 0 or at least the curve order, and the EC point at infinity, which Node accepts, throw a coded SC2020 error.
They support `type`, `asymmetricKeyType`, `asymmetricKeyDetails`, `export()`, `equals()`, and `instanceof KeyObject`.
`crypto.sign`, `crypto.verify`, `createSign`, and `createVerify` support RSA PKCS#1 v1.5 and PSS padding and ECDSA with DER and IEEE P1363 encodings over SHA-1 and SHA-2 digests, and Ed25519 through `crypto.sign` and `crypto.verify` with a `null` or `undefined` algorithm.
Ed25519 signing, verification, and private keys link when a string literal in the program names `ed25519` (in any case); without one they throw a coded SC2020 error, while Ed25519 public keys still import and export.
Sign and Verify values accumulate `update()` data and are not writable streams.
Encrypted private keys (`passphrase`, `cipher`), the other key types (`rsa-pss`, `dsa`, `ed448`, `x25519`, and the rest), and wasm32-wasi builds throw a coded SC2020 error or are refused.
Encrypted private keys (`passphrase`, `cipher`), the other key types (`rsa-pss`, `dsa`, `ed448`, `x448`, and the rest), and wasm32-wasi builds throw a coded SC2020 error or are refused.
Comparing keys of different types with `equals()` answers false; Node also leaves an OpenSSL error queued, which a later key operation can report.
`publicEncrypt`/`privateDecrypt` remain unsupported.
The WebCrypto `crypto` global, which node:crypto also exports as `webcrypto`, supports `randomUUID()` and `getRandomValues()`, also read as values from untyped JavaScript.
docs/content/limitations/builtin-apis/date.mdx
+5 -4
View File
@@ -1,5 +1,6 @@
- **Date:** Date unions, spread constructor arguments, setters, statically typed TypeScript identity comparisons, thrown Date values, and locale formatters are unsupported.
Zero-argument, single number/string, and local-time year/month field constructors, storage and passing, `getTime`, `valueOf`, `toISOString`, `toUTCString`, `toJSON` (a `string | null`: null for an invalid date, as in Node), `toString`, `toDateString`, `toTimeString`, `String(date)` and template literal conversion, calendar getters, `getTimezoneOffset`, and single-string `Date.parse` compile.
JavaScript Dates retain identity through checked storage and support Date-copy construction and JSON serialization.
A TypeScript Date converted to `unknown` becomes a Date with the same time value; each conversion creates a new Date, so two `unknown` values converted from one TypeScript Date are not `===`.
- **Date:** Spread constructor arguments, setters, thrown Date values, and locale formatters are unsupported.
Dates are objects: `===` compares identity, `new Date(date)` makes a new Date, and Dates compile in arrays (`includes`, `indexOf`, `lastIndexOf`, `join`, and default `sort` by `toString()` text), in `Date | undefined` and `Date | null` slots, as Map and Set keys and values, and in records, tuples, class fields, closures, promises and generators.
Unions of a Date with other non-nullish types are unsupported.
Zero-argument, single number/string, and local-time year/month field constructors, `getTime`, `valueOf`, `toISOString`, `toUTCString`, `toJSON` (a `string | null`: null for an invalid date, as in Node), `toString`, `toDateString`, `toTimeString`, `String(date)` and template literal conversion, relational comparison, calendar getters, `getTimezoneOffset`, and single-string `Date.parse` compile.
A Date converted to `unknown` is the same Date object.
See [Dates and timezones](#dates-and-timezones) for timezone data.
docs/content/limitations/builtin-apis/streams-and-readline.mdx
+2 -1
View File
@@ -27,7 +27,8 @@
A `Duplex.from` body function may take the `{ signal }` argument, which is aborted with the error the Duplex is destroyed with.
`stream.compose` accepts streams and async generator functions in any position, an async function as the last stage, and an array, a string, or a generator as the first stage; one stage is `Duplex.from` of it.
A web `ReadableStream` is read as an async iterable by `Readable.from` and as the first stage of `compose` or `pipeline`, and through its reader by `Readable.fromWeb` (with `objectMode`, `highWaterMark`, `encoding`, and `signal` in an options object literal) and `Duplex.from`.
A web stream in a later compose stage, `Readable.toWeb`, and web `WritableStream` and `TransformStream` interop are unsupported.
`new TransformStream()` without arguments builds the identity transform: its readable side is a web `ReadableStream`, its writable side supports `getWriter`, `abort`, `close`, and `locked`, and the writer supports `write`, `close`, `abort`, `releaseLock`, `ready`, `closed`, and `desiredSize`, with Node's backpressure (a write completes when the readable side reads its chunk).
A web stream in a later compose stage, `Readable.toWeb`, a `TransformStream` with a transformer or queuing strategies, the `WritableStream` constructor, `pipeTo`, and `pipeThrough` are unsupported.
The `ERR_INVALID_ARG_VALUE` message for a stream that is no longer readable or writable names the stream's class instead of printing the stream.
`readable.compose(stage, { signal })` is `stream.compose(readable, stage)` with the signal added; the options are an object literal whose `signal` is a variable or a property read.
`pipeline` from `node:stream/promises` accepts a trailing `{ signal, end }` object, with or without function stages, and `finished` accepts `readable`, `writable`, `error`, `cleanup`, and `signal` options, with boolean literals for the flags.
docs/content/limitations/builtin-apis/text-encoding.mdx
+1
View File
@@ -1,6 +1,7 @@
- **Text encoding:** `TextEncoder` and `TextDecoder` can be stored in fields, arguments, return values, arrays, and closures.
Encoding supports UTF-8, including `encodeInto` into a Uint8Array or Buffer view.
Codec properties expose the canonical encoding and decoder flags.
Codecs held in `any` or `unknown` storage keep their identity and streaming state, and dynamic code can call `encode`, `encodeInto` and `decode`, with options objects, and read their properties.
Decoding accepts recognized WHATWG labels, including runtime labels and omitted or undefined encodings.
Literal constructor options support `fatal` and `ignoreBOM`; literal decode options support streaming UTF-8, UTF-16, and single-byte encodings.
Other legacy streaming encodings, runtime options objects, inspection, JSON conversion, and module-scope declarations using `var` or lacking an initializer are unsupported.
docs/package.json
+2 -1
View File
@@ -10,9 +10,10 @@
"build": "fumadocs-mdx && next build",
"start": "next start",
"typecheck": "fumadocs-mdx && next typegen && tsc --noEmit",
"test:unit": "node --test test/compatibility-matrix.test.mjs",
"test:routes": "node scripts/test-routes.mjs",
"compat:check": "pnpm --dir .. node-compat:check",
"check": "pnpm compat:check && pnpm typecheck && pnpm build && pnpm test:routes"
"check": "pnpm compat:check && pnpm typecheck && pnpm test:unit && pnpm build && pnpm test:routes"
},
"dependencies": {
"@vercel/geistdocs": "2.7.8",
docs/src/components/node-compatibility-matrix.tsx
+157 -198
View File
@@ -4,52 +4,28 @@
// empty after an edit.
// @refresh reset
import { useEffect, useMemo, useState } from "react";
import { memo, startTransition, useCallback, useDeferredValue, useEffect, useId, useMemo, useState, type FocusEvent, type KeyboardEvent, type ReactNode } from "react";
import {
buildTree,
expandableIds,
filterTree,
flattenTree,
nodeCount,
rowMatcher,
searchTexts,
statusCounts,
statuses,
type NodeStability,
type Row,
type Snapshot,
type Status,
type Verification,
} from "@/lib/compatibility-tree";
// Set by next.config.mjs from the committed artifact.
const artifactVersion = process.env.COMPATIBILITY_ARTIFACT_VERSION;
const rowCount = Number(process.env.COMPATIBILITY_ROW_COUNT);
type Status =
| "supported"
| "partial"
| "refused"
| "not-implemented"
| "by-design"
| "unreviewed"
| "not-applicable";
type VerificationBasis =
| "test-backed"
| "explicit-refusal"
| "verified-absence"
| "declared-gap"
| "registry-gap"
| "architectural-policy"
| "unreviewed"
| "not-applicable"
| "derived";
type Verification = { label: string; detail: string };
type Tier = { status: Status; detail: string; verification: VerificationBasis };
type NodeStability = { index: string; level: number; text: string; inherited: boolean } | null;
type Row = {
id: string;
chapter: string;
kind: string;
name: string;
signature: string;
label: string;
apiSymbol: string;
depth: number;
scope: "api" | "documentation" | "metadata" | "configuration";
anchor: string;
nodeStability: NodeStability;
static: Tier;
};
type Chapter = { slug: string; title: string; entries: number; apiEntries: number };
type Snapshot = { nodeVersion: string; verificationBases: Record<VerificationBasis, Verification>; chapters: Chapter[]; rows: Row[] };
type TreeNode = { row: Row; children: TreeNode[] };
type VisibleNode = { node: TreeNode; level: number };
const labels: Record<Status, string> = {
supported: "Supported",
partial: "Partial",
@@ -70,7 +46,6 @@ const styles: Record<Status, string> = {
"not-applicable": "border-gray-alpha-400 bg-background-200 text-gray-700",
};
const statuses = ["supported", "partial", "not-implemented", "refused", "by-design", "unreviewed", "not-applicable"] as const;
const stabilityStyles: Record<number, string> = {
0: "border-red-500/40 bg-red-100 text-red-900 dark:bg-red-200",
1: "border-amber-500/50 bg-amber-100 text-amber-900 dark:bg-amber-200",
@@ -78,114 +53,83 @@ const stabilityStyles: Record<number, string> = {
3: "border-gray-alpha-500 bg-gray-alpha-100 text-gray-900",
};
function StatusBadge({ status, detail, verification }: { status: Status; detail?: string; verification?: Verification }) {
const tooltip = verification ? `${detail ?? ""}${detail ? "\n\n" : ""}Verification: ${verification.label}. ${verification.detail}` : detail;
/** A badge's tooltip, mounted only while the badge is hovered or has
* keyboard focus (the :focus-visible rule the CSS-only tooltip used), and
* named by aria-describedby while open. Hover and focus are tracked apart,
* so moving the pointer away keeps a keyboard-focused badge's tooltip.
* Escape dismisses it until the next hover or focus. */
function BadgeTooltip({ tooltipClass, children, badge }: { tooltipClass: string; children: ReactNode; badge: ReactNode }) {
const [hovered, setHovered] = useState(false);
const [focused, setFocused] = useState(false);
const open = hovered || focused;
const id = useId();
const enter = useCallback(() => setHovered(true), []);
const leave = useCallback(() => setHovered(false), []);
const focus = useCallback((event: FocusEvent<HTMLSpanElement>) => {
if (event.currentTarget.matches(":focus-visible")) setFocused(true);
}, []);
const blur = useCallback(() => setFocused(false), []);
const key = useCallback((event: KeyboardEvent<HTMLSpanElement>) => {
if (event.key !== "Escape") return;
setHovered(false);
setFocused(false);
}, []);
return (
<span className="group relative inline-flex" tabIndex={tooltip ? 0 : undefined}>
<span
className={`inline-flex whitespace-nowrap rounded-full border px-2 py-0.5 text-[11px] font-medium ${styles[status]}`}
title={tooltip}
>
{labels[status]}
</span>
{tooltip ? (
<span role="tooltip" className="pointer-events-none invisible absolute left-0 top-full z-30 mt-2 w-64 rounded-md border border-gray-alpha-500 bg-background-100 p-2 text-left text-xs font-normal leading-5 text-gray-1000 opacity-0 shadow-popover transition-opacity group-hover:visible group-hover:opacity-100 group-focus-visible:visible group-focus-visible:opacity-100">
{detail ? <span className="block">{detail}</span> : null}
{verification ? <span className={detail ? "mt-2 block border-t border-gray-alpha-400 pt-2" : "block"}><strong>Verification:</strong> {verification.label}. {verification.detail}</span> : null}
<span
className="relative inline-flex"
tabIndex={0}
aria-describedby={open ? id : undefined}
onMouseEnter={enter}
onMouseLeave={leave}
onFocus={focus}
onBlur={blur}
onKeyDown={key}
>
{badge}
{open ? (
<span id={id} role="tooltip" className={`pointer-events-none absolute top-full z-30 mt-2 rounded-md border border-gray-alpha-500 bg-background-100 p-2 text-left text-xs font-normal leading-5 text-gray-1000 opacity-100 shadow-popover transition-opacity starting:opacity-0 ${tooltipClass}`}>
{children}
</span>
) : null}
</span>
);
}
function StabilityBadge({ stability }: { stability: NodeStability }) {
export const StatusBadge = memo(function StatusBadge({ status, detail, verification }: { status: Status; detail?: string; verification?: Verification }) {
const tooltip = verification ? `${detail ?? ""}${detail ? "\n\n" : ""}Verification: ${verification.label}. ${verification.detail}` : detail;
const badge = (
<span
className={`inline-flex whitespace-nowrap rounded-full border px-2 py-0.5 text-[11px] font-medium ${styles[status]}`}
title={tooltip}
>
{labels[status]}
</span>
);
if (!tooltip) return <span className="relative inline-flex">{badge}</span>;
return (
<BadgeTooltip tooltipClass="left-0 w-64" badge={badge}>
{detail ? <span className="block">{detail}</span> : null}
{verification ? <span className={detail ? "mt-2 block border-t border-gray-alpha-400 pt-2" : "block"}><strong>Verification:</strong> {verification.label}. {verification.detail}</span> : null}
</BadgeTooltip>
);
});
export const StabilityBadge = memo(function StabilityBadge({ stability }: { stability: NodeStability }) {
if (stability === null) return <span className="text-xs text-gray-700" title="Node.js does not publish a stability index for this entry.">—</span>;
const detail = `Node.js Stability ${stability.index}: ${stability.text}${stability.inherited ? " (inherited from the nearest parent section)" : ""}`;
return (
<span className="group relative inline-flex" tabIndex={0}>
<span className={`inline-flex min-w-7 justify-center rounded-full border px-2 py-0.5 text-[11px] font-medium ${stabilityStyles[stability.level] ?? stabilityStyles[3]}`} title={detail}>
{stability.index}
</span>
<span role="tooltip" className="pointer-events-none invisible absolute left-1/2 top-full z-30 mt-2 w-72 -translate-x-1/2 rounded-md border border-gray-alpha-500 bg-background-100 p-2 text-left text-xs font-normal leading-5 text-gray-1000 opacity-0 shadow-popover transition-opacity group-hover:visible group-hover:opacity-100 group-focus-visible:visible group-focus-visible:opacity-100">
{detail}
</span>
</span>
);
}
function statusCounts(rows: Row[], tier: "static") {
return rows.reduce<Record<Status, number>>(
(counts, row) => {
if (row.scope !== "api" || row.depth === 0) return counts;
counts[row[tier].status] += 1;
return counts;
},
{
supported: 0,
partial: 0,
refused: 0,
"not-implemented": 0,
"by-design": 0,
unreviewed: 0,
"not-applicable": 0,
},
);
}
/** Node's all.json is preorder with an explicit heading depth. */
function buildTree(rows: Row[]): TreeNode[] {
const roots: TreeNode[] = [];
const stack: TreeNode[] = [];
for (const row of rows) {
const node: TreeNode = { row, children: [] };
while (stack.length > row.depth) stack.pop();
const parent = stack[row.depth - 1];
if (row.depth === 0 || parent === undefined) roots.push(node);
else parent.children.push(node);
stack[row.depth] = node;
stack.length = row.depth + 1;
}
return roots;
}
function filterTree(nodes: TreeNode[], matches: (row: Row) => boolean): TreeNode[] {
const filtered: TreeNode[] = [];
for (const node of nodes) {
const children = filterTree(node.children, matches);
if (matches(node.row) || children.length > 0) filtered.push({ row: node.row, children });
}
return filtered;
}
function flattenTree(nodes: TreeNode[], expanded: Set<string>, forceExpanded: boolean): VisibleNode[] {
const visible: VisibleNode[] = [];
const visit = (items: TreeNode[], level: number) => {
for (const node of items) {
visible.push({ node, level });
if (node.children.length > 0 && (forceExpanded || expanded.has(node.row.id))) {
visit(node.children, level + 1);
<BadgeTooltip
tooltipClass="left-1/2 w-72 -translate-x-1/2"
badge={
<span className={`inline-flex min-w-7 justify-center rounded-full border px-2 py-0.5 text-[11px] font-medium ${stabilityStyles[stability.level] ?? stabilityStyles[3]}`} title={detail}>
{stability.index}
</span>
}
}
};
visit(nodes, 1);
return visible;
}
function nodeCount(nodes: TreeNode[]): number {
return nodes.reduce((count, node) => count + 1 + nodeCount(node.children), 0);
}
function expandableIds(nodes: TreeNode[]): Set<string> {
const ids = new Set<string>();
const visit = (items: TreeNode[]) => {
for (const node of items) {
if (node.children.length > 0) ids.add(node.row.id);
visit(node.children);
}
};
visit(nodes);
return ids;
}
>
{detail}
</BadgeTooltip>
);
});
function Chevron({ open }: { open: boolean }) {
return (
@@ -195,6 +139,47 @@ function Chevron({ open }: { open: boolean }) {
);
}
type MatrixRowProps = {
row: Row;
level: number;
hasChildren: boolean;
open: boolean;
filtering: boolean;
displayName: string;
href: string;
verification: Verification | undefined;
onToggle: (id: string) => void;
};
/** One table row. Memoized on its own values, so a filter or expansion
* change re-renders only the rows whose values changed. */
const MatrixRow = memo(function MatrixRow({ row, level, hasChildren, open, filtering, displayName, href, verification, onToggle }: MatrixRowProps) {
const isRoot = level === 1;
return (
<tr aria-level={level} aria-expanded={hasChildren ? open : undefined} className={`align-top hover:bg-gray-alpha-100/60 ${isRoot ? "bg-background-200/60" : ""}`}>
<td>
<div className="flex items-start gap-1.5" style={{ paddingLeft: `${(level - 1) * 18}px` }}>
{hasChildren ? (
<button type="button" onClick={() => onToggle(row.id)} disabled={filtering} aria-label={`${open ? "Collapse" : "Expand"} ${displayName}`} className="mt-0.5 flex h-5 w-5 shrink-0 items-center justify-center rounded text-gray-800 hover:bg-gray-alpha-200 hover:text-gray-1000 disabled:cursor-default disabled:hover:bg-transparent">
<Chevron open={open} />
</button>
) : <span className="h-5 w-5 shrink-0" />}
<div className="min-w-0">
<a href={href} target="_blank" rel="noopener noreferrer" className={`${isRoot ? "font-sans text-sm font-medium" : "font-mono text-xs"} text-gray-1000 underline decoration-gray-alpha-500 underline-offset-2 hover:decoration-gray-1000`}>
{displayName}
</a>
<div className="mt-1 text-[11px] text-gray-800">
{row.kind}{row.apiSymbol && row.apiSymbol !== row.signature && !isRoot ? ` · ${row.apiSymbol}` : ""}
</div>
</div>
</div>
</td>
<td className="text-center"><StabilityBadge stability={row.nodeStability} /></td>
<td><StatusBadge status={row.static.status} detail={row.static.detail} verification={verification} /></td>
</tr>
);
});
export function NodeCompatibilityMatrix() {
const [snapshot, setSnapshot] = useState<Snapshot | null>(null);
const [loadError, setLoadError] = useState(false);
@@ -202,15 +187,16 @@ export function NodeCompatibilityMatrix() {
const [staticFilter, setStaticFilter] = useState<"all" | Status>("all");
const [expanded, setExpanded] = useState<Set<string>>(() => new Set());
const rows = snapshot?.rows ?? [];
const chapters = snapshot?.chapters ?? [];
const rows = useMemo(() => snapshot?.rows ?? [], [snapshot]);
const chapters = useMemo(() => snapshot?.chapters ?? [], [snapshot]);
const verificationBases = snapshot?.verificationBases;
const apiRowCount = useMemo(() => rows.filter((row) => row.scope === "api").length, [rows]);
const chapterTitles = useMemo(() => new Map(chapters.map((item) => [item.slug, item.title])), [chapters]);
const base = `https://nodejs.org/docs/v${snapshot?.nodeVersion ?? "24.22.0"}/api/`;
const staticCounts = useMemo(() => statusCounts(rows, "static"), [rows]);
const staticCounts = useMemo(() => statusCounts(rows), [rows]);
const visibleStatuses = useMemo(() => statuses.filter((status) => staticCounts[status] > 0), [staticCounts]);
const tree = useMemo(() => buildTree(rows), [rows]);
const texts = useMemo(() => searchTexts(rows, chapterTitles), [rows, chapterTitles]);
useEffect(() => {
const controller = new AbortController();
@@ -231,36 +217,23 @@ export function NodeCompatibilityMatrix() {
return () => controller.abort();
}, []);
const needle = query.trim().toLocaleLowerCase();
const hasResultFilter = needle !== "" || staticFilter !== "all";
const rowMatches = (row: Row) => {
if (staticFilter !== "all" && row.static.status !== staticFilter) return false;
if (!needle) return true;
return [chapterTitles.get(row.chapter), row.kind, row.name, row.signature, row.apiSymbol, row.static.detail]
.join(" ")
.toLocaleLowerCase()
.includes(needle);
};
// The search field and the status select update at once; the table
// follows the deferred values, so input stays responsive while the rows
// re-render.
const deferredQuery = useDeferredValue(query);
const deferredStatic = useDeferredValue(staticFilter);
const needle = deferredQuery.trim().toLocaleLowerCase();
const hasResultFilter = needle !== "" || deferredStatic !== "all";
const resultTree = useMemo(
() => hasResultFilter ? filterTree(tree, rowMatches) : tree,
// rowMatches closes over these filter values.
// eslint-disable-next-line react-hooks/exhaustive-deps
[hasResultFilter, needle, staticFilter, tree],
const result = useMemo(
() => hasResultFilter ? filterTree(tree, rowMatcher(texts, needle, deferredStatic)) : { nodes: tree, matched: nodeCount(tree) },
[hasResultFilter, needle, deferredStatic, texts, tree],
);
const visible = useMemo(
() => flattenTree(resultTree, expanded, hasResultFilter),
[expanded, hasResultFilter, resultTree],
);
const matchedCount = useMemo(
() => hasResultFilter ? tree.reduce((count, node) => {
const visit = (item: TreeNode): number => (rowMatches(item.row) ? 1 : 0) + item.children.reduce((sum, child) => sum + visit(child), 0);
return count + visit(node);
}, 0) : nodeCount(tree),
// rowMatches closes over these filter values.
// eslint-disable-next-line react-hooks/exhaustive-deps
[hasResultFilter, needle, staticFilter, tree],
() => flattenTree(result.nodes, expanded, hasResultFilter),
[expanded, hasResultFilter, result],
);
const matchedCount = result.matched;
const changeQuery = (value: string) => setQuery(value);
const resetFilters = () => {
@@ -268,12 +241,12 @@ export function NodeCompatibilityMatrix() {
setStaticFilter("all");
setExpanded(new Set());
};
const toggle = (id: string) => setExpanded((current) => {
const toggle = useCallback((id: string) => setExpanded((current) => {
const next = new Set(current);
if (next.has(id)) next.delete(id);
else next.add(id);
return next;
});
}), []);
useEffect(() => {
if (!snapshot) return;
@@ -316,8 +289,8 @@ export function NodeCompatibilityMatrix() {
<span aria-live="polite">{visible.length.toLocaleString()} visible · {matchedCount.toLocaleString()} {hasResultFilter ? "matching" : "API"} rows</span>
{!hasResultFilter ? (
<span className="flex gap-1">
<button type="button" onClick={() => setExpanded(expandableIds(tree))} className="rounded px-1.5 py-1 text-gray-900 hover:bg-gray-alpha-100 hover:text-gray-1000">Expand all</button>
<button type="button" onClick={() => setExpanded(new Set())} className="rounded px-1.5 py-1 text-gray-900 hover:bg-gray-alpha-100 hover:text-gray-1000">Collapse all</button>
<button type="button" onClick={() => startTransition(() => setExpanded(expandableIds(tree)))} className="rounded px-1.5 py-1 text-gray-900 hover:bg-gray-alpha-100 hover:text-gray-1000">Expand all</button>
<button type="button" onClick={() => startTransition(() => setExpanded(new Set()))} className="rounded px-1.5 py-1 text-gray-900 hover:bg-gray-alpha-100 hover:text-gray-1000">Collapse all</button>
</span>
) : null}
</div>
@@ -335,33 +308,19 @@ export function NodeCompatibilityMatrix() {
<tbody>
{visible.map(({ node, level }) => {
const row = node.row;
const hasChildren = node.children.length > 0;
const open = hasResultFilter || expanded.has(row.id);
const href = `${base}${row.chapter}.html${row.anchor ? `#${row.anchor}` : ""}`;
const isRoot = level === 1;
const displayName = isRoot ? chapterTitles.get(row.chapter) ?? row.label : row.label;
return (
<tr key={row.id} aria-level={level} aria-expanded={hasChildren ? open : undefined} className={`align-top hover:bg-gray-alpha-100/60 ${isRoot ? "bg-background-200/60" : ""}`}>
<td>
<div className="flex items-start gap-1.5" style={{ paddingLeft: `${(level - 1) * 18}px` }}>
{hasChildren ? (
<button type="button" onClick={() => toggle(row.id)} disabled={hasResultFilter} aria-label={`${open ? "Collapse" : "Expand"} ${displayName}`} className="mt-0.5 flex h-5 w-5 shrink-0 items-center justify-center rounded text-gray-800 hover:bg-gray-alpha-200 hover:text-gray-1000 disabled:cursor-default disabled:hover:bg-transparent">
<Chevron open={open} />
</button>
) : <span className="h-5 w-5 shrink-0" />}
<div className="min-w-0">
<a href={href} target="_blank" rel="noopener noreferrer" className={`${isRoot ? "font-sans text-sm font-medium" : "font-mono text-xs"} text-gray-1000 underline decoration-gray-alpha-500 underline-offset-2 hover:decoration-gray-1000`}>
{displayName}
</a>
<div className="mt-1 text-[11px] text-gray-800">
{row.kind}{row.apiSymbol && row.apiSymbol !== row.signature && !isRoot ? ` · ${row.apiSymbol}` : ""}
</div>
</div>
</div>
</td>
<td className="text-center"><StabilityBadge stability={row.nodeStability} /></td>
<td><StatusBadge status={row.static.status} detail={row.static.detail} verification={verificationBases?.[row.static.verification]} /></td>
</tr>
<MatrixRow
key={row.id}
row={row}
level={level}
hasChildren={node.children.length > 0}
open={hasResultFilter || expanded.has(row.id)}
filtering={hasResultFilter}
displayName={level === 1 ? chapterTitles.get(row.chapter) ?? row.label : row.label}
href={`${base}${row.chapter}.html${row.anchor ? `#${row.anchor}` : ""}`}
verification={verificationBases?.[row.static.verification]}
onToggle={toggle}
/>
);
})}
</tbody>
docs/src/generated/node-v24-compatibility.json
+9 -9
View File
@@ -11476,9 +11476,9 @@
"inherited": true
},
"static": {
"status": "refused",
"detail": "Explicitly rejected by a named compiler diagnostic.",
"verification": "explicit-refusal"
"status": "partial",
"detail": "Implemented for the call shapes accepted by the compiler lowering.",
"verification": "test-backed"
}
},
{
@@ -35971,9 +35971,9 @@
"inherited": true
},
"static": {
"status": "not-implemented",
"detail": "No static compiler lowering is registered for this API yet.",
"verification": "registry-gap"
"status": "partial",
"detail": "Implemented for the documented scriptc module-loader subset.",
"verification": "test-backed"
}
},
{
@@ -81657,9 +81657,9 @@
"inherited": true
},
"static": {
"status": "not-implemented",
"detail": "No static compiler lowering is registered for this API yet.",
"verification": "registry-gap"
"status": "partial",
"detail": "Implemented for the documented static async-iteration subset.",
"verification": "test-backed"
}
},
{
docs/src/lib/compatibility-tree.ts
+157
View File
@@ -0,0 +1,157 @@
// The compatibility matrix's data model: the ledger rows as a tree, and the
// search and filter passes over it. Kept free of React so the passes can be
// tested directly.
export type Status =
| "supported"
| "partial"
| "refused"
| "not-implemented"
| "by-design"
| "unreviewed"
| "not-applicable";
export type VerificationBasis =
| "test-backed"
| "explicit-refusal"
| "verified-absence"
| "declared-gap"
| "registry-gap"
| "architectural-policy"
| "unreviewed"
| "not-applicable"
| "derived";
export type Verification = { label: string; detail: string };
export type Tier = { status: Status; detail: string; verification: VerificationBasis };
export type NodeStability = { index: string; level: number; text: string; inherited: boolean } | null;
export type Row = {
id: string;
chapter: string;
kind: string;
name: string;
signature: string;
label: string;
apiSymbol: string;
depth: number;
scope: "api" | "documentation" | "metadata" | "configuration";
anchor: string;
nodeStability: NodeStability;
static: Tier;
};
export type Chapter = { slug: string; title: string; entries: number; apiEntries: number };
export type Snapshot = {
nodeVersion: string;
verificationBases: Record<VerificationBasis, Verification>;
chapters: Chapter[];
rows: Row[];
};
export type TreeNode = { row: Row; children: TreeNode[] };
export type VisibleNode = { node: TreeNode; level: number };
export const statuses = ["supported", "partial", "not-implemented", "refused", "by-design", "unreviewed", "not-applicable"] as const;
export function statusCounts(rows: Row[]): Record<Status, number> {
return rows.reduce<Record<Status, number>>(
(counts, row) => {
if (row.scope !== "api" || row.depth === 0) return counts;
counts[row.static.status] += 1;
return counts;
},
{
supported: 0,
partial: 0,
refused: 0,
"not-implemented": 0,
"by-design": 0,
unreviewed: 0,
"not-applicable": 0,
},
);
}
/** Node's all.json is preorder with an explicit heading depth. */
export function buildTree(rows: Row[]): TreeNode[] {
const roots: TreeNode[] = [];
const stack: TreeNode[] = [];
for (const row of rows) {
const node: TreeNode = { row, children: [] };
while (stack.length > row.depth) stack.pop();
const parent = stack[row.depth - 1];
if (row.depth === 0 || parent === undefined) roots.push(node);
else parent.children.push(node);
stack[row.depth] = node;
stack.length = row.depth + 1;
}
return roots;
}
/** The lowercase text a search matches against, built once per row: the
* chapter title, kind, name, signature, API symbol and support detail. */
export function searchTexts(rows: Row[], chapterTitles: ReadonlyMap<string, string>): Map<string, string> {
return new Map(
rows.map((row) => [
row.id,
[chapterTitles.get(row.chapter), row.kind, row.name, row.signature, row.apiSymbol, row.static.detail]
.join(" ")
.toLocaleLowerCase(),
]),
);
}
/** The rows a status filter and a lowercase search needle keep. */
export function rowMatcher(
texts: ReadonlyMap<string, string>,
needle: string,
status: "all" | Status,
): (row: Row) => boolean {
return (row) => {
if (status !== "all" && row.static.status !== status) return false;
return needle === "" || (texts.get(row.id) ?? "").includes(needle);
};
}
/** The matching rows with their ancestors, and the number of matching
* rows, in one pass. */
export function filterTree(nodes: TreeNode[], matches: (row: Row) => boolean): { nodes: TreeNode[]; matched: number } {
let matched = 0;
const visit = (items: TreeNode[]): TreeNode[] => {
const filtered: TreeNode[] = [];
for (const node of items) {
const children = visit(node.children);
const own = matches(node.row);
if (own) matched += 1;
if (own || children.length > 0) filtered.push({ row: node.row, children });
}
return filtered;
};
return { nodes: visit(nodes), matched };
}
export function flattenTree(nodes: TreeNode[], expanded: ReadonlySet<string>, forceExpanded: boolean): VisibleNode[] {
const visible: VisibleNode[] = [];
const visit = (items: TreeNode[], level: number) => {
for (const node of items) {
visible.push({ node, level });
if (node.children.length > 0 && (forceExpanded || expanded.has(node.row.id))) {
visit(node.children, level + 1);
}
}
};
visit(nodes, 1);
return visible;
}
export function nodeCount(nodes: TreeNode[]): number {
return nodes.reduce((count, node) => count + 1 + nodeCount(node.children), 0);
}
export function expandableIds(nodes: TreeNode[]): Set<string> {
const ids = new Set<string>();
const visit = (items: TreeNode[]) => {
for (const node of items) {
if (node.children.length > 0) ids.add(node.row.id);
visit(node.children);
}
};
visit(nodes);
return ids;
}
docs/test/compatibility-matrix.test.mjs
+115
View File
@@ -0,0 +1,115 @@
import assert from "node:assert/strict";
import { mkdir, readFile, writeFile } from "node:fs/promises";
import { test } from "node:test";
import { fileURLToPath, pathToFileURL } from "node:url";
import { createElement } from "react";
import { renderToStaticMarkup } from "react-dom/server";
import ts from "typescript";
import {
buildTree,
expandableIds,
filterTree,
flattenTree,
nodeCount,
rowMatcher,
searchTexts,
statusCounts,
} from "../src/lib/compatibility-tree.ts";
const row = (id, depth, label, status, detail = "") => ({
id,
chapter: "zlib",
kind: depth === 0 ? "module" : "method",
name: label,
signature: label,
label,
apiSymbol: label,
depth,
scope: "api",
anchor: "",
nodeStability: null,
static: { status, detail, verification: "test-backed" },
});
const rows = [
row("root", 0, "zlib", "partial"),
row("a", 1, "zlib.gzipSync()", "supported", "Lowered with Node's options"),
row("b", 1, "zlib.Gzip", "partial"),
row("b1", 2, "gzip.flush()", "supported"),
row("c", 1, "zlib.zstdCompress()", "not-implemented"),
];
const titles = new Map([["zlib", "Zlib"]]);
test("the tree follows the rows' heading depths", () => {
const tree = buildTree(rows);
assert.equal(tree.length, 1);
assert.deepEqual(tree[0].children.map((node) => node.row.id), ["a", "b", "c"]);
assert.deepEqual(tree[0].children[1].children.map((node) => node.row.id), ["b1"]);
assert.equal(nodeCount(tree), 5);
assert.deepEqual([...expandableIds(tree)].sort(), ["b", "root"]);
});
test("filtering keeps matching rows with their ancestors and counts the matches once", () => {
const tree = buildTree(rows);
const texts = searchTexts(rows, titles);
const byText = filterTree(tree, rowMatcher(texts, "flush", "all"));
assert.equal(byText.matched, 1);
assert.deepEqual(flattenTree(byText.nodes, new Set(), true).map(({ node, level }) => `${node.row.id}@${level}`), ["root@1", "b@2", "b1@3"]);
const byDetail = filterTree(tree, rowMatcher(texts, "node's options", "all"));
assert.deepEqual(flattenTree(byDetail.nodes, new Set(), true).map(({ node }) => node.row.id), ["root", "a"]);
const byStatus = filterTree(tree, rowMatcher(texts, "", "supported"));
assert.equal(byStatus.matched, 2);
const both = filterTree(tree, rowMatcher(texts, "gzip", "partial"));
assert.equal(both.matched, 1);
assert.equal(filterTree(tree, rowMatcher(texts, "brotli", "all")).nodes.length, 0);
});
test("collapsed rows hide their children until expanded", () => {
const tree = buildTree(rows);
assert.deepEqual(flattenTree(tree, new Set(), false).map(({ node }) => node.row.id), ["root"]);
assert.deepEqual(flattenTree(tree, new Set(["root"]), false).map(({ node }) => node.row.id), ["root", "a", "b", "c"]);
assert.deepEqual(flattenTree(tree, new Set(["root", "b"]), false).map(({ node }) => node.row.id), ["root", "a", "b", "b1", "c"]);
});
test("status counts cover API rows below the chapters", () => {
const counts = statusCounts(rows);
assert.equal(counts.supported, 2);
assert.equal(counts.partial, 1);
assert.equal(counts["not-implemented"], 1);
});
/** The matrix component, compiled for Node from its TSX source. */
async function loadMatrix() {
const docs = new URL("../", import.meta.url);
const source = await readFile(new URL("src/components/node-compatibility-matrix.tsx", docs), "utf8");
const { outputText } = ts.transpileModule(source, {
compilerOptions: { jsx: ts.JsxEmit.ReactJSX, module: ts.ModuleKind.ESNext, target: ts.ScriptTarget.ES2022 },
});
const lib = pathToFileURL(fileURLToPath(new URL("src/lib/compatibility-tree.ts", docs))).href;
const dir = new URL("node_modules/.cache/compatibility-matrix-test/", docs);
await mkdir(dir, { recursive: true });
const file = new URL("node-compatibility-matrix.mjs", dir);
await writeFile(file, outputText.replace('"@/lib/compatibility-tree"', JSON.stringify(lib)));
return import(file.href);
}
test("badges render without their tooltips until hovered or focused", async () => {
const { StatusBadge, StabilityBadge } = await loadMatrix();
const status = renderToStaticMarkup(
createElement(StatusBadge, {
status: "partial",
detail: "Lowered with Node's options",
verification: { label: "Test-backed", detail: "Corpus programs cover it." },
}),
);
assert.ok(status.includes('tabindex="0"'), status);
assert.ok(status.includes('title="Lowered with Node&#x27;s options'), status);
assert.ok(!status.includes('role="tooltip"'), status);
assert.ok(!status.includes("aria-describedby"), status);
const stability = renderToStaticMarkup(
createElement(StabilityBadge, { stability: { index: "2", level: 2, text: "Stable", inherited: false } }),
);
assert.ok(stability.includes('tabindex="0"'), stability);
assert.ok(!stability.includes('role="tooltip"'), stability);
const legend = renderToStaticMarkup(createElement(StatusBadge, { status: "supported" }));
assert.ok(!legend.includes("tabindex"), legend);
});
internal/compatibility/generated/node-v24-internal.json
+164 -20
View File
@@ -1387,7 +1387,20 @@
"evidence": "derived:descendants",
"tests": [
"tests/corpus/2213-async-local-storage.cjs",
"tests/corpus/5815-als-callback-context.ts"
"tests/corpus/5815-als-callback-context.ts",
"tests/corpus/7110-als-completion-callbacks.ts",
"tests/corpus/7111-als-bind-snapshot-options.ts",
"tests/corpus/7112-als-bind-snapshot-dynamic.mjs",
"tests/corpus/7119-als-net-event-context.mjs",
"tests/corpus/7380-als-http-event-context.mjs",
"tests/corpus/7383-als-stream-events.ts",
"tests/corpus/7384-als-stream-events.mjs",
"tests/corpus/7385-als-child-process-events.ts",
"tests/corpus/7386-als-child-fork-events/main.mjs",
"tests/corpus/7387-als-http2-events.mjs",
"tests/corpus/7388-als-http2-compat-events.mjs",
"tests/corpus/7389-als-http2-secure-events.mjs",
"tests/corpus/7391-als-response-end-and-finished.mjs"
]
},
"anchorSource": "chapter"
@@ -1437,7 +1450,20 @@
"evidence": "compiler-dedicated:AsyncLocalStorage",
"tests": [
"tests/corpus/2213-async-local-storage.cjs",
"tests/corpus/5815-als-callback-context.ts"
"tests/corpus/5815-als-callback-context.ts",
"tests/corpus/7110-als-completion-callbacks.ts",
"tests/corpus/7111-als-bind-snapshot-options.ts",
"tests/corpus/7112-als-bind-snapshot-dynamic.mjs",
"tests/corpus/7119-als-net-event-context.mjs",
"tests/corpus/7380-als-http-event-context.mjs",
"tests/corpus/7383-als-stream-events.ts",
"tests/corpus/7384-als-stream-events.mjs",
"tests/corpus/7385-als-child-process-events.ts",
"tests/corpus/7386-als-child-fork-events/main.mjs",
"tests/corpus/7387-als-http2-events.mjs",
"tests/corpus/7388-als-http2-compat-events.mjs",
"tests/corpus/7389-als-http2-secure-events.mjs",
"tests/corpus/7391-als-response-end-and-finished.mjs"
]
},
"anchorSource": "exact"
@@ -1510,7 +1536,20 @@
"evidence": "compiler-dedicated:asyncLocalStorage.disable",
"tests": [
"tests/corpus/2213-async-local-storage.cjs",
"tests/corpus/5815-als-callback-context.ts"
"tests/corpus/5815-als-callback-context.ts",
"tests/corpus/7110-als-completion-callbacks.ts",
"tests/corpus/7111-als-bind-snapshot-options.ts",
"tests/corpus/7112-als-bind-snapshot-dynamic.mjs",
"tests/corpus/7119-als-net-event-context.mjs",
"tests/corpus/7380-als-http-event-context.mjs",
"tests/corpus/7383-als-stream-events.ts",
"tests/corpus/7384-als-stream-events.mjs",
"tests/corpus/7385-als-child-process-events.ts",
"tests/corpus/7386-als-child-fork-events/main.mjs",
"tests/corpus/7387-als-http2-events.mjs",
"tests/corpus/7388-als-http2-compat-events.mjs",
"tests/corpus/7389-als-http2-secure-events.mjs",
"tests/corpus/7391-als-response-end-and-finished.mjs"
]
},
"anchorSource": "exact"
@@ -1537,7 +1576,20 @@
"evidence": "compiler-dedicated:asyncLocalStorage.getStore",
"tests": [
"tests/corpus/2213-async-local-storage.cjs",
"tests/corpus/5815-als-callback-context.ts"
"tests/corpus/5815-als-callback-context.ts",
"tests/corpus/7110-als-completion-callbacks.ts",
"tests/corpus/7111-als-bind-snapshot-options.ts",
"tests/corpus/7112-als-bind-snapshot-dynamic.mjs",
"tests/corpus/7119-als-net-event-context.mjs",
"tests/corpus/7380-als-http-event-context.mjs",
"tests/corpus/7383-als-stream-events.ts",
"tests/corpus/7384-als-stream-events.mjs",
"tests/corpus/7385-als-child-process-events.ts",
"tests/corpus/7386-als-child-fork-events/main.mjs",
"tests/corpus/7387-als-http2-events.mjs",
"tests/corpus/7388-als-http2-compat-events.mjs",
"tests/corpus/7389-als-http2-secure-events.mjs",
"tests/corpus/7391-als-response-end-and-finished.mjs"
]
},
"anchorSource": "exact"
@@ -1564,7 +1616,20 @@
"evidence": "compiler-dedicated:asyncLocalStorage.enterWith",
"tests": [
"tests/corpus/2213-async-local-storage.cjs",
"tests/corpus/5815-als-callback-context.ts"
"tests/corpus/5815-als-callback-context.ts",
"tests/corpus/7110-als-completion-callbacks.ts",
"tests/corpus/7111-als-bind-snapshot-options.ts",
"tests/corpus/7112-als-bind-snapshot-dynamic.mjs",
"tests/corpus/7119-als-net-event-context.mjs",
"tests/corpus/7380-als-http-event-context.mjs",
"tests/corpus/7383-als-stream-events.ts",
"tests/corpus/7384-als-stream-events.mjs",
"tests/corpus/7385-als-child-process-events.ts",
"tests/corpus/7386-als-child-fork-events/main.mjs",
"tests/corpus/7387-als-http2-events.mjs",
"tests/corpus/7388-als-http2-compat-events.mjs",
"tests/corpus/7389-als-http2-secure-events.mjs",
"tests/corpus/7391-als-response-end-and-finished.mjs"
]
},
"anchorSource": "exact"
@@ -1591,7 +1656,20 @@
"evidence": "compiler-dedicated:asyncLocalStorage.run",
"tests": [
"tests/corpus/2213-async-local-storage.cjs",
"tests/corpus/5815-als-callback-context.ts"
"tests/corpus/5815-als-callback-context.ts",
"tests/corpus/7110-als-completion-callbacks.ts",
"tests/corpus/7111-als-bind-snapshot-options.ts",
"tests/corpus/7112-als-bind-snapshot-dynamic.mjs",
"tests/corpus/7119-als-net-event-context.mjs",
"tests/corpus/7380-als-http-event-context.mjs",
"tests/corpus/7383-als-stream-events.ts",
"tests/corpus/7384-als-stream-events.mjs",
"tests/corpus/7385-als-child-process-events.ts",
"tests/corpus/7386-als-child-fork-events/main.mjs",
"tests/corpus/7387-als-http2-events.mjs",
"tests/corpus/7388-als-http2-compat-events.mjs",
"tests/corpus/7389-als-http2-secure-events.mjs",
"tests/corpus/7391-als-response-end-and-finished.mjs"
]
},
"anchorSource": "exact"
@@ -1618,7 +1696,20 @@
"evidence": "compiler-dedicated:asyncLocalStorage.exit",
"tests": [
"tests/corpus/2213-async-local-storage.cjs",
"tests/corpus/5815-als-callback-context.ts"
"tests/corpus/5815-als-callback-context.ts",
"tests/corpus/7110-als-completion-callbacks.ts",
"tests/corpus/7111-als-bind-snapshot-options.ts",
"tests/corpus/7112-als-bind-snapshot-dynamic.mjs",
"tests/corpus/7119-als-net-event-context.mjs",
"tests/corpus/7380-als-http-event-context.mjs",
"tests/corpus/7383-als-stream-events.ts",
"tests/corpus/7384-als-stream-events.mjs",
"tests/corpus/7385-als-child-process-events.ts",
"tests/corpus/7386-als-child-fork-events/main.mjs",
"tests/corpus/7387-als-http2-events.mjs",
"tests/corpus/7388-als-http2-compat-events.mjs",
"tests/corpus/7389-als-http2-secure-events.mjs",
"tests/corpus/7391-als-response-end-and-finished.mjs"
]
},
"anchorSource": "exact"
@@ -1922,6 +2013,19 @@
"tests": [
"tests/corpus/2213-async-local-storage.cjs",
"tests/corpus/5815-als-callback-context.ts",
"tests/corpus/7110-als-completion-callbacks.ts",
"tests/corpus/7111-als-bind-snapshot-options.ts",
"tests/corpus/7112-als-bind-snapshot-dynamic.mjs",
"tests/corpus/7119-als-net-event-context.mjs",
"tests/corpus/7380-als-http-event-context.mjs",
"tests/corpus/7383-als-stream-events.ts",
"tests/corpus/7384-als-stream-events.mjs",
"tests/corpus/7385-als-child-process-events.ts",
"tests/corpus/7386-als-child-fork-events/main.mjs",
"tests/corpus/7387-als-http2-events.mjs",
"tests/corpus/7388-als-http2-compat-events.mjs",
"tests/corpus/7389-als-http2-secure-events.mjs",
"tests/corpus/7391-als-response-end-and-finished.mjs",
"tests/harness/node-test.test.ts"
]
},
@@ -2484,7 +2588,20 @@
"evidence": "compiler-dedicated:AsyncLocalStorage",
"tests": [
"tests/corpus/2213-async-local-storage.cjs",
"tests/corpus/5815-als-callback-context.ts"
"tests/corpus/5815-als-callback-context.ts",
"tests/corpus/7110-als-completion-callbacks.ts",
"tests/corpus/7111-als-bind-snapshot-options.ts",
"tests/corpus/7112-als-bind-snapshot-dynamic.mjs",
"tests/corpus/7119-als-net-event-context.mjs",
"tests/corpus/7380-als-http-event-context.mjs",
"tests/corpus/7383-als-stream-events.ts",
"tests/corpus/7384-als-stream-events.mjs",
"tests/corpus/7385-als-child-process-events.ts",
"tests/corpus/7386-als-child-fork-events/main.mjs",
"tests/corpus/7387-als-http2-events.mjs",
"tests/corpus/7388-als-http2-compat-events.mjs",
"tests/corpus/7389-als-http2-secure-events.mjs",
"tests/corpus/7391-als-response-end-and-finished.mjs"
]
},
"anchorSource": "exact"
@@ -20228,8 +20345,19 @@
"inherited": true
},
"static": {
"status": "refused",
"evidence": "surface-manifest:unsupported:node-builtin.crypto.diffieHellman"
"status": "partial",
"evidence": "surface-manifest:node-builtin.crypto.diffieHellman",
"tests": [
"tests/corpus/1358-crypto-random.ts",
"tests/corpus/1534-crypto-hash-chain.ts",
"tests/corpus/2556-crypto-introspection.ts",
"tests/corpus/2890-crypto-static-utility.ts",
"tests/harness/npm-static.test.ts",
"tests/corpus/node24-crypto-sha2.ts",
"tests/corpus/node24-crypto-kdf.ts",
"tests/corpus/node24-crypto-kdf-errors.ts",
"tests/corpus/node24-crypto-kdf-options.ts"
]
},
"anchorSource": "exact"
},
@@ -52194,6 +52322,8 @@
"tests/corpus/6294-webcrypto-js-values.mjs",
"tests/corpus/6295-jose-hs256/main.mjs",
"tests/corpus/6331-jose-root-entry/main.ts",
"tests/corpus/7743-transform-stream-identity.ts",
"tests/corpus/7747-text-codec-untyped-slot.js",
"tests/corpus/text-codec-values/main.ts",
"tests/corpus/webassembly-api.mjs",
"tests/corpus/webassembly-dylink/main.mjs",
@@ -53346,7 +53476,8 @@
"tests": [
"tests/corpus/1423-text-codec.ts",
"tests/corpus/text-codec-values/main.ts",
"tests/corpus/3133-text-decoder-streaming.ts"
"tests/corpus/3133-text-decoder-streaming.ts",
"tests/corpus/7747-text-codec-untyped-slot.js"
]
},
"anchorSource": "exact"
@@ -53397,7 +53528,8 @@
"tests": [
"tests/corpus/1423-text-codec.ts",
"tests/corpus/text-codec-values/main.ts",
"tests/corpus/3133-text-decoder-streaming.ts"
"tests/corpus/3133-text-decoder-streaming.ts",
"tests/corpus/7747-text-codec-untyped-slot.js"
]
},
"anchorSource": "exact"
@@ -53443,8 +53575,11 @@
"inherited": true
},
"static": {
"status": "not-implemented",
"evidence": "compiler-unmatched:globals"
"status": "partial",
"evidence": "compiler-feature:globals.TransformStream",
"tests": [
"tests/corpus/7743-transform-stream-identity.ts"
]
},
"anchorSource": "exact"
},
@@ -101277,6 +101412,7 @@
"tests/corpus/5835-util-format-integer-specifiers.ts",
"tests/corpus/5884-inspect-layout-options.ts",
"tests/corpus/6428-promisify-callback-functions.ts",
"tests/corpus/7747-text-codec-untyped-slot.js",
"tests/corpus/node24-deep-equality-properties.js",
"tests/corpus/node24-deep-equality.cjs",
"tests/corpus/node24-deep-equality.ts",
@@ -101805,7 +101941,8 @@
"tests/corpus/text-codec-values/main.ts",
"tests/fixtures/node-types/text-codecs.mts",
"tests/harness/project-config.test.ts",
"tests/corpus/3133-text-decoder-streaming.ts"
"tests/corpus/3133-text-decoder-streaming.ts",
"tests/corpus/7747-text-codec-untyped-slot.js"
]
},
"anchorSource": "exact"
@@ -101926,7 +102063,8 @@
"tests/corpus/text-codec-values/main.ts",
"tests/fixtures/node-types/text-codecs.mts",
"tests/harness/project-config.test.ts",
"tests/corpus/3133-text-decoder-streaming.ts"
"tests/corpus/3133-text-decoder-streaming.ts",
"tests/corpus/7747-text-codec-untyped-slot.js"
]
},
"anchorSource": "exact"
@@ -102036,7 +102174,8 @@
"tests/corpus/text-codec-values/main.ts",
"tests/fixtures/node-types/text-codecs.mts",
"tests/harness/project-config.test.ts",
"tests/corpus/3133-text-decoder-streaming.ts"
"tests/corpus/3133-text-decoder-streaming.ts",
"tests/corpus/7747-text-codec-untyped-slot.js"
]
},
"anchorSource": "exact"
@@ -102065,7 +102204,8 @@
"tests/corpus/text-codec-values/main.ts",
"tests/fixtures/node-types/text-codecs.mts",
"tests/harness/project-config.test.ts",
"tests/corpus/3133-text-decoder-streaming.ts"
"tests/corpus/3133-text-decoder-streaming.ts",
"tests/corpus/7747-text-codec-untyped-slot.js"
]
},
"anchorSource": "exact"
@@ -111483,6 +111623,7 @@
"tests/corpus/2630-stream-consumers-errors.ts",
"tests/corpus/2862-web-readable-async-iteration.ts",
"tests/corpus/4875-stream-consumers-array-buffer.ts",
"tests/corpus/7743-transform-stream-identity.ts",
"tests/corpus/stream-web-readable.ts",
"tests/corpus/stream-web-require.cjs",
"tests/harness/fetch-conformance.test.ts"
@@ -112957,8 +113098,11 @@
"inherited": true
},
"static": {
"status": "not-implemented",
"evidence": "compiler-unmatched:webstreams"
"status": "partial",
"evidence": "compiler-feature:webstreams.TransformStream",
"tests": [
"tests/corpus/7743-transform-stream-identity.ts"
]
},
"anchorSource": "exact"
},
internal/compatibility/static-support.json
+6 -4
View File
@@ -332,11 +332,11 @@
{ "chapter": "buffer", "signatures": ["`buf.readBigInt64BE([offset])`", "`buf.readBigInt64LE([offset])`", "`buf.readBigUInt64BE([offset])`", "`buf.readBigUInt64LE([offset])`", "`buf.writeBigInt64BE(value[, offset])`", "`buf.writeBigInt64LE(value[, offset])`", "`buf.writeBigUInt64BE(value[, offset])`", "`buf.writeBigUInt64LE(value[, offset])`"], "status": "supported", "evidence": ["tests/corpus/2902-bigint-bytes.ts", "tests/corpus/2904-bigint-errors.ts"] },
{ "chapter": "environment_variables", "symbols": ["export"], "status": "not-applicable" },
{ "chapter": "globals", "symbols": ["fetch"], "status": "partial", "evidence": ["tests/harness/fetch-conformance.test.ts"] },
{ "chapter": "globals", "signatures": ["Class: `TextEncoder`", "Class: `TextDecoder`"], "status": "partial", "evidence": ["tests/corpus/1423-text-codec.ts", "tests/corpus/text-codec-values/main.ts", "tests/corpus/3133-text-decoder-streaming.ts"] },
{ "chapter": "globals", "signatures": ["Class: `TextEncoder`", "Class: `TextDecoder`"], "status": "partial", "evidence": ["tests/corpus/1423-text-codec.ts", "tests/corpus/text-codec-values/main.ts", "tests/corpus/3133-text-decoder-streaming.ts", "tests/corpus/7747-text-codec-untyped-slot.js"] },
{ "chapter": "globals", "signatures": ["Class: `Blob`", "Class: `File`"], "status": "partial", "evidence": ["tests/corpus/5285-blob-construct.ts", "tests/corpus/5286-blob-readers.ts", "tests/corpus/5287-blob-inspect.ts", "tests/corpus/5288-blob-validation.js", "tests/corpus/5290-blob-dynamic.js"] },
{ "chapter": "buffer", "signatures": ["Class: `Blob`", "Class: `File`"], "status": "partial", "evidence": ["tests/corpus/5285-blob-construct.ts", "tests/corpus/5288-blob-validation.js", "tests/fixtures/node-types/blob-file.ts"] },
{ "chapter": "buffer", "signatures": ["`blob.arrayBuffer()`", "`blob.bytes()`", "`blob.text()`", "`blob.slice([start[, end[, type]]])`", "`blob.size`", "`type` Type: {string}", "`name` Type: {string}", "`lastModified` Type: {number}"], "status": "supported", "evidence": ["tests/corpus/5285-blob-construct.ts", "tests/corpus/5286-blob-readers.ts", "tests/corpus/5288-blob-validation.js", "tests/corpus/5289-blob-read-order.ts", "tests/corpus/5290-blob-dynamic.js", "tests/fixtures/node-types/blob-file.ts"] },
{ "chapter": "util", "signatures": ["Class: `util.TextEncoder`", "Class: `util.TextDecoder`", "`textEncoder.encode([input])`", "`textDecoder.decode([input[, options]])`"], "status": "partial", "evidence": ["tests/corpus/text-codec-values/main.ts", "tests/fixtures/node-types/text-codecs.mts", "tests/harness/project-config.test.ts", "tests/corpus/3133-text-decoder-streaming.ts"] },
{ "chapter": "util", "signatures": ["Class: `util.TextEncoder`", "Class: `util.TextDecoder`", "`textEncoder.encode([input])`", "`textDecoder.decode([input[, options]])`"], "status": "partial", "evidence": ["tests/corpus/text-codec-values/main.ts", "tests/fixtures/node-types/text-codecs.mts", "tests/harness/project-config.test.ts", "tests/corpus/3133-text-decoder-streaming.ts", "tests/corpus/7747-text-codec-untyped-slot.js"] },
{ "chapter": "modules", "symbols": ["__dirname", "__filename", "exports", "require", "module.require", "main", "filename"], "status": "partial", "evidence": ["tests/corpus/1612-cjs-module-globals.cjs", "tests/corpus/1596-cjs-modules/main.js", "tests/corpus/1629-require-main-filename.cjs", "tests/corpus/2830-cjs-require-self-name/main.cjs", "tests/corpus/2880-cjs-module-graph/main.cjs", "tests/corpus/2923-cjs-factory-export/main.cjs"] },
{ "chapter": "modules", "symbols": ["require.resolve", "require.resolve.paths"], "status": "partial", "evidence": ["tests/corpus/2858-import-meta-resolve/main.mjs", "tests/corpus/2860-require-resolve/main.cjs"] },
{ "chapter": "modules", "symbols": ["cache", "children", "id", "isPreloading", "loaded", "parent", "path", "paths", "Module"], "status": "partial", "evidence": ["tests/corpus/2880-cjs-module-graph/main.cjs"] },
@@ -407,7 +407,9 @@
{ "chapter": "zlib", "signatures": ["`zlib.constants`"], "status": "partial", "evidence": ["tests/corpus/5376-zlib-constants.cjs", "tests/corpus/5374-zlib-stream-flush-params.ts"] },
{ "chapter": "dns", "symbols": ["dns.lookup", "dns.lookupService", "dns.getServers", "dns.getDefaultResultOrder", "dns.setDefaultResultOrder"], "status": "partial", "evidence": ["tests/corpus/5648-dns-lookup-forms.ts", "tests/corpus/5649-dns-service-servers.ts", "tests/corpus/5650-dns-lookup-errors-untyped.cjs"] },
{ "chapter": "dns", "symbols": ["dnsPromises.lookup", "dnsPromises.lookupService", "dnsPromises.getDefaultResultOrder"], "status": "partial", "evidence": ["tests/corpus/dns-promises-lookup.ts", "tests/corpus/dns-promises-untyped.cjs"] },
{ "chapter": "webstreams", "symbols": ["ReadableStream"], "status": "partial", "evidence": ["tests/corpus/stream-web-readable.ts", "tests/corpus/stream-web-require.cjs", "tests/corpus/2862-web-readable-async-iteration.ts"] }
{ "chapter": "webstreams", "symbols": ["ReadableStream"], "status": "partial", "evidence": ["tests/corpus/stream-web-readable.ts", "tests/corpus/stream-web-require.cjs", "tests/corpus/2862-web-readable-async-iteration.ts"] },
{ "chapter": "webstreams", "symbols": ["TransformStream"], "status": "partial", "evidence": ["tests/corpus/7743-transform-stream-identity.ts"] },
{ "chapter": "globals", "signatures": ["Class: `TransformStream`"], "status": "partial", "evidence": ["tests/corpus/7743-transform-stream-identity.ts"] }
],
"dedicated": [
{ "symbols": ["assert.doesNotThrow", "assert.doesNotReject"], "status": "partial", "evidence": ["tests/corpus/node24-no-error-assertions.ts", "tests/corpus/node24-no-error-assertions.cjs", "tests/corpus/node24-no-error-assertions-coercion.js", "tests/fixtures/node-types/no-error-assertions.ts", "tests/harness/project-config.test.ts"] },
@@ -439,7 +441,7 @@
{ "symbols": ["crypto.hkdf", "crypto.hkdfSync", "crypto.scrypt", "crypto.scryptSync"], "status": "partial", "evidence": ["tests/corpus/node24-crypto-kdf.ts", "tests/corpus/node24-crypto-kdf-errors.ts", "tests/corpus/node24-crypto-kdf-options.ts", "tests/corpus/5438-crypto-kdf-digests.ts"] },
{ "symbols": ["EventEmitter", "emitter.on", "emitter.addListener", "emitter.once", "emitter.prependListener", "emitter.prependOnceListener", "emitter.off", "emitter.removeListener", "emitter.removeAllListeners", "emitter.emit", "emitter.listenerCount", "emitter.listeners", "emitter.rawListeners", "emitter.eventNames", "emitter.setMaxListeners", "emitter.getMaxListeners", "events.once"], "status": "partial", "evidence": ["tests/corpus/1677-emitter-listeners.ts", "tests/corpus/2620-ee-override-once-order.ts"] },
{ "symbols": ["events.getEventListeners", "events.getMaxListeners", "events.listenerCount", "events.setMaxListeners", "events.defaultMaxListeners"], "status": "partial", "evidence": ["tests/corpus/5885-events-max-listener-helpers.ts", "tests/corpus/5846-events-esm-default-max.ts", "tests/corpus/5847-events-cjs-default-max.cjs"] },
{ "symbols": ["AsyncLocalStorage", "asyncLocalStorage.run", "asyncLocalStorage.exit", "asyncLocalStorage.getStore", "asyncLocalStorage.enterWith", "asyncLocalStorage.disable"], "status": "partial", "evidence": ["tests/corpus/2213-async-local-storage.cjs", "tests/corpus/5815-als-callback-context.ts"] },
{ "symbols": ["AsyncLocalStorage", "asyncLocalStorage.run", "asyncLocalStorage.exit", "asyncLocalStorage.getStore", "asyncLocalStorage.enterWith", "asyncLocalStorage.disable", "asyncLocalStorage.name", "AsyncLocalStorage.bind", "AsyncLocalStorage.snapshot"], "status": "partial", "evidence": ["tests/corpus/2213-async-local-storage.cjs", "tests/corpus/5815-als-callback-context.ts", "tests/corpus/7110-als-completion-callbacks.ts", "tests/corpus/7111-als-bind-snapshot-options.ts", "tests/corpus/7112-als-bind-snapshot-dynamic.mjs", "tests/corpus/7119-als-net-event-context.mjs", "tests/corpus/7380-als-http-event-context.mjs", "tests/corpus/7383-als-stream-events.ts", "tests/corpus/7384-als-stream-events.mjs", "tests/corpus/7385-als-child-process-events.ts", "tests/corpus/7386-als-child-fork-events/main.mjs", "tests/corpus/7387-als-http2-events.mjs", "tests/corpus/7388-als-http2-compat-events.mjs", "tests/corpus/7389-als-http2-secure-events.mjs", "tests/corpus/7391-als-response-end-and-finished.mjs"] },
{ "symbols": ["StringDecoder", "stringDecoder.write", "stringDecoder.end"], "status": "partial", "evidence": ["tests/corpus/1662-string-decoder-encodings.ts", "tests/corpus/node24-string-decoder.ts", "tests/corpus/5882-string-decoder-runtime-encoding.ts"] },
{ "symbols": ["setImmediate", "setInterval", "setTimeout", "clearImmediate", "clearInterval", "clearTimeout", "timersPromises.setTimeout", "timersPromises.setImmediate", "timersPromises.setInterval", "immediate.hasRef", "immediate.ref", "immediate.unref", "timeout.hasRef", "timeout.ref", "timeout.unref", "timeout.refresh"], "status": "partial", "evidence": ["tests/corpus/1804-timers-module.ts", "tests/corpus/1805-timer-callback-args.ts", "tests/corpus/2093-timers-promises.ts", "tests/corpus/2852-timers-promises-interval.ts", "tests/corpus/5830-timers-promises-signal.ts"] },
{ "symbols": ["timersPromises.scheduler.wait", "timersPromises.scheduler.yield"], "status": "partial", "evidence": ["tests/corpus/5839-timers-promises-scheduler.ts", "tests/corpus/5889-timers-scheduler-signal.ts"] },
packages/cli-darwin-arm64/package.json
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@scriptc/cli-darwin-arm64",
"version": "0.4.2",
"version": "0.4.3",
"description": "Native scriptc compiler for darwin-arm64",
"license": "Apache-2.0",
"homepage": "https://scriptc.dev",
packages/cli-darwin-x64/package.json
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@scriptc/cli-darwin-x64",
"version": "0.4.2",
"version": "0.4.3",
"description": "Native scriptc compiler for darwin-x64",
"license": "Apache-2.0",
"homepage": "https://scriptc.dev",
packages/cli-linux-arm64-gnu/package.json
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@scriptc/cli-linux-arm64-gnu",
"version": "0.4.2",
"version": "0.4.3",
"description": "Native scriptc compiler for linux-arm64-gnu",
"license": "Apache-2.0",
"homepage": "https://scriptc.dev",
packages/cli-linux-arm64-musl/package.json
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@scriptc/cli-linux-arm64-musl",
"version": "0.4.2",
"version": "0.4.3",
"description": "Native scriptc compiler for linux-arm64-musl",
"license": "Apache-2.0",
"homepage": "https://scriptc.dev",
packages/cli-linux-x64-gnu/package.json
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@scriptc/cli-linux-x64-gnu",
"version": "0.4.2",
"version": "0.4.3",
"description": "Native scriptc compiler for linux-x64-gnu",
"license": "Apache-2.0",
"homepage": "https://scriptc.dev",
packages/cli-linux-x64-musl/package.json
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@scriptc/cli-linux-x64-musl",
"version": "0.4.2",
"version": "0.4.3",
"description": "Native scriptc compiler for linux-x64-musl",
"license": "Apache-2.0",
"homepage": "https://scriptc.dev",
packages/cli-win32-x64-msvc/package.json
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@scriptc/cli-win32-x64-msvc",
"version": "0.4.2",
"version": "0.4.3",
"description": "Native scriptc compiler for win32-x64-msvc",
"license": "Apache-2.0",
"homepage": "https://scriptc.dev",
packages/cli/package.json
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "scriptc",
"version": "0.4.2",
"version": "0.4.3",
"description": "Compile ordinary TypeScript and JavaScript to small, fast native executables and WebAssembly modules that run without Node.js",
"license": "Apache-2.0",
"homepage": "https://scriptc.dev",
packages/compiler/ambient/scriptc-node-fallback.d.ts
Vendored
+62 -2
View File
@@ -1106,6 +1106,34 @@ declare var ReadableStream: {
from(iterable: string): ReadableStream<string>;
readonly prototype: ReadableStream<unknown>;
};
/* The writable side of a TransformStream and its writer. The
* WritableStream constructor has no native lowering; writable streams come
* from `new TransformStream()`. */
interface WritableStreamDefaultWriter<W = unknown> {
readonly closed: Promise<void>;
readonly desiredSize: number | null;
readonly ready: Promise<void>;
abort(reason?: unknown): Promise<void>;
close(): Promise<void>;
releaseLock(): void;
write(chunk?: W): Promise<void>;
}
interface WritableStream<W = unknown> {
readonly locked: boolean;
abort(reason?: unknown): Promise<void>;
close(): Promise<void>;
getWriter(): WritableStreamDefaultWriter<W>;
}
/* The identity transform: chunks written to `writable` are read from
* `readable`, and a write completes when its chunk is read. */
interface TransformStream<I = unknown, O = unknown> {
readonly readable: ReadableStream<O>;
readonly writable: WritableStream<I>;
}
declare var TransformStream: {
new <I = unknown, O = I>(): TransformStream<I, O>;
readonly prototype: TransformStream<unknown, unknown>;
};
/* fetch, typed as the native JSON + readable-stream slice: one URL, an
* optional init with the members CLI requests carry, and a Response
@@ -2964,6 +2992,24 @@ declare module "crypto" {
options: ED25519KeyPairOptions<"der", "der">,
): KeyPairSyncResult<Buffer, Buffer>;
export function generateKeyPairSync(type: "ed25519", options?: {}): KeyPairKeyObjectResult;
export interface X25519KeyPairOptions<PubF extends KeyFormat, PrivF extends KeyFormat> {
publicKeyEncoding: { type: "spki"; format: PubF };
privateKeyEncoding: { type: "pkcs8"; format: PrivF };
}
export function generateKeyPairSync(
type: "x25519",
options: X25519KeyPairOptions<"pem", "pem">,
): KeyPairSyncResult<string, string>;
export function generateKeyPairSync(
type: "x25519",
options: X25519KeyPairOptions<"der", "der">,
): KeyPairSyncResult<Buffer, Buffer>;
export function generateKeyPairSync(type: "x25519", options?: {}): KeyPairKeyObjectResult;
export function generateKeyPair(
type: "x25519",
options: {} | undefined,
callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void,
): void;
export function generateKeyPair(
type: "ed25519",
options: {} | undefined,
@@ -2992,6 +3038,11 @@ declare module "crypto" {
export interface VerifyKeyObjectInput extends SigningOptions {
key: KeyObject;
}
export function diffieHellman(options: { privateKey: KeyObject; publicKey: KeyObject }): Buffer;
export function diffieHellman(
options: { privateKey: KeyObject; publicKey: KeyObject },
callback: (err: Error | null, secret: Buffer) => void,
): void;
export function sign(
algorithm: string | null | undefined,
data: ArrayBufferView,
@@ -7207,9 +7258,18 @@ declare module "node:tty" {
declare module "async_hooks" {
/* AsyncLocalStorage: fiber-carried context snapshots — run/getStore/
* exit/enterWith/disable lower onto the runtime's active-slot machinery
* (als.* libCalls); values cross as dyn values. */
* (als.* libCalls); values cross as dyn values. bind and snapshot bind
* functions to the active context; the options carry the store's
* default value and name. */
export interface AsyncLocalStorageOptions {
defaultValue?: any;
name?: string | undefined;
}
export class AsyncLocalStorage<T = any> {
constructor();
constructor(options?: AsyncLocalStorageOptions);
static bind<Func extends (...args: any[]) => any>(fn: Func): Func;
static snapshot(): <R, TArgs extends any[]>(fn: (...args: TArgs) => R, ...args: TArgs) => R;
readonly name: string;
run<R>(store: T, callback: (...args: any[]) => R, ...args: any[]): R;
exit<R>(callback: (...args: any[]) => R, ...args: any[]): R;
getStore(): T | undefined;
packages/compiler/package.json
+2 -2
View File
@@ -1,6 +1,6 @@
{
"name": "@scriptc/compiler",
"version": "0.4.2",
"version": "0.4.3",
"description": "The scriptc compiler — TypeScript/JavaScript frontend, typed IR, LLVM backend",
"license": "Apache-2.0",
"homepage": "https://scriptc.dev",
@@ -40,7 +40,7 @@
},
"dependencies": {
"@scriptc/runtime": "workspace:*",
"tsc-ts": "0.0.8",
"tsc-ts": "0.0.9",
"typescript": "7.0.2",
"typescript5": "npm:typescript@5.9.3"
},
packages/compiler/src/backend/executable-features.ts
+1
View File
@@ -50,6 +50,7 @@ export function executableLinkFeatures(mod: IrModule): NativeLinkFeatures {
dgram: features.dgram,
dnsPromises: features.dnsPromises,
dgramDyn: features.dgramDyn,
textCodecDyn: features.textCodecDyn,
watch: features.fsWatch,
foreignFfi: hasForeignFfiCallback(mod.ffiImports ?? []),
nodeTest: features.nodeTest,
packages/compiler/src/backend/library-pack.ts
+1
View File
@@ -54,6 +54,7 @@ export async function compilePackedLibrary(
dgram: false,
dnsPromises: false,
dgramDyn: false,
textCodecDyn: false,
watch: false,
foreignFfi: false,
nodeTest: false,
packages/compiler/src/backend/llvm/alloc.ts
+65 -12
View File
@@ -459,18 +459,72 @@ export type FreeObservers = "weak" | "weak-or-source";
* type's disposals), and the block — `scr_cyc_free` for collector-headered
* objects, `scr_rt_free` otherwise. Labels use the `sf.` prefix; the lines
* end in an open block.
*
* With `keep` (an alloca of ptr holding NULL; inline allocation paths only),
* a block that would go onto the calling thread's free list is stored there
* instead, for a teardown segment (emitSegmentFree); a block the system or
* another arena owns is still freed.
*/
export function emitObjectFree(
host: AllocHost,
cyc: boolean,
observers: FreeObservers = "weak",
keep: string | null = null,
): string[] {
const lines = threadLocalState(host, "sf", freeLines(host, cyc, observers));
const lines = threadLocalState(host, "sf", freeLines(host, cyc, observers, keep));
if (host.objectAudit === false) return lines.filter((line) => line !== FREE_NOTE);
host.declare(`declare void @scr_obj_free_note()`);
return lines;
}
/** Lines that put the blocks `first` to `last` (linked through their first
* words; one block when they are equal) of the class at reservation offset
* `off` on the calling thread's free list. */
function freeListPushLines(prefix: string, off: string, first: string, last: string): string[] {
return [
` %${prefix}.shp = getelementptr inbounds i8, ptr @scr_sa, i64 ${SA_SHIFT}`,
` %${prefix}.sh32 = load i32, ptr %${prefix}.shp`,
` %${prefix}.sh = zext i32 %${prefix}.sh32 to i64`,
` %${prefix}.c = lshr i64 ${off}, %${prefix}.sh`,
` %${prefix}.c8 = shl i64 %${prefix}.c, 3`,
` %${prefix}.fo = add i64 %${prefix}.c8, ${SA_FREE}`,
` %${prefix}.fp = getelementptr inbounds i8, ptr @scr_sa, i64 %${prefix}.fo`,
` %${prefix}.head = load ptr, ptr %${prefix}.fp`,
` store ptr %${prefix}.head, ptr ${last}`,
` store ptr ${first}, ptr %${prefix}.fp`,
];
}
/**
* Lines that free a teardown segment: the blocks `first` to `last` (ptr
* values, both NULL for an empty segment), linked through their first words,
* which emitObjectFree kept. Every block of a segment is in the calling
* thread's arena and of one size class, so the segment goes onto that
* class's free list in one step, and the next allocations of the class take
* its blocks in segment order. Labels use `prefix`; the lines end in the
* open block `${prefix}.done`.
*/
export function emitSegmentFree(
host: AllocHost,
prefix: string,
first: string,
last: string,
): string[] {
declareState(host);
const lines = [
` %${prefix}.none = icmp eq ptr ${first}, null`,
` br i1 %${prefix}.none, label %${prefix}.done, label %${prefix}.push`,
`${prefix}.push:`,
` %${prefix}.base = load i64, ptr @scr_sa`,
` %${prefix}.bi = ptrtoint ptr ${first} to i64`,
` %${prefix}.off = sub i64 %${prefix}.bi, %${prefix}.base`,
...freeListPushLines(prefix, `%${prefix}.off`, first, last),
` br label %${prefix}.done`,
`${prefix}.done:`,
];
return threadLocalState(host, prefix, lines);
}
/** Lines that leave in `%<prefix>.obs` whether the program can observe a
* disposal of this type (folds to a constant). */
function observedLines(prefix: string, observers: FreeObservers): string[] {
@@ -482,8 +536,14 @@ function observedLines(prefix: string, observers: FreeObservers): string[] {
];
}
function freeLines(host: AllocHost, cyc: boolean, observers: FreeObservers): string[] {
function freeLines(
host: AllocHost,
cyc: boolean,
observers: FreeObservers,
keep: string | null,
): string[] {
if (host.inlineAlloc !== true) {
if (keep !== null) throw new Error("a kept block needs the inline allocation paths");
if (cyc) {
host.declare(`declare void @scr_cyc_free(ptr)`);
return [` call void @scr_obj_free_note()`, ` call void @scr_cyc_free(ptr %o)`];
@@ -548,16 +608,9 @@ function freeLines(host: AllocHost, cyc: boolean, observers: FreeObservers): str
` %sf.inx = call i1 @llvm.expect.i1(i1 %sf.in, i1 true)`,
` br i1 %sf.inx, label %sf.push, label %sf.sys`,
`sf.push:`,
` %sf.shp = getelementptr inbounds i8, ptr @scr_sa, i64 ${SA_SHIFT}`,
` %sf.sh32 = load i32, ptr %sf.shp`,
` %sf.sh = zext i32 %sf.sh32 to i64`,
` %sf.c = lshr i64 %sf.off, %sf.sh`,
` %sf.c8 = shl i64 %sf.c, 3`,
` %sf.fo = add i64 %sf.c8, ${SA_FREE}`,
` %sf.fp = getelementptr inbounds i8, ptr @scr_sa, i64 %sf.fo`,
` %sf.head = load ptr, ptr %sf.fp`,
` store ptr %sf.head, ptr ${blk}`,
` store ptr ${blk}, ptr %sf.fp`,
...(keep !== null
? [` store ptr ${blk}, ptr ${keep}`]
: freeListPushLines("sf", "%sf.off", blk, blk)),
` br label %sf.done`,
`sf.sys: ; outside the reservation, or the allocator is compiled out`,
` call void @scr_obj_free_note()`,
packages/compiler/src/backend/llvm/bytes-alias.ts
+8 -2
View File
@@ -7,9 +7,15 @@ import type { LlvmEmitterContext } from "./expr-context.js";
* buffer. Neither overlaps the other, a native field, array storage or a
* module global's slot, so element stores leave header loads and global
* receiver slots loop-invariant. Untagged accesses and calls still alias
* every category. */
* every category.
*
* Header loads are also `!invariant.load`: no store or call between the
* construction of a view and its release changes them. Without it, a data
* pointer load ahead of a bounds branch is sunk into the in-bounds block,
* and LICM keeps a conditionally executed load inside the loop. */
export function bytesHeaderAlias(host: LlvmEmitterContext): string {
return host.memoryAliasAttachment("bytes:header");
const tag = host.memoryAliasAttachment("bytes:header");
return tag === "" ? "" : `${tag}, !invariant.load !{}`;
}
export function bytesElementAlias(host: LlvmEmitterContext): string {
packages/compiler/src/backend/llvm/bytes-loop-versions.test.ts
+81 -1
View File
@@ -11,7 +11,7 @@ import {
type IrType,
} from "../../ir/ir.js";
import { analyzeIntegerRanges } from "../../ir/integer-ranges.js";
import { matchIntegerCountedForLoop } from "../../ir/integer-loops.js";
import { matchIntegerCountedForLoop, matchIntegerPairedForLoop } from "../../ir/integer-loops.js";
import { findInitializedByteLoopBindings } from "./byte-windows.js";
import { matchBytesLoopVersion, type BytesLoopVersion } from "./bytes-loop-versions.js";
import { emitLlvmModule } from "./emitter.js";
@@ -249,6 +249,11 @@ test("emitted loops version the body and tag typed-array memory", () => {
const elements = /store double [^\n]*!tbaa !(\d+)/.exec(body)![1];
const header = /load ptr, ptr [^\n]*!tbaa !(\d+)/.exec(body)![1];
expect(elements).not.toBe(header);
// Header loads are invariant for the view's lifetime; element accesses
// are not.
expect(body).toMatch(/load ptr, ptr [^\n]*, !tbaa !\d+, !invariant\.load !\{\}$/m);
expect(body).toMatch(/load i64, ptr [^\n]*, !tbaa !\d+, !invariant\.load !\{\}$/m);
expect(body).not.toMatch(/(load double|store double)[^\n]*invariant\.load/);
});
test("loops to a typed array's length version the other typed arrays they index", () => {
@@ -618,3 +623,78 @@ test("while loop counters below a string's length version its reads", () => {
expect(version.bounded.map((c) => c.slack)).toEqual([0]);
expect(version.fixed).toEqual([]);
});
test("a two-counter loop versions the typed arrays it indexes at either counter", () => {
// for (let i = 0, j = k; i < j; i++, j--) { const t = out[i]; out[i] = out[j]; out[j] = t; }
const loop: IrStmt & { kind: "for" } = {
kind: "for",
init: {
kind: "block",
body: [
{ kind: "varDecl", localId: "i", init: num(0), loc },
{ kind: "varDecl", localId: "j", init: ref("k"), loc },
],
loc,
},
cond: { kind: "bin", op: "<", left: ref("i"), right: ref("j"), type: BOOL, loc },
update: {
kind: "block",
body: [
{ kind: "assign", localId: "i", value: bin("+", ref("i"), num(1)), loc },
{ kind: "assign", localId: "j", value: bin("-", ref("j"), num(1)), loc },
],
loc,
},
body: [
{ kind: "varDecl", localId: "t", init: get(ref("out", f64s), ref("i")), loc },
set(ref("out", f64s), ref("i"), get(ref("out", f64s), ref("j"))),
set(ref("out", f64s), ref("j"), ref("t")),
// Another index stays checked.
set(ref("src", f64s), bin("+", ref("i"), num(1)), num(0)),
],
loc,
};
const kernel = fn([loop], [local("t", F64)]);
const ranges = analyzeIntegerRanges(kernel);
const locals = new Map(kernel.locals.map((l) => [l.id, l]));
const paired = matchIntegerPairedForLoop(loop, locals, ranges)!;
expect(paired).not.toBeNull();
const version = matchBytesLoopVersion(
loop,
null,
{
locals,
invariantGlobals: new Set(),
captured: new Set(),
ranges,
initialized: findInitializedByteLoopBindings(kernel).get(loop) ?? new Set(),
proven: new Set(),
workers: false,
owned: new Set(),
scalarStrings: new Set(),
},
paired,
)!;
expect(version.paired?.loop).toBe(paired);
expect(version.paired?.receivers.map((r) => version.receivers[r]!.ref)).toEqual([
ref("out", f64s),
]);
expect(version.bounds.size).toBe(4);
const mod: IrModule = {
irVersion: 17,
sourceFile: loc.file,
entry: "__main",
functions: [
{ name: "__main", params: [], returnType: VOID, locals: [], body: [], loc },
kernel,
],
};
const body = /^define internal [^\n]*@sc_bf_kernel[^]*?^}/m.exec(emitLlvmModule(mod))![0];
const guard = body.slice(0, body.search(/^bytes\.version\.(fast|slow)\d+:$/m));
expect(guard).toMatch(/icmp sge i64 %\S+, 0/);
expect(guard).toMatch(/icmp slt i64 %\S+, %\S+/);
const fast = /^bytes\.version\.fast\d+:$[^]*?^bytes\.version\.done\d+:$/m.exec(body)![0];
// The fast copy keeps only the `src[i + 1]` check, and no second guard.
expect(fast.match(/bytes\.index\.invalid\d+:/g)).toHaveLength(1);
expect(fast).not.toContain("counted.fast");
});
packages/compiler/src/backend/llvm/bytes-loop-versions.ts
+61 -36
View File
@@ -1,11 +1,15 @@
import { F64, type IrExpr, type IrLocal, type IrStmt } from "../../ir/ir.js";
import type { IntegerRange, IntegerRanges } from "../../ir/integer-ranges.js";
import type { IntegerCountedForLoop } from "../../ir/integer-loops.js";
import type { IntegerCountedForLoop, IntegerPairedForLoop } from "../../ir/integer-loops.js";
import type { LlvmEmitterContext } from "./expr-context.js";
import { byteNumberAccess } from "../../ir/byte-numbers.js";
import { everyExprChild, everyStmtChild } from "../../ir/traverse.js";
import { exactInteger, widenInteger } from "./integer-values.js";
import { emitCountedLoopLimit, emitCountedLoopSafety } from "./counted-loops.js";
import {
emitCountedLoopLimit,
emitCountedLoopSafety,
emitExactIntegerTest,
} from "./counted-loops.js";
import { emitBytesHeaderLength, emitBytesSharedStorage } from "./expr-bytes.js";
import { f64Lit } from "./common.js";
import { emitStringAsciiFlag, emitStringByteLength } from "./string-reads.js";
@@ -79,6 +83,10 @@ export interface BytesLoopVersion {
guarded: ReadonlySet<string>;
/** The counted loop whose iteration space the affine checks cover. */
counted: IntegerCountedForLoop | null;
/** A two-counter loop (`for (let i = lo, j = hi; i < j; i++, j--)`) and
* the receivers it indexes at either counter. Both counters stay between
* the two starts, so the guard requires `lo >= 0` and `hi < length`. */
paired: { loop: IntegerPairedForLoop; receivers: number[] } | null;
/** The guard also requires every counter value within [-bound, bound]. */
counterBound: number | null;
/** Integer ranges of affine index operands that hold in the unchecked
@@ -153,6 +161,7 @@ export function matchBytesLoopVersion(
loop: IrStmt & { kind: "for" | "while" },
counted: IntegerCountedForLoop | null,
facts: BytesLoopFacts,
paired: IntegerPairedForLoop | null = null,
): BytesLoopVersion | null {
const written = new Set<string>();
const temps = new Map<string, IrExpr>();
@@ -438,6 +447,9 @@ export function matchBytesLoopVersion(
string,
{ check: BoundedCheck; nodes: { node: Node; access: WhileAccess }[] }
>();
const pairedCounters =
paired !== null && counted === null ? new Set([paired.low.localId, paired.high.localId]) : null;
const pairedNodes = new Map<number, Node[]>();
const access = (node: Node, array: IrExpr, index: IrExpr, width: number): void => {
const ref = root(array);
if (!ref) return;
@@ -448,6 +460,20 @@ export function matchBytesLoopVersion(
else owned.set(receiver, [node]);
}
if (facts.proven.has(node)) return;
// An element at either counter of a two-counter loop.
if (
pairedCounters !== null &&
width === 1 &&
ref.type.kind === "bytes" &&
index.kind === "varRef" &&
pairedCounters.has(index.localId)
) {
const receiver = receiverOf(ref);
const nodes = pairedNodes.get(receiver);
if (nodes) nodes.push(node);
else pairedNodes.set(receiver, [node]);
return;
}
const shape = counter !== null ? affine(index) : null;
if (shape && shape.counter !== 0) {
const operands = new Set<IrExpr>();
@@ -543,11 +569,16 @@ export function matchBytesLoopVersion(
Math.max(0, MAX_CHECKS - fixedKept.length - affineKept.length),
);
const ownedKept = [...owned.entries()].slice(0, MAX_CHECKS);
const pairedKept = [...pairedNodes.entries()].slice(
0,
Math.max(0, MAX_CHECKS - fixedKept.length - affineKept.length - boundedKept.length),
);
if (
fixedKept.length === 0 &&
affineKept.length === 0 &&
boundedKept.length === 0 &&
ownedKept.length === 0
ownedKept.length === 0 &&
pairedKept.length === 0
)
return null;
const bounds = new Set<Node>();
@@ -616,6 +647,10 @@ export function matchBytesLoopVersion(
if (access.index !== access.ref) narrow(access.index, { min: 0, max: SAFE });
}
}
for (const [receiver, nodes] of pairedKept) {
used.add(receiver);
for (const node of nodes) bounds.add(node);
}
const counterChecks: CounterCheck[] = [];
for (const [id, min] of counterMins) {
const info = whileAccesses!.counters.get(id)!;
@@ -658,6 +693,10 @@ export function matchBytesLoopVersion(
counters: counterChecks,
guarded,
counted: affineKept.length > 0 ? counted : null,
paired:
paired !== null && pairedKept.length > 0
? { loop: paired, receivers: pairedKept.map(([receiver]) => renumber.get(receiver)!) }
: null,
counterBound: needsBound ? bound : null,
ranges,
};
@@ -1143,6 +1182,25 @@ export function emitBytesLoopVersionGuard(
conditions.push(both);
}
}
if (version.paired !== null) {
// Both counters stay within [lo, hi] (exact integers below 2^53): every
// access at either one is in bounds when `lo >= 0` and `hi < length`.
const { loop } = version.paired;
const [low, high] = [loop.low.start, loop.high.start].map((expr) => {
const tested = emitExactIntegerTest(host, host.emitExpr(expr).name, -SAFE, SAFE);
conditions.push(tested.ok);
return tested.integer;
});
const nonNegative = B.tmp();
B.line(`${nonNegative} = icmp sge i64 ${low}, 0`);
conditions.push(nonNegative);
for (const receiver of version.paired.receivers) {
// Lengths are at most 2^53 elements: a signed comparison is exact.
const below = B.tmp();
B.line(`${below} = icmp slt i64 ${high}, ${lengths[receiver]}`);
conditions.push(below);
}
}
let valid = "true";
for (const cond of conditions) {
if (valid === "true") valid = cond;
@@ -1156,39 +1214,6 @@ export function emitBytesLoopVersionGuard(
else B.condBr(valid, fast, slow);
}
/** Tests that a double is an exact integer within [min, max] (not -0; NaN
* fails the ordered comparisons) and gives its i64. The integer is frozen,
* so it is a fixed value even when the test fails. */
function emitExactIntegerTest(
host: LlvmEmitterContext,
value: string,
min: number,
max: number,
): { ok: string; integer: string } {
const B = host.B;
const low = B.tmp(),
high = B.tmp(),
inRange = B.tmp(),
raw = B.tmp(),
integer = B.tmp(),
back = B.tmp(),
bits = B.tmp(),
backBits = B.tmp(),
exact = B.tmp(),
ok = B.tmp();
B.line(`${low} = fcmp oge double ${value}, ${f64Lit(min)}`);
B.line(`${high} = fcmp ole double ${value}, ${f64Lit(max)}`);
B.line(`${inRange} = and i1 ${low}, ${high}`);
B.line(`${raw} = fptosi double ${value} to i64`);
B.line(`${integer} = freeze i64 ${raw}`);
B.line(`${back} = sitofp i64 ${integer} to double`);
B.line(`${bits} = bitcast double ${value} to i64`);
B.line(`${backBits} = bitcast double ${back} to i64`);
B.line(`${exact} = icmp eq i64 ${bits}, ${backBits}`);
B.line(`${ok} = and i1 ${inRange}, ${exact}`);
return { ok, integer };
}
function scaleCounter(host: LlvmEmitterContext, value: string, scale: number): string {
if (scale === 1) return value;
const scaled = host.B.tmp();
packages/compiler/src/backend/llvm/classes.test.ts
+59
View File
@@ -77,6 +77,65 @@ test("leaf layouts keep direct teardown while recursive layouts share the depth
}
});
test("teardowns of types with children of their own type free their blocks as one segment", () => {
const linked = { kind: "object" as const, className: "Linked" };
const mod: IrModule = {
irVersion: 17,
sourceFile: loc.file,
entry: "main",
functions: [{ name: "main", params: [], returnType: VOID, locals: [], body: [], loc }],
classes: [
{
name: "Linked",
fields: [
{ name: "next", type: linked },
{ name: "other", type: linked },
],
methods: [],
loc,
},
],
records: [{ id: "branch", fields: [{ name: "next", type: linked }] }],
};
const define = (llvm: string, name: string): string =>
new RegExp(`^define internal [^@]*@${name}\\([^]*?^}`, "m").exec(llvm)?.[0] ?? "";
const linkedDestroy = `${mangleClassRelease("Linked")}_destroy`;
const branchDestroy = `${mangleRecordRelease("branch")}_destroy`;
for (const workers of [false, true]) {
const llvm = emitLlvmModule({ ...mod, workers }, { pointerBits: 64 });
// Linked's teardown keeps its block and its children's in a segment: it
// releases its own block first and places it by address against its
// first child, a child torn down directly appends to the segment, one
// past the direct chain appends through the runtime, and the chain's
// first teardown frees the segment onto the free list in one step.
const seg = define(llvm, `${linkedDestroy}_s`);
expect(seg.startsWith("define internal ptr"), "segment form").toBe(true);
expect(seg).toMatch(
/store ptr %(?:sf\.blk|o), ptr %sg\.own[^]*call ptr @sc_release_Linked_destroy_s\(/,
);
// The children's releases have a copy for each place of the own block.
for (const copy of ["ta", "tb"])
expect(seg).toContain(
`call ptr @scr_rc_destroy_seg(ptr %v0, ptr @${linkedDestroy}_sc, ptr @${linkedDestroy}, ptr %${copy}0.bt)`,
);
expect(seg).not.toContain("call void @scr_rc_destroy(");
expect(seg).toContain("icmp ult ptr %sg.o, %sg.r1");
const first = define(llvm, `${linkedDestroy}_d`);
expect(first).toContain(`call ptr @${linkedDestroy}_s(ptr %o, i32 %d, ptr %head)`);
expect(first).toContain("store ptr %first, ptr %sgf.fp");
expect(first.includes("llvm.threadlocal.address"), "thread-local state").toBe(workers);
expect(define(llvm, linkedDestroy)).toContain(`call void @${linkedDestroy}_d(ptr %o, i32 0)`);
// A record whose child is another type frees its own block as before.
expect(define(llvm, `${branchDestroy}_s`)).toBe("");
expect(define(llvm, branchDestroy)).toContain(`call void @${mangleClassRelease("Linked")}(`);
}
// Without the inline allocation paths (32-bit targets) a teardown frees
// through the runtime, block by block.
const llvm32 = emitLlvmModule(mod, { pointerBits: 32 });
expect(define(llvm32, `${linkedDestroy}_s`)).toBe("");
expect(define(llvm32, `${linkedDestroy}_d`)).toContain(`call void @${linkedDestroy}_d(`);
});
test("releases split into an inlinable fast path and an out-of-line remainder", () => {
// An array of the class itself makes the hierarchy cycle-capable.
const kids = { kind: "array" as const, elem: { kind: "object" as const, className: "Node" } };
packages/compiler/src/backend/llvm/classes.ts
+58 -15
View File
@@ -43,6 +43,9 @@ import {
destroyDefinitions,
directChildReleaseLines,
directDestroyTarget,
segmentPrologueLines,
segmentTeardownLines,
segmentedTeardown,
usedDirectTargets,
type DirectDestroy,
type RegionHooks,
@@ -1082,25 +1085,62 @@ export function emitClassShapes(
bounded &&
(directTargets.has(`object:${cls.name}`) ||
refFields.some((f) => directDestroyTarget(host, f.type, directTargets) !== null));
// The teardown's own symbol, and whether it keeps a segment (shapes.ts
// segmentedTeardown).
const destroy = `${meta.hierarchy ? mangleClassReleaseDirect(cls.name) : mangleClassRelease(cls.name)}_destroy`;
const segmented =
chained &&
!meta.compact &&
runtimePrefix === null &&
!isStreamRooted &&
!meta.threadSlot &&
segmentedTeardown(
host,
destroy,
refFields.map((f) => f.type),
directTargets,
);
// The field-releasing teardown body shared by both release shapes
// (the public one on standalone classes, the DIRECT one on hierarchy
// members). Runs at rc == 0.
const teardown = (lines: string[]): void => {
refFields.forEach((f, t) => {
lines.push(
` %f${t} = getelementptr inbounds %${struct}, ptr %o, i64 0, i32 ${f.index}`,
` %v${t} = load ptr, ptr %f${t}`,
);
const release = (prefix: string, f: (typeof refFields)[number], t: number): string[] => {
const direct = bounded ? directDestroyTarget(host, f.type, directTargets) : null;
if (direct)
lines.push(
...directChildReleaseLines(host, `td${t}`, `%v${t}`, direct, llvmCommentText(f.name)),
);
else
lines.push(
if (direct === null)
return [
` call void ${releaseSym(host, f.type)}(ptr %v${t}) ; ${llvmCommentText(f.name)}`,
);
});
];
const own = segmented && direct.destroy === destroy;
return directChildReleaseLines(
host,
`${prefix}${t}`,
`%v${t}`,
direct,
llvmCommentText(f.name),
own,
);
};
const loads = refFields.map((f, t) => [
` %f${t} = getelementptr inbounds %${struct}, ptr %o, i64 0, i32 ${f.index}`,
` %v${t} = load ptr, ptr %f${t}`,
]);
if (segmented) {
// A segmented teardown loads its fields, releases its own block, and
// then releases the fields (shapes.ts segmentTeardownLines).
const ownType = refFields.flatMap((f, t) =>
directDestroyTarget(host, f.type, directTargets)?.destroy === destroy ? [`%v${t}`] : [],
);
lines.push(
...segmentPrologueLines(),
...loads.flat(),
...emitObjectFree(host, traced, "weak", "%sg.own"),
...segmentTeardownLines(ownType, (prefix) =>
refFields.flatMap((f, t) => release(prefix, f, t)),
),
);
return;
}
refFields.forEach((f, t) => lines.push(...loads[t]!, ...release("td", f, t)));
if (runtimePrefix) lines.push(...regCall("td", runtimePrefix.drop, ""));
if (isStreamRooted) lines.push(...stCall("tds", "scr_stream_st_release", ""));
if (meta.threadSlot) lines.push(...slotForgetLines(host, struct, meta, "tdw"));
@@ -1182,10 +1222,12 @@ export function emitClassShapes(
];
if (traced) reld.push(...cycleDeadLines(host, "teardown"));
if (bounded) {
const destroy = `${mangleClassReleaseDirect(cls.name)}_destroy`;
const destroyBody: string[] = [];
teardown(destroyBody);
defs.push(...destroyDefinitions(destroy, destroyBody, chained), ``);
defs.push(
...destroyDefinitions(destroy, destroyBody, chained, segmented ? host : null),
``,
);
host.declare(`declare void @scr_rc_destroy(ptr, ptr)`);
reld.push(` call void @scr_rc_destroy(ptr %o, ptr @${destroy})`);
} else teardown(reld);
@@ -1207,6 +1249,7 @@ export function emitClassShapes(
bounded,
lifetime,
chained,
segmented,
),
``,
);
packages/compiler/src/backend/llvm/common.ts
+3
View File
@@ -29,6 +29,9 @@ export const SCR_ARR_FIELD = {
* (SCR_ARR_STATES in scr_array.h). */
export const SCR_ARR_STATES = 16;
/** The `spare` flag of a frozen %ScrArr (SCR_ARR_FROZEN in scr_array.h). */
export const SCR_ARR_FROZEN = 32;
/** Loads the i32 `len` or `cap` of a %ScrArr at `ptr` into `dest` as a
* size-type count. */
export function loadArrCount(
packages/compiler/src/backend/llvm/counted-loops.ts
+33
View File
@@ -151,3 +151,36 @@ function emitExactStart(host: LlvmEmitterContext, expr: IrExpr): string {
B.line(`${ok} = and i1 ${inRange}, ${exact}`);
return ok;
}
/** Tests that a double is an exact integer within [min, max] (not -0; NaN
* fails the ordered comparisons) and gives its i64. The integer is frozen,
* so it is a fixed value even when the test fails. */
export function emitExactIntegerTest(
host: LlvmEmitterContext,
value: string,
min: number,
max: number,
): { ok: string; integer: string } {
const B = host.B;
const low = B.tmp(),
high = B.tmp(),
inRange = B.tmp(),
raw = B.tmp(),
integer = B.tmp(),
back = B.tmp(),
bits = B.tmp(),
backBits = B.tmp(),
exact = B.tmp(),
ok = B.tmp();
B.line(`${low} = fcmp oge double ${value}, ${f64Lit(min)}`);
B.line(`${high} = fcmp ole double ${value}, ${f64Lit(max)}`);
B.line(`${inRange} = and i1 ${low}, ${high}`);
B.line(`${raw} = fptosi double ${value} to i64`);
B.line(`${integer} = freeze i64 ${raw}`);
B.line(`${back} = sitofp i64 ${integer} to double`);
B.line(`${bits} = bitcast double ${value} to i64`);
B.line(`${backBits} = bitcast double ${back} to i64`);
B.line(`${exact} = icmp eq i64 ${bits}, ${backBits}`);
B.line(`${ok} = and i1 ${inRange}, ${exact}`);
return { ok, integer };
}
packages/compiler/src/backend/llvm/debug-info.ts
+2 -5
View File
@@ -139,7 +139,6 @@ export class LlvmDebugInfo {
let id: string;
switch (type.kind) {
case "f64":
case "date":
case "procStream":
id = this.add(
`!DIBasicType(name: ${quoted(type.kind === "f64" ? "number" : type.kind)}, size: 64, encoding: DW_ATE_float)`,
@@ -190,7 +189,7 @@ export class LlvmDebugInfo {
? []
: [
this.add(
`!DIDerivedType(tag: DW_TAG_member, name: "arm${i}", baseType: ${this.type(arm)}, size: ${arm.kind === "bool" ? 8 : arm.kind === "f64" || arm.kind === "date" ? 64 : this.pointerBits})`,
`!DIDerivedType(tag: DW_TAG_member, name: "arm${i}", baseType: ${this.type(arm)}, size: ${arm.kind === "bool" ? 8 : arm.kind === "f64" ? 64 : this.pointerBits})`,
),
],
);
@@ -239,9 +238,7 @@ export class LlvmDebugInfo {
// Scalar forward captures use an array-backed TDZ box. Expose that
// exceptional representation opaquely rather than reporting a bad value.
const opaqueBox =
local.boxed &&
local.tdz &&
(local.type.kind === "f64" || local.type.kind === "bool" || local.type.kind === "date");
local.boxed && local.tdz && (local.type.kind === "f64" || local.type.kind === "bool");
const type = opaqueBox
? this.pointer(
this.add(
packages/compiler/src/backend/llvm/dense-array-access.ts
+4
View File
@@ -505,8 +505,12 @@ export function emitDenseArrayState(
indexExpr: IrExpr | undefined,
kind: "state" | "has",
width: number,
/** The index is a dense array loop counter its entry test proved below
* the hole-free prefix (provenDenseIndex): the slot is a present value. */
proven = false,
): string {
const B = host.B;
if (proven) return kind === "state" ? f64Lit(SCR_ARR_VALUE) : "true";
const fn = kind === "state" ? "scr_arr_state" : "scr_arr_has";
const ty = kind === "state" ? "double" : "i1";
host.declare(`declare ${kind === "state" ? "double" : "zeroext i1"} @${fn}(ptr, double)`);
packages/compiler/src/backend/llvm/dense-array-loops.test.ts
+101 -1
View File
@@ -1,9 +1,10 @@
import { expect, test } from "vitest";
import { BOOL, F64, arrayOf, type IrExpr, type IrLocal, type IrStmt } from "../../ir/ir.js";
import type { IntegerCountedForLoop } from "../../ir/integer-loops.js";
import type { IntegerCountedForLoop, IntegerPairedForLoop } from "../../ir/integer-loops.js";
import {
countedDenseShape,
matchDenseArrayLoop,
pairedDenseShape,
type DenseLoopShape,
} from "./dense-array-loops.js";
@@ -42,6 +43,8 @@ const locals = new Map<string, IrLocal>([
["a", { id: "a", name: "a", type: ARR, mutable: false }],
["b", { id: "b", name: "b", type: ARR, mutable: true }],
["c", { id: "c", name: "c", type: ARR, mutable: false }],
["j", { id: "j", name: "j", type: F64, mutable: true }],
["t", { id: "t", name: "t", type: F64, mutable: false }],
]);
/** for (let i = 0; i < a.length; i++) body */
@@ -193,3 +196,100 @@ test("a loop to another invariant limit covers each array whose length it keeps"
expect([...matchLimited(resizing, new Set(["b"]))!.arrays.keys()]).toEqual(["a"]);
expect(matchLimited(resizing)).toBeNull();
});
test("a two-counter loop covers the arrays indexed at either counter", () => {
// for (let i = 1, j = k - 1; i < j; i++, j--) { t = a[i]; a[i] = a[j]; a[j] = t; }
const paired: IntegerPairedForLoop = {
low: { localId: "i", start: num(1), step: 1, startGuarded: false },
high: { localId: "j", start: ref("k"), step: -1, startGuarded: true },
inclusive: false,
guarded: true,
range: { min: -Number.MAX_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER },
};
const pairedShape = pairedDenseShape(paired);
const matchPaired = (body: IrStmt[]) =>
matchDenseArrayLoop(loop(body), pairedShape, locals, new Set(), new Set(["a", "b"]));
const swap: IrStmt[] = [
{ kind: "varDecl", localId: "t", init: read("a"), loc },
write("a", read("a", ref("j"))),
write("a", ref("t"), ref("j")),
];
const dense = matchPaired(swap);
expect([...dense!.arrays.keys()]).toEqual(["a"]);
expect(dense!.pair).toEqual({ high: "j", lowStart: num(1), highStart: ref("k") });
expect(dense!.range).toEqual({ min: 0, max: 2147483646 });
// Stores at any other index may extend the array.
expect(matchPaired([...swap, write("a", num(0), ref("k"))])).toBeNull();
});
test("a present-undefined store is covered only where it stores a covered read's missing arm", () => {
// const v = b[i] (as number | undefined);
// if (v is undefined) c[i] = undefined; else c[i] = v is number ? v : throw;
const unionType = { kind: "union" as const, unionId: "u" };
const v: IrExpr = { kind: "varRef", localId: "v", type: unionType, loc };
const isTag = (tag: number): IrExpr => ({
kind: "unionIsTag",
unionId: "u",
tag,
negated: false,
value: v,
type: BOOL,
loc,
});
const reader = (array: string, index = ref("i")): IrExpr => ({
kind: "call",
callee: "%arr.idxOr.f64",
args: [arr(array), index],
type: unionType,
loc,
});
const undefinedStore: IrStmt = { kind: "arraySetUndefined", arr: arr("c"), index: ref("i"), loc };
const guarded = (array: string): IrStmt[] => [
{ kind: "varDecl", localId: "v", init: reader(array), loc },
{
kind: "if",
cond: isTag(1),
then: [undefinedStore],
else_: [
write("c", {
kind: "ternary",
cond: isTag(0),
then: { kind: "unionNarrow", unionId: "u", tag: 0, value: v, type: F64, loc },
else_: {
kind: "libCall",
fn: "error.nodeThrow",
args: [num(1), { kind: "strLit", value: "", type: { kind: "string" }, loc }],
type: F64,
loc,
},
type: F64,
loc,
}),
],
loc,
},
];
const withV = new Map([
...locals,
["v", { id: "v", name: "v", type: unionType, mutable: false }],
]);
const matchStores = (body: IrStmt[], initialized: string[]) =>
matchDenseArrayLoop(loop(body), shape, withV, new Set(), new Set(initialized));
const dense = matchStores(guarded("b"), ["a", "b", "c"]);
expect([...dense!.arrays.keys()].sort()).toEqual(["b", "c"]);
// A read of an array the entry test does not cover may miss in the fast
// copy, and its undefined store would run there.
expect(matchStores(guarded("b"), ["a", "c"])).toBeNull();
// A present undefined stored on its own leaves out its array and every
// array the other name may hold.
const alone: IrStmt[] = [{ kind: "exprStmt", expr: read("b"), loc }, undefinedStore];
expect(matchStores(alone, ["a", "b", "c"])).toBeNull();
const separate = matchDenseArrayLoop(
loop(alone),
shape,
withV,
new Set(["c"]),
new Set(["a", "b", "c"]),
);
expect([...separate!.arrays.keys()]).toEqual(["b"]);
});
packages/compiler/src/backend/llvm/dense-array-loops.ts
+225 -6
View File
@@ -20,16 +20,23 @@
* A counted loop with another invariant limit, such as `j < n` after
* `const n = a.length` or `j < 5`, is covered the same way: the test bounds
* the loop's exclusive limit by 2^31 - 1 and by each indexed array's
* `filled`, and the loop must provably never change any of their lengths. */
* `filled`, and the loop must provably never change any of their lengths.
*
* A two-counter loop closing in on itself, such as
* `for (let i = 1, j = k - 1; i < j; i++, j--)`, indexes only between its
* low counter's start and its high counter's: the low counter only rises
* and stays below the high one, which only falls. Its test bounds the low
* start below by 0 and the high start by 2^31 - 2 and below each indexed
* array's `filled`, both starts being exact integers. */
import type { IrExpr, IrLocal, IrStmt } from "../../ir/ir.js";
import type { IntegerRange } from "../../ir/integer-ranges.js";
import { preservesArrayLength } from "../../ir/array-length-stability.js";
import { everyExprChild, everyStmtChild } from "../../ir/traverse.js";
import type { IntegerCountedForLoop } from "../../ir/integer-loops.js";
import type { IntegerCountedForLoop, IntegerPairedForLoop } from "../../ir/integer-loops.js";
import type { LlvmEmitterContext } from "./expr-context.js";
import { loadArrCount, SCR_ARR_FIELD } from "./common.js";
import { emitCountedLoopLimit } from "./counted-loops.js";
import { emitCountedLoopLimit, emitExactIntegerTest } from "./counted-loops.js";
export const INT32_MAX = 2147483647;
@@ -47,6 +54,17 @@ export interface DenseArrayLoop {
arrays: ReadonlyMap<string, IrExpr & { kind: "varRef" }>;
/** The counter's range on every pass of the fast copy. */
range: IntegerRange;
/** A two-counter loop's high counter and both starts, when the counter
* is its low one (`length` and `limit` are then null). */
pair: DensePair | null;
}
/** The high counter of a two-counter dense loop, and the starts its entry
* test bounds. */
export interface DensePair {
high: string;
lowStart: IrExpr;
highStart: IrExpr;
}
/** The fast copy duplicates the loop; keep the duplicated code small. */
@@ -62,6 +80,8 @@ export interface DenseLoopShape {
/** The counter's proven range on every pass of the ordinary loop; the
* fast copy keeps its minimum, which must be at least 0. */
range: IntegerRange;
/** A two-counter loop's high counter and starts. */
pair?: DensePair;
}
/** `length.length - c` (c an integer literal, 0 when absent). */
@@ -107,6 +127,124 @@ export function countedDenseShape(
return { counter: counted.localId, length: start.receiver, range: counted.range };
}
/** The shape of a two-counter loop whose low counter rises and high
* counter falls: both stay between the two starts, which the entry test
* bounds, so the fast copy's counters lie in [0, 2^31 - 2]. */
export function pairedDenseShape(loop: IntegerPairedForLoop): DenseLoopShape {
return {
counter: loop.low.localId,
length: null,
range: { min: 0, max: INT32_MAX - 1 },
pair: { high: loop.high.localId, lowStart: loop.low.start, highStart: loop.high.start },
};
}
interface ElementRead {
arr: IrExpr;
index: IrExpr;
}
/** The array and index of a call of an element-reader helper
* (`%arr.idxOr.*`, ir/int32-arrays.ts isElementReader): `a[i]` as
* `number | undefined`. */
function elementReaderCall(e: IrExpr): ElementRead | null {
if (e.kind !== "call" || !e.callee.startsWith("%arr.idxOr.") || e.args.length !== 2) return null;
return { arr: e.args[0]!, index: e.args[1]! };
}
/** The array and index of an element read as `T | undefined`: an
* element-reader call, or its body inlined for an int32 array
* (`arrayState(a, i) === 1 ? wrap(a[i]) : wrap(undefined)`). */
function elementRead(e: IrExpr): ElementRead | null {
const call = elementReaderCall(e);
if (call) return call;
if (e.kind !== "ternary") return null;
const cond = e.cond;
if (cond.kind !== "bin" || cond.op !== "===") return null;
const state = cond.left,
present = cond.right,
wrapped = e.then,
missing = e.else_;
if (state.kind !== "arrayState" || present.kind !== "numLit" || present.value !== 1) return null;
if (wrapped.kind !== "unionWrap" || missing.kind !== "unionWrap") return null;
const value = wrapped.value;
if (value.kind !== "arrayGet" || missing.value.kind !== "unitLit") return null;
const same = (x: IrExpr, y: IrExpr): boolean =>
x.kind === "varRef" && y.kind === "varRef" && x.localId === y.localId;
return same(state.arr, value.arr) && same(state.index, value.index)
? { arr: state.arr, index: state.index }
: null;
}
/** The present-undefined stores of `a[i] = b[j]!` as lowering spells it,
* with the element read each one stores the missing arm of:
*
* const v = %arr.idxOr(b, j);
* if (v is undefined) a[i] = undefined; else a[i] = v is number ? v : throw;
*
* The read's local is declared once in the same list as the `if`, and only
* read after it. */
function missingElementStores(body: IrStmt[]): Map<IrStmt, ElementRead> {
const result = new Map<IrStmt, ElementRead>();
const writes = new Map<string, number>();
const count = (id: string): void => void writes.set(id, (writes.get(id) ?? 0) + 1);
const expr = (e: IrExpr): boolean => {
if (e.kind === "assignExpr" || e.kind === "incDec") count(e.localId);
return everyExprChild(e, expr, stmt);
};
const stmt = (s: IrStmt): boolean => {
if (s.kind === "varDecl" || s.kind === "assign") count(s.localId);
return everyStmtChild(s, expr, stmt);
};
body.every(stmt);
const list = (stmts: IrStmt[]): void => {
const reads = new Map<string, ElementRead>();
for (const s of stmts) {
if (s.kind === "varDecl" && s.init && writes.get(s.localId) === 1) {
const read = elementRead(s.init);
if (read) reads.set(s.localId, read);
}
if (s.kind === "if") {
const store = missingArmStore(s, reads);
if (store) result.set(store.stmt, store.read);
}
// Nested loops keep a loop out of the fast copy (matchDenseArrayLoop),
// and other statement lists leave their stores unmatched.
if (s.kind === "block") list(s.body);
if (s.kind === "if") {
list(s.then);
if (s.else_) list(s.else_);
}
}
};
list(body);
return result;
}
/** The present-undefined store of `if (v is undefined) a[i] = undefined;
* else a[i] = v is number ? v : throw;`, with the read `v` holds. */
function missingArmStore(
s: IrStmt & { kind: "if" },
reads: ReadonlyMap<string, ElementRead>,
): { stmt: IrStmt; read: ElementRead } | null {
const cond = s.cond;
if (cond.kind !== "unionIsTag" || cond.negated || cond.value.kind !== "varRef") return null;
const local = cond.value.localId;
const read = reads.get(local);
if (!read || s.then.length !== 1 || s.else_?.length !== 1) return null;
const store = s.then[0]!,
other = s.else_[0]!;
if (store.kind !== "arraySetUndefined" || other.kind !== "arraySet") return null;
const value = other.value;
if (value.kind !== "ternary") return null;
const test = value.cond,
narrowed = value.then;
if (test.kind !== "unionIsTag" || test.negated || test.tag === cond.tag) return null;
if (test.value.kind !== "varRef" || test.value.localId !== local) return null;
if (narrowed.kind !== "unionNarrow" || narrowed.tag !== test.tag) return null;
return narrowed.type.kind === "f64" ? { stmt: store, read } : null;
}
/** Match the fast copy of a loop of the given shape. `initialized` holds the
* bindings definitely assigned when the loop starts; `unaliased` the local
* arrays no other binding holds. */
@@ -118,6 +256,8 @@ export function matchDenseArrayLoop(
initialized: ReadonlySet<string>,
): DenseArrayLoop | null {
const { counter, length } = shape;
const high = shape.pair?.high ?? null;
const isCounter = (id: string): boolean => id === counter || id === high;
if (shape.range.min < 0 || !loop.cond) return null;
let nodes = 0,
nested = false;
@@ -126,13 +266,21 @@ export function matchDenseArrayLoop(
// element write.
const disturbed = new Set<string>();
const access = (arr: IrExpr, index: IrExpr): void => {
if (arr.kind === "varRef" && index.kind === "varRef" && index.localId === counter)
if (arr.kind === "varRef" && index.kind === "varRef" && isCounter(index.localId))
candidates.set(arr.localId, arr);
};
const missing = missingElementStores(loop.body);
// The element reads behind the guarded present-undefined stores.
const guards: ElementRead[] = [];
// The arrays of the other present-undefined stores. The fast copy runs
// them, and the slot each one writes leaves the hole-free prefix.
const undefinedStores: IrExpr[] = [];
const expr = (e: IrExpr): boolean => {
if (++nodes > MAX_LOOP_NODES) return false;
if (e.kind === "assignExpr" || e.kind === "incDec") disturbed.add(e.localId);
if (e.kind === "arrayGet") access(e.arr, e.index);
const reader = elementReaderCall(e);
if (reader) access(reader.arr, reader.index);
if (e.kind === "arrIntrinsic") {
if (e.method === "getNumber" && e.args[0]) access(e.receiver, e.args[0]);
else if (e.method !== "length" && e.receiver.kind === "varRef")
@@ -147,9 +295,21 @@ export function matchDenseArrayLoop(
if (s.kind === "assign" || s.kind === "varDecl") disturbed.add(s.localId);
if (s.kind === "arraySet") {
access(s.arr, s.index);
if (s.arr.kind === "varRef" && (s.index.kind !== "varRef" || s.index.localId !== counter))
if (s.arr.kind === "varRef" && (s.index.kind !== "varRef" || !isCounter(s.index.localId)))
disturbed.add(s.arr.localId);
}
if (s.kind === "arraySetUndefined") {
// A present undefined at a counter only where it stores a missing
// element read (`a[i] = b[j]!`): the fast copy reads a present value
// there, so the store never runs in it.
const read = missing.get(s);
if (read === undefined || s.index.kind !== "varRef" || !isCounter(s.index.localId)) {
undefinedStores.push(s.arr);
} else {
access(s.arr, s.index);
guards.push(read);
}
}
return everyStmtChild(s, expr, stmt);
};
if (!loop.body.every(stmt) || !expr(loop.cond) || nested) return null;
@@ -164,6 +324,15 @@ export function matchDenseArrayLoop(
)
)
return null;
// A store through another name, such as `const b = a` or a field, lands
// in `a` unless one of the two bindings is a local array no other binding
// holds.
const mayStoreUndefined = (id: string): boolean =>
undefinedStores.some((arr) =>
arr.kind === "varRef"
? arr.localId === id || (!unaliased.has(id) && !unaliased.has(arr.localId))
: !unaliased.has(id),
);
const arrays = new Map<string, IrExpr & { kind: "varRef" }>();
for (const [id, ref] of candidates) {
const local = locals.get(id);
@@ -173,6 +342,7 @@ export function matchDenseArrayLoop(
local.boxed ||
local.tdz ||
disturbed.has(id) ||
mayStoreUndefined(id) ||
(id !== length?.localId && !initialized.has(id))
)
continue;
@@ -180,18 +350,33 @@ export function matchDenseArrayLoop(
// once: the loop must not change any of their lengths.
if (
length === null &&
!preservesArrayLength(nodesOfLoop, { receiver: id, inRange: counter }, locals, unaliased)
!preservesArrayLength(
nodesOfLoop,
{ receiver: id, inRange: counter, inRangeHigh: high },
locals,
unaliased,
)
)
continue;
arrays.set(id, ref);
}
if (arrays.size === 0) return null;
// Each guarded store's read must be one the fast copy proves present.
for (const { arr, index } of guards)
if (
arr.kind !== "varRef" ||
!arrays.has(arr.localId) ||
index.kind !== "varRef" ||
!isCounter(index.localId)
)
return null;
return {
counter,
length,
limit: length === null ? (shape.limit ?? null) : null,
arrays,
range: { min: shape.range.min, max: Math.min(shape.range.max, INT32_MAX - 1) },
pair: shape.pair ?? null,
};
}
@@ -207,6 +392,7 @@ export function emitDenseLoopGuard(host: LlvmEmitterContext, loop: DenseArrayLoo
host.markMemoryPointer(ptr, "array:header");
return ptr;
};
if (loop.pair !== null) return emitPairedDenseGuard(host, loop, loop.pair, header);
if (loop.length === null) {
// A limit at or below the start runs no pass, and passes the test.
const limit = emitCountedLoopLimit(host, loop.limit!);
@@ -254,3 +440,36 @@ export function emitDenseLoopGuard(host: LlvmEmitterContext, loop: DenseArrayLoo
}
return valid;
}
/** A two-counter loop's entry test: both starts are exact integers, the
* low one at least 0 and the high one at most 2^31 - 2 and below every
* indexed array's hole-free prefix bound. The starts are stable values
* (matchIntegerPairedForLoop), so evaluating them here again is unobservable. */
function emitPairedDenseGuard(
host: LlvmEmitterContext,
loop: DenseArrayLoop,
pair: DensePair,
header: (array: string, field: number) => string,
): string {
const B = host.B;
const start = (expr: IrExpr, min: number, max: number) =>
emitExactIntegerTest(host, host.emitExpr(expr).name, min, max);
const low = start(pair.lowStart, 0, INT32_MAX - 1);
const high = start(pair.highStart, -1, INT32_MAX - 1);
let valid = B.tmp();
B.line(`${valid} = and i1 ${low.ok}, ${high.ok}`);
for (const ref of loop.arrays.values()) {
const array = host.emitStableReceiver(ref, []);
const filledPtr = header(array.name, SCR_ARR_FIELD.filled),
filled = B.tmp(),
wide = B.tmp(),
covered = B.tmp(),
both = B.tmp();
B.line(`${filled} = load i32, ptr ${filledPtr}${host.fieldAliasAttachment(filledPtr)}`);
B.line(`${wide} = zext i32 ${filled} to i64`);
B.line(`${covered} = icmp slt i64 ${high.integer}, ${wide}`);
B.line(`${both} = and i1 ${valid}, ${covered}`);
valid = both;
}
return valid;
}
packages/compiler/src/backend/llvm/dyn-handle-tags.test.ts
+7 -1
View File
@@ -1,7 +1,7 @@
import { readFileSync } from "node:fs";
import { expect, test } from "vitest";
import { DYN_HANDLE_KINDS } from "../../ir/ir.js";
import { DYN_HANDLE_TAG_NUM } from "./dyn.js";
import { DYN_HANDLE_TAG_NUM, TEXT_CODEC_TAG_NUM } from "./dyn.js";
// SCR_DYNH_TAGS in scr_dyn.h lists the ScrDynHandleTag values by name, each
// with an explicit value, so changes that add tags edit different lines. The
@@ -39,3 +39,9 @@ test("the backend's handle tag numbers match scr_dyn.h", () => {
expect(values.get(tag!), `${kind} (${tag})`).toBe(num);
}
});
test("the backend's codec handle tag numbers match scr_dyn.h", () => {
const values = new Map(tags.map((tag) => [tag.name, tag.value]));
expect(values.get("SCR_DYNH_TEXT_DECODER")).toBe(TEXT_CODEC_TAG_NUM.TextDecoder);
expect(values.get("SCR_DYNH_TEXT_ENCODER")).toBe(TEXT_CODEC_TAG_NUM.TextEncoder);
});
packages/compiler/src/backend/llvm/dyn.ts
+142 -8
View File
@@ -43,6 +43,8 @@ import {
isDynTypedRefType,
isRefCounted,
isUnitType,
recordTextCodecClass,
textCodecRecordClass,
typeKey,
} from "../../ir/ir.js";
import { dynDesc, streamTypedRefEligible } from "../../ir/analysis.js";
@@ -94,6 +96,17 @@ export const DYN_HANDLE_TAG_NUM: Record<string, number> = {
cryptoHmac: 53,
};
/** The handle tags of TextEncoder and TextDecoder records boxed as dyn
* (scr_dyn.h; scr_text_codec_dyn.c boxes and unboxes them). */
export const TEXT_CODEC_TAG_NUM: Record<"TextEncoder" | "TextDecoder", number> = {
TextDecoder: 76,
TextEncoder: 77,
};
/** The decoder record fields scr_text_decoder_to_dyn reads, in its
* parameter order. */
const TEXT_DECODER_FIELDS = ["%TextDecoder", "%fatal", "%ignoreBOM", "%state"] as const;
/** Handle kinds whose runtime unit boxes them through its own function,
* which installs the tag's ops on first use (scr_crypto.h). Programs that
* never box one of these values do not link its dynamic members. */
@@ -456,7 +469,7 @@ export class LlDyn {
/** The value LLVM type of a dynCheck result / toDyn operand for `t`. */
private valTy(t: IrType): string {
return t.kind === "f64" || t.kind === "date" || t.kind === "procStream"
return t.kind === "f64" || t.kind === "procStream"
? "double"
: t.kind === "bool"
? "i1"
@@ -927,6 +940,21 @@ export class LlDyn {
const name = `sc_dm_${this.dynMatchers.size}`;
this.dynMatchers.set(matcherKey, name);
this.host.journalAllocated?.(name, "dyn.dynMatchHelper", [t, preserveRefs]);
const codec = textCodecRecordClass(t, (id) => this.host.recordsById.get(id));
if (codec !== null) {
// A codec matches only its own handle box.
const B = new BlockBuilder();
const matched = this.handleTagMatches(B, TEXT_CODEC_TAG_NUM[codec]);
B.terminate(`ret i1 ${matched}`);
this.defs.push(
`define internal zeroext i1 @${name}(ptr %d) ${FN_ATTRS} { ; matches ${key}`,
B.render(),
`}`,
``,
);
this.host.journalBuilt?.();
return name;
}
const recursive = this.isRecursiveShape(t);
const wrapped = recursive || this.holdsRecursiveShape(t);
const B = new BlockBuilder();
@@ -1535,6 +1563,19 @@ export class LlDyn {
return descriptor;
}
/** `record.sourceSpread(built, value)`: the built record keeps value's
* kept-source order over its own declared names. */
emitRecordSourceSpread(B: BlockBuilder, built: string, value: string, shapeId: string): void {
const host = this.host;
const shape = host.recordsById.get(shapeId)!;
this.keepsRecordSources = true;
const names = this.recordNameTable(shapeId, shape);
host.declare(`declare void @scr_record_source_spread(ptr, ptr, ptr, ptr, ${host.sizeType})`);
B.line(
`call void @scr_record_source_spread(ptr ${built}, ptr ${value}, ptr ${names.names}, ptr ${names.lens}, ${host.sizeType} ${shape.fields.length})`,
);
}
/** The declared-name tables scr_record_source_note scans: parallel
* constant arrays of field-name bytes and byte lengths in declaration
* order (the order the record serializes), interned per shape. Internal
@@ -1643,6 +1684,24 @@ export class LlDyn {
this.host.journalBuilt?.();
return name;
}
const codec = textCodecRecordClass(t, (id) => host.recordsById.get(id));
if (codec !== null) {
// The record the codec's handle box holds (+1), or the path TypeError.
host.declare(`declare ptr @scr_text_codec_from_dyn(ptr, i1 zeroext, ptr, ptr)`);
const checked = B.tmp();
B.line(
`${checked} = call ptr @scr_text_codec_from_dyn(ptr %d, i1 ${codec === "TextDecoder"}, ptr %path, ptr ${want})`,
);
B.terminate(`ret ptr ${checked}`);
this.defs.push(
`define internal ptr @${name}(ptr %d, ptr %path) ${FN_ATTRS} {`,
B.render(),
`}`,
``,
);
this.host.journalBuilt?.();
return name;
}
if (isRefCounted(t) && t.kind !== "dyn") {
host.declare(`declare ptr @scr_dyn_typed_ref_unbox(ptr)`);
if (t.kind === "object" && t.className === "%Error") {
@@ -1895,10 +1954,10 @@ export class LlDyn {
};
switch (t.kind) {
case "date": {
host.declare(`declare double @scr_dyn_native_date_value(ptr)`);
host.declare(`declare ptr @scr_dyn_native_date_check(ptr, ptr)`);
const r = B.tmp();
B.line(`${r} = call double @scr_dyn_native_date_value(ptr %d)`);
B.terminate(`ret double ${r}`);
B.line(`${r} = call ptr @scr_dyn_native_date_check(ptr %d, ptr %path)`);
B.terminate(`ret ptr ${r}`);
break;
}
case "url":
@@ -2671,6 +2730,77 @@ export class LlDyn {
return name;
}
/** `i1`: %d is a handle box with tag `tag`. */
private handleTagMatches(B: BlockBuilder, tag: number): string {
const kd = this.kindOf(B, "%d");
const isHandle = B.tmp();
B.line(`${isHandle} = icmp eq i32 ${kd}, ${DYN_KIND.HANDLE}`);
const lHandle = B.newLabel("dm.handle");
const lDone = B.newLabel("dm.handle.done");
const entry = B.currentLabel();
B.condBr(isHandle, lHandle, lDone);
B.startBlock(lHandle);
const tagPtr = B.tmp();
const loaded = B.tmp();
B.line(
`${tagPtr} = getelementptr inbounds i8, ptr %d, i64 ${this.abiOffset(24, 20)} ; ->v.handle.tag`,
);
B.line(`${loaded} = load i32, ptr ${tagPtr}`);
const same = B.tmp();
B.line(`${same} = icmp eq i32 ${loaded}, ${tag}`);
B.br(lDone);
B.startBlock(lDone);
const matched = B.tmp();
B.line(`${matched} = phi i1 [ false, %${entry} ], [ ${same}, %${lHandle} ]`);
return matched;
}
/** A TextEncoder or TextDecoder record boxes as its handle (+1), which
* holds the record by reference. A decoder passes the byte offsets of the
* fields its boxed decode reads. */
private textCodecToDyn(
B: BlockBuilder,
t: IrType & { kind: "record" },
shape: IrRecordShape,
codec: "TextEncoder" | "TextDecoder",
): void {
const host = this.host;
const rc = vAdapters(host, t);
const r = B.tmp();
if (codec === "TextEncoder") {
host.declare(`declare ptr @scr_text_encoder_to_dyn(ptr, ptr, ptr)`);
B.line(
`${r} = call ptr @scr_text_encoder_to_dyn(ptr %v, ptr ${rc.retain}, ptr ${rc.release})`,
);
} else {
const struct = mangleRecordStruct(t.shapeId);
const base = host.nullableUnions.fieldBase(t.shapeId);
const start = B.tmp();
B.line(`${start} = ptrtoint ptr %v to ${this.S}`);
const offsets = TEXT_DECODER_FIELDS.map((field) => {
const index = shape.fields.findIndex((f) => f.name === field);
if (index < 0)
throw new InternalCompilerError(`llvm emitter bug: TextDecoder record lacks ${field}`);
const p = B.tmp();
const at = B.tmp();
const offset = B.tmp();
B.line(
`${p} = getelementptr inbounds %${struct}, ptr %v, i64 0, i32 ${index + base} ; .${llvmCommentText(field)}`,
);
B.line(`${at} = ptrtoint ptr ${p} to ${this.S}`);
B.line(`${offset} = sub ${this.S} ${at}, ${start}`);
return `${this.S} ${offset}`;
});
host.declare(
`declare ptr @scr_text_decoder_to_dyn(ptr, ptr, ptr, ${this.S}, ${this.S}, ${this.S}, ${this.S})`,
);
B.line(
`${r} = call ptr @scr_text_decoder_to_dyn(ptr %v, ptr ${rc.retain}, ptr ${rc.release}, ${offsets.join(", ")})`,
);
}
B.terminate(`ret ptr ${r}`);
}
/* ── toDynHelper (walkers.ts, ported) ─────────────────────────── */
/** `sc_td_<n>(<T> v) -> ptr` — build a fresh dyn value from a
@@ -2688,11 +2818,10 @@ export class LlDyn {
let sourceAccessor: { name: string; release: string } | null = null;
switch (t.kind) {
case "date": {
// A Date handle holding the same time value; native Dates are
// immutable values, and so is the handle.
host.declare(`declare ptr @scr_dyn_native_date_from_ms(double)`);
// A Date handle holding the same Date object.
host.declare(`declare ptr @scr_dyn_native_date(ptr)`);
const r = B.tmp();
B.line(`${r} = call ptr @scr_dyn_native_date_from_ms(double %v)`);
B.line(`${r} = call ptr @scr_dyn_native_date(ptr %v)`);
B.terminate(`ret ptr ${r}`);
break;
}
@@ -2846,6 +2975,11 @@ export class LlDyn {
const shape = host.recordsById.get(t.shapeId);
if (!shape)
throw new InternalCompilerError(`llvm emitter bug: to-dyn of unknown shape ${t.shapeId}`);
const codec = recordTextCodecClass(shape);
if (codec !== null) {
this.textCodecToDyn(B, t, shape, codec);
break;
}
const struct = mangleRecordStruct(t.shapeId);
const base = host.nullableUnions.fieldBase(t.shapeId);
const fieldIndex = new Map(shape.fields.map((f, i) => [f.name, i + base]));
packages/compiler/src/backend/llvm/emit-function.ts
+2 -10
View File
@@ -304,11 +304,7 @@ export function emitFunction(emitter: LlEmitter, fn: IrFunction): string {
// ScrGen owns the frame), so its OUT slot address is fixed.
let out: string | null = null;
const yieldKind = fn.generator?.yieldT.kind;
if (
!emitter.wasi &&
fn.async !== true &&
(yieldKind === "f64" || yieldKind === "date" || yieldKind === "bool")
) {
if (!emitter.wasi && fn.async !== true && (yieldKind === "f64" || yieldKind === "bool")) {
emitter.declare(`declare ptr @scr_gen_of_fiber(ptr)`);
const gen = B.tmp();
B.line(`${gen} = call ptr @scr_gen_of_fiber(ptr ${self})`);
@@ -704,7 +700,6 @@ export function emitGenScaffolding(emitter: LlEmitter): string[] {
tr.push(` br label %done ; void body: the done value is undefined (NONE)`);
break;
case "f64":
case "date":
emitter.declare(`declare void @scr_gen_out_f64(ptr, double)`);
tr.push(` call void @scr_gen_out_f64(ptr %g, double %r)`, ` br label %done`);
break;
@@ -1053,7 +1048,6 @@ export function emitAsyncAwaitCall(
emitter.declare(`declare void @scr_await_void(ptr)`);
return ` call void @scr_await_void(ptr ${promise})`;
case "f64":
case "date":
emitter.declare(`declare double @scr_await_f64(ptr)`);
return ` ${dest} = call double @scr_await_f64(ptr ${promise})`;
case "bool":
@@ -1108,7 +1102,7 @@ export function emitAsyncAwaitCall(
const kind =
ret.kind === "void"
? "void"
: ret.kind === "f64" || ret.kind === "date"
: ret.kind === "f64"
? "f64"
: ret.kind === "bool"
? "bool"
@@ -1187,7 +1181,6 @@ export function emitWasiFulfill(emitter: LlEmitter, v: LlValue | null): void {
case "void":
return;
case "f64":
case "date":
emitter.declare(`declare void @scr_gen_out_f64(ptr, double)`);
emitter.B.line(`call void @scr_gen_out_f64(ptr ${gen}, double ${v!.name})`);
return;
@@ -1212,7 +1205,6 @@ export function emitWasiFulfill(emitter: LlEmitter, v: LlValue | null): void {
emitter.B.line(`call void @scr_promise_fulfill_void(ptr ${pr})`);
break;
case "f64":
case "date":
emitter.declare(`declare void @scr_promise_fulfill_f64(ptr, double)`);
emitter.B.line(`call void @scr_promise_fulfill_f64(ptr ${pr}, double ${v!.name})`);
break;
packages/compiler/src/backend/llvm/emit-statements.ts
+23 -11
View File
@@ -52,13 +52,19 @@ import {
matchIntegerPairedForLoop,
} from "../../ir/integer-loops.js";
import { emitByteWindowGuard, matchByteWindow } from "./byte-windows.js";
import { countedDenseShape, emitDenseLoopGuard, matchDenseArrayLoop } from "./dense-array-loops.js";
import {
countedDenseShape,
emitDenseLoopGuard,
matchDenseArrayLoop,
pairedDenseShape,
} from "./dense-array-loops.js";
import {
emitCountedLoopLimit,
emitCountedLoopSafety,
emitPairedLoopSafety,
} from "./counted-loops.js";
import { emitBytesLoopVersionGuard, type BytesLoopVersion } from "./bytes-loop-versions.js";
import { bytesHeaderAlias } from "./bytes-alias.js";
import { mangleLocal } from "../mangle.js";
import { LlvmUnsupportedError } from "./unsupported.js";
import type { LlValue } from "./expr-context.js";
@@ -966,7 +972,9 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void {
}
: countedLoop && !countedLoop.guarded && countedLoop.followers.length === 0
? countedDenseShape(s, countedLoop)
: null;
: pairedLoop
? pairedDenseShape(pairedLoop)
: null;
const dense =
denseShape && !window
? matchDenseArrayLoop(
@@ -1043,15 +1051,17 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void {
LOOPS.of(emitter).unaliasedArrays,
)
: countedLoop;
const version = versionable ? emitter.matchBytesLoopVersion(s, versionCounted) : null;
const version = versionable
? emitter.matchBytesLoopVersion(s, versionCounted, versionCounted ? null : pairedLoop)
: null;
if (version) {
emitVersionedLoop(emitter, s, version);
break;
}
let countedJoin: string | null = null;
if (
(countedLoop?.guarded && !LOOPS.of(emitter).provenCountedGuards.has(s)) ||
pairedLoop?.guarded
(countedLoop?.guarded || pairedLoop?.guarded) &&
!LOOPS.of(emitter).provenCountedGuards.has(s)
) {
const safe = countedLoop
? emitCountedLoopSafety(emitter, countedLoop)
@@ -1144,11 +1154,15 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void {
B.line(`${start} = fptosi double ${value.name} to i64`);
B.line(`store i64 ${start}, ptr ${slot}`);
pairedSlots.push(slot);
const dense = LOOPS.of(emitter).denseLoop;
emitter.integerLoopBindings.set(counter.localId, {
slot,
type: "i64",
signed: true,
range: pairedLoop.range,
range:
dense?.pair && dense.counter === pairedLoop.low.localId
? dense.range
: pairedLoop.range,
});
}
} else if (s.init) {
@@ -1218,10 +1232,7 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void {
}
B.line(`${inBounds} = icmp ult i32 ${narrow}, ${len}`);
} else {
emitter.markMemoryPointer(lenPtr, "bytes:header");
B.line(
`${len} = load ${emitter.sizeType}, ptr ${lenPtr}${emitter.fieldAliasAttachment(lenPtr)}`,
);
B.line(`${len} = load ${emitter.sizeType}, ptr ${lenPtr}${bytesHeaderAlias(emitter)}`);
B.line(`${inBounds} = icmp ult ${emitter.sizeType} ${index}, ${len}`);
}
B.condBr(inBounds, lb, exit);
@@ -2085,7 +2096,8 @@ function emitVersionedLoop(
if (version.owned.size > 0) emitter.bytesOwned = new Set([...originalOwned, ...version.owned]);
if (version.ranges.size > 0)
emitter.integerRanges = new Map([...originalRanges, ...version.ranges]);
if (version.counted?.guarded) LOOPS.of(emitter).provenCountedGuards.add(s);
if (version.counted?.guarded || version.paired?.loop.guarded)
LOOPS.of(emitter).provenCountedGuards.add(s);
emitter.emitStmt(s);
B.br(done);
} finally {
packages/compiler/src/backend/llvm/emitter.test.ts
+22 -2
View File
@@ -1,7 +1,6 @@
import { expect, test } from "vitest";
import {
BOOL,
DATE_T,
F64,
PROCSTREAM_T,
STRING,
@@ -287,7 +286,7 @@ test("shared exceptional exits preserve the function's scalar return ABI", () =>
});
test("exceptional exits use each scalar kind's LLVM return type", () => {
for (const type of [F64, DATE_T, BOOL, PROCSTREAM_T]) {
for (const type of [F64, BOOL, PROCSTREAM_T]) {
for (const ownedLocals of [false, true]) {
const module = moduleFor([call(), call(), { kind: "throw", value: literal("failed"), loc }]);
const work = module.functions[1]!;
@@ -499,6 +498,27 @@ test("class brand probes compare the program's key constant before the key text"
const named = work(probe("dyn.typedRefIs"), dyn);
expect(named).toContain("; ->v.typed_ref.type_key");
expect(named).toContain("@scr_dyn_typed_ref_is_key");
// Another key pointer is rejected on its length and last eight bytes
// ("Example" plus the prefix's ':') before the out-of-line comparison.
expect(named).toContain("; ->v.typed_ref.type_key_len");
expect(named).toContain("and i32 %t");
expect(named).toMatch(/icmp eq i32 %t\d+, 14\b/);
const tail = Buffer.from("object:Example").readBigInt64LE(6);
expect(named).toContain(`icmp eq i64 %t`);
expect(named).toContain(`, ${tail}`);
const shortKey: IrExpr = { kind: "strLit", value: "o:E", type: STRING, loc: receiverLoc };
const short = work(
{
kind: "libCall",
fn: "dyn.typedRefIs",
args: [ref(dyn), shortKey],
type: BOOL,
loc: receiverLoc,
},
dyn,
);
expect(short).toMatch(/icmp eq i32 %t\d+, 3\b/);
expect(short).not.toContain("load i64");
// The key-pointer test answers false for capsules boxed elsewhere.
const exact = work(probe("dyn.typedRefKeyIs"), dyn);
expect(exact).toContain("; ->v.typed_ref.type_key");
packages/compiler/src/backend/llvm/emitter.ts
+96 -31
View File
@@ -60,7 +60,7 @@ import { captureFreeFunctions, observesStacks } from "../stack-observations.js";
import { findInitializedByteLoopBindings } from "./byte-windows.js";
import { matchBytesLoopVersion } from "./bytes-loop-versions.js";
import { globalSlotAlias } from "./bytes-alias.js";
import type { IntegerCountedForLoop } from "../../ir/integer-loops.js";
import type { IntegerCountedForLoop, IntegerPairedForLoop } from "../../ir/integer-loops.js";
import {
materializeSplitPiece,
type SplitSpan,
@@ -68,7 +68,7 @@ import {
type StringSplit,
} from "./split-loops.js";
import { scalarizeNumericRecords } from "../../ir/scalar-records.js";
import { addRecordResultEntries } from "./record-results.js";
import { addRecordResultEntries, resultEntryName } from "./record-results.js";
import { specializeCallbackCalls } from "../../ir/callback-specialization.js";
import {
type ChunkResult,
@@ -82,6 +82,7 @@ import { versionLoopBoundParameters } from "../../ir/parameter-versions.js";
import {
allocatedLiteral,
fillAllocationLength,
int32ArrayKey,
selectInt32Arrays,
} from "../../ir/int32-arrays.js";
import { everyExpr, everyExprChild, everyStmtChild, everyStmtList } from "../../ir/traverse.js";
@@ -185,7 +186,7 @@ import {
} from "./string-slices.js";
import { LazyCaptures } from "./lazy-captures.js";
import { StackCaptures } from "./stack-captures.js";
import { emitFieldAbsentTest, f64Lit, SCR_ARR_FIELD } from "./common.js";
import { emitFieldAbsentTest, f64Lit, SCR_ARR_FIELD, SCR_ARR_FROZEN } from "./common.js";
import { ffiExtendsNarrowIntegers } from "../targets.js";
import {
emitLiteralExpr,
@@ -510,6 +511,15 @@ function provenInt32Arrays(mod: IrModule): ReadonlySet<string> {
return new Set([...slots.int32Arrays, ...slots.checkedInt32Arrays]);
}
/** The functions whose calls the backend may emit as calls of their
* result-slot entries (record-results.ts). */
function resultEntryTargets(mod: IrModule): ReadonlySet<string> {
const names = new Set(mod.functions.map((fn) => fn.name));
const targets = new Set<string>();
for (const name of names) if (names.has(resultEntryName(name))) targets.add(name);
return targets;
}
/** The emitter for `input` after the module passes every emission runs. */
function moduleEmitter(input: IrModule, options: LlvmTargetOptions): LlEmitter {
// Facts are keyed by node identity: emit the same module whether it was
@@ -545,6 +555,7 @@ function moduleEmitter(input: IrModule, options: LlvmTargetOptions): LlEmitter {
),
),
provenInt32Arrays,
resultEntryTargets,
)
: mod,
options,
@@ -781,7 +792,7 @@ export class LlEmitter {
everyStmtList(fn.body, {
stmt: (s) => {
if (s.kind !== "varDecl" && s.kind !== "assign") return true;
const key = `${fn.name}\0${s.localId}`;
const key = int32ArrayKey(fn.name, s.localId);
const checked = checkedInt32Arrays.has(key);
if (!checked && !int32Arrays.has(key)) return true;
const value = s.kind === "varDecl" ? s.init : s.value;
@@ -799,15 +810,16 @@ export class LlEmitter {
});
}
/** Whether `arr` is one of the current function's int32 arrays
* (ir/int32-arrays.ts, kept by the int32 slot analysis). */
/** Whether `arr` reads one of the int32 arrays (ir/int32-arrays.ts, kept
* by the int32 slot analysis): a local or parameter of the current
* function, or a module global. */
int32Array(arr: IrExpr): boolean {
if (arr.kind !== "varRef") return false;
if (this.int32KindArray(arr)) return true;
if (this.int32Slots.int32Arrays.size === 0) return false;
return (
this.int32ArrayTemps.has(arr.localId) ||
this.int32Slots.int32Arrays.has(`${this.currentFunctionName}\0${arr.localId}`)
this.int32Slots.int32Arrays.has(int32ArrayKey(this.currentFunctionName, arr.localId))
);
}
@@ -974,8 +986,8 @@ export class LlEmitter {
}
/** Whether an element access at `index` of `arr` lies in the hole-free
* prefix: the counter of a dense array loop's fast copy indexing one of
* the arrays its entry test covered. */
* prefix: a counter of a dense array loop's fast copy indexing one of the
* arrays its entry test covered. */
provenDenseIndex(arr: IrExpr, index: IrExpr): boolean {
const loop = LOOPS.of(this).denseLoop;
return (
@@ -983,8 +995,8 @@ export class LlEmitter {
arr.kind === "varRef" &&
loop.arrays.has(arr.localId) &&
index.kind === "varRef" &&
index.localId === loop.counter &&
this.integerLoopBindings.has(loop.counter)
(index.localId === loop.counter || index.localId === loop.pair?.high) &&
this.integerLoopBindings.has(index.localId)
);
}
@@ -2032,7 +2044,6 @@ export class LlEmitter {
if (POINTER_KINDS.has(t.kind)) return "ptr";
switch (t.kind) {
case "f64":
case "date":
return "double";
case "bool":
return "i1";
@@ -2165,7 +2176,6 @@ export class LlEmitter {
this.declare(`declare void @scr_promise_fulfill_void(ptr)`);
return [` call void @scr_promise_fulfill_void(ptr ${promise})`];
case "f64":
case "date":
this.declare(`declare void @scr_promise_fulfill_f64(ptr, double)`);
return [` call void @scr_promise_fulfill_f64(ptr ${promise}, double %r)`];
case "bool":
@@ -2395,7 +2405,7 @@ export class LlEmitter {
return { name: "", type };
}
const t = B.tmp();
if (type.kind === "f64" || type.kind === "date") {
if (type.kind === "f64") {
this.declare(`declare double @scr_coro_direct_f64(ptr)`);
B.line(`${t} = call double @scr_coro_direct_f64(ptr ${record})`);
} else if (type.kind === "bool") {
@@ -4251,6 +4261,7 @@ export class LlEmitter {
matchBytesLoopVersion(
s: IrStmt & { kind: "for" | "while" },
counted: IntegerCountedForLoop | null,
paired: IntegerPairedForLoop | null = null,
): ReturnType<typeof matchBytesLoopVersion> {
const fn = LOOPS.of(this).bytesLoopFunction;
if (!fn) return null;
@@ -4260,17 +4271,22 @@ export class LlEmitter {
const invariantGlobals = new Set(this.stableGlobals);
for (const global of this.initializerBindings.get(fn.name) ?? [])
invariantGlobals.add(global.id);
return matchBytesLoopVersion(s, counted, {
locals: this.currentLocals,
invariantGlobals,
captured: this.captureIds,
ranges: this.integerRanges,
initialized,
proven: this.bytesBounds,
workers: this.mod.workers === true,
owned: this.bytesOwned,
scalarStrings: new Set(this.stringSlices.keys()),
});
return matchBytesLoopVersion(
s,
counted,
{
locals: this.currentLocals,
invariantGlobals,
captured: this.captureIds,
ranges: this.integerRanges,
initialized,
proven: this.bytesBounds,
workers: this.mod.workers === true,
owned: this.bytesOwned,
scalarStrings: new Set(this.stringSlices.keys()),
},
paired,
);
}
/** The alias tag of a whole-slot load of a binding (module globals only). */
@@ -6279,6 +6295,41 @@ export class LlEmitter {
return ok;
}
/** Branches on "the array `arr` is frozen" (SCR_ARR_FROZEN in its storage
* flags, scr_array.h), or published too when `published`; like
* emitPublishedTest, leaves the builder in the cold block and answers the
* continuation label. */
private emitFrozenArrayTest(arr: string, published: boolean): string {
const B = this.B;
const sparep = B.tmp(),
spare = B.tmp(),
bit = B.tmp();
let frozen = B.tmp();
B.line(
`${sparep} = getelementptr inbounds %ScrArr, ptr ${arr}, i32 0, i32 ${SCR_ARR_FIELD.spare}`,
);
B.line(`${spare} = load i16, ptr ${sparep}`);
B.line(`${bit} = and i16 ${spare}, ${SCR_ARR_FROZEN}`);
B.line(`${frozen} = icmp ne i16 ${bit}, 0`);
if (published) {
const rc = B.tmp(),
immortal = B.tmp(),
either = B.tmp();
B.line(`${rc} = load ${this.sizeType}, ptr ${arr}`);
B.line(`${immortal} = icmp eq ${this.sizeType} ${rc}, -1`);
B.line(`${either} = or i1 ${frozen}, ${immortal}`);
frozen = either;
}
this.declare(`declare i1 @llvm.expect.i1(i1, i1)`);
const expected = B.tmp();
B.line(`${expected} = call i1 @llvm.expect.i1(i1 ${frozen}, i1 false)`);
const cold = B.newLabel("arr.frozen"),
ok = B.newLabel("arr.ok");
B.condBr(expected, cold, ok);
B.startBlock(cold);
return ok;
}
private publishedNamesSym: string | null = null;
/** The class-name table the hierarchy field guards index by preorder. */
@@ -6343,15 +6394,29 @@ export class LlEmitter {
op: number,
index = f64Lit(0),
count = f64Lit(0),
third: string | null = null,
): void {
if (this.publishedTypes?.containerGuarded(arrType) !== true) return;
const published = this.publishedTypes;
if (published?.containerGuarded(arrType) !== true) return;
const B = this.B;
const ok = this.emitPublishedTest(arr);
this.declare(`declare zeroext i1 @scr_throw_published_array(i32, ptr, double, double)`);
const guards = published.arrayGuards(arrType);
const ok = guards.frozen
? this.emitFrozenArrayTest(arr, guards.published)
: this.emitPublishedTest(arr);
const threw = B.tmp();
B.line(
`${threw} = call zeroext i1 @scr_throw_published_array(i32 ${op}, ptr ${arr}, double ${index}, double ${count})`,
);
if (third === null) {
this.declare(`declare zeroext i1 @scr_throw_published_array(i32, ptr, double, double)`);
B.line(
`${threw} = call zeroext i1 @scr_throw_published_array(i32 ${op}, ptr ${arr}, double ${index}, double ${count})`,
);
} else {
this.declare(
`declare zeroext i1 @scr_throw_published_array_range(i32, ptr, double, double, double)`,
);
B.line(
`${threw} = call zeroext i1 @scr_throw_published_array_range(i32 ${op}, ptr ${arr}, double ${index}, double ${count}, double ${third})`,
);
}
const unwind = B.newLabel("pub.throw");
B.condBr(threw, unwind, ok);
B.startBlock(unwind);
packages/compiler/src/backend/llvm/expr-async.ts
+11 -13
View File
@@ -184,7 +184,7 @@ export function emitIntrinsicExpr(host: LlvmEmitterContext, e: ExprOf<"intrinsic
}
const v = host.emitExpr(e.args[0]!);
const t = e.args[0]!.type;
if (t.kind === "f64" || t.kind === "date") {
if (t.kind === "f64") {
host.declare(`declare void @scr_promise_fulfill_f64(ptr, double)`);
B.line(`call void @scr_promise_fulfill_f64(ptr ${p}, double ${v.name})`);
} else if (t.kind === "bool") {
@@ -500,7 +500,7 @@ export function emitAsyncExpr(
host.declare(`declare void @scr_async_gen_hop_done()`);
B.line(`call void @scr_async_gen_hop_done()`);
}
if (yt.kind === "f64" || yt.kind === "date") {
if (yt.kind === "f64") {
if (host.currentCoro !== null) {
const coro = host.currentCoro;
if (coro.out !== null) host.emitGenSlotStore(coro.out, "f64", v.name);
@@ -582,7 +582,7 @@ export function emitAsyncExpr(
return { name: "", type: e.type };
}
const t = B.tmp();
if (e.type.kind === "f64" || e.type.kind === "date") {
if (e.type.kind === "f64") {
host.declare(`declare double @scr_gen_take_in_f64()`);
B.line(`${t} = call double @scr_gen_take_in_f64()`);
return { name: t, type: e.type };
@@ -710,12 +710,12 @@ export function emitAsyncExpr(
throw new InternalCompilerError(`llvm emitter bug: genResume ${e.mode} on async`);
const gb = emitBorrowedInput(host, e.gen);
if (e.mode === "value") {
if (!host.wasi && (e.type.kind === "f64" || e.type.kind === "date"))
if (!host.wasi && e.type.kind === "f64")
return { name: host.emitGenSlotTake(host.genOutSlot(gb.name), "f64"), type: e.type };
if (!host.wasi && e.type.kind === "bool")
return { name: host.emitGenSlotTake(host.genOutSlot(gb.name), "bool"), type: e.type };
const t = B.tmp();
if (e.type.kind === "f64" || e.type.kind === "date") {
if (e.type.kind === "f64") {
host.declare(`declare double @scr_gen_take_out_f64(ptr)`);
B.line(`${t} = call double @scr_gen_take_out_f64(ptr ${gb.name})`);
return { name: t, type: e.type };
@@ -752,7 +752,7 @@ export function emitAsyncExpr(
store(a.name, e.arg!.type);
};
const parkIn = (name: string, t: IrType): void => {
if (t.kind === "f64" || t.kind === "date") {
if (t.kind === "f64") {
host.declare(`declare void @scr_gen_in_f64(ptr, double)`);
B.line(`call void @scr_gen_in_f64(ptr ${g.name}, double ${name})`);
} else if (t.kind === "bool") {
@@ -787,7 +787,7 @@ export function emitAsyncExpr(
const a = host.emitExpr(e.arg);
const t = e.arg.type;
if (isRefCounted(t)) host.toHeap(a);
if (t.kind === "f64" || t.kind === "date") {
if (t.kind === "f64") {
host.declare(`declare ptr @scr_async_gen_next_f64(ptr, double)`);
call = `call ptr @scr_async_gen_next_f64(ptr ${g.name}, double ${a.name})`;
} else if (t.kind === "bool") {
@@ -806,7 +806,7 @@ export function emitAsyncExpr(
const a = host.emitExpr(e.arg);
const t = e.arg.type;
if (isRefCounted(t)) host.toHeap(a);
if (t.kind === "f64" || t.kind === "date") {
if (t.kind === "f64") {
host.declare(`declare ptr @scr_async_gen_return_f64(ptr, double)`);
call = `call ptr @scr_async_gen_return_f64(ptr ${g.name}, double ${a.name})`;
} else if (t.kind === "bool") {
@@ -849,7 +849,7 @@ export function emitAsyncExpr(
B.line(`call void @scr_gen_ret_none(ptr ${g.name})`);
} else {
sendArg((name, t) => {
if (t.kind === "f64" || t.kind === "date") {
if (t.kind === "f64") {
host.declare(`declare void @scr_gen_ret_f64(ptr, double)`);
B.line(`call void @scr_gen_ret_f64(ptr ${g.name}, double ${name})`);
} else if (t.kind === "bool") {
@@ -960,7 +960,7 @@ export function emitAsyncExpr(
return { name: "", type: e.type };
}
const t = B.tmp();
if (e.type.kind === "f64" || e.type.kind === "date") {
if (e.type.kind === "f64") {
const f64Await = host.awaitResultFn("f64");
host.declare(`declare double @${f64Await}(ptr)`);
B.line(`${t} = call double @${f64Await}(ptr ${pr.name})`);
@@ -1050,7 +1050,7 @@ export function emitAsyncExpr(
const peek = host.unionPeek(u.name, def.id);
if (host.coroAwait) host.emitCoroAwait(peek);
let awaited: LlValue;
if (inner.kind === "f64" || inner.kind === "date") {
if (inner.kind === "f64") {
const f64Await = host.awaitResultFn("f64");
host.declare(`declare double @${f64Await}(ptr)`);
const x = B.tmp();
@@ -1136,7 +1136,6 @@ export function emitAsyncExpr(
let resolve: string;
const kindNums: Partial<Record<IrType["kind"], number>> = {
f64: 0,
date: 0,
bool: 1,
string: 2,
void: 3,
@@ -1191,7 +1190,6 @@ export function emitAsyncExpr(
B.line(`${p} = call ptr @scr_promise_new()`);
const kindNums: Partial<Record<IrType["kind"], number>> = {
f64: 0,
date: 0,
bool: 1,
string: 2,
void: 3,
packages/compiler/src/backend/llvm/expr-calls.ts
+4
View File
@@ -44,6 +44,7 @@ import { LlvmUnsupportedError } from "./unsupported.js";
import type { LlvmEmitterContext, ExprOf, LlValue } from "./expr-context.js";
import { f64Lit, ffiNativeTypeLl, ffiNativeParamLl, ffiNativeReturnLl } from "./common.js";
import { canStackUnion, emitStackUnion } from "./stack-unions.js";
import { emitStackRecordKeyGet, scalarRecordKeyGet } from "./expr-records.js";
import { emitCallArrayRead } from "./local-array-reads.js";
import { emitScalarOptional, isScalarOptionalSource } from "./local-union-storage.js";
import { emitStackMapRead } from "./map-read-lifetimes.js";
@@ -166,6 +167,9 @@ export function emitCallExpr(
return { name: host.emitOwnedNullableStack(a).box, type: a.type };
// An inline union field read copies its tag and bits.
if (host.inlineFieldGet(a)) return host.emitReadReceiver(a);
// A scalar keyed record read writes its tag and bits.
if (a.kind === "recordKeyGet" && scalarRecordKeyGet(host, a))
return { name: emitStackRecordKeyGet(host, a), type: a.type };
}
if (inputs[index]) return host.emitReadReceiver(a);
}
packages/compiler/src/backend/llvm/expr-containers.ts
+52 -3
View File
@@ -257,6 +257,16 @@ function emitDiscarded(host: LlvmEmitterContext, e: IrExpr): void {
const start = host.emitExpr(e.args[0]!);
const count = e.args[1] ? host.emitExpr(e.args[1]).name : F64_INF;
const values = items.map((item) => host.emitExpr(item));
// Before the values move into the buffer: a throw releases them with the
// frame.
host.emitPublishedArrayGuard(
r.name,
e.receiver.type,
10,
start.name,
count,
f64Lit(values.length),
);
if (acc === "ref") values.forEach((value) => host.toHeap(value));
let buffer = "null";
if (values.length > 0) {
@@ -904,6 +914,12 @@ export function emitArrIntrinsic(
B.line(`${t} = call ptr @${helper}(ptr ${r.name}, ptr ${sep.name})`);
return host.own({ name: t, type: e.type });
}
if (elem.kind === "date") {
host.declare(`declare ptr @scr_date_arr_join(ptr, ptr)`);
const t = B.tmp();
B.line(`${t} = call ptr @scr_date_arr_join(ptr ${r.name}, ptr ${sep.name})`);
return host.own({ name: t, type: e.type });
}
host.declare(`declare ptr @scr_arr_join(ptr, ptr)`);
const t = B.tmp();
B.line(`${t} = call ptr @scr_arr_join(ptr ${r.name}, ptr ${sep.name})`);
@@ -928,6 +944,16 @@ export function emitArrIntrinsic(
case "sortPrimitive":
case "toSortedPrimitive": {
if (e.method === "sortPrimitive") host.emitPublishedArrayGuard(r.name, e.receiver.type, 7);
if (elem.kind === "date") {
// Dates order by their toString() text.
host.declare(`declare ptr @scr_arr_sort_by_text(ptr, i1 zeroext, ptr)`);
host.declare(`declare ptr @scr_date_object_to_string(ptr)`);
const sorted = B.tmp();
B.line(
`${sorted} = call ptr @scr_arr_sort_by_text(ptr ${r.name}, i1 ${e.method === "toSortedPrimitive" ? 1 : 0}, ptr @scr_date_object_to_string)`,
);
return host.own({ name: sorted, type: e.type });
}
host.declare(`declare ptr @scr_arr_sort_primitive(ptr, i1 zeroext)`);
const result = B.tmp();
B.line(
@@ -978,7 +1004,25 @@ export function emitArrIntrinsic(
case "fill":
case "fillUndefined": {
const args = e.args.map((arg) => host.emitExpr(arg));
host.emitPublishedArrayGuard(r.name, e.receiver.type, 7);
// fill's range is its last two arguments; copyWithin's target,
// start and end are its three.
if (e.method === "copyWithin")
host.emitPublishedArrayGuard(
r.name,
e.receiver.type,
9,
args[0]!.name,
args[1]!.name,
args[2]!.name,
);
else
host.emitPublishedArrayGuard(
r.name,
e.receiver.type,
8,
args[args.length - 2]!.name,
args[args.length - 1]!.name,
);
if (host.checkedFills.has(e)) {
// A new int32 array with checked stores, filled with a value that
// may not be an int32: widen it first then.
@@ -1042,7 +1086,7 @@ export function emitArrIntrinsic(
// removes to the end (+Infinity, the slice convention).
const start = host.emitExpr(e.args[0]!);
const cnt = e.args[1] ? host.emitExpr(e.args[1]).name : F64_INF;
host.emitPublishedArrayGuard(r.name, e.receiver.type, 7);
host.emitPublishedArrayGuard(r.name, e.receiver.type, 10, start.name, cnt, f64Lit(0));
host.declare(`declare ptr @scr_arr_splice(ptr, double, double)`);
const t = B.tmp();
B.line(`${t} = call ptr @scr_arr_splice(ptr ${r.name}, double ${start.name}, double ${cnt})`);
@@ -1052,7 +1096,12 @@ export function emitArrIntrinsic(
const start = host.emitExpr(e.args[0]!);
const count = host.emitExpr(e.args[1]!);
const items = emitBorrowedInput(host, e.args[2]!);
host.emitPublishedArrayGuard(r.name, e.receiver.type, 7);
if (host.publishedTypes?.containerGuarded(e.receiver.type) === true) {
host.declare(`declare double @scr_arr_len(ptr)`);
const n = B.tmp();
B.line(`${n} = call double @scr_arr_len(ptr ${items.name})`);
host.emitPublishedArrayGuard(r.name, e.receiver.type, 10, start.name, count.name, n);
}
host.declare(`declare ptr @scr_arr_splice_insert(ptr, double, double, ptr)`);
const t = B.tmp();
B.line(
packages/compiler/src/backend/llvm/expr-dynamic.ts
+5 -1
View File
@@ -18,6 +18,7 @@ import {
type IrExpr,
type IrType,
isDynTypedRefType,
textCodecRecordClass,
isRefCounted,
isUnitType,
typeEquals,
@@ -86,7 +87,10 @@ export function emitDynamicExpr(
// Bytes already box their shared mutable storage directly. A second
// capsule would split identity between checked and native views.
const errorRef = v.type.kind === "object" && host.shapeHost.isErrorClass(v.type.className);
if (!errorRef && ((e.liveRef && v.type.kind !== "bytes") || identityRef)) {
// A TextEncoder or TextDecoder record boxes as its own handle, which
// keeps the record's identity (toDynHelper).
const codecRef = textCodecRecordClass(v.type, (id) => host.recordsById.get(id)) !== null;
if (!errorRef && !codecRef && ((e.liveRef && v.type.kind !== "bytes") || identityRef)) {
if (v.type.kind === "union") {
const adapter = host.liveDynUnionRefAdapter(v.type);
const boxed = B.tmp();
packages/compiler/src/backend/llvm/expr-primitives.ts
+3 -1
View File
@@ -1076,9 +1076,10 @@ export function emitContainerExpr(
const idx = host.emitExpr(e.index);
if (e.arr.type.kind !== "array")
throw new InternalCompilerError("llvm emitter bug: arrayState on non-array");
const proven = host.provenDenseIndex(e.arr, e.index);
const t = host.checkedInt32Array(e.arr)
? host.emitByElementKind(arr.name, "double", (kind) =>
emitDenseArrayState(host, arr.name, idx, e.index, "state", slotWidth(kind)),
emitDenseArrayState(host, arr.name, idx, e.index, "state", slotWidth(kind), proven),
)!
: emitDenseArrayState(
host,
@@ -1087,6 +1088,7 @@ export function emitContainerExpr(
e.index,
"state",
host.int32Array(e.arr) ? slotWidth("i32") : denseSlotWidth(host, e.arr.type.elem),
proven,
);
return { name: t, type: e.type };
}
packages/compiler/src/backend/llvm/expr-records.ts
+109
View File
@@ -7,6 +7,7 @@ import type { LlvmEmitterContext, LlValue } from "./expr-context.js";
import { f64Lit, llvmCommentText } from "./common.js";
import { borrowableInputs, emitBorrowedInputs, emitBorrowedInput } from "./borrowed-inputs.js";
import { regexLiteralTemplate } from "./expr-primitives.js";
import { isScalarUnionDef, loadInlineUnion, presentBits } from "./inline-unions.js";
import { preservesRegexInputs } from "./reference-effects.js";
/** Widen one tagged read. The source is borrowed unless the overflow map
@@ -365,6 +366,114 @@ export function emitRecordKeyGet(
return host.own({ name: t, type: e.type });
}
/** A keyed read whose result is a scalar union (`r[k]` on a
* `Record<string, number>`, at `number | undefined`) and whose every hit
* is a number or boolean arm of it, or an inline field of the same union.
* Projections (`??`, `!`, tag tests) read it as a private stack box, so
* the read allocates nothing. */
export function scalarRecordKeyGet(host: LlvmEmitterContext, e: IrExpr): boolean {
if (e.kind !== "recordKeyGet" || e.missNaN === true || e.type.kind !== "union") return false;
const resultType = e.type;
const def = host.unionsById.get(resultType.unionId);
if (!isScalarUnionDef(def) || undefinedArmTag(resultType, host.unionsById) < 0) return false;
const isArm = (t: IrType): boolean =>
(t.kind === "f64" || t.kind === "bool") && def!.arms.some((a) => typeEquals(a, t));
const shape = host.recordShape(e.shapeId);
if (e.overflowOnly !== true) {
for (const f of shape.fields) {
const inline = host.recordFieldInline(e.shapeId, f.name);
if (!isArm(f.type) && !(inline && typeEquals(f.type, resultType))) return false;
}
}
return shape.indexValue === undefined || isArm(shape.indexValue);
}
/** A scalarRecordKeyGet read as a private stack box: the tag and bits of
* the declared field or overflow entry the key names, or the undefined arm
* for a miss. The box must never reach an RC entry point. */
export function emitStackRecordKeyGet(
host: LlvmEmitterContext,
e: IrExpr & { kind: "recordKeyGet" },
): string {
const B = host.B;
if (e.type.kind !== "union")
throw new InternalCompilerError("llvm emitter bug: stack keyed read of a non-union");
const resultType = e.type;
const def = host.unionsById.get(resultType.unionId)!;
const armTag = (t: IrType): number => def.arms.findIndex((a) => typeEquals(a, t));
const obj = host.emitExpr(e.obj);
const key = host.emitExpr(e.key);
const box = B.slot();
B.entryAllocas.push(`${box} = alloca %ScrUnion`);
const tagPtr = B.tmp(),
bitsPtr = B.tmp();
B.line(`store ${host.sizeType} -1, ptr ${box}`);
B.line(`${tagPtr} = getelementptr inbounds %ScrUnion, ptr ${box}, i64 0, i32 1`);
B.line(`${bitsPtr} = getelementptr inbounds %ScrUnion, ptr ${box}, i64 0, i32 5`);
const join = B.newLabel("rks.j");
const storeScalar = (t: IrType, value: string): void => {
const bits = B.tmp();
if (t.kind === "f64") B.line(`${bits} = bitcast double ${value} to i64`);
else B.line(`${bits} = zext i1 ${value} to i64`);
B.line(`store i32 ${armTag(t)}, ptr ${tagPtr}`);
B.line(`store i64 ${bits}, ptr ${bitsPtr}`);
};
const shape = host.recordShape(e.shapeId);
for (const f of e.overflowOnly === true ? [] : shape.fields) {
const hit = B.tmp();
B.line(
`${hit} = call zeroext i1 ${host.literalEquals(f.name)}(ptr ${key.name}) ; ${llvmCommentText(f.name)}`,
);
const lh = B.newLabel("rks.h");
const ln = B.newLabel("rks.n");
B.condBr(hit, lh, ln);
B.startBlock(lh);
const { ptr, type, inline } = host.recordFieldPtr(obj.name, e.shapeId, f.name);
if (inline) {
const { tag, bits } = loadInlineUnion(B, ptr);
const present = presentBits(B, tag, bits, undefinedArmTag(type, host.unionsById));
B.line(`store i32 ${tag}, ptr ${tagPtr}`);
B.line(`store i64 ${present}, ptr ${bitsPtr}`);
} else {
storeScalar(type, host.loadRecordField(ptr, type, false));
}
B.br(join);
B.startBlock(ln);
}
const iv = shape.indexValue;
if (iv) {
const ovf = host.recordOvfPtr(obj.name, e.shapeId);
const outTy = iv.kind === "f64" ? "double" : "i8";
const outSlot = B.slot();
B.entryAllocas.push(`${outSlot} = alloca ${outTy}`);
B.line(`store ${outTy} ${iv.kind === "f64" ? f64Lit(0) : "0"}, ptr ${outSlot}`);
const getter = `scr_map_get_str_${iv.kind === "f64" ? "f64" : "bool"}`;
host.declare(`declare zeroext i1 @${getter}(ptr, ptr, ptr)`);
const found = B.tmp();
B.line(`${found} = call zeroext i1 @${getter}(ptr ${ovf}, ptr ${key.name}, ptr ${outSlot})`);
const lh = B.newLabel("rks.h");
const ln = B.newLabel("rks.n");
B.condBr(found, lh, ln);
B.startBlock(lh);
const raw = B.tmp();
B.line(`${raw} = load ${outTy}, ptr ${outSlot}`);
let value = raw;
if (iv.kind === "bool") {
value = B.tmp();
B.line(`${value} = trunc i8 ${raw} to i1`);
}
storeScalar(iv, value);
B.br(join);
B.startBlock(ln);
}
// A miss is the undefined arm.
B.line(`store i32 ${undefinedArmTag(resultType, host.unionsById)}, ptr ${tagPtr}`);
B.line(`store i64 0, ptr ${bitsPtr}`);
B.br(join);
B.startBlock(join);
return box;
}
export function keyedRecordReadInto(
host: LlvmEmitterContext,
slot: string,
packages/compiler/src/backend/llvm/expr-stream-bridges.ts
+20 -9
View File
@@ -16,6 +16,7 @@ import {
KEY_ORDER_FIELD,
shapeKeyOrders,
isDynTypedRefType,
textCodecRecordClass,
isRefCounted,
shapeHasAccessorSlots,
typeKey,
@@ -121,12 +122,7 @@ export function dynPromiseAdapter(host: LlvmEmitterContext, inner: IrType): stri
if (inner.kind === "void") {
host.declare(`declare void @scr_promise_fulfill_void(ptr)`);
B.line(`call void @scr_promise_fulfill_void(ptr %dst)`);
} else if (
inner.kind === "f64" ||
inner.kind === "date" ||
inner.kind === "procStream" ||
inner.kind === "bool"
) {
} else if (inner.kind === "f64" || inner.kind === "procStream" || inner.kind === "bool") {
const fn = inner.kind !== "bool" ? "scr_promise_fulfill_f64" : "scr_promise_fulfill_bool";
host.declare(
`declare void @${fn}(ptr, ${host.llType(inner)}${inner.kind === "bool" ? " zeroext" : ""})`,
@@ -597,12 +593,21 @@ export function liveDynUnionRefAdapter(
if (!union) {
throw new InternalCompilerError(`llvm emitter bug: live dyn ref of unknown union ${t.unionId}`);
}
// Codec records box as their own handles, by reference, through toDynHelper.
const codecArm = (arm: IrType): boolean =>
textCodecRecordClass(arm, (id) => host.recordsById.get(id)) !== null;
const mutableArms = union.arms
.map((arm, tag) => ({ arm, tag }))
.filter(
({ arm }) => arm.kind !== "bytes" && (streamTypedRefEligible(arm) || isDynTypedRefType(arm)),
({ arm }) =>
arm.kind !== "bytes" &&
!codecArm(arm) &&
(streamTypedRefEligible(arm) || isDynTypedRefType(arm)),
);
if (mutableArms.length === 0 && !union.arms.some((arm) => arm.kind === "bytes")) {
if (
mutableArms.length === 0 &&
!union.arms.some((arm) => arm.kind === "bytes" || codecArm(arm))
) {
throw new InternalCompilerError(`llvm emitter bug: live dyn ref of immutable union ${key}`);
}
@@ -712,7 +717,13 @@ export function streamTypedRefBoxValue(
B.line(`${boxed} = call ptr @${host.liveDynUnionRefAdapter(t)}(ptr ${value})`);
return boxed;
}
if (t.kind === "bytes" || (!streamTypedRefEligible(t) && !isDynTypedRefType(t))) {
// A codec record boxes as its own handle, by reference (toDynHelper), as
// it does outside a live view.
if (
t.kind === "bytes" ||
textCodecRecordClass(t, (id) => host.recordsById.get(id)) !== null ||
(!streamTypedRefEligible(t) && !isDynTypedRefType(t))
) {
const valueTy = host.llType(t);
B.line(`${boxed} = call ptr @${host.dyn.toDynHelper(t)}(${valueTy} ${value})`);
return boxed;
packages/compiler/src/backend/llvm/lib-dispatch.ts
+112 -4
View File
@@ -9,7 +9,7 @@ import { emitTestLibCall } from "./lib-test.js";
import { InternalCompilerError } from "../../errors.js";
import { MAY_THROW_LIB_FNS } from "../../ir/builtin-effects.js";
import type { IrExpr, IrType } from "../../ir/ir.js";
import { F64, type IrExpr, type IrType } from "../../ir/ir.js";
import { LlvmUnsupportedError } from "./unsupported.js";
import { emitJsLibCall } from "./jsval.js";
import type { LlvmEmitterContext, LibCallExpr, LibCallPrefix, LlValue } from "./expr-context.js";
@@ -25,6 +25,9 @@ import { rawBytes } from "./lib-abi.js";
import { emitInlineAtomicsOp } from "./expr-bytes.js";
import { regexLiteralCaptures } from "./regex-matchers.js";
/** ScrDyn.v.typed_ref.type_key_len: the low 27 bits of its bit-field word. */
const TYPE_KEY_LEN_MASK = (1 << 27) - 1;
export function emitAssertInspectLibCall(host: LlvmEmitterContext, e: LibCallExpr): LlValue {
const B = host.B;
if (e.fn === "assert.shapeStr" || e.fn === "assert.shapeRe") {
@@ -236,6 +239,15 @@ export function emitGenericLibCall(host: LlvmEmitterContext, e: LibCallExpr): Ll
host.emitPendingCheck();
return output;
}
if (e.fn === "record.sourceSpread") {
const built = host.emitReadReceiver(e.args[0]!);
const value = host.emitReadReceiver(e.args[1]!);
const type = e.args[0]!.type;
if (type.kind !== "record")
throw new InternalCompilerError("llvm emitter bug: record.sourceSpread of a non-record");
host.dyn.emitRecordSourceSpread(B, built.name, value.name, type.shapeId);
return { name: "", type: e.type };
}
if (e.fn === "dyn.typedRefIs" || e.fn === "dyn.typedRefKeyIs") {
const literal = e.args[1]!.kind === "strLit" ? e.args[1]!.value : null;
if (e.fn === "dyn.typedRefKeyIs" && literal === null)
@@ -281,6 +293,38 @@ export function emitGenericLibCall(host: LlvmEmitterContext, e: LibCallExpr): Ll
B.line(`store i1 true, ptr ${slot}`);
B.condBr(same, done, compare);
B.startBlock(compare);
// A capsule with another key pointer usually belongs to another
// class: reject it on its key length and last eight bytes before
// the out-of-line name comparison, so a class table's chain of
// probes costs a few instructions per class it skips.
B.line(`store i1 false, ptr ${slot}`);
const bytes = Buffer.from(literal, "utf8");
const lenSlot = B.tmp(),
lenWord = B.tmp(),
len = B.tmp(),
lenEq = B.tmp();
B.line(
`${lenSlot} = getelementptr inbounds i8, ptr ${value.name}, i64 ${host.abiOffset(88, 52)} ; ->v.typed_ref.type_key_len`,
);
B.line(`${lenWord} = load i32, ptr ${lenSlot}`);
B.line(`${len} = and i32 ${lenWord}, ${TYPE_KEY_LEN_MASK}`);
B.line(`${lenEq} = icmp eq i32 ${len}, ${bytes.length}`);
const full = B.newLabel("brand.full");
if (bytes.length >= 8) {
const tail = B.newLabel("brand.tail");
B.condBr(lenEq, tail, done);
B.startBlock(tail);
const tailPtr = B.tmp(),
word = B.tmp(),
wordEq = B.tmp();
B.line(`${tailPtr} = getelementptr inbounds i8, ptr ${keyPtr}, i64 ${bytes.length - 8}`);
B.line(`${word} = load i64, ptr ${tailPtr}, align 1`);
B.line(`${wordEq} = icmp eq i64 ${word}, ${bytes.readBigInt64LE(bytes.length - 8)}`);
B.condBr(wordEq, full, done);
} else {
B.condBr(lenEq, full, done);
}
B.startBlock(full);
}
}
if (e.fn === "dyn.typedRefIs") {
@@ -594,16 +638,66 @@ export function emitGenericLibCall(host: LlvmEmitterContext, e: LibCallExpr): Ll
? "scr_stream_dyn_async_iterator_open"
: LIB_FN_SYMS[e.fn]);
if (sym === undefined) throw new LlvmUnsupportedError(`libCall:${e.fn}`, e.loc);
// The runtime's Date functions take and answer time values: a Date
// operand passes its time value, read at once from the borrowed object,
// and a Date result is a new Date object.
const args = READ_ONLY_STRING_LIB_FNS.has(e.fn)
? emitBorrowedInputs(host, e.args)
: e.args.map((a) =>
borrowsJsonInputs(e.fn) || borrowsIteratorInputs(e.fn)
? emitBorrowedInput(host, a)
: host.emitExpr(a),
a.type.kind === "date"
? { name: emitDateTimeArg(host, a), type: F64 }
: borrowsJsonInputs(e.fn) || borrowsIteratorInputs(e.fn)
? emitBorrowedInput(host, a)
: host.emitExpr(a),
);
// getTime and valueOf answer the time value the argument already is.
if ((e.fn === "date.getTime" || e.fn === "date.valueOf") && e.args[0]?.type.kind === "date")
return { name: args[0]!.name, type: e.type };
// The deep comparisons' number test: computed here, with no runtime call.
if (e.fn === "assert.sameValue")
return { name: emitSameValueF64(host, args[0]!.name, args[1]!.name), type: e.type };
const callArgs = args;
if (e.type.kind === "date") {
const ms = emitSymbolLibCall(host, { ...e, type: F64 }, sym, callArgs);
host.declare(`declare ptr @scr_date_new(double)`);
const date = B.tmp();
B.line(`${date} = call ptr @scr_date_new(double ${ms.name})`);
return host.own({ name: date, type: e.type });
}
return emitSymbolLibCall(host, e, sym, callArgs);
}
/** The time value of a Date argument. A Date that a runtime Date function
* produces for this argument alone (`new Date(ms).getTime()`, a
* time-value local's read) passes the function's time value and creates
* no Date object. */
function emitDateTimeArg(host: LlvmEmitterContext, date: IrExpr): string {
// A time-value local's read is its time value itself.
if (date.kind === "libCall" && date.fn === "date.fromTime")
return host.emitExpr(date.args[0]!).name;
if (date.kind === "libCall" && date.fn.startsWith("date."))
return emitGenericLibCall(host, { ...date, type: F64 }).name;
return emitDateTime(host, emitBorrowedInput(host, date).name);
}
/** A Date object's time value (ScrDate.ms). */
function emitDateTime(host: LlvmEmitterContext, date: string): string {
const B = host.B;
const field = B.tmp();
const ms = B.tmp();
B.line(`${field} = getelementptr inbounds i8, ptr ${date}, i64 8 ; ->ms`);
B.line(`${ms} = load double, ptr ${field}`);
return ms;
}
/** The call of runtime function `sym` with evaluated arguments. */
function emitSymbolLibCall(
host: LlvmEmitterContext,
e: LibCallExpr,
sym: string,
args: readonly LlValue[],
): LlValue {
const B = host.B;
const argDecls = args.map((a) => {
const ty = host.llType(a.type);
return ty === "i1" ? "i1 zeroext" : ty;
@@ -805,6 +899,19 @@ export function emitLibCall(host: LlvmEmitterContext, e: LibCallExpr): LlValue {
return { name: t, type: e.type };
}
if (e.fn === "bytes.absent") return host.own({ name: "null", type: e.type });
if (e.fn === "record.isFrozen") {
// The frozen bit of the record's rc word (scr_rc.h SCR_RC_FROZEN) is
// its second-highest bit; an immortal word sets the highest one too.
const value = host.emitReadReceiver(e.args[0]!);
const S = host.sizeType;
const rc = host.B.tmp(),
top = host.B.tmp(),
t = host.B.tmp();
host.B.line(`${rc} = load ${S}, ptr ${value.name}`);
host.B.line(`${top} = lshr ${S} ${rc}, ${S === "i64" ? 62 : 30}`);
host.B.line(`${t} = icmp eq ${S} ${top}, 1`);
return { name: t, type: e.type };
}
const prefix = e.fn.slice(0, e.fn.indexOf(".")) as LibCallPrefix;
// events.once builds typed listener adapters beside the emitter calls.
if (e.fn === "events.once" || e.fn === "events.onceSignal")
@@ -913,6 +1020,7 @@ export function emitLibCall(host: LlvmEmitterContext, e: LibCallExpr): LlValue {
case "blob":
case "wasm":
case "array":
case "collection":
case "record":
case "disposable":
case "punycode":
packages/compiler/src/backend/llvm/lib-process.ts
+51 -1
View File
@@ -1,10 +1,11 @@
/* Focused LLVM library-call emission extracted from emitter.ts. */
import { InternalCompilerError } from "../../errors.js";
import { undefinedArmTag } from "../../ir/analysis.js";
import { F64, RUNTIME_ERROR_CLASSES, STRING } from "../../ir/ir.js";
import { F64, type IrType, RUNTIME_ERROR_CLASSES, STRING, typeKey } from "../../ir/ir.js";
import type { LlvmEmitterContext, LibCallExpr, LlValue } from "./expr-context.js";
import { f64Lit } from "./common.js";
import { mockTimerSym } from "./lib-shared.js";
import { FN_ATTRS } from "./shapes.js";
export function emitChildProcessLibCall(host: LlvmEmitterContext, e: LibCallExpr): LlValue {
const B = host.B;
@@ -460,9 +461,58 @@ export function emitAsyncContextLibCall(host: LlvmEmitterContext, e: LibCallExpr
for (const a of e.args) host.emitExpr(a);
return { name: "", type: e.type };
}
if (e.fn === "als.bindCallback") {
// The closure moves into the bound closure, whose entry is the
// per-signature thunk; with nothing to bind the runtime answers the
// closure itself.
if (e.type.kind !== "func")
throw new InternalCompilerError("llvm emitter bug: als.bindCallback on non-func");
const cb = host.emitExpr(e.args[0]!);
const always = host.emitExpr(e.args[1]!);
host.toHeap(cb);
const thunk = boundCallbackThunk(host, e.type);
host.declare("declare ptr @scr_als_bind_closure(ptr, ptr, i1 zeroext)");
const t = B.tmp();
B.line(
`${t} = call ptr @scr_als_bind_closure(ptr ${cb.name}, ptr @${thunk}, i1 ${always.name})`,
);
return host.own({ name: t, type: e.type });
}
return host.emitGenericLibCall(e);
}
/** The entry of a callback bound to an AsyncLocalStorage context, one per
* callback signature: enters the captured context, calls the target with
* the same arguments (the callValue ABI) and restores the caller's
* context, also when the target leaves an exception pending. */
function boundCallbackThunk(host: LlvmEmitterContext, cbT: IrType & { kind: "func" }): string {
const key = `alsbound:${typeKey(cbT)}`;
let sym = host.resolveThunks.get(key);
if (sym) return sym;
sym = `sc_alsbound_${host.resolveThunks.size}`;
host.resolveThunks.set(key, sym);
host.declare("declare ptr @scr_als_bound_target(ptr)");
host.declare("declare ptr @scr_als_bound_enter(ptr)");
host.declare("declare void @scr_als_bound_leave(ptr, ptr)");
const ret = host.llType(cbT.ret);
const params = cbT.params.map((p, i) => `${host.llType(p)} %a${i}`);
const call = `call ${ret} %fn(${["ptr %cb", ...params].join(", ")})`;
host.resolveThunkDefs.push(
`define internal ${ret} @${sym}(${["ptr %self", ...params].join(", ")}) ${FN_ATTRS} { ; AsyncLocalStorage-bound callback ${typeKey(cbT)}`,
`entry:`,
` %cb = call ptr @scr_als_bound_target(ptr %self)`,
` %prev = call ptr @scr_als_bound_enter(ptr %self)`,
` %fnp = getelementptr inbounds %ScrClosure, ptr %cb, i64 0, i32 1`,
` %fn = load ptr, ptr %fnp`,
ret === "void" ? ` ${call}` : ` %r = ${call}`,
` call void @scr_als_bound_leave(ptr %prev, ptr %cb)`,
ret === "void" ? ` ret void` : ` ret ${ret} %r`,
`}`,
``,
);
return sym;
}
export function emitProcessLibCall(host: LlvmEmitterContext, e: LibCallExpr): LlValue {
const B = host.B;
if (e.fn === "process.forkTarget") {
packages/compiler/src/backend/llvm/lib-shared.ts
+17
View File
@@ -333,6 +333,7 @@ export const LIB_FN_SYMS: Record<string, string> = {
"date.parse": "scr_date_parse",
"date.getTime": "scr_date_get_time",
"date.valueOf": "scr_date_get_time",
"date.fromTime": "scr_date_get_time",
"date.parseGetTime": "scr_date_parse",
"date.utc": "scr_date_utc",
"date.newLocal": "scr_date_new_local",
@@ -560,6 +561,7 @@ export const LIB_FN_SYMS: Record<string, string> = {
"text.decoderEncoding": "scr_text_decoder_encoding",
"text.decoderName": "scr_text_decoder_name",
"text.encodeInto": "scr_text_encode_into",
"text.codecIs": "scr_text_codec_is",
"buffer.isAscii": "scr_buffer_is_ascii",
"buffer.isUtf8": "scr_buffer_is_utf8",
"buffer.transcode": "scr_buffer_transcode",
@@ -677,6 +679,7 @@ export const LIB_FN_SYMS: Record<string, string> = {
"insp.circular": "scr_insp_circular",
// Undeclared source properties kept beside a checked record (scr_json.c).
"record.sourceHas": "scr_record_source_has",
"record.sourceSpread": "scr_record_source_spread",
// WHATWG URL + URLSearchParams (scr_url.c / scr_url_params.c):
// constructions +1; url.new, the fileURLToPath pair, the win32
// pathToFileURL flavor, and sp.fromPairs throw catchably (may-throw).
@@ -958,6 +961,7 @@ export const LIB_FN_SYMS: Record<string, string> = {
"fetch.streamIs": "scr_fetch_stream_is",
"zlib.streamIs": "scr_zlib_stream_is",
"fetch.streamNew": "scr_fetch_stream_new",
"fetch.transformNew": "scr_fetch_transform_new",
"fetch.streamFrom": "scr_fetch_stream_from",
"fetch.readerRead": "scr_fetch_reader_read",
"json.parse": "scr_json_parse",
@@ -1019,6 +1023,12 @@ export const LIB_FN_SYMS: Record<string, string> = {
"class.descriptorHasValue": "scr_class_descriptor_has_value",
"class.throwReadOnly": "scr_class_throw_read_only",
"class.throwNotExtensible": "scr_class_throw_not_extensible",
"record.freeze": "scr_record_freeze",
"record.throwFrozen": "scr_record_throw_frozen",
"array.freeze": "scr_arr_freeze",
"array.isFrozen": "scr_arr_is_frozen",
"collection.preventExtensions": "scr_map_prevent_extensions",
"collection.isExtensible": "scr_map_is_extensible",
"dyn.nativeSetNew": "scr_dyn_native_set_new",
"dyn.nativeSetIs": "scr_dyn_native_set_is",
"dyn.nativeMapIs": "scr_dyn_native_map_is",
@@ -1061,6 +1071,7 @@ export const LIB_FN_SYMS: Record<string, string> = {
"crypto.generateKeyPairSync": "scr_crypto_generate_key_pair_sync",
"crypto.generateKeyPairCb": "scr_crypto_generate_key_pair_async",
"crypto.signOneshot": "scr_crypto_sign_oneshot",
"crypto.diffieHellman": "scr_crypto_diffie_hellman",
"crypto.verifyOneshot": "scr_crypto_verify_oneshot",
"crypto.createSign": "scr_crypto_create_sign",
"crypto.createVerify": "scr_crypto_create_verify",
@@ -1478,6 +1489,10 @@ export const LIB_FN_SYMS: Record<string, string> = {
"als.exitRun": "scr_als_exit_run",
"als.enterWith": "scr_als_enter_with",
"als.disable": "scr_als_disable",
"als.newOptions": "scr_als_new_options",
"als.name": "scr_als_name",
"als.bindCallbackDyn": "scr_als_bind_dyn",
"als.snapshot": "scr_als_snapshot",
"dc.chanBindStore": "scr_dc_chan_bind_store",
"dc.chanUnbindStore": "scr_dc_chan_unbind_store",
"dc.chanRunStores": "scr_dc_chan_run_stores",
@@ -1641,6 +1656,7 @@ export function mockTimerSym(
export const USES_TIMERS_LIB_FNS = new Set<string>([
"crypto.generateKeyPairCb",
"crypto.diffieHellman",
"crypto.checkPrimeCb",
"crypto.generatePrimeCb",
"process.emitWarning",
@@ -1691,6 +1707,7 @@ export const USES_TIMERS_LIB_FNS = new Set<string>([
"fetch.abortAny",
"fetch.streamNew",
"fetch.streamFrom",
"fetch.transformNew",
"readable.new",
// fs.ReadStream / fs.WriteStream open, read and write on the worker pool.
"fs.createReadStream",
packages/compiler/src/backend/llvm/local-array-reads.ts
+27 -1
View File
@@ -797,7 +797,33 @@ export function emitLocalArrayRead(
);
return null;
});
else if (inline)
else if (
inline &&
loopIndex !== null &&
read.element.kind === "f64" &&
host.provenDenseIndex(read.array, read.index)
) {
// In a dense array loop's fast copy, the entry test proved the counter
// below the array's hole-free prefix: the slot holds a present value,
// and the read has no missing arm.
const dataPtr = B.tmp(),
data = B.tmp(),
valuePtr = B.tmp(),
value = B.tmp(),
width = int32 ? "i32" : "i64";
B.line(
`${dataPtr} = getelementptr inbounds %ScrArr, ptr ${array.name}, i32 0, i32 ${SCR_ARR_FIELD.data}`,
);
host.markMemoryPointer(dataPtr, "array:header");
B.line(`${data} = load ptr, ptr ${dataPtr}${host.fieldAliasAttachment(dataPtr)}`);
B.line(
`${valuePtr} = getelementptr inbounds ${width}, ptr ${data}, ${host.sizeType} ${loopIndex}`,
);
host.markMemoryPointer(valuePtr, "array:elements");
B.line(`${value} = load ${width}, ptr ${valuePtr}${host.fieldAliasAttachment(valuePtr)}`);
storeValue(value);
B.br(join);
} else if (inline)
emitDenseReferenceArrayRead(
host,
array,
packages/compiler/src/backend/llvm/publish.ts
+3 -3
View File
@@ -596,10 +596,10 @@ export class PublishWalkers {
}
}
/** Unpublishable types stored as scalars (dates are time values, process
* streams file descriptors): no pointer to push, and always a value. */
/** Unpublishable types stored as scalars (process streams are file
* descriptors): no pointer to push, and always a value. */
function scalarRefusal(t: IrType): boolean {
return t.kind === "date" || t.kind === "procStream";
return t.kind === "procStream";
}
/** The Node.js implementation's refusal for a value of type `t`. */
packages/compiler/src/backend/llvm/receivers.ts
+5 -1
View File
@@ -18,6 +18,7 @@ import { canStackUnion, emitStackUnion } from "./stack-unions.js";
import { emitDowncastGuard, emitUnionNarrowGuard } from "./narrow-guards.js";
import { emitScalarOptional, isScalarOptionalSource } from "./local-union-storage.js";
import { borrowableInputs } from "./borrowed-inputs.js";
import { emitStackRecordKeyGet, scalarRecordKeyGet } from "./expr-records.js";
import { type WalkBorrowHost, analyzeWalks } from "./walk-borrows.js";
/** Read a receiver whose value is consumed immediately by a field or tag
@@ -95,6 +96,8 @@ export function emitReadReceiver(emitter: LlEmitter, e: IrExpr): LlValue {
const narrowed = narrow ? emitCheckedNarrowReceiver(emitter, narrow) : null;
if (narrowed) return narrowed;
if (canStackUnion(e, emitter.boxedUnionsById)) return emitStackUnion(emitter, e).value;
if (e.kind === "recordKeyGet" && scalarRecordKeyGet(emitter, e))
return { name: emitStackRecordKeyGet(emitter, e), type: e.type };
if (e.kind === "unionNarrow") {
const union = emitter.emitUnionProjection(e.value);
emitUnionNarrowGuard(emitter, union.name, e.unionId, e.tag);
@@ -410,6 +413,7 @@ export function isStackUnionSource(emitter: LlEmitter, e: IrExpr): boolean {
emitter.optionalArrayReads.get(e) !== null ||
isScalarOptionalSource(e, emitter.unionSources) ||
emitter.scalarResultCall(e) ||
emitter.inlineFieldGet(e)
emitter.inlineFieldGet(e) ||
scalarRecordKeyGet(emitter, e)
);
}
packages/compiler/src/backend/llvm/shapes.test.ts
+37
View File
@@ -14,6 +14,7 @@ import {
type ShapeHost,
vAdapters,
} from "./shapes.js";
import { mangleRecordRelease } from "../mangle.js";
import { NullableUnions } from "./nullable-unions.js";
import { InlineUnionFields } from "./inline-unions.js";
@@ -315,6 +316,42 @@ describe("emitted object releases", () => {
root.indexOf("call void @scr_cyc_on_release(ptr %o)"),
);
});
test("freezable records count their references without the frozen bit", () => {
const mod: IrModule = {
irVersion: 17,
sourceFile: "frozen.ts",
entry: "main",
functions: [],
records: [
{ id: "plain", fields: [{ name: "n", type: F64 }] },
{ id: "frozen", fields: [{ name: "n", type: F64 }], freezable: true },
],
};
const body = (defs: string, name: string): string =>
new RegExp(`^define internal void @${name}\\([^]*?^}`, "m").exec(defs)?.[0] ?? "";
for (const [pointerBits, notFrozen, sharedBelow] of [
[64, "-4611686018427387905", "-4611686018427387907"],
[32, "-1073741825", "-1073741827"],
] as const) {
const { host } = declarationHost(pointerBits);
const defs = emitRecordShapes({ ...host, objectAudit: false }, mod).defs.join("\n");
const S = pointerBits === 64 ? "i64" : "i32";
const plain = body(defs, mangleRecordRelease("plain"));
expect(plain).toContain(`%shared = icmp ult ${S} %rcm2, -3`);
expect(plain).not.toContain("%refs");
// The immortal word's count is ~FROZEN, which the compare sends to the
// immortal test, like counts 0 and 1.
const fast = body(defs, mangleRecordRelease("frozen"));
expect(fast).toContain(`%refs = and ${S} %rc, ${notFrozen}`);
expect(fast).toContain(`%rcm2 = sub ${S} %refs, 2`);
expect(fast).toContain(`%shared = icmp ult ${S} %rcm2, ${sharedBelow}`);
expect(fast).toContain(`%imm = icmp eq ${S} %rc, -1`);
const slow = body(defs, `${mangleRecordRelease("frozen")}_slow`);
expect(slow).toContain(`%refs = and ${S} %n, ${notFrozen}`);
expect(slow).toContain(`%dead = icmp eq ${S} %refs, 0`);
}
});
});
describe("live-object audit notes", () => {
packages/compiler/src/backend/llvm/shapes.ts
+251 -35
View File
@@ -34,6 +34,7 @@ import {
cycTypeDescriptor,
emitObjectAlloc,
emitObjectFree,
emitSegmentFree,
CYC_APPEND,
cycleAppendDecls,
cycleAppendHelper,
@@ -1099,6 +1100,7 @@ export function arrNewCall(
elem.kind === "stats" || // fs.Stats snapshots: scr_stats_* adapters, no trace
elem.kind === "dyn" || // native collection seeds/drains: traced REF
elem.kind === "regex" || // RegExp values: scr_regex_* adapters, no trace (no refs inside)
elem.kind === "date" || // Date objects: scr_date_* adapters, no trace (no refs inside)
(elem.kind === "array" && traceAdapter(host, elem) !== null);
if (!useRef) {
if (small) {
@@ -1162,7 +1164,6 @@ const SCR_ARR_OPS_RELEASE_NOTHING = 2;
export function boxNewCall(host: ShapeHost, t: IrType): string {
const plain: Partial<Record<IrType["kind"], number>> = {
f64: 0,
date: 0,
procStream: 0,
bool: 1,
string: 2,
@@ -1187,11 +1188,7 @@ export function boxNewCall(host: ShapeHost, t: IrType): string {
/** Box accessor suffix (boxAccess): scalars unboxed, ref kinds pointers. */
export function boxAccess(t: IrType): "f64" | "bool" | "ref" {
return t.kind === "f64" || t.kind === "date" || t.kind === "procStream"
? "f64"
: t.kind === "bool"
? "bool"
: "ref";
return t.kind === "f64" || t.kind === "procStream" ? "f64" : t.kind === "bool" ? "bool" : "ref";
}
/* ── record shapes ────────────────────────────────────────────────────── */
@@ -1207,7 +1204,6 @@ export function llFieldType(
if (POINTER_KINDS.has(t.kind)) return "ptr";
switch (t.kind) {
case "f64":
case "date":
case "procStream":
return "double";
case "bool":
@@ -1405,17 +1401,23 @@ export interface DirectDestroy {
/** The release of child `value` (a loaded field, possibly NULL) inside a
* teardown whose chain length is `%d`: the child's own release for a shared
* or immortal reference, its teardown for the last one. Labels use `tag`;
* the lines end in the open block `${tag}.next`. */
* the lines end in the open block `${tag}.next`.
*
* With `segment` (the child has the teardown's own type, in a segmented
* teardown; segmentPrologueLines), the child's teardown appends its blocks
* to the teardown's segment. */
export function directChildReleaseLines(
host: ShapeHost,
tag: string,
value: string,
target: DirectDestroy,
comment: string,
segment = false,
): string[] {
const S = host.sizeType;
const C = target.count ?? S;
host.declare(`declare void @scr_rc_destroy(ptr, ptr)`);
if (segment) host.declare(`declare ptr @scr_rc_destroy_seg(ptr, ptr, ptr, ptr)`);
else host.declare(`declare void @scr_rc_destroy(ptr, ptr)`);
const lines = [
` %${tag}.nn = icmp ne ptr ${value}, null`,
` br i1 %${tag}.nn, label %${tag}.chk, label %${tag}.next`,
@@ -1447,16 +1449,139 @@ export function directChildReleaseLines(
` br i1 %${tag}.short, label %${tag}.direct, label %${tag}.bounded`,
`${tag}.direct:`,
` %${tag}.d = add i32 %d, 1`,
` call void @${target.destroy}_d(ptr ${value}, i32 %${tag}.d)`,
);
if (!segment) {
lines.push(
` call void @${target.destroy}_d(ptr ${value}, i32 %${tag}.d)`,
` br label %${tag}.next`,
`${tag}.bounded:`,
` call void @scr_rc_destroy(ptr ${value}, ptr @${target.destroy})`,
` br label %${tag}.next`,
`${tag}.next:`,
);
return lines;
}
lines.push(
` %${tag}.t = load ptr, ptr %sg.t`,
` %${tag}.dt = call ptr @${target.destroy}_s(ptr ${value}, i32 %${tag}.d, ptr %${tag}.t)`,
` store ptr %${tag}.dt, ptr %sg.t`,
` br label %${tag}.next`,
`${tag}.bounded:`,
` call void @scr_rc_destroy(ptr ${value}, ptr @${target.destroy})`,
` %${tag}.bt = load ptr, ptr %sg.t`,
` %${tag}.rt = call ptr @scr_rc_destroy_seg(ptr ${value}, ptr @${target.destroy}_sc, ptr @${target.destroy}, ptr %${tag}.bt)`,
` store ptr %${tag}.rt, ptr %sg.t`,
` br label %${tag}.next`,
`${tag}.next:`,
);
return lines;
}
/* Teardown segments. A typed teardown that frees each block onto its free
* list as it goes frees a tree in walk order, and the free lists, which are
* LIFO, hand the blocks to the next allocations in the reverse order: a tree
* built again in the same order as the last (each generation of a structure
* a loop rebuilds) is laid out mirrored, and every walk over it, the next
* teardown included, runs through memory backwards, which defeats the
* hardware prefetchers. The runtime frees large dead sets of the cycle
* collector in address order for the same reason (scr_mem_order_for_free).
*
* So the teardown of a type with children of its own type (the `_s` form,
* segmentedTeardown) keeps the blocks it frees in a segment, linked through
* their first words, which it builds in order through a tail pointer: the
* `_s` form takes the segment's last link (the first word of its last block,
* or the head slot of an empty segment) and returns the new one. A node
* first releases its own block (emitObjectFree, keeping it), then appends it
* ahead of its children's blocks when its address is the lower, behind them
* otherwise (segmentTeardownLines), and the children append theirs in field
* order, so a structure
* built parent first (object literals allocate before their fields) or
* children first (constructor arguments) comes back in ascending order. The
* chain's first teardown (`_d`) frees the whole segment onto the class's
* free list in one step (emitSegmentFree), and the walks over the next
* generation run forward. A teardown past DIRECT_DESTROY_CHAIN appends
* through scr_rc_destroy_seg, under the same depth budget as
* scr_rc_destroy. Blocks outside the calling thread's arena are freed as
* before; one type's blocks are all of one class. */
/** Whether the teardown of a type whose reference fields have `fieldTypes`
* (with direct targets `targets`) and whose own teardown is `destroy` keeps
* a segment: a child field has its own type, and the inline allocation paths
* are in use. */
export function segmentedTeardown(
host: ShapeHost,
destroy: string,
fieldTypes: readonly IrType[],
targets: ReadonlyMap<string, DirectDestroy>,
): boolean {
if (host.inlineAlloc !== true) return false;
return fieldTypes.some((t) => directDestroyTarget(host, t, targets)?.destroy === destroy);
}
/** The first lines of a segmented teardown, in its entry block: the
* segment's last link (`%sg.t`, from the `%tail` argument) and the kept own
* block (`%sg.own`, for emitObjectFree). */
export function segmentPrologueLines(): string[] {
return [
` %sg.t = alloca ptr`,
` %sg.own = alloca ptr`,
` store ptr %tail, ptr %sg.t`,
` store ptr null, ptr %sg.own`,
];
}
/** The rest of a segmented teardown after emitObjectFree kept (or freed)
* its own block: the block goes ahead of its children's when its address is
* below the first non-NULL one of `children` (loaded fields of the
* teardown's own type, which stand for their blocks) or there is none, and
* behind them otherwise; then the children's releases (`releases`, given a
* label prefix), and the segment's last link is returned. Each order has its
* own copy of the releases, so neither keeps the decision, or the block once
* it is appended, across the children's teardowns. */
export function segmentTeardownLines(
children: readonly string[],
releases: (prefix: string) => string[],
): string[] {
const lines = [` %sg.o = load ptr, ptr %sg.own`, ` %sg.kept = icmp ne ptr %sg.o, null`];
let ref = "null";
[...children].reverse().forEach((child, i) => {
lines.push(
` %sg.nn${i} = icmp ne ptr ${child}, null`,
` %sg.r${i} = select i1 %sg.nn${i}, ptr ${child}, ptr ${ref}`,
);
ref = `%sg.r${i}`;
});
lines.push(
` %sg.leaf = icmp eq ptr ${ref}, null`,
` %sg.lower = icmp ult ptr %sg.o, ${ref}`,
` %sg.first = or i1 %sg.leaf, %sg.lower`,
` %sg.ahead = and i1 %sg.kept, %sg.first`,
` br i1 %sg.ahead, label %sg.front, label %sg.back`,
`sg.front:`,
...segmentAppendLines("a"),
...releases("ta"),
` br label %sg.ret`,
`sg.back:`,
...releases("tb"),
` %sg.keep = icmp ne ptr %sg.o, null`,
` br i1 %sg.keep, label %sg.last, label %sg.ret`,
`sg.last:`,
...segmentAppendLines("l"),
` br label %sg.ret`,
`sg.ret:`,
` %sg.tr = load ptr, ptr %sg.t`,
` ret ptr %sg.tr`,
);
return lines;
}
function segmentAppendLines(tag: string): string[] {
return [
` %sg.t${tag} = load ptr, ptr %sg.t`,
` store ptr %sg.o, ptr %sg.t${tag}`,
` store ptr %sg.o, ptr %sg.t`,
];
}
/** The direct-teardown target of a reference of `type`, if `targets` (keyed
* `record:<id>` / `object:<class>`) has one. Nullable unions hold the arm's
* pointer, NULL or an immortal sentinel, which the child release handles. */
@@ -1499,12 +1624,42 @@ export function usedDirectTargets(
/** The teardown definitions for `destroy`: with `chained`, the body takes
* the chain length `%d` (directChildReleaseLines) and the runtime's
* one-argument entry starts a chain. */
* one-argument entry starts a chain. With `segment` (the host, for a
* segmented teardown), the body is a segment teardown's
* (segmentPrologueLines to segmentTeardownLines), defined as `_s`, with
* `_sc` for scr_rc_destroy_seg, and `_d` starts a segment and frees it. */
export function destroyDefinitions(
destroy: string,
body: readonly string[],
chained: boolean,
segment: ShapeHost | null = null,
): string[] {
if (segment !== null)
return [
`define internal ptr @${destroy}_s(ptr %o, i32 %d, ptr %tail) ${FN_ATTRS} {`,
`entry:`,
...body,
`}`,
`define internal ptr @${destroy}_sc(ptr %o, ptr %tail) ${FN_ATTRS} {`,
`entry:`,
` %t = call ptr @${destroy}_s(ptr %o, i32 0, ptr %tail)`,
` ret ptr %t`,
`}`,
`define internal void @${destroy}_d(ptr %o, i32 %d) ${FN_ATTRS} {`,
`entry:`,
` %head = alloca ptr`,
` store ptr null, ptr %head`,
` %last = call ptr @${destroy}_s(ptr %o, i32 %d, ptr %head)`,
` %first = load ptr, ptr %head`,
...emitSegmentFree(segment, "sgf", "%first", "%last"),
` ret void`,
`}`,
`define internal void @${destroy}(ptr %o) ${FN_ATTRS} {`,
`entry:`,
` call void @${destroy}_d(ptr %o, i32 0)`,
` ret void`,
`}`,
];
if (!chained)
return [
`define internal void @${destroy}(ptr %o) ${FN_ATTRS} {`,
@@ -1527,6 +1682,17 @@ export function destroyDefinitions(
];
}
/** The frozen bit of a freezable record's rc word (scr_rc.h SCR_RC_FROZEN):
* bit 62 on 64-bit targets, bit 30 on 32-bit ones. */
function recordFrozenBit(sizeType: RcCount): bigint {
return 1n << (sizeType === "i64" ? 62n : 30n);
}
/** `value` as a signed LLVM integer literal of `sizeType`. */
function sizeLiteral(sizeType: RcCount, value: bigint): string {
return BigInt.asIntN(sizeType === "i64" ? 64 : 32, value).toString();
}
/** Common NULL/immortal/decrement skeleton for ordinary object releases.
* `freeBody` owns the zero-ref teardown and must leave the current block at
* its end; traced objects also get the possible-cycle-root branch.
@@ -1543,13 +1709,17 @@ export function releaseBody(
bounded = true,
immortal = false,
chained = false,
segmented = false,
frozen = false,
): string[] {
const S = host.sizeType;
if (bounded) host.declare(`declare void @scr_rc_destroy(ptr, ptr)`);
const destroy = `${fnName}_destroy`;
// A freezable record's count is the word without its frozen bit.
const notFrozen = sizeLiteral(S, ~recordFrozenBit(S));
const lines = [
...(bounded ? destroyDefinitions(destroy, freeBody, chained) : []),
...releaseFastPath(host, fnName, `${fnName}_slow`, traced, comment, immortal),
...(bounded ? destroyDefinitions(destroy, freeBody, chained, segmented ? host : null) : []),
...releaseFastPath(host, fnName, `${fnName}_slow`, traced, comment, immortal, S, frozen),
`define internal void @${fnName}_slow(ptr %o) noinline ${FN_ATTRS} {${comment ? ` ; ${comment}` : ""}`,
`entry:`,
` %isnull = icmp eq ptr %o, null`,
@@ -1561,7 +1731,9 @@ export function releaseBody(
`dec:`,
` %n = sub ${S} %rc, 1`,
` store ${S} %n, ptr %o`,
` %dead = icmp eq ${S} %n, 0`,
...(frozen
? [` %refs = and ${S} %n, ${notFrozen}`, ` %dead = icmp eq ${S} %refs, 0`]
: [` %dead = icmp eq ${S} %n, 0`]),
` br i1 %dead, label %free, label %${traced ? "root" : "done"}`,
`free:`,
...(traced ? cycleDeadLines(host, "teardown") : []),
@@ -1591,9 +1763,14 @@ export function releaseFastPath(
comment = "",
immortal = false,
count: RcCount = host.sizeType,
frozen = false,
): string[] {
const S = count;
if (immortal) return immortalRcBody(host, fnName, "void", comment);
// A freezable record compares its count without the frozen bit: an
// immortal word's count is then ~FROZEN, which the same compare sends to
// `slow`.
const notFrozen = ~recordFrozenBit(S);
return [
`define internal void @${fnName}(ptr %o) ${FN_ATTRS} {${comment ? ` ; ${comment} (fast path)` : ""}`,
`entry:`,
@@ -1601,8 +1778,13 @@ export function releaseFastPath(
` br i1 %isnull, label %done, label %check`,
`check:`,
` %rc = load ${S}, ptr %o`,
` %rcm2 = sub ${S} %rc, 2`,
` %shared = icmp ult ${S} %rcm2, -3`,
...(frozen
? [
` %refs = and ${S} %rc, ${sizeLiteral(S, notFrozen)}`,
` %rcm2 = sub ${S} %refs, 2`,
` %shared = icmp ult ${S} %rcm2, ${sizeLiteral(S, notFrozen - 2n)}`,
]
: [` %rcm2 = sub ${S} %rc, 2`, ` %shared = icmp ult ${S} %rcm2, -3`]),
` br i1 %shared, label %dec, label %slow`,
`dec:`,
` %n = sub ${S} %rc, 1`,
@@ -1780,26 +1962,58 @@ export function emitRecordShapes(
const chained =
directTargets.has(`record:${shape.id}`) ||
refMembers.some((m) => directDestroyTarget(host, m.type, directTargets) !== null);
for (const m of refMembers) {
freeBody.push(
` %f${t} = getelementptr inbounds %${struct}, ptr %o, i64 0, i32 ${m.index}`,
` %v${t} = load ptr, ptr %f${t}`,
const destroy = `${mangleRecordRelease(shape.id)}_destroy`;
const bounded = refMembers.some((member) => needsBoundedRelease(member.type));
const segmented =
bounded &&
segmentedTeardown(
host,
destroy,
refMembers.map((m) => m.type),
directTargets,
);
const direct = directDestroyTarget(host, m.type, directTargets);
if (direct) {
freeBody.push(
...directChildReleaseLines(host, `td${t}`, `%v${t}`, direct, llvmCommentText(m.name)),
);
} else {
freeBody.push(
` call void ${releaseSym(host, m.type)}(ptr %v${t}) ; ${llvmCommentText(m.name)}`,
);
}
t++;
}
// Closed layouts can carry a kept record source (record-sources.ts).
const observers = recordMayKeepSource(shape) ? "weak-or-source" : "weak";
freeBody.push(...emitObjectFree(host, traced, observers));
// A segmented teardown loads its fields, releases its own block, and
// then releases the fields (segmentTeardownLines).
const loads: string[] = [];
const ownType: string[] = [];
const release = (prefix: string, m: (typeof refMembers)[number], i: number): string[] => {
const direct = directDestroyTarget(host, m.type, directTargets);
if (direct === null)
return [` call void ${releaseSym(host, m.type)}(ptr %v${i}) ; ${llvmCommentText(m.name)}`];
const own = segmented && direct.destroy === destroy;
return directChildReleaseLines(
host,
`${prefix}${i}`,
`%v${i}`,
direct,
llvmCommentText(m.name),
own,
);
};
for (const m of refMembers) {
const fieldLines = [
` %f${t} = getelementptr inbounds %${struct}, ptr %o, i64 0, i32 ${m.index}`,
` %v${t} = load ptr, ptr %f${t}`,
];
if (segmented) {
loads.push(...fieldLines);
if (directDestroyTarget(host, m.type, directTargets)?.destroy === destroy)
ownType.push(`%v${t}`);
} else freeBody.push(...fieldLines, ...release("td", m, t));
t++;
}
if (segmented)
freeBody.push(
...segmentPrologueLines(),
...loads,
...emitObjectFree(host, traced, observers, "%sg.own"),
...segmentTeardownLines(ownType, (prefix) =>
refMembers.flatMap((m, i) => release(prefix, m, i)),
),
);
else freeBody.push(...emitObjectFree(host, traced, observers));
defs.push(
...releaseBody(
host,
@@ -1807,9 +2021,11 @@ export function emitRecordShapes(
traced,
freeBody,
"",
refMembers.some((member) => needsBoundedRelease(member.type)),
bounded,
false,
chained,
segmented,
shape.freezable === true,
),
``,
);
packages/compiler/src/backend/llvm/stack-captures.ts
+1 -7
View File
@@ -105,13 +105,7 @@ export class StackCaptures {
// sites, including duplicated finally bodies and versioned loops.
if (!this.locals.has(id) || this.remaining < 48) return null;
const ref = isRefCounted(type);
if (
!ref &&
type.kind !== "f64" &&
type.kind !== "date" &&
type.kind !== "procStream" &&
type.kind !== "bool"
)
if (!ref && type.kind !== "f64" && type.kind !== "procStream" && type.kind !== "bool")
return null;
this.remaining -= 48;
const B = host.B;
packages/compiler/src/backend/llvm/stack-objects.ts
+5 -2
View File
@@ -44,8 +44,9 @@ export type StackObjectFieldOwner = (fields: readonly StackObjectField[]) => voi
* standalone scalar class whose constructor never lets `this` escape
* (record-results.ts). The caller proves that every use of the value only
* projects it. Record fields may own references; the frame releases them
* (stackObjectFields). Published shapes keep heap storage: their field
* guards treat the immortal header as a frozen object. */
* (stackObjectFields). Published and freezable shapes keep heap storage:
* their field guards treat the immortal header as a frozen object, and a
* frozen record keeps its frozen bit in a counted header. */
export function canStackObject(host: LlvmEmitterContext, e: IrExpr): e is StackObjectSource {
// A ThreadSlots key keeps its slot index for its lifetime and has its
// values released when it is freed: it lives on the heap.
@@ -53,6 +54,8 @@ export function canStackObject(host: LlvmEmitterContext, e: IrExpr): e is StackO
return false;
if (e.type.kind === "record" && host.publishedTypes?.recordGuarded(e.type.shapeId) === true)
return false;
if (e.type.kind === "record" && host.recordsById.get(e.type.shapeId)?.freezable === true)
return false;
// A producer with a result-slot entry builds its fresh result in the
// caller's storage.
if (e.kind === "call") return host.fnByName.has(resultEntryName(e.callee));
packages/compiler/src/backend/llvm/walkers.ts
+15
View File
@@ -234,6 +234,10 @@ export class LlWalkers {
this.host.declare(`declare void @scr_jb_put_json_str(ptr, ptr)`);
B.line(`call void @scr_jb_put_json_str(ptr %b, ptr %v)`);
break;
case "date":
this.host.declare(`declare void @scr_jb_put_date(ptr, ptr)`);
B.line(`call void @scr_jb_put_date(ptr %b, ptr %v) ; toJSON(): ISO text, null if invalid`);
break;
case "dyn":
// A checked-dynamic value serializes itself (runtime walker).
// Bare stringify of dyn stays frontend-fenced, and overflow
@@ -927,6 +931,17 @@ export class LlWalkers {
case "string":
this.putScrStr(B, buf, this.unionPeek(B, u, unionId));
break;
case "date": {
host.declare(`declare ptr @scr_date_object_to_string(ptr)`);
host.declare(`declare void @scr_str_release(ptr)`);
const text = B.tmp();
B.line(
`${text} = call ptr @scr_date_object_to_string(ptr ${this.unionPeek(B, u, unionId)})`,
);
this.putScrStr(B, buf, text);
B.line(`call void @scr_str_release(ptr ${text})`);
break;
}
case "f64": {
host.declare(`declare double @scr_union_get_f64(ptr)`);
host.declare(`declare void @scr_jb_put_number(ptr, double)`);
packages/compiler/src/backend/native-codegen-core.ts
+16 -6
View File
@@ -6,19 +6,29 @@ export const NATIVE_CODEGEN_LLVM_VERSION = "22.1.8";
export type NativeCodegenOutputKind = "asm" | "obj";
/** LLVM text per partition, and the most partitions one executable uses. */
/** LLVM text that stays one module, LLVM text per partition, the fewest
* partitions (MIN_PROGRAM_PARTITIONS, of at least MIN_PARTITION_BYTES each)
* a divided module gets, and the most one executable uses. */
const SINGLE_PARTITION_BYTES = 1024 * 1024;
const PROGRAM_PARTITION_BYTES = 4 * 1024 * 1024;
const MIN_PARTITION_BYTES = 512 * 1024;
const MIN_PROGRAM_PARTITIONS = 8;
const MAX_PROGRAM_PARTITIONS = 64;
/** Executable objects this large are divided into partitions that the helper
* simplifies, optimizes and compiles concurrently, importing small functions
* across partitions for inlining, and reuses individually across builds. The
/** Executable objects larger than SINGLE_PARTITION_BYTES are divided into
* partitions that the helper simplifies, optimizes and compiles concurrently,
* importing small functions across partitions for inlining, and reuses
* individually across builds. A divided module gets at least
* MIN_PROGRAM_PARTITIONS so that mid-size programs use several cores. The
* count is a power of two that depends only on the module's size, on every
* target, so artifacts never vary with the host and ordinary edits keep every
* function in its partition. */
export function nativeProgramPartitions(llvmBytes: number): number {
const required = Math.ceil(llvmBytes / PROGRAM_PARTITION_BYTES);
if (required < 2) return 1;
if (llvmBytes <= SINGLE_PARTITION_BYTES) return 1;
const required = Math.max(
Math.ceil(llvmBytes / PROGRAM_PARTITION_BYTES),
Math.min(MIN_PROGRAM_PARTITIONS, Math.ceil(llvmBytes / MIN_PARTITION_BYTES)),
);
return Math.min(MAX_PROGRAM_PARTITIONS, 2 ** Math.ceil(Math.log2(required)));
}
packages/compiler/src/backend/native-codegen.test.ts
+6 -4
View File
@@ -352,11 +352,13 @@ test("sanitized native artifacts fail before helper resolution", async () => {
test("program partitions depend only on module size", () => {
const megabyte = 1024 * 1024;
expect(nativeProgramPartitions(4 * megabyte)).toBe(1);
expect(nativeProgramPartitions(4 * megabyte + 1)).toBe(2);
expect(nativeProgramPartitions(megabyte)).toBe(1);
expect(nativeProgramPartitions(megabyte + 1)).toBe(4);
expect(nativeProgramPartitions(2 * megabyte)).toBe(4);
expect(nativeProgramPartitions(2 * megabyte + 1)).toBe(8);
expect(nativeProgramPartitions(32 * megabyte)).toBe(8);
// Powers of two keep every function in its partition across small edits.
expect(nativeProgramPartitions(13 * megabyte)).toBe(4);
expect(nativeProgramPartitions(16 * megabyte)).toBe(4);
expect(nativeProgramPartitions(32 * megabyte + 1)).toBe(16);
expect(nativeProgramPartitions(100 * megabyte)).toBe(32);
expect(nativeProgramPartitions(1024 * megabyte)).toBe(64);
expect(nativePartitionPaths("/build.d/program.o", 3)).toEqual([
packages/compiler/src/backend/native-link-info-core.ts
+3
View File
@@ -81,6 +81,9 @@ export interface NativeLinkFeatures {
dnsPromises: boolean;
/** dgram sockets as untyped values: scr_dgram_dyn.c. */
dgramDyn: boolean;
/** TextEncoder and TextDecoder records as untyped values:
* scr_text_codec_dyn.c. */
textCodecDyn: boolean;
watch: boolean;
foreignFfi: boolean;
nodeTest: boolean;
packages/compiler/src/backend/native/contracts.ts
+4
View File
@@ -220,6 +220,10 @@ export interface CcOptions {
* scr_dgram_dyn.c over the dgram unit, so typed dgram binaries keep
* their exact link line. */
dgramDyn?: boolean;
/** A TextEncoder or TextDecoder record converts to or from an untyped
* value: compiles scr_text_codec_dyn.c, so typed codec binaries keep
* their exact link line. */
textCodecDyn?: boolean;
/** The program uses fs.watch (moduleUsesFsWatch on the IR): compiles
* scr_watch.c into the binary — the net gating precedent, so watch-free
packages/compiler/src/backend/native/executable.ts
+1
View File
@@ -302,6 +302,7 @@ const RUNTIME_UNITS: readonly RuntimeUnit[] = [
unit((u) => u.opts.dgram, "scr_dgram.c"),
unit((u) => u.opts.dgram && u.opts.dnsPromises, "scr_dns_promises.c"),
unit((u) => u.opts.dgram && u.opts.dgramDyn, "scr_dgram_dyn.c"),
unit((u) => u.opts.textCodecDyn, "scr_text_codec_dyn.c"),
unit((u) => u.opts.watch, "scr_watch.c"),
unit((u) => u.opts.foreignFfi, "scr_ffi_queue.c"),
unit((u) => u.opts.nodeTest, "scr_test.c"),
packages/compiler/src/backend/publication.test.ts
+31
View File
@@ -85,3 +85,34 @@ test("published types close over fields, containers and whole hierarchies", () =
computePublishedTypes({ ...withStores, functions: withStores.functions.slice(1) }),
).toBeNull();
});
test("freezable array types carry the array write guard without a publish", () => {
const numbers = arrayOf(F64);
const push: IrStmt = {
kind: "exprStmt",
expr: {
kind: "arrIntrinsic",
method: "push",
receiver: ref("a", numbers),
args: [{ kind: "numLit", value: 1, type: F64, loc }],
type: F64,
loc,
},
loc,
};
const mod: IrModule = {
irVersion: 17,
sourceFile: loc.file,
entry: "main",
functions: [fn("main", []), fn("pushNumber", [push])],
freezableArrays: ["array<f64>"],
};
const guarded = computePublishedTypes(mod)!;
expect(guarded.containerGuarded(numbers)).toBe(true);
expect(guarded.arrayGuards(numbers)).toEqual({ published: false, frozen: true });
expect(guarded.containerGuarded(arrayOf(STRING))).toBe(false);
// A frozen array's push throws, so the function may throw.
expect(computeMayThrow(mod).fns.has("pushNumber")).toBe(true);
const { freezableArrays: _frozen, ...plain } = mod;
expect(computePublishedTypes(plain)).toBeNull();
});
packages/compiler/src/backend/publication.ts
+22 -5
View File
@@ -46,6 +46,10 @@ export class PublishedTypes {
readonly records = new Set<string>();
/** typeKeys of array, map and set types. */
readonly containers = new Set<string>();
/** typeKeys of the array types the program may freeze
* (IrModule.freezableArrays): a frozen array refuses writes like a
* published one, so their stores carry the same guard. */
readonly frozenArrays = new Set<string>();
/** Constructor stores into a `this` nothing else can reach yet
* (immutability.ts): never a published target, so never guarded. */
privateStores: ReadonlySet<IrStmt> = new Set();
@@ -64,10 +68,16 @@ export class PublishedTypes {
}
containerGuarded(t: IrType): boolean {
return (
(t.kind === "array" || t.kind === "map" || t.kind === "set") &&
this.containers.has(typeKey(t))
);
if (t.kind !== "array" && t.kind !== "map" && t.kind !== "set") return false;
const key = typeKey(t);
return this.containers.has(key) || this.frozenArrays.has(key);
}
/** Whether an array of type `t` may be published, and whether it may be
* frozen: the two states its write guard tests. */
arrayGuards(t: IrType): { published: boolean; frozen: boolean } {
const key = typeKey(t);
return { published: this.containers.has(key), frozen: this.frozenArrays.has(key) };
}
}
@@ -87,7 +97,13 @@ export function computePublishedTypes(mod: IrModule, nodes?: IrNodeIndex): Publi
)
roots.push(node.type);
});
if (roots.length === 0) return null;
const frozenArrays = mod.freezableArrays ?? [];
if (roots.length === 0 && frozenArrays.length === 0) return null;
if (roots.length === 0) {
const frozen = new PublishedTypes();
for (const key of frozenArrays) frozen.frozenArrays.add(key);
return frozen;
}
const classes = new Map((mod.classes ?? []).map((c) => [c.name, c]));
const children = new Map<string, string[]>();
@@ -100,6 +116,7 @@ export function computePublishedTypes(mod: IrModule, nodes?: IrNodeIndex): Publi
const records = new Map((mod.records ?? []).map((r) => [r.id, r]));
const unions = new Map((mod.unions ?? []).map((u) => [u.id, u]));
const out = new PublishedTypes();
for (const key of frozenArrays) out.frozenArrays.add(key);
out.privateStores = computeConstructionFacts(mod, nodes).privateStores;
const seen = new Set<string>();
const stack = [...roots];
packages/compiler/src/backend/runtime-pack-targets.test.ts
+1
View File
@@ -118,6 +118,7 @@ const features = {
dgram: false,
dnsPromises: false,
dgramDyn: false,
textCodecDyn: false,
watch: false,
foreignFfi: false,
nodeTest: false,
packages/compiler/src/backend/runtime-pack.test.ts
+1
View File
@@ -54,6 +54,7 @@ const BASE: NativeLinkFeatures = {
dgram: false,
dnsPromises: false,
dgramDyn: false,
textCodecDyn: false,
watch: false,
foreignFfi: false,
nodeTest: false,
packages/compiler/src/backend/warm-cache.ts
+1
View File
@@ -61,6 +61,7 @@ export async function warmNativeCaches(
dgram: false,
dnsPromises: false,
dgramDyn: false,
textCodecDyn: false,
watch: false,
foreignFfi: false,
nodeTest: false,
packages/compiler/src/compat/fetch-profile.ts
+1 -1
View File
@@ -900,7 +900,7 @@ export const NODE24_FETCH_COMPAT_PROFILE = {
{
name: "WritableStream/TransformStream",
reason:
"native support currently covers readable fetch bodies; general Web Streams graphs are unsupported",
"native support covers readable fetch bodies and the identity `new TransformStream()`; the WritableStream constructor, transformers, and general Web Streams graphs are unsupported",
},
{
name: "Readable byte/BYOB streams",
packages/compiler/src/diagnostics/diagnostic.ts
+1 -1
View File
@@ -656,7 +656,7 @@ export function genericSignatureTypeDiag(typeText: string, loc: SrcLoc): ScrDiag
export function indexSignatureTypeDiag(typeText: string, loc: SrcLoc): ScrDiagnostic {
return {
code: "SC2006",
message: `values of type '${typeText}' cannot be compiled: this index signature is outside the supported shape (string or number keys; values limited to numbers, strings, booleans, records, classes, arrays, unions, functions, Maps, Sets, RegExps, Promises, or 'unknown')`,
message: `values of type '${typeText}' cannot be compiled: this index signature is outside the supported shape (string or number keys; values limited to numbers, strings, booleans, records, classes, arrays, unions, functions, Maps, Sets, RegExps, Dates, Promises, or 'unknown')`,
loc,
milestone: "M2",
hint: "string- and number-keyed index signatures over the supported value types compile directly; symbol keys and dual signatures with unequal value types have no lowering",
packages/compiler/src/executable/executable-cache.test.ts
+1
View File
@@ -58,6 +58,7 @@ const native: EarlyExecutableNativeFeatures = {
dgram: false,
dnsPromises: false,
dgramDyn: false,
textCodecDyn: false,
watch: false,
foreignFfi: false,
nodeTest: false,
packages/compiler/src/executable/executable-cache.ts
+2
View File
@@ -92,6 +92,7 @@ export interface EarlyExecutableNativeFeatures {
dgram: boolean;
dnsPromises: boolean;
dgramDyn: boolean;
textCodecDyn: boolean;
watch: boolean;
foreignFfi: boolean;
nodeTest: boolean;
@@ -235,6 +236,7 @@ const BOOLEAN_NATIVE_KEYS = [
"dgram",
"dnsPromises",
"dgramDyn",
"textCodecDyn",
"watch",
"foreignFfi",
"nodeTest",
packages/compiler/src/frontend/lowering/array-values.ts
+99 -2
View File
@@ -15,6 +15,7 @@ import {
typeKey,
unionContainerArmsOk,
} from "../../ir/ir.js";
import { everyExpr } from "../../ir/traverse.js";
import type { Lowerer } from "./lowerer.js";
import type * as ts from "../ts7/adapter.js";
@@ -193,6 +194,81 @@ export function unionArrayValueRead(
return result;
}
/** Expression kinds that evaluate without running other code or writing
* a binding. */
const PURE_KINDS = new Set<IrExpr["kind"]>([
"varRef",
"numLit",
"strLit",
"boolLit",
"unitLit",
"bin",
"unary",
"logical",
"ternary",
"toBool",
"fieldGet",
"recordGet",
"arrayGet",
"arrayState",
"arrayHas",
"unionIsTag",
"unionNarrow",
"unionWrap",
]);
/** The locals evaluating `value` may assign, and whether it may run other
* code (anything but the pure kinds and the read-only element helpers),
* which can assign locals and fields through closures. */
function valueEffects(lowerer: Lowerer, value: IrExpr): { writes: Set<string>; opaque: boolean } {
const readers = new Set<string>();
for (const [key, name] of lowerer.arrHofHelpers) if (key.startsWith("idxOr:")) readers.add(name);
const writes = new Set<string>();
let opaque = false;
everyExpr(value, {
expr: (e) => {
if (e.kind === "assignExpr" || e.kind === "incDec") writes.add(e.localId);
else if (e.kind === "call" ? !readers.has(e.callee) : !PURE_KINDS.has(e.kind)) opaque = true;
return true;
},
stmt: (s) => {
if (s.kind === "varDecl" || s.kind === "assign") writes.add(s.localId);
else opaque = true;
return true;
},
});
return { writes, opaque };
}
/** Whether evaluating `e` after `value` gives what it gives before it: a
* literal, or a local and field read `value` cannot change. */
function unaffectedBy(e: IrExpr, effects: { writes: Set<string>; opaque: boolean }): boolean {
switch (e.kind) {
case "numLit":
case "strLit":
return true;
case "varRef":
return !effects.writes.has(e.localId);
case "bin":
return unaffectedBy(e.left, effects) && unaffectedBy(e.right, effects);
case "fieldGet":
case "recordGet":
return !effects.opaque && unaffectedBy(e.obj, effects);
default:
return false;
}
}
/** Whether `e` reads a `let` or `var` binding, which code the value runs
* can assign through a closure. */
function readsMutableLocal(lowerer: Lowerer, e: IrExpr): boolean {
return !everyExpr(e, {
expr: (x) =>
x.kind !== "varRef" || lowerer.ctx.locals.find((l) => l.id === x.localId)?.mutable === false,
stmt: () => true,
});
}
/** Store a stabilized value without changing the array's element ABI. */
export function arrayValueStore(
lowerer: Lowerer,
@@ -210,10 +286,31 @@ export function arrayValueStore(
// owned union temporary to release on every path.
const unionId = value.type.unionId;
let stable = value;
let prefix: IrStmt[] = [];
const prefix: IrStmt[] = [];
// The stores below evaluate the receiver and the index after the value.
// JavaScript evaluates them first (`out[n++] = src[n]` reads src[1]), so
// either may need its value held before the value runs.
if (value.kind !== "varRef") {
const valueFx = valueEffects(lowerer, value);
const hold = (e: IrExpr, name: string, effects: typeof valueFx): IrExpr => {
if (unaffectedBy(e, effects) && !(effects.opaque && readsMutableLocal(lowerer, e)))
return e;
const temp = lowerer.declareHiddenLocal(name, e.type);
prefix.push({ kind: "varDecl", localId: temp.id, init: e, loc });
return varRef(temp.id, temp.type, loc);
};
// The receiver runs before the index and the value, so the index's
// effects can change it too (`a[(a = b, 0)] = c[0]!`).
const indexFx = valueEffects(lowerer, index);
arr = hold(arr, "%arrayTarget", {
writes: new Set([...valueFx.writes, ...indexFx.writes]),
opaque: valueFx.opaque || indexFx.opaque,
});
index = hold(index, "%arrayIndex", valueFx);
}
if (value.kind !== "varRef") {
const temp = lowerer.declareHiddenLocal("%arrayValue", value.type);
prefix = [{ kind: "varDecl", localId: temp.id, init: value, loc }];
prefix.push({ kind: "varDecl", localId: temp.id, init: value, loc });
stable = varRef(temp.id, temp.type, loc);
}
const write: IrStmt = {
packages/compiler/src/frontend/lowering/builtins/async-context.ts
+76 -3
View File
@@ -2,7 +2,7 @@ import { isBuiltinClassInstance } from "./receiver-types.js";
import { dynUndefinedExpr } from "../../../ir/build.js";
import * as ts from "../../ts7/adapter.js";
import { type Lowerer } from "../lowerer.js";
import { locOf } from "../../program.js";
import { isJsSourceFile, locOf } from "../../program.js";
import {
BOOL,
DYN,
@@ -184,16 +184,89 @@ export function lowerDiagnosticsChannelMethodCall(
);
}
/** Whether `node` names the AsyncLocalStorage class itself. */
function isAsyncLocalStorageClass(lowerer: Lowerer, node: ts.Expression): boolean {
if (!ts.isIdentifier(node)) return false;
const symbol = lowerer.resolveValueSymbol(node);
return (
symbol !== null &&
lowerer.isStdlibSymbol(symbol) &&
ts.symbolName(symbol) === "AsyncLocalStorage"
);
}
/** The static AsyncLocalStorage members: bind(fn) answers fn bound to the
* active context (its own type for a typed function; a dyn function in
* JavaScript files, where the bound function's name and receiver are
* observable, and for dyn values); snapshot() answers a dyn function
* (cb, ...args) that runs cb in the context active at the snapshot. */
function lowerAsyncLocalStorageStaticCall(
lowerer: Lowerer,
call: ts.CallExpression,
access: ts.PropertyAccessExpression,
): IrExpr {
const name = access.name.text;
const loc = locOf(call);
const always: IrExpr = { kind: "boolLit", value: true, type: BOOL, loc };
if (name === "bind" && call.arguments.nodes.length === 1) {
const arg = call.arguments.nodes[0]!;
if (!isJsSourceFile(ts.getSourceFileOfNode(call))) {
const fn = lowerer.lowerExpr(arg);
if (fn.type.kind === "func")
return { kind: "libCall", fn: "als.bindCallback", args: [fn, always], type: fn.type, loc };
}
return asyncLocalStorageResult(lowerer, call, {
kind: "libCall",
fn: "als.bindCallbackDyn",
args: [lowerDiagnosticsMessage(lowerer, arg), always],
type: DYN,
loc,
});
}
if (name === "snapshot" && call.arguments.nodes.length === 0)
return { kind: "libCall", fn: "als.snapshot", args: [], type: DYN, loc };
lowerer.noLowering(
`AsyncLocalStorage.${name}`,
call,
"AsyncLocalStorage.bind(fn) and AsyncLocalStorage.snapshot() are the supported static members",
lowerer.checker.getSymbolAtLocation(access.name),
);
}
/** new AsyncLocalStorage(options): the options object as a dyn value
* (plain property literals build it member by member). */
export function lowerAsyncLocalStorageOptions(lowerer: Lowerer, node: ts.Expression): IrExpr {
return lowerTracingHandlers(lowerer, node);
}
/** `.name` on AsyncLocalStorage receivers: the constructor's name option
* (als.name), converted to the property's type. Null otherwise. */
export function lowerAsyncLocalStorageProperty(
lowerer: Lowerer,
access: ts.PropertyAccessExpression,
): IrExpr | null {
if (access.questionDotToken || access.name.text !== "name") return null;
if (!isBuiltinClassInstance(lowerer, access.expression, "AsyncLocalStorage")) return null;
if (!lowerer.isStdlibMember(access)) return null;
const loc = locOf(access);
const receiver = lowerer.lowerExprExpecting(access.expression, F64);
const value: IrExpr = { kind: "libCall", fn: "als.name", args: [receiver], type: DYN, loc };
const expected = lowerer.mapTypeOf(lowerer.typeOf(access));
return !expected || expected.kind === "dyn" ? value : lowerer.coerceInto(access, value, expected);
}
/** Method calls on AsyncLocalStorage receivers: run(store, fn, ...args),
* exit(fn, ...args), getStore(), enterWith(store), disable() — over the
* f64 store handle (als.* libCalls; values cross as dyn values). Null
* for non-ALS receivers. */
* f64 store handle (als.* libCalls; values cross as dyn values) — and the
* static bind/snapshot members. Null for other receivers. */
export function lowerAsyncLocalStorageMethodCall(
lowerer: Lowerer,
call: ts.CallExpression,
access: ts.PropertyAccessExpression,
): IrExpr | null {
if (call.questionDotToken || access.questionDotToken) return null;
if (isAsyncLocalStorageClass(lowerer, access.expression))
return lowerAsyncLocalStorageStaticCall(lowerer, call, access);
if (!isBuiltinClassInstance(lowerer, access.expression, "AsyncLocalStorage")) return null;
if (!lowerer.isStdlibMember(access)) return null;
const name = access.name.text;
packages/compiler/src/frontend/lowering/builtins/crypto.ts
+3 -1
View File
@@ -1454,6 +1454,7 @@ function lowerPkiCall(
],
sign: ["crypto.signOneshot", 3, 3, "sign(algorithm, data, key)"],
verify: ["crypto.verifyOneshot", 4, 4, "verify(algorithm, data, key, signature)"],
diffieHellman: ["crypto.diffieHellman", 1, 2, "diffieHellman(options[, callback])"],
createSign: ["crypto.createSign", 1, 1, "createSign(algorithm)"],
createVerify: ["crypto.createVerify", 1, 1, "createVerify(algorithm)"],
};
@@ -1474,6 +1475,7 @@ function lowerPkiCall(
return { kind: "libCall", fn, args: values, type: VOID, loc };
const call: IrExpr = { kind: "libCall", fn, args: values, type: DYN, loc };
const result = lowerer.mapTypeOf(lowerer.typeOf(expr));
if (result === null || result.kind === "dyn") return call;
// diffieHellman's callback form answers undefined.
if (result === null || result.kind === "dyn" || result.kind === "void") return call;
return lowerer.coerceInto(expr, call, result);
}
packages/compiler/src/frontend/lowering/builtins/dates.ts
+7 -1
View File
@@ -53,7 +53,13 @@ export function lowerDateCall(
call: ts.CallExpression,
access: ts.PropertyAccessExpression,
): IrExpr | null {
if (call.questionDotToken || access.questionDotToken) return null;
// An optional chain lowers the call again once it has narrowed the
// receiver (Lowerer.chainHandled).
if (
(call.questionDotToken && !lowerer.chainHandled.has(call)) ||
(access.questionDotToken && !lowerer.chainHandled.has(access))
)
return null;
const loc = locOf(call);
const member = lowerer.stdlibGlobalMember(access, "Date");
if (member === "now" || member === "parse" || member === "UTC")
packages/compiler/src/frontend/lowering/call-signatures.ts
-1
View File
@@ -611,7 +611,6 @@ export function checkDefaultParamBodyType(
if (
bodyType.kind === "void" ||
bodyType.kind === "regex" ||
bodyType.kind === "date" ||
bodyType.kind === "dyn" ||
isUnitType(bodyType)
) {
packages/compiler/src/frontend/lowering/cjs-exports-object.ts
+1 -1
View File
@@ -381,7 +381,7 @@ function esModuleExportIgnoresThis(
depth: number,
): boolean {
const moduleSym = lowerer.checker.getSymbolAtLocation(sf);
const exported = moduleSym?.getExports().get(name as ts.__String);
const exported = moduleSym?.getExports().get(ts.escapedSymbolName(name));
if (exported !== undefined) {
const target =
exported.flags & ts.SymbolFlags.Alias ? lowerer.checker.getAliasedSymbol(exported) : exported;
packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts
+109 -1
View File
@@ -282,6 +282,11 @@ interface PropertyDispatch {
fn: IrFunction;
classes: Set<string>;
reflect?: boolean;
/** The helper's fallthrough statements as created, and the same access
* applied to the receiver itself: what the fallthrough reduces to for a
* value that is neither a class capsule nor a function, whose bag is the
* value. */
plain?: { tail: readonly IrStmt[]; access: IrStmt[] };
}
export function classInstanceOf(
@@ -2724,7 +2729,28 @@ export class ClassDynamicDispatch {
loc,
});
}
dispatch = { name, write: !!write, fn: helper, classes: new Set() };
const receiverAccess: IrStmt[] = read
? [{ kind: "return", value: { ...read, value: varRef("p.0", DYN, loc) }, loc }]
: [
{
kind: "exprStmt",
expr: {
...write!,
args: [varRef("p.0", DYN, loc), write!.args[1]!, varRef("p.1", DYN, loc)],
},
loc,
},
{ kind: "return", value: null, loc },
];
dispatch = {
name,
write: !!write,
fn: helper,
classes: new Set(),
...(name !== "constructor" && name !== "toString"
? { plain: { tail: [...helper.body], access: receiverAccess } }
: {}),
};
this.properties.set(key, dispatch);
this.generated.add(helper);
lowerer.liftedFns.push(helper);
@@ -4896,6 +4922,7 @@ export class ClassDynamicDispatch {
);
}
if (lowerer) this.guardClassTables(lowerer);
if (lowerer) this.guardPropertyHelpers(lowerer);
}
/** Each tracked class's bag initializer over a typed receiver (`this`),
@@ -4985,6 +5012,87 @@ export class ClassDynamicDispatch {
}
}
/** Fast exits for the generated property helpers: when every class
* branch tests a capsule key or a class key and the fallthrough is still
* the bag access the helper was created with, a value of another kind
* (a plain object, array or primitive) normalizes to itself, has itself
* as its bag, and so gets the plain access directly, without the
* normalization, bag and static-bag calls. */
private guardPropertyHelpers(lowerer: Lowerer): void {
// Every class table the fallthrough or normalization calls must answer
// a plain value with the value itself: its kind exit is in place.
const exits = (name: string): boolean => {
const helper = lowerer.liftedFnNamed(name);
const first = helper?.body[0];
const param = helper?.params[0]?.localId;
return (
param !== undefined &&
first?.kind === "if" &&
first.cond.kind === "dynTest" &&
first.cond.negated === true &&
first.then.length === 1 &&
first.then[0]!.kind === "return" &&
first.then[0]!.value !== null &&
returnsParam(first.then[0]!.value, param)
);
};
const tables = new Set([
"%dyn.class.properties",
READ_PROPERTIES,
READ_PROPERTIES_OR_EMPTY,
"%dyn.class.normalize",
"%dyn.class.staticProperties",
]);
const callsOnlyGuardedTables = (statements: IrStmt[]): boolean =>
everyStmtList(statements, {
stmt: () => true,
expr: (expression) =>
expression.kind !== "call" || (tables.has(expression.callee) && exits(expression.callee)),
});
for (const dispatch of this.properties.values()) {
const plain = dispatch.plain;
if (!plain) continue;
const fn = dispatch.fn;
const param = fn.params[0]?.localId;
if (param === undefined) continue;
const head = fn.body.length - plain.tail.length;
if (head < 0 || plain.tail.some((stmt, i) => fn.body[head + i] !== stmt)) continue;
let ok = true;
for (const stmt of fn.body.slice(0, head)) {
if (
stmt.kind === "assign" &&
stmt.localId === param &&
stmt.value.kind === "call" &&
stmt.value.callee === "%dyn.class.normalize"
)
continue;
if (stmt.kind === "if" && stmt.else_ === null && branchKind(stmt.cond, param) !== null)
continue;
ok = false;
break;
}
// Class branches never run for a plain value; the rest always does.
if (!ok || !callsOnlyGuardedTables(fn.body.filter((stmt) => stmt.kind !== "if"))) continue;
const loc = fn.loc;
const not = (test: "classCapsule" | "funcKind"): IrExpr => ({
kind: "dynTest",
test,
negated: true,
value: varRef(param, DYN, loc),
type: BOOL,
loc,
});
fn.body.unshift({
kind: "if",
cond: not("classCapsule"),
then: [{ kind: "if", cond: not("funcKind"), then: plain.access, else_: null, loc }],
else_: null,
loc,
});
delete dispatch.plain;
}
}
private normalizedDispatches(): IrFunction[] {
return [
...(this.propertyBag ? [this.propertyBag] : []),
packages/compiler/src/frontend/lowering/class-method-mutations.ts
+29 -11
View File
@@ -46,6 +46,13 @@ export function collectClassMethodMutations(
const typedClasses: (ts.ClassDeclaration | ts.ClassExpression)[] = [];
const symbolMethods = new Set<string>();
let unknownKey: ts.Node | undefined;
/** Every write with an unknown key: each may install a replacement of any
* method name, and the key-order witness asks what each one installs. */
const unknownKeySites: ts.Node[] = [];
const markUnknownKey = (site: ts.Node): void => {
unknownKey = site;
unknownKeySites.push(site);
};
let numericKey: ts.Node | undefined;
let unknownOwnField = false;
// `sym:iterator` for `Symbol.iterator`: the name a class method declared
@@ -83,7 +90,7 @@ export function collectClassMethodMutations(
for (const key of computedMethods)
for (const name of literalValues(lowerer.typeOf(key)) ?? []) methods.add(String(name));
const markName = (name: string, site: ts.Node, arrow = false): void => {
if (name === "prototype" || name === "__proto__") unknownKey = site;
if (name === "prototype" || name === "__proto__") markUnknownKey(site);
if (methods.has(name)) lowerer.noteMethodAccess(name, site);
if (!arrow) receiverFields.add(name);
};
@@ -125,11 +132,13 @@ export function collectClassMethodMutations(
};
// Whether no function value can inhabit `type`. Primitives qualify, and so
// do non-callable object types a function is not assignable to: one that
// requires a property functions lack, or a weak (all-optional) type that
// requires a property functions lack, a weak (all-optional) type that
// shares no property with functions (TypeScript's weak-type rule rejects
// callable sources too).
const functionFree = (type: ts.Type): boolean => {
if (type.isUnionType()) return ts.constituentTypes(type).every(functionFree);
// callable sources too), or a dictionary with no properties whose index
// signatures hold function-free values (functions have no index
// signature). `seen` stops recursive dictionary types.
const functionFree = (type: ts.Type, seen: Set<ts.Type> = new Set()): boolean => {
if (type.isUnionType()) return ts.constituentTypes(type).every((t) => functionFree(t, seen));
if (
(type.flags &
(ts.TypeFlags.StringLike |
@@ -149,7 +158,12 @@ export function collectClassMethodMutations(
)
return false;
const properties = lowerer.checker.getPropertiesOfType(type);
if (properties.length === 0) return false;
if (properties.length === 0) {
if (seen.has(type)) return true;
seen.add(type);
const indexes = lowerer.checker.getIndexInfosOfType(type);
return indexes.length > 0 && indexes.every((index) => functionFree(index.type, seen));
}
const required = properties.filter(
(property) => (property.flags & ts.SymbolFlags.Optional) === 0,
);
@@ -442,11 +456,12 @@ export function collectClassMethodMutations(
(lowerer.isStdlibGlobal(node, "Object") || lowerer.isStdlibGlobal(node, "Reflect")) &&
(!ts.isPropertyAccessExpression(node.parent) || node.parent.expression !== node)
)
unknownKey = node;
markUnknownKey(node);
for (const node of reflection) {
const objectMethod = lowerer.stdlibGlobalMember(node, "Object");
const reflectMethod = lowerer.stdlibGlobalMember(node, "Reflect");
if (objectMethod === "setPrototypeOf" || reflectMethod === "setPrototypeOf") unknownKey = node;
if (objectMethod === "setPrototypeOf" || reflectMethod === "setPrototypeOf")
markUnknownKey(node);
const single =
objectMethod === "defineProperty" ||
reflectMethod === "defineProperty" ||
@@ -456,7 +471,7 @@ export function collectClassMethodMutations(
if (!single && !multiple) continue;
const call = node.parent;
if (!ts.isCallExpression(call) || call.expression !== node) {
unknownKey = node;
markUnknownKey(node);
continue;
}
const receiver = call.arguments.nodes[0];
@@ -611,7 +626,7 @@ export function collectClassMethodMutations(
// Numeric writes can replace numeric names but not ordinary names.
numericKey = site;
} else if (!(flags & ts.TypeFlags.ESSymbolLike)) {
unknownKey = site;
markUnknownKey(site);
}
}
if (numericKey) {
@@ -620,7 +635,10 @@ export function collectClassMethodMutations(
}
}
if (unknownKey) {
for (const method of methods) lowerer.noteMethodAccess(method, unknownKey);
for (const method of methods) {
lowerer.prototypeMethodAccesses.set(method, unknownKey);
for (const site of unknownKeySites) lowerer.noteMethodSite(method, site);
}
for (const method of symbolMethods) lowerer.replacedSymbolMethods.add(method);
}
if (!unknownKey && !unknownOwnField)
packages/compiler/src/frontend/lowering/completion-callbacks.ts
+155
View File
@@ -0,0 +1,155 @@
/* Completion callbacks in programs that use AsyncLocalStorage. Node runs
* the callback of an operation a callback-style API starts (fs.readFile,
* crypto.randomBytes, zlib.gzip, dns.lookup, server.listen, net.connect,
* http.get, stream.finished, stream.pipeline, ...) with the stores active
* when the call started it. The runtime invokes these callbacks from
* the event loop, where the context is empty, so in programs whose
* scheduling carries contexts (RuntimeFeatures asyncContext) each such
* argument is bound to the active context at the call: als.bindCallback
* for typed closures, als.bindCallbackDyn for dyn functions. Other
* programs are left unchanged. */
import { BOOL, type IrExpr, type IrModule, type IrStmt } from "../../ir/ir.js";
import type { IrLibFn } from "../../ir/builtin-signatures.js";
import { mapExprChildren, mapStmtChildren } from "../../ir/traverse.js";
import { moduleRuntimeFeatures } from "../../ir/runtime-features.js";
/** The argument that is the completion callback: its index; "last" for
* calls whose callback is the final argument when one is passed; or
* "arguments" for the fs callback calls, whose argument is the call's
* dyn argument vector, where the runtime finds the callback. */
type CallbackPosition = number | "last" | "arguments";
const COMPLETION_CALLBACKS: ReadonlyMap<IrLibFn, CallbackPosition> = new Map<
IrLibFn,
CallbackPosition
>([
["cp.execFile", 2],
["crypto.generateKeyCb", 2],
["crypto.hkdfCb", 5],
["crypto.pbkdf2Cb", 5],
["crypto.randomBytesCb", 1],
["crypto.randomFillCb", 4],
["crypto.randomFillCbDyn", 4],
["crypto.randomIntCb", 3],
["crypto.scryptCb", 4],
["dgram.bindCb", 3],
["dgram.closeCb", 1],
["dgram.connectCb", 3],
["dns.lookupDyn", 2],
["fs.callbackCall", "arguments"],
["fs.callbackGlob", "arguments"],
["fs.renameCb", 2],
["http.requestAgentCb", "last"],
["http.requestCb", "last"],
["http.requestConnCb", "last"],
["http.requestDynCb", "last"],
["http.requestUrlCb", "last"],
["net.connectCb", 2],
["net.listenCb", 2],
["net.listenOptsCb", 4],
["net.listenOptsReusePortCb", 5],
["net.listenPathCb", 2],
["process.stderrWriteBytesCb", 2],
["process.stdoutWriteBytesCb", 2],
// stream.finished and stream.pipeline callbacks, which Node binds to
// the context of the call (eos' and pipeline's AsyncResource.bind).
["stream.finished", 1],
["stream.finishedDyn", 1],
["stream.finishedOpts", "last"],
["stream.finishedOptsSignal", "last"],
["stream.pipeline", "last"],
["stream.pipelineDyn", "last"],
["stream.pipelineStages", "last"],
["stream.pipelineStagesDyn", "last"],
["zlib.cbOpts", 3],
["zlib.cbOptsDyn", 3],
["zlib.deflateCb", 1],
["zlib.deflateRawCb", 1],
["zlib.gunzipCb", 1],
["zlib.gzipCb", 1],
["zlib.inflateCb", 1],
["zlib.inflateRawCb", 1],
["zlib.unzipCb", 1],
]);
/** Completion callbacks that fire from other contexts' code (a stream event
* that another context's call emits), so an empty context at the call
* binds too: the callback then runs with no store, as in Node. */
const BIND_EMPTY_CONTEXT: ReadonlySet<IrLibFn> = new Set<IrLibFn>([
"stream.finished",
"stream.finishedDyn",
"stream.finishedOpts",
"stream.finishedOptsSignal",
"stream.pipeline",
"stream.pipelineDyn",
"stream.pipelineStages",
"stream.pipelineStagesDyn",
]);
/** `cb` bound to the context active where it is evaluated. Unless
* `bindEmpty`, an empty context leaves it unbound (`always` false): the
* loop already runs those callbacks with an empty context. */
function bindToActiveContext(cb: IrExpr, bindEmpty = false): IrExpr {
const always: IrExpr = { kind: "boolLit", value: bindEmpty, type: BOOL, loc: cb.loc };
if (cb.type.kind === "func")
return {
kind: "libCall",
fn: "als.bindCallback",
args: [cb, always],
type: cb.type,
loc: cb.loc,
};
if (cb.type.kind === "dyn")
return {
kind: "libCall",
fn: "als.bindCallbackDyn",
args: [cb, always],
type: cb.type,
loc: cb.loc,
};
return cb;
}
/** An element of a dyn argument vector that can be the callback: a boxed
* closure binds as a typed closure; any other dyn value that is not a
* boxed primitive binds as a dyn function (non-functions pass through). */
function bindArgumentElement(e: IrExpr): IrExpr {
if (e.kind === "dynFrom") {
return e.value.type.kind === "func" ? { ...e, value: bindToActiveContext(e.value) } : e;
}
return e.type.kind === "dyn" ? bindToActiveContext(e) : e;
}
function bindCall(e: IrExpr): IrExpr {
if (e.kind !== "libCall") return e;
const position = COMPLETION_CALLBACKS.get(e.fn);
if (position === undefined) return e;
if (position === "arguments") {
const index = e.fn === "fs.callbackCall" ? 1 : 0;
const vector = e.args[index];
if (vector === undefined || vector.kind !== "dynArrLit") return e;
const args = e.args.slice();
args[index] = {
kind: "dynArrLit",
elems: vector.elems.map(bindArgumentElement),
type: vector.type,
loc: vector.loc,
};
return { ...e, args };
}
const index = position === "last" ? e.args.length - 1 : position;
const cb = e.args[index];
if (cb === undefined || (position === "last" && cb.type.kind !== "func")) return e;
const args = e.args.slice();
args[index] = bindToActiveContext(cb, BIND_EMPTY_CONTEXT.has(e.fn));
return { ...e, args };
}
/** Binds the completion callbacks of `mod` when its scheduling carries
* AsyncLocalStorage contexts. */
export function bindCompletionCallbacks(mod: IrModule): void {
if (!moduleRuntimeFeatures(mod).asyncContext) return;
const rewriteExpr = (e: IrExpr): IrExpr => bindCall(mapExprChildren(e, rewriteExpr, rewriteStmt));
const rewriteStmt = (s: IrStmt): IrStmt => mapStmtChildren(s, rewriteExpr, rewriteStmt);
for (const fn of mod.functions) fn.body = fn.body.map(rewriteStmt);
}
packages/compiler/src/frontend/lowering/containers/array-callbacks.ts
+7 -6
View File
@@ -2358,10 +2358,11 @@ function reduceHelper(
* the left element first. Undefined values sink without reaching the user
* comparator. The callback sequence differs from V8's TimSort, so exact
* order and count parity are not claimed; results agree for consistent
* comparators. Without a comparator, string, number and boolean arrays use
* native stable ordering: their String conversions cannot call user code.
* Strings compare UTF-16 units; numbers compare their decimal spellings
* ([10, 9, 1] → [1, 10, 9]). Other element types still need a comparator. */
* comparators. Without a comparator, string, number, boolean and Date
* arrays use native stable ordering: their String conversions cannot call
* user code. Strings compare UTF-16 units; numbers compare their decimal
* spellings ([10, 9, 1] → [1, 10, 9]); Dates compare their toString() text.
* Other element types still need a comparator. */
export function lowerArraySortCall(
lowerer: Lowerer,
call: ts.CallExpression,
@@ -2374,7 +2375,7 @@ export function lowerArraySortCall(
const copyFirst = method === "toSorted";
if (
call.arguments.nodes.length === 0 &&
(elem.kind === "string" || elem.kind === "f64" || elem.kind === "bool")
(elem.kind === "string" || elem.kind === "f64" || elem.kind === "bool" || elem.kind === "date")
) {
return {
kind: "arrIntrinsic",
@@ -2389,7 +2390,7 @@ export function lowerArraySortCall(
lowerer.noLowering(
`.${method} with ${call.arguments.nodes.length} arguments`,
call,
"default ordering supports string[], number[] and boolean[]; other element types need a comparator",
"default ordering supports string[], number[], boolean[] and Date[]; other element types need a comparator",
);
}
const receiver = lowerer.lowerExpr(access.expression);
packages/compiler/src/frontend/lowering/containers/array-methods.ts
+14 -3
View File
@@ -1081,14 +1081,25 @@ export function lowerArrayMethodCall(
(lowerer.unions
.get(elem.unionId)
?.arms.every(
(a) => a.kind === "f64" || a.kind === "string" || a.kind === "bool" || isUnitType(a),
(a) =>
a.kind === "f64" ||
a.kind === "string" ||
a.kind === "bool" ||
a.kind === "date" ||
isUnitType(a),
) ??
false);
if (elem.kind !== "f64" && elem.kind !== "string" && elem.kind !== "bool" && !joinableUnion) {
if (
elem.kind !== "f64" &&
elem.kind !== "string" &&
elem.kind !== "bool" &&
elem.kind !== "date" &&
!joinableUnion
) {
lowerer.unsupported(
"SC1090",
call,
"'.join()' on arrays of this element type (number, string, and boolean arrays join — unions of those with undefined/null arms too, the units printing empty like JS)",
"'.join()' on arrays of this element type (number, string, boolean and Date arrays join — unions of those with undefined/null arms too, the units printing empty like JS)",
);
}
const receiver = lowerer.lowerExpr(access.expression);
packages/compiler/src/frontend/lowering/containers/bytes.ts
+122 -16
View File
@@ -1,5 +1,5 @@
import { keyedHelperName } from "../stable-names.js";
import { boolLit, dynUndefinedExpr, numLit, varRef } from "../../../ir/build.js";
import { boolLit, dynUndefinedExpr, nodeThrowExpr, numLit, varRef } from "../../../ir/build.js";
import { BUF_NUM_METHODS } from "./buffer-numeric-methods.js";
import * as ts from "../../ts7/adapter.js";
import {
@@ -903,6 +903,126 @@ function lowerDataViewNew(lowerer: Lowerer, expr: ts.NewExpression): IrExpr {
return lowerArrayBufferView(lowerer, args, "dv", locOf(expr));
}
/** `receiver.set(src, offset?)` on a lowered typed-array receiver. */
function bytesSetIntrinsic(
lowerer: Lowerer,
receiver: IrExpr,
argNodes: readonly ts.Expression[],
loc: SrcLoc,
): IrExpr {
const src = lowerer.lowerExpr(argNodes[0]!);
const method = src.type.kind === "bytes" ? "setFrom" : "setFromDyn";
const args = [src.type.kind === "bytes" ? src : lowerer.coerceInto(argNodes[0]!, src, DYN)];
if (argNodes.length === 2)
args.push(
lowerOptionalArgument(lowerer, argNodes[1]!, F64, {
kind: "numLit",
value: 0,
type: F64,
loc,
}),
);
return { kind: "bytesIntrinsic", method, receiver, args, type: VOID, loc };
}
/** `Uint8Array.prototype.set.call(target, src, offset?)`, through any typed
* array constructor's prototype (they share %TypedArray%.prototype.set). A
* target the checker types as a typed array or Buffer lowers like
* `target.set(src, offset)`. Any other target, a DataView included, is
* checked at run time: a typed array calls its `set`, and
* anything else throws Node's TypeError "this is not a typed array.",
* after every argument is evaluated. */
export function lowerBytesPrototypeSetCall(
lowerer: Lowerer,
call: ts.CallExpression,
access: ts.PropertyAccessExpression,
): IrExpr | null {
if (
call.questionDotToken ||
access.questionDotToken ||
access.name.text !== "call" ||
!ts.isPropertyAccessExpression(access.expression)
)
return null;
const method = access.expression;
const proto = method.expression;
if (
method.questionDotToken ||
method.name.text !== "set" ||
!ts.isPropertyAccessExpression(proto) ||
proto.questionDotToken ||
proto.name.text !== "prototype" ||
!ts.isIdentifier(proto.expression) ||
!lowerer.isStdlibMember(method)
)
return null;
const ctor = lowerer.resolveValueSymbol(proto.expression);
if (!ctor || !lowerer.isStdlibSymbol(ctor) || !own(BYTES_CTORS, ts.symbolName(ctor))) return null;
const argNodes = call.arguments.nodes;
if (argNodes.length < 2 || argNodes.length > 3 || argNodes.some(ts.isSpreadElement)) return null;
const loc = locOf(call);
const target = lowerer.lowerExpr(argNodes[0]!);
// A DataView lowers to the same bytes type, so the checker type decides:
// only a typed array (or a Buffer) takes the method's path.
const targetSymbol = lowerer.typeOf(argNodes[0]!).getSymbol();
if (
target.type.kind === "bytes" &&
targetSymbol !== undefined &&
lowerer.isStdlibSymbol(targetSymbol) &&
(own(BYTES_CTORS, ts.symbolName(targetSymbol)) !== undefined ||
ts.symbolName(targetSymbol) === "Buffer")
)
return bytesSetIntrinsic(lowerer, target, argNodes.slice(1), loc);
const slot = (value: IrExpr): { decl: IrStmt; read: IrExpr } => {
const local = lowerer.declareHiddenLocal("%setArg", DYN);
return {
decl: { kind: "varDecl", localId: local.id, init: value, loc },
read: varRef(local.id, DYN, loc),
};
};
const slots = [
slot(lowerer.coerceInto(argNodes[0]!, target, DYN)),
...argNodes.slice(1).map((arg) => slot(lowerer.lowerExprExpecting(arg, DYN))),
];
const isTypedArray: IrExpr = {
kind: "libCall",
fn: "util.typeIs",
args: [slots[0]!.read, { kind: "strLit", value: "isTypedArray", type: STRING, loc }],
type: BOOL,
loc,
};
return {
kind: "seqExpr",
stmts: [
...slots.map((s) => s.decl),
{
kind: "if",
cond: { kind: "unary", op: "!", operand: isTypedArray, type: BOOL, loc },
then: [
{
kind: "exprStmt",
expr: nodeThrowExpr(1, "", "this is not a typed array.", VOID, loc),
loc,
},
],
else_: null,
loc,
},
],
result: {
kind: "dynInvoke",
recv: slots[0]!.read,
method: "set",
calleeName: ts.getTextOfNode(method),
args: slots.slice(1).map((s) => s.read),
type: DYN,
loc,
},
type: DYN,
loc,
};
}
/** Method calls on typed-array/Buffer receivers: slice (copy), subarray
* (shared view), toReversed, copyWithin, set(src,
* offset?), and the u8-only Buffer surface: toString(enc?) plus the
@@ -1106,21 +1226,7 @@ export function lowerBytesMethodCall(
lowerer.noLowering(`.set with ${nArgs} arguments on typed arrays`, call);
}
const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
const src = lowerer.lowerExpr(call.arguments.nodes[0]!);
const method = src.type.kind === "bytes" ? "setFrom" : "setFromDyn";
const args = [
src.type.kind === "bytes" ? src : lowerer.coerceInto(call.arguments.nodes[0]!, src, DYN),
];
if (nArgs === 2)
args.push(
lowerOptionalArgument(lowerer, call.arguments.nodes[1]!, F64, {
kind: "numLit",
value: 0,
type: F64,
loc,
}),
);
return { kind: "bytesIntrinsic", method, receiver, args, type: VOID, loc };
return bytesSetIntrinsic(lowerer, receiver, call.arguments.nodes, loc);
}
if (name === "toString") {
// Buffer's toString(encoding?) — utf8 by default. A 0-arg toString
packages/compiler/src/frontend/lowering/date-values.ts
+207
View File
@@ -0,0 +1,207 @@
import * as ts from "../ts7/adapter.js";
import type { Lowerer } from "./lowerer.js";
/** Date methods whose receiver is only read for its time value: a Date
* local used as their receiver can store the time value instead of a Date
* object (builtins/dates.ts lowers them). */
const TIME_VALUE_METHODS = new Set([
"getTime",
"valueOf",
"toISOString",
"toJSON",
"toString",
"toDateString",
"toTimeString",
"toUTCString",
"getFullYear",
"getUTCFullYear",
"getMonth",
"getUTCMonth",
"getDate",
"getUTCDate",
"getDay",
"getUTCDay",
"getHours",
"getUTCHours",
"getMinutes",
"getUTCMinutes",
"getSeconds",
"getUTCSeconds",
"getMilliseconds",
"getUTCMilliseconds",
"getTimezoneOffset",
]);
const RELATIONAL = new Set([
ts.SyntaxKind.LessThanToken,
ts.SyntaxKind.LessThanEqualsToken,
ts.SyntaxKind.GreaterThanToken,
ts.SyntaxKind.GreaterThanEqualsToken,
]);
/** True when a local `const` (or a `let` that is never assigned again)
* initialized with `new Date(...)` can keep the Date's time value instead
* of a Date object: no use observes the Date's identity. Every use reads the time value as
* a Date method receiver, a String() or template operand, a relational or
* string `+` operand, or `new Date(d)`'s argument, inside the declaring
* function, or inside the block or loop that scopes a module-level
* binding (no closure captures it). Top-level module bindings keep the
* object. Other uses box the time value into a new Date at the use. */
export function isTimeValueDateDeclaration(
lowerer: Lowerer,
decl: ts.VariableDeclaration,
): boolean {
const known = lowerer.timeValueDateDecisions.get(decl);
if (known !== undefined) return known;
const answer = decideTimeValueDate(lowerer, decl);
lowerer.timeValueDateDecisions.set(decl, answer);
return answer;
}
function decideTimeValueDate(lowerer: Lowerer, decl: ts.VariableDeclaration): boolean {
if (!ts.isIdentifier(decl.name) || decl.initializer === undefined) return false;
// Only a Date the declaration creates: another reference to an existing
// Date can mutate it (`const d = a; a.setTime(0)`), and d must see that.
if (!createsDate(lowerer, decl.initializer)) return false;
const sf = decl.getSourceFile();
if (sf.isDeclarationFile || /\.[cm]?jsx?$/.test(sf.fileName)) return false;
const list = decl.parent;
if (!ts.isVariableDeclarationList(list)) return false;
const isConst = (list.flags & ts.NodeFlags.Const) !== 0;
const isLet = (list.flags & ts.NodeFlags.Let) !== 0;
if (!isConst && !isLet) return false;
if (!ts.isVariableStatement(list.parent) && !ts.isForStatement(list.parent)) return false;
const fn = enclosingFunction(decl);
// The uses to check: the function body, or for a binding inside a block
// or loop at module level (a local of the module's initializer, not a
// module binding) the block or loop that scopes it.
let scope: ts.Node | undefined;
if (fn !== null) scope = fn.body;
else if (!inClassStaticBlock(decl)) scope = moduleBlockScope(decl);
if (scope === undefined) return false;
// The lib Date interface by its symbol first: mapping every candidate
// binding's type would intern its unions before the lowering does.
const typeSymbol = lowerer.typeOf(decl.name).getSymbol();
if (
typeSymbol === undefined ||
ts.symbolName(typeSymbol) !== "Date" ||
!typeSymbol.declarations.some(
(d) => ts.isInterfaceDeclaration(d) && lowerer.isStdlibFile(d.getSourceFile()),
)
)
return false;
if (lowerer.mapTypeOf(lowerer.typeOf(decl.name))?.kind !== "date") return false;
const symbol = lowerer.checker.getSymbolAtLocation(decl.name);
if (!symbol) return false;
let ok = true;
const visit = (node: ts.Node): void => {
if (!ok) return;
if (ts.isIdentifier(node) && node !== decl.name && node.text === decl.name.text) {
if (lowerer.checker.getSymbolAtLocation(node) === symbol) {
if (enclosingFunction(node) !== fn || !readsTimeValue(lowerer, node)) ok = false;
}
return;
}
ts.forEachChild(node, visit);
};
visit(scope);
return ok;
}
/** True for `new Date(...)` of the standard Date, through parentheses and
* type-only wrappers: a Date no other reference can reach. */
function createsDate(lowerer: Lowerer, init: ts.Expression): boolean {
let e = init;
while (
ts.isParenthesizedExpression(e) ||
ts.isAsExpression(e) ||
ts.isSatisfiesExpression(e) ||
ts.isTypeAssertion(e) ||
ts.isNonNullExpression(e)
)
e = e.expression;
return ts.isNewExpression(e) && lowerer.isStdlibGlobal(e.expression, "Date");
}
/** The block or for statement that scopes a module-level binding which is
* not a module binding: a declaration in a block or loop body, or in a
* for statement's initializer. Undefined for a top-level declaration. */
function moduleBlockScope(decl: ts.VariableDeclaration): ts.Node | undefined {
const list = decl.parent;
if (!list || !ts.isVariableDeclarationList(list)) return undefined;
if (ts.isForStatement(list.parent)) return list.parent;
const statement = list.parent;
if (!ts.isVariableStatement(statement) || ts.isSourceFile(statement.parent)) return undefined;
for (let cur: ts.Node | undefined = statement.parent; cur; cur = cur.parent) {
if (ts.isBlock(cur) || ts.isCaseBlock(cur)) return cur;
if (ts.isSourceFile(cur)) return undefined;
}
return undefined;
}
function inClassStaticBlock(node: ts.Node): boolean {
for (let cur = node.parent; cur; cur = cur.parent) {
if (ts.isClassStaticBlockDeclaration(cur)) return true;
if (ts.isSourceFile(cur)) return false;
}
return false;
}
function enclosingFunction(node: ts.Node): ts.FunctionLikeDeclaration | null {
for (let cur = node.parent; cur; cur = cur.parent) {
if (
ts.isFunctionDeclaration(cur) ||
ts.isFunctionExpression(cur) ||
ts.isArrowFunction(cur) ||
ts.isMethodDeclaration(cur) ||
ts.isConstructorDeclaration(cur) ||
ts.isGetAccessorDeclaration(cur) ||
ts.isSetAccessorDeclaration(cur)
)
return cur;
if (ts.isClassStaticBlockDeclaration(cur) || ts.isSourceFile(cur)) return null;
}
return null;
}
/** A use of the binding that reads only its time value. */
function readsTimeValue(lowerer: Lowerer, id: ts.Identifier): boolean {
let node: ts.Node = id;
while (ts.isParenthesizedExpression(node.parent)) node = node.parent;
const parent = node.parent;
if (ts.isPropertyAccessExpression(parent) && parent.expression === node) {
const call = parent.parent;
return (
!parent.questionDotToken &&
ts.isCallExpression(call) &&
call.expression === parent &&
!call.questionDotToken &&
TIME_VALUE_METHODS.has(parent.name.text) &&
lowerer.isStdlibMember(parent)
);
}
if (ts.isTemplateSpan(parent)) return parent.expression === node;
if (ts.isCallExpression(parent)) {
return (
parent.arguments.nodes.length === 1 &&
parent.arguments.nodes[0] === node &&
ts.isIdentifier(parent.expression) &&
lowerer.isStdlibGlobal(parent.expression, "String")
);
}
if (ts.isNewExpression(parent)) {
return (
parent.arguments?.nodes.length === 1 &&
parent.arguments.nodes[0] === node &&
ts.isIdentifier(parent.expression) &&
lowerer.isStdlibGlobal(parent.expression, "Date")
);
}
if (ts.isBinaryExpression(parent)) {
const other = parent.left === node ? parent.right : parent.left;
const otherKind = lowerer.mapTypeOf(lowerer.typeOf(other))?.kind;
if (RELATIONAL.has(parent.operatorToken.kind)) return otherKind === "date";
if (parent.operatorToken.kind === ts.SyntaxKind.PlusToken) return otherKind === "string";
}
return false;
}
packages/compiler/src/frontend/lowering/expressions/binary.ts
+50 -18
View File
@@ -764,10 +764,21 @@ export function ensureString(lowerer: Lowerer, e: IrExpr, node: ts.Node): IrExpr
(lowerer.unions
.get(elem.unionId)
?.arms.every(
(a) => a.kind === "f64" || a.kind === "string" || a.kind === "bool" || isUnitType(a),
(a) =>
a.kind === "f64" ||
a.kind === "string" ||
a.kind === "bool" ||
a.kind === "date" ||
isUnitType(a),
) ??
false);
if (elem.kind === "f64" || elem.kind === "string" || elem.kind === "bool" || joinableUnion) {
if (
elem.kind === "f64" ||
elem.kind === "string" ||
elem.kind === "bool" ||
elem.kind === "date" ||
joinableUnion
) {
const sep: IrExpr = { kind: "strLit", value: ",", type: STRING, loc: e.loc };
return {
kind: "arrIntrinsic",
@@ -2195,14 +2206,41 @@ export function lowerBinary(lowerer: Lowerer, expr: ts.BinaryExpression): IrExpr
loc,
};
if (bothStr) return { kind: "strCmp", op: cmpOp, left, right, type: BOOL, loc };
// A Date converts to a new checked-dynamic Date on each crossing, so
// comparisons keep their Date fence instead of comparing copies.
if (
left.type.kind !== "date" &&
right.type.kind !== "date" &&
lowerer.dynConvertible(left.type) &&
lowerer.dynConvertible(right.type)
) {
// Dates compare by time value, the number hint of ToPrimitive. Both
// operands evaluate before either converts, so a right operand that
// mutates the left Date (`a < (a.setTime(t), b)`) is seen: with such
// a right operand, both Dates bind first and their times read after.
if (left.type.kind === "date" && right.type.kind === "date") {
const time = (d: IrExpr): IrExpr => ({
kind: "libCall",
fn: "date.getTime",
args: [d],
type: F64,
loc,
});
if (isSafeToRepeat(right))
return { kind: "bin", op: cmpOp, left: time(left), right: time(right), type: BOOL, loc };
const leftDate = lowerer.declareHiddenLocal("%date", left.type);
const rightDate = lowerer.declareHiddenLocal("%date", right.type);
return {
kind: "seqExpr",
stmts: [
{ kind: "varDecl", localId: leftDate.id, init: left, loc },
{ kind: "varDecl", localId: rightDate.id, init: right, loc },
],
result: {
kind: "bin",
op: cmpOp,
left: time(varRef(leftDate.id, left.type, loc)),
right: time(varRef(rightDate.id, right.type, loc)),
type: BOOL,
loc,
},
type: BOOL,
loc,
};
}
if (lowerer.dynConvertible(left.type) && lowerer.dynConvertible(right.type)) {
return {
kind: "libCall",
fn: "dyn.compare",
@@ -2416,6 +2454,7 @@ export function lowerStrictEquality(
idLeft.type.kind === "map" ||
idLeft.type.kind === "set" ||
idLeft.type.kind === "regex" ||
idLeft.type.kind === "date" ||
idLeft.type.kind === "url" ||
idLeft.type.kind === "object" ||
idLeft.type.kind === "record" ||
@@ -2452,14 +2491,7 @@ export function lowerStrictEquality(
loc,
};
}
// A Date converts to a new checked-dynamic Date on each crossing; its
// identity has no representation, so equality keeps the fence.
if (
idLeft.type.kind !== "date" &&
idRight.type.kind !== "date" &&
lowerer.dynConvertible(idLeft.type) &&
lowerer.dynConvertible(idRight.type)
) {
if (lowerer.dynConvertible(idLeft.type) && lowerer.dynConvertible(idRight.type)) {
return {
kind: "dynScalarEq",
left: lowerer.coerceToExpected(idLeft, DYN),
packages/compiler/src/frontend/lowering/expressions/element-access.ts
+1 -1
View File
@@ -1028,7 +1028,7 @@ function lowerGuardedRecordWrite(
const value = stabilized(lowerer, lowerer.lowerExpr(expr.right), "%recordValue", receiver.stmts);
const write = lowerer.withExpressionOverride(target.expression, receiver.present, () =>
lowerer.withExpressionOverride(target.argumentExpression, key, () =>
lowerer.withExpressionOverride(expr.right, value, () => lowerElementWrite(lowerer, expr)),
lowerer.withExpressionOverride(expr.right, value, () => lowerer.lowerElementWrite(expr)),
),
);
return {
packages/compiler/src/frontend/lowering/expressions/identifiers.ts
+18
View File
@@ -9,6 +9,7 @@ import { type Lowerer, PoisonError } from "../lowerer.js";
import {
BOOL,
BYTES_ELEMENT_NAME,
DATE_T,
DYN,
F64,
type IrExpr,
@@ -171,6 +172,12 @@ export function lowerIdentifierExpr(lowerer: Lowerer, expr: ts.Identifier, loc:
// when the checker types this USE as a single arm, maybeNarrow
// bridges the tagged representation with a unionNarrow.
const local = lowerer.resolveLocal(expr);
// A Date local holding its time value reads as that Date: only uses
// that read the time value reach here (date-values.ts).
if (local && lowerer.timeValueDateLocals.has(local)) {
const time: IrExpr = { kind: "varRef", localId: local.id, type: F64, loc };
return { kind: "libCall", fn: "date.fromTime", args: [time], type: DATE_T, loc };
}
if (local) {
// A switch can dispatch past a lexical declaration. Keep this
// previously refused codec form out until switch-scope TDZ boxes
@@ -744,6 +751,17 @@ export function lowerIdentifierExpr(lowerer: Lowerer, expr: ts.Identifier, loc:
return { kind: "libCall", fn: "webcrypto.object", args: [], type: DYN, loc };
const nativeAlias = stdlibGlobalNameOf(lowerer, expr);
if (nativeAlias === "Buffer" && expr.text !== "Buffer") {
// An alias through a cast of globalThis carries the cast's static type,
// which the identity token below does not have.
const aliasSymbol = identifierReadSymbol(lowerer, expr);
if (aliasSymbol && lowerer.castGlobalAliases.has(aliasSymbol)) {
lowerer.unsupported(
"SC1090",
expr,
"the Buffer constructor read through a cast of globalThis as a value",
"test it in a condition, read its typeof, or call its members",
);
}
return { kind: "strLit", value: "[builtin Buffer]", type: STRING, loc };
}
if (lowerer.isStdlibGlobal(expr, "fetch")) {
packages/compiler/src/frontend/lowering/expressions/property-access.ts
+22
View File
@@ -134,6 +134,7 @@ import {
import { expandoMemberRead } from "../lower-expando.js";
import { lowerProtocolPropertyRead } from "../class-protocol-dispatch.js";
import { lowerReadlineProperty } from "../builtins/readline.js";
import { lowerAsyncLocalStorageProperty } from "../builtins/async-context.js";
import { lowerEventStaticProperty } from "../builtins/numbers.js";
import { lowerStreamProperty, lowerStreamStateProperty, streamSidesOf } from "../lower-stream.js";
import { lowerValueStreamProperty } from "../builtins/hash-stream.js";
@@ -833,6 +834,8 @@ export function lowerPropertyAccessExpr(
// diagnostics_channel Channel receivers — name/hasSubscribers
// over the f64 channel handle.
lowerer.lowerDiagnosticsChannelProperty(expr) ??
// AsyncLocalStorage receivers — the name option.
lowerAsyncLocalStorageProperty(lowerer, expr) ??
// readline Interface receivers — the history and option members
// over the f64 interface handle.
lowerReadlineProperty(lowerer, expr) ??
@@ -1499,6 +1502,25 @@ export function lowerPropertyAccessExpr(
) {
return afterReceiver(recvLowered, dynUndefinedExpr(loc), loc);
}
// A typed array under a checker `any` (a JS binding its own initializer's
// inference refers to: hono's etag digest `nextChunk`) reads through its
// box, as the method-call twin dispatches. The box shares the native
// storage, so it needs no fresh-result restriction.
if (
recvLowered.type.kind === "bytes" &&
(lowerer.typeOf(expr.expression).flags & ts.TypeFlags.Any) !== 0
) {
return lowerer.maybeNarrow(
{
kind: "dynKeyGet",
value: lowerer.coerceToExpected(recvLowered, DYN),
key: { kind: "strLit", value: expr.name.text, type: STRING, loc },
type: DYN,
loc,
},
expr,
);
}
lowerer.unsupported(
"SC1090",
expr,
packages/compiler/src/frontend/lowering/expressions/relational.ts
+16
View File
@@ -338,6 +338,22 @@ export function lowerInstanceOf(lowerer: Lowerer, expr: ts.BinaryExpression, loc
type: BOOL,
loc,
};
// A codec in untyped storage is its record's handle box.
const codec = (["TextEncoder", "TextDecoder"] as const).find((name) =>
lowerer.isStdlibGlobal(expr.right, name),
);
if (codec && lowerer.mapTypeOf(lowerer.typeOf(expr.left))?.kind === "dyn") {
return {
kind: "libCall",
fn: "text.codecIs",
args: [
lowerer.lowerExprExpecting(expr.left, DYN),
{ kind: "boolLit", value: codec === "TextDecoder", type: BOOL, loc },
],
type: BOOL,
loc,
};
}
if (lowerer.isStdlibGlobal(expr.right, "ReadableStream")) {
const value = lowerer.lowerExprExpecting(expr.left, DYN);
return { kind: "libCall", fn: "fetch.streamIs", args: [value], type: BOOL, loc };
packages/compiler/src/frontend/lowering/expressions/typeof.ts
+6
View File
@@ -88,6 +88,12 @@ export function lowerTypeofExpr(lowerer: Lowerer, expr: ts.TypeOfExpression, loc
if (builtinClassRefOf(lowerer, expr.expression) !== null) {
return { kind: "strLit", value: "function", type: STRING, loc };
}
// The Buffer constructor and its aliases (`const B = globalThis.Buffer`,
// `(globalThis as { Buffer?: B }).Buffer`): a value read of an alias is an
// identity token, so its typeof is decided here.
if (stdlibGlobalNameOf(lowerer, expr.expression) === "Buffer") {
return { kind: "strLit", value: "function", type: STRING, loc };
}
if (ts.isPropertyAccessExpression(expr.expression)) {
const member = expr.expression;
const prototype = member.expression;
packages/compiler/src/frontend/lowering/expressions/union-fields.ts
+3
View File
@@ -2,6 +2,7 @@ import { nodeThrowExpr, varRef } from "../../../ir/build.js";
import * as ts from "../../ts7/adapter.js";
import type { Lowerer } from "../lowerer.js";
import { narrowStoredClassValue } from "../class-unions.js";
import { markSloppyRecordWrites } from "../frozen-records.js";
import {
BOOL,
type IrExpr,
@@ -246,6 +247,8 @@ export function lowerUnionFieldWrite(
value: slotValue,
loc,
};
// A sloppy-mode write to a frozen record leaves it unchanged.
if (write.kind === "recordSet") markSloppyRecordWrites(lowerer, write, access);
branch = { kind: "seqExpr", stmts: [write], result, type: result.type, loc };
} else {
branch = nodeThrowExpr(
packages/compiler/src/frontend/lowering/expressions/updates.ts
+4
View File
@@ -191,6 +191,10 @@ export function lowerPrefixUnary(lowerer: Lowerer, expr: ts.PrefixUnaryExpressio
operatorUnsupported(lowerer, expr, "+", [raw.type]);
}
case ts.SyntaxKind.ExclamationToken: {
// `!runtimeBuffer` over an alias of the Buffer global: Node always
// defines Buffer (the condition twin is lowerCondition's).
if (lowerer.isStdlibGlobal(expr.operand, "Buffer"))
return { kind: "boolLit", value: false, type: BOOL, loc };
// `!x` is ToBoolean-then-negate: f64/string operands go through toBool.
const operand = lowerer.ensureBool(
deferredSlotOr(
packages/compiler/src/frontend/lowering/frozen-records.ts
+354
View File
@@ -0,0 +1,354 @@
import * as ts from "../ts7/adapter.js";
import {
BOOL,
VOID,
shapeHasAccessorSlots,
typeKey,
type IrExpr,
type IrFunction,
type IrStmt,
type IrType,
type SrcLoc,
} from "../../ir/ir.js";
import { numLit, strLit, varRef } from "../../ir/build.js";
import { everyStmtList, transformStmtList } from "../../ir/traverse.js";
import type { Lowerer } from "./lowerer.js";
import { recordHasOwnHelper } from "./lower-calls.js";
import { isStrictCode } from "./strict-mode.js";
/* Object.freeze of records and arrays that other references can still
* write. Only the types a program may freeze pay for it. A record keeps its
* frozen bit in the rc word (scr_rc.h SCR_RC_FROZEN), which its release
* ignores, and every write to it checks the bit first
* (guardFrozenWrites). An array keeps it in its storage flags
* (scr_array.h SCR_ARR_FROZEN), which the backend's array write guards test
* for the array types the module lists (IrModule.freezableArrays). A type is
* freezable when a static Object.freeze names it, or, in a program that
* freezes untyped values, when a value of it or of a type reaching it can be
* held as a live untyped reference. */
type RecordType = Extract<IrType, { kind: "record" }>;
type RecordWrite = Extract<IrStmt, { kind: "recordSet" | "recordKeySet" | "recordKeyDelete" }>;
type FreezeFn = "record.freeze" | "array.freeze" | "collection.preventExtensions";
/** Object.freeze of a record or an array, or Object.freeze, seal or
* preventExtensions of a Map or Set: `fn` sets the value's bit, and the
* call answers the value. */
export function lowerNativeFreeze(
lowerer: Lowerer,
fn: FreezeFn,
target: IrExpr,
loc: SrcLoc,
): IrExpr {
const type = target.type;
const slot = lowerer.declareHiddenLocal("%freezeTarget", type);
const receiver = (): IrExpr => varRef(slot.id, type, loc);
return {
kind: "seqExpr",
stmts: [
{ kind: "varDecl", localId: slot.id, init: target, loc },
{
kind: "exprStmt",
expr: { kind: "libCall", fn, args: [receiver()], type: VOID, loc },
loc,
},
],
result: receiver(),
type,
loc,
};
}
function isRecordWrite(s: IrStmt): s is RecordWrite {
return s.kind === "recordSet" || s.kind === "recordKeySet" || s.kind === "recordKeyDelete";
}
/** The key of a record write's source range: strict mode is lexical, so
* every write lowered from the same range shares its mode. */
function writeKey(loc: SrcLoc): string {
return `${loc.file}\0${loc.start}\0${loc.end}`;
}
/** Records the record writes of `stmt`, lowered from `node`, as sloppy-mode
* writes when `node` is sloppy-mode code: a write to a frozen record then
* leaves it unchanged instead of throwing. `deletes` says `stmt` is the
* absent-state write of `delete r.f`, which Node refuses only while the
* field is present. */
export function markSloppyRecordWrites(
lowerer: Lowerer,
stmt: IrStmt,
node: ts.Node,
deletes = false,
): IrStmt {
if (deletes) lowerer.recordFieldDeletes.add(writeKey(stmt.loc));
if (isStrictCode(node)) return stmt;
everyStmtList([stmt], {
stmt: (s) => {
if (s.kind === "recordSet" || s.kind === "recordKeySet" || s.kind === "recordKeyDelete")
lowerer.sloppyRecordWrites.add(writeKey(s.loc));
return true;
},
expr: () => true,
});
return stmt;
}
/** Whether a field write's value can be an optional field's absent state,
* which only a field write itself can hold. */
function holdsAbsentState(e: IrExpr): boolean {
if (e.kind === "fieldAbsent") return true;
return e.kind === "ternary" && (holdsAbsentState(e.then) || holdsAbsentState(e.else_));
}
/** The record shapes and array types (typeKeys) whose values the program
* may freeze. */
function freezableTypes(
lowerer: Lowerer,
functions: IrFunction[],
): { shapes: Set<string>; arrays: Set<string> } {
const shapes = new Set<string>();
const arrays = new Set<string>();
const live: IrType[] = [];
let dynFreeze = false;
for (const fn of functions)
everyStmtList(fn.body, {
expr: (e) => {
if (e.kind === "libCall" && e.fn === "record.freeze") {
const target = e.args[0];
if (target && target.type.kind === "record") shapes.add(target.type.shapeId);
} else if (e.kind === "libCall" && e.fn === "array.freeze") {
const target = e.args[0];
if (target && target.type.kind === "array") arrays.add(typeKey(target.type));
} else if (e.kind === "libCall" && e.fn === "dyn.freeze") dynFreeze = true;
else if (e.kind === "dynFrom") live.push(e.value.type);
return true;
},
stmt: () => true,
});
if (!dynFreeze) return { shapes, arrays };
// An untyped reference to a class instance, or to a record or array
// boxed live, reaches the values its fields and elements hold as further
// live references. Class instances also cross into untyped code through
// compiled callbacks, so every class is a root.
const stack = [...live];
for (const info of lowerer.classes.values())
for (const field of info.def.fields) stack.push(field.type);
const seen = new Set<string>();
while (stack.length > 0) {
const type = stack.pop()!;
switch (type.kind) {
case "record": {
if (seen.has(`record:${type.shapeId}`)) break;
seen.add(`record:${type.shapeId}`);
shapes.add(type.shapeId);
const shape = lowerer.shapes.get(type.shapeId);
for (const field of shape?.fields ?? []) stack.push(field.type);
if (shape?.indexValue) stack.push(shape.indexValue);
break;
}
case "union":
if (seen.has(`union:${type.unionId}`)) break;
seen.add(`union:${type.unionId}`);
for (const arm of lowerer.unions.get(type.unionId)?.arms ?? []) stack.push(arm);
break;
case "array": {
const key = typeKey(type);
if (seen.has(key)) break;
seen.add(key);
arrays.add(key);
stack.push(type.elem);
break;
}
case "set":
stack.push(type.elem);
break;
case "map":
stack.push(type.key, type.value);
break;
case "promise":
stack.push(type.inner);
break;
case "generator":
stack.push(type.yieldT, type.retT, type.nextT);
break;
case "func":
for (const param of type.params) stack.push(param);
stack.push(type.ret);
break;
default:
break;
}
}
return { shapes, arrays };
}
/** The guarded form of a write to a freezable record: the receiver and the
* operands are evaluated first, in source order, then the frozen bit decides
* between the write and `reject`. */
function guardedWrite(
receiver: IrExpr,
decls: IrStmt[],
reject: IrStmt[],
store: IrStmt,
loc: SrcLoc,
): IrStmt {
return {
kind: "block",
body: [
...decls,
{
kind: "if",
cond: { kind: "libCall", fn: "record.isFrozen", args: [receiver], type: BOOL, loc },
then: reject,
else_: [store],
loc,
},
],
loc,
};
}
/** Checks the frozen bit before every write to a record of a freezable
* shape, and lists the freezable array types, whose writes the backend
* guards (IrModule.freezableArrays). A write to a frozen record throws
* Node's TypeError in strict mode code; in sloppy-mode code it leaves the
* record unchanged. Deleting a key the record does not have succeeds either
* way. */
export function guardFrozenWrites(lowerer: Lowerer, functions: IrFunction[]): void {
const { shapes: freezable, arrays } = freezableTypes(lowerer, functions);
for (const id of freezable) {
const shape = lowerer.shapes.get(id);
if (shape) shape.freezable = true;
}
for (const key of arrays) lowerer.freezableArrays.add(key);
if (freezable.size === 0) return;
const lifted = lowerer.liftedFns.length;
for (const fn of functions) {
const local = (type: IrType, loc: SrcLoc): Extract<IrExpr, { kind: "varRef" }> => {
const id = `%frozenWrite.${fn.locals.length}`;
fn.locals.push({ id, name: id, type, mutable: false });
return { kind: "varRef", localId: id, type, loc };
};
const guarded = new Set<IrStmt>();
fn.body = transformStmtList(fn.body, {
stmt: (statement) => {
if (!isRecordWrite(statement) || guarded.has(statement)) return statement;
if (!freezable.has(statement.shapeId)) return statement;
const sloppy = lowerer.sloppyRecordWrites.has(writeKey(statement.loc));
const deletes =
statement.kind === "recordSet" && lowerer.recordFieldDeletes.has(writeKey(statement.loc));
const loc = statement.loc;
const shapeId = statement.shapeId;
const receiver = local(statement.obj.type, loc);
const decls: IrStmt[] = [
{ kind: "varDecl", localId: receiver.localId, init: statement.obj, loc },
];
const owner = strLit(
lowerer.shapes.get(shapeId)?.tuple ? "[object Array]" : "#<Object>",
loc,
);
const thrown = (key: IrExpr, operation: number): IrStmt => ({
kind: "exprStmt",
expr: {
kind: "libCall",
fn: "record.throwFrozen",
args: [key, owner, numLit(operation, loc)],
type: VOID,
loc,
},
loc,
});
if (statement.kind === "recordSet") {
let value = statement.value;
if (!holdsAbsentState(value)) {
const slot = local(value.type, loc);
decls.push({ kind: "varDecl", localId: slot.localId, init: value, loc });
value = slot;
}
const store: IrStmt = {
kind: "recordSet",
obj: receiver,
shapeId,
field: statement.field,
value,
loc,
};
guarded.add(store);
const field = strLit(statement.field, loc);
// `delete r.f` of an optional field writes its absent state: Node
// only refuses it when the field is present.
const reject: IrStmt[] = sloppy
? []
: deletes
? [
{
kind: "if",
cond: lowerer.recordFieldPresent(receiver, shapeId, statement.field, loc),
then: [thrown(field, 2)],
else_: null,
loc,
},
]
: [thrown(field, 0)];
return guardedWrite(receiver, decls, reject, store, loc);
}
const key = local(statement.key.type, loc);
decls.push({ kind: "varDecl", localId: key.localId, init: statement.key, loc });
const named = key.type.kind === "string";
const present: IrExpr = named
? {
kind: "call",
callee: recordHasOwnHelper(lowerer, shapeId, loc),
args: [receiver, key],
type: BOOL,
loc,
}
: { kind: "boolLit", value: true, type: BOOL, loc };
const text: IrExpr = named ? key : strLit("[key]", loc);
if (statement.kind === "recordKeySet") {
const value = local(statement.value.type, loc);
decls.push({ kind: "varDecl", localId: value.localId, init: statement.value, loc });
const store: IrStmt = {
kind: "recordKeySet",
obj: receiver,
shapeId,
key,
value,
...(statement.overflowOnly ? { overflowOnly: true as const } : {}),
loc,
};
guarded.add(store);
const reject: IrStmt[] = sloppy
? []
: [
{
kind: "if",
cond: present,
then: [thrown(text, 0)],
else_: [thrown(text, 1)],
loc,
},
];
return guardedWrite(receiver, decls, reject, store, loc);
}
const store: IrStmt = { kind: "recordKeyDelete", obj: receiver, shapeId, key, loc };
guarded.add(store);
const reject: IrStmt[] = sloppy
? []
: [{ kind: "if", cond: present, then: [thrown(text, 2)], else_: null, loc }];
return guardedWrite(receiver, decls, reject, store, loc);
},
expr: (expression) => expression,
});
}
// The key-presence helpers the guards call.
for (const helper of lowerer.liftedFns.slice(lifted)) functions.push(helper);
}
/** Whether a statically typed Object.freeze can freeze a value of `type`:
* a record whose shape has no accessor properties. */
export function freezableRecordType(lowerer: Lowerer, type: IrType): type is RecordType {
if (type.kind !== "record") return false;
const shape = lowerer.shapes.get(type.shapeId);
return shape !== undefined && !shapeHasAccessorSlots(shape);
}
packages/compiler/src/frontend/lowering/iterator-adapters.ts
+196 -1
View File
@@ -28,11 +28,206 @@ export function iteratorSlotAdapter(
expr: IrExpr,
expected: IrType & { kind: "generator" },
): IrExpr | null {
if (expr.type.kind === "dyn") return dynIteratorAdapter(lowerer, expr, expected);
if (expr.type.kind === "dyn")
return (
collectionIteratorSlotValue(lowerer, expr, expected) ??
dynIteratorAdapter(lowerer, expr, expected)
);
if (expr.type.kind === "generator") return generatorRetypeAdapter(lowerer, expr, expected);
return null;
}
/** `m.values()` (or keys/entries, or a Set's) on a typed Map or Set, which
* lowers to a dynamic invocation on the boxed collection, flowing into an
* iterator-typed slot (`values(): IterableIterator<T> { return
* this.rows.values(); }`): an interned generator over the collection that
* reads each entry typed, instead of the checked adapter over the boxed
* native iterator (dynIteratorAdapter), which boxes every value and checks
* it back. It keeps that adapter's protocol: the walk is lazy and live, and
* since the native iterator has no return(), an early exit from a
* consumer's loop parks it on the current entry instead of completing it,
* so a later loop continues with the next entry. Null for any other source
* or a slot whose yield type is not the collection's entry type. */
function collectionIteratorSlotValue(
lowerer: Lowerer,
expr: IrExpr,
expected: IrType & { kind: "generator" },
): IrExpr | null {
if (expr.kind !== "dynInvoke" || expr.args.length > 0 || expr.calleeNameValue) return null;
const method = expr.method;
if (method !== "values" && method !== "keys" && method !== "entries") return null;
if (expr.recv.kind !== "dynFrom") return null;
const receiver = expr.recv.value;
const collT = receiver.type;
if (collT.kind !== "map" && collT.kind !== "set") return null;
if (expected.async || expected.yieldT.kind === "void") return null;
if (expected.retT.kind !== "void" && expected.retT.kind !== "dyn") return null;
if (expected.nextT.kind !== "undefinedT" && expected.nextT.kind !== "dyn") return null;
const resultType = genResultRecord(
expected.yieldT,
expected.retT,
lowerer.shapes,
lowerer.unions,
);
if (!resultType) return null;
const loc = expr.loc;
const key = `collIterSlot:${method}:${typeKey(collT)}:${typeKey(expected)}`;
let name = lowerer.valueHelpers.get(key);
if (!name) {
const coll = varRef("coll.0", collT, loc);
const index = varRef("index.0", F64, loc);
const native = varRef("native.0", DYN, loc);
const resumedFlag = varRef("resumed.0", BOOL, loc);
const keyT = collT.kind === "map" ? collT.key : collT.elem;
const valueT = collT.kind === "map" ? collT.value : collT.elem;
const read = (m: "iterKey" | "iterValue", t: IrType): IrExpr =>
collT.kind === "map"
? { kind: "mapIntrinsic", method: m, receiver: coll, args: [index], type: t, loc }
: { kind: "setIntrinsic", method: "iterKey", receiver: coll, args: [index], type: t, loc };
// entries() answers [key, value] pairs: only a slot whose yield type is
// that pair as a record of the two fields takes the typed walk; a tuple
// or other pair type keeps the checked adapter.
if (method === "entries") {
const pair =
expected.yieldT.kind === "record" ? lowerer.shapes.get(expected.yieldT.shapeId) : undefined;
const field = (name: string): IrType | undefined =>
pair?.fields.find((f) => f.name === name)?.type;
const first = field("0");
const second = field("1");
if (
pair === undefined ||
pair.fields.length !== 2 ||
first === undefined ||
second === undefined ||
!typeEquals(first, keyT) ||
!typeEquals(second, valueT)
)
return null;
}
const entry = (): IrExpr =>
method === "keys" || (collT.kind === "set" && method === "values")
? read("iterKey", keyT)
: method === "values"
? read("iterValue", valueT)
: {
kind: "recordLit",
fields: [
{ name: "0", value: read("iterKey", keyT) },
{ name: "1", value: read("iterValue", valueT) },
],
type: expected.yieldT,
loc,
};
if (!typeEquals(entry().type, expected.yieldT)) return null;
// The entry is read once per step and kept: the parking yield of an
// early exit answers it again rather than rereading a slot the loop may
// have deleted.
const current = varRef("current.0", expected.yieldT, loc);
const suspend = (): IrStmt => ({
kind: "exprStmt",
expr: { kind: "yieldExpr", value: current, type: resumeType(expected.nextT), loc },
loc,
});
const finish: IrStmt = {
kind: "return",
value: expected.retT.kind === "dyn" ? dynUndefinedExpr(loc) : null,
loc,
};
name = keyedHelperName(lowerer, "%coll.iterSlot", key);
lowerer.valueHelpers.set(key, name);
lowerer.liftedFns.push({
name,
params: [{ localId: "coll.0", name: "coll", type: collT }],
returnType: expected.retT,
locals: [
{ id: "coll.0", name: "coll", type: collT, mutable: false },
{ id: "native.0", name: "native", type: DYN, mutable: false },
{ id: "index.0", name: "index", type: F64, mutable: true },
{ id: "resumed.0", name: "resumed", type: BOOL, mutable: true },
{ id: "current.0", name: "current", type: expected.yieldT, mutable: false },
],
body: [
{
kind: "varDecl",
localId: "native.0",
init: {
kind: "dynInvoke",
recv: lowerer.coerceToExpected(coll, DYN),
method: "values",
calleeName: collT.kind === "map" ? "map.values" : "set.values",
args: [],
type: DYN,
loc,
},
loc,
},
{
kind: "varDecl",
localId: "resumed.0",
init: { kind: "boolLit", value: false, type: BOOL, loc },
loc,
},
{
kind: "while",
cond: { kind: "boolLit", value: true, type: BOOL, loc },
body: [
{
kind: "assign",
localId: "index.0",
value: {
kind: "libCall",
fn: "dyn.collectionIteratorIndex",
args: [native],
type: F64,
loc,
},
loc,
},
{
kind: "if",
cond: {
kind: "bin",
op: "<",
left: index,
right: { kind: "numLit", value: 0, type: F64, loc },
type: BOOL,
loc,
},
then: [finish],
else_: null,
loc,
},
setResumed(false, loc),
{ kind: "varDecl", localId: "current.0", init: entry(), loc },
{
kind: "tryCatch",
tryBody: [suspend(), setResumed(true, loc)],
catchBody: null,
catchLocalId: null,
// An early exit parks on the current entry; the next step
// resumes the walk after it.
finallyBody: [
{
kind: "if",
cond: { kind: "unary", op: "!", operand: resumedFlag, type: BOOL, loc },
then: [suspend(), { kind: "continue", loc }],
else_: null,
loc,
},
],
loc,
},
],
loc,
},
],
generator: { yieldT: expected.yieldT, nextT: expected.nextT, resultType, tag: "!" },
loc,
});
}
return { kind: "call", callee: name, args: [receiver], type: expected, loc };
}
/** `resumed.0 = value` — the adapters' early-exit marker around a yield. */
function setResumed(value: boolean, loc: SrcLoc): IrStmt {
return {

Some files were not shown because too many files have changed in this diff Show More