From c8a524c368ace54c88a4f9720ffad486e61f75f6 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Wed, 21 Oct 2026 19:59:04 -0500 Subject: [PATCH 001/102] Keep the .d.ts-only types of a package compiled from its JavaScript --- .../frontend/npm-static-type-exports-host.ts | 164 +++++++++++++++ .../frontend/npm-static-type-exports.test.ts | 76 +++++++ .../src/frontend/npm-static-type-exports.ts | 188 ++++++++++++++++++ packages/compiler/src/frontend/npm-static.ts | 28 +++ packages/compiler/src/frontend/program.ts | 6 + .../7001-package-declared-types/main.ts.json | 6 + .../7001-package-declared-types/main.ts | 19 ++ .../node_modules/issue-list/lib/index.d.ts | 17 ++ .../node_modules/issue-list/lib/index.js | 24 +++ .../node_modules/issue-list/lib/paging.d.ts | 4 + .../node_modules/issue-list/lib/paging.js | 2 + .../node_modules/issue-list/package.json | 1 + .../7001-package-declared-types/main.ts.json | 1 + 13 files changed, 536 insertions(+) create mode 100644 packages/compiler/src/frontend/npm-static-type-exports-host.ts create mode 100644 packages/compiler/src/frontend/npm-static-type-exports.test.ts create mode 100644 packages/compiler/src/frontend/npm-static-type-exports.ts create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7001-package-declared-types/main.ts.json create mode 100644 tests/corpus/7001-package-declared-types/main.ts create mode 100644 tests/corpus/7001-package-declared-types/node_modules/issue-list/lib/index.d.ts create mode 100644 tests/corpus/7001-package-declared-types/node_modules/issue-list/lib/index.js create mode 100644 tests/corpus/7001-package-declared-types/node_modules/issue-list/lib/paging.d.ts create mode 100644 tests/corpus/7001-package-declared-types/node_modules/issue-list/lib/paging.js create mode 100644 tests/corpus/7001-package-declared-types/node_modules/issue-list/package.json create mode 100644 tests/harness/corpus-costs/7001-package-declared-types/main.ts.json diff --git a/packages/compiler/src/frontend/npm-static-type-exports-host.ts b/packages/compiler/src/frontend/npm-static-type-exports-host.ts new file mode 100644 index 000000000..809464763 --- /dev/null +++ b/packages/compiler/src/frontend/npm-static-type-exports-host.ts @@ -0,0 +1,164 @@ +/** Filesystem side of npm-static-type-exports.ts: finds each opted-in + * package's declaration entry and runtime entry, copies the declaration + * files the entry reaches, and builds the runtime entry's typedefs. */ +import { dirname, relative, resolve as resolvePath } from "node:path"; +import { trackedFileExists, trackedReadFile } from "./input-tracker.js"; +import { resolveBareModule } from "./resolve.js"; +import { isJsSourceFileName } from "./tsc-codes.js"; +import type { FrontendServices } from "./services.js"; +import * as ts from "./ts7/syntax.js"; +import { + NPM_STATIC_TYPES_SUFFIX, + npmStaticDeclarationCopy, + npmStaticDeclarationExports, + npmStaticDeclarationSpecifiers, + npmStaticTypedefBlock, + type NpmStaticDeclarationExports, + type NpmStaticTypeDeclaration, +} from "./npm-static-type-exports.js"; + +export interface NpmStaticTypeExportPlan { + /** Copies of the declaration files, by copy path. */ + copies: Map; + /** The typedef block to append, by runtime entry (forward slashes). */ + typedefs: Map; +} + +/** The copy path of a declaration file. */ +function copyPathOf(declarationFile: string): string { + return declarationFile.replace(/\.d\.ts$/, NPM_STATIC_TYPES_SUFFIX); +} + +/** The declaration file a relative specifier names from `fromFile`, or null. */ +function declarationTargetOf(fromFile: string, specifier: string): string | null { + const base = resolvePath(dirname(fromFile), specifier); + const candidates = [ + `${base}.d.ts`, + `${base.replace(/\.(c|m)?js$/, "")}.d.ts`, + resolvePath(base, "index.d.ts"), + ]; + for (const candidate of candidates) if (trackedFileExists(candidate)) return candidate; + return null; +} + +/** A specifier for `target` from `fromFile`'s directory, without `.d.ts`. */ +function specifierFor(fromFile: string, target: string): string { + const rel = relative(dirname(fromFile), target) + .split("\\") + .join("/") + .replace(/\.d\.ts$/, ""); + return rel.startsWith(".") ? rel : `./${rel}`; +} + +/** The names the runtime JavaScript declares as types itself: classes, + * JSDoc typedefs and callbacks, and `@enum` constants. */ +function runtimeTypeNames(services: FrontendServices, file: string, text: string): Set { + const names = new Set(); + for (const m of text.matchAll(/@(?:typedef|callback)\s+(?:\{[^}]*\}\s*)?([A-Za-z_$][\w$]*)/g)) + names.add(m[1]!); + // `/** @enum {number} */ const Kind = { ... }`: the constant names a type too. + for (const m of text.matchAll( + /@enum\b[^\n]*\n(?:\s*\*[^\n]*\n)*?\s*(?:\*\/\s*)?(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)/g, + )) + names.add(m[1]!); + const sf = services.parse(file, text, "js"); + for (const stmt of sf.statements.nodes) + if (ts.isClassDeclaration(stmt) && stmt.name !== undefined) names.add(stmt.name.text); + return names; +} + +export function npmStaticTypeExportPlan( + services: FrontendServices, + entryPath: string, + packages: readonly string[], +): NpmStaticTypeExportPlan { + const copies = new Map(); + const typedefs = new Map(); + const parsed = new Map(); + const parse = (file: string): ts.SourceFile | null => { + let sf = parsed.get(file); + if (sf === undefined) { + const text = trackedReadFile(file); + sf = text === null ? null : services.parse(file, text, "ts"); + parsed.set(file, sf); + } + return sf; + }; + // Copies every declaration file reachable from `file` through relative + // specifiers, each specifier respelled to its target's copy. + const copy = (file: string): void => { + const copyPath = copyPathOf(file); + if (copies.has(copyPath)) return; + const sf = parse(file); + if (sf === null) return; + copies.set(copyPath, ""); + const targets = new Map(); + for (const specifier of npmStaticDeclarationSpecifiers(sf)) { + const target = declarationTargetOf(file, specifier); + if (target !== null) targets.set(specifier, target); + } + copies.set( + copyPath, + npmStaticDeclarationCopy(sf, (specifier) => { + const target = targets.get(specifier); + return target === undefined ? null : specifierFor(copyPath, copyPathOf(target)); + }), + ); + for (const target of targets.values()) copy(target); + }; + // The exported type-only declarations of `file`, through its re-exports. + const typesOf = ( + file: string, + seen: Set, + ): { types: Map; values: Set } => { + const result = { + types: new Map(), + values: new Set(), + }; + if (seen.has(file)) return result; + seen.add(file); + const sf = parse(file); + if (sf === null) return result; + const own: NpmStaticDeclarationExports = npmStaticDeclarationExports(sf); + for (const t of own.types) result.types.set(t.name, t); + for (const v of own.values) result.values.add(v); + for (const n of own.named) { + const target = n.specifier === null ? null : declarationTargetOf(file, n.specifier); + if (target === null) continue; + const inner = typesOf(target, new Set(seen)); + const t = inner.types.get(n.local); + if (t !== undefined) result.types.set(n.exported, { ...t, name: n.exported }); + else if (inner.values.has(n.local)) result.values.add(n.exported); + } + for (const specifier of own.stars) { + const target = declarationTargetOf(file, specifier); + if (target === null) continue; + const inner = typesOf(target, new Set(seen)); + for (const [name, t] of inner.types) if (!result.types.has(name)) result.types.set(name, t); + for (const v of inner.values) result.values.add(v); + } + return result; + }; + for (const pkg of packages) { + const declared = resolveBareModule(entryPath, pkg, "types-only"); + if (declared === null || declared.packageName !== pkg || !declared.typesFile.endsWith(".d.ts")) + continue; + const runtime = resolveBareModule(entryPath, pkg, "js-only"); + if (runtime === null || !isJsSourceFileName(runtime.typesFile)) continue; + const runtimeText = trackedReadFile(runtime.typesFile); + if (runtimeText === null) continue; + const { types, values } = typesOf(declared.typesFile, new Set()); + const declaredByRuntime = runtimeTypeNames(services, runtime.typesFile, runtimeText); + const exported = [...types.values()].filter( + (t) => !values.has(t.name) && !declaredByRuntime.has(t.name), + ); + if (exported.length === 0) continue; + copy(declared.typesFile); + const specifier = specifierFor(runtime.typesFile, copyPathOf(declared.typesFile)); + typedefs.set( + runtime.typesFile.split("\\").join("/"), + npmStaticTypedefBlock(exported, specifier), + ); + } + return { copies, typedefs }; +} diff --git a/packages/compiler/src/frontend/npm-static-type-exports.test.ts b/packages/compiler/src/frontend/npm-static-type-exports.test.ts new file mode 100644 index 000000000..fa95c0fe0 --- /dev/null +++ b/packages/compiler/src/frontend/npm-static-type-exports.test.ts @@ -0,0 +1,76 @@ +import { expect, test } from "vitest"; +import { nodeFrontendServices } from "./services-node.js"; +import { + npmStaticDeclarationCopy, + npmStaticDeclarationExports, + npmStaticTypedefBlock, +} from "./npm-static-type-exports.js"; + +function parse(text: string) { + return nodeFrontendServices().parse("/pkg/lib/index.d.ts", text, "ts"); +} + +test("type-only exports are told from values and re-exports", () => { + const exports = npmStaticDeclarationExports( + parse(`import type { Page } from "./paging"; +export * from "./paging"; +export { Entry as Item, Kind } from "./entries"; +export interface Options { value: T; label: U } +export type Mode = "a" | "b"; +export declare const enum Level { Low = 1 } +export declare class Client { url: string } +export declare function make(options: Options): Client; +export declare const version: string; +interface Hidden { x: number } +export { Hidden as Visible }; +declare function helper(): void; +export { helper };`), + ); + expect(exports.types.map((t) => [t.name, t.params, t.templates])).toEqual([ + ["Options", ["T", "U"], ["{object} [T={}]", "[U=string]"]], + ["Mode", [], []], + ["Level", [], []], + ["Visible", [], []], + ]); + expect(exports.values).toEqual(["Client", "make", "version", "helper"]); + expect(exports.named).toEqual([ + { exported: "Item", local: "Entry", specifier: "./entries" }, + { exported: "Kind", local: "Kind", specifier: "./entries" }, + ]); + expect(exports.stars).toEqual(["./paging"]); +}); + +test("a copy respells the relative specifiers it is told", () => { + const sf = parse(`import type { Page } from "./paging"; +export * from './entries'; +export type Box = import("./paging").Page; +export { readFile } from "fs"; +`); + const copy = npmStaticDeclarationCopy(sf, (s) => + s === "./paging" ? "./paging.scriptc-types" : null, + ); + expect(copy).toBe(`import type { Page } from "./paging.scriptc-types"; +export * from './entries'; +export type Box = import("./paging.scriptc-types").Page; +export { readFile } from "fs"; +`); +}); + +test("the typedef block re-exports each type with its parameters", () => { + expect( + npmStaticTypedefBlock( + [ + { name: "Mode", params: [], templates: [] }, + { name: "Options", params: ["T", "U"], templates: ["{object} [T={}]", "[U=string]"] }, + ], + "./index.scriptc-types", + ), + ).toBe(`/** + * @typedef {import("./index.scriptc-types").Mode} Mode + */ +/** + * @template {object} [T={}] + * @template [U=string] + * @typedef {import("./index.scriptc-types").Options} Options + */`); +}); diff --git a/packages/compiler/src/frontend/npm-static-type-exports.ts b/packages/compiler/src/frontend/npm-static-type-exports.ts new file mode 100644 index 000000000..844afa590 --- /dev/null +++ b/packages/compiler/src/frontend/npm-static-type-exports.ts @@ -0,0 +1,188 @@ +/* The type-only exports of an opted-in package's declaration files. + * + * An opted-in package compiles from its JavaScript, and the checker types + * the package from it: the package's shipped .d.ts is hidden from + * resolution (npmStaticFsShadow). Values keep their JavaScript types, but a + * type that exists only in the .d.ts (an interface, a type alias, an enum + * used as a type) has no declaration in the JavaScript, so a program's + * `import type { Options } from "pkg"` resolved to `any`. TypeScript and + * Node see the .d.ts types. + * + * The package's declaration files stay available as copies under another + * name (`.scriptc-types.d.ts`, relative specifiers respelled to the + * copies), and the runtime entry gains a JSDoc typedef per type-only export + * that names the declaration in the copy: + * + * / ** @template T @typedef {import("./main.scriptc-types").Box} Box * / + * + * Classes and values keep the JavaScript's own declarations. */ +import * as ts from "./ts7/syntax.js"; +import { tokenStartOfNode } from "./ts7/node-functions.js"; + +/** The suffix that replaces `.d.ts` in a copy's name. */ +export const NPM_STATIC_TYPES_SUFFIX = ".scriptc-types.d.ts"; + +/** A type-only declaration: its name, its type parameters' names and their + * JSDoc @template tag bodies. */ +export interface NpmStaticTypeDeclaration { + name: string; + params: readonly string[]; + templates: readonly string[]; +} + +/** What a declaration file declares and re-exports, by exported name. */ +export interface NpmStaticDeclarationExports { + /** Exported interfaces, type aliases and enums, with their parameters. */ + types: readonly NpmStaticTypeDeclaration[]; + /** Exported classes, functions, variables and namespaces: names the + * JavaScript declares itself, or that are not type-only. */ + values: readonly string[]; + /** `export { local as exported } from "specifier"` and local + * `export { a, b }` (specifier null). */ + named: readonly { exported: string; local: string; specifier: string | null }[]; + /** `export * from "specifier"`. */ + stars: readonly string[]; +} + +function isExported(node: ts.Node): boolean { + const modifiers = (node as { modifiers?: { nodes: readonly ts.Node[] } }).modifiers?.nodes ?? []; + return modifiers.some((m) => m.kind === ts.SyntaxKind.ExportKeyword); +} + +function templatesOf(sf: ts.SourceFile, params: readonly ts.TypeParameterDeclaration[]): string[] { + const text = (n: ts.Node): string => sf.text.slice(tokenStartOfNode(n), n.end); + return params.map((p) => { + const name = p.name.text; + const constraint = p.constraint === undefined ? "" : `{${text(p.constraint)}} `; + return p.defaultType === undefined + ? `${constraint}${name}` + : `${constraint}[${name}=${text(p.defaultType)}]`; + }); +} + +/** The exports of one declaration file. */ +export function npmStaticDeclarationExports(sf: ts.SourceFile): NpmStaticDeclarationExports { + const types: NpmStaticTypeDeclaration[] = []; + const values: string[] = []; + const named: { exported: string; local: string; specifier: string | null }[] = []; + const stars: string[] = []; + const localTypes = new Map(); + const localValues = new Set(); + for (const stmt of sf.statements.nodes) { + const exported = isExported(stmt); + if (ts.isInterfaceDeclaration(stmt) || ts.isTypeAliasDeclaration(stmt)) { + const params = stmt.typeParameters?.nodes ?? []; + const decl = { + name: stmt.name.text, + params: params.map((p) => p.name.text), + templates: templatesOf(sf, params), + }; + localTypes.set(decl.name, decl); + if (exported) types.push(decl); + } else if (ts.isEnumDeclaration(stmt)) { + const decl = { name: stmt.name.text, params: [], templates: [] }; + localTypes.set(decl.name, decl); + if (exported) types.push(decl); + } else if ( + ts.isClassDeclaration(stmt) || + ts.isFunctionDeclaration(stmt) || + ts.isModuleDeclaration(stmt) + ) { + const name = stmt.name !== undefined && ts.isIdentifier(stmt.name) ? stmt.name.text : null; + if (name !== null) { + localValues.add(name); + if (exported) values.push(name); + } + } else if (ts.isVariableStatement(stmt)) { + for (const d of stmt.declarationList.declarations.nodes) { + if (!ts.isIdentifier(d.name)) continue; + localValues.add(d.name.text); + if (exported) values.push(d.name.text); + } + } else if (ts.isExportDeclaration(stmt)) { + const specifier = + stmt.moduleSpecifier !== undefined && ts.isStringLiteral(stmt.moduleSpecifier) + ? stmt.moduleSpecifier.text + : null; + const clause = stmt.exportClause; + if (clause === undefined) { + if (specifier !== null) stars.push(specifier); + } else if (ts.isNamedExports(clause)) { + for (const e of clause.elements.nodes) { + const exportedName = e.name.text; + const local = (e.propertyName ?? e.name).text; + named.push({ exported: exportedName, local, specifier }); + } + } + } + } + // Local `export { a as b }` of the file's own declarations. + const resolvedNamed: typeof named = []; + for (const n of named) { + if (n.specifier !== null) { + resolvedNamed.push(n); + continue; + } + const local = localTypes.get(n.local); + if (local !== undefined) types.push({ ...local, name: n.exported }); + else if (localValues.has(n.local)) values.push(n.exported); + } + return { types, values, named: resolvedNamed, stars }; +} + +/** The relative module specifiers of a declaration file's imports, exports + * and `import("...")` types, with their spans. */ +function relativeSpecifiers(sf: ts.SourceFile): { start: number; end: number; text: string }[] { + const found: { start: number; end: number; text: string }[] = []; + const add = (literal: ts.Node | undefined): void => { + if (literal === undefined || !ts.isStringLiteral(literal)) return; + if (!literal.text.startsWith("./") && !literal.text.startsWith("../")) return; + found.push({ start: tokenStartOfNode(literal), end: literal.end, text: literal.text }); + }; + ts.walkPreorder(sf, (n) => { + if (ts.isImportDeclaration(n) || ts.isExportDeclaration(n)) add(n.moduleSpecifier); + else if (ts.isImportTypeNode(n) && ts.isLiteralTypeNode(n.argument)) add(n.argument.literal); + return undefined; + }); + return found; +} + +/** The relative specifiers a declaration file names. */ +export function npmStaticDeclarationSpecifiers(sf: ts.SourceFile): string[] { + return relativeSpecifiers(sf).map((s) => s.text); +} + +/** The declaration file's text with each relative specifier `rename` + * answers respelled (quoted with the original's quote). */ +export function npmStaticDeclarationCopy( + sf: ts.SourceFile, + rename: (specifier: string) => string | null, +): string { + const spans = relativeSpecifiers(sf).sort((a, b) => a.start - b.start); + let text = ""; + let at = 0; + for (const span of spans) { + const renamed = rename(span.text); + if (renamed === null) continue; + const quote = sf.text[span.start] ?? '"'; + text += sf.text.slice(at, span.start) + quote + renamed + quote; + at = span.end; + } + return text + sf.text.slice(at); +} + +/** The JSDoc typedefs that re-export `types` from the copy at `specifier`. */ +export function npmStaticTypedefBlock( + types: readonly NpmStaticTypeDeclaration[], + specifier: string, +): string { + const lines: string[] = []; + for (const t of types) { + const args = t.params.length === 0 ? "" : `<${t.params.join(", ")}>`; + lines.push("/**"); + for (const tag of t.templates) lines.push(` * @template ${tag}`); + lines.push(` * @typedef {import(${JSON.stringify(specifier)}).${t.name}${args}} ${t.name}`); + lines.push(" */"); + } + return lines.join("\n"); +} diff --git a/packages/compiler/src/frontend/npm-static.ts b/packages/compiler/src/frontend/npm-static.ts index 56edafc48..33ff54cfd 100644 --- a/packages/compiler/src/frontend/npm-static.ts +++ b/packages/compiler/src/frontend/npm-static.ts @@ -16,12 +16,14 @@ import { } from "./workspace-registry.js"; import { clearVirtualSources, + isVirtualSource, setVirtualSource, trackedExists, trackedReadFile, trackedRealpath, } from "./input-tracker.js"; import { npmBuiltinAliasOf } from "./builtin-modules.js"; +import { NPM_STATIC_TYPES_SUFFIX } from "./npm-static-type-exports.js"; let activePackages: ReadonlySet = new Set(); let declarationOverloads: ReadonlyMap = new Map(); @@ -53,10 +55,27 @@ export function npmStaticLexerVisibleNames(path: string): readonly string[] { return lexerNames.get(path.split("\\").join("/")) ?? []; } +/** Per runtime entry (forward slashes), the JSDoc typedefs that re-export + * its package's type-only declarations (npm-static-type-exports.ts). */ +let typeExportTypedefs = new Map(); + +/** Registers the copies of the opted-in packages' declaration files and the + * typedefs their runtime entries gain (after setNpmStaticPackages, which + * clears virtual sources). */ +export function setNpmStaticTypeExports( + copies: ReadonlyMap, + typedefs: ReadonlyMap, +): void { + for (const [path, text] of copies) setVirtualSource(path, text); + typeExportTypedefs = new Map(typedefs); + rewriteCache.clear(); +} + export function setNpmStaticPackages>(packages: T): void { // npm packages served as builtins (graceful-fs as fs) never compile // their JavaScript, even when named. activePackages = new Set([...packages].filter((name) => npmBuiltinAliasOf(name) === null)); + typeExportTypedefs = new Map(); declarationOverloads = new Map(); declarationProperties = new Map(); offenders.clear(); @@ -524,12 +543,21 @@ export function npmStaticFsShadow(services: FrontendServices): NpmStaticFsShadow } catch { rewritten = null; // unreadable/unparseable: fall through untouched } + // The runtime entry re-exports the type-only declarations of the + // package's .d.ts, after every respelling, so positions stay. + const typedefs = typeExportTypedefs.get(path.split("\\").join("/")); + if (typedefs !== undefined) { + const text = rewritten ?? trackedReadFile(path); + if (text !== null) rewritten = `${text}\n${typedefs}\n`; + } rewriteCache.set(path, rewritten); return rewritten ?? undefined; } return undefined; }, hideFile: (path) => { + // The copies of the package's declaration files the typedefs name. + if (path.endsWith(NPM_STATIC_TYPES_SUFFIX) && isVirtualSource(path)) return false; const target = shadowTargetOf(path); if (!target) return false; if (isBundledShimForwarder(path)) return false; diff --git a/packages/compiler/src/frontend/program.ts b/packages/compiler/src/frontend/program.ts index db43b7749..e398e59df 100644 --- a/packages/compiler/src/frontend/program.ts +++ b/packages/compiler/src/frontend/program.ts @@ -76,8 +76,10 @@ import { reportNpmStaticOffender, setNpmStaticDeclarationOverloads, setNpmStaticPackages, + setNpmStaticTypeExports, } from "./npm-static.js"; import { isPrunedNpmReexport, planNpmStaticReexports } from "./npm-static-prune.js"; +import { npmStaticTypeExportPlan } from "./npm-static-type-exports-host.js"; import { isNpmStaticSubclassArgument } from "./npm-static-subtyping.js"; import { npmStaticDeclarationReexports, @@ -1032,6 +1034,10 @@ export function loadProgram( } setNpmStaticPackages(npmStaticPackages); setNpmStaticDeclarationOverloads(declarationOverloads, declarationProperties); + // Types only the packages' .d.ts declares keep their declarations + // (npm-static-type-exports.ts). + const typeExports = npmStaticTypeExportPlan(services, entryPath, npmStaticPackages); + setNpmStaticTypeExports(typeExports.copies, typeExports.typedefs); // Workspace-package registrations reset per load (same discipline as the // npm-static set), then the opted-in names are probed UP FRONT: a // workspace-linked opt-in resolves to files whose realpaths carry no diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7001-package-declared-types/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7001-package-declared-types/main.ts.json new file mode 100644 index 000000000..c5aa8bb42 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7001-package-declared-types/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7001-package-declared-types/main.ts" + ], + "diags": [] +} diff --git a/tests/corpus/7001-package-declared-types/main.ts b/tests/corpus/7001-package-declared-types/main.ts new file mode 100644 index 000000000..c5194d33d --- /dev/null +++ b/tests/corpus/7001-package-declared-types/main.ts @@ -0,0 +1,19 @@ +// A package that compiles from its JavaScript, whose interfaces, type +// aliases and enums exist only in its .d.ts. A program that imports its +// values compiles the JavaScript, and the type-only names it imports keep +// the declarations TypeScript reads from the .d.ts. +import { Severity, collect, firstOf, label, type Issue, type Page, type Report } from "issue-list"; + +function report(text: string): Report { + const issues: Issue[] = []; + const count = collect(text, issues); + return { count, issues }; +} + +const result = report("a?b!c?"); +console.log(result.count, result.issues.length); +const first = result.issues[0]!; +console.log(label(first.severity), first.offset, first.severity === Severity.Warning); +const page: Page = { items: result.issues.slice(1), next: null }; +console.log(page.items.map((issue) => `${label(issue.severity)}@${issue.offset}`).join(","), page.next); +console.log(firstOf(page)?.offset); diff --git a/tests/corpus/7001-package-declared-types/node_modules/issue-list/lib/index.d.ts b/tests/corpus/7001-package-declared-types/node_modules/issue-list/lib/index.d.ts new file mode 100644 index 000000000..5ba9d04ac --- /dev/null +++ b/tests/corpus/7001-package-declared-types/node_modules/issue-list/lib/index.d.ts @@ -0,0 +1,17 @@ +import type { Page } from "./paging"; +export * from "./paging"; +export declare enum Severity { + Warning = 1, + Error = 2 +} +export interface Issue { + severity: Severity; + offset: number; +} +export type Report = { + count: number; + issues: Issue[]; +}; +export declare function collect(text: string, issues: Issue[]): number; +export declare function label(severity: Severity): string; +export declare function firstOf(page: Page): T | undefined; diff --git a/tests/corpus/7001-package-declared-types/node_modules/issue-list/lib/index.js b/tests/corpus/7001-package-declared-types/node_modules/issue-list/lib/index.js new file mode 100644 index 000000000..516d2fa30 --- /dev/null +++ b/tests/corpus/7001-package-declared-types/node_modules/issue-list/lib/index.js @@ -0,0 +1,24 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.Severity = void 0; +exports.collect = collect; +exports.label = label; +exports.firstOf = firstOf; +var Severity; +(function (Severity) { + Severity[Severity["Warning"] = 1] = "Warning"; + Severity[Severity["Error"] = 2] = "Error"; +})(Severity || (exports.Severity = Severity = {})); +function collect(text, issues) { + for (let i = 0; i < text.length; i++) { + if (text[i] === "?") issues.push({ severity: Severity.Warning, offset: i }); + else if (text[i] === "!") issues.push({ severity: Severity.Error, offset: i }); + } + return issues.length; +} +function label(severity) { + return severity === Severity.Warning ? "warning" : "error"; +} +function firstOf(page) { + return page.items[0]; +} diff --git a/tests/corpus/7001-package-declared-types/node_modules/issue-list/lib/paging.d.ts b/tests/corpus/7001-package-declared-types/node_modules/issue-list/lib/paging.d.ts new file mode 100644 index 000000000..c427d5ce0 --- /dev/null +++ b/tests/corpus/7001-package-declared-types/node_modules/issue-list/lib/paging.d.ts @@ -0,0 +1,4 @@ +export interface Page { + items: T[]; + next: string | null; +} diff --git a/tests/corpus/7001-package-declared-types/node_modules/issue-list/lib/paging.js b/tests/corpus/7001-package-declared-types/node_modules/issue-list/lib/paging.js new file mode 100644 index 000000000..c8ad2e549 --- /dev/null +++ b/tests/corpus/7001-package-declared-types/node_modules/issue-list/lib/paging.js @@ -0,0 +1,2 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); diff --git a/tests/corpus/7001-package-declared-types/node_modules/issue-list/package.json b/tests/corpus/7001-package-declared-types/node_modules/issue-list/package.json new file mode 100644 index 000000000..dcb8f20c3 --- /dev/null +++ b/tests/corpus/7001-package-declared-types/node_modules/issue-list/package.json @@ -0,0 +1 @@ +{ "name": "issue-list", "version": "1.0.0", "main": "./lib/index.js", "types": "./lib/index.d.ts" } diff --git a/tests/harness/corpus-costs/7001-package-declared-types/main.ts.json b/tests/harness/corpus-costs/7001-package-declared-types/main.ts.json new file mode 100644 index 000000000..d34ce5c69 --- /dev/null +++ b/tests/harness/corpus-costs/7001-package-declared-types/main.ts.json @@ -0,0 +1 @@ +{ "plain": 2683, "san": 1176 } From 462f93d50802826e771341ec81d101b43c45bc1d Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Wed, 21 Oct 2026 20:42:16 -0500 Subject: [PATCH 002/102] Type the enum entry of a package's declaration exports explicitly The compiler compiles itself natively, and an empty array in an object literal took number[] there, so the enum entry did not match the declaration record. The coverage snapshot of native-npm-imports now counts one dynamic-tier statement instead of three: the program's `const point: Vector` takes the interface from the package's .d.ts instead of any. --- packages/compiler/src/frontend/npm-static-type-exports.ts | 2 +- tests/harness/__snapshots__/coverage-npm-packages.txt | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/packages/compiler/src/frontend/npm-static-type-exports.ts b/packages/compiler/src/frontend/npm-static-type-exports.ts index 844afa590..bdea8eb03 100644 --- a/packages/compiler/src/frontend/npm-static-type-exports.ts +++ b/packages/compiler/src/frontend/npm-static-type-exports.ts @@ -80,7 +80,7 @@ export function npmStaticDeclarationExports(sf: ts.SourceFile): NpmStaticDeclara localTypes.set(decl.name, decl); if (exported) types.push(decl); } else if (ts.isEnumDeclaration(stmt)) { - const decl = { name: stmt.name.text, params: [], templates: [] }; + const decl: NpmStaticTypeDeclaration = { name: stmt.name.text, params: [], templates: [] }; localTypes.set(decl.name, decl); if (exported) types.push(decl); } else if ( diff --git a/tests/harness/__snapshots__/coverage-npm-packages.txt b/tests/harness/__snapshots__/coverage-npm-packages.txt index 475b10e45..6150b08c2 100644 --- a/tests/harness/__snapshots__/coverage-npm-packages.txt +++ b/tests/harness/__snapshots__/coverage-npm-packages.txt @@ -2,7 +2,7 @@ scriptc coverage tests/corpus/native-npm-imports/main.ts statements analyzed 14 compile statically 14 (100%) - in dynamic tier 3 (operate on values typed only at runtime; --explain-dynamic lists them) + in dynamic tier 1 (operate on values typed only at runtime; --explain-dynamic lists them) npm package compilation: mathkit static From 283a504fe02195a7d5337127fe35a40c2c8c8a34 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Wed, 21 Oct 2026 21:55:47 -0500 Subject: [PATCH 003/102] Support crypto.createDiffieHellman and getDiffieHellman crypto.createDiffieHellman, crypto.getDiffieHellman and crypto.createDiffieHellmanGroup return native DiffieHellman and DiffieHellmanGroup handles backed by mbedTLS bignums. generateKeys, computeSecret, getPrime, getGenerator, getPublicKey, getPrivateKey, setPublicKey, setPrivateKey and verifyError follow Node 24.22: - the modp1, modp2, modp5 and modp14 through modp18 groups, with the private key widths of Node's OpenSSL 3 path (200 to 400 bits for modp5 and up, [2, p - 2] for modp1 and modp2); - explicit primes and generators in every argument form and encoding, with keys of bits(p) - 2 bits, or below min(2^N, q) when the parameters equal an OpenSSL named group (RFC 3526, RFC 7919, RFC 5114); - generated safe primes with OpenSSL's congruences for the generator; - verifyError's DH_check bits, computed when it is first read; - Node's argument, generator, modulus, key range, state and encoding errors, including the OpenSSL errors' library and reason properties. Safe-prime generation sieves candidates with the odd primes below a bound that grows with the prime's length and tests them with Miller-Rabin rounds over a variable-time Montgomery exponentiation that only reads public values; key and secret exponentiations stay on mbedTLS's constant-time path. Primes longer than 8192 bits, property reads other than verifyError, property writes, Object.prototype methods, and calls whose output encoding is typed any or matches no @types/node overload are refused. The runtime unit scr_dh.c links, with the mbedTLS archive, only into programs that use DiffieHellman. wasm32-wasi builds refuse it. The ECDH unit's argument and encoding helpers move to scr_crypto_args.h, which both units include. --- .../limitations/builtin-apis/crypto.mdx | 6 + .../src/generated/node-v24-compatibility.json | 110 +- .../generated/node-v24-internal.json | 237 +++- internal/compatibility/src/generate.mjs | 16 +- internal/compatibility/static-support.json | 5 + .../ambient/scriptc-node-fallback.d.ts | 62 + .../src/backend/executable-features.ts | 1 + packages/compiler/src/backend/library-pack.ts | 1 + .../compiler/src/backend/llvm/lib-shared.ts | 2 + .../src/backend/native-link-info-core.ts | 3 + .../compiler/src/backend/native/contracts.ts | 4 + .../compiler/src/backend/native/executable.ts | 9 +- .../src/backend/runtime-pack-targets.test.ts | 1 + .../compiler/src/backend/runtime-pack.test.ts | 1 + .../src/backend/target-diagnostics.ts | 7 + packages/compiler/src/backend/warm-cache.ts | 1 + .../src/executable/executable-cache.test.ts | 1 + .../src/executable/executable-cache.ts | 2 + .../src/frontend/lowering/builtins/crypto.ts | 4 + .../src/frontend/lowering/builtins/dh.ts | 166 +++ .../src/frontend/lowering/builtins/ecdh.ts | 19 +- .../compiler/src/frontend/lowering/lowerer.ts | 13 +- .../src/frontend/lowering/surfaces.ts | 13 +- packages/compiler/src/frontend/type-mapper.ts | 17 + packages/compiler/src/index.ts | 1 + packages/compiler/src/ir/builtin-effects.ts | 3 + .../compiler/src/ir/builtin-signatures.ts | 7 + packages/compiler/src/ir/runtime-features.ts | 6 + packages/compiler/src/library/ir-policy.ts | 2 + packages/compiler/src/native/cli.ts | 1 + packages/compiler/src/native/prepare.ts | 1 + .../compiler/src/native/sanitizer.test.ts | 1 + packages/compiler/surface-manifest.json | 14 +- packages/compiler/test/cc-driver.test.ts | 5 + .../tests/corpus/6706-dh-groups.ts.json | 6 + .../corpus/6707-dh-explicit-params.ts.json | 6 + .../tests/corpus/6708-dh-errors.js.json | 6 + .../tests/corpus/6709-dh-generate.ts.json | 6 + .../tests/corpus/6710-dh-encodings.cjs.json | 6 + .../tests/corpus/6711-dh-handles.ts.json | 6 + .../tests/fixtures/node-types/dh.ts.json | 6 + .../runtime-pack-matrix.mjs | 2 +- .../runtime-darwin-arm64/scripts/build.mjs | 3 +- .../runtime-pack-matrix.mjs | 3 +- .../runtime-pack-common/scripts/build.mjs | 3 +- .../runtime-wasm32-wasi/scripts/build.mjs | 1 + packages/runtime/src/scr_crypto.h | 7 + packages/runtime/src/scr_crypto_args.h | 181 +++ packages/runtime/src/scr_dh.c | 1186 +++++++++++++++++ packages/runtime/src/scr_dh_groups.h | 557 ++++++++ packages/runtime/src/scr_dyn.h | 2 + packages/runtime/src/scr_ecdh.c | 192 +-- packages/runtime/test/dh.test.ts | 85 ++ packages/runtime/test/test_dh.c | 228 ++++ tests/corpus/6706-dh-groups.ts | 52 + tests/corpus/6707-dh-explicit-params.ts | 169 +++ tests/corpus/6708-dh-errors.js | 147 ++ tests/corpus/6709-dh-generate.ts | 47 + tests/corpus/6710-dh-encodings.cjs | 73 + tests/corpus/6711-dh-handles.ts | 56 + tests/fixtures/node-types/dh.ts | 22 + tests/fixtures/node-types/fenced.ts | 6 + .../__snapshots__/node-types-fenced.txt | 36 +- .../corpus-costs/6706-dh-groups.ts.json | 1 + .../6707-dh-explicit-params.ts.json | 1 + .../corpus-costs/6708-dh-errors.js.json | 1 + .../corpus-costs/6709-dh-generate.ts.json | 1 + .../corpus-costs/6710-dh-encodings.cjs.json | 1 + .../corpus-costs/6711-dh-handles.ts.json | 1 + tests/harness/errors.test.ts | 47 + tests/harness/project-config.test.ts | 14 + .../self-hosting-native-toolchain.test.ts | 1 + .../harness/self-hosting-runtime-pack.test.ts | 1 + 73 files changed, 3602 insertions(+), 309 deletions(-) create mode 100644 packages/compiler/src/frontend/lowering/builtins/dh.ts create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6706-dh-groups.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6707-dh-explicit-params.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6708-dh-errors.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6709-dh-generate.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6710-dh-encodings.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6711-dh-handles.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/dh.ts.json create mode 100644 packages/runtime/src/scr_crypto_args.h create mode 100644 packages/runtime/src/scr_dh.c create mode 100644 packages/runtime/src/scr_dh_groups.h create mode 100644 packages/runtime/test/dh.test.ts create mode 100644 packages/runtime/test/test_dh.c create mode 100644 tests/corpus/6706-dh-groups.ts create mode 100644 tests/corpus/6707-dh-explicit-params.ts create mode 100644 tests/corpus/6708-dh-errors.js create mode 100644 tests/corpus/6709-dh-generate.ts create mode 100644 tests/corpus/6710-dh-encodings.cjs create mode 100644 tests/corpus/6711-dh-handles.ts create mode 100644 tests/fixtures/node-types/dh.ts create mode 100644 tests/harness/corpus-costs/6706-dh-groups.ts.json create mode 100644 tests/harness/corpus-costs/6707-dh-explicit-params.ts.json create mode 100644 tests/harness/corpus-costs/6708-dh-errors.js.json create mode 100644 tests/harness/corpus-costs/6709-dh-generate.ts.json create mode 100644 tests/harness/corpus-costs/6710-dh-encodings.cjs.json create mode 100644 tests/harness/corpus-costs/6711-dh-handles.ts.json diff --git a/docs/content/limitations/builtin-apis/crypto.mdx b/docs/content/limitations/builtin-apis/crypto.mdx index 3c830c63d..b07cd6962 100644 --- a/docs/content/limitations/builtin-apis/crypto.mdx +++ b/docs/content/limitations/builtin-apis/crypto.mdx @@ -15,5 +15,11 @@ `createECDH` and `ECDH.convertKey` support prime192v1, secp224r1, prime256v1, secp384r1, secp521r1, secp192k1, secp224k1, secp256k1, brainpoolP256r1, brainpoolP384r1, and brainpoolP512r1, on native targets, through `generateKeys()`, `computeSecret()`, `getPublicKey()`, `getPrivateKey()`, `setPrivateKey()`, and `setPublicKey()`, in compressed, uncompressed, and hybrid forms; the other curves `crypto.getCurves()` lists and wasm32-wasi builds are refused. A call on an ECDH value whose arguments no @types/node overload accepts (`getPublicKey("HEX")`) is refused at compile time, as is `computeSecret(view, encoding)`: Node reads that encoding as the input encoding and answers a Buffer where @types/node declares a string. ECDH property reads and writes throw a coded SC2020 error. + `createDiffieHellman`, `getDiffieHellman`, and `createDiffieHellmanGroup` support the modp1, modp2, modp5, and modp14 through modp18 groups, explicit primes and generators, and generated safe primes, on native targets, through `generateKeys()`, `computeSecret()`, `getPrime()`, `getGenerator()`, `getPublicKey()`, `getPrivateKey()`, `setPublicKey()`, `setPrivateKey()`, and `verifyError`, with Node's private key lengths, DH_check results, and errors; wasm32-wasi builds are refused. + Primes longer than 8192 bits throw a coded SC2020 error; Node accepts primes up to 10000 bits for key generation and secrets. + 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 asymmetric KeyObjects, and the `DiffieHellman` and `DiffieHellmanGroup` constructors are not available. Other public-key operations remain unsupported. Native derivations finish before their deferred callbacks, so computation blocks the caller. diff --git a/docs/src/generated/node-v24-compatibility.json b/docs/src/generated/node-v24-compatibility.json index 66b0ba3dd..09bc7df29 100644 --- a/docs/src/generated/node-v24-compatibility.json +++ b/docs/src/generated/node-v24-compatibility.json @@ -11177,9 +11177,9 @@ "inherited": true }, "static": { - "status": "refused", - "detail": "Explicitly rejected by a named compiler diagnostic.", - "verification": "explicit-refusal" + "status": "partial", + "detail": "Supports the modp groups, explicit primes and generators, and generated safe primes up to 8192 bits with Node's argument, generator and modulus errors.", + "verification": "test-backed" } }, { @@ -11200,9 +11200,9 @@ "inherited": true }, "static": { - "status": "refused", - "detail": "Explicitly rejected by a named compiler diagnostic.", - "verification": "explicit-refusal" + "status": "partial", + "detail": "Supports the modp groups, explicit primes and generators, and generated safe primes up to 8192 bits with Node's argument, generator and modulus errors.", + "verification": "test-backed" } }, { @@ -11223,9 +11223,9 @@ "inherited": true }, "static": { - "status": "refused", - "detail": "Explicitly rejected by a named compiler diagnostic.", - "verification": "explicit-refusal" + "status": "partial", + "detail": "Supports the modp groups, explicit primes and generators, and generated safe primes up to 8192 bits with Node's argument, generator and modulus errors.", + "verification": "test-backed" } }, { @@ -11247,7 +11247,7 @@ }, "static": { "status": "partial", - "detail": "Implemented for the call shapes accepted by the compiler lowering.", + "detail": "Supports prime192v1, secp224r1, prime256v1, secp384r1, secp521r1, secp192k1, secp224k1, secp256k1, brainpoolP256r1, brainpoolP384r1 and brainpoolP512r1 with Node's curve, key, point, format and encoding errors; other curves Node knows are refused.", "verification": "test-backed" } }, @@ -11729,9 +11729,9 @@ "inherited": true }, "static": { - "status": "refused", - "detail": "Explicitly rejected by a named compiler diagnostic.", - "verification": "explicit-refusal" + "status": "partial", + "detail": "Supports the modp groups, explicit primes and generators, and generated safe primes up to 8192 bits with Node's argument, generator and modulus errors.", + "verification": "test-backed" } }, { @@ -12856,9 +12856,9 @@ "inherited": true }, "static": { - "status": "not-implemented", - "detail": "No static compiler lowering is registered for this API yet.", - "verification": "registry-gap" + "status": "partial", + "detail": "Matches Node's private key lengths, DH_check results, public key range checks, secret padding and errors; primes longer than 8192 bits, property writes and property reads other than verifyError are refused.", + "verification": "test-backed" } }, { @@ -12879,9 +12879,9 @@ "inherited": true }, "static": { - "status": "not-implemented", - "detail": "No static compiler lowering is registered for this API yet.", - "verification": "registry-gap" + "status": "partial", + "detail": "Matches Node's private key lengths, DH_check results, public key range checks, secret padding and errors; primes longer than 8192 bits, property writes and property reads other than verifyError are refused.", + "verification": "test-backed" } }, { @@ -12902,9 +12902,9 @@ "inherited": true }, "static": { - "status": "not-implemented", - "detail": "No static compiler lowering is registered for this API yet.", - "verification": "registry-gap" + "status": "partial", + "detail": "Matches Node's private key lengths, DH_check results, public key range checks, secret padding and errors; primes longer than 8192 bits, property writes and property reads other than verifyError are refused.", + "verification": "test-backed" } }, { @@ -12925,9 +12925,9 @@ "inherited": true }, "static": { - "status": "not-implemented", - "detail": "No static compiler lowering is registered for this API yet.", - "verification": "registry-gap" + "status": "partial", + "detail": "Matches Node's private key lengths, DH_check results, public key range checks, secret padding and errors; primes longer than 8192 bits, property writes and property reads other than verifyError are refused.", + "verification": "test-backed" } }, { @@ -12948,9 +12948,9 @@ "inherited": true }, "static": { - "status": "not-implemented", - "detail": "No static compiler lowering is registered for this API yet.", - "verification": "registry-gap" + "status": "partial", + "detail": "Matches Node's private key lengths, DH_check results, public key range checks, secret padding and errors; primes longer than 8192 bits, property writes and property reads other than verifyError are refused.", + "verification": "test-backed" } }, { @@ -12971,9 +12971,9 @@ "inherited": true }, "static": { - "status": "not-implemented", - "detail": "No static compiler lowering is registered for this API yet.", - "verification": "registry-gap" + "status": "partial", + "detail": "Matches Node's private key lengths, DH_check results, public key range checks, secret padding and errors; primes longer than 8192 bits, property writes and property reads other than verifyError are refused.", + "verification": "test-backed" } }, { @@ -12994,9 +12994,9 @@ "inherited": true }, "static": { - "status": "not-implemented", - "detail": "No static compiler lowering is registered for this API yet.", - "verification": "registry-gap" + "status": "partial", + "detail": "Matches Node's private key lengths, DH_check results, public key range checks, secret padding and errors; primes longer than 8192 bits, property writes and property reads other than verifyError are refused.", + "verification": "test-backed" } }, { @@ -13017,9 +13017,9 @@ "inherited": true }, "static": { - "status": "not-implemented", - "detail": "No static compiler lowering is registered for this API yet.", - "verification": "registry-gap" + "status": "partial", + "detail": "Matches Node's private key lengths, DH_check results, public key range checks, secret padding and errors; primes longer than 8192 bits, property writes and property reads other than verifyError are refused.", + "verification": "test-backed" } }, { @@ -13040,9 +13040,9 @@ "inherited": true }, "static": { - "status": "not-implemented", - "detail": "No static compiler lowering is registered for this API yet.", - "verification": "registry-gap" + "status": "partial", + "detail": "Matches Node's private key lengths, DH_check results, public key range checks, secret padding and errors; primes longer than 8192 bits, property writes and property reads other than verifyError are refused.", + "verification": "test-backed" } }, { @@ -13063,9 +13063,9 @@ "inherited": true }, "static": { - "status": "not-implemented", - "detail": "No static compiler lowering is registered for this API yet.", - "verification": "registry-gap" + "status": "partial", + "detail": "Matches Node's private key lengths, DH_check results, public key range checks, secret padding and errors; primes longer than 8192 bits, property writes and property reads other than verifyError are refused.", + "verification": "test-backed" } }, { @@ -13086,9 +13086,9 @@ "inherited": true }, "static": { - "status": "not-implemented", - "detail": "No static compiler lowering is registered for this API yet.", - "verification": "registry-gap" + "status": "partial", + "detail": "Matches Node's private key lengths, DH_check results, public key range checks, secret padding and errors; primes longer than 8192 bits, property writes and property reads other than verifyError are refused.", + "verification": "test-backed" } }, { @@ -18880,9 +18880,9 @@ "anchor": "err_crypto_invalid_keylen", "nodeStability": null, "static": { - "status": "not-implemented", - "detail": "No static compiler lowering is registered for this API yet.", - "verification": "registry-gap" + "status": "partial", + "detail": "Implemented by a dedicated static compiler/runtime path.", + "verification": "test-backed" } }, { @@ -19006,9 +19006,9 @@ "anchor": "err_crypto_invalid_state", "nodeStability": null, "static": { - "status": "not-implemented", - "detail": "No static compiler lowering is registered for this API yet.", - "verification": "registry-gap" + "status": "partial", + "detail": "Implemented by a dedicated static compiler/runtime path.", + "verification": "test-backed" } }, { @@ -19276,9 +19276,9 @@ "anchor": "err_crypto_unknown_dh_group", "nodeStability": null, "static": { - "status": "not-implemented", - "detail": "No static compiler lowering is registered for this API yet.", - "verification": "registry-gap" + "status": "partial", + "detail": "Implemented by a dedicated static compiler/runtime path.", + "verification": "test-backed" } }, { diff --git a/internal/compatibility/generated/node-v24-internal.json b/internal/compatibility/generated/node-v24-internal.json index c6a7a102c..7ebd09df8 100644 --- a/internal/compatibility/generated/node-v24-internal.json +++ b/internal/compatibility/generated/node-v24-internal.json @@ -19313,11 +19313,18 @@ "tests/corpus/6703-ecdh-private-keys.ts", "tests/corpus/6704-ecdh-set-public-key.cjs", "tests/corpus/6705-ecdh-handles.ts", + "tests/corpus/6706-dh-groups.ts", + "tests/corpus/6707-dh-explicit-params.ts", + "tests/corpus/6708-dh-errors.js", + "tests/corpus/6709-dh-generate.ts", + "tests/corpus/6710-dh-encodings.cjs", + "tests/corpus/6711-dh-handles.ts", "tests/corpus/node24-crypto-kdf-errors.ts", "tests/corpus/node24-crypto-kdf-options.ts", "tests/corpus/node24-crypto-kdf.ts", "tests/corpus/node24-crypto-sha2.ts", "tests/fixtures/node-types/cipher.ts", + "tests/fixtures/node-types/dh.ts", "tests/fixtures/node-types/ecdh.ts", "tests/harness/npm-static.test.ts" ] @@ -19759,8 +19766,17 @@ "inherited": true }, "static": { - "status": "refused", - "evidence": "surface-manifest:unsupported:node-builtin.crypto.createDiffieHellman" + "status": "partial", + "evidence": "surface-manifest:node-builtin.crypto.createDiffieHellman", + "tests": [ + "tests/corpus/6706-dh-groups.ts", + "tests/corpus/6707-dh-explicit-params.ts", + "tests/corpus/6708-dh-errors.js", + "tests/corpus/6709-dh-generate.ts", + "tests/corpus/6710-dh-encodings.cjs", + "tests/corpus/6711-dh-handles.ts", + "tests/fixtures/node-types/dh.ts" + ] }, "anchorSource": "exact" }, @@ -19782,8 +19798,17 @@ "inherited": true }, "static": { - "status": "refused", - "evidence": "surface-manifest:unsupported:node-builtin.crypto.createDiffieHellman" + "status": "partial", + "evidence": "surface-manifest:node-builtin.crypto.createDiffieHellman", + "tests": [ + "tests/corpus/6706-dh-groups.ts", + "tests/corpus/6707-dh-explicit-params.ts", + "tests/corpus/6708-dh-errors.js", + "tests/corpus/6709-dh-generate.ts", + "tests/corpus/6710-dh-encodings.cjs", + "tests/corpus/6711-dh-handles.ts", + "tests/fixtures/node-types/dh.ts" + ] }, "anchorSource": "exact" }, @@ -19805,8 +19830,17 @@ "inherited": true }, "static": { - "status": "refused", - "evidence": "surface-manifest:unsupported:node-builtin.crypto.createDiffieHellmanGroup" + "status": "partial", + "evidence": "surface-manifest:node-builtin.crypto.createDiffieHellmanGroup", + "tests": [ + "tests/corpus/6706-dh-groups.ts", + "tests/corpus/6707-dh-explicit-params.ts", + "tests/corpus/6708-dh-errors.js", + "tests/corpus/6709-dh-generate.ts", + "tests/corpus/6710-dh-encodings.cjs", + "tests/corpus/6711-dh-handles.ts", + "tests/fixtures/node-types/dh.ts" + ] }, "anchorSource": "exact" }, @@ -20387,8 +20421,17 @@ "inherited": true }, "static": { - "status": "refused", - "evidence": "surface-manifest:unsupported:node-builtin.crypto.getDiffieHellman" + "status": "partial", + "evidence": "surface-manifest:node-builtin.crypto.getDiffieHellman", + "tests": [ + "tests/corpus/6706-dh-groups.ts", + "tests/corpus/6707-dh-explicit-params.ts", + "tests/corpus/6708-dh-errors.js", + "tests/corpus/6709-dh-generate.ts", + "tests/corpus/6710-dh-encodings.cjs", + "tests/corpus/6711-dh-handles.ts", + "tests/fixtures/node-types/dh.ts" + ] }, "anchorSource": "exact" }, @@ -22153,8 +22196,17 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:crypto" + "status": "partial", + "evidence": "compiler-dedicated:DiffieHellman", + "tests": [ + "tests/corpus/6706-dh-groups.ts", + "tests/corpus/6707-dh-explicit-params.ts", + "tests/corpus/6708-dh-errors.js", + "tests/corpus/6709-dh-generate.ts", + "tests/corpus/6710-dh-encodings.cjs", + "tests/corpus/6711-dh-handles.ts", + "tests/fixtures/node-types/dh.ts" + ] }, "anchorSource": "exact" }, @@ -22176,8 +22228,17 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:crypto" + "status": "partial", + "evidence": "compiler-dedicated:diffieHellman.computeSecret", + "tests": [ + "tests/corpus/6706-dh-groups.ts", + "tests/corpus/6707-dh-explicit-params.ts", + "tests/corpus/6708-dh-errors.js", + "tests/corpus/6709-dh-generate.ts", + "tests/corpus/6710-dh-encodings.cjs", + "tests/corpus/6711-dh-handles.ts", + "tests/fixtures/node-types/dh.ts" + ] }, "anchorSource": "exact" }, @@ -22199,8 +22260,17 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:crypto" + "status": "partial", + "evidence": "compiler-dedicated:diffieHellman.generateKeys", + "tests": [ + "tests/corpus/6706-dh-groups.ts", + "tests/corpus/6707-dh-explicit-params.ts", + "tests/corpus/6708-dh-errors.js", + "tests/corpus/6709-dh-generate.ts", + "tests/corpus/6710-dh-encodings.cjs", + "tests/corpus/6711-dh-handles.ts", + "tests/fixtures/node-types/dh.ts" + ] }, "anchorSource": "exact" }, @@ -22222,8 +22292,17 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:crypto" + "status": "partial", + "evidence": "compiler-dedicated:diffieHellman.getGenerator", + "tests": [ + "tests/corpus/6706-dh-groups.ts", + "tests/corpus/6707-dh-explicit-params.ts", + "tests/corpus/6708-dh-errors.js", + "tests/corpus/6709-dh-generate.ts", + "tests/corpus/6710-dh-encodings.cjs", + "tests/corpus/6711-dh-handles.ts", + "tests/fixtures/node-types/dh.ts" + ] }, "anchorSource": "exact" }, @@ -22245,8 +22324,17 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:crypto" + "status": "partial", + "evidence": "compiler-dedicated:diffieHellman.getPrime", + "tests": [ + "tests/corpus/6706-dh-groups.ts", + "tests/corpus/6707-dh-explicit-params.ts", + "tests/corpus/6708-dh-errors.js", + "tests/corpus/6709-dh-generate.ts", + "tests/corpus/6710-dh-encodings.cjs", + "tests/corpus/6711-dh-handles.ts", + "tests/fixtures/node-types/dh.ts" + ] }, "anchorSource": "exact" }, @@ -22268,8 +22356,17 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:crypto" + "status": "partial", + "evidence": "compiler-dedicated:diffieHellman.getPrivateKey", + "tests": [ + "tests/corpus/6706-dh-groups.ts", + "tests/corpus/6707-dh-explicit-params.ts", + "tests/corpus/6708-dh-errors.js", + "tests/corpus/6709-dh-generate.ts", + "tests/corpus/6710-dh-encodings.cjs", + "tests/corpus/6711-dh-handles.ts", + "tests/fixtures/node-types/dh.ts" + ] }, "anchorSource": "exact" }, @@ -22291,8 +22388,17 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:crypto" + "status": "partial", + "evidence": "compiler-dedicated:diffieHellman.getPublicKey", + "tests": [ + "tests/corpus/6706-dh-groups.ts", + "tests/corpus/6707-dh-explicit-params.ts", + "tests/corpus/6708-dh-errors.js", + "tests/corpus/6709-dh-generate.ts", + "tests/corpus/6710-dh-encodings.cjs", + "tests/corpus/6711-dh-handles.ts", + "tests/fixtures/node-types/dh.ts" + ] }, "anchorSource": "exact" }, @@ -22314,8 +22420,17 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:crypto" + "status": "partial", + "evidence": "compiler-dedicated:diffieHellman.setPrivateKey", + "tests": [ + "tests/corpus/6706-dh-groups.ts", + "tests/corpus/6707-dh-explicit-params.ts", + "tests/corpus/6708-dh-errors.js", + "tests/corpus/6709-dh-generate.ts", + "tests/corpus/6710-dh-encodings.cjs", + "tests/corpus/6711-dh-handles.ts", + "tests/fixtures/node-types/dh.ts" + ] }, "anchorSource": "exact" }, @@ -22337,8 +22452,17 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:crypto" + "status": "partial", + "evidence": "compiler-dedicated:diffieHellman.setPublicKey", + "tests": [ + "tests/corpus/6706-dh-groups.ts", + "tests/corpus/6707-dh-explicit-params.ts", + "tests/corpus/6708-dh-errors.js", + "tests/corpus/6709-dh-generate.ts", + "tests/corpus/6710-dh-encodings.cjs", + "tests/corpus/6711-dh-handles.ts", + "tests/fixtures/node-types/dh.ts" + ] }, "anchorSource": "exact" }, @@ -22360,8 +22484,17 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:crypto" + "status": "partial", + "evidence": "compiler-dedicated:diffieHellman.verifyError", + "tests": [ + "tests/corpus/6706-dh-groups.ts", + "tests/corpus/6707-dh-explicit-params.ts", + "tests/corpus/6708-dh-errors.js", + "tests/corpus/6709-dh-generate.ts", + "tests/corpus/6710-dh-encodings.cjs", + "tests/corpus/6711-dh-handles.ts", + "tests/fixtures/node-types/dh.ts" + ] }, "anchorSource": "exact" }, @@ -22383,8 +22516,17 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:crypto" + "status": "partial", + "evidence": "compiler-dedicated:DiffieHellmanGroup", + "tests": [ + "tests/corpus/6706-dh-groups.ts", + "tests/corpus/6707-dh-explicit-params.ts", + "tests/corpus/6708-dh-errors.js", + "tests/corpus/6709-dh-generate.ts", + "tests/corpus/6710-dh-encodings.cjs", + "tests/corpus/6711-dh-handles.ts", + "tests/fixtures/node-types/dh.ts" + ] }, "anchorSource": "exact" }, @@ -27448,8 +27590,17 @@ "anchor": "dep0167-weak-diffiehellmangroup-instances-modp1-modp2-modp5", "nodeStability": null, "static": { - "status": "not-applicable", - "evidence": "compiler-chapter-policy:deprecations" + "status": "partial", + "evidence": "compiler-dedicated:DiffieHellmanGroup", + "tests": [ + "tests/corpus/6706-dh-groups.ts", + "tests/corpus/6707-dh-explicit-params.ts", + "tests/corpus/6708-dh-errors.js", + "tests/corpus/6709-dh-generate.ts", + "tests/corpus/6710-dh-encodings.cjs", + "tests/corpus/6711-dh-handles.ts", + "tests/fixtures/node-types/dh.ts" + ] }, "anchorSource": "exact" }, @@ -32191,6 +32342,7 @@ "evidence": "derived:descendants", "tests": [ "tests/corpus/6702-ecdh-errors.js", + "tests/corpus/6708-dh-errors.js", "tests/corpus/caught-system-error-fields.ts", "tests/corpus/error-stack-frames.ts", "tests/corpus/error-stack-limit.ts", @@ -33601,8 +33753,11 @@ "anchor": "err_crypto_invalid_keylen", "nodeStability": null, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:errors" + "status": "partial", + "evidence": "compiler-dedicated:ERR_CRYPTO_INVALID_KEYLEN", + "tests": [ + "tests/corpus/6708-dh-errors.js" + ] }, "anchorSource": "exact" }, @@ -33727,8 +33882,11 @@ "anchor": "err_crypto_invalid_state", "nodeStability": null, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:errors" + "status": "partial", + "evidence": "compiler-dedicated:ERR_CRYPTO_INVALID_STATE", + "tests": [ + "tests/corpus/6708-dh-errors.js" + ] }, "anchorSource": "exact" }, @@ -33997,8 +34155,11 @@ "anchor": "err_crypto_unknown_dh_group", "nodeStability": null, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:errors" + "status": "partial", + "evidence": "compiler-dedicated:ERR_CRYPTO_UNKNOWN_DH_GROUP", + "tests": [ + "tests/corpus/6708-dh-errors.js" + ] }, "anchorSource": "exact" }, diff --git a/internal/compatibility/src/generate.mjs b/internal/compatibility/src/generate.mjs index 9bd3927b8..536d4ce5e 100644 --- a/internal/compatibility/src/generate.mjs +++ b/internal/compatibility/src/generate.mjs @@ -582,17 +582,27 @@ function publicDetail(tier) { if (/^surface-manifest:node-builtin\.crypto\.create(?:Cipheriv|Decipheriv)$/.test(source)) { return "Supports aes-128/192/256 in cbc, ctr, and gcm modes and chacha20-poly1305 with Node's argument, IV, tag-length, and key-length errors; other OpenSSL ciphers and KeyObject keys are refused."; } + if (/^surface-manifest:node-builtin\.crypto\.createECDH$/.test(source)) { + return "Supports prime192v1, secp224r1, prime256v1, secp384r1, secp521r1, secp192k1, secp224k1, secp256k1, brainpoolP256r1, brainpoolP384r1 and brainpoolP512r1 with Node's curve, key, point, format and encoding errors; other curves Node knows are refused."; + } + if ( + /^surface-manifest:node-builtin\.crypto\.(?:createDiffieHellman|createDiffieHellmanGroup|getDiffieHellman)$/.test( + source, + ) + ) { + return "Supports the modp groups, explicit primes and generators, and generated safe primes up to 8192 bits with Node's argument, generator and modulus errors."; + } if (source.startsWith("surface-manifest:")) return "Implemented for the call shapes accepted by the compiler lowering."; if (/^compiler-dedicated:assert\.doesNot(?:Throw|Reject)$/.test(source)) { return "Supports callbacks or native promises with messages, Error classes, regular expressions, and validators accepting unknown values; object expectations and complete AssertionError metadata remain unsupported."; } - if (/^surface-manifest:node-builtin\.crypto\.createECDH$/.test(source)) { - return "Supports prime192v1, secp224r1, prime256v1, secp384r1, secp521r1, secp192k1, secp224k1, secp256k1, brainpoolP256r1, brainpoolP384r1 and brainpoolP512r1 with Node's curve, key, point, format and encoding errors; other curves Node knows are refused."; - } if (/^compiler-dedicated:(?:ECDH|ecdh\.)/.test(source)) { return "Matches Node's key formats, point encodings, private-key range checks, key-pair checks and errors on the supported curves; ECDH.convertKey is supported, and property reads and writes are refused."; } + if (/^compiler-dedicated:(?:DiffieHellman|diffieHellman\.)/.test(source)) { + return "Matches Node's private key lengths, DH_check results, public key range checks, secret padding and errors; primes longer than 8192 bits, property writes and property reads other than verifyError are refused."; + } if (/^compiler-dedicated:(?:Cipheriv|Decipheriv|cipher\.|decipher\.)/.test(source)) { return "Matches Node's update() output lengths, padding, authentication tags, string encodings, and state errors for the supported ciphers; the stream.Transform interface is refused."; } diff --git a/internal/compatibility/static-support.json b/internal/compatibility/static-support.json index 23c7a159b..b6cfed75d 100644 --- a/internal/compatibility/static-support.json +++ b/internal/compatibility/static-support.json @@ -44,6 +44,8 @@ "node-builtin.console": ["tests/corpus/console-imports.cjs", "tests/corpus/2440-console-inspect-args.ts", "tests/corpus/console-native-value.js", "tests/harness/npm-static.test.ts"], "node-builtin.crypto.createCipheriv": ["tests/corpus/5250-cipher-aes-gcm.ts", "tests/corpus/5251-cipher-aes-cbc.ts", "tests/corpus/5252-cipher-aes-ctr.ts", "tests/corpus/5253-cipher-chacha20-poly1305.ts", "tests/corpus/5254-cipher-errors.js", "tests/corpus/5255-cipher-encodings.cjs", "tests/corpus/5256-cipher-deprecation.cjs", "tests/corpus/5257-cipher-vectors.ts", "tests/corpus/5258-cipher-handles.js", "tests/corpus/5259-cipher-chunked.ts", "tests/fixtures/node-types/cipher.ts"], "node-builtin.crypto.createDecipheriv": ["tests/corpus/5250-cipher-aes-gcm.ts", "tests/corpus/5251-cipher-aes-cbc.ts", "tests/corpus/5252-cipher-aes-ctr.ts", "tests/corpus/5253-cipher-chacha20-poly1305.ts", "tests/corpus/5254-cipher-errors.js", "tests/corpus/5255-cipher-encodings.cjs", "tests/corpus/5256-cipher-deprecation.cjs", "tests/corpus/5257-cipher-vectors.ts", "tests/corpus/5258-cipher-handles.js", "tests/corpus/5259-cipher-chunked.ts", "tests/fixtures/node-types/cipher.ts"], + "node-builtin.crypto.createDiffieHellman": ["tests/corpus/6706-dh-groups.ts", "tests/corpus/6707-dh-explicit-params.ts", "tests/corpus/6708-dh-errors.js", "tests/corpus/6709-dh-generate.ts", "tests/corpus/6710-dh-encodings.cjs", "tests/corpus/6711-dh-handles.ts", "tests/fixtures/node-types/dh.ts"], + "node-builtin.crypto.createDiffieHellmanGroup": ["tests/corpus/6706-dh-groups.ts", "tests/corpus/6707-dh-explicit-params.ts", "tests/corpus/6708-dh-errors.js", "tests/corpus/6709-dh-generate.ts", "tests/corpus/6710-dh-encodings.cjs", "tests/corpus/6711-dh-handles.ts", "tests/fixtures/node-types/dh.ts"], "node-builtin.crypto.createECDH": ["tests/corpus/6700-ecdh-shared-secret.ts", "tests/corpus/6701-ecdh-formats.ts", "tests/corpus/6702-ecdh-errors.js", "tests/corpus/6703-ecdh-private-keys.ts", "tests/corpus/6704-ecdh-set-public-key.cjs", "tests/corpus/6705-ecdh-handles.ts", "tests/fixtures/node-types/ecdh.ts"], "node-builtin.crypto": ["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"], "node-builtin.dgram": ["tests/corpus/2597-dgram-send-ladders.cjs"], @@ -118,6 +120,7 @@ "node-builtin.os.version": ["tests/corpus/5140-os-host-facts.ts"], "node-builtin.os.constants": ["tests/corpus/5141-os-constants.ts"], "node-builtin.fs.constants": ["tests/corpus/6207-fs-constants-object.ts", "tests/corpus/6208-fs-constants-require.cjs"], + "node-builtin.crypto.getDiffieHellman": ["tests/corpus/6706-dh-groups.ts", "tests/corpus/6707-dh-explicit-params.ts", "tests/corpus/6708-dh-errors.js", "tests/corpus/6709-dh-generate.ts", "tests/corpus/6710-dh-encodings.cjs", "tests/corpus/6711-dh-handles.ts", "tests/fixtures/node-types/dh.ts"], "node-builtin.crypto.getRandomValues": ["tests/corpus/6204-crypto-get-random-values.ts", "tests/corpus/6205-crypto-get-random-values.js"], "node-builtin.url.parse": ["tests/corpus/5220-url-parse-warnings.ts", "tests/corpus/5221-url-parse-shapes.ts", "tests/corpus/5222-url-parse-hosts.ts", "tests/corpus/5223-url-parse-query.ts", "tests/corpus/5227-url-legacy-dependency/main.ts", "tests/corpus/5229-url-legacy-errors.cjs", "packages/runtime/test/url-legacy.test.ts", "tests/fixtures/node-types/url-legacy.ts"], "node-builtin.url.format": ["tests/corpus/5224-url-format-objects.ts", "tests/corpus/5225-url-format-whatwg.ts", "tests/corpus/5227-url-legacy-dependency/main.ts", "tests/corpus/5229-url-legacy-errors.cjs", "packages/runtime/test/url-legacy.test.ts", "tests/fixtures/node-types/url-legacy.ts"], @@ -414,6 +417,8 @@ { "symbols": ["assert", "assert.ok", "assert.equal", "assert.notEqual", "assert.strictEqual", "assert.notStrictEqual", "assert.deepStrictEqual", "assert.notDeepStrictEqual", "assert.fail", "assert.match", "assert.doesNotMatch", "assert.throws", "assert.rejects", "assert.ifError"], "status": "partial", "evidence": ["tests/corpus/1600-assert-passing.ts", "tests/corpus/1604-assert-deep-structures.ts", "tests/corpus/1609-assert-async.ts", "tests/corpus/1721-assert-throws-regex-class.ts", "tests/corpus/2936-static-loose-equality.ts", "tests/corpus/5515-assert-deep-strict-typed-messages.ts"] }, { "chapter": "crypto", "symbols": ["Cipheriv", "cipher.update", "cipher.final", "cipher.setAAD", "cipher.getAuthTag", "cipher.setAutoPadding", "Decipheriv", "decipher.update", "decipher.final", "decipher.setAAD", "decipher.setAuthTag", "decipher.setAutoPadding"], "status": "partial", "evidence": ["tests/corpus/5250-cipher-aes-gcm.ts", "tests/corpus/5251-cipher-aes-cbc.ts", "tests/corpus/5252-cipher-aes-ctr.ts", "tests/corpus/5253-cipher-chacha20-poly1305.ts", "tests/corpus/5254-cipher-errors.js", "tests/corpus/5255-cipher-encodings.cjs", "tests/corpus/5256-cipher-deprecation.cjs", "tests/corpus/5257-cipher-vectors.ts", "tests/corpus/5258-cipher-handles.js", "tests/corpus/5259-cipher-chunked.ts", "tests/fixtures/node-types/cipher.ts"] }, { "chapter": "crypto", "symbols": ["ECDH", "ecdh.computeSecret", "ecdh.generateKeys", "ecdh.getPrivateKey", "ecdh.getPublicKey", "ecdh.setPrivateKey", "ecdh.setPublicKey"], "status": "partial", "evidence": ["tests/corpus/6700-ecdh-shared-secret.ts", "tests/corpus/6701-ecdh-formats.ts", "tests/corpus/6702-ecdh-errors.js", "tests/corpus/6703-ecdh-private-keys.ts", "tests/corpus/6704-ecdh-set-public-key.cjs", "tests/corpus/6705-ecdh-handles.ts", "tests/fixtures/node-types/ecdh.ts"] }, + { "chapter": "crypto", "symbols": ["DiffieHellman", "DiffieHellmanGroup", "diffieHellman.computeSecret", "diffieHellman.generateKeys", "diffieHellman.getGenerator", "diffieHellman.getPrime", "diffieHellman.getPrivateKey", "diffieHellman.getPublicKey", "diffieHellman.setPrivateKey", "diffieHellman.setPublicKey", "diffieHellman.verifyError"], "status": "partial", "evidence": ["tests/corpus/6706-dh-groups.ts", "tests/corpus/6707-dh-explicit-params.ts", "tests/corpus/6708-dh-errors.js", "tests/corpus/6709-dh-generate.ts", "tests/corpus/6710-dh-encodings.cjs", "tests/corpus/6711-dh-handles.ts", "tests/fixtures/node-types/dh.ts"] }, + { "chapter": "errors", "symbols": ["ERR_CRYPTO_UNKNOWN_DH_GROUP", "ERR_CRYPTO_INVALID_KEYLEN", "ERR_CRYPTO_INVALID_STATE"], "status": "partial", "evidence": ["tests/corpus/6708-dh-errors.js"] }, { "chapter": "errors", "symbols": ["ERR_CRYPTO_ECDH_INVALID_FORMAT", "ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY"], "status": "partial", "evidence": ["tests/corpus/6702-ecdh-errors.js"] }, { "symbols": ["crypto.createHash", "Hash", "hash.update", "hash.digest", "hash.copy", "crypto.createHmac", "Hmac", "hmac.update", "hmac.digest", "crypto.hash", "crypto.pbkdf2", "crypto.pbkdf2Sync"], "status": "partial", "evidence": ["tests/corpus/5760-crypto-hash-stream.ts", "tests/corpus/5768-crypto-hash-unknown.ts", "tests/corpus/5769-crypto-hash-unknown.cjs", "tests/corpus/5761-crypto-hash-stream-states.ts", "tests/corpus/5762-crypto-hash-stream.cjs", "tests/corpus/2890-crypto-static-utility.ts", "tests/corpus/node24-crypto-sha2.ts", "tests/corpus/5435-crypto-hash-algorithms.ts", "tests/corpus/5436-crypto-hash-names.js", "tests/corpus/5437-crypto-hmac-algorithms.ts", "tests/corpus/5438-crypto-kdf-digests.ts", "tests/corpus/5440-crypto-hash-encodings.js", "tests/corpus/5441-crypto-hash-output-length.ts", "tests/harness/npm-static.test.ts"] }, { "symbols": ["crypto.randomFill", "crypto.randomFillSync", "crypto.randomUUID", "crypto.randomUUIDv7"], "status": "supported", "evidence": ["tests/corpus/5442-crypto-random-values.ts", "tests/corpus/5443-crypto-random-arguments.js", "tests/corpus/1358-crypto-random.ts"] }, diff --git a/packages/compiler/ambient/scriptc-node-fallback.d.ts b/packages/compiler/ambient/scriptc-node-fallback.d.ts index dbb3cd8fd..ab4b59eb8 100644 --- a/packages/compiler/ambient/scriptc-node-fallback.d.ts +++ b/packages/compiler/ambient/scriptc-node-fallback.d.ts @@ -2968,6 +2968,68 @@ declare module "crypto" { setPrivateKey(privateKey: string, encoding: BinaryToTextEncoding): void; } export function createECDH(curveName: string): ECDH; + export class DiffieHellman { + private constructor(); + generateKeys(): Buffer; + generateKeys(encoding: BinaryToTextEncoding): string; + computeSecret( + otherPublicKey: ArrayBufferView, + inputEncoding?: null, + outputEncoding?: null, + ): Buffer; + computeSecret( + otherPublicKey: string, + inputEncoding: BinaryToTextEncoding, + outputEncoding?: null, + ): Buffer; + computeSecret( + otherPublicKey: ArrayBufferView, + inputEncoding: null, + outputEncoding: BinaryToTextEncoding, + ): string; + computeSecret( + otherPublicKey: string, + inputEncoding: BinaryToTextEncoding, + outputEncoding: BinaryToTextEncoding, + ): string; + getPrime(): Buffer; + getPrime(encoding: BinaryToTextEncoding): string; + getGenerator(): Buffer; + getGenerator(encoding: BinaryToTextEncoding): string; + getPublicKey(): Buffer; + getPublicKey(encoding: BinaryToTextEncoding): string; + getPrivateKey(): Buffer; + getPrivateKey(encoding: BinaryToTextEncoding): string; + setPublicKey(publicKey: ArrayBufferView): void; + setPublicKey(publicKey: string, encoding: BufferEncoding): void; + setPrivateKey(privateKey: ArrayBufferView): void; + setPrivateKey(privateKey: string, encoding: BufferEncoding): void; + verifyError: number; + } + export type DiffieHellmanGroup = Omit; + export function createDiffieHellman(primeLength: number, generator?: number): DiffieHellman; + export function createDiffieHellman( + prime: ArrayBuffer | ArrayBufferView, + generator?: number | ArrayBuffer | ArrayBufferView, + ): DiffieHellman; + export function createDiffieHellman( + prime: ArrayBuffer | ArrayBufferView, + generator: string, + generatorEncoding: BinaryToTextEncoding, + ): DiffieHellman; + export function createDiffieHellman( + prime: string, + primeEncoding: BinaryToTextEncoding, + generator?: number | ArrayBuffer | ArrayBufferView, + ): DiffieHellman; + export function createDiffieHellman( + prime: string, + primeEncoding: BinaryToTextEncoding, + generator: string, + generatorEncoding: BinaryToTextEncoding, + ): DiffieHellman; + export function getDiffieHellman(groupName: string): DiffieHellmanGroup; + export function createDiffieHellmanGroup(name: string): DiffieHellmanGroup; export interface ScryptOptions { N?: number; r?: number; diff --git a/packages/compiler/src/backend/executable-features.ts b/packages/compiler/src/backend/executable-features.ts index f7cae8508..92b16965d 100644 --- a/packages/compiler/src/backend/executable-features.ts +++ b/packages/compiler/src/backend/executable-features.ts @@ -56,6 +56,7 @@ export function executableLinkFeatures(mod: IrModule): NativeLinkFeatures { tlsCa: features.tlsCa, cipher: features.cipher, ecdh: features.ecdh, + dh: features.dh, webcrypto: features.webcrypto, perfLoop: features.perfLoop, }; diff --git a/packages/compiler/src/backend/library-pack.ts b/packages/compiler/src/backend/library-pack.ts index 805198df1..a58203688 100644 --- a/packages/compiler/src/backend/library-pack.ts +++ b/packages/compiler/src/backend/library-pack.ts @@ -60,6 +60,7 @@ export async function compilePackedLibrary( tls: false, cipher: false, ecdh: false, + dh: false, webcrypto: false, perfLoop: false, tlsCa: false, diff --git a/packages/compiler/src/backend/llvm/lib-shared.ts b/packages/compiler/src/backend/llvm/lib-shared.ts index 8bb8bc3aa..0745b8806 100644 --- a/packages/compiler/src/backend/llvm/lib-shared.ts +++ b/packages/compiler/src/backend/llvm/lib-shared.ts @@ -577,6 +577,8 @@ export const LIB_FN_SYMS: Record = { "crypto.cipherNew": "scr_crypto_cipher_new", "crypto.ecdhNew": "scr_crypto_ecdh_new", "crypto.ecdhConvertKey": "scr_crypto_ecdh_convert_key", + "crypto.dhNew": "scr_crypto_dh_new", + "crypto.dhGroupNew": "scr_crypto_dh_group_new", "crypto.hmacNewStr": "scr_crypto_hmac_new_str", "crypto.hmacNewBytes": "scr_crypto_hmac_new_bytes", "crypto.hashUpdateStr": "scr_crypto_hash_update_str", diff --git a/packages/compiler/src/backend/native-link-info-core.ts b/packages/compiler/src/backend/native-link-info-core.ts index a476e1f7f..ad8b662ea 100644 --- a/packages/compiler/src/backend/native-link-info-core.ts +++ b/packages/compiler/src/backend/native-link-info-core.ts @@ -90,6 +90,9 @@ export interface NativeLinkFeatures { /** crypto.createECDH and ECDH.convertKey: scr_ecdh.c plus the mbedTLS * archive. */ ecdh: boolean; + /** crypto.createDiffieHellman, getDiffieHellman and + * createDiffieHellmanGroup: scr_dh.c plus the mbedTLS archive. */ + dh: boolean; /** perf_hooks event-loop metrics: scr_perf_loop.c. */ perfLoop: boolean; tlsCa: boolean; diff --git a/packages/compiler/src/backend/native/contracts.ts b/packages/compiler/src/backend/native/contracts.ts index 06a41c9b2..f268e67b2 100644 --- a/packages/compiler/src/backend/native/contracts.ts +++ b/packages/compiler/src/backend/native/contracts.ts @@ -249,6 +249,10 @@ export interface CcOptions { /** crypto.createECDH and ECDH.convertKey: compiles scr_ecdh.c and links * the mbedTLS archive (shared with tls). */ ecdh?: boolean; + /** crypto.createDiffieHellman, getDiffieHellman and + * createDiffieHellmanGroup: compiles scr_dh.c and links the mbedTLS + * archive (shared with tls). */ + dh?: boolean; /** crypto.subtle importKey/sign/verify/digest: compiles scr_webcrypto.c. */ webcrypto?: boolean; /** perf_hooks event-loop metrics: compiles scr_perf_loop.c. */ diff --git a/packages/compiler/src/backend/native/executable.ts b/packages/compiler/src/backend/native/executable.ts index a551ad600..8caf79a07 100644 --- a/packages/compiler/src/backend/native/executable.ts +++ b/packages/compiler/src/backend/native/executable.ts @@ -114,6 +114,7 @@ interface RuntimeUnitContext { tlsCa: boolean; cipher: boolean; ecdh: boolean; + dh: boolean; lreObjects: readonly string[]; zlibObjects: readonly string[]; tlsArchive: string | null; @@ -308,6 +309,7 @@ const RUNTIME_UNITS: readonly RuntimeUnit[] = [ ...(u.tls ? [u.rt(join(u.rtDir, "scr_tls.c"))] : []), ...(u.cipher ? [u.rt(join(u.rtDir, "scr_cipher.c"))] : []), ...(u.ecdh ? [u.rt(join(u.rtDir, "scr_ecdh.c"))] : []), + ...(u.dh ? [u.rt(join(u.rtDir, "scr_dh.c"))] : []), u.tlsArchive, // mbedTLS's win32 entropy poll is BCryptGenRandom (bcrypt.h). // The unconditional win32 libs above do not carry it. @@ -372,10 +374,12 @@ export async function compileCInternal( const http = (opts.http ?? false) || nativeFetch; const tls = (opts.tls ?? false) || nativeFetch; const tlsCa = (opts.tlsCa ?? false) || tls; - // Symmetric ciphers and ECDH link the same mbedTLS archive as TLS. + // Symmetric ciphers, ECDH and DiffieHellman link the same mbedTLS + // archive as TLS. const cipher = opts.cipher ?? false; const ecdh = opts.ecdh ?? false; - const mbedtls = tls || cipher || ecdh; + const dh = opts.dh ?? false; + const mbedtls = tls || cipher || ecdh || dh; const driver = resolveCc(); const darwinDebugSymbols = needsDarwinDebugSymbols( targetPlatform(driver), @@ -733,6 +737,7 @@ export async function compileCInternal( tlsCa, cipher, ecdh, + dh, lreObjects, zlibObjects, tlsArchive, diff --git a/packages/compiler/src/backend/runtime-pack-targets.test.ts b/packages/compiler/src/backend/runtime-pack-targets.test.ts index 19519e1f2..e2ba393a2 100644 --- a/packages/compiler/src/backend/runtime-pack-targets.test.ts +++ b/packages/compiler/src/backend/runtime-pack-targets.test.ts @@ -125,6 +125,7 @@ const features = { tlsCa: false, cipher: false, ecdh: false, + dh: false, webcrypto: false, perfLoop: false, }; diff --git a/packages/compiler/src/backend/runtime-pack.test.ts b/packages/compiler/src/backend/runtime-pack.test.ts index ee2301172..2a1c46f72 100644 --- a/packages/compiler/src/backend/runtime-pack.test.ts +++ b/packages/compiler/src/backend/runtime-pack.test.ts @@ -61,6 +61,7 @@ const BASE: NativeLinkFeatures = { tlsCa: false, cipher: false, ecdh: false, + dh: false, webcrypto: false, perfLoop: false, }; diff --git a/packages/compiler/src/backend/target-diagnostics.ts b/packages/compiler/src/backend/target-diagnostics.ts index b7049f6fe..e480beae4 100644 --- a/packages/compiler/src/backend/target-diagnostics.ts +++ b/packages/compiler/src/backend/target-diagnostics.ts @@ -215,6 +215,13 @@ export function moduleWasiUnavailableSurface( }; return false; } + if (node.fn === "crypto.dhNew" || node.fn === "crypto.dhGroupNew") { + found = { + surface: "DiffieHellman (the wasm32-wasi runtime does not include the mbedTLS library)", + loc, + }; + return false; + } if (node.fn === "os.networkInterfaces") { found = { surface: "network-interface enumeration (WASI Preview 1 has no interface API)", diff --git a/packages/compiler/src/backend/warm-cache.ts b/packages/compiler/src/backend/warm-cache.ts index 2d8ae6641..8870e21e7 100644 --- a/packages/compiler/src/backend/warm-cache.ts +++ b/packages/compiler/src/backend/warm-cache.ts @@ -67,6 +67,7 @@ export async function warmNativeCaches( tls: false, cipher: false, ecdh: false, + dh: false, webcrypto: false, perfLoop: false, tlsCa: false, diff --git a/packages/compiler/src/executable/executable-cache.test.ts b/packages/compiler/src/executable/executable-cache.test.ts index 94b136c90..3770a6bd6 100644 --- a/packages/compiler/src/executable/executable-cache.test.ts +++ b/packages/compiler/src/executable/executable-cache.test.ts @@ -65,6 +65,7 @@ const native: EarlyExecutableNativeFeatures = { tlsCa: false, cipher: false, ecdh: false, + dh: false, webcrypto: false, perfLoop: false, }; diff --git a/packages/compiler/src/executable/executable-cache.ts b/packages/compiler/src/executable/executable-cache.ts index 2312f5e85..6f96f8f75 100644 --- a/packages/compiler/src/executable/executable-cache.ts +++ b/packages/compiler/src/executable/executable-cache.ts @@ -96,6 +96,7 @@ export interface EarlyExecutableNativeFeatures { tls: boolean; cipher: boolean; ecdh: boolean; + dh: boolean; perfLoop: boolean; tlsCa: boolean; webcrypto: boolean; @@ -228,6 +229,7 @@ const BOOLEAN_NATIVE_KEYS = [ "tlsCa", "cipher", "ecdh", + "dh", "webcrypto", "perfLoop", ] as const satisfies readonly (keyof EarlyExecutableNativeFeatures)[]; diff --git a/packages/compiler/src/frontend/lowering/builtins/crypto.ts b/packages/compiler/src/frontend/lowering/builtins/crypto.ts index f4270dbe8..6ea83fce5 100644 --- a/packages/compiler/src/frontend/lowering/builtins/crypto.ts +++ b/packages/compiler/src/frontend/lowering/builtins/crypto.ts @@ -1,6 +1,7 @@ import { lowerBuiltinByteInput, errorFirstBytesCallback, errorFirstCallback } from "./arguments.js"; import { isKeyObjectValue } from "./key-object.js"; import { lowerCreateEcdh } from "./ecdh.js"; +import { lowerCreateDiffieHellman, lowerGetDiffieHellman } from "./dh.js"; import { boolLit, dynUndefinedExpr, nodeThrowExpr, varRef } from "../../../ir/build.js"; import * as ts from "../../ts7/adapter.js"; import { type Lowerer, own } from "../lowerer.js"; @@ -410,6 +411,9 @@ export function lowerCryptoModuleCall( }; } if (bi.member === "createECDH") return lowerCreateEcdh(lowerer, expr); + if (bi.member === "createDiffieHellman") return lowerCreateDiffieHellman(lowerer, expr); + if (bi.member === "getDiffieHellman" || bi.member === "createDiffieHellmanGroup") + return lowerGetDiffieHellman(lowerer, expr); if (bi.member === "createHmac") { if (args.length < 1 || args.length > 3 || args.some(ts.isSpreadElement)) { lowerer.noLowering( diff --git a/packages/compiler/src/frontend/lowering/builtins/dh.ts b/packages/compiler/src/frontend/lowering/builtins/dh.ts new file mode 100644 index 000000000..eea5a4813 --- /dev/null +++ b/packages/compiler/src/frontend/lowering/builtins/dh.ts @@ -0,0 +1,166 @@ +import * as ts from "../../ts7/adapter.js"; +import { nodeThrowExpr } from "../../../ir/build.js"; +import { type Lowerer } from "../lowerer.js"; +import { locOf } from "../../program.js"; +import { DYN, type IrExpr, type IrStmt } from "../../../ir/ir.js"; +import { v8CalleeText } from "./crypto.js"; +import { dynArguments, refuseUnmatchedOverload } from "./ecdh.js"; + +/* node:crypto's DiffieHellman and DiffieHellmanGroup are native + * checked-dynamic handles (scr_dh.c): both types map to dyn, their methods + * dispatch through the handle, and these helpers lower + * createDiffieHellman, getDiffieHellman, createDiffieHellmanGroup and the + * method calls. The runtime applies Node's argument checks, so the + * constructors take any arguments; method calls are refused when their + * argument types leave the Buffer or string result undetermined. */ + +/** Whether a checker type is node:crypto's DiffieHellman class or its + * DiffieHellmanGroup alias, or a union of them. */ +export function isDiffieHellmanType(lowerer: Lowerer, type: ts.Type): boolean { + if (type.isUnionType()) + return ts.constituentTypes(type).every((part) => isDiffieHellmanType(lowerer, part)); + const symbol = type.getAliasSymbol() ?? type.getSymbol(); + if (!symbol || !lowerer.isStdlibSymbol(symbol)) return false; + const name = ts.symbolName(symbol); + return name === "DiffieHellman" || name === "DiffieHellmanGroup"; +} + +function isDiffieHellmanGroupType(type: ts.Type): boolean { + if (type.isUnionType()) return ts.constituentTypes(type).some(isDiffieHellmanGroupType); + const symbol = type.getAliasSymbol(); + return !!symbol && ts.symbolName(symbol) === "DiffieHellmanGroup"; +} + +function newHandle( + lowerer: Lowerer, + call: ts.CallExpression, + fn: "crypto.dhNew" | "crypto.dhGroupNew", +): IrExpr { + const loc = locOf(call); + const stmts: IrStmt[] = []; + const values = dynArguments(lowerer, call, fn === "crypto.dhNew" ? 4 : 1, stmts, "%dhInput"); + return { + kind: "seqExpr", + stmts, + result: { kind: "libCall", fn, args: values, type: DYN, loc }, + type: DYN, + loc, + }; +} + +/** crypto.createDiffieHellman(sizeOrKey, keyEncoding, generator, + * generatorEncoding): a native DiffieHellman handle. */ +export function lowerCreateDiffieHellman(lowerer: Lowerer, call: ts.CallExpression): IrExpr { + return newHandle(lowerer, call, "crypto.dhNew"); +} + +/** crypto.getDiffieHellman(groupName) and createDiffieHellmanGroup(name): + * a native DiffieHellmanGroup handle. */ +export function lowerGetDiffieHellman(lowerer: Lowerer, call: ts.CallExpression): IrExpr { + return newHandle(lowerer, call, "crypto.dhGroupNew"); +} + +const DH_METHODS = new Set([ + "generateKeys", + "computeSecret", + "getPrime", + "getGenerator", + "getPublicKey", + "getPrivateKey", + "setPublicKey", + "setPrivateKey", +]); + +/** Object.prototype methods, which a DiffieHellman inherits. */ +const OBJECT_METHODS = new Set([ + "constructor", + "hasOwnProperty", + "isPrototypeOf", + "propertyIsEnumerable", + "toLocaleString", + "toString", + "valueOf", +]); + +/** The argument that selects each method's Buffer or string result: the + * output encoding. */ +const OUTPUT_ENCODING_ARG: Record = { + generateKeys: 0, + computeSecret: 2, + getPrime: 0, + getGenerator: 0, + getPublicKey: 0, + getPrivateKey: 0, +}; + +/** An output encoding typed any: the checker's chosen overload then types + * the result as a Buffer or a string that Node may not answer, so the call + * is refused rather than checked against that type at run time. */ +function refuseAnyOutputEncoding(lowerer: Lowerer, call: ts.CallExpression, name: string): void { + const index = OUTPUT_ENCODING_ARG[name]; + const arg = index === undefined ? undefined : call.arguments.nodes[index]; + if (!arg || (lowerer.typeOf(arg).flags & ts.TypeFlags.Any) === 0) return; + lowerer.noLowering( + `DiffieHellman.${name} with an output encoding typed any`, + arg, + "type the encoding as a BinaryToTextEncoding such as 'hex', or as null or undefined for a Buffer", + ); +} + +/** Calls on native DiffieHellman and DiffieHellmanGroup handles. Methods + * dispatch through the handle with checked-dynamic arguments. */ +export function lowerDiffieHellmanCall(lowerer: Lowerer, call: ts.CallExpression): IrExpr | null { + if (call.questionDotToken || !ts.isPropertyAccessExpression(call.expression)) return null; + const access = call.expression; + if (access.questionDotToken) return null; + const receiver = lowerer.typeOf(access.expression); + if (!isDiffieHellmanType(lowerer, receiver)) return null; + const name = access.name.text; + const loc = locOf(call); + const setter = name === "setPublicKey" || name === "setPrivateKey"; + if (!DH_METHODS.has(name) || (setter && isDiffieHellmanGroupType(receiver))) { + if (OBJECT_METHODS.has(name)) + lowerer.noLowering( + `DiffieHellman.${name}`, + call, + "generateKeys(), computeSecret(), getPrime(), getGenerator(), getPublicKey(), getPrivateKey(), " + + "setPublicKey(), setPrivateKey() and verifyError are supported", + ); + // Node reads the member as undefined (a DiffieHellmanGroup has no key + // setters) and throws a TypeError once the receiver and arguments are + // evaluated. + const evaluated = [access.expression, ...call.arguments.nodes].map((node): IrStmt => ({ + kind: "exprStmt", + expr: lowerer.lowerExpr(node), + loc, + })); + return { + kind: "seqExpr", + stmts: evaluated, + result: nodeThrowExpr(1, "", `${v8CalleeText(access)} is not a function`, DYN, loc), + type: DYN, + loc, + }; + } + if (call.arguments.nodes.some(ts.isSpreadElement)) + lowerer.noLowering(`DiffieHellman.${name} with spread arguments`, call); + refuseAnyOutputEncoding(lowerer, call, name); + refuseUnmatchedOverload(lowerer, call, `DiffieHellman.${name}`); + const invoke: IrExpr = { + kind: "dynInvoke", + recv: lowerer.lowerExprExpecting(access.expression, DYN), + method: name, + calleeName: v8CalleeText(access), + args: call.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(arg, DYN)), + type: DYN, + loc, + }; + // setPublicKey and setPrivateKey answer the receiver where @types/node + // declares void. Other results take the static representation of the + // declared overload the arguments match. + if (setter) return invoke; + const result = lowerer.irTypeOf(call); + return result.kind === "bytes" || result.kind === "string" + ? lowerer.coerceInto(call, invoke, result) + : invoke; +} diff --git a/packages/compiler/src/frontend/lowering/builtins/ecdh.ts b/packages/compiler/src/frontend/lowering/builtins/ecdh.ts index e08be56f4..6e937284c 100644 --- a/packages/compiler/src/frontend/lowering/builtins/ecdh.ts +++ b/packages/compiler/src/frontend/lowering/builtins/ecdh.ts @@ -28,15 +28,16 @@ export function isEcdhType(lowerer: Lowerer, type: ts.Type): boolean { return !!symbol && ts.symbolName(symbol) === "ECDH" && lowerer.isStdlibSymbol(symbol); } -/** The call's arguments as checked-dynamic values in hidden locals, the - * first `count` of them padded with undefined, so every argument is - * evaluated left to right before the runtime checks them. Surplus - * arguments are evaluated and dropped. */ -function dynArguments( +/** The call's arguments as checked-dynamic values in hidden locals named + * `local`, the first `count` of them padded with undefined, so every + * argument is evaluated left to right before the runtime checks them. + * Surplus arguments are evaluated and dropped. */ +export function dynArguments( lowerer: Lowerer, call: ts.CallExpression, count: number, stmts: IrStmt[], + local = "%ecdhInput", ): IrExpr[] { const args = call.arguments.nodes; const loc = locOf(call); @@ -45,7 +46,7 @@ function dynArguments( const input: IrExpr = args[i] ? lowerer.lowerExprExpecting(args[i]!, DYN) : dynUndefinedExpr(loc); - const saved = lowerer.declareHiddenLocal("%ecdhInput", DYN); + const saved = lowerer.declareHiddenLocal(local, DYN); stmts.push({ kind: "varDecl", localId: saved.id, init: input, loc }); values.push(varRef(saved.id, DYN, loc)); } @@ -137,7 +138,11 @@ function refuseViewKeyWithEncoding(lowerer: Lowerer, call: ts.CallExpression, na * not follow (getPublicKey("HEX") answers a string where the encoding-less * overload declares a Buffer), so the call is refused rather than checked * against that type at run time. Arguments typed any are accepted. */ -function refuseUnmatchedOverload(lowerer: Lowerer, call: ts.CallExpression, what: string): void { +export function refuseUnmatchedOverload( + lowerer: Lowerer, + call: ts.CallExpression, + what: string, +): void { const signature = lowerer.checker.getResolvedSignature(call); if (signature === undefined) return; const params = signature.getParameters(); diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts index 870e21b1f..8072e410d 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -58,6 +58,7 @@ import { encodeBase64 } from "../../wasm/base64.js"; import { resolveRequireRuntime } from "../runtime-resolve.js"; import { lowerKeyObjectCall } from "./builtins/key-object.js"; import { isEcdhType, lowerEcdhCall } from "./builtins/ecdh.js"; +import { isDiffieHellmanType, lowerDiffieHellmanCall } from "./builtins/dh.js"; import { fenceWebCryptoMember, lowerWebCryptoCall } from "./builtins/webcrypto.js"; import { hashStreamOf } from "./builtins/hash-stream.js"; import { lowerNetAddressCall, lowerNetAddressNew } from "./builtins/net-address.js"; @@ -3620,9 +3621,9 @@ export class Lowerer { * is `unknown` or `object` (also with `null` or `undefined`, or an array * of those), names checked protocol identity, is an owned runtime * handle (a Worker or MessagePort, a fetch Headers/Request/Response, or - * a node:crypto ECDH), or is a WeakMap/WeakSet (native weak collections - * live in checked-dynamic storage, as locals of those types do); `any` - * fields stay refused. */ + * a node:crypto ECDH, DiffieHellman or DiffieHellmanGroup), or is a + * WeakMap/WeakSet (native weak collections live in checked-dynamic + * storage, as locals of those types do); `any` fields stay refused. */ classFieldStoresDyn(type: ts.Type): boolean { return ( this.opaqueValueType(type) || @@ -3630,7 +3631,10 @@ export class Lowerer { isWorkerHandleType(type, this.typeCtx) || isFetchHandleType(type, this.typeCtx) || this.weakCollectionType(type) || - this.stdlibHandleType(type, (part) => isEcdhType(this, part)) + this.stdlibHandleType( + type, + (part) => isEcdhType(this, part) || isDiffieHellmanType(this, part), + ) ); } @@ -12737,6 +12741,7 @@ export class Lowerer { lowerWebCryptoCall(this, expr) ?? lowerKeyObjectCall(this, expr) ?? lowerEcdhCall(this, expr) ?? + lowerDiffieHellmanCall(this, expr) ?? lowerNetAddressCall(this, expr) ?? lowerFetchElementMethodCall(this, expr) ?? lowerDynamicImportCall(this, expr) ?? diff --git a/packages/compiler/src/frontend/lowering/surfaces.ts b/packages/compiler/src/frontend/lowering/surfaces.ts index c77938337..75bf42516 100644 --- a/packages/compiler/src/frontend/lowering/surfaces.ts +++ b/packages/compiler/src/frontend/lowering/surfaces.ts @@ -1574,6 +1574,12 @@ export const BUILTIN_MODULE_FNS: Record< // A checked-dynamic curve name; the result is a native ECDH handle // (lowerCreateEcdh). createECDH: { fn: "crypto.ecdhNew", params: [DYN], result: DYN }, + // Checked-dynamic arguments; the result is a native DiffieHellman or + // DiffieHellmanGroup handle (lowerCreateDiffieHellman and + // lowerGetDiffieHellman). + createDiffieHellman: { fn: "crypto.dhNew", params: [DYN, DYN, DYN, DYN], result: DYN }, + getDiffieHellman: { fn: "crypto.dhGroupNew", params: [DYN], result: DYN }, + createDiffieHellmanGroup: { fn: "crypto.dhGroupNew", params: [DYN], result: DYN }, }, zlib: { // The default-options convenience family is special-cased in @@ -3063,10 +3069,6 @@ export const BUILTIN_MODULE_FENCE_HINTS: Record< "createVerify", "sign", "verify", - "createDiffieHellman", - "createDiffieHellmanGroup", - "getDiffieHellman", - "diffieHellman", "publicEncrypt", "publicDecrypt", "privateEncrypt", @@ -3078,6 +3080,9 @@ export const BUILTIN_MODULE_FENCE_HINTS: Record< "can be small; the lowered crypto surface is hashing, randomness, secret KeyObjects, and the introspection statics", ]), ), + diffieHellman: + "crypto.diffieHellman takes asymmetric KeyObjects, which the static runtime does not have; " + + "the objects of createDiffieHellman, getDiffieHellman and createECDH compute shared secrets", ...Object.fromEntries( ["getCipherInfo"].map((m) => [ m, diff --git a/packages/compiler/src/frontend/type-mapper.ts b/packages/compiler/src/frontend/type-mapper.ts index a233f0186..189efaac0 100644 --- a/packages/compiler/src/frontend/type-mapper.ts +++ b/packages/compiler/src/frontend/type-mapper.ts @@ -2973,6 +2973,23 @@ function mapTypeInner(type: ts.Type, ctx: TypeMapperCtx): IrType | null { ) { return DYN; } + // node:crypto DiffieHellman values, and @types/node's DiffieHellmanGroup + // alias over them, are native handles carried by the checked-dynamic + // representation; lowerDiffieHellmanCall dispatches their methods. + { + const dhSym = widened.getAliasSymbol() ?? psym; + if ( + dhSym !== undefined && + (ts.symbolName(dhSym) === "DiffieHellman" || ts.symbolName(dhSym) === "DiffieHellmanGroup") && + dhSym.declarations.some( + (d) => + (ts.isClassDeclaration(d) || ts.isTypeAliasDeclaration(d)) && + ctx.isStdlibFile(ts.getSourceFileOfNode(d)), + ) + ) { + return DYN; + } + } // ReadonlyMap/ReadonlySet are the SAME runtime values as Map/Set — the // readonly-ness is a checker-only view (no mutating members on the // interface), so both map to the identical IR kinds and the read-side diff --git a/packages/compiler/src/index.ts b/packages/compiler/src/index.ts index 92ee6b75e..acd9f168a 100644 --- a/packages/compiler/src/index.ts +++ b/packages/compiler/src/index.ts @@ -620,6 +620,7 @@ async function compileExecutableNative( tlsCa: features.tlsCa, cipher: features.cipher, ecdh: features.ecdh, + dh: features.dh, webcrypto: features.webcrypto, perfLoop: features.perfLoop, ...(onArtifactReady === undefined ? {} : { onArtifactReady }), diff --git a/packages/compiler/src/ir/builtin-effects.ts b/packages/compiler/src/ir/builtin-effects.ts index ca8c52118..21215d28f 100644 --- a/packages/compiler/src/ir/builtin-effects.ts +++ b/packages/compiler/src/ir/builtin-effects.ts @@ -13,6 +13,9 @@ export const MAY_THROW_LIB_FNS: ReadonlySet = new Set([ // Node's curve, key, point, encoding and format errors. "crypto.ecdhNew", "crypto.ecdhConvertKey", + // Node's prime, generator, size, encoding and group-name errors. + "crypto.dhNew", + "crypto.dhGroupNew", // node:test's { timeout } and { concurrency } range checks. "test.register", "test.registerEmpty", diff --git a/packages/compiler/src/ir/builtin-signatures.ts b/packages/compiler/src/ir/builtin-signatures.ts index 771b53152..d362e13fa 100644 --- a/packages/compiler/src/ir/builtin-signatures.ts +++ b/packages/compiler/src/ir/builtin-signatures.ts @@ -2782,6 +2782,13 @@ export const LIB_FN_SIGS = defineLibFnSignatures({ /** ECDH.convertKey(key, curve, inputEncoding, outputEncoding, format): * the converted point as a Buffer or string. */ "crypto.ecdhConvertKey": { argTypes: [DYN, DYN, DYN, DYN, DYN], result: DYN }, + /** createDiffieHellman(sizeOrKey, keyEncoding, generator, + * generatorEncoding) over checked-dynamic arguments (scr_dh.c): a native + * DiffieHellman handle whose methods dispatch through dynInvoke. */ + "crypto.dhNew": { argTypes: [DYN, DYN, DYN, DYN], result: DYN }, + /** getDiffieHellman(groupName) and createDiffieHellmanGroup(name): a + * native DiffieHellmanGroup handle. */ + "crypto.dhGroupNew": { argTypes: [DYN], result: DYN }, "crypto.hmacNewStr": { argTypes: [STRING, STRING], result: CRYPTOHMAC_T }, "crypto.hmacNewBytes": { argTypes: [STRING, BYTES_U8], result: CRYPTOHMAC_T }, "crypto.hashUpdateStr": { argTypes: [CRYPTOHASH_T, STRING], result: CRYPTOHASH_T }, diff --git a/packages/compiler/src/ir/runtime-features.ts b/packages/compiler/src/ir/runtime-features.ts index 4142b6efe..eec599e94 100644 --- a/packages/compiler/src/ir/runtime-features.ts +++ b/packages/compiler/src/ir/runtime-features.ts @@ -744,6 +744,9 @@ const RUNTIME_FEATURE_RULES = { * process-warning unit, and unknown encodings and formats render through * the inspect unit. */ ecdh: rule({ fns: ["crypto.ecdhNew", "crypto.ecdhConvertKey"] }), + /** scr_dh.c over the mbedTLS archive; unknown encodings render through + * the inspect unit. */ + dh: rule({ fns: ["crypto.dhNew", "crypto.dhGroupNew"] }), emitter: rule({ initial: (mod) => mod.workers === true || (mod.classes ?? []).some((c) => c.name === RUNTIME_EMITTER_CLASS), @@ -789,6 +792,8 @@ const RUNTIME_FEATURE_RULES = { "crypto.cipherNew", "crypto.ecdhNew", "crypto.ecdhConvertKey", + "crypto.dhNew", + "crypto.dhGroupNew", ...BUILTIN_CLASS_LIB_FNS, ...UTIL_CALLABLE_LIB_FNS, ], @@ -910,6 +915,7 @@ function noRuntimeFeatures(): RuntimeFeatures { dynInvoke: false, dynTier: false, ecdh: false, + dh: false, emitter: false, eventTarget: false, eventsOnceSignal: false, diff --git a/packages/compiler/src/library/ir-policy.ts b/packages/compiler/src/library/ir-policy.ts index 51aeb6146..4fc912ea6 100644 --- a/packages/compiler/src/library/ir-policy.ts +++ b/packages/compiler/src/library/ir-policy.ts @@ -52,6 +52,8 @@ const LIB_MODE_REFUSED_PREFIXES: readonly [string, string][] = [ ["tls.", "the node:tls surface"], ["crypto.cipherNew", "crypto.createCipheriv and createDecipheriv"], ["crypto.ecdh", "crypto.createECDH and ECDH.convertKey"], + ["crypto.dhNew", "crypto.createDiffieHellman"], + ["crypto.dhGroupNew", "crypto.getDiffieHellman and createDiffieHellmanGroup"], ["webcrypto.", "WebCrypto (crypto.subtle)"], ["fs.watch", "fs.watch"], ["watcher.", "fs.watch"], diff --git a/packages/compiler/src/native/cli.ts b/packages/compiler/src/native/cli.ts index ed8d52293..8529678ff 100644 --- a/packages/compiler/src/native/cli.ts +++ b/packages/compiler/src/native/cli.ts @@ -110,6 +110,7 @@ async function main(): Promise { tls: false, cipher: false, ecdh: false, + dh: false, webcrypto: false, perfLoop: false, tlsCa: false, diff --git a/packages/compiler/src/native/prepare.ts b/packages/compiler/src/native/prepare.ts index b90760616..1a1263035 100644 --- a/packages/compiler/src/native/prepare.ts +++ b/packages/compiler/src/native/prepare.ts @@ -161,6 +161,7 @@ function validFeatures(value: unknown): value is NativeLinkFeatures { "tlsCa", "cipher", "ecdh", + "dh", "webcrypto", "perfLoop", ].every((name) => typeof features[name] === "boolean"); diff --git a/packages/compiler/src/native/sanitizer.test.ts b/packages/compiler/src/native/sanitizer.test.ts index e6beb24cc..ec9580ccc 100644 --- a/packages/compiler/src/native/sanitizer.test.ts +++ b/packages/compiler/src/native/sanitizer.test.ts @@ -120,6 +120,7 @@ test.skipIf(process.platform !== "linux" && process.platform !== "darwin")( tlsCa: false, cipher: false, ecdh: false, + dh: false, webcrypto: false, perfLoop: false, nativeFetch: false, diff --git a/packages/compiler/surface-manifest.json b/packages/compiler/surface-manifest.json index c05e994a8..6998a574e 100644 --- a/packages/compiler/surface-manifest.json +++ b/packages/compiler/surface-manifest.json @@ -496,17 +496,13 @@ "id": "node-builtin.crypto.createDiffieHellman", "kind": "node-builtin", "name": "crypto.createDiffieHellman", - "status": "unsupported", - "code": "SC2020", - "note": "asymmetric-key operations need a public-key stack (bignum, RSA/EC/EdDSA math) and public and private KeyObjects — neither exists in the static runtime, so no faithful lowering can be small; the lowered crypto surface is hashing, randomness, secret KeyObjects, and the introspection statics" + "status": "static" }, { "id": "node-builtin.crypto.createDiffieHellmanGroup", "kind": "node-builtin", "name": "crypto.createDiffieHellmanGroup", - "status": "unsupported", - "code": "SC2020", - "note": "asymmetric-key operations need a public-key stack (bignum, RSA/EC/EdDSA math) and public and private KeyObjects — neither exists in the static runtime, so no faithful lowering can be small; the lowered crypto surface is hashing, randomness, secret KeyObjects, and the introspection statics" + "status": "static" }, { "id": "node-builtin.crypto.createECDH", @@ -570,7 +566,7 @@ "name": "crypto.diffieHellman", "status": "unsupported", "code": "SC2020", - "note": "asymmetric-key operations need a public-key stack (bignum, RSA/EC/EdDSA math) and public and private KeyObjects — neither exists in the static runtime, so no faithful lowering can be small; the lowered crypto surface is hashing, randomness, secret KeyObjects, and the introspection statics" + "note": "crypto.diffieHellman takes asymmetric KeyObjects, which the static runtime does not have; the objects of createDiffieHellman, getDiffieHellman and createECDH compute shared secrets" }, { "id": "node-builtin.crypto.generateKey", @@ -612,9 +608,7 @@ "id": "node-builtin.crypto.getDiffieHellman", "kind": "node-builtin", "name": "crypto.getDiffieHellman", - "status": "unsupported", - "code": "SC2020", - "note": "asymmetric-key operations need a public-key stack (bignum, RSA/EC/EdDSA math) and public and private KeyObjects — neither exists in the static runtime, so no faithful lowering can be small; the lowered crypto surface is hashing, randomness, secret KeyObjects, and the introspection statics" + "status": "static" }, { "id": "node-builtin.crypto.getRandomValues", diff --git a/packages/compiler/test/cc-driver.test.ts b/packages/compiler/test/cc-driver.test.ts index b9f0403c6..5ddae6534 100644 --- a/packages/compiler/test/cc-driver.test.ts +++ b/packages/compiler/test/cc-driver.test.ts @@ -291,6 +291,11 @@ test.skipIf(!zigOnPath())( options: { ecdh: true, dynAsync: true, dynInvoke: true, inspect: true }, call: "scr_dyn_release(scr_crypto_ecdh_new(scr_dyn_undefined()))", }, + { + name: "dh", + options: { dh: true, dynInvoke: true, inspect: true }, + call: "scr_dyn_release(scr_crypto_dh_group_new(scr_dyn_undefined()))", + }, ]; try { await withCcEnv("zigcc", "x86_64-windows-gnu", async () => { diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6706-dh-groups.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6706-dh-groups.ts.json new file mode 100644 index 000000000..d8f5b48c3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6706-dh-groups.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6706-dh-groups.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6707-dh-explicit-params.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6707-dh-explicit-params.ts.json new file mode 100644 index 000000000..4cb3c882c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6707-dh-explicit-params.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6707-dh-explicit-params.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6708-dh-errors.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6708-dh-errors.js.json new file mode 100644 index 000000000..c252657a8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6708-dh-errors.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6708-dh-errors.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6709-dh-generate.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6709-dh-generate.ts.json new file mode 100644 index 000000000..5c50c8ec1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6709-dh-generate.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6709-dh-generate.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6710-dh-encodings.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6710-dh-encodings.cjs.json new file mode 100644 index 000000000..86abbb6ba --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6710-dh-encodings.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6710-dh-encodings.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6711-dh-handles.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6711-dh-handles.ts.json new file mode 100644 index 000000000..ae8daf9f1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6711-dh-handles.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6711-dh-handles.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/dh.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/dh.ts.json new file mode 100644 index 000000000..db078292a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/dh.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/node-types/dh.ts" + ], + "diags": [] +} diff --git a/packages/runtime-darwin-arm64/runtime-pack-matrix.mjs b/packages/runtime-darwin-arm64/runtime-pack-matrix.mjs index db72284f6..16fe348f2 100644 --- a/packages/runtime-darwin-arm64/runtime-pack-matrix.mjs +++ b/packages/runtime-darwin-arm64/runtime-pack-matrix.mjs @@ -43,7 +43,7 @@ export const RUNTIME_PACK_MATRIX = withLibraryRuntimeFlavors( { id: "quickjs", predicate: false }, { id: "libregexp", predicate: "regex" }, { id: "zlib", predicate: "zlibEffective" }, - { id: "mbedtls", predicate: any("tlsEffective", "cipher", "ecdh") }, + { id: "mbedtls", predicate: any("tlsEffective", "cipher", "ecdh", "dh") }, ], system_libraries: [{ name: "System", predicate: true }], }), diff --git a/packages/runtime-darwin-arm64/scripts/build.mjs b/packages/runtime-darwin-arm64/scripts/build.mjs index 856de4b86..e44ba4a33 100644 --- a/packages/runtime-darwin-arm64/scripts/build.mjs +++ b/packages/runtime-darwin-arm64/scripts/build.mjs @@ -172,7 +172,8 @@ async function build() { ...(unit.source === "scr_regex.c" ? ["-I", quickjs] : []), ...(unit.source === "scr_tls.c" || unit.source === "scr_cipher.c" || - unit.source === "scr_ecdh.c" + unit.source === "scr_ecdh.c" || + unit.source === "scr_dh.c" ? ["-I", join(mbedtls, "include")] : []), ...(unit.source === "scr_zlib.c" || unit.source === "scr_fetch.c" diff --git a/packages/runtime-pack-common/runtime-pack-matrix.mjs b/packages/runtime-pack-common/runtime-pack-matrix.mjs index 0f40218a1..ad426c953 100644 --- a/packages/runtime-pack-common/runtime-pack-matrix.mjs +++ b/packages/runtime-pack-common/runtime-pack-matrix.mjs @@ -149,6 +149,7 @@ export const OPTIONAL_RUNTIME_SOURCES = [ ["scr_tls.c", "tlsEffective"], ["scr_cipher.c", "cipher"], ["scr_ecdh.c", "ecdh"], + ["scr_dh.c", "dh"], ["scr_wasm.c", "wasm"], ["scr_webcrypto.c", "webcrypto"], ["scr_fetch.c", "nativeFetch"], @@ -212,7 +213,7 @@ export function createRuntimePackMatrix({ { id: "quickjs", predicate: false }, { id: "libregexp", predicate: "regex" }, { id: "zlib", predicate: "zlibEffective" }, - { id: "mbedtls", predicate: any("tlsEffective", "cipher", "ecdh") }, + { id: "mbedtls", predicate: any("tlsEffective", "cipher", "ecdh", "dh") }, ]; const matrix = withLibraryRuntimeFlavors( withWorkerRuntimeVariants({ diff --git a/packages/runtime-pack-common/scripts/build.mjs b/packages/runtime-pack-common/scripts/build.mjs index fa84e9c4d..b99bd8438 100644 --- a/packages/runtime-pack-common/scripts/build.mjs +++ b/packages/runtime-pack-common/scripts/build.mjs @@ -223,7 +223,8 @@ async function build() { ...(unit.source === "scr_regex.c" ? ["-I", quickjs] : []), ...(unit.source === "scr_tls.c" || unit.source === "scr_cipher.c" || - unit.source === "scr_ecdh.c" + unit.source === "scr_ecdh.c" || + unit.source === "scr_dh.c" ? ["-I", join(mbedtls, "include")] : []), ...(unit.source === "scr_zlib.c" || unit.source === "scr_fetch.c" diff --git a/packages/runtime-wasm32-wasi/scripts/build.mjs b/packages/runtime-wasm32-wasi/scripts/build.mjs index 2dd983973..818ebac94 100644 --- a/packages/runtime-wasm32-wasi/scripts/build.mjs +++ b/packages/runtime-wasm32-wasi/scripts/build.mjs @@ -22,6 +22,7 @@ process.env.SCRIPTC_RUNTIME_PACK_CONFIG = JSON.stringify({ "scr_tls.c", "scr_cipher.c", "scr_ecdh.c", + "scr_dh.c", "scr_wasm.c", "scr_fetch.c", ], diff --git a/packages/runtime/src/scr_crypto.h b/packages/runtime/src/scr_crypto.h index d12858abf..65a6245ef 100644 --- a/packages/runtime/src/scr_crypto.h +++ b/packages/runtime/src/scr_crypto.h @@ -94,6 +94,13 @@ ScrDyn *scr_crypto_cipher_new(bool decrypt, ScrDyn *cipher, ScrDyn *key, ScrDyn * or result, or NULL with Node's error pending. */ ScrDyn *scr_crypto_ecdh_new(ScrDyn *curve); ScrDyn *scr_crypto_ecdh_convert_key(ScrDyn *key, ScrDyn *curve, ScrDyn *in_enc, ScrDyn *out_enc, ScrDyn *format); +/* crypto.createDiffieHellman(sizeOrKey, keyEncoding, generator, + * generatorEncoding) and crypto.getDiffieHellman(groupName) over + * checked-dynamic arguments (scr_dh.c, linked with the vendored mbedTLS + * archive). +1 DiffieHellman or DiffieHellmanGroup handle, or NULL with + * Node's error pending. */ +ScrDyn *scr_crypto_dh_new(ScrDyn *size_or_key, ScrDyn *key_encoding, ScrDyn *generator, ScrDyn *generator_encoding); +ScrDyn *scr_crypto_dh_group_new(ScrDyn *name); ScrBytes *scr_crypto_pbkdf2(ScrBytes *password, ScrBytes *salt, double iterations, double keylen, ScrStr *digest); ScrBytes *scr_crypto_pbkdf2_job(ScrBytes *password, ScrBytes *salt, double iterations, diff --git a/packages/runtime/src/scr_crypto_args.h b/packages/runtime/src/scr_crypto_args.h new file mode 100644 index 000000000..b8bdcc1c9 --- /dev/null +++ b/packages/runtime/src/scr_crypto_args.h @@ -0,0 +1,181 @@ +/* Argument and result handling shared by the checked-dynamic node:crypto + * key-exchange handles (scr_ecdh.c and scr_dh.c), as Node 24's + * lib/internal/crypto/diffiehellman.js and lib/internal/crypto/util.js + * read keys and encodings: getArrayBufferOrView for key inputs and + * encode() for Buffer results. `subject` names the value in the coded + * SC2020 error for encodings that have no lowering ("An ECDH encoding or + * format"). All arguments are borrowed. */ +#ifndef SCR_CRYPTO_ARGS_H +#define SCR_CRYPTO_ARGS_H + +#include "scr_runtime.h" + +#include + +/* An object's toString the program defined, as an own or inherited + * function property. */ +static bool ca_custom_to_string(ScrDyn *value) { + if (value->kind != SCR_DYN_OBJ && value->kind != SCR_DYN_TYPED_REF) return false; + ScrDyn *member = scr_dyn_obj_read(value, "toString", 8); + bool custom = member && member->kind == SCR_DYN_FUNC; + scr_dyn_release(member); + return custom; +} + +/* Whether value is a class instance whose class defines toString. */ +static bool ca_class_to_string(const ScrDyn *value) { + ScrStr *name = scr_str_new("toString", 8); + bool method = scr_dyn_typed_ref_class_has(value, name); + scr_str_release(name); + return method; +} + +/* `prefix` and the value as util.format's %s renders it: strings and + * objects with a program-defined toString as String(value), numbers as + * util.inspect does, other values inspected at depth 0. Functions and + * class instances that define toString have no lowering. */ +static void ca_throw_formatted(const char *subject, const char *code, const char *prefix, const ScrDyn *value) { + ScrDyn *v = (ScrDyn *)value; + if (v->kind == SCR_DYN_FUNC || ca_class_to_string(v)) { + ScrJsonBuf b; + scr_jb_init(&b); + scr_jb_puts(&b, subject); + scr_jb_puts(&b, " that is a function or an instance of a class defining toString has no lowering; " + "pass the name as a string"); + ScrStr *message = scr_jb_finish(&b); + scr_throw_error_msg_code(SCR_ERR_ERROR, message->data, message->len, "SC2020"); + scr_str_release(message); + return; + } + ScrStr *text; + if (v->kind == SCR_DYN_STR || ca_custom_to_string(v)) text = scr_dyn_string_coerce_js(v); + else if (v->kind == SCR_DYN_NUM) text = scr_insp_f64(v->v.num); + else text = scr_insp_dyn_s(v, 0); + if (!text) return; + ScrJsonBuf b; + scr_jb_init(&b); + scr_jb_puts(&b, prefix); + scr_jb_put_str(&b, text); + scr_str_release(text); + ScrStr *message = scr_jb_finish(&b); + scr_throw_error_msg_code(SCR_ERR_TYPE, message->data, message->len, code); + scr_str_release(message); +} + +static bool ca_ascii_eq_ci(const char *a, size_t a_len, const char *b) { + size_t b_len = strlen(b); + if (a_len != b_len) return false; + for (size_t i = 0; i < a_len; i++) { + char x = a[i]; + if (x >= 'A' && x <= 'Z') x = (char)(x - 'A' + 'a'); + if (x != b[i]) return false; + } + return true; +} + +static bool ca_str_is(const ScrStr *text, const char *literal) { + size_t len = strlen(literal); + return text->len == len && memcmp(text->data, literal, len) == 0; +} + +/* Node's normalizeEncoding: the canonical name, or NULL. */ +static const char *ca_normalize_encoding(const ScrStr *name) { + static const struct { const char *from; const char *to; } map[] = { + {"utf8", "utf8"}, {"utf-8", "utf8"}, {"hex", "hex"}, + {"base64", "base64"}, {"base64url", "base64url"}, {"latin1", "latin1"}, + {"binary", "latin1"}, {"ascii", "ascii"}, {"utf16le", "utf16le"}, + {"utf-16le", "utf16le"}, {"ucs2", "utf16le"}, {"ucs-2", "utf16le"}, + }; + for (size_t i = 0; i < sizeof map / sizeof map[0]; i++) + if (ca_ascii_eq_ci(name->data, name->len, map[i].from)) return map[i].to; + return NULL; +} + +/* The value a typed-ref box holds when it is a string, view, ArrayBuffer + * or native handle (+1). Other values are retained as passed, so argument + * errors describe the original value. NULL after throwing. */ +static ScrDyn *ca_unbox(ScrDyn *value) { + if (value->kind != SCR_DYN_TYPED_REF) return scr_dyn_retain(value); + ScrDyn *view = scr_dyn_typed_ref_materialize(value); + if (!view) return NULL; + if (view->kind == SCR_DYN_STR || view->kind == SCR_DYN_BYTES || view->kind == SCR_DYN_HANDLE || + scr_buffer_storage_is(view)) + return view; + scr_dyn_release(view); + return scr_dyn_retain(value); +} + +/* Buffer.from(text, encoding) as toBuf calls it: an encoding that is not + * a non-empty string, or is 'buffer', reads as utf8. +1 or NULL after + * throwing. */ +static ScrBytes *ca_string_bytes(const char *subject, const ScrStr *text, const ScrDyn *encoding) { + const char *name = "utf8"; + if (encoding->kind == SCR_DYN_STR && encoding->v.str->len > 0 && !ca_str_is(encoding->v.str, "buffer")) { + name = ca_normalize_encoding(encoding->v.str); + if (!name) { + ca_throw_formatted(subject, "ERR_UNKNOWN_ENCODING", "Unknown encoding: ", encoding); + return NULL; + } + } + ScrStr *canonical = scr_str_new(name, strlen(name)); + ScrBytes *bytes = scr_bytes_from_str(text, canonical); + scr_str_release(canonical); + return bytes; +} + +/* getArrayBufferOrView(key, 'key', encoding): a string is Buffer.from(key, + * encoding) with 'buffer' read as utf8; views and ArrayBuffers are their + * bytes. +1 or NULL after throwing. */ +static ScrBytes *ca_key_bytes(const char *subject, const ScrDyn *key, const ScrDyn *encoding) { + if (key->kind == SCR_DYN_STR) return ca_string_bytes(subject, key->v.str, encoding); + if (key->kind == SCR_DYN_BYTES || scr_buffer_storage_is(key)) return scr_bytes_buffer_source(key); + scr_dyn_arg_type_fail("key", "of type string or an instance of ArrayBuffer, Buffer, TypedArray, or DataView", key); + return NULL; +} + +/* encode(buffer, encoding): the Buffer, or buffer.toString(encoding) for + * a truthy encoding other than 'buffer'. Consumes bytes. */ +static ScrDyn *ca_encode(const char *subject, ScrBytes *bytes, const ScrDyn *encoding) { + if (!scr_dyn_truthy(encoding) || (encoding->kind == SCR_DYN_STR && ca_str_is(encoding->v.str, "buffer"))) { + ScrDyn *result = scr_dyn_new_buffer(bytes); + scr_bytes_release(bytes); + return result; + } + /* toString answers "" for no bytes before it reads the encoding. */ + ScrStr *text = NULL; + if (bytes->len == 0) { + text = scr_str_new("", 0); + } else { + /* getEncodingOps reads `encoding + ''`. */ + ScrStr *name = encoding->kind == SCR_DYN_STR ? scr_str_retain(encoding->v.str) : NULL; + if (!name) { + if (encoding->kind == SCR_DYN_FUNC || ca_class_to_string(encoding)) { + ca_throw_formatted(subject, "ERR_UNKNOWN_ENCODING", "Unknown encoding: ", encoding); + scr_bytes_release(bytes); + return NULL; + } + name = scr_dyn_string_coerce_js(encoding); + if (!name) { + scr_bytes_release(bytes); + return NULL; + } + } + const char *canonical = ca_normalize_encoding(name); + scr_str_release(name); + if (!canonical) { + ca_throw_formatted(subject, "ERR_UNKNOWN_ENCODING", "Unknown encoding: ", encoding); + scr_bytes_release(bytes); + return NULL; + } + ScrStr *canonical_text = scr_str_new(canonical, strlen(canonical)); + text = scr_bytes_to_str(bytes, canonical_text); + scr_str_release(canonical_text); + } + scr_bytes_release(bytes); + if (!text) return NULL; + ScrDyn *result = scr_dyn_new_str(text); + scr_str_release(text); + return result; +} + +#endif diff --git a/packages/runtime/src/scr_dh.c b/packages/runtime/src/scr_dh.c new file mode 100644 index 000000000..c514b45ba --- /dev/null +++ b/packages/runtime/src/scr_dh.c @@ -0,0 +1,1186 @@ +/* node:crypto DiffieHellman over the vendored mbedTLS bignum arithmetic: + * crypto.createDiffieHellman, crypto.getDiffieHellman and + * crypto.createDiffieHellmanGroup. A DiffieHellman or DiffieHellmanGroup + * is a native dyn handle. Construction follows Node 24's + * lib/internal/crypto/diffiehellman.js argument handling and + * src/crypto/crypto_dh.cc; key generation, verifyError, the public key + * range check and computeSecret follow the OpenSSL 3 paths of + * deps/ncrypto and OpenSSL 3.5's DH provider: + * - a group draws modp5 through modp18 private keys of a fixed width + * (200 to 400 bits) and modp1 and modp2 keys in [2, p - 2], and its + * verifyError is 0; + * - createDiffieHellman parameters that equal an OpenSSL named group + * draw keys below min(2^N, q) for the group's key length N; other + * parameters draw keys of bits(p) - 2 bits, and key generation and + * computeSecret need a 512- to 10000-bit prime; + * - createDiffieHellman(primeLength, generator) generates a safe prime + * p ≡ 23 (mod 24) for the generator 2, p ≡ 59 (mod 60) for 5 and + * p ≡ 11 (mod 12) otherwise, as OpenSSL's dh_builtin_genparams does. + * Primes longer than mbedTLS's 8192-bit limit throw a coded SC2020 + * error. All arguments are borrowed. */ +#include "scr_runtime.h" + +#include +#include +#include +#include +#include + +#include "mbedtls/bignum.h" +#include "mbedtls/platform_util.h" + +#include "scr_crypto_args.h" +#include "scr_dh_groups.h" + +/* The value the SC2020 error for an unlowered encoding names. */ +#define SD_SUBJECT "A DiffieHellman encoding" + +/* DH_MIN_MODULUS_BITS and OPENSSL_DH_MAX_MODULUS_BITS. */ +#define SD_MIN_MODULUS_BITS 512 +#define SD_MAX_MODULUS_BITS 10000 + +/* DH_check result bits, as verifyError reports them. */ +enum { + SD_P_NOT_PRIME = 0x01, + SD_P_NOT_SAFE_PRIME = 0x02, + SD_NOT_SUITABLE_GENERATOR = 0x08, + SD_MODULUS_TOO_SMALL = 0x80, +}; + +/* A crypto.getDiffieHellman group. */ +typedef struct { + const char *name; + const unsigned char *p; + size_t p_len; + int private_bits; /* ncrypto's GetDhGroupPrivateBits; 0 draws keys in [2, p - 2] */ +} ScDhGroup; + +static const ScDhGroup sd_groups[] = { + {"modp1", scr_dh_modp1_p, sizeof scr_dh_modp1_p, 0}, + {"modp2", scr_dh_modp2_p, sizeof scr_dh_modp2_p, 0}, + {"modp5", scr_dh_modp5_p, sizeof scr_dh_modp5_p, 200}, + {"modp14", scr_dh_modp14_p, sizeof scr_dh_modp14_p, 225}, + {"modp15", scr_dh_modp15_p, sizeof scr_dh_modp15_p, 275}, + {"modp16", scr_dh_modp16_p, sizeof scr_dh_modp16_p, 325}, + {"modp17", scr_dh_modp17_p, sizeof scr_dh_modp17_p, 375}, + {"modp18", scr_dh_modp18_p, sizeof scr_dh_modp18_p, 400}, +}; + +/* An OpenSSL DH named group, which the DH provider recognizes in explicit + * p and g. A NULL q is (p - 1) / 2. */ +typedef struct { + const unsigned char *p; + size_t p_len; + const unsigned char *g; + size_t g_len; + const unsigned char *q; + size_t q_len; + int keylength; +} ScDhNamed; + +static const unsigned char sd_two[] = {2}; + +#define SD_SAFE(p, keylength) {p, sizeof p, sd_two, 1, NULL, 0, keylength} +#define SD_RFC5114(name, keylength) \ + {scr_dh_##name##_p, sizeof scr_dh_##name##_p, scr_dh_##name##_g, sizeof scr_dh_##name##_g, \ + scr_dh_##name##_q, sizeof scr_dh_##name##_q, keylength} + +static const ScDhNamed sd_named[] = { + SD_SAFE(scr_dh_ffdhe2048_p, 225), SD_SAFE(scr_dh_ffdhe3072_p, 275), SD_SAFE(scr_dh_ffdhe4096_p, 325), + SD_SAFE(scr_dh_ffdhe6144_p, 375), SD_SAFE(scr_dh_ffdhe8192_p, 400), SD_SAFE(scr_dh_modp5_p, 200), + SD_SAFE(scr_dh_modp14_p, 225), SD_SAFE(scr_dh_modp15_p, 275), SD_SAFE(scr_dh_modp16_p, 325), + SD_SAFE(scr_dh_modp17_p, 375), SD_SAFE(scr_dh_modp18_p, 400), SD_RFC5114(dh_1024_160, 160), + SD_RFC5114(dh_2048_224, 224), SD_RFC5114(dh_2048_256, 224), +}; + +typedef struct ScDh { + size_t rc; + const ScDhGroup *group; /* crypto.getDiffieHellman's group, or NULL */ + const ScDhNamed *named; /* the named group createDiffieHellman's parameters equal, or NULL */ + mbedtls_mpi p, g; + mbedtls_mpi pub; /* when has_pub */ + mbedtls_mpi priv; /* when has_priv */ + bool has_pub; + bool has_priv; + int verify_error; /* -1 until computed */ +} ScDh; + +static ScrDynHandleOps sd_ops; +static ScrDynHandleOps sd_group_ops; + +static void *sd_retain(void *h) { + ((ScDh *)h)->rc++; + return h; +} + +static void sd_release(void *h) { + ScDh *d = h; + if (--d->rc) return; + mbedtls_mpi_free(&d->p); + mbedtls_mpi_free(&d->g); + mbedtls_mpi_free(&d->pub); + mbedtls_mpi_free(&d->priv); + mbedtls_platform_zeroize(d, sizeof *d); + free(d); +} + +static int sd_random(void *state, unsigned char *out, size_t len) { + (void)state; + arc4random_buf(out, len); + return 0; +} + +/* ── errors ───────────────────────────────────────────────────────────── */ + +static void sd_throw(int kind, const char *code, const char *message) { + scr_throw_error_msg_code(kind, message, strlen(message), code); +} + +static void sd_operation_failed(const char *message) { + sd_throw(SCR_ERR_ERROR, "ERR_CRYPTO_OPERATION_FAILED", message); +} + +/* An OpenSSL DH error as ThrowCryptoError reports it: the formatted + * message plus own library, reason and code properties, in Node's key + * order. */ +static void sd_throw_openssl(const char *packed, const char *reason, const char *code) { + char message[96]; + snprintf(message, sizeof message, "error:%s:Diffie-Hellman routines::%s", packed, reason); + ScrStr *text = scr_str_new(message, strlen(message)); + ScrError *e = scr_error_new(SCR_ERR_ERROR, text); + scr_str_release(text); + ScrStr *library = scr_str_new("Diffie-Hellman routines", 23); + scr_error_set_prop(e, "library", 7, scr_dyn_new_str(library)); + scr_str_release(library); + ScrStr *reason_text = scr_str_new(reason, strlen(reason)); + scr_error_set_prop(e, "reason", 6, scr_dyn_new_str(reason_text)); + scr_str_release(reason_text); + scr_error_set_code(e, code); + ScrStr *code_text = scr_str_new(code, strlen(code)); + scr_error_set_prop(e, "code", 4, scr_dyn_new_str(code_text)); + scr_str_release(code_text); + scr_throw_obj(e, &scr_error_retain_v, &scr_error_release_v, scr_error_trace_arg()); +} + +static void sd_bad_generator(void) { + sd_throw_openssl("02800065", "bad generator", "ERR_OSSL_DH_BAD_GENERATOR"); +} + +static void sd_too_long(void) { + static const char message[] = "DiffieHellman primes longer than 8192 bits have no native implementation"; + scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020"); +} + +/* validateInt32(value, name). */ +static bool sd_validate_int32(const char *name, double value) { + bool integer = isfinite(value) && trunc(value) == value; + if (integer && value >= INT32_MIN && value <= INT32_MAX) return true; + char received[48]; + scr_num_received(value, received); + char text[192]; + int n = integer ? snprintf(text, sizeof text, + "The value of \"%s\" is out of range. It must be >= -2147483648 && <= 2147483647. " + "Received %s", + name, received) + : snprintf(text, sizeof text, + "The value of \"%s\" is out of range. It must be an integer. Received %s", name, + received); + scr_throw_error_msg_code(SCR_ERR_RANGE, text, n < 0 ? 0 : (size_t)n, "ERR_OUT_OF_RANGE"); + return false; +} + +/* ── arithmetic ───────────────────────────────────────────────────────── */ + +/* The exponent digit width that keeps every mbedtls_mpi_exp_mod exponent + * within its 8192-bit limit. */ +#define SD_DIGIT_BITS (MBEDTLS_MPI_MAX_BITS - 1) + +/* base^e mod p, as BN_mod_exp_mont_consttime computes it: false for an + * even modulus or one below 3. Exponents past 8192 bits are split into + * SD_DIGIT_BITS-bit digits. */ +static bool sd_exp(mbedtls_mpi *out, const mbedtls_mpi *base, const mbedtls_mpi *e, const mbedtls_mpi *p) { + if (mbedtls_mpi_cmp_int(p, 1) <= 0 || mbedtls_mpi_get_bit(p, 0) == 0) return false; + size_t ebits = mbedtls_mpi_bitlen(e); + if (ebits <= MBEDTLS_MPI_MAX_BITS) return mbedtls_mpi_exp_mod(out, base, e, p, NULL) == 0; + /* base^e = Π (base^(2^(k·w)))^digit_k for the w-bit digits of e. */ + mbedtls_mpi acc, power, digit, term, step; + mbedtls_mpi_init(&acc); + mbedtls_mpi_init(&power); + mbedtls_mpi_init(&digit); + mbedtls_mpi_init(&term); + mbedtls_mpi_init(&step); + int ret = 0; + MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&acc, 1)); + MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&power, base)); + MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&step, 1)); + MBEDTLS_MPI_CHK(mbedtls_mpi_shift_l(&step, SD_DIGIT_BITS)); + for (size_t offset = 0; offset < ebits; offset += SD_DIGIT_BITS) { + MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&digit, e)); + MBEDTLS_MPI_CHK(mbedtls_mpi_shift_r(&digit, offset)); + for (size_t bit = SD_DIGIT_BITS; bit < mbedtls_mpi_bitlen(&digit); bit++) + MBEDTLS_MPI_CHK(mbedtls_mpi_set_bit(&digit, bit, 0)); + MBEDTLS_MPI_CHK(mbedtls_mpi_exp_mod(&term, &power, &digit, p, NULL)); + MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&acc, &acc, &term)); + MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(&acc, &acc, p)); + if (offset + SD_DIGIT_BITS < ebits) MBEDTLS_MPI_CHK(mbedtls_mpi_exp_mod(&power, &power, &step, p, NULL)); + } + MBEDTLS_MPI_CHK(mbedtls_mpi_copy(out, &acc)); +cleanup: + mbedtls_mpi_free(&acc); + mbedtls_mpi_free(&power); + mbedtls_mpi_free(&digit); + mbedtls_mpi_free(&term); + mbedtls_mpi_free(&step); + return ret == 0; +} + +/* A uniformly random number of exactly `bits` bits (the top bit set), and + * odd when `odd`, as BN_priv_rand writes it. */ +static bool sd_random_bits(mbedtls_mpi *x, size_t bits, bool odd) { + size_t len = (bits + 7) / 8; + unsigned char *buf = malloc(len); + if (!buf) scr_trap("scriptc: out of memory\n"); + arc4random_buf(buf, len); + unsigned extra = (unsigned)(len * 8 - bits); + buf[0] &= (unsigned char)(0xff >> extra); + buf[0] |= (unsigned char)(0x80 >> extra); + if (odd) buf[len - 1] |= 1; + bool ok = mbedtls_mpi_read_binary(x, buf, len) == 0; + mbedtls_platform_zeroize(buf, len); + free(buf); + return ok; +} + +/* ── primes ───────────────────────────────────────────────────────────── */ + +/* The odd primes below 17864 (OpenSSL's first 2048 primes but 2), which + * trial division divides by. Consecutive primes are grouped into products + * below the half-limb bound mbedtls_mpi_mod_int divides correctly by, so + * one call reduces by several. */ +#define SD_SMALL_PRIMES 2047 +#define SD_SMALL_LIMIT 17864 +#define SD_PRODUCT_LIMIT ((uint64_t)1 << (sizeof(mbedtls_mpi_uint) * 4)) + +typedef struct { + uint16_t primes[SD_SMALL_PRIMES]; + uint64_t products[SD_SMALL_PRIMES]; + uint16_t starts[SD_SMALL_PRIMES + 1]; /* products[g] covers primes[starts[g]] to primes[starts[g + 1] - 1] */ + size_t groups; + uint32_t mods[SD_SMALL_PRIMES]; +} ScDhSmallPrimes; + +static ScDhSmallPrimes *sd_small_primes(void) { + ScDhSmallPrimes *t = calloc(1, sizeof *t); + unsigned char *composite = calloc(SD_SMALL_LIMIT, 1); + if (!t || !composite) scr_trap("scriptc: out of memory\n"); + size_t count = 0; + for (uint32_t n = 3; n < SD_SMALL_LIMIT && count < SD_SMALL_PRIMES; n += 2) { + if (composite[n]) continue; + t->primes[count++] = (uint16_t)n; + for (uint32_t m = n * n; m < SD_SMALL_LIMIT; m += 2 * n) composite[m] = 1; + } + free(composite); + uint64_t product = 1; + for (size_t i = 0; i < SD_SMALL_PRIMES; i++) { + if (product > SD_PRODUCT_LIMIT / t->primes[i]) { + t->products[t->groups++] = product; + t->starts[t->groups] = (uint16_t)i; + product = 1; + } + product *= t->primes[i]; + } + t->products[t->groups++] = product; + t->starts[t->groups] = SD_SMALL_PRIMES; + return t; +} + +/* x mod each small prime, into t->mods. */ +static bool sd_small_residues(ScDhSmallPrimes *t, const mbedtls_mpi *x) { + for (size_t g = 0; g < t->groups; g++) { + mbedtls_mpi_uint r; + if (mbedtls_mpi_mod_int(&r, x, (mbedtls_mpi_sint)t->products[g]) != 0) return false; + for (size_t i = t->starts[g]; i < t->starts[g + 1]; i++) t->mods[i] = (uint32_t)(r % t->primes[i]); + } + return true; +} + +#if defined(__SIZEOF_INT128__) +#define SD_MONT 1 +typedef unsigned __int128 sd_u128; + +/* Montgomery arithmetic modulo an odd n of k 64-bit limbs, little-endian, + * with R = 2^(64k), for the Miller-Rabin rounds. It runs in variable time + * and reads only public values. */ +typedef struct { + size_t k; + uint64_t mm; /* -n^-1 mod 2^64 */ + uint64_t *n; /* k limbs */ + uint64_t *rr; /* R^2 mod n, k limbs */ + uint64_t *acc; /* k limbs */ + uint64_t *table; /* 16·k limbs: base^i·R mod n */ + uint64_t *t; /* 2k + 1 limbs of products */ +} ScDhMont; + +static void sd_limbs_read(uint64_t *out, size_t k, const mbedtls_mpi *x, unsigned char *buf) { + if (mbedtls_mpi_write_binary_le(x, buf, 8 * k) != 0) scr_trap("scriptc: internal error: limb overflow\n"); + for (size_t i = 0; i < k; i++) { + uint64_t w = 0; + for (size_t b = 8; b-- > 0;) w = (w << 8) | buf[8 * i + b]; + out[i] = w; + } +} + +static bool sd_limbs_write(mbedtls_mpi *x, const uint64_t *in, size_t k, unsigned char *buf) { + for (size_t i = 0; i < k; i++) + for (size_t b = 0; b < 8; b++) buf[8 * i + b] = (unsigned char)(in[i] >> (8 * b)); + return mbedtls_mpi_read_binary_le(x, buf, 8 * k) == 0; +} + +static bool sd_mont_init(ScDhMont *m, const mbedtls_mpi *n) { + size_t k = (mbedtls_mpi_bitlen(n) + 63) / 64; + m->k = k; + m->n = calloc(21 * k + 1, sizeof(uint64_t)); + if (!m->n) scr_trap("scriptc: out of memory\n"); + m->rr = m->n + k; + m->acc = m->rr + k; + m->table = m->acc + k; + m->t = m->table + 16 * k; + unsigned char *buf = malloc(8 * k); + if (!buf) scr_trap("scriptc: out of memory\n"); + sd_limbs_read(m->n, k, n, buf); + /* Newton's iteration doubles the correct low bits of n^-1 from 3. */ + uint64_t inverse = m->n[0]; + for (int i = 0; i < 6; i++) inverse *= 2 - m->n[0] * inverse; + m->mm = (uint64_t)0 - inverse; + mbedtls_mpi rr; + mbedtls_mpi_init(&rr); + bool ok = mbedtls_mpi_lset(&rr, 1) == 0 && mbedtls_mpi_shift_l(&rr, 128 * k) == 0 && + mbedtls_mpi_mod_mpi(&rr, &rr, n) == 0; + if (ok) sd_limbs_read(m->rr, k, &rr, buf); + mbedtls_mpi_free(&rr); + free(buf); + return ok; +} + +static void sd_mont_free(ScDhMont *m) { + free(m->n); +} + +/* r = v mod n for v < 2n, given as k limbs and a top limb. */ +static void sd_mont_final(const ScDhMont *m, uint64_t *r, const uint64_t *v, uint64_t top) { + size_t k = m->k; + bool ge = top != 0; + if (!ge) { + ge = true; + for (size_t j = k; j-- > 0;) + if (v[j] != m->n[j]) { + ge = v[j] > m->n[j]; + break; + } + } + if (!ge) { + if (r != v) memmove(r, v, k * sizeof *r); + return; + } + uint64_t borrow = 0; + for (size_t j = 0; j < k; j++) { + sd_u128 d = (sd_u128)v[j] - m->n[j] - borrow; + r[j] = (uint64_t)d; + borrow = (uint64_t)(d >> 64) & 1; + } +} + +/* r = t·R^-1 mod n for the 2k-limb product in t. */ +static void sd_mont_redc(ScDhMont *m, uint64_t *r) { + size_t k = m->k; + uint64_t *t = m->t; + t[2 * k] = 0; + for (size_t i = 0; i < k; i++) { + uint64_t q = t[i] * m->mm; + uint64_t carry = 0; + for (size_t j = 0; j < k; j++) { + sd_u128 v = (sd_u128)q * m->n[j] + t[i + j] + carry; + t[i + j] = (uint64_t)v; + carry = (uint64_t)(v >> 64); + } + for (size_t j = i + k; carry != 0 && j <= 2 * k; j++) { + sd_u128 v = (sd_u128)t[j] + carry; + t[j] = (uint64_t)v; + carry = (uint64_t)(v >> 64); + } + } + sd_mont_final(m, r, t + k, t[2 * k]); +} + +static void sd_mont_mul(ScDhMont *m, uint64_t *r, const uint64_t *a, const uint64_t *b) { + size_t k = m->k; + uint64_t *t = m->t; + memset(t, 0, 2 * k * sizeof *t); + for (size_t i = 0; i < k; i++) { + uint64_t carry = 0; + for (size_t j = 0; j < k; j++) { + sd_u128 v = (sd_u128)a[i] * b[j] + t[i + j] + carry; + t[i + j] = (uint64_t)v; + carry = (uint64_t)(v >> 64); + } + t[i + k] = carry; + } + sd_mont_redc(m, r); +} + +/* r = a^2·R^-1 mod n: the cross products once, doubled, plus the squares. */ +static void sd_mont_sqr(ScDhMont *m, uint64_t *r, const uint64_t *a) { + size_t k = m->k; + uint64_t *t = m->t; + memset(t, 0, 2 * k * sizeof *t); + for (size_t i = 0; i < k; i++) { + uint64_t carry = 0; + for (size_t j = i + 1; j < k; j++) { + sd_u128 v = (sd_u128)a[i] * a[j] + t[i + j] + carry; + t[i + j] = (uint64_t)v; + carry = (uint64_t)(v >> 64); + } + t[i + k] = carry; + } + uint64_t shifted = 0; + for (size_t i = 0; i < 2 * k; i++) { + uint64_t v = t[i]; + t[i] = (v << 1) | shifted; + shifted = v >> 63; + } + uint64_t carry = 0; + for (size_t i = 0; i < k; i++) { + sd_u128 square = (sd_u128)a[i] * a[i]; + sd_u128 low = (sd_u128)t[2 * i] + (uint64_t)square + carry; + t[2 * i] = (uint64_t)low; + sd_u128 high = (sd_u128)t[2 * i + 1] + (uint64_t)(square >> 64) + (uint64_t)(low >> 64); + t[2 * i + 1] = (uint64_t)high; + carry = (uint64_t)(high >> 64); + } + sd_mont_redc(m, r); +} + +/* x = 2x mod n. */ +static void sd_mont_double(const ScDhMont *m, uint64_t *x) { + size_t k = m->k; + uint64_t top = x[k - 1] >> 63; + for (size_t j = k; j-- > 1;) x[j] = (x[j] << 1) | (x[j - 1] >> 63); + x[0] <<= 1; + sd_mont_final(m, x, x, top); +} + +/* out = base^e mod n, or 2^e mod n for a NULL base. A base of 2 doubles + * instead of multiplying; others use a 4-bit fixed window. */ +static bool sd_mont_pow(ScDhMont *m, mbedtls_mpi *out, const mbedtls_mpi *base, const mbedtls_mpi *e) { + size_t k = m->k; + unsigned char *buf = malloc(8 * k); + if (!buf) scr_trap("scriptc: out of memory\n"); + /* acc = R mod n, the Montgomery form of 1. */ + memset(m->t, 0, 2 * k * sizeof *m->t); + memcpy(m->t, m->rr, k * sizeof *m->t); + sd_mont_redc(m, m->acc); + size_t bits = mbedtls_mpi_bitlen(e); + if (!base) { + for (size_t i = bits; i-- > 0;) { + sd_mont_sqr(m, m->acc, m->acc); + if (mbedtls_mpi_get_bit(e, i)) sd_mont_double(m, m->acc); + } + } else { + memcpy(m->table, m->acc, k * sizeof *m->table); + sd_limbs_read(m->table + k, k, base, buf); + sd_mont_mul(m, m->table + k, m->table + k, m->rr); + for (size_t i = 2; i < 16; i++) sd_mont_mul(m, m->table + i * k, m->table + (i - 1) * k, m->table + k); + size_t windows = (bits + 3) / 4; + for (size_t w = windows; w-- > 0;) { + if (w + 1 < windows) + for (int s = 0; s < 4; s++) sd_mont_sqr(m, m->acc, m->acc); + unsigned digit = 0; + for (size_t b = 4; b-- > 0;) digit = (digit << 1) | (unsigned)mbedtls_mpi_get_bit(e, 4 * w + b); + if (digit) sd_mont_mul(m, m->acc, m->acc, m->table + digit * k); + } + } + /* Leave the Montgomery form. */ + memset(m->t, 0, 2 * k * sizeof *m->t); + memcpy(m->t, m->acc, k * sizeof *m->t); + sd_mont_redc(m, m->acc); + bool ok = sd_limbs_write(out, m->acc, k, buf); + free(buf); + return ok; +} +#else +#define SD_MONT 0 +#endif + +/* Miller-Rabin state for an odd n > 3: n - 1 = d·2^s. */ +typedef struct { + mbedtls_mpi n1, d, a, x; + size_t s; +#if SD_MONT + ScDhMont mont; +#else + mbedtls_mpi rr; /* the Montgomery constant mbedtls_mpi_exp_mod caches */ +#endif +} ScDhMillerRabin; + +static bool sd_mr_init(ScDhMillerRabin *m, const mbedtls_mpi *n) { + mbedtls_mpi_init(&m->n1); + mbedtls_mpi_init(&m->d); + mbedtls_mpi_init(&m->a); + mbedtls_mpi_init(&m->x); +#if SD_MONT + if (!sd_mont_init(&m->mont, n)) return false; +#else + mbedtls_mpi_init(&m->rr); +#endif + if (mbedtls_mpi_sub_int(&m->n1, n, 1) != 0 || mbedtls_mpi_copy(&m->d, &m->n1) != 0) return false; + m->s = mbedtls_mpi_lsb(&m->d); + return mbedtls_mpi_shift_r(&m->d, m->s) == 0; +} + +static void sd_mr_free(ScDhMillerRabin *m) { + mbedtls_mpi_free(&m->n1); + mbedtls_mpi_free(&m->d); + mbedtls_mpi_free(&m->a); + mbedtls_mpi_free(&m->x); +#if SD_MONT + sd_mont_free(&m->mont); +#else + mbedtls_mpi_free(&m->rr); +#endif +} + +/* x = a^e mod n, or 2^e mod n when base2. */ +static bool sd_mr_pow(ScDhMillerRabin *m, const mbedtls_mpi *n, const mbedtls_mpi *e, bool base2) { +#if SD_MONT + (void)n; + return sd_mont_pow(&m->mont, &m->x, base2 ? NULL : &m->a, e); +#else + if (base2 && mbedtls_mpi_lset(&m->a, 2) != 0) return false; + return mbedtls_mpi_exp_mod(&m->x, &m->a, e, n, &m->rr) == 0; +#endif +} + +/* One round with the base 2, or with a uniformly random base in + * [2, n - 2]: 1 when n is a strong probable prime to the base, 0 when it + * is composite, -1 when an operation fails. */ +static int sd_mr_round(ScDhMillerRabin *m, const mbedtls_mpi *n, bool base2) { + if (!base2 && mbedtls_mpi_random(&m->a, 2, &m->n1, sd_random, NULL) != 0) return -1; + if (!sd_mr_pow(m, n, &m->d, base2)) return -1; + if (mbedtls_mpi_cmp_int(&m->x, 1) == 0 || mbedtls_mpi_cmp_mpi(&m->x, &m->n1) == 0) return 1; + for (size_t i = 1; i < m->s; i++) { + if (mbedtls_mpi_mul_mpi(&m->x, &m->x, &m->x) != 0 || mbedtls_mpi_mod_mpi(&m->x, &m->x, n) != 0) return -1; + if (mbedtls_mpi_cmp_mpi(&m->x, &m->n1) == 0) return 1; + if (mbedtls_mpi_cmp_int(&m->x, 1) == 0) return 0; + } + return 0; +} + +/* 2^(n-1) ≡ 1 (mod n) for an odd n > 3. */ +static int sd_fermat2(const mbedtls_mpi *n) { + ScDhMillerRabin m; + int ret = sd_mr_init(&m, n) && sd_mr_pow(&m, n, &m.n1, true) ? mbedtls_mpi_cmp_int(&m.x, 1) == 0 : -1; + sd_mr_free(&m); + return ret; +} + +/* OpenSSL's Miller-Rabin round count: 64, or 128 past 2048 bits. */ +static int sd_mr_rounds(size_t bits) { + return bits > 2048 ? 128 : 64; +} + +/* BN_check_prime: trial division by the small primes, then Miller-Rabin + * rounds with random bases. */ +static bool sd_is_prime(ScDhSmallPrimes *t, const mbedtls_mpi *x) { + if (mbedtls_mpi_cmp_int(x, 2) < 0) return false; + if (mbedtls_mpi_get_bit(x, 0) == 0) return mbedtls_mpi_cmp_int(x, 2) == 0; + if (!sd_small_residues(t, x)) return false; + for (size_t i = 0; i < SD_SMALL_PRIMES; i++) + if (t->mods[i] == 0) return mbedtls_mpi_cmp_int(x, t->primes[i]) == 0; + /* No prime factor up to sqrt(x). */ + if (mbedtls_mpi_cmp_int(x, (mbedtls_mpi_sint)SD_SMALL_LIMIT * SD_SMALL_LIMIT) < 0) return true; + ScDhMillerRabin m; + bool prime = sd_mr_init(&m, x); + int rounds = sd_mr_rounds(mbedtls_mpi_bitlen(x)); + for (int i = 0; i < rounds && prime; i++) prime = sd_mr_round(&m, x, false) == 1; + sd_mr_free(&m); + return prime; +} + +/* DH_check for parameters without q, as ncrypto's CheckDhParams reports + * it. */ +static int sd_check_params(const mbedtls_mpi *p, const mbedtls_mpi *g) { + int codes = 0; + if (mbedtls_mpi_get_bit(p, 0) == 0) codes |= SD_P_NOT_PRIME; + if (mbedtls_mpi_cmp_int(g, 1) <= 0) codes |= SD_NOT_SUITABLE_GENERATOR; + if (mbedtls_mpi_bitlen(p) < SD_MIN_MODULUS_BITS) codes |= SD_MODULUS_TOO_SMALL; + mbedtls_mpi t; + mbedtls_mpi_init(&t); + if (mbedtls_mpi_sub_int(&t, p, 1) != 0) scr_trap("scriptc: out of memory\n"); + if (mbedtls_mpi_cmp_mpi(g, &t) >= 0) codes |= SD_NOT_SUITABLE_GENERATOR; + /* BN_check_prime(p), then BN_check_prime((p - 1) / 2) for a prime p. + * For an odd p > 3 whose (p - 1) / 2 is prime, p is prime exactly when + * 3 does not divide it and 2^(p-1) ≡ 1 (mod p) (Pocklington's + * criterion), so (p - 1) / 2 is tested first. */ + ScDhSmallPrimes *small = sd_small_primes(); + if (mbedtls_mpi_copy(&t, p) != 0 || mbedtls_mpi_shift_r(&t, 1) != 0) scr_trap("scriptc: out of memory\n"); + bool p_prime, q_prime; + if (mbedtls_mpi_get_bit(p, 0) == 0 || mbedtls_mpi_cmp_int(p, 3) <= 0) { + p_prime = sd_is_prime(small, p); + q_prime = p_prime && sd_is_prime(small, &t); + } else { + q_prime = sd_is_prime(small, &t); + mbedtls_mpi_uint r = 0; + if (!q_prime) p_prime = sd_is_prime(small, p); + else p_prime = mbedtls_mpi_mod_int(&r, p, 3) == 0 && r != 0 && sd_fermat2(p) == 1; + } + if (!p_prime) codes |= SD_P_NOT_PRIME; + else if (!q_prime) codes |= SD_P_NOT_SAFE_PRIME; + free(small); + mbedtls_mpi_free(&t); + return codes; +} + +/* The named group whose p and g equal these, as ossl_dh_cache_named_group + * finds it, or NULL. */ +static const ScDhNamed *sd_find_named(const mbedtls_mpi *p, const mbedtls_mpi *g) { + size_t p_len = mbedtls_mpi_size(p); + const ScDhNamed *found = NULL; + mbedtls_mpi x; + mbedtls_mpi_init(&x); + for (size_t i = 0; i < sizeof sd_named / sizeof sd_named[0] && !found; i++) { + const ScDhNamed *n = &sd_named[i]; + if (n->p_len != p_len) continue; + if (mbedtls_mpi_read_binary(&x, n->p, n->p_len) != 0 || mbedtls_mpi_cmp_mpi(&x, p) != 0) continue; + if (mbedtls_mpi_read_binary(&x, n->g, n->g_len) == 0 && mbedtls_mpi_cmp_mpi(&x, g) == 0) found = n; + } + mbedtls_mpi_free(&x); + return found; +} + +/* The safe-prime sieve: the odd primes below a bound that grows with the + * prime's length and do not divide the step `add`, each with add^-1 and a + * start's residue modulo it, and the marks of a window of candidates + * start + k·add. */ +#define SD_SIEVE_WINDOW 65536 + +static uint32_t sd_sieve_bound(size_t bits) { + /* mbedtls_mpi_mod_int divides correctly by values below 2^(limb bits / 2). */ + if (sizeof(mbedtls_mpi_uint) < 8) return 1u << 16; + return bits < 1024 ? 1u << 18 : bits < 2048 ? 1u << 22 : 1u << 24; +} + +typedef struct { + uint32_t *primes; + uint32_t *inverse; + uint32_t *residue; + size_t count; + unsigned char marks[SD_SIEVE_WINDOW]; +} ScDhSieve; + +/* a^-1 mod m for gcd(a, m) = 1. */ +static uint32_t sd_inverse(uint32_t a, uint32_t m) { + int64_t t = 0, next = 1; + int64_t r = m, rest = a; + while (rest != 0) { + int64_t quotient = r / rest; + int64_t t_next = t - quotient * next; + t = next; + next = t_next; + int64_t r_next = r - quotient * rest; + r = rest; + rest = r_next; + } + return (uint32_t)(t < 0 ? t + m : t); +} + +static ScDhSieve *sd_sieve_new(size_t bits, unsigned add) { + uint32_t bound = sd_sieve_bound(bits); + ScDhSieve *sv = calloc(1, sizeof *sv); + unsigned char *composite = calloc(bound / 2, 1); /* composite[i] for 2i + 1 */ + if (!sv || !composite) scr_trap("scriptc: out of memory\n"); + size_t count = 0; + for (uint32_t i = 1; i < bound / 2; i++) { + if (composite[i]) continue; + uint32_t n = 2 * i + 1; + for (uint64_t m = (uint64_t)n * n; m < bound; m += 2 * n) composite[m / 2] = 1; + if (add % n != 0) count++; + } + sv->primes = malloc(count * sizeof(uint32_t)); + sv->inverse = malloc(count * sizeof(uint32_t)); + sv->residue = malloc(count * sizeof(uint32_t)); + if (!sv->primes || !sv->inverse || !sv->residue) scr_trap("scriptc: out of memory\n"); + for (uint32_t i = 1; i < bound / 2; i++) { + uint32_t n = 2 * i + 1; + if (composite[i] || add % n == 0) continue; + sv->inverse[sv->count] = sd_inverse(add % n, n); + sv->primes[sv->count++] = n; + } + free(composite); + return sv; +} + +static void sd_sieve_free(ScDhSieve *sv) { + free(sv->primes); + free(sv->inverse); + free(sv->residue); + free(sv); +} + +/* Marks the candidates start + k·add of the window that a sieve prime + * divides, or whose (p - 1) / 2 it divides, then moves the residues to + * the next window. */ +static void sd_sieve_window(ScDhSieve *sv, unsigned add) { + memset(sv->marks, 0, sizeof sv->marks); + for (size_t i = 0; i < sv->count; i++) { + uint64_t r = sv->primes[i]; + uint64_t s = sv->residue[i]; + /* start + k·add ≡ t (mod r) for t = 0 and t = 1. */ + for (uint64_t t = 0; t < 2; t++) { + uint64_t k = (r + t - s) % r * sv->inverse[i] % r; + for (; k < SD_SIEVE_WINDOW; k += r) sv->marks[k] = 1; + } + sv->residue[i] = (uint32_t)((s + (uint64_t)SD_SIEVE_WINDOW * add) % r); + } +} + +/* A random safe prime of exactly `bits` bits with p ≡ rem (mod add), + * rem ≡ 2 (mod 3), as BN_generate_prime_ex2(p, bits, safe = 1, add, rem) + * draws one: a random start of `bits` bits moved to p ≡ rem (mod add), + * then candidates stepping by `add` past values that a sieve prime + * divides or that make (p - 1) / 2 divisible by one. A candidate is kept + * when p is a strong probable prime to the base 2 and q = (p - 1) / 2 + * passes OpenSSL's Miller-Rabin round count; a prime q then proves p prime + * (Pocklington's criterion with 2^(p-1) ≡ 1 and gcd(2^2 - 1, p) = 1). + * Candidates past `bits` bits take a new start. */ +static bool sd_generate_safe_prime(mbedtls_mpi *p, size_t bits, unsigned add, unsigned rem) { + ScDhSieve *sv = sd_sieve_new(bits, add); + int rounds = sd_mr_rounds(bits); + mbedtls_mpi start, q; + mbedtls_mpi_init(&start); + mbedtls_mpi_init(&q); + int ret = 0; + while (ret == 0) { + mbedtls_mpi_uint r; + if (!sd_random_bits(&start, bits, true) || mbedtls_mpi_mod_int(&r, &start, add) != 0 || + mbedtls_mpi_sub_int(&start, &start, (mbedtls_mpi_sint)r) != 0 || + mbedtls_mpi_add_int(&start, &start, rem) != 0 || + (mbedtls_mpi_bitlen(&start) < bits && mbedtls_mpi_add_int(&start, &start, add) != 0)) { + ret = -1; + break; + } + for (size_t i = 0; i < sv->count && ret == 0; i++) { + if (mbedtls_mpi_mod_int(&r, &start, sv->primes[i]) != 0) ret = -1; + sv->residue[i] = (uint32_t)r; + } + bool fits = true; + while (ret == 0 && fits) { + sd_sieve_window(sv, add); + for (uint32_t k = 0; k < SD_SIEVE_WINDOW && ret == 0 && fits; k++) { + if (sv->marks[k]) continue; + if (mbedtls_mpi_add_int(p, &start, (mbedtls_mpi_sint)k * add) != 0 || mbedtls_mpi_copy(&q, p) != 0 || + mbedtls_mpi_shift_r(&q, 1) != 0) { + ret = -1; + break; + } + fits = mbedtls_mpi_bitlen(p) == bits; + if (!fits) break; + ScDhMillerRabin mr; + ret = sd_mr_init(&mr, p) ? sd_mr_round(&mr, p, true) : -1; + sd_mr_free(&mr); + if (ret != 1) continue; + ret = sd_mr_init(&mr, &q) ? sd_mr_round(&mr, &q, true) : -1; + for (int i = 1; i < rounds && ret == 1; i++) ret = sd_mr_round(&mr, &q, false); + sd_mr_free(&mr); + } + if (ret == 0 && fits && mbedtls_mpi_add_int(&start, &start, (mbedtls_mpi_sint)SD_SIEVE_WINDOW * add) != 0) + ret = -1; + } + } + sd_sieve_free(sv); + mbedtls_mpi_free(&start); + mbedtls_mpi_free(&q); + return ret == 1; +} + +/* ── construction ─────────────────────────────────────────────────────── */ + +static ScDh *sd_alloc(void) { + ScDh *d = calloc(1, sizeof *d); + if (!d) scr_trap("scriptc: out of memory\n"); + d->rc = 1; + mbedtls_mpi_init(&d->p); + mbedtls_mpi_init(&d->g); + mbedtls_mpi_init(&d->pub); + mbedtls_mpi_init(&d->priv); + return d; +} + +static ScrDyn *sd_box(ScDh *d) { + ScrDynHandleTag tag = d->group ? SCR_DYNH_DIFFIE_HELLMAN_GROUP : SCR_DYNH_DIFFIE_HELLMAN; + scr_dyn_handle_install(tag, d->group ? &sd_group_ops : &sd_ops); + ScrDyn *result = scr_dyn_new_handle(d, tag); /* retains */ + sd_release(d); + return result; +} + +static bool sd_is_view(const ScrDyn *value) { + return value->kind == SCR_DYN_BYTES || scr_buffer_storage_is(value); +} + +/* Buffer.isEncoding(value). */ +static bool sd_is_encoding(const ScrDyn *value) { + return value->kind == SCR_DYN_STR && value->v.str->len > 0 && ca_normalize_encoding(value->v.str) != NULL; +} + +/* new DiffieHellman(primeLength, generator): generated parameters. */ +static ScrDyn *sd_generate(double bits, const ScrBytes *generator_bytes, double generator) { + if (bits < 2) { + sd_throw_openssl("0280007E", "modulus too small", "ERR_OSSL_DH_MODULUS_TOO_SMALL"); + return NULL; + } + if (generator_bytes) { + sd_throw(SCR_ERR_TYPE, "ERR_INVALID_ARG_TYPE", "Second argument must be an int32"); + return NULL; + } + if (generator < 2) { + sd_bad_generator(); + return NULL; + } + if (bits < SD_MIN_MODULUS_BITS || bits > SD_MAX_MODULUS_BITS) { + sd_throw(SCR_ERR_TYPE, "ERR_INVALID_ARG_VALUE", "Invalid DH parameters"); + return NULL; + } + if (bits > MBEDTLS_MPI_MAX_BITS) { + sd_too_long(); + return NULL; + } + unsigned add = 12; + if (generator == 2) add = 24; + else if (generator == 5) add = 60; + ScDh *d = sd_alloc(); + if (!sd_generate_safe_prime(&d->p, (size_t)bits, add, add - 1) || mbedtls_mpi_lset(&d->g, (mbedtls_mpi_sint)generator) != 0) { + sd_release(d); + sd_throw(SCR_ERR_TYPE, "ERR_INVALID_ARG_VALUE", "Invalid DH parameters"); + return NULL; + } + /* A safe prime of at least 512 bits with a generator below p - 1 has no + * DH_check findings. */ + d->verify_error = 0; + return sd_box(d); +} + +/* new DiffieHellman(prime, generator) over explicit parameters. */ +static ScrDyn *sd_from_prime(const ScrBytes *prime, const ScrBytes *generator_bytes, double generator) { + ScDh *d = sd_alloc(); + if (mbedtls_mpi_read_binary(&d->p, prime->data, prime->len) != 0) scr_trap("scriptc: out of memory\n"); + if (generator_bytes) { + if (mbedtls_mpi_read_binary(&d->g, generator_bytes->data, generator_bytes->len) != 0) + scr_trap("scriptc: out of memory\n"); + } else if (mbedtls_mpi_lset(&d->g, (mbedtls_mpi_sint)generator) != 0) { + scr_trap("scriptc: out of memory\n"); + } + if (mbedtls_mpi_cmp_int(&d->g, 2) < 0 || + (mbedtls_mpi_bitlen(&d->p) >= SD_MIN_MODULUS_BITS && mbedtls_mpi_cmp_mpi(&d->g, &d->p) >= 0)) { + sd_release(d); + sd_bad_generator(); + return NULL; + } + if (mbedtls_mpi_bitlen(&d->p) > MBEDTLS_MPI_MAX_BITS) { + sd_release(d); + sd_too_long(); + return NULL; + } + d->named = sd_find_named(&d->p, &d->g); + /* A named group's parameters have no DH_check findings. Other + * parameters are checked when verifyError is first read. */ + d->verify_error = d->named ? 0 : -1; + return sd_box(d); +} + +/* new DiffieHellman(sizeOrKey, keyEncoding, generator, genEncoding). */ +static ScrDyn *sd_new(const ScrDyn *size_or_key, const ScrDyn *key_encoding, const ScrDyn *generator, + const ScrDyn *generator_encoding) { + static const char *const types = + "one of type number or string or an instance of ArrayBuffer, Buffer, TypedArray, or DataView"; + bool size = size_or_key->kind == SCR_DYN_NUM; + if (!size && size_or_key->kind != SCR_DYN_STR && !sd_is_view(size_or_key)) { + scr_dyn_arg_type_fail("sizeOrKey", types, size_or_key); + return NULL; + } + if (size && !sd_validate_int32("sizeOrKey", size_or_key->v.num)) return NULL; + /* A truthy keyEncoding that names no encoding is the generator. */ + const ScrDyn *gen = generator; + const ScrDyn *gen_encoding = generator_encoding; + const ScrDyn *encoding = key_encoding; + if (scr_dyn_truthy(key_encoding) && !sd_is_encoding(key_encoding) && + !(key_encoding->kind == SCR_DYN_STR && ca_str_is(key_encoding->v.str, "buffer"))) { + gen_encoding = generator; + gen = key_encoding; + encoding = scr_dyn_undefined(); + } + ScrBytes *prime = NULL; + if (size_or_key->kind == SCR_DYN_STR) prime = ca_string_bytes(SD_SUBJECT, size_or_key->v.str, encoding); + else if (!size) prime = scr_bytes_buffer_source(size_or_key); + if (!size && !prime) return NULL; + ScrBytes *gen_bytes = NULL; + double gen_number = 2; + ScrDyn *result = NULL; + if (!scr_dyn_truthy(gen)) { + gen_number = 2; + } else if (gen->kind == SCR_DYN_NUM) { + if (!sd_validate_int32("generator", gen->v.num)) goto done; + gen_number = gen->v.num; + } else if (gen->kind == SCR_DYN_STR) { + if (!(gen_bytes = ca_string_bytes(SD_SUBJECT, gen->v.str, gen_encoding))) goto done; + } else if (sd_is_view(gen)) { + gen_bytes = scr_bytes_buffer_source(gen); + } else { + scr_dyn_arg_type_fail("generator", types, gen); + goto done; + } + result = size ? sd_generate(size_or_key->v.num + 0, gen_bytes, gen_number) + : sd_from_prime(prime, gen_bytes, gen_number); +done: + if (prime) scr_bytes_release(prime); + if (gen_bytes) scr_bytes_release(gen_bytes); + return result; +} + +ScrDyn *scr_crypto_dh_new(ScrDyn *size_or_key, ScrDyn *key_encoding, ScrDyn *generator, ScrDyn *generator_encoding) { + ScrDyn *args[4] = {size_or_key, key_encoding, generator, generator_encoding}; + ScrDyn *unboxed[4] = {NULL, NULL, NULL, NULL}; + ScrDyn *result = NULL; + for (size_t i = 0; i < 4; i++) + if (!(unboxed[i] = ca_unbox(args[i]))) goto done; + result = sd_new(unboxed[0], unboxed[1], unboxed[2], unboxed[3]); +done: + for (size_t i = 0; i < 4; i++) scr_dyn_release(unboxed[i]); + return result; +} + +/* new DiffieHellmanGroup(name): names match case-insensitively. */ +ScrDyn *scr_crypto_dh_group_new(ScrDyn *name) { + ScrDyn *unboxed = ca_unbox(name); + if (!unboxed) return NULL; + if (unboxed->kind != SCR_DYN_STR) { + scr_dyn_release(unboxed); + sd_throw(SCR_ERR_TYPE, "ERR_INVALID_ARG_TYPE", "Group name must be a string"); + return NULL; + } + const ScDhGroup *group = NULL; + for (size_t i = 0; i < sizeof sd_groups / sizeof sd_groups[0] && !group; i++) + if (ca_ascii_eq_ci(unboxed->v.str->data, unboxed->v.str->len, sd_groups[i].name)) group = &sd_groups[i]; + scr_dyn_release(unboxed); + if (!group) { + sd_throw(SCR_ERR_ERROR, "ERR_CRYPTO_UNKNOWN_DH_GROUP", "Unknown DH group"); + return NULL; + } + ScDh *d = sd_alloc(); + d->group = group; + if (mbedtls_mpi_read_binary(&d->p, group->p, group->p_len) != 0 || mbedtls_mpi_lset(&d->g, 2) != 0) + scr_trap("scriptc: out of memory\n"); + d->verify_error = 0; + return sd_box(d); +} + +/* ── methods ──────────────────────────────────────────────────────────── */ + +static ScrDyn *sd_arg(ScrDyn *const *args, size_t argc, size_t index) { + return index < argc ? args[index] : scr_dyn_undefined(); +} + +/* The minimal big-endian bytes of a value, as BignumPointer::Encode + * writes them (none for 0), passed through encode(). */ +static ScrDyn *sd_encode_value(const mbedtls_mpi *value, const ScrDyn *encoding) { + size_t len = mbedtls_mpi_size(value); + ScrBytes *out = scr_bytes_new(SCR_BYTES_U8, (double)len); + if (mbedtls_mpi_write_binary(value, out->data, len) != 0) scr_trap("scriptc: out of memory\n"); + return ca_encode(SD_SUBJECT, out, encoding); +} + +/* A new private key for generateKeys(). */ +static bool sd_new_private_key(ScDh *d, mbedtls_mpi *priv) { + if (d->group) { + if (d->group->private_bits) return sd_random_bits(priv, (size_t)d->group->private_bits, false); + /* BN_priv_rand_range(p - 3) + 2. */ + mbedtls_mpi bound; + mbedtls_mpi_init(&bound); + bool ok = mbedtls_mpi_sub_int(&bound, &d->p, 1) == 0 && mbedtls_mpi_random(priv, 2, &bound, sd_random, NULL) == 0; + mbedtls_mpi_free(&bound); + return ok; + } + size_t bits = mbedtls_mpi_bitlen(&d->p); + if (bits < SD_MIN_MODULUS_BITS || bits > SD_MAX_MODULUS_BITS) return false; + if (!d->named) return sd_random_bits(priv, bits - 2, false); + /* ossl_ffc_generate_private_key: 1 <= priv < min(2^N, q). */ + mbedtls_mpi bound, q; + mbedtls_mpi_init(&bound); + mbedtls_mpi_init(&q); + bool ok = mbedtls_mpi_lset(&bound, 1) == 0 && mbedtls_mpi_shift_l(&bound, (size_t)d->named->keylength) == 0; + if (ok && d->named->q) ok = mbedtls_mpi_read_binary(&q, d->named->q, d->named->q_len) == 0; + else if (ok) ok = mbedtls_mpi_copy(&q, &d->p) == 0 && mbedtls_mpi_shift_r(&q, 1) == 0; + if (ok && mbedtls_mpi_cmp_mpi(&q, &bound) < 0) ok = mbedtls_mpi_copy(&bound, &q) == 0; + ok = ok && mbedtls_mpi_random(priv, 1, &bound, sd_random, NULL) == 0; + mbedtls_mpi_free(&bound); + mbedtls_mpi_free(&q); + return ok; +} + +/* generateKeys(encoding): a new key pair, or the public key of the + * private key the object has. */ +static ScrDyn *sd_generate_keys(ScDh *d, const ScrDyn *encoding) { + mbedtls_mpi priv, pub; + mbedtls_mpi_init(&priv); + mbedtls_mpi_init(&pub); + bool fresh = !d->has_priv; + bool ok = fresh ? sd_new_private_key(d, &priv) : mbedtls_mpi_copy(&priv, &d->priv) == 0; + ok = ok && sd_exp(&pub, &d->g, &priv, &d->p); + if (ok) { + mbedtls_mpi_swap(&d->priv, &priv); + mbedtls_mpi_swap(&d->pub, &pub); + d->has_priv = true; + d->has_pub = true; + } + mbedtls_mpi_free(&priv); + mbedtls_mpi_free(&pub); + if (!ok || mbedtls_mpi_cmp_int(&d->pub, 0) == 0) { + sd_operation_failed("Key generation failed"); + return NULL; + } + return sd_encode_value(&d->pub, encoding); +} + +/* Whether OpenSSL's DH derivation accepts explicit parameters' private + * key: a nonzero key and a 512- to 10000-bit prime. */ +static bool sd_derives(const ScDh *d) { + size_t bits = mbedtls_mpi_bitlen(&d->p); + return mbedtls_mpi_cmp_int(&d->priv, 0) != 0 && bits >= SD_MIN_MODULUS_BITS && bits <= SD_MAX_MODULUS_BITS; +} + +/* computeSecret(key, inputEncoding, outputEncoding): key^priv mod p, + * padded to the prime's length. */ +static ScrDyn *sd_compute_secret(ScDh *d, const ScrDyn *key, const ScrDyn *in_enc, const ScrDyn *out_enc) { + ScrBytes *bytes = ca_key_bytes(SD_SUBJECT, key, in_enc); + if (!bytes) return NULL; + ScrDyn *result = NULL; + mbedtls_mpi peer, bound, secret; + mbedtls_mpi_init(&peer); + mbedtls_mpi_init(&bound); + mbedtls_mpi_init(&secret); + if (mbedtls_mpi_read_binary(&peer, bytes->data, bytes->len) != 0 || mbedtls_mpi_sub_int(&bound, &d->p, 1) != 0) + scr_trap("scriptc: out of memory\n"); + if (mbedtls_mpi_cmp_int(&peer, 1) <= 0) { + sd_throw(SCR_ERR_RANGE, "ERR_CRYPTO_INVALID_KEYLEN", "Supplied key is too small"); + } else if (mbedtls_mpi_cmp_mpi(&peer, &bound) >= 0) { + sd_throw(SCR_ERR_RANGE, "ERR_CRYPTO_INVALID_KEYLEN", "Supplied key is too large"); + } else if (!d->has_priv || (!d->group && !sd_derives(d)) || !sd_exp(&secret, &peer, &d->priv, &d->p)) { + sd_operation_failed("Failed to compute shared secret"); + } else { + size_t len = mbedtls_mpi_size(&d->p); + ScrBytes *out = scr_bytes_new(SCR_BYTES_U8, (double)len); + if (mbedtls_mpi_write_binary(&secret, out->data, len) != 0) scr_trap("scriptc: out of memory\n"); + result = ca_encode(SD_SUBJECT, out, out_enc); + } + mbedtls_mpi_free(&peer); + mbedtls_mpi_free(&bound); + mbedtls_mpi_free(&secret); + scr_bytes_release(bytes); + return result; +} + +static ScrDyn *sd_get_value(const mbedtls_mpi *value, bool present, const char *missing, const ScrDyn *encoding) { + if (!present || mbedtls_mpi_cmp_int(value, 0) == 0) { + sd_throw(SCR_ERR_ERROR, "ERR_CRYPTO_INVALID_STATE", missing); + return NULL; + } + return sd_encode_value(value, encoding); +} + +/* setPublicKey(key, encoding) and setPrivateKey(key, encoding). */ +static ScrDyn *sd_set_value(mbedtls_mpi *value, bool *present, ScrDyn *self, const ScrDyn *key, const ScrDyn *encoding) { + ScrBytes *bytes = ca_key_bytes(SD_SUBJECT, key, encoding); + if (!bytes) return NULL; + if (mbedtls_mpi_read_binary(value, bytes->data, bytes->len) != 0) scr_trap("scriptc: out of memory\n"); + *present = true; + scr_bytes_release(bytes); + return scr_dyn_retain(self); +} + +static bool sd_name_is(const char *method, const char *name) { + return strcmp(method, name) == 0; +} + +static ScrDyn *sd_dispatch(ScDh *d, ScrDyn *self, const char *method, ScrDyn *const *args, size_t argc, + const char *what) { + const ScrDyn *a0 = sd_arg(args, argc, 0); + if (sd_name_is(method, "generateKeys")) return sd_generate_keys(d, a0); + if (sd_name_is(method, "computeSecret")) + return sd_compute_secret(d, a0, sd_arg(args, argc, 1), sd_arg(args, argc, 2)); + if (sd_name_is(method, "getPrime")) return sd_get_value(&d->p, true, "p is null", a0); + if (sd_name_is(method, "getGenerator")) return sd_get_value(&d->g, true, "g is null", a0); + if (sd_name_is(method, "getPublicKey")) + return sd_get_value(&d->pub, d->has_pub, "No public key - did you forget to generate one?", a0); + if (sd_name_is(method, "getPrivateKey")) + return sd_get_value(&d->priv, d->has_priv, "No private key - did you forget to generate one?", a0); + /* DiffieHellmanGroup has no key setters. */ + if (!d->group && sd_name_is(method, "setPublicKey")) + return sd_set_value(&d->pub, &d->has_pub, self, a0, sd_arg(args, argc, 1)); + if (!d->group && sd_name_is(method, "setPrivateKey")) + return sd_set_value(&d->priv, &d->has_priv, self, a0, sd_arg(args, argc, 1)); + /* The Object.prototype methods a DiffieHellman inherits. */ + static const char *const inherited[] = {"constructor", "hasOwnProperty", "isPrototypeOf", + "propertyIsEnumerable", "toLocaleString", "toString", + "valueOf"}; + for (size_t i = 0; i < sizeof inherited / sizeof inherited[0]; i++) + if (sd_name_is(method, inherited[i])) { + static const char message[] = "DiffieHellman's Object.prototype methods have no lowering"; + scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020"); + return NULL; + } + ScrJsonBuf b; + scr_jb_init(&b); + scr_jb_puts(&b, what); + scr_jb_puts(&b, " is not a function"); + scr_throw_error(SCR_ERR_TYPE, scr_jb_finish(&b)); + return NULL; +} + +/* Every method reads at most three arguments. */ +static ScrDyn *sd_invoke(void *h, ScrDyn *self, const char *method, ScrDyn *const *args, size_t argc, + const char *what) { + ScrDyn *unboxed[3] = {NULL, NULL, NULL}; + size_t count = argc < 3 ? argc : 3; + ScrDyn *result = NULL; + for (size_t i = 0; i < count; i++) + if (!(unboxed[i] = ca_unbox(args[i]))) goto done; + result = sd_dispatch(h, self, method, unboxed, count, what); +done: + for (size_t i = 0; i < count; i++) scr_dyn_release(unboxed[i]); + return result; +} + +/* verifyError, the one own data property. */ +static ScrDyn *sd_get(void *h, const char *key, size_t key_len) { + ScDh *d = h; + if (key_len == 11 && memcmp(key, "verifyError", 11) == 0) { + if (d->verify_error < 0) d->verify_error = sd_check_params(&d->p, &d->g); + return scr_dyn_new_num(d->verify_error); + } + static const char message[] = + "DiffieHellman property reads other than verifyError have no lowering; call generateKeys(), " + "computeSecret(), getPrime(), getGenerator(), getPublicKey(), getPrivateKey(), setPublicKey() or " + "setPrivateKey()"; + scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020"); + return NULL; +} + +static bool sd_set(void *h, const char *key, size_t key_len, const ScrDyn *value) { + (void)h; (void)key; (void)key_len; (void)value; + static const char message[] = "Writing DiffieHellman properties has no lowering"; + scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020"); + return true; +} + +static ScrDynHandleOps sd_ops = {"DiffieHellman", sd_retain, sd_release, sd_invoke, sd_get, sd_set, NULL, NULL, NULL}; +static ScrDynHandleOps sd_group_ops = {"DiffieHellmanGroup", sd_retain, sd_release, sd_invoke, sd_get, sd_set, + NULL, NULL, NULL}; diff --git a/packages/runtime/src/scr_dh_groups.h b/packages/runtime/src/scr_dh_groups.h new file mode 100644 index 000000000..c82ec7270 --- /dev/null +++ b/packages/runtime/src/scr_dh_groups.h @@ -0,0 +1,557 @@ +/* Diffie-Hellman group parameters, big-endian: the primes behind Node 24's + * crypto.getDiffieHellman groups (modp1 and modp2 from RFC 2409, modp5 and + * modp14 through modp18 from RFC 3526), and the RFC 7919 (ffdhe2048 through + * ffdhe8192) and RFC 5114 (dh_1024_160, dh_2048_224 and dh_2048_256) + * parameters OpenSSL 3.5 lists among its DH named groups + * (crypto/ffc/ffc_dh.c). Every group but RFC 5114's uses the generator 2 + * and a safe prime. */ +#ifndef SCR_DH_GROUPS_H +#define SCR_DH_GROUPS_H + +static const unsigned char scr_dh_modp1_p[96] = { + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc9, 0x0f, 0xda, 0xa2, 0x21, 0x68, 0xc2, 0x34, + 0xc4, 0xc6, 0x62, 0x8b, 0x80, 0xdc, 0x1c, 0xd1, 0x29, 0x02, 0x4e, 0x08, 0x8a, 0x67, 0xcc, 0x74, + 0x02, 0x0b, 0xbe, 0xa6, 0x3b, 0x13, 0x9b, 0x22, 0x51, 0x4a, 0x08, 0x79, 0x8e, 0x34, 0x04, 0xdd, + 0xef, 0x95, 0x19, 0xb3, 0xcd, 0x3a, 0x43, 0x1b, 0x30, 0x2b, 0x0a, 0x6d, 0xf2, 0x5f, 0x14, 0x37, + 0x4f, 0xe1, 0x35, 0x6d, 0x6d, 0x51, 0xc2, 0x45, 0xe4, 0x85, 0xb5, 0x76, 0x62, 0x5e, 0x7e, 0xc6, + 0xf4, 0x4c, 0x42, 0xe9, 0xa6, 0x3a, 0x36, 0x20, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, +}; + +static const unsigned char scr_dh_modp2_p[128] = { + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc9, 0x0f, 0xda, 0xa2, 0x21, 0x68, 0xc2, 0x34, + 0xc4, 0xc6, 0x62, 0x8b, 0x80, 0xdc, 0x1c, 0xd1, 0x29, 0x02, 0x4e, 0x08, 0x8a, 0x67, 0xcc, 0x74, + 0x02, 0x0b, 0xbe, 0xa6, 0x3b, 0x13, 0x9b, 0x22, 0x51, 0x4a, 0x08, 0x79, 0x8e, 0x34, 0x04, 0xdd, + 0xef, 0x95, 0x19, 0xb3, 0xcd, 0x3a, 0x43, 0x1b, 0x30, 0x2b, 0x0a, 0x6d, 0xf2, 0x5f, 0x14, 0x37, + 0x4f, 0xe1, 0x35, 0x6d, 0x6d, 0x51, 0xc2, 0x45, 0xe4, 0x85, 0xb5, 0x76, 0x62, 0x5e, 0x7e, 0xc6, + 0xf4, 0x4c, 0x42, 0xe9, 0xa6, 0x37, 0xed, 0x6b, 0x0b, 0xff, 0x5c, 0xb6, 0xf4, 0x06, 0xb7, 0xed, + 0xee, 0x38, 0x6b, 0xfb, 0x5a, 0x89, 0x9f, 0xa5, 0xae, 0x9f, 0x24, 0x11, 0x7c, 0x4b, 0x1f, 0xe6, + 0x49, 0x28, 0x66, 0x51, 0xec, 0xe6, 0x53, 0x81, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, +}; + +static const unsigned char scr_dh_modp5_p[192] = { + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc9, 0x0f, 0xda, 0xa2, 0x21, 0x68, 0xc2, 0x34, + 0xc4, 0xc6, 0x62, 0x8b, 0x80, 0xdc, 0x1c, 0xd1, 0x29, 0x02, 0x4e, 0x08, 0x8a, 0x67, 0xcc, 0x74, + 0x02, 0x0b, 0xbe, 0xa6, 0x3b, 0x13, 0x9b, 0x22, 0x51, 0x4a, 0x08, 0x79, 0x8e, 0x34, 0x04, 0xdd, + 0xef, 0x95, 0x19, 0xb3, 0xcd, 0x3a, 0x43, 0x1b, 0x30, 0x2b, 0x0a, 0x6d, 0xf2, 0x5f, 0x14, 0x37, + 0x4f, 0xe1, 0x35, 0x6d, 0x6d, 0x51, 0xc2, 0x45, 0xe4, 0x85, 0xb5, 0x76, 0x62, 0x5e, 0x7e, 0xc6, + 0xf4, 0x4c, 0x42, 0xe9, 0xa6, 0x37, 0xed, 0x6b, 0x0b, 0xff, 0x5c, 0xb6, 0xf4, 0x06, 0xb7, 0xed, + 0xee, 0x38, 0x6b, 0xfb, 0x5a, 0x89, 0x9f, 0xa5, 0xae, 0x9f, 0x24, 0x11, 0x7c, 0x4b, 0x1f, 0xe6, + 0x49, 0x28, 0x66, 0x51, 0xec, 0xe4, 0x5b, 0x3d, 0xc2, 0x00, 0x7c, 0xb8, 0xa1, 0x63, 0xbf, 0x05, + 0x98, 0xda, 0x48, 0x36, 0x1c, 0x55, 0xd3, 0x9a, 0x69, 0x16, 0x3f, 0xa8, 0xfd, 0x24, 0xcf, 0x5f, + 0x83, 0x65, 0x5d, 0x23, 0xdc, 0xa3, 0xad, 0x96, 0x1c, 0x62, 0xf3, 0x56, 0x20, 0x85, 0x52, 0xbb, + 0x9e, 0xd5, 0x29, 0x07, 0x70, 0x96, 0x96, 0x6d, 0x67, 0x0c, 0x35, 0x4e, 0x4a, 0xbc, 0x98, 0x04, + 0xf1, 0x74, 0x6c, 0x08, 0xca, 0x23, 0x73, 0x27, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, +}; + +static const unsigned char scr_dh_modp14_p[256] = { + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc9, 0x0f, 0xda, 0xa2, 0x21, 0x68, 0xc2, 0x34, + 0xc4, 0xc6, 0x62, 0x8b, 0x80, 0xdc, 0x1c, 0xd1, 0x29, 0x02, 0x4e, 0x08, 0x8a, 0x67, 0xcc, 0x74, + 0x02, 0x0b, 0xbe, 0xa6, 0x3b, 0x13, 0x9b, 0x22, 0x51, 0x4a, 0x08, 0x79, 0x8e, 0x34, 0x04, 0xdd, + 0xef, 0x95, 0x19, 0xb3, 0xcd, 0x3a, 0x43, 0x1b, 0x30, 0x2b, 0x0a, 0x6d, 0xf2, 0x5f, 0x14, 0x37, + 0x4f, 0xe1, 0x35, 0x6d, 0x6d, 0x51, 0xc2, 0x45, 0xe4, 0x85, 0xb5, 0x76, 0x62, 0x5e, 0x7e, 0xc6, + 0xf4, 0x4c, 0x42, 0xe9, 0xa6, 0x37, 0xed, 0x6b, 0x0b, 0xff, 0x5c, 0xb6, 0xf4, 0x06, 0xb7, 0xed, + 0xee, 0x38, 0x6b, 0xfb, 0x5a, 0x89, 0x9f, 0xa5, 0xae, 0x9f, 0x24, 0x11, 0x7c, 0x4b, 0x1f, 0xe6, + 0x49, 0x28, 0x66, 0x51, 0xec, 0xe4, 0x5b, 0x3d, 0xc2, 0x00, 0x7c, 0xb8, 0xa1, 0x63, 0xbf, 0x05, + 0x98, 0xda, 0x48, 0x36, 0x1c, 0x55, 0xd3, 0x9a, 0x69, 0x16, 0x3f, 0xa8, 0xfd, 0x24, 0xcf, 0x5f, + 0x83, 0x65, 0x5d, 0x23, 0xdc, 0xa3, 0xad, 0x96, 0x1c, 0x62, 0xf3, 0x56, 0x20, 0x85, 0x52, 0xbb, + 0x9e, 0xd5, 0x29, 0x07, 0x70, 0x96, 0x96, 0x6d, 0x67, 0x0c, 0x35, 0x4e, 0x4a, 0xbc, 0x98, 0x04, + 0xf1, 0x74, 0x6c, 0x08, 0xca, 0x18, 0x21, 0x7c, 0x32, 0x90, 0x5e, 0x46, 0x2e, 0x36, 0xce, 0x3b, + 0xe3, 0x9e, 0x77, 0x2c, 0x18, 0x0e, 0x86, 0x03, 0x9b, 0x27, 0x83, 0xa2, 0xec, 0x07, 0xa2, 0x8f, + 0xb5, 0xc5, 0x5d, 0xf0, 0x6f, 0x4c, 0x52, 0xc9, 0xde, 0x2b, 0xcb, 0xf6, 0x95, 0x58, 0x17, 0x18, + 0x39, 0x95, 0x49, 0x7c, 0xea, 0x95, 0x6a, 0xe5, 0x15, 0xd2, 0x26, 0x18, 0x98, 0xfa, 0x05, 0x10, + 0x15, 0x72, 0x8e, 0x5a, 0x8a, 0xac, 0xaa, 0x68, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, +}; + +static const unsigned char scr_dh_modp15_p[384] = { + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc9, 0x0f, 0xda, 0xa2, 0x21, 0x68, 0xc2, 0x34, + 0xc4, 0xc6, 0x62, 0x8b, 0x80, 0xdc, 0x1c, 0xd1, 0x29, 0x02, 0x4e, 0x08, 0x8a, 0x67, 0xcc, 0x74, + 0x02, 0x0b, 0xbe, 0xa6, 0x3b, 0x13, 0x9b, 0x22, 0x51, 0x4a, 0x08, 0x79, 0x8e, 0x34, 0x04, 0xdd, + 0xef, 0x95, 0x19, 0xb3, 0xcd, 0x3a, 0x43, 0x1b, 0x30, 0x2b, 0x0a, 0x6d, 0xf2, 0x5f, 0x14, 0x37, + 0x4f, 0xe1, 0x35, 0x6d, 0x6d, 0x51, 0xc2, 0x45, 0xe4, 0x85, 0xb5, 0x76, 0x62, 0x5e, 0x7e, 0xc6, + 0xf4, 0x4c, 0x42, 0xe9, 0xa6, 0x37, 0xed, 0x6b, 0x0b, 0xff, 0x5c, 0xb6, 0xf4, 0x06, 0xb7, 0xed, + 0xee, 0x38, 0x6b, 0xfb, 0x5a, 0x89, 0x9f, 0xa5, 0xae, 0x9f, 0x24, 0x11, 0x7c, 0x4b, 0x1f, 0xe6, + 0x49, 0x28, 0x66, 0x51, 0xec, 0xe4, 0x5b, 0x3d, 0xc2, 0x00, 0x7c, 0xb8, 0xa1, 0x63, 0xbf, 0x05, + 0x98, 0xda, 0x48, 0x36, 0x1c, 0x55, 0xd3, 0x9a, 0x69, 0x16, 0x3f, 0xa8, 0xfd, 0x24, 0xcf, 0x5f, + 0x83, 0x65, 0x5d, 0x23, 0xdc, 0xa3, 0xad, 0x96, 0x1c, 0x62, 0xf3, 0x56, 0x20, 0x85, 0x52, 0xbb, + 0x9e, 0xd5, 0x29, 0x07, 0x70, 0x96, 0x96, 0x6d, 0x67, 0x0c, 0x35, 0x4e, 0x4a, 0xbc, 0x98, 0x04, + 0xf1, 0x74, 0x6c, 0x08, 0xca, 0x18, 0x21, 0x7c, 0x32, 0x90, 0x5e, 0x46, 0x2e, 0x36, 0xce, 0x3b, + 0xe3, 0x9e, 0x77, 0x2c, 0x18, 0x0e, 0x86, 0x03, 0x9b, 0x27, 0x83, 0xa2, 0xec, 0x07, 0xa2, 0x8f, + 0xb5, 0xc5, 0x5d, 0xf0, 0x6f, 0x4c, 0x52, 0xc9, 0xde, 0x2b, 0xcb, 0xf6, 0x95, 0x58, 0x17, 0x18, + 0x39, 0x95, 0x49, 0x7c, 0xea, 0x95, 0x6a, 0xe5, 0x15, 0xd2, 0x26, 0x18, 0x98, 0xfa, 0x05, 0x10, + 0x15, 0x72, 0x8e, 0x5a, 0x8a, 0xaa, 0xc4, 0x2d, 0xad, 0x33, 0x17, 0x0d, 0x04, 0x50, 0x7a, 0x33, + 0xa8, 0x55, 0x21, 0xab, 0xdf, 0x1c, 0xba, 0x64, 0xec, 0xfb, 0x85, 0x04, 0x58, 0xdb, 0xef, 0x0a, + 0x8a, 0xea, 0x71, 0x57, 0x5d, 0x06, 0x0c, 0x7d, 0xb3, 0x97, 0x0f, 0x85, 0xa6, 0xe1, 0xe4, 0xc7, + 0xab, 0xf5, 0xae, 0x8c, 0xdb, 0x09, 0x33, 0xd7, 0x1e, 0x8c, 0x94, 0xe0, 0x4a, 0x25, 0x61, 0x9d, + 0xce, 0xe3, 0xd2, 0x26, 0x1a, 0xd2, 0xee, 0x6b, 0xf1, 0x2f, 0xfa, 0x06, 0xd9, 0x8a, 0x08, 0x64, + 0xd8, 0x76, 0x02, 0x73, 0x3e, 0xc8, 0x6a, 0x64, 0x52, 0x1f, 0x2b, 0x18, 0x17, 0x7b, 0x20, 0x0c, + 0xbb, 0xe1, 0x17, 0x57, 0x7a, 0x61, 0x5d, 0x6c, 0x77, 0x09, 0x88, 0xc0, 0xba, 0xd9, 0x46, 0xe2, + 0x08, 0xe2, 0x4f, 0xa0, 0x74, 0xe5, 0xab, 0x31, 0x43, 0xdb, 0x5b, 0xfc, 0xe0, 0xfd, 0x10, 0x8e, + 0x4b, 0x82, 0xd1, 0x20, 0xa9, 0x3a, 0xd2, 0xca, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, +}; + +static const unsigned char scr_dh_modp16_p[512] = { + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc9, 0x0f, 0xda, 0xa2, 0x21, 0x68, 0xc2, 0x34, + 0xc4, 0xc6, 0x62, 0x8b, 0x80, 0xdc, 0x1c, 0xd1, 0x29, 0x02, 0x4e, 0x08, 0x8a, 0x67, 0xcc, 0x74, + 0x02, 0x0b, 0xbe, 0xa6, 0x3b, 0x13, 0x9b, 0x22, 0x51, 0x4a, 0x08, 0x79, 0x8e, 0x34, 0x04, 0xdd, + 0xef, 0x95, 0x19, 0xb3, 0xcd, 0x3a, 0x43, 0x1b, 0x30, 0x2b, 0x0a, 0x6d, 0xf2, 0x5f, 0x14, 0x37, + 0x4f, 0xe1, 0x35, 0x6d, 0x6d, 0x51, 0xc2, 0x45, 0xe4, 0x85, 0xb5, 0x76, 0x62, 0x5e, 0x7e, 0xc6, + 0xf4, 0x4c, 0x42, 0xe9, 0xa6, 0x37, 0xed, 0x6b, 0x0b, 0xff, 0x5c, 0xb6, 0xf4, 0x06, 0xb7, 0xed, + 0xee, 0x38, 0x6b, 0xfb, 0x5a, 0x89, 0x9f, 0xa5, 0xae, 0x9f, 0x24, 0x11, 0x7c, 0x4b, 0x1f, 0xe6, + 0x49, 0x28, 0x66, 0x51, 0xec, 0xe4, 0x5b, 0x3d, 0xc2, 0x00, 0x7c, 0xb8, 0xa1, 0x63, 0xbf, 0x05, + 0x98, 0xda, 0x48, 0x36, 0x1c, 0x55, 0xd3, 0x9a, 0x69, 0x16, 0x3f, 0xa8, 0xfd, 0x24, 0xcf, 0x5f, + 0x83, 0x65, 0x5d, 0x23, 0xdc, 0xa3, 0xad, 0x96, 0x1c, 0x62, 0xf3, 0x56, 0x20, 0x85, 0x52, 0xbb, + 0x9e, 0xd5, 0x29, 0x07, 0x70, 0x96, 0x96, 0x6d, 0x67, 0x0c, 0x35, 0x4e, 0x4a, 0xbc, 0x98, 0x04, + 0xf1, 0x74, 0x6c, 0x08, 0xca, 0x18, 0x21, 0x7c, 0x32, 0x90, 0x5e, 0x46, 0x2e, 0x36, 0xce, 0x3b, + 0xe3, 0x9e, 0x77, 0x2c, 0x18, 0x0e, 0x86, 0x03, 0x9b, 0x27, 0x83, 0xa2, 0xec, 0x07, 0xa2, 0x8f, + 0xb5, 0xc5, 0x5d, 0xf0, 0x6f, 0x4c, 0x52, 0xc9, 0xde, 0x2b, 0xcb, 0xf6, 0x95, 0x58, 0x17, 0x18, + 0x39, 0x95, 0x49, 0x7c, 0xea, 0x95, 0x6a, 0xe5, 0x15, 0xd2, 0x26, 0x18, 0x98, 0xfa, 0x05, 0x10, + 0x15, 0x72, 0x8e, 0x5a, 0x8a, 0xaa, 0xc4, 0x2d, 0xad, 0x33, 0x17, 0x0d, 0x04, 0x50, 0x7a, 0x33, + 0xa8, 0x55, 0x21, 0xab, 0xdf, 0x1c, 0xba, 0x64, 0xec, 0xfb, 0x85, 0x04, 0x58, 0xdb, 0xef, 0x0a, + 0x8a, 0xea, 0x71, 0x57, 0x5d, 0x06, 0x0c, 0x7d, 0xb3, 0x97, 0x0f, 0x85, 0xa6, 0xe1, 0xe4, 0xc7, + 0xab, 0xf5, 0xae, 0x8c, 0xdb, 0x09, 0x33, 0xd7, 0x1e, 0x8c, 0x94, 0xe0, 0x4a, 0x25, 0x61, 0x9d, + 0xce, 0xe3, 0xd2, 0x26, 0x1a, 0xd2, 0xee, 0x6b, 0xf1, 0x2f, 0xfa, 0x06, 0xd9, 0x8a, 0x08, 0x64, + 0xd8, 0x76, 0x02, 0x73, 0x3e, 0xc8, 0x6a, 0x64, 0x52, 0x1f, 0x2b, 0x18, 0x17, 0x7b, 0x20, 0x0c, + 0xbb, 0xe1, 0x17, 0x57, 0x7a, 0x61, 0x5d, 0x6c, 0x77, 0x09, 0x88, 0xc0, 0xba, 0xd9, 0x46, 0xe2, + 0x08, 0xe2, 0x4f, 0xa0, 0x74, 0xe5, 0xab, 0x31, 0x43, 0xdb, 0x5b, 0xfc, 0xe0, 0xfd, 0x10, 0x8e, + 0x4b, 0x82, 0xd1, 0x20, 0xa9, 0x21, 0x08, 0x01, 0x1a, 0x72, 0x3c, 0x12, 0xa7, 0x87, 0xe6, 0xd7, + 0x88, 0x71, 0x9a, 0x10, 0xbd, 0xba, 0x5b, 0x26, 0x99, 0xc3, 0x27, 0x18, 0x6a, 0xf4, 0xe2, 0x3c, + 0x1a, 0x94, 0x68, 0x34, 0xb6, 0x15, 0x0b, 0xda, 0x25, 0x83, 0xe9, 0xca, 0x2a, 0xd4, 0x4c, 0xe8, + 0xdb, 0xbb, 0xc2, 0xdb, 0x04, 0xde, 0x8e, 0xf9, 0x2e, 0x8e, 0xfc, 0x14, 0x1f, 0xbe, 0xca, 0xa6, + 0x28, 0x7c, 0x59, 0x47, 0x4e, 0x6b, 0xc0, 0x5d, 0x99, 0xb2, 0x96, 0x4f, 0xa0, 0x90, 0xc3, 0xa2, + 0x23, 0x3b, 0xa1, 0x86, 0x51, 0x5b, 0xe7, 0xed, 0x1f, 0x61, 0x29, 0x70, 0xce, 0xe2, 0xd7, 0xaf, + 0xb8, 0x1b, 0xdd, 0x76, 0x21, 0x70, 0x48, 0x1c, 0xd0, 0x06, 0x91, 0x27, 0xd5, 0xb0, 0x5a, 0xa9, + 0x93, 0xb4, 0xea, 0x98, 0x8d, 0x8f, 0xdd, 0xc1, 0x86, 0xff, 0xb7, 0xdc, 0x90, 0xa6, 0xc0, 0x8f, + 0x4d, 0xf4, 0x35, 0xc9, 0x34, 0x06, 0x31, 0x99, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, +}; + +static const unsigned char scr_dh_modp17_p[768] = { + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc9, 0x0f, 0xda, 0xa2, 0x21, 0x68, 0xc2, 0x34, + 0xc4, 0xc6, 0x62, 0x8b, 0x80, 0xdc, 0x1c, 0xd1, 0x29, 0x02, 0x4e, 0x08, 0x8a, 0x67, 0xcc, 0x74, + 0x02, 0x0b, 0xbe, 0xa6, 0x3b, 0x13, 0x9b, 0x22, 0x51, 0x4a, 0x08, 0x79, 0x8e, 0x34, 0x04, 0xdd, + 0xef, 0x95, 0x19, 0xb3, 0xcd, 0x3a, 0x43, 0x1b, 0x30, 0x2b, 0x0a, 0x6d, 0xf2, 0x5f, 0x14, 0x37, + 0x4f, 0xe1, 0x35, 0x6d, 0x6d, 0x51, 0xc2, 0x45, 0xe4, 0x85, 0xb5, 0x76, 0x62, 0x5e, 0x7e, 0xc6, + 0xf4, 0x4c, 0x42, 0xe9, 0xa6, 0x37, 0xed, 0x6b, 0x0b, 0xff, 0x5c, 0xb6, 0xf4, 0x06, 0xb7, 0xed, + 0xee, 0x38, 0x6b, 0xfb, 0x5a, 0x89, 0x9f, 0xa5, 0xae, 0x9f, 0x24, 0x11, 0x7c, 0x4b, 0x1f, 0xe6, + 0x49, 0x28, 0x66, 0x51, 0xec, 0xe4, 0x5b, 0x3d, 0xc2, 0x00, 0x7c, 0xb8, 0xa1, 0x63, 0xbf, 0x05, + 0x98, 0xda, 0x48, 0x36, 0x1c, 0x55, 0xd3, 0x9a, 0x69, 0x16, 0x3f, 0xa8, 0xfd, 0x24, 0xcf, 0x5f, + 0x83, 0x65, 0x5d, 0x23, 0xdc, 0xa3, 0xad, 0x96, 0x1c, 0x62, 0xf3, 0x56, 0x20, 0x85, 0x52, 0xbb, + 0x9e, 0xd5, 0x29, 0x07, 0x70, 0x96, 0x96, 0x6d, 0x67, 0x0c, 0x35, 0x4e, 0x4a, 0xbc, 0x98, 0x04, + 0xf1, 0x74, 0x6c, 0x08, 0xca, 0x18, 0x21, 0x7c, 0x32, 0x90, 0x5e, 0x46, 0x2e, 0x36, 0xce, 0x3b, + 0xe3, 0x9e, 0x77, 0x2c, 0x18, 0x0e, 0x86, 0x03, 0x9b, 0x27, 0x83, 0xa2, 0xec, 0x07, 0xa2, 0x8f, + 0xb5, 0xc5, 0x5d, 0xf0, 0x6f, 0x4c, 0x52, 0xc9, 0xde, 0x2b, 0xcb, 0xf6, 0x95, 0x58, 0x17, 0x18, + 0x39, 0x95, 0x49, 0x7c, 0xea, 0x95, 0x6a, 0xe5, 0x15, 0xd2, 0x26, 0x18, 0x98, 0xfa, 0x05, 0x10, + 0x15, 0x72, 0x8e, 0x5a, 0x8a, 0xaa, 0xc4, 0x2d, 0xad, 0x33, 0x17, 0x0d, 0x04, 0x50, 0x7a, 0x33, + 0xa8, 0x55, 0x21, 0xab, 0xdf, 0x1c, 0xba, 0x64, 0xec, 0xfb, 0x85, 0x04, 0x58, 0xdb, 0xef, 0x0a, + 0x8a, 0xea, 0x71, 0x57, 0x5d, 0x06, 0x0c, 0x7d, 0xb3, 0x97, 0x0f, 0x85, 0xa6, 0xe1, 0xe4, 0xc7, + 0xab, 0xf5, 0xae, 0x8c, 0xdb, 0x09, 0x33, 0xd7, 0x1e, 0x8c, 0x94, 0xe0, 0x4a, 0x25, 0x61, 0x9d, + 0xce, 0xe3, 0xd2, 0x26, 0x1a, 0xd2, 0xee, 0x6b, 0xf1, 0x2f, 0xfa, 0x06, 0xd9, 0x8a, 0x08, 0x64, + 0xd8, 0x76, 0x02, 0x73, 0x3e, 0xc8, 0x6a, 0x64, 0x52, 0x1f, 0x2b, 0x18, 0x17, 0x7b, 0x20, 0x0c, + 0xbb, 0xe1, 0x17, 0x57, 0x7a, 0x61, 0x5d, 0x6c, 0x77, 0x09, 0x88, 0xc0, 0xba, 0xd9, 0x46, 0xe2, + 0x08, 0xe2, 0x4f, 0xa0, 0x74, 0xe5, 0xab, 0x31, 0x43, 0xdb, 0x5b, 0xfc, 0xe0, 0xfd, 0x10, 0x8e, + 0x4b, 0x82, 0xd1, 0x20, 0xa9, 0x21, 0x08, 0x01, 0x1a, 0x72, 0x3c, 0x12, 0xa7, 0x87, 0xe6, 0xd7, + 0x88, 0x71, 0x9a, 0x10, 0xbd, 0xba, 0x5b, 0x26, 0x99, 0xc3, 0x27, 0x18, 0x6a, 0xf4, 0xe2, 0x3c, + 0x1a, 0x94, 0x68, 0x34, 0xb6, 0x15, 0x0b, 0xda, 0x25, 0x83, 0xe9, 0xca, 0x2a, 0xd4, 0x4c, 0xe8, + 0xdb, 0xbb, 0xc2, 0xdb, 0x04, 0xde, 0x8e, 0xf9, 0x2e, 0x8e, 0xfc, 0x14, 0x1f, 0xbe, 0xca, 0xa6, + 0x28, 0x7c, 0x59, 0x47, 0x4e, 0x6b, 0xc0, 0x5d, 0x99, 0xb2, 0x96, 0x4f, 0xa0, 0x90, 0xc3, 0xa2, + 0x23, 0x3b, 0xa1, 0x86, 0x51, 0x5b, 0xe7, 0xed, 0x1f, 0x61, 0x29, 0x70, 0xce, 0xe2, 0xd7, 0xaf, + 0xb8, 0x1b, 0xdd, 0x76, 0x21, 0x70, 0x48, 0x1c, 0xd0, 0x06, 0x91, 0x27, 0xd5, 0xb0, 0x5a, 0xa9, + 0x93, 0xb4, 0xea, 0x98, 0x8d, 0x8f, 0xdd, 0xc1, 0x86, 0xff, 0xb7, 0xdc, 0x90, 0xa6, 0xc0, 0x8f, + 0x4d, 0xf4, 0x35, 0xc9, 0x34, 0x02, 0x84, 0x92, 0x36, 0xc3, 0xfa, 0xb4, 0xd2, 0x7c, 0x70, 0x26, + 0xc1, 0xd4, 0xdc, 0xb2, 0x60, 0x26, 0x46, 0xde, 0xc9, 0x75, 0x1e, 0x76, 0x3d, 0xba, 0x37, 0xbd, + 0xf8, 0xff, 0x94, 0x06, 0xad, 0x9e, 0x53, 0x0e, 0xe5, 0xdb, 0x38, 0x2f, 0x41, 0x30, 0x01, 0xae, + 0xb0, 0x6a, 0x53, 0xed, 0x90, 0x27, 0xd8, 0x31, 0x17, 0x97, 0x27, 0xb0, 0x86, 0x5a, 0x89, 0x18, + 0xda, 0x3e, 0xdb, 0xeb, 0xcf, 0x9b, 0x14, 0xed, 0x44, 0xce, 0x6c, 0xba, 0xce, 0xd4, 0xbb, 0x1b, + 0xdb, 0x7f, 0x14, 0x47, 0xe6, 0xcc, 0x25, 0x4b, 0x33, 0x20, 0x51, 0x51, 0x2b, 0xd7, 0xaf, 0x42, + 0x6f, 0xb8, 0xf4, 0x01, 0x37, 0x8c, 0xd2, 0xbf, 0x59, 0x83, 0xca, 0x01, 0xc6, 0x4b, 0x92, 0xec, + 0xf0, 0x32, 0xea, 0x15, 0xd1, 0x72, 0x1d, 0x03, 0xf4, 0x82, 0xd7, 0xce, 0x6e, 0x74, 0xfe, 0xf6, + 0xd5, 0x5e, 0x70, 0x2f, 0x46, 0x98, 0x0c, 0x82, 0xb5, 0xa8, 0x40, 0x31, 0x90, 0x0b, 0x1c, 0x9e, + 0x59, 0xe7, 0xc9, 0x7f, 0xbe, 0xc7, 0xe8, 0xf3, 0x23, 0xa9, 0x7a, 0x7e, 0x36, 0xcc, 0x88, 0xbe, + 0x0f, 0x1d, 0x45, 0xb7, 0xff, 0x58, 0x5a, 0xc5, 0x4b, 0xd4, 0x07, 0xb2, 0x2b, 0x41, 0x54, 0xaa, + 0xcc, 0x8f, 0x6d, 0x7e, 0xbf, 0x48, 0xe1, 0xd8, 0x14, 0xcc, 0x5e, 0xd2, 0x0f, 0x80, 0x37, 0xe0, + 0xa7, 0x97, 0x15, 0xee, 0xf2, 0x9b, 0xe3, 0x28, 0x06, 0xa1, 0xd5, 0x8b, 0xb7, 0xc5, 0xda, 0x76, + 0xf5, 0x50, 0xaa, 0x3d, 0x8a, 0x1f, 0xbf, 0xf0, 0xeb, 0x19, 0xcc, 0xb1, 0xa3, 0x13, 0xd5, 0x5c, + 0xda, 0x56, 0xc9, 0xec, 0x2e, 0xf2, 0x96, 0x32, 0x38, 0x7f, 0xe8, 0xd7, 0x6e, 0x3c, 0x04, 0x68, + 0x04, 0x3e, 0x8f, 0x66, 0x3f, 0x48, 0x60, 0xee, 0x12, 0xbf, 0x2d, 0x5b, 0x0b, 0x74, 0x74, 0xd6, + 0xe6, 0x94, 0xf9, 0x1e, 0x6d, 0xcc, 0x40, 0x24, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, +}; + +static const unsigned char scr_dh_modp18_p[1024] = { + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc9, 0x0f, 0xda, 0xa2, 0x21, 0x68, 0xc2, 0x34, + 0xc4, 0xc6, 0x62, 0x8b, 0x80, 0xdc, 0x1c, 0xd1, 0x29, 0x02, 0x4e, 0x08, 0x8a, 0x67, 0xcc, 0x74, + 0x02, 0x0b, 0xbe, 0xa6, 0x3b, 0x13, 0x9b, 0x22, 0x51, 0x4a, 0x08, 0x79, 0x8e, 0x34, 0x04, 0xdd, + 0xef, 0x95, 0x19, 0xb3, 0xcd, 0x3a, 0x43, 0x1b, 0x30, 0x2b, 0x0a, 0x6d, 0xf2, 0x5f, 0x14, 0x37, + 0x4f, 0xe1, 0x35, 0x6d, 0x6d, 0x51, 0xc2, 0x45, 0xe4, 0x85, 0xb5, 0x76, 0x62, 0x5e, 0x7e, 0xc6, + 0xf4, 0x4c, 0x42, 0xe9, 0xa6, 0x37, 0xed, 0x6b, 0x0b, 0xff, 0x5c, 0xb6, 0xf4, 0x06, 0xb7, 0xed, + 0xee, 0x38, 0x6b, 0xfb, 0x5a, 0x89, 0x9f, 0xa5, 0xae, 0x9f, 0x24, 0x11, 0x7c, 0x4b, 0x1f, 0xe6, + 0x49, 0x28, 0x66, 0x51, 0xec, 0xe4, 0x5b, 0x3d, 0xc2, 0x00, 0x7c, 0xb8, 0xa1, 0x63, 0xbf, 0x05, + 0x98, 0xda, 0x48, 0x36, 0x1c, 0x55, 0xd3, 0x9a, 0x69, 0x16, 0x3f, 0xa8, 0xfd, 0x24, 0xcf, 0x5f, + 0x83, 0x65, 0x5d, 0x23, 0xdc, 0xa3, 0xad, 0x96, 0x1c, 0x62, 0xf3, 0x56, 0x20, 0x85, 0x52, 0xbb, + 0x9e, 0xd5, 0x29, 0x07, 0x70, 0x96, 0x96, 0x6d, 0x67, 0x0c, 0x35, 0x4e, 0x4a, 0xbc, 0x98, 0x04, + 0xf1, 0x74, 0x6c, 0x08, 0xca, 0x18, 0x21, 0x7c, 0x32, 0x90, 0x5e, 0x46, 0x2e, 0x36, 0xce, 0x3b, + 0xe3, 0x9e, 0x77, 0x2c, 0x18, 0x0e, 0x86, 0x03, 0x9b, 0x27, 0x83, 0xa2, 0xec, 0x07, 0xa2, 0x8f, + 0xb5, 0xc5, 0x5d, 0xf0, 0x6f, 0x4c, 0x52, 0xc9, 0xde, 0x2b, 0xcb, 0xf6, 0x95, 0x58, 0x17, 0x18, + 0x39, 0x95, 0x49, 0x7c, 0xea, 0x95, 0x6a, 0xe5, 0x15, 0xd2, 0x26, 0x18, 0x98, 0xfa, 0x05, 0x10, + 0x15, 0x72, 0x8e, 0x5a, 0x8a, 0xaa, 0xc4, 0x2d, 0xad, 0x33, 0x17, 0x0d, 0x04, 0x50, 0x7a, 0x33, + 0xa8, 0x55, 0x21, 0xab, 0xdf, 0x1c, 0xba, 0x64, 0xec, 0xfb, 0x85, 0x04, 0x58, 0xdb, 0xef, 0x0a, + 0x8a, 0xea, 0x71, 0x57, 0x5d, 0x06, 0x0c, 0x7d, 0xb3, 0x97, 0x0f, 0x85, 0xa6, 0xe1, 0xe4, 0xc7, + 0xab, 0xf5, 0xae, 0x8c, 0xdb, 0x09, 0x33, 0xd7, 0x1e, 0x8c, 0x94, 0xe0, 0x4a, 0x25, 0x61, 0x9d, + 0xce, 0xe3, 0xd2, 0x26, 0x1a, 0xd2, 0xee, 0x6b, 0xf1, 0x2f, 0xfa, 0x06, 0xd9, 0x8a, 0x08, 0x64, + 0xd8, 0x76, 0x02, 0x73, 0x3e, 0xc8, 0x6a, 0x64, 0x52, 0x1f, 0x2b, 0x18, 0x17, 0x7b, 0x20, 0x0c, + 0xbb, 0xe1, 0x17, 0x57, 0x7a, 0x61, 0x5d, 0x6c, 0x77, 0x09, 0x88, 0xc0, 0xba, 0xd9, 0x46, 0xe2, + 0x08, 0xe2, 0x4f, 0xa0, 0x74, 0xe5, 0xab, 0x31, 0x43, 0xdb, 0x5b, 0xfc, 0xe0, 0xfd, 0x10, 0x8e, + 0x4b, 0x82, 0xd1, 0x20, 0xa9, 0x21, 0x08, 0x01, 0x1a, 0x72, 0x3c, 0x12, 0xa7, 0x87, 0xe6, 0xd7, + 0x88, 0x71, 0x9a, 0x10, 0xbd, 0xba, 0x5b, 0x26, 0x99, 0xc3, 0x27, 0x18, 0x6a, 0xf4, 0xe2, 0x3c, + 0x1a, 0x94, 0x68, 0x34, 0xb6, 0x15, 0x0b, 0xda, 0x25, 0x83, 0xe9, 0xca, 0x2a, 0xd4, 0x4c, 0xe8, + 0xdb, 0xbb, 0xc2, 0xdb, 0x04, 0xde, 0x8e, 0xf9, 0x2e, 0x8e, 0xfc, 0x14, 0x1f, 0xbe, 0xca, 0xa6, + 0x28, 0x7c, 0x59, 0x47, 0x4e, 0x6b, 0xc0, 0x5d, 0x99, 0xb2, 0x96, 0x4f, 0xa0, 0x90, 0xc3, 0xa2, + 0x23, 0x3b, 0xa1, 0x86, 0x51, 0x5b, 0xe7, 0xed, 0x1f, 0x61, 0x29, 0x70, 0xce, 0xe2, 0xd7, 0xaf, + 0xb8, 0x1b, 0xdd, 0x76, 0x21, 0x70, 0x48, 0x1c, 0xd0, 0x06, 0x91, 0x27, 0xd5, 0xb0, 0x5a, 0xa9, + 0x93, 0xb4, 0xea, 0x98, 0x8d, 0x8f, 0xdd, 0xc1, 0x86, 0xff, 0xb7, 0xdc, 0x90, 0xa6, 0xc0, 0x8f, + 0x4d, 0xf4, 0x35, 0xc9, 0x34, 0x02, 0x84, 0x92, 0x36, 0xc3, 0xfa, 0xb4, 0xd2, 0x7c, 0x70, 0x26, + 0xc1, 0xd4, 0xdc, 0xb2, 0x60, 0x26, 0x46, 0xde, 0xc9, 0x75, 0x1e, 0x76, 0x3d, 0xba, 0x37, 0xbd, + 0xf8, 0xff, 0x94, 0x06, 0xad, 0x9e, 0x53, 0x0e, 0xe5, 0xdb, 0x38, 0x2f, 0x41, 0x30, 0x01, 0xae, + 0xb0, 0x6a, 0x53, 0xed, 0x90, 0x27, 0xd8, 0x31, 0x17, 0x97, 0x27, 0xb0, 0x86, 0x5a, 0x89, 0x18, + 0xda, 0x3e, 0xdb, 0xeb, 0xcf, 0x9b, 0x14, 0xed, 0x44, 0xce, 0x6c, 0xba, 0xce, 0xd4, 0xbb, 0x1b, + 0xdb, 0x7f, 0x14, 0x47, 0xe6, 0xcc, 0x25, 0x4b, 0x33, 0x20, 0x51, 0x51, 0x2b, 0xd7, 0xaf, 0x42, + 0x6f, 0xb8, 0xf4, 0x01, 0x37, 0x8c, 0xd2, 0xbf, 0x59, 0x83, 0xca, 0x01, 0xc6, 0x4b, 0x92, 0xec, + 0xf0, 0x32, 0xea, 0x15, 0xd1, 0x72, 0x1d, 0x03, 0xf4, 0x82, 0xd7, 0xce, 0x6e, 0x74, 0xfe, 0xf6, + 0xd5, 0x5e, 0x70, 0x2f, 0x46, 0x98, 0x0c, 0x82, 0xb5, 0xa8, 0x40, 0x31, 0x90, 0x0b, 0x1c, 0x9e, + 0x59, 0xe7, 0xc9, 0x7f, 0xbe, 0xc7, 0xe8, 0xf3, 0x23, 0xa9, 0x7a, 0x7e, 0x36, 0xcc, 0x88, 0xbe, + 0x0f, 0x1d, 0x45, 0xb7, 0xff, 0x58, 0x5a, 0xc5, 0x4b, 0xd4, 0x07, 0xb2, 0x2b, 0x41, 0x54, 0xaa, + 0xcc, 0x8f, 0x6d, 0x7e, 0xbf, 0x48, 0xe1, 0xd8, 0x14, 0xcc, 0x5e, 0xd2, 0x0f, 0x80, 0x37, 0xe0, + 0xa7, 0x97, 0x15, 0xee, 0xf2, 0x9b, 0xe3, 0x28, 0x06, 0xa1, 0xd5, 0x8b, 0xb7, 0xc5, 0xda, 0x76, + 0xf5, 0x50, 0xaa, 0x3d, 0x8a, 0x1f, 0xbf, 0xf0, 0xeb, 0x19, 0xcc, 0xb1, 0xa3, 0x13, 0xd5, 0x5c, + 0xda, 0x56, 0xc9, 0xec, 0x2e, 0xf2, 0x96, 0x32, 0x38, 0x7f, 0xe8, 0xd7, 0x6e, 0x3c, 0x04, 0x68, + 0x04, 0x3e, 0x8f, 0x66, 0x3f, 0x48, 0x60, 0xee, 0x12, 0xbf, 0x2d, 0x5b, 0x0b, 0x74, 0x74, 0xd6, + 0xe6, 0x94, 0xf9, 0x1e, 0x6d, 0xbe, 0x11, 0x59, 0x74, 0xa3, 0x92, 0x6f, 0x12, 0xfe, 0xe5, 0xe4, + 0x38, 0x77, 0x7c, 0xb6, 0xa9, 0x32, 0xdf, 0x8c, 0xd8, 0xbe, 0xc4, 0xd0, 0x73, 0xb9, 0x31, 0xba, + 0x3b, 0xc8, 0x32, 0xb6, 0x8d, 0x9d, 0xd3, 0x00, 0x74, 0x1f, 0xa7, 0xbf, 0x8a, 0xfc, 0x47, 0xed, + 0x25, 0x76, 0xf6, 0x93, 0x6b, 0xa4, 0x24, 0x66, 0x3a, 0xab, 0x63, 0x9c, 0x5a, 0xe4, 0xf5, 0x68, + 0x34, 0x23, 0xb4, 0x74, 0x2b, 0xf1, 0xc9, 0x78, 0x23, 0x8f, 0x16, 0xcb, 0xe3, 0x9d, 0x65, 0x2d, + 0xe3, 0xfd, 0xb8, 0xbe, 0xfc, 0x84, 0x8a, 0xd9, 0x22, 0x22, 0x2e, 0x04, 0xa4, 0x03, 0x7c, 0x07, + 0x13, 0xeb, 0x57, 0xa8, 0x1a, 0x23, 0xf0, 0xc7, 0x34, 0x73, 0xfc, 0x64, 0x6c, 0xea, 0x30, 0x6b, + 0x4b, 0xcb, 0xc8, 0x86, 0x2f, 0x83, 0x85, 0xdd, 0xfa, 0x9d, 0x4b, 0x7f, 0xa2, 0xc0, 0x87, 0xe8, + 0x79, 0x68, 0x33, 0x03, 0xed, 0x5b, 0xdd, 0x3a, 0x06, 0x2b, 0x3c, 0xf5, 0xb3, 0xa2, 0x78, 0xa6, + 0x6d, 0x2a, 0x13, 0xf8, 0x3f, 0x44, 0xf8, 0x2d, 0xdf, 0x31, 0x0e, 0xe0, 0x74, 0xab, 0x6a, 0x36, + 0x45, 0x97, 0xe8, 0x99, 0xa0, 0x25, 0x5d, 0xc1, 0x64, 0xf3, 0x1c, 0xc5, 0x08, 0x46, 0x85, 0x1d, + 0xf9, 0xab, 0x48, 0x19, 0x5d, 0xed, 0x7e, 0xa1, 0xb1, 0xd5, 0x10, 0xbd, 0x7e, 0xe7, 0x4d, 0x73, + 0xfa, 0xf3, 0x6b, 0xc3, 0x1e, 0xcf, 0xa2, 0x68, 0x35, 0x90, 0x46, 0xf4, 0xeb, 0x87, 0x9f, 0x92, + 0x40, 0x09, 0x43, 0x8b, 0x48, 0x1c, 0x6c, 0xd7, 0x88, 0x9a, 0x00, 0x2e, 0xd5, 0xee, 0x38, 0x2b, + 0xc9, 0x19, 0x0d, 0xa6, 0xfc, 0x02, 0x6e, 0x47, 0x95, 0x58, 0xe4, 0x47, 0x56, 0x77, 0xe9, 0xaa, + 0x9e, 0x30, 0x50, 0xe2, 0x76, 0x56, 0x94, 0xdf, 0xc8, 0x1f, 0x56, 0xe8, 0x80, 0xb9, 0x6e, 0x71, + 0x60, 0xc9, 0x80, 0xdd, 0x98, 0xed, 0xd3, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, +}; + +static const unsigned char scr_dh_ffdhe2048_p[256] = { + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xad, 0xf8, 0x54, 0x58, 0xa2, 0xbb, 0x4a, 0x9a, + 0xaf, 0xdc, 0x56, 0x20, 0x27, 0x3d, 0x3c, 0xf1, 0xd8, 0xb9, 0xc5, 0x83, 0xce, 0x2d, 0x36, 0x95, + 0xa9, 0xe1, 0x36, 0x41, 0x14, 0x64, 0x33, 0xfb, 0xcc, 0x93, 0x9d, 0xce, 0x24, 0x9b, 0x3e, 0xf9, + 0x7d, 0x2f, 0xe3, 0x63, 0x63, 0x0c, 0x75, 0xd8, 0xf6, 0x81, 0xb2, 0x02, 0xae, 0xc4, 0x61, 0x7a, + 0xd3, 0xdf, 0x1e, 0xd5, 0xd5, 0xfd, 0x65, 0x61, 0x24, 0x33, 0xf5, 0x1f, 0x5f, 0x06, 0x6e, 0xd0, + 0x85, 0x63, 0x65, 0x55, 0x3d, 0xed, 0x1a, 0xf3, 0xb5, 0x57, 0x13, 0x5e, 0x7f, 0x57, 0xc9, 0x35, + 0x98, 0x4f, 0x0c, 0x70, 0xe0, 0xe6, 0x8b, 0x77, 0xe2, 0xa6, 0x89, 0xda, 0xf3, 0xef, 0xe8, 0x72, + 0x1d, 0xf1, 0x58, 0xa1, 0x36, 0xad, 0xe7, 0x35, 0x30, 0xac, 0xca, 0x4f, 0x48, 0x3a, 0x79, 0x7a, + 0xbc, 0x0a, 0xb1, 0x82, 0xb3, 0x24, 0xfb, 0x61, 0xd1, 0x08, 0xa9, 0x4b, 0xb2, 0xc8, 0xe3, 0xfb, + 0xb9, 0x6a, 0xda, 0xb7, 0x60, 0xd7, 0xf4, 0x68, 0x1d, 0x4f, 0x42, 0xa3, 0xde, 0x39, 0x4d, 0xf4, + 0xae, 0x56, 0xed, 0xe7, 0x63, 0x72, 0xbb, 0x19, 0x0b, 0x07, 0xa7, 0xc8, 0xee, 0x0a, 0x6d, 0x70, + 0x9e, 0x02, 0xfc, 0xe1, 0xcd, 0xf7, 0xe2, 0xec, 0xc0, 0x34, 0x04, 0xcd, 0x28, 0x34, 0x2f, 0x61, + 0x91, 0x72, 0xfe, 0x9c, 0xe9, 0x85, 0x83, 0xff, 0x8e, 0x4f, 0x12, 0x32, 0xee, 0xf2, 0x81, 0x83, + 0xc3, 0xfe, 0x3b, 0x1b, 0x4c, 0x6f, 0xad, 0x73, 0x3b, 0xb5, 0xfc, 0xbc, 0x2e, 0xc2, 0x20, 0x05, + 0xc5, 0x8e, 0xf1, 0x83, 0x7d, 0x16, 0x83, 0xb2, 0xc6, 0xf3, 0x4a, 0x26, 0xc1, 0xb2, 0xef, 0xfa, + 0x88, 0x6b, 0x42, 0x38, 0x61, 0x28, 0x5c, 0x97, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, +}; + +static const unsigned char scr_dh_ffdhe3072_p[384] = { + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xad, 0xf8, 0x54, 0x58, 0xa2, 0xbb, 0x4a, 0x9a, + 0xaf, 0xdc, 0x56, 0x20, 0x27, 0x3d, 0x3c, 0xf1, 0xd8, 0xb9, 0xc5, 0x83, 0xce, 0x2d, 0x36, 0x95, + 0xa9, 0xe1, 0x36, 0x41, 0x14, 0x64, 0x33, 0xfb, 0xcc, 0x93, 0x9d, 0xce, 0x24, 0x9b, 0x3e, 0xf9, + 0x7d, 0x2f, 0xe3, 0x63, 0x63, 0x0c, 0x75, 0xd8, 0xf6, 0x81, 0xb2, 0x02, 0xae, 0xc4, 0x61, 0x7a, + 0xd3, 0xdf, 0x1e, 0xd5, 0xd5, 0xfd, 0x65, 0x61, 0x24, 0x33, 0xf5, 0x1f, 0x5f, 0x06, 0x6e, 0xd0, + 0x85, 0x63, 0x65, 0x55, 0x3d, 0xed, 0x1a, 0xf3, 0xb5, 0x57, 0x13, 0x5e, 0x7f, 0x57, 0xc9, 0x35, + 0x98, 0x4f, 0x0c, 0x70, 0xe0, 0xe6, 0x8b, 0x77, 0xe2, 0xa6, 0x89, 0xda, 0xf3, 0xef, 0xe8, 0x72, + 0x1d, 0xf1, 0x58, 0xa1, 0x36, 0xad, 0xe7, 0x35, 0x30, 0xac, 0xca, 0x4f, 0x48, 0x3a, 0x79, 0x7a, + 0xbc, 0x0a, 0xb1, 0x82, 0xb3, 0x24, 0xfb, 0x61, 0xd1, 0x08, 0xa9, 0x4b, 0xb2, 0xc8, 0xe3, 0xfb, + 0xb9, 0x6a, 0xda, 0xb7, 0x60, 0xd7, 0xf4, 0x68, 0x1d, 0x4f, 0x42, 0xa3, 0xde, 0x39, 0x4d, 0xf4, + 0xae, 0x56, 0xed, 0xe7, 0x63, 0x72, 0xbb, 0x19, 0x0b, 0x07, 0xa7, 0xc8, 0xee, 0x0a, 0x6d, 0x70, + 0x9e, 0x02, 0xfc, 0xe1, 0xcd, 0xf7, 0xe2, 0xec, 0xc0, 0x34, 0x04, 0xcd, 0x28, 0x34, 0x2f, 0x61, + 0x91, 0x72, 0xfe, 0x9c, 0xe9, 0x85, 0x83, 0xff, 0x8e, 0x4f, 0x12, 0x32, 0xee, 0xf2, 0x81, 0x83, + 0xc3, 0xfe, 0x3b, 0x1b, 0x4c, 0x6f, 0xad, 0x73, 0x3b, 0xb5, 0xfc, 0xbc, 0x2e, 0xc2, 0x20, 0x05, + 0xc5, 0x8e, 0xf1, 0x83, 0x7d, 0x16, 0x83, 0xb2, 0xc6, 0xf3, 0x4a, 0x26, 0xc1, 0xb2, 0xef, 0xfa, + 0x88, 0x6b, 0x42, 0x38, 0x61, 0x1f, 0xcf, 0xdc, 0xde, 0x35, 0x5b, 0x3b, 0x65, 0x19, 0x03, 0x5b, + 0xbc, 0x34, 0xf4, 0xde, 0xf9, 0x9c, 0x02, 0x38, 0x61, 0xb4, 0x6f, 0xc9, 0xd6, 0xe6, 0xc9, 0x07, + 0x7a, 0xd9, 0x1d, 0x26, 0x91, 0xf7, 0xf7, 0xee, 0x59, 0x8c, 0xb0, 0xfa, 0xc1, 0x86, 0xd9, 0x1c, + 0xae, 0xfe, 0x13, 0x09, 0x85, 0x13, 0x92, 0x70, 0xb4, 0x13, 0x0c, 0x93, 0xbc, 0x43, 0x79, 0x44, + 0xf4, 0xfd, 0x44, 0x52, 0xe2, 0xd7, 0x4d, 0xd3, 0x64, 0xf2, 0xe2, 0x1e, 0x71, 0xf5, 0x4b, 0xff, + 0x5c, 0xae, 0x82, 0xab, 0x9c, 0x9d, 0xf6, 0x9e, 0xe8, 0x6d, 0x2b, 0xc5, 0x22, 0x36, 0x3a, 0x0d, + 0xab, 0xc5, 0x21, 0x97, 0x9b, 0x0d, 0xea, 0xda, 0x1d, 0xbf, 0x9a, 0x42, 0xd5, 0xc4, 0x48, 0x4e, + 0x0a, 0xbc, 0xd0, 0x6b, 0xfa, 0x53, 0xdd, 0xef, 0x3c, 0x1b, 0x20, 0xee, 0x3f, 0xd5, 0x9d, 0x7c, + 0x25, 0xe4, 0x1d, 0x2b, 0x66, 0xc6, 0x2e, 0x37, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, +}; + +static const unsigned char scr_dh_ffdhe4096_p[512] = { + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xad, 0xf8, 0x54, 0x58, 0xa2, 0xbb, 0x4a, 0x9a, + 0xaf, 0xdc, 0x56, 0x20, 0x27, 0x3d, 0x3c, 0xf1, 0xd8, 0xb9, 0xc5, 0x83, 0xce, 0x2d, 0x36, 0x95, + 0xa9, 0xe1, 0x36, 0x41, 0x14, 0x64, 0x33, 0xfb, 0xcc, 0x93, 0x9d, 0xce, 0x24, 0x9b, 0x3e, 0xf9, + 0x7d, 0x2f, 0xe3, 0x63, 0x63, 0x0c, 0x75, 0xd8, 0xf6, 0x81, 0xb2, 0x02, 0xae, 0xc4, 0x61, 0x7a, + 0xd3, 0xdf, 0x1e, 0xd5, 0xd5, 0xfd, 0x65, 0x61, 0x24, 0x33, 0xf5, 0x1f, 0x5f, 0x06, 0x6e, 0xd0, + 0x85, 0x63, 0x65, 0x55, 0x3d, 0xed, 0x1a, 0xf3, 0xb5, 0x57, 0x13, 0x5e, 0x7f, 0x57, 0xc9, 0x35, + 0x98, 0x4f, 0x0c, 0x70, 0xe0, 0xe6, 0x8b, 0x77, 0xe2, 0xa6, 0x89, 0xda, 0xf3, 0xef, 0xe8, 0x72, + 0x1d, 0xf1, 0x58, 0xa1, 0x36, 0xad, 0xe7, 0x35, 0x30, 0xac, 0xca, 0x4f, 0x48, 0x3a, 0x79, 0x7a, + 0xbc, 0x0a, 0xb1, 0x82, 0xb3, 0x24, 0xfb, 0x61, 0xd1, 0x08, 0xa9, 0x4b, 0xb2, 0xc8, 0xe3, 0xfb, + 0xb9, 0x6a, 0xda, 0xb7, 0x60, 0xd7, 0xf4, 0x68, 0x1d, 0x4f, 0x42, 0xa3, 0xde, 0x39, 0x4d, 0xf4, + 0xae, 0x56, 0xed, 0xe7, 0x63, 0x72, 0xbb, 0x19, 0x0b, 0x07, 0xa7, 0xc8, 0xee, 0x0a, 0x6d, 0x70, + 0x9e, 0x02, 0xfc, 0xe1, 0xcd, 0xf7, 0xe2, 0xec, 0xc0, 0x34, 0x04, 0xcd, 0x28, 0x34, 0x2f, 0x61, + 0x91, 0x72, 0xfe, 0x9c, 0xe9, 0x85, 0x83, 0xff, 0x8e, 0x4f, 0x12, 0x32, 0xee, 0xf2, 0x81, 0x83, + 0xc3, 0xfe, 0x3b, 0x1b, 0x4c, 0x6f, 0xad, 0x73, 0x3b, 0xb5, 0xfc, 0xbc, 0x2e, 0xc2, 0x20, 0x05, + 0xc5, 0x8e, 0xf1, 0x83, 0x7d, 0x16, 0x83, 0xb2, 0xc6, 0xf3, 0x4a, 0x26, 0xc1, 0xb2, 0xef, 0xfa, + 0x88, 0x6b, 0x42, 0x38, 0x61, 0x1f, 0xcf, 0xdc, 0xde, 0x35, 0x5b, 0x3b, 0x65, 0x19, 0x03, 0x5b, + 0xbc, 0x34, 0xf4, 0xde, 0xf9, 0x9c, 0x02, 0x38, 0x61, 0xb4, 0x6f, 0xc9, 0xd6, 0xe6, 0xc9, 0x07, + 0x7a, 0xd9, 0x1d, 0x26, 0x91, 0xf7, 0xf7, 0xee, 0x59, 0x8c, 0xb0, 0xfa, 0xc1, 0x86, 0xd9, 0x1c, + 0xae, 0xfe, 0x13, 0x09, 0x85, 0x13, 0x92, 0x70, 0xb4, 0x13, 0x0c, 0x93, 0xbc, 0x43, 0x79, 0x44, + 0xf4, 0xfd, 0x44, 0x52, 0xe2, 0xd7, 0x4d, 0xd3, 0x64, 0xf2, 0xe2, 0x1e, 0x71, 0xf5, 0x4b, 0xff, + 0x5c, 0xae, 0x82, 0xab, 0x9c, 0x9d, 0xf6, 0x9e, 0xe8, 0x6d, 0x2b, 0xc5, 0x22, 0x36, 0x3a, 0x0d, + 0xab, 0xc5, 0x21, 0x97, 0x9b, 0x0d, 0xea, 0xda, 0x1d, 0xbf, 0x9a, 0x42, 0xd5, 0xc4, 0x48, 0x4e, + 0x0a, 0xbc, 0xd0, 0x6b, 0xfa, 0x53, 0xdd, 0xef, 0x3c, 0x1b, 0x20, 0xee, 0x3f, 0xd5, 0x9d, 0x7c, + 0x25, 0xe4, 0x1d, 0x2b, 0x66, 0x9e, 0x1e, 0xf1, 0x6e, 0x6f, 0x52, 0xc3, 0x16, 0x4d, 0xf4, 0xfb, + 0x79, 0x30, 0xe9, 0xe4, 0xe5, 0x88, 0x57, 0xb6, 0xac, 0x7d, 0x5f, 0x42, 0xd6, 0x9f, 0x6d, 0x18, + 0x77, 0x63, 0xcf, 0x1d, 0x55, 0x03, 0x40, 0x04, 0x87, 0xf5, 0x5b, 0xa5, 0x7e, 0x31, 0xcc, 0x7a, + 0x71, 0x35, 0xc8, 0x86, 0xef, 0xb4, 0x31, 0x8a, 0xed, 0x6a, 0x1e, 0x01, 0x2d, 0x9e, 0x68, 0x32, + 0xa9, 0x07, 0x60, 0x0a, 0x91, 0x81, 0x30, 0xc4, 0x6d, 0xc7, 0x78, 0xf9, 0x71, 0xad, 0x00, 0x38, + 0x09, 0x29, 0x99, 0xa3, 0x33, 0xcb, 0x8b, 0x7a, 0x1a, 0x1d, 0xb9, 0x3d, 0x71, 0x40, 0x00, 0x3c, + 0x2a, 0x4e, 0xce, 0xa9, 0xf9, 0x8d, 0x0a, 0xcc, 0x0a, 0x82, 0x91, 0xcd, 0xce, 0xc9, 0x7d, 0xcf, + 0x8e, 0xc9, 0xb5, 0x5a, 0x7f, 0x88, 0xa4, 0x6b, 0x4d, 0xb5, 0xa8, 0x51, 0xf4, 0x41, 0x82, 0xe1, + 0xc6, 0x8a, 0x00, 0x7e, 0x5e, 0x65, 0x5f, 0x6a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, +}; + +static const unsigned char scr_dh_ffdhe6144_p[768] = { + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xad, 0xf8, 0x54, 0x58, 0xa2, 0xbb, 0x4a, 0x9a, + 0xaf, 0xdc, 0x56, 0x20, 0x27, 0x3d, 0x3c, 0xf1, 0xd8, 0xb9, 0xc5, 0x83, 0xce, 0x2d, 0x36, 0x95, + 0xa9, 0xe1, 0x36, 0x41, 0x14, 0x64, 0x33, 0xfb, 0xcc, 0x93, 0x9d, 0xce, 0x24, 0x9b, 0x3e, 0xf9, + 0x7d, 0x2f, 0xe3, 0x63, 0x63, 0x0c, 0x75, 0xd8, 0xf6, 0x81, 0xb2, 0x02, 0xae, 0xc4, 0x61, 0x7a, + 0xd3, 0xdf, 0x1e, 0xd5, 0xd5, 0xfd, 0x65, 0x61, 0x24, 0x33, 0xf5, 0x1f, 0x5f, 0x06, 0x6e, 0xd0, + 0x85, 0x63, 0x65, 0x55, 0x3d, 0xed, 0x1a, 0xf3, 0xb5, 0x57, 0x13, 0x5e, 0x7f, 0x57, 0xc9, 0x35, + 0x98, 0x4f, 0x0c, 0x70, 0xe0, 0xe6, 0x8b, 0x77, 0xe2, 0xa6, 0x89, 0xda, 0xf3, 0xef, 0xe8, 0x72, + 0x1d, 0xf1, 0x58, 0xa1, 0x36, 0xad, 0xe7, 0x35, 0x30, 0xac, 0xca, 0x4f, 0x48, 0x3a, 0x79, 0x7a, + 0xbc, 0x0a, 0xb1, 0x82, 0xb3, 0x24, 0xfb, 0x61, 0xd1, 0x08, 0xa9, 0x4b, 0xb2, 0xc8, 0xe3, 0xfb, + 0xb9, 0x6a, 0xda, 0xb7, 0x60, 0xd7, 0xf4, 0x68, 0x1d, 0x4f, 0x42, 0xa3, 0xde, 0x39, 0x4d, 0xf4, + 0xae, 0x56, 0xed, 0xe7, 0x63, 0x72, 0xbb, 0x19, 0x0b, 0x07, 0xa7, 0xc8, 0xee, 0x0a, 0x6d, 0x70, + 0x9e, 0x02, 0xfc, 0xe1, 0xcd, 0xf7, 0xe2, 0xec, 0xc0, 0x34, 0x04, 0xcd, 0x28, 0x34, 0x2f, 0x61, + 0x91, 0x72, 0xfe, 0x9c, 0xe9, 0x85, 0x83, 0xff, 0x8e, 0x4f, 0x12, 0x32, 0xee, 0xf2, 0x81, 0x83, + 0xc3, 0xfe, 0x3b, 0x1b, 0x4c, 0x6f, 0xad, 0x73, 0x3b, 0xb5, 0xfc, 0xbc, 0x2e, 0xc2, 0x20, 0x05, + 0xc5, 0x8e, 0xf1, 0x83, 0x7d, 0x16, 0x83, 0xb2, 0xc6, 0xf3, 0x4a, 0x26, 0xc1, 0xb2, 0xef, 0xfa, + 0x88, 0x6b, 0x42, 0x38, 0x61, 0x1f, 0xcf, 0xdc, 0xde, 0x35, 0x5b, 0x3b, 0x65, 0x19, 0x03, 0x5b, + 0xbc, 0x34, 0xf4, 0xde, 0xf9, 0x9c, 0x02, 0x38, 0x61, 0xb4, 0x6f, 0xc9, 0xd6, 0xe6, 0xc9, 0x07, + 0x7a, 0xd9, 0x1d, 0x26, 0x91, 0xf7, 0xf7, 0xee, 0x59, 0x8c, 0xb0, 0xfa, 0xc1, 0x86, 0xd9, 0x1c, + 0xae, 0xfe, 0x13, 0x09, 0x85, 0x13, 0x92, 0x70, 0xb4, 0x13, 0x0c, 0x93, 0xbc, 0x43, 0x79, 0x44, + 0xf4, 0xfd, 0x44, 0x52, 0xe2, 0xd7, 0x4d, 0xd3, 0x64, 0xf2, 0xe2, 0x1e, 0x71, 0xf5, 0x4b, 0xff, + 0x5c, 0xae, 0x82, 0xab, 0x9c, 0x9d, 0xf6, 0x9e, 0xe8, 0x6d, 0x2b, 0xc5, 0x22, 0x36, 0x3a, 0x0d, + 0xab, 0xc5, 0x21, 0x97, 0x9b, 0x0d, 0xea, 0xda, 0x1d, 0xbf, 0x9a, 0x42, 0xd5, 0xc4, 0x48, 0x4e, + 0x0a, 0xbc, 0xd0, 0x6b, 0xfa, 0x53, 0xdd, 0xef, 0x3c, 0x1b, 0x20, 0xee, 0x3f, 0xd5, 0x9d, 0x7c, + 0x25, 0xe4, 0x1d, 0x2b, 0x66, 0x9e, 0x1e, 0xf1, 0x6e, 0x6f, 0x52, 0xc3, 0x16, 0x4d, 0xf4, 0xfb, + 0x79, 0x30, 0xe9, 0xe4, 0xe5, 0x88, 0x57, 0xb6, 0xac, 0x7d, 0x5f, 0x42, 0xd6, 0x9f, 0x6d, 0x18, + 0x77, 0x63, 0xcf, 0x1d, 0x55, 0x03, 0x40, 0x04, 0x87, 0xf5, 0x5b, 0xa5, 0x7e, 0x31, 0xcc, 0x7a, + 0x71, 0x35, 0xc8, 0x86, 0xef, 0xb4, 0x31, 0x8a, 0xed, 0x6a, 0x1e, 0x01, 0x2d, 0x9e, 0x68, 0x32, + 0xa9, 0x07, 0x60, 0x0a, 0x91, 0x81, 0x30, 0xc4, 0x6d, 0xc7, 0x78, 0xf9, 0x71, 0xad, 0x00, 0x38, + 0x09, 0x29, 0x99, 0xa3, 0x33, 0xcb, 0x8b, 0x7a, 0x1a, 0x1d, 0xb9, 0x3d, 0x71, 0x40, 0x00, 0x3c, + 0x2a, 0x4e, 0xce, 0xa9, 0xf9, 0x8d, 0x0a, 0xcc, 0x0a, 0x82, 0x91, 0xcd, 0xce, 0xc9, 0x7d, 0xcf, + 0x8e, 0xc9, 0xb5, 0x5a, 0x7f, 0x88, 0xa4, 0x6b, 0x4d, 0xb5, 0xa8, 0x51, 0xf4, 0x41, 0x82, 0xe1, + 0xc6, 0x8a, 0x00, 0x7e, 0x5e, 0x0d, 0xd9, 0x02, 0x0b, 0xfd, 0x64, 0xb6, 0x45, 0x03, 0x6c, 0x7a, + 0x4e, 0x67, 0x7d, 0x2c, 0x38, 0x53, 0x2a, 0x3a, 0x23, 0xba, 0x44, 0x42, 0xca, 0xf5, 0x3e, 0xa6, + 0x3b, 0xb4, 0x54, 0x32, 0x9b, 0x76, 0x24, 0xc8, 0x91, 0x7b, 0xdd, 0x64, 0xb1, 0xc0, 0xfd, 0x4c, + 0xb3, 0x8e, 0x8c, 0x33, 0x4c, 0x70, 0x1c, 0x3a, 0xcd, 0xad, 0x06, 0x57, 0xfc, 0xcf, 0xec, 0x71, + 0x9b, 0x1f, 0x5c, 0x3e, 0x4e, 0x46, 0x04, 0x1f, 0x38, 0x81, 0x47, 0xfb, 0x4c, 0xfd, 0xb4, 0x77, + 0xa5, 0x24, 0x71, 0xf7, 0xa9, 0xa9, 0x69, 0x10, 0xb8, 0x55, 0x32, 0x2e, 0xdb, 0x63, 0x40, 0xd8, + 0xa0, 0x0e, 0xf0, 0x92, 0x35, 0x05, 0x11, 0xe3, 0x0a, 0xbe, 0xc1, 0xff, 0xf9, 0xe3, 0xa2, 0x6e, + 0x7f, 0xb2, 0x9f, 0x8c, 0x18, 0x30, 0x23, 0xc3, 0x58, 0x7e, 0x38, 0xda, 0x00, 0x77, 0xd9, 0xb4, + 0x76, 0x3e, 0x4e, 0x4b, 0x94, 0xb2, 0xbb, 0xc1, 0x94, 0xc6, 0x65, 0x1e, 0x77, 0xca, 0xf9, 0x92, + 0xee, 0xaa, 0xc0, 0x23, 0x2a, 0x28, 0x1b, 0xf6, 0xb3, 0xa7, 0x39, 0xc1, 0x22, 0x61, 0x16, 0x82, + 0x0a, 0xe8, 0xdb, 0x58, 0x47, 0xa6, 0x7c, 0xbe, 0xf9, 0xc9, 0x09, 0x1b, 0x46, 0x2d, 0x53, 0x8c, + 0xd7, 0x2b, 0x03, 0x74, 0x6a, 0xe7, 0x7f, 0x5e, 0x62, 0x29, 0x2c, 0x31, 0x15, 0x62, 0xa8, 0x46, + 0x50, 0x5d, 0xc8, 0x2d, 0xb8, 0x54, 0x33, 0x8a, 0xe4, 0x9f, 0x52, 0x35, 0xc9, 0x5b, 0x91, 0x17, + 0x8c, 0xcf, 0x2d, 0xd5, 0xca, 0xce, 0xf4, 0x03, 0xec, 0x9d, 0x18, 0x10, 0xc6, 0x27, 0x2b, 0x04, + 0x5b, 0x3b, 0x71, 0xf9, 0xdc, 0x6b, 0x80, 0xd6, 0x3f, 0xdd, 0x4a, 0x8e, 0x9a, 0xdb, 0x1e, 0x69, + 0x62, 0xa6, 0x95, 0x26, 0xd4, 0x31, 0x61, 0xc1, 0xa4, 0x1d, 0x57, 0x0d, 0x79, 0x38, 0xda, 0xd4, + 0xa4, 0x0e, 0x32, 0x9c, 0xd0, 0xe4, 0x0e, 0x65, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, +}; + +static const unsigned char scr_dh_ffdhe8192_p[1024] = { + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xad, 0xf8, 0x54, 0x58, 0xa2, 0xbb, 0x4a, 0x9a, + 0xaf, 0xdc, 0x56, 0x20, 0x27, 0x3d, 0x3c, 0xf1, 0xd8, 0xb9, 0xc5, 0x83, 0xce, 0x2d, 0x36, 0x95, + 0xa9, 0xe1, 0x36, 0x41, 0x14, 0x64, 0x33, 0xfb, 0xcc, 0x93, 0x9d, 0xce, 0x24, 0x9b, 0x3e, 0xf9, + 0x7d, 0x2f, 0xe3, 0x63, 0x63, 0x0c, 0x75, 0xd8, 0xf6, 0x81, 0xb2, 0x02, 0xae, 0xc4, 0x61, 0x7a, + 0xd3, 0xdf, 0x1e, 0xd5, 0xd5, 0xfd, 0x65, 0x61, 0x24, 0x33, 0xf5, 0x1f, 0x5f, 0x06, 0x6e, 0xd0, + 0x85, 0x63, 0x65, 0x55, 0x3d, 0xed, 0x1a, 0xf3, 0xb5, 0x57, 0x13, 0x5e, 0x7f, 0x57, 0xc9, 0x35, + 0x98, 0x4f, 0x0c, 0x70, 0xe0, 0xe6, 0x8b, 0x77, 0xe2, 0xa6, 0x89, 0xda, 0xf3, 0xef, 0xe8, 0x72, + 0x1d, 0xf1, 0x58, 0xa1, 0x36, 0xad, 0xe7, 0x35, 0x30, 0xac, 0xca, 0x4f, 0x48, 0x3a, 0x79, 0x7a, + 0xbc, 0x0a, 0xb1, 0x82, 0xb3, 0x24, 0xfb, 0x61, 0xd1, 0x08, 0xa9, 0x4b, 0xb2, 0xc8, 0xe3, 0xfb, + 0xb9, 0x6a, 0xda, 0xb7, 0x60, 0xd7, 0xf4, 0x68, 0x1d, 0x4f, 0x42, 0xa3, 0xde, 0x39, 0x4d, 0xf4, + 0xae, 0x56, 0xed, 0xe7, 0x63, 0x72, 0xbb, 0x19, 0x0b, 0x07, 0xa7, 0xc8, 0xee, 0x0a, 0x6d, 0x70, + 0x9e, 0x02, 0xfc, 0xe1, 0xcd, 0xf7, 0xe2, 0xec, 0xc0, 0x34, 0x04, 0xcd, 0x28, 0x34, 0x2f, 0x61, + 0x91, 0x72, 0xfe, 0x9c, 0xe9, 0x85, 0x83, 0xff, 0x8e, 0x4f, 0x12, 0x32, 0xee, 0xf2, 0x81, 0x83, + 0xc3, 0xfe, 0x3b, 0x1b, 0x4c, 0x6f, 0xad, 0x73, 0x3b, 0xb5, 0xfc, 0xbc, 0x2e, 0xc2, 0x20, 0x05, + 0xc5, 0x8e, 0xf1, 0x83, 0x7d, 0x16, 0x83, 0xb2, 0xc6, 0xf3, 0x4a, 0x26, 0xc1, 0xb2, 0xef, 0xfa, + 0x88, 0x6b, 0x42, 0x38, 0x61, 0x1f, 0xcf, 0xdc, 0xde, 0x35, 0x5b, 0x3b, 0x65, 0x19, 0x03, 0x5b, + 0xbc, 0x34, 0xf4, 0xde, 0xf9, 0x9c, 0x02, 0x38, 0x61, 0xb4, 0x6f, 0xc9, 0xd6, 0xe6, 0xc9, 0x07, + 0x7a, 0xd9, 0x1d, 0x26, 0x91, 0xf7, 0xf7, 0xee, 0x59, 0x8c, 0xb0, 0xfa, 0xc1, 0x86, 0xd9, 0x1c, + 0xae, 0xfe, 0x13, 0x09, 0x85, 0x13, 0x92, 0x70, 0xb4, 0x13, 0x0c, 0x93, 0xbc, 0x43, 0x79, 0x44, + 0xf4, 0xfd, 0x44, 0x52, 0xe2, 0xd7, 0x4d, 0xd3, 0x64, 0xf2, 0xe2, 0x1e, 0x71, 0xf5, 0x4b, 0xff, + 0x5c, 0xae, 0x82, 0xab, 0x9c, 0x9d, 0xf6, 0x9e, 0xe8, 0x6d, 0x2b, 0xc5, 0x22, 0x36, 0x3a, 0x0d, + 0xab, 0xc5, 0x21, 0x97, 0x9b, 0x0d, 0xea, 0xda, 0x1d, 0xbf, 0x9a, 0x42, 0xd5, 0xc4, 0x48, 0x4e, + 0x0a, 0xbc, 0xd0, 0x6b, 0xfa, 0x53, 0xdd, 0xef, 0x3c, 0x1b, 0x20, 0xee, 0x3f, 0xd5, 0x9d, 0x7c, + 0x25, 0xe4, 0x1d, 0x2b, 0x66, 0x9e, 0x1e, 0xf1, 0x6e, 0x6f, 0x52, 0xc3, 0x16, 0x4d, 0xf4, 0xfb, + 0x79, 0x30, 0xe9, 0xe4, 0xe5, 0x88, 0x57, 0xb6, 0xac, 0x7d, 0x5f, 0x42, 0xd6, 0x9f, 0x6d, 0x18, + 0x77, 0x63, 0xcf, 0x1d, 0x55, 0x03, 0x40, 0x04, 0x87, 0xf5, 0x5b, 0xa5, 0x7e, 0x31, 0xcc, 0x7a, + 0x71, 0x35, 0xc8, 0x86, 0xef, 0xb4, 0x31, 0x8a, 0xed, 0x6a, 0x1e, 0x01, 0x2d, 0x9e, 0x68, 0x32, + 0xa9, 0x07, 0x60, 0x0a, 0x91, 0x81, 0x30, 0xc4, 0x6d, 0xc7, 0x78, 0xf9, 0x71, 0xad, 0x00, 0x38, + 0x09, 0x29, 0x99, 0xa3, 0x33, 0xcb, 0x8b, 0x7a, 0x1a, 0x1d, 0xb9, 0x3d, 0x71, 0x40, 0x00, 0x3c, + 0x2a, 0x4e, 0xce, 0xa9, 0xf9, 0x8d, 0x0a, 0xcc, 0x0a, 0x82, 0x91, 0xcd, 0xce, 0xc9, 0x7d, 0xcf, + 0x8e, 0xc9, 0xb5, 0x5a, 0x7f, 0x88, 0xa4, 0x6b, 0x4d, 0xb5, 0xa8, 0x51, 0xf4, 0x41, 0x82, 0xe1, + 0xc6, 0x8a, 0x00, 0x7e, 0x5e, 0x0d, 0xd9, 0x02, 0x0b, 0xfd, 0x64, 0xb6, 0x45, 0x03, 0x6c, 0x7a, + 0x4e, 0x67, 0x7d, 0x2c, 0x38, 0x53, 0x2a, 0x3a, 0x23, 0xba, 0x44, 0x42, 0xca, 0xf5, 0x3e, 0xa6, + 0x3b, 0xb4, 0x54, 0x32, 0x9b, 0x76, 0x24, 0xc8, 0x91, 0x7b, 0xdd, 0x64, 0xb1, 0xc0, 0xfd, 0x4c, + 0xb3, 0x8e, 0x8c, 0x33, 0x4c, 0x70, 0x1c, 0x3a, 0xcd, 0xad, 0x06, 0x57, 0xfc, 0xcf, 0xec, 0x71, + 0x9b, 0x1f, 0x5c, 0x3e, 0x4e, 0x46, 0x04, 0x1f, 0x38, 0x81, 0x47, 0xfb, 0x4c, 0xfd, 0xb4, 0x77, + 0xa5, 0x24, 0x71, 0xf7, 0xa9, 0xa9, 0x69, 0x10, 0xb8, 0x55, 0x32, 0x2e, 0xdb, 0x63, 0x40, 0xd8, + 0xa0, 0x0e, 0xf0, 0x92, 0x35, 0x05, 0x11, 0xe3, 0x0a, 0xbe, 0xc1, 0xff, 0xf9, 0xe3, 0xa2, 0x6e, + 0x7f, 0xb2, 0x9f, 0x8c, 0x18, 0x30, 0x23, 0xc3, 0x58, 0x7e, 0x38, 0xda, 0x00, 0x77, 0xd9, 0xb4, + 0x76, 0x3e, 0x4e, 0x4b, 0x94, 0xb2, 0xbb, 0xc1, 0x94, 0xc6, 0x65, 0x1e, 0x77, 0xca, 0xf9, 0x92, + 0xee, 0xaa, 0xc0, 0x23, 0x2a, 0x28, 0x1b, 0xf6, 0xb3, 0xa7, 0x39, 0xc1, 0x22, 0x61, 0x16, 0x82, + 0x0a, 0xe8, 0xdb, 0x58, 0x47, 0xa6, 0x7c, 0xbe, 0xf9, 0xc9, 0x09, 0x1b, 0x46, 0x2d, 0x53, 0x8c, + 0xd7, 0x2b, 0x03, 0x74, 0x6a, 0xe7, 0x7f, 0x5e, 0x62, 0x29, 0x2c, 0x31, 0x15, 0x62, 0xa8, 0x46, + 0x50, 0x5d, 0xc8, 0x2d, 0xb8, 0x54, 0x33, 0x8a, 0xe4, 0x9f, 0x52, 0x35, 0xc9, 0x5b, 0x91, 0x17, + 0x8c, 0xcf, 0x2d, 0xd5, 0xca, 0xce, 0xf4, 0x03, 0xec, 0x9d, 0x18, 0x10, 0xc6, 0x27, 0x2b, 0x04, + 0x5b, 0x3b, 0x71, 0xf9, 0xdc, 0x6b, 0x80, 0xd6, 0x3f, 0xdd, 0x4a, 0x8e, 0x9a, 0xdb, 0x1e, 0x69, + 0x62, 0xa6, 0x95, 0x26, 0xd4, 0x31, 0x61, 0xc1, 0xa4, 0x1d, 0x57, 0x0d, 0x79, 0x38, 0xda, 0xd4, + 0xa4, 0x0e, 0x32, 0x9c, 0xcf, 0xf4, 0x6a, 0xaa, 0x36, 0xad, 0x00, 0x4c, 0xf6, 0x00, 0xc8, 0x38, + 0x1e, 0x42, 0x5a, 0x31, 0xd9, 0x51, 0xae, 0x64, 0xfd, 0xb2, 0x3f, 0xce, 0xc9, 0x50, 0x9d, 0x43, + 0x68, 0x7f, 0xeb, 0x69, 0xed, 0xd1, 0xcc, 0x5e, 0x0b, 0x8c, 0xc3, 0xbd, 0xf6, 0x4b, 0x10, 0xef, + 0x86, 0xb6, 0x31, 0x42, 0xa3, 0xab, 0x88, 0x29, 0x55, 0x5b, 0x2f, 0x74, 0x7c, 0x93, 0x26, 0x65, + 0xcb, 0x2c, 0x0f, 0x1c, 0xc0, 0x1b, 0xd7, 0x02, 0x29, 0x38, 0x88, 0x39, 0xd2, 0xaf, 0x05, 0xe4, + 0x54, 0x50, 0x4a, 0xc7, 0x8b, 0x75, 0x82, 0x82, 0x28, 0x46, 0xc0, 0xba, 0x35, 0xc3, 0x5f, 0x5c, + 0x59, 0x16, 0x0c, 0xc0, 0x46, 0xfd, 0x82, 0x51, 0x54, 0x1f, 0xc6, 0x8c, 0x9c, 0x86, 0xb0, 0x22, + 0xbb, 0x70, 0x99, 0x87, 0x6a, 0x46, 0x0e, 0x74, 0x51, 0xa8, 0xa9, 0x31, 0x09, 0x70, 0x3f, 0xee, + 0x1c, 0x21, 0x7e, 0x6c, 0x38, 0x26, 0xe5, 0x2c, 0x51, 0xaa, 0x69, 0x1e, 0x0e, 0x42, 0x3c, 0xfc, + 0x99, 0xe9, 0xe3, 0x16, 0x50, 0xc1, 0x21, 0x7b, 0x62, 0x48, 0x16, 0xcd, 0xad, 0x9a, 0x95, 0xf9, + 0xd5, 0xb8, 0x01, 0x94, 0x88, 0xd9, 0xc0, 0xa0, 0xa1, 0xfe, 0x30, 0x75, 0xa5, 0x77, 0xe2, 0x31, + 0x83, 0xf8, 0x1d, 0x4a, 0x3f, 0x2f, 0xa4, 0x57, 0x1e, 0xfc, 0x8c, 0xe0, 0xba, 0x8a, 0x4f, 0xe8, + 0xb6, 0x85, 0x5d, 0xfe, 0x72, 0xb0, 0xa6, 0x6e, 0xde, 0xd2, 0xfb, 0xab, 0xfb, 0xe5, 0x8a, 0x30, + 0xfa, 0xfa, 0xbe, 0x1c, 0x5d, 0x71, 0xa8, 0x7e, 0x2f, 0x74, 0x1e, 0xf8, 0xc1, 0xfe, 0x86, 0xfe, + 0xa6, 0xbb, 0xfd, 0xe5, 0x30, 0x67, 0x7f, 0x0d, 0x97, 0xd1, 0x1d, 0x49, 0xf7, 0xa8, 0x44, 0x3d, + 0x08, 0x22, 0xe5, 0x06, 0xa9, 0xf4, 0x61, 0x4e, 0x01, 0x1e, 0x2a, 0x94, 0x83, 0x8f, 0xf8, 0x8c, + 0xd6, 0x8c, 0x8b, 0xb7, 0xc5, 0xc6, 0x42, 0x4c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, +}; + +static const unsigned char scr_dh_dh_1024_160_p[128] = { + 0xb1, 0x0b, 0x8f, 0x96, 0xa0, 0x80, 0xe0, 0x1d, 0xde, 0x92, 0xde, 0x5e, 0xae, 0x5d, 0x54, 0xec, + 0x52, 0xc9, 0x9f, 0xbc, 0xfb, 0x06, 0xa3, 0xc6, 0x9a, 0x6a, 0x9d, 0xca, 0x52, 0xd2, 0x3b, 0x61, + 0x60, 0x73, 0xe2, 0x86, 0x75, 0xa2, 0x3d, 0x18, 0x98, 0x38, 0xef, 0x1e, 0x2e, 0xe6, 0x52, 0xc0, + 0x13, 0xec, 0xb4, 0xae, 0xa9, 0x06, 0x11, 0x23, 0x24, 0x97, 0x5c, 0x3c, 0xd4, 0x9b, 0x83, 0xbf, + 0xac, 0xcb, 0xdd, 0x7d, 0x90, 0xc4, 0xbd, 0x70, 0x98, 0x48, 0x8e, 0x9c, 0x21, 0x9a, 0x73, 0x72, + 0x4e, 0xff, 0xd6, 0xfa, 0xe5, 0x64, 0x47, 0x38, 0xfa, 0xa3, 0x1a, 0x4f, 0xf5, 0x5b, 0xcc, 0xc0, + 0xa1, 0x51, 0xaf, 0x5f, 0x0d, 0xc8, 0xb4, 0xbd, 0x45, 0xbf, 0x37, 0xdf, 0x36, 0x5c, 0x1a, 0x65, + 0xe6, 0x8c, 0xfd, 0xa7, 0x6d, 0x4d, 0xa7, 0x08, 0xdf, 0x1f, 0xb2, 0xbc, 0x2e, 0x4a, 0x43, 0x71, +}; + +static const unsigned char scr_dh_dh_1024_160_g[128] = { + 0xa4, 0xd1, 0xcb, 0xd5, 0xc3, 0xfd, 0x34, 0x12, 0x67, 0x65, 0xa4, 0x42, 0xef, 0xb9, 0x99, 0x05, + 0xf8, 0x10, 0x4d, 0xd2, 0x58, 0xac, 0x50, 0x7f, 0xd6, 0x40, 0x6c, 0xff, 0x14, 0x26, 0x6d, 0x31, + 0x26, 0x6f, 0xea, 0x1e, 0x5c, 0x41, 0x56, 0x4b, 0x77, 0x7e, 0x69, 0x0f, 0x55, 0x04, 0xf2, 0x13, + 0x16, 0x02, 0x17, 0xb4, 0xb0, 0x1b, 0x88, 0x6a, 0x5e, 0x91, 0x54, 0x7f, 0x9e, 0x27, 0x49, 0xf4, + 0xd7, 0xfb, 0xd7, 0xd3, 0xb9, 0xa9, 0x2e, 0xe1, 0x90, 0x9d, 0x0d, 0x22, 0x63, 0xf8, 0x0a, 0x76, + 0xa6, 0xa2, 0x4c, 0x08, 0x7a, 0x09, 0x1f, 0x53, 0x1d, 0xbf, 0x0a, 0x01, 0x69, 0xb6, 0xa2, 0x8a, + 0xd6, 0x62, 0xa4, 0xd1, 0x8e, 0x73, 0xaf, 0xa3, 0x2d, 0x77, 0x9d, 0x59, 0x18, 0xd0, 0x8b, 0xc8, + 0x85, 0x8f, 0x4d, 0xce, 0xf9, 0x7c, 0x2a, 0x24, 0x85, 0x5e, 0x6e, 0xeb, 0x22, 0xb3, 0xb2, 0xe5, +}; + +static const unsigned char scr_dh_dh_1024_160_q[20] = { + 0xf5, 0x18, 0xaa, 0x87, 0x81, 0xa8, 0xdf, 0x27, 0x8a, 0xba, 0x4e, 0x7d, 0x64, 0xb7, 0xcb, 0x9d, + 0x49, 0x46, 0x23, 0x53, +}; + +static const unsigned char scr_dh_dh_2048_224_p[256] = { + 0xad, 0x10, 0x7e, 0x1e, 0x91, 0x23, 0xa9, 0xd0, 0xd6, 0x60, 0xfa, 0xa7, 0x95, 0x59, 0xc5, 0x1f, + 0xa2, 0x0d, 0x64, 0xe5, 0x68, 0x3b, 0x9f, 0xd1, 0xb5, 0x4b, 0x15, 0x97, 0xb6, 0x1d, 0x0a, 0x75, + 0xe6, 0xfa, 0x14, 0x1d, 0xf9, 0x5a, 0x56, 0xdb, 0xaf, 0x9a, 0x3c, 0x40, 0x7b, 0xa1, 0xdf, 0x15, + 0xeb, 0x3d, 0x68, 0x8a, 0x30, 0x9c, 0x18, 0x0e, 0x1d, 0xe6, 0xb8, 0x5a, 0x12, 0x74, 0xa0, 0xa6, + 0x6d, 0x3f, 0x81, 0x52, 0xad, 0x6a, 0xc2, 0x12, 0x90, 0x37, 0xc9, 0xed, 0xef, 0xda, 0x4d, 0xf8, + 0xd9, 0x1e, 0x8f, 0xef, 0x55, 0xb7, 0x39, 0x4b, 0x7a, 0xd5, 0xb7, 0xd0, 0xb6, 0xc1, 0x22, 0x07, + 0xc9, 0xf9, 0x8d, 0x11, 0xed, 0x34, 0xdb, 0xf6, 0xc6, 0xba, 0x0b, 0x2c, 0x8b, 0xbc, 0x27, 0xbe, + 0x6a, 0x00, 0xe0, 0xa0, 0xb9, 0xc4, 0x97, 0x08, 0xb3, 0xbf, 0x8a, 0x31, 0x70, 0x91, 0x88, 0x36, + 0x81, 0x28, 0x61, 0x30, 0xbc, 0x89, 0x85, 0xdb, 0x16, 0x02, 0xe7, 0x14, 0x41, 0x5d, 0x93, 0x30, + 0x27, 0x82, 0x73, 0xc7, 0xde, 0x31, 0xef, 0xdc, 0x73, 0x10, 0xf7, 0x12, 0x1f, 0xd5, 0xa0, 0x74, + 0x15, 0x98, 0x7d, 0x9a, 0xdc, 0x0a, 0x48, 0x6d, 0xcd, 0xf9, 0x3a, 0xcc, 0x44, 0x32, 0x83, 0x87, + 0x31, 0x5d, 0x75, 0xe1, 0x98, 0xc6, 0x41, 0xa4, 0x80, 0xcd, 0x86, 0xa1, 0xb9, 0xe5, 0x87, 0xe8, + 0xbe, 0x60, 0xe6, 0x9c, 0xc9, 0x28, 0xb2, 0xb9, 0xc5, 0x21, 0x72, 0xe4, 0x13, 0x04, 0x2e, 0x9b, + 0x23, 0xf1, 0x0b, 0x0e, 0x16, 0xe7, 0x97, 0x63, 0xc9, 0xb5, 0x3d, 0xcf, 0x4b, 0xa8, 0x0a, 0x29, + 0xe3, 0xfb, 0x73, 0xc1, 0x6b, 0x8e, 0x75, 0xb9, 0x7e, 0xf3, 0x63, 0xe2, 0xff, 0xa3, 0x1f, 0x71, + 0xcf, 0x9d, 0xe5, 0x38, 0x4e, 0x71, 0xb8, 0x1c, 0x0a, 0xc4, 0xdf, 0xfe, 0x0c, 0x10, 0xe6, 0x4f, +}; + +static const unsigned char scr_dh_dh_2048_224_g[256] = { + 0xac, 0x40, 0x32, 0xef, 0x4f, 0x2d, 0x9a, 0xe3, 0x9d, 0xf3, 0x0b, 0x5c, 0x8f, 0xfd, 0xac, 0x50, + 0x6c, 0xde, 0xbe, 0x7b, 0x89, 0x99, 0x8c, 0xaf, 0x74, 0x86, 0x6a, 0x08, 0xcf, 0xe4, 0xff, 0xe3, + 0xa6, 0x82, 0x4a, 0x4e, 0x10, 0xb9, 0xa6, 0xf0, 0xdd, 0x92, 0x1f, 0x01, 0xa7, 0x0c, 0x4a, 0xfa, + 0xab, 0x73, 0x9d, 0x77, 0x00, 0xc2, 0x9f, 0x52, 0xc5, 0x7d, 0xb1, 0x7c, 0x62, 0x0a, 0x86, 0x52, + 0xbe, 0x5e, 0x90, 0x01, 0xa8, 0xd6, 0x6a, 0xd7, 0xc1, 0x76, 0x69, 0x10, 0x19, 0x99, 0x02, 0x4a, + 0xf4, 0xd0, 0x27, 0x27, 0x5a, 0xc1, 0x34, 0x8b, 0xb8, 0xa7, 0x62, 0xd0, 0x52, 0x1b, 0xc9, 0x8a, + 0xe2, 0x47, 0x15, 0x04, 0x22, 0xea, 0x1e, 0xd4, 0x09, 0x93, 0x9d, 0x54, 0xda, 0x74, 0x60, 0xcd, + 0xb5, 0xf6, 0xc6, 0xb2, 0x50, 0x71, 0x7c, 0xbe, 0xf1, 0x80, 0xeb, 0x34, 0x11, 0x8e, 0x98, 0xd1, + 0x19, 0x52, 0x9a, 0x45, 0xd6, 0xf8, 0x34, 0x56, 0x6e, 0x30, 0x25, 0xe3, 0x16, 0xa3, 0x30, 0xef, + 0xbb, 0x77, 0xa8, 0x6f, 0x0c, 0x1a, 0xb1, 0x5b, 0x05, 0x1a, 0xe3, 0xd4, 0x28, 0xc8, 0xf8, 0xac, + 0xb7, 0x0a, 0x81, 0x37, 0x15, 0x0b, 0x8e, 0xeb, 0x10, 0xe1, 0x83, 0xed, 0xd1, 0x99, 0x63, 0xdd, + 0xd9, 0xe2, 0x63, 0xe4, 0x77, 0x05, 0x89, 0xef, 0x6a, 0xa2, 0x1e, 0x7f, 0x5f, 0x2f, 0xf3, 0x81, + 0xb5, 0x39, 0xcc, 0xe3, 0x40, 0x9d, 0x13, 0xcd, 0x56, 0x6a, 0xfb, 0xb4, 0x8d, 0x6c, 0x01, 0x91, + 0x81, 0xe1, 0xbc, 0xfe, 0x94, 0xb3, 0x02, 0x69, 0xed, 0xfe, 0x72, 0xfe, 0x9b, 0x6a, 0xa4, 0xbd, + 0x7b, 0x5a, 0x0f, 0x1c, 0x71, 0xcf, 0xff, 0x4c, 0x19, 0xc4, 0x18, 0xe1, 0xf6, 0xec, 0x01, 0x79, + 0x81, 0xbc, 0x08, 0x7f, 0x2a, 0x70, 0x65, 0xb3, 0x84, 0xb8, 0x90, 0xd3, 0x19, 0x1f, 0x2b, 0xfa, +}; + +static const unsigned char scr_dh_dh_2048_224_q[28] = { + 0x80, 0x1c, 0x0d, 0x34, 0xc5, 0x8d, 0x93, 0xfe, 0x99, 0x71, 0x77, 0x10, 0x1f, 0x80, 0x53, 0x5a, + 0x47, 0x38, 0xce, 0xbc, 0xbf, 0x38, 0x9a, 0x99, 0xb3, 0x63, 0x71, 0xeb, +}; + +static const unsigned char scr_dh_dh_2048_256_p[256] = { + 0x87, 0xa8, 0xe6, 0x1d, 0xb4, 0xb6, 0x66, 0x3c, 0xff, 0xbb, 0xd1, 0x9c, 0x65, 0x19, 0x59, 0x99, + 0x8c, 0xee, 0xf6, 0x08, 0x66, 0x0d, 0xd0, 0xf2, 0x5d, 0x2c, 0xee, 0xd4, 0x43, 0x5e, 0x3b, 0x00, + 0xe0, 0x0d, 0xf8, 0xf1, 0xd6, 0x19, 0x57, 0xd4, 0xfa, 0xf7, 0xdf, 0x45, 0x61, 0xb2, 0xaa, 0x30, + 0x16, 0xc3, 0xd9, 0x11, 0x34, 0x09, 0x6f, 0xaa, 0x3b, 0xf4, 0x29, 0x6d, 0x83, 0x0e, 0x9a, 0x7c, + 0x20, 0x9e, 0x0c, 0x64, 0x97, 0x51, 0x7a, 0xbd, 0x5a, 0x8a, 0x9d, 0x30, 0x6b, 0xcf, 0x67, 0xed, + 0x91, 0xf9, 0xe6, 0x72, 0x5b, 0x47, 0x58, 0xc0, 0x22, 0xe0, 0xb1, 0xef, 0x42, 0x75, 0xbf, 0x7b, + 0x6c, 0x5b, 0xfc, 0x11, 0xd4, 0x5f, 0x90, 0x88, 0xb9, 0x41, 0xf5, 0x4e, 0xb1, 0xe5, 0x9b, 0xb8, + 0xbc, 0x39, 0xa0, 0xbf, 0x12, 0x30, 0x7f, 0x5c, 0x4f, 0xdb, 0x70, 0xc5, 0x81, 0xb2, 0x3f, 0x76, + 0xb6, 0x3a, 0xca, 0xe1, 0xca, 0xa6, 0xb7, 0x90, 0x2d, 0x52, 0x52, 0x67, 0x35, 0x48, 0x8a, 0x0e, + 0xf1, 0x3c, 0x6d, 0x9a, 0x51, 0xbf, 0xa4, 0xab, 0x3a, 0xd8, 0x34, 0x77, 0x96, 0x52, 0x4d, 0x8e, + 0xf6, 0xa1, 0x67, 0xb5, 0xa4, 0x18, 0x25, 0xd9, 0x67, 0xe1, 0x44, 0xe5, 0x14, 0x05, 0x64, 0x25, + 0x1c, 0xca, 0xcb, 0x83, 0xe6, 0xb4, 0x86, 0xf6, 0xb3, 0xca, 0x3f, 0x79, 0x71, 0x50, 0x60, 0x26, + 0xc0, 0xb8, 0x57, 0xf6, 0x89, 0x96, 0x28, 0x56, 0xde, 0xd4, 0x01, 0x0a, 0xbd, 0x0b, 0xe6, 0x21, + 0xc3, 0xa3, 0x96, 0x0a, 0x54, 0xe7, 0x10, 0xc3, 0x75, 0xf2, 0x63, 0x75, 0xd7, 0x01, 0x41, 0x03, + 0xa4, 0xb5, 0x43, 0x30, 0xc1, 0x98, 0xaf, 0x12, 0x61, 0x16, 0xd2, 0x27, 0x6e, 0x11, 0x71, 0x5f, + 0x69, 0x38, 0x77, 0xfa, 0xd7, 0xef, 0x09, 0xca, 0xdb, 0x09, 0x4a, 0xe9, 0x1e, 0x1a, 0x15, 0x97, +}; + +static const unsigned char scr_dh_dh_2048_256_g[256] = { + 0x3f, 0xb3, 0x2c, 0x9b, 0x73, 0x13, 0x4d, 0x0b, 0x2e, 0x77, 0x50, 0x66, 0x60, 0xed, 0xbd, 0x48, + 0x4c, 0xa7, 0xb1, 0x8f, 0x21, 0xef, 0x20, 0x54, 0x07, 0xf4, 0x79, 0x3a, 0x1a, 0x0b, 0xa1, 0x25, + 0x10, 0xdb, 0xc1, 0x50, 0x77, 0xbe, 0x46, 0x3f, 0xff, 0x4f, 0xed, 0x4a, 0xac, 0x0b, 0xb5, 0x55, + 0xbe, 0x3a, 0x6c, 0x1b, 0x0c, 0x6b, 0x47, 0xb1, 0xbc, 0x37, 0x73, 0xbf, 0x7e, 0x8c, 0x6f, 0x62, + 0x90, 0x12, 0x28, 0xf8, 0xc2, 0x8c, 0xbb, 0x18, 0xa5, 0x5a, 0xe3, 0x13, 0x41, 0x00, 0x0a, 0x65, + 0x01, 0x96, 0xf9, 0x31, 0xc7, 0x7a, 0x57, 0xf2, 0xdd, 0xf4, 0x63, 0xe5, 0xe9, 0xec, 0x14, 0x4b, + 0x77, 0x7d, 0xe6, 0x2a, 0xaa, 0xb8, 0xa8, 0x62, 0x8a, 0xc3, 0x76, 0xd2, 0x82, 0xd6, 0xed, 0x38, + 0x64, 0xe6, 0x79, 0x82, 0x42, 0x8e, 0xbc, 0x83, 0x1d, 0x14, 0x34, 0x8f, 0x6f, 0x2f, 0x91, 0x93, + 0xb5, 0x04, 0x5a, 0xf2, 0x76, 0x71, 0x64, 0xe1, 0xdf, 0xc9, 0x67, 0xc1, 0xfb, 0x3f, 0x2e, 0x55, + 0xa4, 0xbd, 0x1b, 0xff, 0xe8, 0x3b, 0x9c, 0x80, 0xd0, 0x52, 0xb9, 0x85, 0xd1, 0x82, 0xea, 0x0a, + 0xdb, 0x2a, 0x3b, 0x73, 0x13, 0xd3, 0xfe, 0x14, 0xc8, 0x48, 0x4b, 0x1e, 0x05, 0x25, 0x88, 0xb9, + 0xb7, 0xd2, 0xbb, 0xd2, 0xdf, 0x01, 0x61, 0x99, 0xec, 0xd0, 0x6e, 0x15, 0x57, 0xcd, 0x09, 0x15, + 0xb3, 0x35, 0x3b, 0xbb, 0x64, 0xe0, 0xec, 0x37, 0x7f, 0xd0, 0x28, 0x37, 0x0d, 0xf9, 0x2b, 0x52, + 0xc7, 0x89, 0x14, 0x28, 0xcd, 0xc6, 0x7e, 0xb6, 0x18, 0x4b, 0x52, 0x3d, 0x1d, 0xb2, 0x46, 0xc3, + 0x2f, 0x63, 0x07, 0x84, 0x90, 0xf0, 0x0e, 0xf8, 0xd6, 0x47, 0xd1, 0x48, 0xd4, 0x79, 0x54, 0x51, + 0x5e, 0x23, 0x27, 0xcf, 0xef, 0x98, 0xc5, 0x82, 0x66, 0x4b, 0x4c, 0x0f, 0x6c, 0xc4, 0x16, 0x59, +}; + +static const unsigned char scr_dh_dh_2048_256_q[32] = { + 0x8c, 0xf8, 0x36, 0x42, 0xa7, 0x09, 0xa0, 0x97, 0xb4, 0x47, 0x99, 0x76, 0x40, 0x12, 0x9d, 0xa2, + 0x99, 0xb1, 0xa4, 0x7d, 0x1e, 0xb3, 0x75, 0x0b, 0xa3, 0x08, 0xb0, 0xfe, 0x64, 0xf5, 0xfb, 0xd3, +}; + +#endif diff --git a/packages/runtime/src/scr_dyn.h b/packages/runtime/src/scr_dyn.h index 37e9eacce..4b618a809 100644 --- a/packages/runtime/src/scr_dyn.h +++ b/packages/runtime/src/scr_dyn.h @@ -155,6 +155,8 @@ typedef enum { X(DATE, 30) /* JavaScript Date with stable native identity */ \ X(DECIPHER, 46) /* node:crypto Decipheriv (scr_cipher.c) */ \ X(DGRAM_SOCKET, 62) /* dgram.Socket (scr_dgram.c) */ \ + X(DIFFIE_HELLMAN, 65) /* node:crypto DiffieHellman (scr_dh.c) */ \ + X(DIFFIE_HELLMAN_GROUP, 66) /* node:crypto DiffieHellmanGroup (scr_dh.c) */ \ X(DIR, 44) /* fs.Dir (scr_lib.c) */ \ X(DISPOSABLE_STACK, 49) /* DisposableStack (scr_symbol.c) */ \ X(ECDH, 64) /* node:crypto ECDH (scr_ecdh.c) */ \ diff --git a/packages/runtime/src/scr_ecdh.c b/packages/runtime/src/scr_ecdh.c index fc8797571..5edbadba6 100644 --- a/packages/runtime/src/scr_ecdh.c +++ b/packages/runtime/src/scr_ecdh.c @@ -21,6 +21,7 @@ #include "mbedtls/ecp.h" #include "mbedtls/platform_util.h" +#include "scr_crypto_args.h" #include "scr_ecdh_names.h" typedef struct { @@ -73,6 +74,9 @@ static int se_random(void *state, unsigned char *out, size_t len) { return 0; } +/* The value the SC2020 error for an unlowered encoding or format names. */ +#define SE_SUBJECT "An ECDH encoding or format" + /* ── errors ───────────────────────────────────────────────────────────── */ static void se_throw(int kind, const char *code, const char *message) { @@ -83,51 +87,6 @@ static void se_operation_failed(const char *message) { se_throw(SCR_ERR_ERROR, "ERR_CRYPTO_OPERATION_FAILED", message); } -/* An object's toString the program defined, as an own or inherited - * function property. */ -static bool se_custom_to_string(ScrDyn *value) { - if (value->kind != SCR_DYN_OBJ && value->kind != SCR_DYN_TYPED_REF) return false; - ScrDyn *member = scr_dyn_obj_read(value, "toString", 8); - bool custom = member && member->kind == SCR_DYN_FUNC; - scr_dyn_release(member); - return custom; -} - -/* Whether value is a class instance whose class defines toString. */ -static bool se_class_to_string(const ScrDyn *value) { - ScrStr *name = scr_str_new("toString", 8); - bool method = scr_dyn_typed_ref_class_has(value, name); - scr_str_release(name); - return method; -} - -/* `prefix` and the value as util.format's %s renders it: strings and - * objects with a program-defined toString as String(value), numbers as - * util.inspect does, other values inspected at depth 0. Functions and - * class instances that define toString have no lowering. */ -static void se_throw_formatted(const char *code, const char *prefix, const ScrDyn *value) { - ScrDyn *v = (ScrDyn *)value; - if (v->kind == SCR_DYN_FUNC || se_class_to_string(v)) { - static const char message[] = "An ECDH encoding or format that is a function or an instance of a class " - "defining toString has no lowering; pass the name as a string"; - scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020"); - return; - } - ScrStr *text; - if (v->kind == SCR_DYN_STR || se_custom_to_string(v)) text = scr_dyn_string_coerce_js(v); - else if (v->kind == SCR_DYN_NUM) text = scr_insp_f64(v->v.num); - else text = scr_insp_dyn_s(v, 0); - if (!text) return; - ScrJsonBuf b; - scr_jb_init(&b); - scr_jb_puts(&b, prefix); - scr_jb_put_str(&b, text); - scr_str_release(text); - ScrStr *message = scr_jb_finish(&b); - scr_throw_error_msg_code(SCR_ERR_TYPE, message->data, message->len, code); - scr_str_release(message); -} - /* ── names and encodings ──────────────────────────────────────────────── */ static int se_name_cmp(const void *key, const void *entry) { @@ -198,129 +157,16 @@ static bool se_load_group(const ScrStr *name, mbedtls_ecp_group *grp, const char return false; } -static bool se_ascii_eq_ci(const char *a, size_t a_len, const char *b) { - size_t b_len = strlen(b); - if (a_len != b_len) return false; - for (size_t i = 0; i < a_len; i++) { - char x = a[i]; - if (x >= 'A' && x <= 'Z') x = (char)(x - 'A' + 'a'); - if (x != b[i]) return false; - } - return true; -} - -static bool se_str_is(const ScrStr *text, const char *literal) { - size_t len = strlen(literal); - return text->len == len && memcmp(text->data, literal, len) == 0; -} - -/* Node's normalizeEncoding: the canonical name, or NULL. */ -static const char *se_normalize_encoding(const ScrStr *name) { - static const struct { const char *from; const char *to; } map[] = { - {"utf8", "utf8"}, {"utf-8", "utf8"}, {"hex", "hex"}, - {"base64", "base64"}, {"base64url", "base64url"}, {"latin1", "latin1"}, - {"binary", "latin1"}, {"ascii", "ascii"}, {"utf16le", "utf16le"}, - {"utf-16le", "utf16le"}, {"ucs2", "utf16le"}, {"ucs-2", "utf16le"}, - }; - for (size_t i = 0; i < sizeof map / sizeof map[0]; i++) - if (se_ascii_eq_ci(name->data, name->len, map[i].from)) return map[i].to; - return NULL; -} - -/* The value a typed-ref box holds when it is a string, view, ArrayBuffer - * or native handle (+1). Other values are retained as passed, so argument - * errors describe the original value. NULL after throwing. */ -static ScrDyn *se_unbox(ScrDyn *value) { - if (value->kind != SCR_DYN_TYPED_REF) return scr_dyn_retain(value); - ScrDyn *view = scr_dyn_typed_ref_materialize(value); - if (!view) return NULL; - if (view->kind == SCR_DYN_STR || view->kind == SCR_DYN_BYTES || view->kind == SCR_DYN_HANDLE || - scr_buffer_storage_is(view)) - return view; - scr_dyn_release(view); - return scr_dyn_retain(value); -} - -/* getArrayBufferOrView(key, 'key', encoding): a string is Buffer.from(key, - * encoding) with 'buffer' read as utf8; views and ArrayBuffers are their - * bytes. +1 or NULL after throwing. */ -static ScrBytes *se_key_bytes(const ScrDyn *key, const ScrDyn *encoding) { - if (key->kind == SCR_DYN_STR) { - /* Buffer.from(string, encoding): an encoding that is not a non-empty - * string reads as utf8. */ - const char *name = "utf8"; - if (encoding->kind == SCR_DYN_STR && encoding->v.str->len > 0 && !se_str_is(encoding->v.str, "buffer")) { - name = se_normalize_encoding(encoding->v.str); - if (!name) { - se_throw_formatted("ERR_UNKNOWN_ENCODING", "Unknown encoding: ", encoding); - return NULL; - } - } - ScrStr *canonical = scr_str_new(name, strlen(name)); - ScrBytes *bytes = scr_bytes_from_str(key->v.str, canonical); - scr_str_release(canonical); - return bytes; - } - if (key->kind == SCR_DYN_BYTES || scr_buffer_storage_is(key)) return scr_bytes_buffer_source(key); - scr_dyn_arg_type_fail("key", "of type string or an instance of ArrayBuffer, Buffer, TypedArray, or DataView", key); - return NULL; -} - -/* encode(buffer, encoding): the Buffer, or buffer.toString(encoding) for - * a truthy encoding other than 'buffer'. Consumes bytes. */ -static ScrDyn *se_encode(ScrBytes *bytes, const ScrDyn *encoding) { - if (!scr_dyn_truthy(encoding) || (encoding->kind == SCR_DYN_STR && se_str_is(encoding->v.str, "buffer"))) { - ScrDyn *result = scr_dyn_new_buffer(bytes); - scr_bytes_release(bytes); - return result; - } - /* toString answers "" for no bytes before it reads the encoding. */ - ScrStr *text = NULL; - if (bytes->len == 0) { - text = scr_str_new("", 0); - } else { - /* getEncodingOps reads `encoding + ''`. */ - ScrStr *name = encoding->kind == SCR_DYN_STR ? scr_str_retain(encoding->v.str) : NULL; - if (!name) { - if (encoding->kind == SCR_DYN_FUNC || se_class_to_string(encoding)) { - se_throw_formatted("ERR_UNKNOWN_ENCODING", "Unknown encoding: ", encoding); - scr_bytes_release(bytes); - return NULL; - } - name = scr_dyn_string_coerce_js(encoding); - if (!name) { - scr_bytes_release(bytes); - return NULL; - } - } - const char *canonical = se_normalize_encoding(name); - scr_str_release(name); - if (!canonical) { - se_throw_formatted("ERR_UNKNOWN_ENCODING", "Unknown encoding: ", encoding); - scr_bytes_release(bytes); - return NULL; - } - ScrStr *canonical_text = scr_str_new(canonical, strlen(canonical)); - text = scr_bytes_to_str(bytes, canonical_text); - scr_str_release(canonical_text); - } - scr_bytes_release(bytes); - if (!text) return NULL; - ScrDyn *result = scr_dyn_new_str(text); - scr_str_release(text); - return result; -} - /* getFormat: a falsy format is uncompressed; other values must be * 'compressed', 'hybrid' or 'uncompressed'. 0 after throwing. */ static int se_format(const ScrDyn *format) { if (!scr_dyn_truthy(format)) return SE_UNCOMPRESSED; if (format->kind == SCR_DYN_STR) { - if (se_str_is(format->v.str, "compressed")) return SE_COMPRESSED; - if (se_str_is(format->v.str, "hybrid")) return SE_HYBRID; - if (se_str_is(format->v.str, "uncompressed")) return SE_UNCOMPRESSED; + if (ca_str_is(format->v.str, "compressed")) return SE_COMPRESSED; + if (ca_str_is(format->v.str, "hybrid")) return SE_HYBRID; + if (ca_str_is(format->v.str, "uncompressed")) return SE_UNCOMPRESSED; } - se_throw_formatted("ERR_CRYPTO_ECDH_INVALID_FORMAT", "Invalid ECDH format: ", format); + ca_throw_formatted(SE_SUBJECT, "ERR_CRYPTO_ECDH_INVALID_FORMAT", "Invalid ECDH format: ", format); return 0; } @@ -516,7 +362,7 @@ static ScrDyn *se_new(const ScrDyn *curve) { } ScrDyn *scr_crypto_ecdh_new(ScrDyn *curve) { - ScrDyn *unboxed = se_unbox(curve); + ScrDyn *unboxed = ca_unbox(curve); if (!unboxed) return NULL; ScrDyn *result = se_new(unboxed); scr_dyn_release(unboxed); @@ -530,7 +376,7 @@ static ScrDyn *se_convert_key(const ScrDyn *key, const ScrDyn *curve, const ScrD scr_dyn_arg_type_fail("curve", "of type string", curve); return NULL; } - ScrBytes *bytes = se_key_bytes(key, in_enc); + ScrBytes *bytes = ca_key_bytes(SE_SUBJECT, key, in_enc); if (!bytes) return NULL; int form = se_format(format); if (!form) { @@ -557,7 +403,7 @@ static ScrDyn *se_convert_key(const ScrDyn *key, const ScrDyn *curve, const ScrD } else { ScrBytes *out = se_write_point(&grp, &pt, form); if (!out) se_operation_failed("Failed to convert EC_POINT to Buffer"); - else result = se_encode(out, out_enc); + else result = ca_encode(SE_SUBJECT, out, out_enc); } } mbedtls_ecp_point_free(&pt); @@ -571,7 +417,7 @@ ScrDyn *scr_crypto_ecdh_convert_key(ScrDyn *key, ScrDyn *curve, ScrDyn *in_enc, ScrDyn *unboxed[5] = {NULL, NULL, NULL, NULL, NULL}; ScrDyn *result = NULL; for (size_t i = 0; i < 5; i++) - if (!(unboxed[i] = se_unbox(args[i]))) goto done; + if (!(unboxed[i] = ca_unbox(args[i]))) goto done; result = se_convert_key(unboxed[0], unboxed[1], unboxed[2], unboxed[3], unboxed[4]); done: for (size_t i = 0; i < 5; i++) scr_dyn_release(unboxed[i]); @@ -597,7 +443,7 @@ static ScrDyn *se_get_public_key(ScEcdh *e, const ScrDyn *encoding, const ScrDyn se_operation_failed("Failed to get ECDH public key"); return NULL; } - return se_encode(out, encoding); + return ca_encode(SE_SUBJECT, out, encoding); } static ScrDyn *se_generate_keys(ScEcdh *e, const ScrDyn *encoding, const ScrDyn *format) { @@ -628,12 +474,12 @@ static ScrDyn *se_get_private_key(ScEcdh *e, const ScrDyn *encoding) { se_operation_failed("Failed to get ECDH private key"); return NULL; } - return se_encode(out, encoding); + return ca_encode(SE_SUBJECT, out, encoding); } /* setPrivateKey(key, encoding): 1 <= d < n, and the public key d·G. */ static ScrDyn *se_set_private_key(ScEcdh *e, ScrDyn *self, const ScrDyn *key, const ScrDyn *encoding) { - ScrBytes *bytes = se_key_bytes(key, encoding); + ScrBytes *bytes = ca_key_bytes(SE_SUBJECT, key, encoding); if (!bytes) return NULL; mbedtls_mpi d; mbedtls_ecp_point q; @@ -680,7 +526,7 @@ static void se_dep0031(void) { static ScrDyn *se_set_public_key(ScEcdh *e, ScrDyn *self, const ScrDyn *key, const ScrDyn *encoding) { se_dep0031(); - ScrBytes *bytes = se_key_bytes(key, encoding); + ScrBytes *bytes = ca_key_bytes(SE_SUBJECT, key, encoding); if (!bytes) return NULL; mbedtls_ecp_point q; mbedtls_ecp_point_init(&q); @@ -716,7 +562,7 @@ static bool se_pair_valid(ScEcdh *e) { /* computeSecret(key, inputEncoding, outputEncoding): the x coordinate of * d·P, padded to the field size as ECDH_compute_key writes it. */ static ScrDyn *se_compute_secret(ScEcdh *e, const ScrDyn *key, const ScrDyn *in_enc, const ScrDyn *out_enc) { - ScrBytes *bytes = se_key_bytes(key, in_enc); + ScrBytes *bytes = ca_key_bytes(SE_SUBJECT, key, in_enc); if (!bytes) return NULL; ScrDyn *result = NULL; mbedtls_ecp_point pub; @@ -737,7 +583,7 @@ static ScrDyn *se_compute_secret(ScEcdh *e, const ScrDyn *key, const ScrDyn *in_ scr_bytes_release(out); se_operation_failed("Failed to compute ECDH key"); } else { - result = se_encode(out, out_enc); + result = ca_encode(SE_SUBJECT, out, out_enc); } } mbedtls_mpi_free(&z); @@ -776,7 +622,7 @@ static ScrDyn *se_invoke(void *h, ScrDyn *self, const char *method, ScrDyn *cons size_t count = argc < 3 ? argc : 3; ScrDyn *result = NULL; for (size_t i = 0; i < count; i++) - if (!(unboxed[i] = se_unbox(args[i]))) goto done; + if (!(unboxed[i] = ca_unbox(args[i]))) goto done; result = se_dispatch(h, self, method, unboxed, count, what); done: for (size_t i = 0; i < count; i++) scr_dyn_release(unboxed[i]); diff --git a/packages/runtime/test/dh.test.ts b/packages/runtime/test/dh.test.ts new file mode 100644 index 000000000..d402d0465 --- /dev/null +++ b/packages/runtime/test/dh.test.ts @@ -0,0 +1,85 @@ +import { execFile } from "node:child_process"; +import { mkdir } from "node:fs/promises"; +import { join } from "node:path"; +import { promisify } from "node:util"; +import { beforeAll, expect, test } from "vitest"; + +const execFileAsync = promisify(execFile); +const testDir = import.meta.dirname; +const bin = join(testDir, "build", "test_dh"); +const mbedtls = join(testDir, "../vendor/mbedtls"); + +const runtimeSources = [ + "scr_shared.c", + "scr_bytes.c", + "scr_bytes.test.c", + "scr_bytes_io.c", + "scr_fs_cp.c", + "scr_zlib.c", + "scr_lib.c", + "scr_hash.c", + "scr_string.c", + "scr_array.c", + "scr_map.c", + "scr_exception.c", + "scr_error.c", + "scr_number.c", + "scr_console.c", + "scr_closure.c", + "scr_ffi.c", + "scr_object.c", + "scr_union.c", + "scr_cycle.c", + "scr_alloc.c", + "scr_json.c", + "scr_inspect.c", + "scr_bigint.c", + "scr_async.c", + "scr_async_dyn.c", + "scr_child.c", + "scr_path.c", + "scr_url.c", + "scr_url_params.c", +]; + +// The bignum modules scr_dh.c uses. +const mbedtlsSources = ["bignum.c", "bignum_core.c", "constant_time.c", "platform_util.c"]; + +// Compiled once with ASan, UBSan and the RC audit. test_dh.c includes +// scr_dh.c and checks the primality tests' Montgomery exponentiation +// against mbedTLS's, the primality test on primes, Carmichael numbers and +// strong pseudoprimes, exponents past mbedTLS's 8192-bit limit, DH_check +// results, and generated safe primes. +beforeAll(async () => { + await mkdir(join(testDir, "build"), { recursive: true }); + await execFileAsync("clang", [ + "-std=c11", + "-O1", + "-Wall", + "-Wextra", + "-Wno-missing-field-initializers", + "-fsanitize=address,undefined", + "-DSCR_RC_AUDIT", + "-I", + join(testDir, "../src"), + "-I", + join(mbedtls, "include"), + "-I", + join(mbedtls, "library"), + "-o", + bin, + join(testDir, "test_dh.c"), + ...runtimeSources.map((source) => join(testDir, "../src", source)), + ...mbedtlsSources.map((source) => join(mbedtls, "library", source)), + "-Wno-deprecated-declarations", + "-lz", + ...(process.platform === "linux" ? ["-D_GNU_SOURCE", "-lm"] : []), + ]); +}, 300_000); + +test("DiffieHellman runtime: exponentiation, primality and safe primes", async () => { + const { stderr } = await execFileAsync(bin, [], { + env: { ...process.env, UBSAN_OPTIONS: "halt_on_error=1" }, + }); + expect(stderr.trim().split("\n").pop()).toMatch(/^(\d+)\/\1 cases passed$/); +}, 300_000); diff --git a/packages/runtime/test/test_dh.c b/packages/runtime/test/test_dh.c new file mode 100644 index 000000000..aa8f175a3 --- /dev/null +++ b/packages/runtime/test/test_dh.c @@ -0,0 +1,228 @@ +/* Unit tests for the DiffieHellman runtime's arithmetic (scr_dh.c), built + * with ASan and UBSan by dh.test.ts. The unit is included directly so the + * tests can compare the Montgomery exponentiation the primality tests use + * with mbedTLS's, run the primality test on primes, Carmichael numbers and + * strong pseudoprimes to small bases, split exponents past mbedTLS's limit, + * and check generated safe primes and DH_check results. */ +#include "../src/scr_dh.c" + +#include +#include + +static long total = 0, failed = 0; + +static void check(bool ok, const char *what) { + total++; + if (!ok) { + failed++; + fprintf(stderr, "FAIL: %s\n", what); + } +} + +static void from_hex(mbedtls_mpi *x, const char *hex) { + if (mbedtls_mpi_read_string(x, 16, hex) != 0) scr_trap("bad hex\n"); +} + +/* The Montgomery exponentiation, with the base 2 and with general bases, + * against mbedtls_mpi_exp_mod for moduli of one to 64 limbs. */ +static void test_mont_pow(void) { +#if SD_MONT + static const size_t sizes[] = {3, 64, 65, 127, 128, 129, 512, 1000, 2048, 4096}; + mbedtls_mpi n, base, e, two, got, want; + mbedtls_mpi_init(&n); + mbedtls_mpi_init(&base); + mbedtls_mpi_init(&e); + mbedtls_mpi_init(&two); + mbedtls_mpi_init(&got); + mbedtls_mpi_init(&want); + mbedtls_mpi_lset(&two, 2); + for (size_t s = 0; s < sizeof sizes / sizeof sizes[0]; s++) { + for (int trial = 0; trial < 6; trial++) { + size_t bits = sizes[s]; + sd_random_bits(&n, bits, true); + if (mbedtls_mpi_cmp_int(&n, 3) <= 0) mbedtls_mpi_lset(&n, 7); + sd_random_bits(&base, bits > 2 ? bits - 1 : 1, false); + size_t ebits = trial == 0 ? 1 : trial == 1 ? bits + 70 : (bits * (size_t)trial) / 5 + 1; + sd_random_bits(&e, ebits, false); + if (trial == 0) mbedtls_mpi_lset(&e, 0); + ScDhMont m; + bool ready = sd_mont_init(&m, &n); + check(ready, "sd_mont_init"); + char what[96]; + snprintf(what, sizeof what, "base^e mod n for %zu bits, trial %d", bits, trial); + bool ok = ready && sd_mont_pow(&m, &got, &base, &e) && mbedtls_mpi_exp_mod(&want, &base, &e, &n, NULL) == 0; + check(ok && mbedtls_mpi_cmp_mpi(&got, &want) == 0, what); + snprintf(what, sizeof what, "2^e mod n for %zu bits, trial %d", bits, trial); + ok = ready && sd_mont_pow(&m, &got, NULL, &e) && mbedtls_mpi_exp_mod(&want, &two, &e, &n, NULL) == 0; + check(ok && mbedtls_mpi_cmp_mpi(&got, &want) == 0, what); + sd_mont_free(&m); + } + } + mbedtls_mpi_free(&n); + mbedtls_mpi_free(&base); + mbedtls_mpi_free(&e); + mbedtls_mpi_free(&two); + mbedtls_mpi_free(&got); + mbedtls_mpi_free(&want); +#endif +} + +/* BN_check_prime's answers for small values, Mersenne numbers, Carmichael + * numbers and strong pseudoprimes to small prime bases. */ +static void test_is_prime(void) { + static const struct { + const char *hex; + bool prime; + } cases[] = { + {"0", false}, + {"1", false}, + {"2", true}, + {"3", true}, + {"4", false}, + {"5", true}, + {"9", false}, + {"231", false}, /* 561, a Carmichael number */ + {"451", false}, /* 1105, a Carmichael number */ + {"7ff", false}, /* 2047, a strong pseudoprime to the base 2 */ + {"45c5", false}, /* 17861 = 53 · 337 */ + {"45c7", true}, /* 17863, the largest trial-division prime */ + {"bfa17dc7", false}, /* 3215031751, to the bases 2, 3, 5 and 7 */ + {"351591274f9af9fb", false}, /* 3825123056546413051, to the bases up to 23 */ + {"437ae92817f9fc85b7e5", false}, /* to the prime bases up to 37 */ + {"2be6951adc5b22410a5fd", false}, /* to the prime bases up to 41 */ + {"1fffffffffffffff", true}, /* 2^61 - 1 */ + {"1ffffffffffffffffffffff", true}, /* 2^89 - 1 */ + {"7fffffffffffffffffffffffffffffff", true}, /* 2^127 - 1 */ + {"100000000000000000000000000000001", false}, /* 2^128 + 1 */ + }; + ScDhSmallPrimes *small = sd_small_primes(); + mbedtls_mpi x; + mbedtls_mpi_init(&x); + for (size_t i = 0; i < sizeof cases / sizeof cases[0]; i++) { + from_hex(&x, cases[i].hex); + char what[96]; + snprintf(what, sizeof what, "is_prime(0x%s) == %d", cases[i].hex, cases[i].prime); + check(sd_is_prime(small, &x) == cases[i].prime, what); + } + /* The modp groups' primes are safe primes. */ + for (size_t i = 0; i < 4; i++) { + mbedtls_mpi_read_binary(&x, sd_groups[i].p, sd_groups[i].p_len); + check(sd_is_prime(small, &x), "a modp prime is prime"); + mbedtls_mpi_shift_r(&x, 1); + check(sd_is_prime(small, &x), "half a modp prime is prime"); + mbedtls_mpi_add_int(&x, &x, 2); + check(!sd_is_prime(small, &x), "half a modp prime plus 2 is composite"); + } + mbedtls_mpi_free(&x); + free(small); +} + +/* DH_check bits for small and composite primes, the Pocklington path for + * safe primes, and a generator at p - 1. */ +static void test_check_params(void) { + static const struct { + const char *p; + int g; + int codes; + } cases[] = { + {"0", 2, 137}, {"1", 2, 137}, {"2", 2, 139}, {"3", 2, 138}, {"5", 2, 128}, {"5", 5, 136}, + {"7", 2, 128}, {"9", 2, 129}, {"f", 2, 129}, {"11", 2, 130}, {"17", 2, 128}, {"17", 22, 136}, + {"18", 2, 129}, {"231", 2, 129}, {"7ff", 2, 129}, + }; + mbedtls_mpi p, g; + mbedtls_mpi_init(&p); + mbedtls_mpi_init(&g); + for (size_t i = 0; i < sizeof cases / sizeof cases[0]; i++) { + from_hex(&p, cases[i].p); + mbedtls_mpi_lset(&g, cases[i].g); + char what[96]; + int codes = sd_check_params(&p, &g); + snprintf(what, sizeof what, "check(0x%s, %d) == %d (got %d)", cases[i].p, cases[i].g, cases[i].codes, codes); + check(codes == cases[i].codes, what); + } + mbedtls_mpi_read_binary(&p, sd_groups[1].p, sd_groups[1].p_len); + mbedtls_mpi_lset(&g, 2); + check(sd_check_params(&p, &g) == 0, "check(modp2, 2) == 0"); + mbedtls_mpi_sub_int(&g, &p, 1); + check(sd_check_params(&p, &g) == SD_NOT_SUITABLE_GENERATOR, "check(modp2, p - 1) == 8"); + mbedtls_mpi_lset(&g, 2); + mbedtls_mpi_add_int(&p, &p, 2); + check(sd_check_params(&p, &g) == SD_P_NOT_PRIME, "check(modp2 + 2, 2) == 1"); + mbedtls_mpi_free(&p); + mbedtls_mpi_free(&g); +} + +/* Exponents past 8192 bits, split into digits, against the exponent + * reduced modulo p - 1 (Fermat) for a prime p. */ +static void test_long_exponent(void) { + mbedtls_mpi p, p1, base, e, reduced, got, want; + mbedtls_mpi_init(&p); + mbedtls_mpi_init(&p1); + mbedtls_mpi_init(&base); + mbedtls_mpi_init(&e); + mbedtls_mpi_init(&reduced); + mbedtls_mpi_init(&got); + mbedtls_mpi_init(&want); + mbedtls_mpi_read_binary(&p, sd_groups[0].p, sd_groups[0].p_len); + mbedtls_mpi_sub_int(&p1, &p, 1); + mbedtls_mpi_lset(&base, 5); + static const size_t sizes[] = {8192, 8193, 16382, 16383, 20000}; + for (size_t i = 0; i < sizeof sizes / sizeof sizes[0]; i++) { + sd_random_bits(&e, sizes[i], false); + mbedtls_mpi_mod_mpi(&reduced, &e, &p1); + bool ok = sd_exp(&got, &base, &e, &p) && mbedtls_mpi_exp_mod(&want, &base, &reduced, &p, NULL) == 0; + char what[64]; + snprintf(what, sizeof what, "5^e mod p for a %zu-bit e", sizes[i]); + check(ok && mbedtls_mpi_cmp_mpi(&got, &want) == 0, what); + } + mbedtls_mpi_lset(&p, 24); + check(!sd_exp(&got, &base, &e, &p), "an even modulus fails"); + mbedtls_mpi_lset(&p, 1); + check(!sd_exp(&got, &base, &e, &p), "the modulus 1 fails"); + mbedtls_mpi_free(&p); + mbedtls_mpi_free(&p1); + mbedtls_mpi_free(&base); + mbedtls_mpi_free(&e); + mbedtls_mpi_free(&reduced); + mbedtls_mpi_free(&got); + mbedtls_mpi_free(&want); +} + +/* Generated safe primes have the requested length and congruence, and + * mbedTLS's own primality test accepts p and (p - 1) / 2. */ +static void test_generate(void) { + static const unsigned adds[] = {24, 60, 12}; + mbedtls_mpi p, q, g; + mbedtls_mpi_init(&p); + mbedtls_mpi_init(&q); + mbedtls_mpi_init(&g); + mbedtls_mpi_lset(&g, 2); + for (size_t i = 0; i < sizeof adds / sizeof adds[0]; i++) { + for (int trial = 0; trial < 2; trial++) { + bool ok = sd_generate_safe_prime(&p, 512, adds[i], adds[i] - 1); + mbedtls_mpi_uint r = 0; + ok = ok && mbedtls_mpi_bitlen(&p) == 512 && mbedtls_mpi_mod_int(&r, &p, adds[i]) == 0 && r == adds[i] - 1; + mbedtls_mpi_copy(&q, &p); + mbedtls_mpi_shift_r(&q, 1); + ok = ok && mbedtls_mpi_is_prime_ext(&p, 40, sd_random, NULL) == 0 && + mbedtls_mpi_is_prime_ext(&q, 40, sd_random, NULL) == 0; + char what[64]; + snprintf(what, sizeof what, "a 512-bit safe prime ≡ %u (mod %u)", adds[i] - 1, adds[i]); + check(ok, what); + check(sd_check_params(&p, &g) == 0, "a generated prime has no DH_check findings"); + } + } + mbedtls_mpi_free(&p); + mbedtls_mpi_free(&q); + mbedtls_mpi_free(&g); +} + +int main(void) { + test_mont_pow(); + test_is_prime(); + test_check_params(); + test_long_exponent(); + test_generate(); + fprintf(stderr, "%ld/%ld cases passed\n", total - failed, total); + return failed ? 1 : 0; +} diff --git a/tests/corpus/6706-dh-groups.ts b/tests/corpus/6706-dh-groups.ts new file mode 100644 index 000000000..24c8b5773 --- /dev/null +++ b/tests/corpus/6706-dh-groups.ts @@ -0,0 +1,52 @@ +// crypto.getDiffieHellman and createDiffieHellmanGroup on every modp +// group: the RFC primes and generator, verifyError, case-insensitive names, +// private keys of the group's width, and key pairs that agree on one +// secret of the prime's length. +import { createDiffieHellmanGroup, getDiffieHellman, type DiffieHellmanGroup } from "node:crypto"; + +const groups = ["modp1", "modp2", "modp5", "modp14", "modp15", "modp16", "modp17", "modp18"]; + +function bitLength(bytes: Buffer): number { + if (bytes.length === 0) return 0; + return (bytes.length - 1) * 8 + bytes[0]!.toString(2).length; +} + +for (const name of groups) { + const group: DiffieHellmanGroup = getDiffieHellman(name); + const prime: Buffer = group.getPrime(); + console.log( + name, + group.verifyError, + bitLength(prime), + prime.toString("hex").slice(0, 24), + prime.toString("hex").slice(-16), + group.getGenerator("hex"), + ); +} + +// Key exchange on the groups whose exponentiations stay quick. +for (const name of ["modp1", "modp2", "modp5", "modp14"]) { + const alice = getDiffieHellman(name); + const bob = createDiffieHellmanGroup(name.toUpperCase()); + const alicePublic: Buffer = alice.generateKeys(); + const bobPublic: string = bob.generateKeys("base64"); + const fromAlice: Buffer = alice.computeSecret(bobPublic, "base64"); + const fromBob: string = bob.computeSecret(alicePublic, null, "hex"); + const width = bitLength(alice.getPrivateKey()); + console.log( + name, + fromAlice.length, + fromAlice.toString("hex") === fromBob, + alicePublic.length <= fromAlice.length, + name === "modp1" || name === "modp2" ? width <= bitLength(alice.getPrime()) : width, + ); + // generateKeys keeps the key pair it has. + console.log(alice.generateKeys("hex") === alicePublic.toString("hex"), alice.getPublicKey().equals(alicePublic)); +} + +// The prime and generator in every encoding. +const modp5 = getDiffieHellman("Modp5"); +for (const encoding of ["hex", "base64", "base64url", "latin1", "binary"] as const) { + const prime: string = modp5.getPrime(encoding as "hex"); + console.log(encoding, prime.length, JSON.stringify(modp5.getGenerator(encoding as "hex"))); +} diff --git a/tests/corpus/6707-dh-explicit-params.ts b/tests/corpus/6707-dh-explicit-params.ts new file mode 100644 index 000000000..57e239d73 --- /dev/null +++ b/tests/corpus/6707-dh-explicit-params.ts @@ -0,0 +1,169 @@ +// crypto.createDiffieHellman over explicit parameters: fixed private keys +// give Node's public keys and secrets, verifyError reports DH_check's +// findings, and parameters that equal an OpenSSL named group draw private +// keys of the group's length. +import { createDiffieHellman, getDiffieHellman, type DiffieHellman } from "node:crypto"; + +// A 512-bit safe prime with p ≡ 23 (mod 24). +const P512 = + "f29864297728009aab9d4220c05ca2d80a5e4ac2f016cd098543a2486bde8bcb" + + "deed9eab7029c8d2b7a681f9495bfc7b1c39c6db64457bb79beeb74a4b78f5ff"; + +function bitLength(bytes: Buffer): number { + if (bytes.length === 0) return 0; + return (bytes.length - 1) * 8 + bytes[0]!.toString(2).length; +} + +function fixed(prime: Buffer, generator: number | Buffer, key: string): DiffieHellman { + const dh = createDiffieHellman(prime, generator); + dh.setPrivateKey(key, "hex"); + return dh; +} + +const prime512 = Buffer.from(P512, "hex"); +for (const generator of [2, 3, 5, Buffer.from([0x0b])]) { + const alice = fixed(prime512, generator, "0123456789abcdef0123456789abcdef"); + const bob = fixed(prime512, generator, "fedcba9876543210fedcba9876543210ff"); + const alicePublic: string = alice.generateKeys("hex"); + const bobPublic: Buffer = bob.generateKeys(); + const secret: string = alice.computeSecret(bobPublic, null, "hex"); + console.log(alice.getGenerator("hex"), alice.verifyError, alicePublic.slice(0, 32), bobPublic.length); + console.log(secret, secret === bob.computeSecret(alicePublic, "hex", "hex")); +} + +// Secrets pad to the prime's length; public keys are minimal. +const modp1 = getDiffieHellman("modp1").getPrime(); +const small = fixed(modp1, 2, "01"); +console.log(small.generateKeys("hex"), small.getPrivateKey("hex")); +const big = fixed(modp1, 2, "ff".repeat(100)); +console.log(big.generateKeys().length, big.getPrivateKey().length); +const padded: Buffer = small.computeSecret(Buffer.from([4])); +console.log(padded.length, padded.subarray(0, 4).toString("hex"), padded.subarray(-2).toString("hex")); +console.log(big.computeSecret(Buffer.from([2]), null, "base64url")); + +// A private key of 0 still yields a public key; reading it back and +// deriving a secret from it fail. A private key of 1 answers the peer's +// key. +function report(run: () => unknown): void { + try { + const result = run(); + console.log(Buffer.isBuffer(result) ? result.toString("hex") : result); + } catch (error) { + const e = error as Error & { code?: string }; + console.log(e.name, e.code, e.message); + } +} +const zero = fixed(prime512, 2, "00"); +console.log(zero.generateKeys("hex")); +report(() => zero.getPrivateKey()); +report(() => zero.computeSecret(Buffer.from([5]))); +report(() => fixed(prime512, 2, "01").computeSecret(Buffer.from([5]))); + +// A private key longer than the prime: 8800 bits. +const long = fixed(modp1, 2, "ff".repeat(1100)); +console.log(long.generateKeys("hex").slice(0, 32), long.computeSecret(Buffer.from([7]), null, "hex").slice(-32)); + +// setPublicKey and setPrivateKey answer the object and replace the keys. +const keys = createDiffieHellman(prime512); +keys.setPublicKey(Buffer.from([0, 0, 7])); +keys.setPrivateKey("0005", "hex"); +console.log(keys.getPublicKey("hex"), keys.getPrivateKey("hex")); +console.log(keys.generateKeys("hex").length, keys.getPublicKey("hex") !== "07"); + +// verifyError for small, even, composite and non-safe primes and for +// unsuitable generators. +const cases: [string, number | string][] = [ + ["01", 2], + ["02", 2], + ["03", 2], + ["0d", 2], + ["15", 2], + ["17", 2], + ["17", 5], + ["17", "16"], + ["17", "1e"], + ["18", 2], + ["000017", 2], + ["05", 2], + ["05", 5], + ["07", 2], + ["09", 2], + ["0b", 5], + ["0f", 2], + ["11", 2], + ["2f", 2], + ["3b", 5], + ["0231", 2], + ["0451", 2], + ["07ff", 2], +]; +for (const [prime, generator] of cases) { + const g = typeof generator === "number" ? generator : Buffer.from(generator, "hex"); + console.log(prime, generator, createDiffieHellman(Buffer.from(prime, "hex"), g).verifyError); +} +const almost = Buffer.from(P512, "hex"); +almost[almost.length - 1] = 0xfe; +console.log(createDiffieHellman(almost).verifyError); +const composite = Buffer.from(P512, "hex"); +composite[composite.length - 1] = 0xfd; +console.log(createDiffieHellman(composite).verifyError); +const generatorPMinus1 = Buffer.from(P512, "hex"); +generatorPMinus1[generatorPMinus1.length - 1] = 0xfe; +console.log(createDiffieHellman(prime512, generatorPMinus1).verifyError); + +// Generated keys: bits(p) - 2 bits for other primes, at most the named +// group's key length for RFC 3526 and RFC 5114 parameters. +const generated = createDiffieHellman(prime512); +generated.generateKeys(); +console.log(bitLength(generated.getPrivateKey())); +const modp14 = getDiffieHellman("modp14").getPrime(); +const named = createDiffieHellman(modp14, Buffer.from([0, 2])); +named.generateKeys(); +console.log(named.verifyError, bitLength(named.getPrivateKey()) <= 225); +const notNamed = createDiffieHellman(modp1); +notNamed.generateKeys(); +console.log(bitLength(notNamed.getPrivateKey())); +const rfc5114 = createDiffieHellman( + Buffer.from( + "b10b8f96a080e01dde92de5eae5d54ec52c99fbcfb06a3c69a6a9dca52d23b616073e28675a23d189838ef1e2ee652c0" + + "13ecb4aea906112324975c3cd49b83bfaccbdd7d90c4bd7098488e9c219a73724effd6fae5644738faa31a4ff55bccc0" + + "a151af5f0dc8b4bd45bf37df365c1a65e68cfda76d4da708df1fb2bc2e4a4371", + "hex", + ), + Buffer.from( + "a4d1cbd5c3fd34126765a442efb99905f8104dd258ac507fd6406cff14266d31266fea1e5c41564b777e690f5504f213" + + "160217b4b01b886a5e91547f9e2749f4d7fbd7d3b9a92ee1909d0d2263f80a76a6a24c087a091f531dbf0a0169b6a28a" + + "d662a4d18e73afa32d779d5918d08bc8858f4dcef97c2a24855e6eeb22b3b2e5", + "hex", + ), +); +rfc5114.generateKeys(); +console.log(rfc5114.verifyError, bitLength(rfc5114.getPrivateKey()) <= 160); +// RFC 5114's 2048-bit group with a 256-bit subgroup draws 224-bit keys. +const rfc5114q256 = createDiffieHellman( + Buffer.from( + "87a8e61db4b6663cffbbd19c651959998ceef608660dd0f25d2ceed4435e3b00e00df8f1d61957d4faf7df4561b2aa30" + + "16c3d91134096faa3bf4296d830e9a7c209e0c6497517abd5a8a9d306bcf67ed91f9e6725b4758c022e0b1ef4275bf7b" + + "6c5bfc11d45f9088b941f54eb1e59bb8bc39a0bf12307f5c4fdb70c581b23f76b63acae1caa6b7902d52526735488a0e" + + "f13c6d9a51bfa4ab3ad8347796524d8ef6a167b5a41825d967e144e5140564251ccacb83e6b486f6b3ca3f7971506026" + + "c0b857f689962856ded4010abd0be621c3a3960a54e710c375f26375d7014103a4b54330c198af126116d2276e11715f" + + "693877fad7ef09cadb094ae91e1a1597", + "hex", + ), + Buffer.from( + "3fb32c9b73134d0b2e77506660edbd484ca7b18f21ef205407f4793a1a0ba12510dbc15077be463fff4fed4aac0bb555" + + "be3a6c1b0c6b47b1bc3773bf7e8c6f62901228f8c28cbb18a55ae31341000a650196f931c77a57f2ddf463e5e9ec144b" + + "777de62aaab8a8628ac376d282d6ed3864e67982428ebc831d14348f6f2f9193b5045af2767164e1dfc967c1fb3f2e55" + + "a4bd1bffe83b9c80d052b985d182ea0adb2a3b7313d3fe14c8484b1e052588b9b7d2bbd2df016199ecd06e1557cd0915" + + "b3353bbb64e0ec377fd028370df92b52c7891428cdc67eb6184b523d1db246c32f63078490f00ef8d647d148d4795451" + + "5e2327cfef98c582664b4c0f6cc41659", + "hex", + ), +); +let widest = 0; +for (let i = 0; i < 8; i++) { + const keys = createDiffieHellman(rfc5114q256.getPrime(), rfc5114q256.getGenerator()); + keys.generateKeys(); + widest = Math.max(widest, bitLength(keys.getPrivateKey())); +} +console.log(rfc5114q256.verifyError, widest <= 224, widest > 200); diff --git a/tests/corpus/6708-dh-errors.js b/tests/corpus/6708-dh-errors.js new file mode 100644 index 000000000..e092da727 --- /dev/null +++ b/tests/corpus/6708-dh-errors.js @@ -0,0 +1,147 @@ +// createDiffieHellman, getDiffieHellman and DiffieHellman errors from +// JavaScript: argument types and ranges, the keyEncoding and generator +// forms, OpenSSL's generator and modulus errors with their library and +// reason properties, parameter sizes, group names, encodings, keys read +// before they exist, public keys outside (1, p - 1), key generation and +// secrets on primes outside 512 to 10000 bits, and members a +// DiffieHellmanGroup does not have. +import crypto from "node:crypto"; + +// Values the declared overloads reject reach the calls through an +// untyped function, as they would from other untyped code. +const loose = (value) => value; + +function attempt(label, run) { + try { + const result = run(); + if (Buffer.isBuffer(result)) console.log(label, "ok", result.toString("hex")); + else if (typeof result === "object" && result !== null) + console.log(label, "ok", result.getGenerator("hex"), result.getPrime().length); + else console.log(label, "ok", JSON.stringify(result)); + } catch (e) { + const extra = e.library === undefined ? "" : ` [${Object.keys(e).join(",")}] ${e.library} / ${e.reason}`; + console.log(label, e.name, e.code, e.message + extra); + } +} + +const prime = crypto.getDiffieHellman("modp1").getPrime(); + +attempt("size missing", () => crypto.createDiffieHellman(loose(undefined))); +attempt("size null", () => crypto.createDiffieHellman(loose(null))); +attempt("size boolean", () => crypto.createDiffieHellman(loose(true))); +attempt("size object", () => crypto.createDiffieHellman(loose({}))); +attempt("size bigint", () => crypto.createDiffieHellman(loose(5n))); +attempt("size fraction", () => crypto.createDiffieHellman(1.5)); +attempt("size NaN", () => crypto.createDiffieHellman(NaN)); +attempt("size 2^31", () => crypto.createDiffieHellman(2 ** 31)); +attempt("size 2^40", () => crypto.createDiffieHellman(2 ** 40)); +attempt("size -1", () => crypto.createDiffieHellman(-1)); +attempt("size -0", () => crypto.createDiffieHellman(-0)); +attempt("size 1", () => crypto.createDiffieHellman(1)); +attempt("size 1 bad generator", () => crypto.createDiffieHellman(1, 1)); +attempt("size 2 generator 1", () => crypto.createDiffieHellman(2, 1)); +attempt("size 2", () => crypto.createDiffieHellman(2)); +attempt("size 511", () => crypto.createDiffieHellman(511)); +attempt("size 10001", () => crypto.createDiffieHellman(10001)); +attempt("size generator string", () => crypto.createDiffieHellman(64, loose("02"))); +attempt("size generator view", () => crypto.createDiffieHellman(64, loose(Buffer.from([2])))); + +attempt("generator 0", () => crypto.createDiffieHellman(prime, 0)); +attempt("generator 1", () => crypto.createDiffieHellman(prime, 1)); +attempt("generator -1", () => crypto.createDiffieHellman(prime, -1)); +attempt("generator fraction", () => crypto.createDiffieHellman(prime, 2.5)); +attempt("generator 2^31", () => crypto.createDiffieHellman(prime, 2 ** 31)); +attempt("generator NaN", () => crypto.createDiffieHellman(prime, NaN)); +attempt("generator null", () => crypto.createDiffieHellman(prime, loose(null))); +attempt("generator empty string", () => crypto.createDiffieHellman(prime, loose(""))); +attempt("generator true", () => crypto.createDiffieHellman(prime, loose(true))); +attempt("generator object", () => crypto.createDiffieHellman(prime, loose({}))); +attempt("generator view 1", () => crypto.createDiffieHellman(prime, Buffer.from([1]))); +attempt("generator view 0", () => crypto.createDiffieHellman(prime, Buffer.from([0]))); +attempt("generator view empty", () => crypto.createDiffieHellman(prime, Buffer.alloc(0))); +attempt("generator view 0002", () => crypto.createDiffieHellman(prime, Buffer.from([0, 2]))); +attempt("generator = p", () => crypto.createDiffieHellman(prime, prime)); +attempt("generator > p", () => crypto.createDiffieHellman(prime, Buffer.concat([Buffer.from([1]), prime]))); +attempt("generator string", () => crypto.createDiffieHellman(prime, loose("abc"))); +attempt("generator string hex", () => crypto.createDiffieHellman(prime, loose("05"), loose("hex"))); +attempt("generator bad encoding", () => crypto.createDiffieHellman(prime, loose("05"), loose("nope"))); +attempt("generator uint16", () => crypto.createDiffieHellman(prime, new Uint16Array([0x0300]))); + +attempt("prime hex", () => crypto.createDiffieHellman(prime.toString("hex"), "hex")); +attempt("prime base64 generator", () => crypto.createDiffieHellman(prime.toString("base64"), "base64", 5)); +attempt("prime utf8", () => crypto.createDiffieHellman("abc").verifyError); +attempt("prime buffer encoding", () => crypto.createDiffieHellman("abc", "buffer")); +attempt("keyEncoding as generator", () => crypto.createDiffieHellman("abc", loose("nope")).verifyError); +attempt("keyEncoding as generator with encoding", () => crypto.createDiffieHellman("abc", loose("nope"), loose("hex"))); +attempt("keyEncoding number", () => crypto.createDiffieHellman(prime, loose(5))); +attempt("keyEncoding on a view", () => crypto.createDiffieHellman(prime, loose("hex"), 5)); +attempt("prime ArrayBuffer", () => crypto.createDiffieHellman(new Uint8Array(prime).buffer)); +attempt("prime DataView", () => crypto.createDiffieHellman(new DataView(new ArrayBuffer(3))).verifyError); +attempt("prime zero", () => crypto.createDiffieHellman(Buffer.alloc(4)).getPrime()); + +attempt("group unknown", () => crypto.getDiffieHellman("modp3")); +attempt("group empty", () => crypto.getDiffieHellman("")); +attempt("group ffdhe", () => crypto.createDiffieHellmanGroup("ffdhe2048")); +attempt("group case", () => crypto.getDiffieHellman("MoDp2")); +attempt("group missing", () => crypto.getDiffieHellman(loose(undefined))); +attempt("group number", () => crypto.getDiffieHellman(loose(14))); + +const group = crypto.getDiffieHellman("modp2"); +attempt("group public before keys", () => group.getPublicKey()); +attempt("group private before keys", () => group.getPrivateKey()); +attempt("group secret before keys", () => group.computeSecret(Buffer.from([5]))); +const untypedGroup = loose(group); +attempt("group setPublicKey", () => untypedGroup.setPublicKey(Buffer.from([5]))); +attempt("group setPrivateKey", () => untypedGroup.setPrivateKey(Buffer.from([5]))); +group.generateKeys(); +attempt("secret 0", () => group.computeSecret(Buffer.from([0]))); +attempt("secret empty", () => group.computeSecret(Buffer.alloc(0))); +attempt("secret 1", () => group.computeSecret(Buffer.from([0, 1]))); +attempt("secret p - 1", () => { + const key = Buffer.from(group.getPrime()); + key[key.length - 1]--; + return group.computeSecret(key); +}); +attempt("secret p", () => group.computeSecret(group.getPrime())); +attempt("secret 2", () => group.computeSecret(Buffer.from([2])).length); +attempt("secret number", () => group.computeSecret(loose(5))); +attempt("secret bad input encoding", () => group.computeSecret("ab", loose("nope"))); +attempt("secret bad output encoding", () => untypedGroup.computeSecret(Buffer.from([2]), null, "nope")); +attempt("getPrime bad encoding", () => untypedGroup.getPrime("nope")); +attempt("getPrime HEX", () => untypedGroup.getPrime("HEX").slice(0, 8)); +attempt("getGenerator utf16le", () => untypedGroup.getGenerator("utf16le")); +attempt("verifyError call", () => untypedGroup.verifyError()); +attempt("unknown member", () => untypedGroup.bogus()); + +const fresh = crypto.createDiffieHellman(prime); +attempt("public before keys", () => fresh.getPublicKey()); +attempt("private before keys", () => fresh.getPrivateKey()); +attempt("secret before keys", () => fresh.computeSecret(Buffer.from([5]))); +attempt("setPublicKey number", () => fresh.setPublicKey(loose(5))); +attempt("setPrivateKey bad encoding", () => fresh.setPrivateKey("ab", loose("nope"))); +attempt("setPublicKey 0", () => loose(fresh.setPublicKey(Buffer.from([0]))).getPublicKey()); +attempt("setPrivateKey utf8", () => loose(fresh.setPrivateKey("ab")).getPrivateKey("hex")); + +// Primes outside 512 to 10000 bits: key generation and secrets fail, but a +// private key the program sets still yields a public key. +for (const value of [23, 1, 0, 24]) { + const label = `p ${value}`; + const dh = crypto.createDiffieHellman(Buffer.from([value])); + attempt(`${label} generateKeys`, () => dh.generateKeys()); + attempt(`${label} secret 2`, () => dh.computeSecret(Buffer.from([2]))); + attempt(`${label} secret 5`, () => dh.computeSecret(Buffer.from([5]))); + dh.setPrivateKey(Buffer.from([3])); + attempt(`${label} generateKeys with key`, () => dh.generateKeys()); + attempt(`${label} public with key`, () => dh.getPublicKey()); + attempt(`${label} secret with key`, () => dh.computeSecret(Buffer.from([5]))); +} +const even = Buffer.from(prime); +even[even.length - 1] = 0xfe; +const evenDh = crypto.createDiffieHellman(even); +attempt("even generateKeys", () => evenDh.generateKeys()); +evenDh.setPrivateKey(Buffer.from([3])); +attempt("even generateKeys with key", () => evenDh.generateKeys()); +attempt("p 23 generator 30", () => + loose(crypto.createDiffieHellman(Buffer.from([23]), 30).setPrivateKey(Buffer.from([2]))).generateKeys(), +); +attempt("p 9", () => loose(crypto.createDiffieHellman(Buffer.from([9])).setPrivateKey(Buffer.from([3]))).generateKeys()); diff --git a/tests/corpus/6709-dh-generate.ts b/tests/corpus/6709-dh-generate.ts new file mode 100644 index 000000000..b041605c2 --- /dev/null +++ b/tests/corpus/6709-dh-generate.ts @@ -0,0 +1,47 @@ +// crypto.createDiffieHellman(primeLength, generator) generates a safe +// prime of the requested length: p ≡ 23 (mod 24) for the generator 2, +// p ≡ 59 (mod 60) for 5 and p ≡ 11 (mod 12) otherwise. A second party built +// from the first one's prime and generator agrees on the secret. +import { createDiffieHellman } from "node:crypto"; + +function bitLength(bytes: Buffer): number { + if (bytes.length === 0) return 0; + return (bytes.length - 1) * 8 + bytes[0]!.toString(2).length; +} + +function mod(bytes: Buffer, m: number): number { + let r = 0; + for (const byte of bytes) r = (r * 256 + byte) % m; + return r; +} + +for (const generator of [undefined, 2, 5, 3, 7]) { + const alice = generator === undefined ? createDiffieHellman(512) : createDiffieHellman(512, generator); + const prime = alice.getPrime(); + console.log( + generator, + bitLength(prime), + alice.getGenerator("hex"), + alice.verifyError, + generator === undefined || generator === 2 + ? mod(prime, 24) + : generator === 5 + ? mod(prime, 60) + : mod(prime, 12), + ); + const bob = createDiffieHellman(alice.getPrime(), alice.getGenerator()); + const alicePublic = alice.generateKeys(); + const bobPublic = bob.generateKeys("hex"); + const secret = alice.computeSecret(bobPublic, "hex"); + console.log( + bob.verifyError, + bitLength(alice.getPrivateKey()), + secret.length, + secret.equals(bob.computeSecret(alicePublic)), + ); +} + +// A string prime with its encoding, and the generator as a string. +const shared = createDiffieHellman(512); +const copy = createDiffieHellman(shared.getPrime("base64"), "base64", shared.getGenerator("hex"), "hex"); +console.log(copy.getPrime().equals(shared.getPrime()), copy.getGenerator("hex"), copy.verifyError); diff --git a/tests/corpus/6710-dh-encodings.cjs b/tests/corpus/6710-dh-encodings.cjs new file mode 100644 index 000000000..100ee95e2 --- /dev/null +++ b/tests/corpus/6710-dh-encodings.cjs @@ -0,0 +1,73 @@ +// DiffieHellman string inputs and outputs from CommonJS: primes and +// generators as strings in every binary encoding, the keyEncoding slot +// read as the generator, keys set in every Buffer encoding and read in the +// declared ones, and computeSecret's input and output encodings. +const crypto = require("node:crypto"); + +// Values the declared overloads do not cover reach the calls through an +// untyped function, as they would from other untyped code. +const loose = (value) => value; + +const prime = crypto.getDiffieHellman("modp2").getPrime(); +const encodings = ["hex", "base64", "base64url", "latin1", "binary", "HEX", "Base64"]; + +for (const encoding of encodings) { + const text = prime.toString(encoding.toLowerCase()); + const dh = crypto.createDiffieHellman(text, encoding, "05", "hex"); + console.log(encoding, dh.getPrime().equals(prime), dh.getGenerator("hex")); +} +console.log(crypto.createDiffieHellman(prime.toString("hex"), "hex", "05", "hex").verifyError); + +// A truthy keyEncoding that names no encoding is the generator, and the +// generator slot its encoding. +console.log(crypto.createDiffieHellman(prime, 7).getGenerator("hex")); +console.log(crypto.createDiffieHellman(prime, "\x05").getGenerator("hex")); +console.log(crypto.createDiffieHellman(prime, Buffer.from([3])).getGenerator("hex")); +console.log(crypto.createDiffieHellman(prime, "buffer", 11).getGenerator("hex")); +console.log(crypto.createDiffieHellman(prime, "0d", "hex").getGenerator("hex")); +console.log(crypto.createDiffieHellman(prime, "base64", "Ew==", "base64").getGenerator("hex")); +console.log(crypto.createDiffieHellman(prime, "", 0, "").getGenerator("hex")); + +// Keys in and out of every encoding. +const alice = crypto.createDiffieHellman(prime); +const bob = crypto.createDiffieHellman(prime); +alice.setPrivateKey("q83vEjRWeJA=", "base64"); +bob.setPrivateKey(Buffer.from("10325476", "hex")); +alice.generateKeys(); +bob.generateKeys(); +function report(encoding, key, secret) { + const bytes = Buffer.isBuffer(secret) ? secret : Buffer.from(secret, encoding); + console.log(encoding, typeof key, key.length, bytes.toString("hex").slice(0, 24)); +} +const hex = alice.getPublicKey("hex"); +report("hex", hex, bob.computeSecret(hex, "hex", "hex")); +const base64 = alice.getPublicKey("base64"); +report("base64", base64, bob.computeSecret(base64, "base64", "base64")); +const base64url = alice.getPublicKey("base64url"); +report("base64url", base64url, bob.computeSecret(base64url, "base64url", "base64url")); +const binary = alice.getPublicKey("binary"); +report("binary", binary, bob.computeSecret(binary, "binary", "binary")); +const view = alice.getPublicKey(); +report("undefined", view, bob.computeSecret(view, undefined, undefined)); +report("null", view, bob.computeSecret(view, null, null)); +// Encodings @types/node does not declare for these methods reach them +// through an untyped receiver. +const untypedBob = loose(bob); +console.log(alice.getPrivateKey("hex"), alice.getPrivateKey("base64url"), untypedBob.getPrivateKey("latin1").length); +console.log(untypedBob.getPublicKey("utf16le").length, untypedBob.getPrime("ucs2").length, untypedBob.getGenerator("buffer")); +console.log(untypedBob.computeSecret(loose(alice).getPublicKey("latin1"), "latin1", "base64").slice(0, 16)); + +// setPublicKey and setPrivateKey read strings through their encoding; +// 'buffer' and a missing encoding read utf8. +const keys = crypto.createDiffieHellman(prime); +keys.setPublicKey("ffee", "hex"); +loose(keys).setPrivateKey("zz", "buffer"); +console.log(keys.getPublicKey("hex"), keys.getPrivateKey("hex")); +keys.setPublicKey("é"); +console.log(keys.getPublicKey("hex")); +keys.setPublicKey("é", "latin1"); +console.log(keys.getPublicKey("hex")); +keys.setPrivateKey(new Uint16Array([0x0102, 0x0304])); +console.log(keys.getPrivateKey("hex")); +keys.setPrivateKey(new DataView(new Uint8Array([9, 8, 7]).buffer)); +console.log(keys.getPrivateKey("hex")); diff --git a/tests/corpus/6711-dh-handles.ts b/tests/corpus/6711-dh-handles.ts new file mode 100644 index 000000000..c0c5522be --- /dev/null +++ b/tests/corpus/6711-dh-handles.ts @@ -0,0 +1,56 @@ +// DiffieHellman and DiffieHellmanGroup values as ordinary values: class +// fields, optional fields, arrays, Map values, parameters and return +// values, with verifyError read through each. +import * as crypto from "node:crypto"; +import { type DiffieHellman, type DiffieHellmanGroup } from "node:crypto"; + +const prime = crypto.getDiffieHellman("modp1").getPrime(); + +class Party { + readonly dh: DiffieHellman; + peer: DiffieHellman | null = null; + group?: DiffieHellmanGroup; + + constructor(seed: number) { + this.dh = crypto.createDiffieHellman(prime, 2); + this.dh.setPrivateKey(Buffer.from([seed, seed + 1, seed + 2])); + this.dh.generateKeys(); + } + + secretWith(other: Party): string { + return this.dh.computeSecret(other.dh.getPublicKey(), null, "hex"); + } +} + +const alice = new Party(1); +const bob = new Party(7); +alice.peer = bob.dh; +console.log(alice.secretWith(bob) === bob.secretWith(alice), alice.secretWith(bob).slice(0, 32)); +console.log(alice.peer !== null && alice.peer.getPublicKey().equals(bob.dh.getPublicKey())); +console.log(alice.group === undefined); +alice.group = crypto.getDiffieHellman("modp2"); +console.log(alice.group.verifyError, alice.group.getPrime().length); + +function verify(dh: DiffieHellman | DiffieHellmanGroup): number { + return dh.verifyError; +} + +function make(bytes: number[]): DiffieHellman { + return crypto.createDiffieHellman(Buffer.from(bytes)); +} + +const all: (DiffieHellman | DiffieHellmanGroup)[] = [alice.dh, make([23]), make([24]), crypto.getDiffieHellman("modp5")]; +console.log(all.map(verify).join(",")); +for (const dh of all) console.log(dh.getGenerator("hex"), dh.getPrime().length); + +const byName = new Map(); +for (const name of ["modp1", "modp2"]) byName.set(name, crypto.createDiffieHellmanGroup(name)); +for (const [name, group] of byName) { + group.generateKeys(); + console.log(name, group.getGenerator("hex"), group.computeSecret(alice.dh.getPublicKey()).length); +} + +let maybe: DiffieHellman | undefined; +console.log(maybe?.verifyError); +maybe = make([0x0d]); +console.log(maybe?.verifyError, maybe.getPrime("hex")); diff --git a/tests/fixtures/node-types/dh.ts b/tests/fixtures/node-types/dh.ts new file mode 100644 index 000000000..0b20b1056 --- /dev/null +++ b/tests/fixtures/node-types/dh.ts @@ -0,0 +1,22 @@ +import { + type DiffieHellman, + type DiffieHellmanGroup, + createDiffieHellman, + createDiffieHellmanGroup, + getDiffieHellman, +} from "node:crypto"; + +const group: DiffieHellmanGroup = getDiffieHellman("modp2"); +const alice: DiffieHellman = createDiffieHellman(group.getPrime(), group.getGenerator()); +const bob: DiffieHellman = createDiffieHellman(group.getPrime("hex"), "hex", 2); +alice.setPrivateKey(Buffer.from("0a0b0c", "hex")); +bob.setPrivateKey("0d0e0f", "hex"); +const alicePublic: Buffer = alice.generateKeys(); +const bobPublic: string = bob.generateKeys("base64"); +const fromAlice: string = alice.computeSecret(bobPublic, "base64", "hex"); +const fromBob: Buffer = bob.computeSecret(alicePublic); +console.log(fromAlice === fromBob.toString("hex"), fromAlice.slice(0, 16), alice.verifyError); +const named: DiffieHellmanGroup = createDiffieHellmanGroup("modp5"); +console.log(named.getPrime().length, named.getGenerator("hex"), bob.getPrivateKey("hex")); +const generated: string = named.generateKeys("hex"); +console.log(generated.length <= 384, named.getPublicKey("hex") === generated); diff --git a/tests/fixtures/node-types/fenced.ts b/tests/fixtures/node-types/fenced.ts index 16a74081f..c6a8e90b7 100644 --- a/tests/fixtures/node-types/fenced.ts +++ b/tests/fixtures/node-types/fenced.ts @@ -103,6 +103,12 @@ cipherStream.on("data", () => {}); import { createECDH } from "node:crypto"; createECDH("sect163k1"); createECDH("prime256v1").computeSecret(Buffer.alloc(65), "hex"); +/* DiffieHellman's Object.prototype members, and crypto.diffieHellman over + * asymmetric KeyObjects. */ +import { createDiffieHellman, diffieHellman, type KeyObject } from "node:crypto"; +createDiffieHellman(Buffer.from([23])).toString(); +declare const dhKey: KeyObject; +diffieHellman({ privateKey: dhKey, publicKey: dhKey }); /* WebCrypto beyond the HMAC slice: @types/node declares the whole * SubtleCrypto surface, and the methods outside importKey, sign, verify * and digest fence by name. */ diff --git a/tests/harness/__snapshots__/node-types-fenced.txt b/tests/harness/__snapshots__/node-types-fenced.txt index 0bd13963d..6ac45473f 100644 --- a/tests/harness/__snapshots__/node-types-fenced.txt +++ b/tests/harness/__snapshots__/node-types-fenced.txt @@ -228,24 +228,42 @@ fenced.ts:105:1 - error SC2020: 'ECDH.computeSecret(key, encoding) with a Buffer 104 | createECDH("sect163k1"); 105 | createECDH("prime256v1").computeSecret(Buffer.alloc(65), "hex"); | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - 106 | /* WebCrypto beyond the HMAC slice: @types/node declares the whole + 106 | /* DiffieHellman's Object.prototype members, and crypto.diffieHellman over hint: Node reads the second argument as the key's input encoding and answers a Buffer; pass the output encoding third: computeSecret(key, undefined, encoding) -fenced.ts:110:9 - error SC2020: 'crypto.subtle.encrypt' is part of the standard library types but has no scriptc lowering yet +fenced.ts:109:1 - error SC2020: 'DiffieHellman.toString' is part of the standard library types but has no scriptc lowering yet - 109 | async function encryptWithWebCrypto(key: import("node:crypto").webcrypto.CryptoKey): Promise { - 110 | await crypto.subtle.encrypt({ name: "AES-GCM", iv: new Uint8Array(12) }, key, new Uint8Array(1)); + 108 | import { createDiffieHellman, diffieHellman, type KeyObject } from "node:crypto"; + 109 | createDiffieHellman(Buffer.from([23])).toString(); + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + 110 | declare const dhKey: KeyObject; + + hint: generateKeys(), computeSecret(), getPrime(), getGenerator(), getPublicKey(), getPrivateKey(), setPublicKey(), setPrivateKey() and verifyError are supported + +fenced.ts:111:1 - error SC2020: 'crypto.diffieHellman' is typed by @types/node but has no scriptc lowering yet + + 110 | declare const dhKey: KeyObject; + 111 | diffieHellman({ privateKey: dhKey, publicKey: dhKey }); + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + 112 | /* WebCrypto beyond the HMAC slice: @types/node declares the whole + + hint: crypto.diffieHellman takes asymmetric KeyObjects, which the static runtime does not have; the objects of createDiffieHellman, getDiffieHellman and createECDH compute shared secrets + +fenced.ts:116:9 - error SC2020: 'crypto.subtle.encrypt' is part of the standard library types but has no scriptc lowering yet + + 115 | async function encryptWithWebCrypto(key: import("node:crypto").webcrypto.CryptoKey): Promise { + 116 | await crypto.subtle.encrypt({ name: "AES-GCM", iv: new Uint8Array(12) }, key, new Uint8Array(1)); | ^~~~~~~~~~~~~~~~~~~~~ - 111 | } + 117 | } hint: the native WebCrypto surface is crypto.subtle.importKey('raw', ...) for HMAC keys, sign and verify with HMAC, and digest with SHA-1, SHA-256, SHA-384 or SHA-512, each called directly on crypto.subtle -fenced.ts:115:15 - error SC2020: 'navigator.hardwareConcurrency' is typed by @types/node but has no scriptc lowering yet +fenced.ts:121:15 - error SC2020: 'navigator.hardwareConcurrency' is typed by @types/node but has no scriptc lowering yet - 114 | * compile; the other members fence by name. */ - 115 | const cores = navigator.hardwareConcurrency; + 120 | * compile; the other members fence by name. */ + 121 | const cores = navigator.hardwareConcurrency; | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - 116 | void cores; + 122 | void cores; hint: of Node's navigator global only typeof navigator and navigator.userAgent compile \ No newline at end of file diff --git a/tests/harness/corpus-costs/6706-dh-groups.ts.json b/tests/harness/corpus-costs/6706-dh-groups.ts.json new file mode 100644 index 000000000..b051df274 --- /dev/null +++ b/tests/harness/corpus-costs/6706-dh-groups.ts.json @@ -0,0 +1 @@ +{ "plain": 4855, "san": 8228 } diff --git a/tests/harness/corpus-costs/6707-dh-explicit-params.ts.json b/tests/harness/corpus-costs/6707-dh-explicit-params.ts.json new file mode 100644 index 000000000..95ab0f1b2 --- /dev/null +++ b/tests/harness/corpus-costs/6707-dh-explicit-params.ts.json @@ -0,0 +1 @@ +{ "plain": 6328, "san": 10420 } diff --git a/tests/harness/corpus-costs/6708-dh-errors.js.json b/tests/harness/corpus-costs/6708-dh-errors.js.json new file mode 100644 index 000000000..743216cb9 --- /dev/null +++ b/tests/harness/corpus-costs/6708-dh-errors.js.json @@ -0,0 +1 @@ +{ "plain": 8044, "san": 10499 } diff --git a/tests/harness/corpus-costs/6709-dh-generate.ts.json b/tests/harness/corpus-costs/6709-dh-generate.ts.json new file mode 100644 index 000000000..1e00ad64d --- /dev/null +++ b/tests/harness/corpus-costs/6709-dh-generate.ts.json @@ -0,0 +1 @@ +{ "plain": 6999, "san": 9388 } diff --git a/tests/harness/corpus-costs/6710-dh-encodings.cjs.json b/tests/harness/corpus-costs/6710-dh-encodings.cjs.json new file mode 100644 index 000000000..15e5385e0 --- /dev/null +++ b/tests/harness/corpus-costs/6710-dh-encodings.cjs.json @@ -0,0 +1 @@ +{ "plain": 6048, "san": 8117 } diff --git a/tests/harness/corpus-costs/6711-dh-handles.ts.json b/tests/harness/corpus-costs/6711-dh-handles.ts.json new file mode 100644 index 000000000..ecf09ecb1 --- /dev/null +++ b/tests/harness/corpus-costs/6711-dh-handles.ts.json @@ -0,0 +1 @@ +{ "plain": 5664, "san": 7161 } diff --git a/tests/harness/errors.test.ts b/tests/harness/errors.test.ts index 8af6998ca..87ca7b59f 100644 --- a/tests/harness/errors.test.ts +++ b/tests/harness/errors.test.ts @@ -918,6 +918,53 @@ for (const run of [() => ecdh.getPublicKey.name, () => { ecdh.custom = 1; }]) { }); }); +// DiffieHellman primes past mbedTLS's 8192-bit limit throw a coded SC2020 +// error, as do property reads other than verifyError, property writes, and +// Object.prototype method calls on an untyped DiffieHellman. +describe("DiffieHellman runtime refusals", () => { + test("primes longer than 8192 bits throw SC2020", async () => { + const r = await compileAndRun( + "dh-long-prime", + `import { createDiffieHellman } from "node:crypto"; +const prime = Buffer.alloc(1025, 0xff); +for (const run of [() => createDiffieHellman(prime), () => createDiffieHellman(8193)]) { + try { + run(); + } catch (error) { + const e = error as Error & { code?: string }; + console.log(e.name, e.code, e.message); + } +} +console.log(createDiffieHellman(Buffer.alloc(1024, 0xff)).verifyError); +`, + ); + expect(r.exitCode).toBe(0); + const message = "DiffieHellman primes longer than 8192 bits have no native implementation"; + expect(r.stdout).toBe(`Error SC2020 ${message}\nError SC2020 ${message}\n1\n`); + expect(r.stderr).toBe(""); + }); + + test("DiffieHellman property reads, writes and Object.prototype calls throw SC2020", async () => { + const r = await compileAndRun( + "dh-properties", + `const crypto = require("node:crypto"); +const dh = crypto.getDiffieHellman("modp1"); +console.log(dh.verifyError); +for (const run of [() => dh.getPrime.name, () => { dh.verifyError = 1; }, () => dh.hasOwnProperty("verifyError")]) { + try { + run(); + } catch (e) { + console.log(e.name, e.code); + } +} +`, + "cjs", + ); + expect(r.exitCode).toBe(0); + expect(r.stdout).toBe("0\nError SC2020\nError SC2020\nError SC2020\n"); + }); +}); + // Node formats an unknown output encoding with %s, which prints a // function's source text and calls a toString the encoding's class // defines. The cipher runtime has neither, so both throw a coded SC2020 diff --git a/tests/harness/project-config.test.ts b/tests/harness/project-config.test.ts index dabb9b0bf..2f336a1cd 100644 --- a/tests/harness/project-config.test.ts +++ b/tests/harness/project-config.test.ts @@ -1114,6 +1114,20 @@ test("node-types: ECDH matches Node under @types/node", async () => { expect(comparableStderr(native.stderr)).toBe(node.stderr); }); +test("node-types: DiffieHellman matches Node under @types/node", async () => { + const outDir = outDirFor("node-dh"); + const entry = join(nodeTypesDir, "dh.ts"); + const result = await compile(entry, { outPath: join(outDir, "dh"), outDir, sanitize }); + expect(result.ok, !result.ok ? JSON.stringify(result.diagnostics, null, 2) : "").toBe(true); + if (!result.ok) return; + const [native, node] = await Promise.all([ + execFileAsync(result.binaryPath), + execFileAsync(process.execPath, ["--disable-warning=MODULE_TYPELESS_PACKAGE_JSON", entry]), + ]); + expect(native.stdout).toBe(node.stdout); + expect(comparableStderr(native.stderr)).toBe(node.stderr); +}); + test("node-types: WebCrypto HMAC matches Node under @types/node", async () => { const outDir = outDirFor("node-webcrypto-hmac"); const entry = join(nodeTypesDir, "webcrypto-hmac.ts"); diff --git a/tests/harness/self-hosting-native-toolchain.test.ts b/tests/harness/self-hosting-native-toolchain.test.ts index 6d028d597..cbab9f6c9 100644 --- a/tests/harness/self-hosting-native-toolchain.test.ts +++ b/tests/harness/self-hosting-native-toolchain.test.ts @@ -48,6 +48,7 @@ const features: NativeLinkFeatures = { tlsCa: false, cipher: false, ecdh: false, + dh: false, webcrypto: false, perfLoop: false, }; diff --git a/tests/harness/self-hosting-runtime-pack.test.ts b/tests/harness/self-hosting-runtime-pack.test.ts index f4fde795c..f170f96d1 100644 --- a/tests/harness/self-hosting-runtime-pack.test.ts +++ b/tests/harness/self-hosting-runtime-pack.test.ts @@ -49,6 +49,7 @@ const base: NativeLinkFeatures = { tlsCa: false, cipher: false, ecdh: false, + dh: false, webcrypto: false, perfLoop: false, }; From c36c414065bdf07d6fb3f7a245943a5d8f1ac4f9 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Wed, 21 Oct 2026 22:23:04 -0500 Subject: [PATCH 004/102] Re-export only data shapes from package declarations, through imports and .mjs entries - A local `export { Kind }` of a name the declaration file imports (`import type { Kind } from "./kinds"`) now resolves like `export { Kind } from "./kinds"`; it was dropped. - The typedefs now reach a runtime entry outside the .js/.cjs rewrite path (an .mjs file). - Only data shapes are re-exported: an interface, type alias or enum with no method, call or construct signature, function type or other computed type, whose referenced types are data shapes too. An interface with methods describes the package's JavaScript objects and stays as the JavaScript types it (@opentelemetry/api's Counter). - NPM_STATIC_TYPES_SUFFIX moves to npm-static.ts, so that module does not import the syntax modules (the self-hosted frontend tests compile it natively). --- .../frontend/npm-static-type-exports-host.ts | 79 ++++++++--- .../frontend/npm-static-type-exports.test.ts | 53 +++++++- .../src/frontend/npm-static-type-exports.ts | 127 ++++++++++++++++-- packages/compiler/src/frontend/npm-static.ts | 29 ++-- .../main.ts.json | 6 + .../main.ts | 19 +++ .../node_modules/row-module/lib/index.d.ts | 5 + .../node_modules/row-module/lib/index.mjs | 7 + .../node_modules/row-module/package.json | 1 + .../node_modules/shape-kinds/lib/index.d.ts | 4 + .../node_modules/shape-kinds/lib/index.js | 8 ++ .../node_modules/shape-kinds/lib/kinds.d.ts | 5 + .../node_modules/shape-kinds/lib/kinds.js | 2 + .../node_modules/shape-kinds/package.json | 1 + .../main.ts.json | 1 + tests/harness/coverage.test.ts | 13 ++ 16 files changed, 320 insertions(+), 40 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7004-package-declared-type-reexports/main.ts.json create mode 100644 tests/corpus/7004-package-declared-type-reexports/main.ts create mode 100644 tests/corpus/7004-package-declared-type-reexports/node_modules/row-module/lib/index.d.ts create mode 100644 tests/corpus/7004-package-declared-type-reexports/node_modules/row-module/lib/index.mjs create mode 100644 tests/corpus/7004-package-declared-type-reexports/node_modules/row-module/package.json create mode 100644 tests/corpus/7004-package-declared-type-reexports/node_modules/shape-kinds/lib/index.d.ts create mode 100644 tests/corpus/7004-package-declared-type-reexports/node_modules/shape-kinds/lib/index.js create mode 100644 tests/corpus/7004-package-declared-type-reexports/node_modules/shape-kinds/lib/kinds.d.ts create mode 100644 tests/corpus/7004-package-declared-type-reexports/node_modules/shape-kinds/lib/kinds.js create mode 100644 tests/corpus/7004-package-declared-type-reexports/node_modules/shape-kinds/package.json create mode 100644 tests/harness/corpus-costs/7004-package-declared-type-reexports/main.ts.json diff --git a/packages/compiler/src/frontend/npm-static-type-exports-host.ts b/packages/compiler/src/frontend/npm-static-type-exports-host.ts index 809464763..3c196e6a7 100644 --- a/packages/compiler/src/frontend/npm-static-type-exports-host.ts +++ b/packages/compiler/src/frontend/npm-static-type-exports-host.ts @@ -5,10 +5,10 @@ import { dirname, relative, resolve as resolvePath } from "node:path"; import { trackedFileExists, trackedReadFile } from "./input-tracker.js"; import { resolveBareModule } from "./resolve.js"; import { isJsSourceFileName } from "./tsc-codes.js"; +import { NPM_STATIC_TYPES_SUFFIX } from "./npm-static.js"; import type { FrontendServices } from "./services.js"; import * as ts from "./ts7/syntax.js"; import { - NPM_STATIC_TYPES_SUFFIX, npmStaticDeclarationCopy, npmStaticDeclarationExports, npmStaticDeclarationSpecifiers, @@ -106,28 +106,37 @@ export function npmStaticTypeExportPlan( ); for (const target of targets.values()) copy(target); }; - // The exported type-only declarations of `file`, through its re-exports. + const exportsOf = new Map(); + const declarationExports = (file: string): NpmStaticDeclarationExports | null => { + let ex = exportsOf.get(file); + if (ex === undefined) { + const sf = parse(file); + ex = sf === null ? null : npmStaticDeclarationExports(sf); + exportsOf.set(file, ex); + } + return ex; + }; + // The exported type-only declarations of `file`, through its re-exports, + // each with the file that declares it. + type Found = { decl: NpmStaticTypeDeclaration; file: string }; const typesOf = ( file: string, seen: Set, - ): { types: Map; values: Set } => { - const result = { - types: new Map(), - values: new Set(), - }; + ): { types: Map; values: Set } => { + const result = { types: new Map(), values: new Set() }; if (seen.has(file)) return result; seen.add(file); - const sf = parse(file); - if (sf === null) return result; - const own: NpmStaticDeclarationExports = npmStaticDeclarationExports(sf); - for (const t of own.types) result.types.set(t.name, t); + const own = declarationExports(file); + if (own === null) return result; + for (const t of own.types) result.types.set(t.name, { decl: t, file }); for (const v of own.values) result.values.add(v); for (const n of own.named) { const target = n.specifier === null ? null : declarationTargetOf(file, n.specifier); if (target === null) continue; const inner = typesOf(target, new Set(seen)); const t = inner.types.get(n.local); - if (t !== undefined) result.types.set(n.exported, { ...t, name: n.exported }); + if (t !== undefined) + result.types.set(n.exported, { ...t, decl: { ...t.decl, name: n.exported } }); else if (inner.values.has(n.local)) result.values.add(n.exported); } for (const specifier of own.stars) { @@ -139,6 +148,39 @@ export function npmStaticTypeExportPlan( } return result; }; + // Whether `name`, as `file` sees it, is a data shape: an interface, type + // alias or enum whose syntax describes no behavior (npm-static-type- + // exports.ts) and whose referenced types are data shapes too. A name the + // package's declaration files do not declare is a global (`Array`, + // `Record`, `Date`); a class, a value or an import from another package + // is not a data shape. + const dataMemo = new Map(); + const isData = (file: string, name: string, visiting: Set): boolean => { + const key = `${file}\0${name}`; + const memo = dataMemo.get(key); + if (memo !== undefined) return memo; + if (visiting.has(key)) return true; // a recursive shape + visiting.add(key); + const answer = ((): boolean => { + const ex = declarationExports(file); + if (ex === null) return false; + const local = ex.locals.get(name); + if (local !== undefined) + return !local.behavior && local.references.every((r) => isData(file, r, visiting)); + if (ex.valueNames.has(name)) return false; + const from = ex.imports.get(name); + if (from !== undefined) { + const target = declarationTargetOf(file, from.specifier); + return target !== null && isData(target, from.local, visiting); + } + const reexport = typesOf(file, new Set()).types.get(name); + if (reexport !== undefined) return isData(reexport.file, reexport.decl.declared, visiting); + return true; + })(); + visiting.delete(key); + dataMemo.set(key, answer); + return answer; + }; for (const pkg of packages) { const declared = resolveBareModule(entryPath, pkg, "types-only"); if (declared === null || declared.packageName !== pkg || !declared.typesFile.endsWith(".d.ts")) @@ -149,9 +191,16 @@ export function npmStaticTypeExportPlan( if (runtimeText === null) continue; const { types, values } = typesOf(declared.typesFile, new Set()); const declaredByRuntime = runtimeTypeNames(services, runtime.typesFile, runtimeText); - const exported = [...types.values()].filter( - (t) => !values.has(t.name) && !declaredByRuntime.has(t.name), - ); + // Only data shapes: a type with methods describes the package's + // JavaScript objects, which stay as the JavaScript types them. + const exported = [...types.values()] + .filter( + ({ decl, file }) => + !values.has(decl.name) && + !declaredByRuntime.has(decl.name) && + isData(file, decl.declared, new Set()), + ) + .map(({ decl }) => decl); if (exported.length === 0) continue; copy(declared.typesFile); const specifier = specifierFor(runtime.typesFile, copyPathOf(declared.typesFile)); diff --git a/packages/compiler/src/frontend/npm-static-type-exports.test.ts b/packages/compiler/src/frontend/npm-static-type-exports.test.ts index fa95c0fe0..89adf5bbc 100644 --- a/packages/compiler/src/frontend/npm-static-type-exports.test.ts +++ b/packages/compiler/src/frontend/npm-static-type-exports.test.ts @@ -40,6 +40,41 @@ export { helper };`), expect(exports.stars).toEqual(["./paging"]); }); +test("a local export of an imported name resolves like a re-export", () => { + const exports = npmStaticDeclarationExports( + parse(`import type { Kind } from "./kinds"; +import { type Shape as Form, helper } from "./kinds"; +export { Kind, Form as Outline, helper };`), + ); + expect(exports.types).toEqual([]); + expect(exports.named).toEqual([ + { exported: "Kind", local: "Kind", specifier: "./kinds" }, + { exported: "Outline", local: "Shape", specifier: "./kinds" }, + { exported: "helper", local: "helper", specifier: "./kinds" }, + ]); +}); + +test("each declaration records whether it describes behavior and what it references", () => { + const { locals } = npmStaticDeclarationExports( + parse(`interface Row { key: string; value: T; next?: Row; tags: Tag[] } +type Tag = "a" | "b"; +interface Counter { add(value: number): void } +type Callback = (row: Row) => void; +type Keys = keyof Row; +interface Named extends Base { label: Label }`), + ); + const shape = (name: string) => { + const d = locals.get(name)!; + return [d.behavior, [...d.references].sort()]; + }; + expect(shape("Row")).toEqual([false, ["Row", "Tag"]]); + expect(shape("Tag")).toEqual([false, []]); + expect(shape("Counter")).toEqual([true, []]); + expect(shape("Callback")[0]).toBe(true); + expect(shape("Keys")[0]).toBe(true); + expect(shape("Named")).toEqual([false, ["Base", "Label"]]); +}); + test("a copy respells the relative specifiers it is told", () => { const sf = parse(`import type { Page } from "./paging"; export * from './entries'; @@ -60,8 +95,22 @@ test("the typedef block re-exports each type with its parameters", () => { expect( npmStaticTypedefBlock( [ - { name: "Mode", params: [], templates: [] }, - { name: "Options", params: ["T", "U"], templates: ["{object} [T={}]", "[U=string]"] }, + { + name: "Mode", + declared: "Mode", + params: [], + templates: [], + behavior: false, + references: [], + }, + { + name: "Options", + declared: "Options", + params: ["T", "U"], + templates: ["{object} [T={}]", "[U=string]"], + behavior: false, + references: [], + }, ], "./index.scriptc-types", ), diff --git a/packages/compiler/src/frontend/npm-static-type-exports.ts b/packages/compiler/src/frontend/npm-static-type-exports.ts index bdea8eb03..3b74b8aef 100644 --- a/packages/compiler/src/frontend/npm-static-type-exports.ts +++ b/packages/compiler/src/frontend/npm-static-type-exports.ts @@ -19,15 +19,21 @@ import * as ts from "./ts7/syntax.js"; import { tokenStartOfNode } from "./ts7/node-functions.js"; -/** The suffix that replaces `.d.ts` in a copy's name. */ -export const NPM_STATIC_TYPES_SUFFIX = ".scriptc-types.d.ts"; - -/** A type-only declaration: its name, its type parameters' names and their - * JSDoc @template tag bodies. */ +/** A type-only declaration: its exported name, its name where it is + * declared, its type parameters' names and their JSDoc @template tag + * bodies, and what npmStaticDataShape needs to know. */ export interface NpmStaticTypeDeclaration { name: string; + declared: string; params: readonly string[]; templates: readonly string[]; + /** The declaration's own syntax describes behavior or a computed type: + * a method, call or construct signature, a function or constructor + * type, an accessor, `typeof`, `import("...")`, a conditional, mapped, + * indexed-access or `keyof` type, or a qualified type name. */ + behavior: boolean; + /** The type names it refers to, its own type parameters excepted. */ + references: readonly string[]; } /** What a declaration file declares and re-exports, by exported name. */ @@ -37,11 +43,17 @@ export interface NpmStaticDeclarationExports { /** Exported classes, functions, variables and namespaces: names the * JavaScript declares itself, or that are not type-only. */ values: readonly string[]; - /** `export { local as exported } from "specifier"` and local - * `export { a, b }` (specifier null). */ + /** `export { local as exported } from "specifier"`, including a local + * `export { a }` of an imported name. */ named: readonly { exported: string; local: string; specifier: string | null }[]; /** `export * from "specifier"`. */ stars: readonly string[]; + /** Every interface, type alias and enum the file declares, by name. */ + locals: ReadonlyMap; + /** The file's named imports: local name to imported name and specifier. */ + imports: ReadonlyMap; + /** Every class, function, namespace and variable the file declares. */ + valueNames: ReadonlySet; } function isExported(node: ts.Node): boolean { @@ -60,6 +72,49 @@ function templatesOf(sf: ts.SourceFile, params: readonly ts.TypeParameterDeclara }); } +/** Syntax kinds of a type that describes behavior or is computed. */ +const BEHAVIOR_KINDS: ReadonlySet = new Set([ + ts.SyntaxKind.MethodSignature, + ts.SyntaxKind.CallSignature, + ts.SyntaxKind.ConstructSignature, + ts.SyntaxKind.FunctionType, + ts.SyntaxKind.ConstructorType, + ts.SyntaxKind.GetAccessor, + ts.SyntaxKind.SetAccessor, + ts.SyntaxKind.TypeQuery, + ts.SyntaxKind.ImportType, + ts.SyntaxKind.ConditionalType, + ts.SyntaxKind.MappedType, + ts.SyntaxKind.InferType, + ts.SyntaxKind.IndexedAccessType, + ts.SyntaxKind.ThisType, + ts.SyntaxKind.TypePredicate, + ts.SyntaxKind.TemplateLiteralType, +]); + +/** The behavior flag and type references of an interface or type alias. */ +function shapeOf( + decl: ts.InterfaceDeclaration | ts.TypeAliasDeclaration, + params: readonly string[], +): { behavior: boolean; references: string[] } { + let behavior = false; + const references = new Set(); + const refer = (name: ts.Node): void => { + if (ts.isIdentifier(name)) { + if (!params.includes(name.text)) references.add(name.text); + } else behavior = true; // a qualified name: a namespace member + }; + ts.walkPreorder(decl, (n) => { + if (behavior) return "stop"; + if (BEHAVIOR_KINDS.has(n.kind)) behavior = true; + else if (ts.isTypeOperatorNode(n) && n.operator === ts.SyntaxKind.KeyOfKeyword) behavior = true; + else if (ts.isTypeReferenceNode(n)) refer(n.typeName); + else if (ts.isExpressionWithTypeArguments(n)) refer(n.expression); + return undefined; + }); + return { behavior, references: [...references] }; +} + /** The exports of one declaration file. */ export function npmStaticDeclarationExports(sf: ts.SourceFile): NpmStaticDeclarationExports { const types: NpmStaticTypeDeclaration[] = []; @@ -68,19 +123,44 @@ export function npmStaticDeclarationExports(sf: ts.SourceFile): NpmStaticDeclara const stars: string[] = []; const localTypes = new Map(); const localValues = new Set(); + // `import { A as B } from "./x"`: local name B is A of "./x". + const imported = new Map(); for (const stmt of sf.statements.nodes) { const exported = isExported(stmt); - if (ts.isInterfaceDeclaration(stmt) || ts.isTypeAliasDeclaration(stmt)) { + if (ts.isImportDeclaration(stmt)) { + const bindings = stmt.importClause?.namedBindings; + if (ts.isStringLiteral(stmt.moduleSpecifier) && bindings && ts.isNamedImports(bindings)) { + for (const e of bindings.elements.nodes) { + imported.set(e.name.text, { + local: (e.propertyName ?? e.name).text, + specifier: stmt.moduleSpecifier.text, + }); + } + } + } else if (ts.isInterfaceDeclaration(stmt) || ts.isTypeAliasDeclaration(stmt)) { const params = stmt.typeParameters?.nodes ?? []; - const decl = { + const paramNames = params.map((p) => p.name.text); + const shape = shapeOf(stmt, paramNames); + const merged = localTypes.get(stmt.name.text); // interface merging + const decl: NpmStaticTypeDeclaration = { name: stmt.name.text, - params: params.map((p) => p.name.text), + declared: stmt.name.text, + params: paramNames, templates: templatesOf(sf, params), + behavior: shape.behavior || merged?.behavior === true, + references: [...shape.references, ...(merged?.references ?? [])], }; localTypes.set(decl.name, decl); - if (exported) types.push(decl); + if (exported && merged === undefined) types.push(decl); } else if (ts.isEnumDeclaration(stmt)) { - const decl: NpmStaticTypeDeclaration = { name: stmt.name.text, params: [], templates: [] }; + const decl: NpmStaticTypeDeclaration = { + name: stmt.name.text, + declared: stmt.name.text, + params: [], + templates: [], + behavior: false, + references: [], + }; localTypes.set(decl.name, decl); if (exported) types.push(decl); } else if ( @@ -116,7 +196,9 @@ export function npmStaticDeclarationExports(sf: ts.SourceFile): NpmStaticDeclara } } } - // Local `export { a as b }` of the file's own declarations. + // Local `export { a as b }`: of the file's own declarations, or of a + // name it imports (`import type { A } from "./a"; export { A }`), which + // resolves like `export { A } from "./a"`. const resolvedNamed: typeof named = []; for (const n of named) { if (n.specifier !== null) { @@ -124,10 +206,27 @@ export function npmStaticDeclarationExports(sf: ts.SourceFile): NpmStaticDeclara continue; } const local = localTypes.get(n.local); + const from = imported.get(n.local); if (local !== undefined) types.push({ ...local, name: n.exported }); else if (localValues.has(n.local)) values.push(n.exported); + else if (from !== undefined) resolvedNamed.push({ exported: n.exported, ...from }); } - return { types, values, named: resolvedNamed, stars }; + // A merged interface's exported entry takes the merged flags. + const exportedTypes: NpmStaticTypeDeclaration[] = []; + for (const t of types) { + const local = localTypes.get(t.declared); + if (local === undefined) exportedTypes.push(t); + else exportedTypes.push({ ...local, name: t.name }); + } + return { + types: exportedTypes, + values, + named: resolvedNamed, + stars, + locals: localTypes, + imports: imported, + valueNames: localValues, + }; } /** The relative module specifiers of a declaration file's imports, exports diff --git a/packages/compiler/src/frontend/npm-static.ts b/packages/compiler/src/frontend/npm-static.ts index 33ff54cfd..800d02eff 100644 --- a/packages/compiler/src/frontend/npm-static.ts +++ b/packages/compiler/src/frontend/npm-static.ts @@ -23,7 +23,6 @@ import { trackedRealpath, } from "./input-tracker.js"; import { npmBuiltinAliasOf } from "./builtin-modules.js"; -import { NPM_STATIC_TYPES_SUFFIX } from "./npm-static-type-exports.js"; let activePackages: ReadonlySet = new Set(); let declarationOverloads: ReadonlyMap = new Map(); @@ -55,6 +54,11 @@ export function npmStaticLexerVisibleNames(path: string): readonly string[] { return lexerNames.get(path.split("\\").join("/")) ?? []; } +/** The suffix that replaces `.d.ts` in the name of a copy of an opted-in + * package's declaration file (npm-static-type-exports.ts). Defined here so + * this module does not depend on the syntax modules. */ +export const NPM_STATIC_TYPES_SUFFIX = ".scriptc-types.d.ts"; + /** Per runtime entry (forward slashes), the JSDoc typedefs that re-export * its package's type-only declarations (npm-static-type-exports.ts). */ let typeExportTypedefs = new Map(); @@ -71,6 +75,17 @@ export function setNpmStaticTypeExports( rewriteCache.clear(); } +/** `text` (or the file's own text when null) with the typedefs of a + * package runtime entry appended: the entry re-exports the type-only + * declarations of the package's .d.ts, after every respelling, so + * positions stay. Null when `path` is no runtime entry and `text` is null. */ +function withTypeExportTypedefs(path: string, text: string | null): string | null { + const typedefs = typeExportTypedefs.get(path.split("\\").join("/")); + if (typedefs === undefined) return text; + const source = text ?? trackedReadFile(path); + return source === null ? text : `${source}\n${typedefs}\n`; +} + export function setNpmStaticPackages>(packages: T): void { // npm packages served as builtins (graceful-fs as fs) never compile // their JavaScript, even when named. @@ -543,17 +558,13 @@ export function npmStaticFsShadow(services: FrontendServices): NpmStaticFsShadow } catch { rewritten = null; // unreadable/unparseable: fall through untouched } - // The runtime entry re-exports the type-only declarations of the - // package's .d.ts, after every respelling, so positions stay. - const typedefs = typeExportTypedefs.get(path.split("\\").join("/")); - if (typedefs !== undefined) { - const text = rewritten ?? trackedReadFile(path); - if (text !== null) rewritten = `${text}\n${typedefs}\n`; - } + rewritten = withTypeExportTypedefs(path, rewritten); rewriteCache.set(path, rewritten); return rewritten ?? undefined; } - return undefined; + // Other runtime entries (`.mjs`) keep their text and gain only the + // typedefs. + return withTypeExportTypedefs(path, null) ?? undefined; }, hideFile: (path) => { // The copies of the package's declaration files the typedefs name. diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7004-package-declared-type-reexports/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7004-package-declared-type-reexports/main.ts.json new file mode 100644 index 000000000..927b902d9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7004-package-declared-type-reexports/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7004-package-declared-type-reexports/main.ts" + ], + "diags": [] +} diff --git a/tests/corpus/7004-package-declared-type-reexports/main.ts b/tests/corpus/7004-package-declared-type-reexports/main.ts new file mode 100644 index 000000000..52e45e7d4 --- /dev/null +++ b/tests/corpus/7004-package-declared-type-reexports/main.ts @@ -0,0 +1,19 @@ +// Two packages that compile from their JavaScript, with types only their +// .d.ts declares: one re-exports types its entry imports +// (`import type { Kind } from "./kinds"; export { Kind }`), the other's +// runtime entry is an ES module (`.mjs`). Declarations using those types +// keep TypeScript's types: the empty arrays the packages fill hold the +// declared rows. +import { addShapes, type Form, type Kind } from "shape-kinds"; +import { readRows, type Row } from "row-module"; + +const forms: Form[] = []; +addShapes("c2 s3", forms); +const kinds: Kind[] = forms.map((form) => form.kind); +const first = forms[0]!; +console.log(kinds.join(","), first.size + forms[1]!.size, first.kind === "circle"); + +const rows: Row[] = []; +const count = readRows("a=1;b=22", rows); +const last = rows[count - 1]!; +console.log(count, last.key, last.value.length); diff --git a/tests/corpus/7004-package-declared-type-reexports/node_modules/row-module/lib/index.d.ts b/tests/corpus/7004-package-declared-type-reexports/node_modules/row-module/lib/index.d.ts new file mode 100644 index 000000000..1f732f996 --- /dev/null +++ b/tests/corpus/7004-package-declared-type-reexports/node_modules/row-module/lib/index.d.ts @@ -0,0 +1,5 @@ +export interface Row { + key: string; + value: string; +} +export declare function readRows(text: string, into: Row[]): number; diff --git a/tests/corpus/7004-package-declared-type-reexports/node_modules/row-module/lib/index.mjs b/tests/corpus/7004-package-declared-type-reexports/node_modules/row-module/lib/index.mjs new file mode 100644 index 000000000..33d110065 --- /dev/null +++ b/tests/corpus/7004-package-declared-type-reexports/node_modules/row-module/lib/index.mjs @@ -0,0 +1,7 @@ +export function readRows(text, into) { + for (const part of text.split(";")) { + const at = part.indexOf("="); + into.push({ key: part.slice(0, at), value: part.slice(at + 1) }); + } + return into.length; +} diff --git a/tests/corpus/7004-package-declared-type-reexports/node_modules/row-module/package.json b/tests/corpus/7004-package-declared-type-reexports/node_modules/row-module/package.json new file mode 100644 index 000000000..240a3f816 --- /dev/null +++ b/tests/corpus/7004-package-declared-type-reexports/node_modules/row-module/package.json @@ -0,0 +1 @@ +{ "name": "row-module", "version": "1.0.0", "main": "./lib/index.mjs", "types": "./lib/index.d.ts" } diff --git a/tests/corpus/7004-package-declared-type-reexports/node_modules/shape-kinds/lib/index.d.ts b/tests/corpus/7004-package-declared-type-reexports/node_modules/shape-kinds/lib/index.d.ts new file mode 100644 index 000000000..ada1748d8 --- /dev/null +++ b/tests/corpus/7004-package-declared-type-reexports/node_modules/shape-kinds/lib/index.d.ts @@ -0,0 +1,4 @@ +import type { Kind } from "./kinds"; +import { type Shape as Form } from "./kinds"; +export { Kind, Form }; +export declare function addShapes(text: string, into: Form[]): void; diff --git a/tests/corpus/7004-package-declared-type-reexports/node_modules/shape-kinds/lib/index.js b/tests/corpus/7004-package-declared-type-reexports/node_modules/shape-kinds/lib/index.js new file mode 100644 index 000000000..d6165c4b9 --- /dev/null +++ b/tests/corpus/7004-package-declared-type-reexports/node_modules/shape-kinds/lib/index.js @@ -0,0 +1,8 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.addShapes = addShapes; +function addShapes(text, into) { + for (const part of text.split(" ")) { + into.push({ kind: part.charAt(0) === "c" ? "circle" : "square", size: Number(part.slice(1)) }); + } +} diff --git a/tests/corpus/7004-package-declared-type-reexports/node_modules/shape-kinds/lib/kinds.d.ts b/tests/corpus/7004-package-declared-type-reexports/node_modules/shape-kinds/lib/kinds.d.ts new file mode 100644 index 000000000..79c90322c --- /dev/null +++ b/tests/corpus/7004-package-declared-type-reexports/node_modules/shape-kinds/lib/kinds.d.ts @@ -0,0 +1,5 @@ +export type Kind = "circle" | "square"; +export interface Shape { + kind: Kind; + size: number; +} diff --git a/tests/corpus/7004-package-declared-type-reexports/node_modules/shape-kinds/lib/kinds.js b/tests/corpus/7004-package-declared-type-reexports/node_modules/shape-kinds/lib/kinds.js new file mode 100644 index 000000000..c8ad2e549 --- /dev/null +++ b/tests/corpus/7004-package-declared-type-reexports/node_modules/shape-kinds/lib/kinds.js @@ -0,0 +1,2 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); diff --git a/tests/corpus/7004-package-declared-type-reexports/node_modules/shape-kinds/package.json b/tests/corpus/7004-package-declared-type-reexports/node_modules/shape-kinds/package.json new file mode 100644 index 000000000..e428fc315 --- /dev/null +++ b/tests/corpus/7004-package-declared-type-reexports/node_modules/shape-kinds/package.json @@ -0,0 +1 @@ +{ "name": "shape-kinds", "version": "1.0.0", "main": "./lib/index.js", "types": "./lib/index.d.ts" } diff --git a/tests/harness/corpus-costs/7004-package-declared-type-reexports/main.ts.json b/tests/harness/corpus-costs/7004-package-declared-type-reexports/main.ts.json new file mode 100644 index 000000000..e9e0bf6d2 --- /dev/null +++ b/tests/harness/corpus-costs/7004-package-declared-type-reexports/main.ts.json @@ -0,0 +1 @@ +{ "plain": 1015, "san": 2516 } diff --git a/tests/harness/coverage.test.ts b/tests/harness/coverage.test.ts index ca62352b1..1f790c225 100644 --- a/tests/harness/coverage.test.ts +++ b/tests/harness/coverage.test.ts @@ -488,6 +488,19 @@ test("JavaScript builtin aliases keep their deferred value fence", async () => { ); }); +test("types only a package's .d.ts declares stay static through re-exports and .mjs entries", () => { + // shape-kinds re-exports types its .d.ts entry imports; row-module's + // runtime entry is an .mjs file. Without their declared types the + // program's uses of Form, Kind and Row run in the dynamic tier (12 + // statements); with them only the packages' own JavaScript and one + // arithmetic on a JavaScript return value do (4). + const { coverage } = analyze( + join(repoRoot, "tests/corpus/7004-package-declared-type-reexports/main.ts"), + ); + expect(coverage.diagnostics).toEqual([]); + expect(coverage.stats.statementsDynamic).toBe(4); +}); + test("any-typed checked-dynamic operators compile natively", () => { const file = join(repoRoot, "tests/corpus/2856-dynamic-any-local-operators.ts"); const staticCoverage = analyze(file).coverage; From ecee5fdaaffe061b715a73915aea39179f6d5803 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Wed, 21 Oct 2026 23:25:33 -0500 Subject: [PATCH 005/102] Store references to ProgramLifetime instances in 4 bytes on Linux --- docs/content/docs/contracts.mdx | 2 + .../compiler/src/backend/llvm/classes.test.ts | 109 +++++++++- packages/compiler/src/backend/llvm/classes.ts | 144 ++++++++++++- .../src/backend/llvm/emit-function.ts | 1 + .../compiler/src/backend/llvm/emit-module.ts | 4 + .../src/backend/llvm/emit-statements.ts | 2 +- packages/compiler/src/backend/llvm/emitter.ts | 116 ++++++++-- .../compiler/src/backend/llvm/expr-control.ts | 10 +- .../compiler/src/backend/llvm/expr-dynamic.ts | 2 +- .../src/backend/llvm/expr-primitives.ts | 10 +- .../src/backend/llvm/expr-stream-bridges.ts | 39 +++- packages/compiler/src/backend/llvm/publish.ts | 17 +- .../compiler/src/backend/llvm/receivers.ts | 7 +- packages/compiler/src/index.ts | 8 +- packages/compiler/src/native/prepare.ts | 3 +- ...ntract-program-lifetime-references.ts.json | 6 + ...-contract-program-lifetime-workers.ts.json | 6 + packages/runtime/src/scr_alloc.c | 200 ++++++++++++++++++ packages/runtime/src/scr_rc.h | 24 +++ scripts/ci-test-costs.json | 2 + ...36-contract-program-lifetime-references.ts | 195 +++++++++++++++++ .../4637-contract-program-lifetime-workers.ts | 79 +++++++ ...ntract-program-lifetime-references.ts.json | 1 + ...-contract-program-lifetime-workers.ts.json | 1 + .../harness/program-lifetime-workers.test.ts | 48 +++++ 25 files changed, 981 insertions(+), 55 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4636-contract-program-lifetime-references.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4637-contract-program-lifetime-workers.ts.json create mode 100644 tests/corpus/4636-contract-program-lifetime-references.ts create mode 100644 tests/corpus/4637-contract-program-lifetime-workers.ts create mode 100644 tests/harness/corpus-costs/4636-contract-program-lifetime-references.ts.json create mode 100644 tests/harness/corpus-costs/4637-contract-program-lifetime-workers.ts.json create mode 100644 tests/harness/program-lifetime-workers.test.ts diff --git a/docs/content/docs/contracts.mdx b/docs/content/docs/contracts.mdx index d1bfb8cad..5af1cad2f 100644 --- a/docs/content/docs/contracts.mdx +++ b/docs/content/docs/contracts.mdx @@ -349,6 +349,8 @@ class Identifier extends SyntaxNode { } ``` +On Linux, except in builds with sanitizers, the instances also take less memory. An executable keeps them in one address range below 32 GiB that it reserves at startup (only the pages in use take memory), and a field typed `C`, `C | undefined` or `C | null`, where `C` is a program-lifetime class, stores the instance's address in 4 bytes instead of 8. In the example, `parent` takes 4 bytes. + scriptc checks that the promise cannot change what the program computes (SC7008): - the class is the root of its hierarchy, so every value of any class type in the hierarchy is program-lifetime; built-in bases such as `Error`, `EventEmitter` and streams are refused because they hold runtime state that is released with the object; diff --git a/packages/compiler/src/backend/llvm/classes.test.ts b/packages/compiler/src/backend/llvm/classes.test.ts index 94da472d4..2d95e942c 100644 --- a/packages/compiler/src/backend/llvm/classes.test.ts +++ b/packages/compiler/src/backend/llvm/classes.test.ts @@ -1,13 +1,15 @@ import { expect, test } from "vitest"; import { DYN, F64, STRING, VOID, type IrModule } from "../../ir/ir.js"; import { + assignCompactLayouts, buildClassGraph, + classFieldIndex, classIdLoadLines, classMembershipIntervals, emitClassMembershipHelper, type LlClassMeta, } from "./classes.js"; -import { emitLlvmModule } from "./emitter.js"; +import { emitLlvmModule, lowRegionTarget } from "./emitter.js"; import { mangleClassNew, mangleClassReleaseDirect, @@ -196,11 +198,9 @@ test("classes whose trace visits nothing start acyclic in a traced hierarchy", ( }); test("ProgramLifetime classes pack their fields after a 32-bit header", () => { - const node = { kind: "object" as const, className: "Node" }; - const leaf = { kind: "object" as const, className: "Leaf" }; const BOOL = { kind: "bool" as const }; const nodeFields = [ - { name: "parent", type: node }, + { name: "parent", type: STRING }, { name: "flag", type: BOOL }, { name: "weight", type: F64 }, ]; @@ -214,7 +214,7 @@ test("ProgramLifetime classes pack their fields after a 32-bit header", () => { { name: "Leaf", base: "Node", - fields: [...nodeFields, { name: "next", type: leaf }, { name: "mark", type: BOOL }], + fields: [...nodeFields, { name: "next", type: STRING }, { name: "mark", type: BOOL }], methods: [], loc, }, @@ -233,6 +233,105 @@ test("ProgramLifetime classes pack their fields after a 32-bit header", () => { expect(mortal).toContain(`%${mangleClassStruct("Leaf")} = type { i64, ptr, i8, i32, ptr, i8 }`); }); +test("references between ProgramLifetime instances are 32-bit indexes into their region", () => { + const node = { kind: "object" as const, className: "Node" }; + const leaf = { kind: "object" as const, className: "Leaf" }; + const root = { localId: "root", name: "root", type: leaf }; + const nodeFields = [{ name: "parent", type: node }]; + const mod: IrModule = { + irVersion: 17, + sourceFile: loc.file, + entry: "main", + functions: [ + { + name: "main", + params: [root], + returnType: VOID, + locals: [{ id: "root", name: "root", type: leaf, mutable: false }], + body: [ + { + kind: "fieldSet", + obj: { kind: "varRef", localId: "root", type: leaf, loc }, + className: "Leaf", + field: "parent", + value: { + kind: "fieldGet", + obj: { kind: "varRef", localId: "root", type: leaf, loc }, + className: "Leaf", + field: "next", + type: leaf, + loc, + }, + loc, + }, + ], + loc, + }, + ], + classes: [ + { name: "Node", fields: nodeFields, methods: [], loc }, + { + name: "Leaf", + base: "Node", + fields: [...nodeFields, { name: "next", type: leaf }, { name: "label", type: STRING }], + methods: [], + loc, + }, + ], + contracts: { programLifetime: ["Node"] }, + }; + // Linux executables without sanitizers (lowRegionTarget). + const llvm = emitLlvmModule(mod, { pointerBits: 64, objectAudit: false, lowRegion: true }); + // parent and next take 4 bytes each; the string keeps its pointer. + expect(llvm).toContain(`%${mangleClassStruct("Node")} = type { i32, i32 }`); + expect(llvm).toContain(`%${mangleClassStruct("Leaf")} = type { i32, i32, ptr, i32 }`); + // Instances come from the region, reserved below 32 GiB before compiled + // code runs: a bump of the thread's chunk, and the runtime when it is used + // up. + const nw = + new RegExp(`^define internal ptr @${mangleClassNew("Leaf")}\\([^]*?^}`, "m").exec(llvm)?.[0] ?? + ""; + expect(nw).toContain("%plr.end = getelementptr i8, ptr %plr.next"); + expect(nw).toContain("store ptr %plr.end, ptr %plr.c"); + expect(nw).toMatch(/%plr.o = call ptr @scr_plr_alloc\(i64 /); + expect(llvm).toMatch(/call void @scr_init\(\)\n {2}call void @scr_plr_init\(\)/); + // A reference is the instance's address over 8 (0 is NULL): a read + // shifts the loaded word, a write shifts the pointer. + const main = llvm.split(/^define /m).find((fn) => fn.includes("; main\n")) ?? ""; + expect(main).toMatch(/= load i32, ptr %\S+, !tbaa/); + expect(main).toMatch(/= shl nuw nsw i64 %\S+, 3\n\s+%\S+ = inttoptr i64 %\S+ to ptr/); + expect(main).toMatch(/= ptrtoint ptr %\S+ to i64\n\s+%\S+ = lshr i64 %\S+, 3/); + expect(main).toMatch(/store i32 %\S+, ptr %\S+/); + expect(main).not.toContain("select"); + expect(lowRegionTarget("linux", false)).toBe(true); + expect(lowRegionTarget("linux", true)).toBe(false); + expect(lowRegionTarget("darwin", false)).toBe(false); + expect(lowRegionTarget("win32", false)).toBe(false); + // Other targets, 32-bit targets and mortal classes keep pointers. + const elsewhere = emitLlvmModule(mod, { pointerBits: 64, objectAudit: false }); + expect(elsewhere).toContain(`%${mangleClassStruct("Leaf")} = type { i32, ptr, ptr, ptr }`); + expect(elsewhere).not.toContain("scr_plr"); + const llvm32 = emitLlvmModule(mod, { pointerBits: 32, lowRegion: true }); + expect(llvm32).not.toContain("scr_plr"); + const mortal = emitLlvmModule({ ...mod, contracts: {} }, { pointerBits: 64, lowRegion: true }); + expect(mortal).not.toContain("scr_plr"); + // Field accessors that read the storage as a pointer are refused. + const metas = buildClassGraph(mod, new Map()); + assignCompactLayouts( + metas, + () => true, + (cls) => cls.fields.map(() => "ptr"), + (cls, i, isCompact) => { + const t = cls.fields[i]!.type; + return t.kind === "object" && isCompact(t.className); + }, + ); + const leafMeta = metas.get("Leaf")!; + expect(() => classFieldIndex(leafMeta, "next")).toThrow(/holds a 32-bit reference/); + expect(classFieldIndex(leafMeta, "next", "compressed").compressed).toBe(true); + expect(classFieldIndex(leafMeta, "label").compressed).toBe(false); +}); + test("a recycled block is cleared from the end of a ProgramLifetime instance's 32-bit header", () => { const BOOL = { kind: "bool" as const }; const mod: IrModule = { diff --git a/packages/compiler/src/backend/llvm/classes.ts b/packages/compiler/src/backend/llvm/classes.ts index 7ca2216d2..3073bd1bd 100644 --- a/packages/compiler/src/backend/llvm/classes.ts +++ b/packages/compiler/src/backend/llvm/classes.ts @@ -98,6 +98,10 @@ export class LlClassMeta { compactElems: { offset: number; size: number; align: number; type: string; field: number }[] = []; /** Compact classes: each field's GEP index, by its index in def.fields. */ compactSlots: number[] = []; + /** Compact classes: whether each field (by its index in def.fields) holds + * a compact class instance as a 32-bit index (COMPACT_REF) rather than a + * pointer: compactRefLoadLines decodes it, compactRefStoreLines encodes it. */ + compressed: boolean[] = []; constructor(readonly def: IrClassDef) { this.root = this; @@ -395,13 +399,24 @@ export function classEnvironmentIndex(meta: LlClassMeta): number { /** A field's GEP index inside its class struct: rc at 0, the vtable word * at 1 on hierarchy members, then the flattened field list. */ -export function classFieldIndex(meta: LlClassMeta, field: string): { index: number; type: IrType } { +export function classFieldIndex( + meta: LlClassMeta, + field: string, + refs: "pointer" | "compressed" = "pointer", +): { index: number; type: IrType; compressed: boolean } { const idx = meta.def.fields.findIndex((f) => f.name === field); if (idx < 0) throw new InternalCompilerError( `llvm emitter bug: unknown field ${field} on class ${meta.def.name}`, ); - return { index: classFieldSlot(meta, idx), type: meta.def.fields[idx]!.type }; + const compressed = meta.compressed[idx] === true; + // Callers that read or write a field's storage as a pointer must not see + // a compressed one; callers that decode and encode pass "compressed". + if (compressed && refs === "pointer") + throw new InternalCompilerError( + `llvm emitter bug: field ${field} of ${meta.def.name} holds a 32-bit reference`, + ); + return { index: classFieldSlot(meta, idx), type: meta.def.fields[idx]!.type, compressed }; } /** The GEP index of the field at `idx` in `meta.def.fields`. */ @@ -590,6 +605,75 @@ export function compactHeaderWord(meta: LlClassMeta): number { return COMPACT_HEADER_TAG | (meta.hierarchy ? meta.pre + 1 : 0); } +/** Lines that decode the 32-bit reference `idx` (an i32) of a compressed + * field into the pointer `out`. The program-lifetime region lies below + * 32 GiB (LlvmTargetOptions.lowRegion), so a reference is the instance's + * address over 8 and 0 is NULL: one shift, which x86-64 folds into the + * address of the next load. `t` names the temporaries. */ +export function compactRefLoadLines(idx: string, out: string, t: string): string[] { + return [ + ` ${t}.z = zext i32 ${idx} to i64`, + ` ${t}.o = shl nuw nsw i64 ${t}.z, 3`, + ` ${out} = inttoptr i64 ${t}.o to ptr`, + ]; +} + +/** Lines that encode the pointer `ptr` (NULL or a compact class instance) + * as the 32-bit reference `out` (an i32) a compressed field stores. */ +export function compactRefStoreLines(ptr: string, out: string, t: string): string[] { + return [ + ` ${t}.pi = ptrtoint ptr ${ptr} to i64`, + ` ${t}.s = lshr i64 ${t}.pi, 3`, + ` ${out} = trunc i64 ${t}.s to i32`, + ]; +} + +/** The storage type of a compressed field (LlClassMeta.compressed): a + * 32-bit index into the program-lifetime region. */ +export const COMPACT_REF = "i32"; + +/** Lines that allocate `%o`, `size` zeroed bytes in the program-lifetime + * region: a bump of the calling thread's chunk (scr_rc.h ScrPlrChunk, + * thread-local in worker programs), and scr_plr_alloc when the chunk is + * exhausted or the target has no inline allocation. The lines end in an + * open block. */ +function plrAllocLines(host: ClassHost, size: string): string[] { + const S = host.sizeType; + host.declare(`declare ptr @scr_plr_alloc(${S})`); + host.declare(`declare i1 @llvm.expect.i1(i1, i1)`); + if (host.inlineAlloc !== true) return [` %o = call ptr @scr_plr_alloc(${S} ${size})`]; + const chunk: string[] = []; + if (host.threadLocalAlloc === true) { + host.declare(`@scr_plr_chunk = external thread_local global { ptr, ptr }`); + host.declare(`declare nonnull ptr @llvm.threadlocal.address.p0(ptr nonnull)`); + chunk.push(` %plr.c = call ptr @llvm.threadlocal.address.p0(ptr @scr_plr_chunk)`); + } else { + host.declare(`@scr_plr_chunk = external dso_local global { ptr, ptr }`); + chunk.push(` %plr.c = getelementptr inbounds i8, ptr @scr_plr_chunk, i64 0`); + } + // A thread without a chunk has NULL for both, so nothing fits. + return [ + ...chunk, + ` %plr.lp = getelementptr inbounds i8, ptr %plr.c, i64 8`, + ` %plr.next = load ptr, ptr %plr.c`, + ` %plr.lim = load ptr, ptr %plr.lp`, + ` %plr.n7 = add ${S} ${size}, 7`, + ` %plr.n = and ${S} %plr.n7, -8`, + ` %plr.end = getelementptr i8, ptr %plr.next, ${S} %plr.n`, + ` %plr.fits = icmp ule ptr %plr.end, %plr.lim`, + ` %plr.fitsx = call i1 @llvm.expect.i1(i1 %plr.fits, i1 true)`, + ` br i1 %plr.fitsx, label %plr.bump, label %plr.slow`, + `plr.bump:`, + ` store ptr %plr.end, ptr %plr.c`, + ` br label %plr.done`, + `plr.slow:`, + ` %plr.o = call ptr @scr_plr_alloc(${S} ${size})`, + ` br label %plr.done`, + `plr.done:`, + ` %o = phi ptr [ %plr.next, %plr.bump ], [ %plr.o, %plr.slow ]`, + ]; +} + /** Byte size and alignment of a class field's LLVM storage type. */ function fieldStorage(type: string): { size: number; align: number } { switch (type) { @@ -628,7 +712,16 @@ export function assignCompactLayouts( metaMap: ReadonlyMap, compact: (root: LlClassMeta) => boolean, fieldTypes: (cls: IrClassDef) => string[], + compressedRef?: ( + cls: IrClassDef, + field: number, + isCompact: (className: string) => boolean, + ) => boolean, ): void { + const isCompact = (className: string): boolean => { + const target = metaMap.get(className); + return target !== undefined && target.def.runtime !== true && compact(target.root); + }; const byPre = [...metaMap.values()].sort((a, b) => a.pre - b.pre); for (const meta of byPre) { if (meta.def.runtime === true || !compact(meta.root)) continue; @@ -642,7 +735,22 @@ export function assignCompactLayouts( `llvm emitter bug: compact class ${meta.def.name} does not extend its base's layout`, ); const elems = inherited.map((e) => ({ ...e })); - const types = fieldTypes(meta.def); + // A reference to a compact class instance is a 32-bit index into the + // program-lifetime region (compactRefLoadLines); inherited fields keep the + // base's choice. + const compressed = meta.def.fields.map((_, i) => + i < baseCount + ? base!.compressed[i]! + : compressedRef !== undefined && compressedRef(meta.def, i, isCompact), + ); + const types = fieldTypes(meta.def).map((t, i) => { + if (!compressed[i]) return t; + if (t !== "ptr") + throw new InternalCompilerError( + `llvm emitter bug: compressed field ${meta.def.fields[i]!.name} of ${meta.def.name} is stored as ${t}`, + ); + return COMPACT_REF; + }); const own = types .map((type, field) => ({ type, field, ...fieldStorage(type) })) .slice(baseCount) @@ -679,6 +787,7 @@ export function assignCompactLayouts( meta.compact = true; meta.compactElems = elems; meta.compactSlots = slots; + meta.compressed = compressed; } } @@ -705,7 +814,10 @@ function undefFieldInits( if (f.name === "%cause") return; // A nullable-pointer field's zeroed slot already is its unit arm. if (nullable?.get(meta.def.name, f.name)) return; - const { index } = classFieldIndex(meta, f.name); + // Only union and dyn fields get a store here; a compressed field is a + // class reference, which starts NULL. + const { index, compressed } = classFieldIndex(meta, f.name, "compressed"); + if (compressed) return; if (f.type.kind === "union" && host.inlineUnions.classField(meta.def.name, f.name)) { // An inline field starts at the undefined arm's tag with zero bits. const tag = undefinedArmTag(f.type, host.unionsById); @@ -748,6 +860,9 @@ export function emitClassShapes( nullable?: NullableRefFields, int32?: Int32Slots, ): { typeDefs: string[]; defs: string[] } { + // Whether compact instances live in the program-lifetime region (any + // field holds a 32-bit reference to one; emitter.ts assignCompactLayouts). + const regionRefs = [...metaMap.values()].some((m) => m.compressed.some(Boolean)); const typeDefs: string[] = []; const defs: string[] = []; const emitted = (mod.classes ?? []).filter((c) => !c.runtime); @@ -897,13 +1012,17 @@ export function emitClassShapes( const fieldIndex = (i: number): number => classFieldSlot(meta, i); // Teardown, trace and gcFree see each slot's storage type: a nullable // class field holds the instance pointer (NULL for the unit arm), and - // every class retain/release/visit entry point is NULL-tolerant. + // every class retain/release/visit entry point is NULL-tolerant. A + // compressed field refers to a compact instance, which nothing releases + // or traces, so they skip it. const indexedFields = [ - ...ownedFields(cls).map(({ field, i }) => ({ - name: field.name, - type: storedFieldType(cls, field), - index: fieldIndex(i), - })), + ...ownedFields(cls) + .filter(({ i }) => meta.compressed[i] !== true) + .map(({ field, i }) => ({ + name: field.name, + type: storedFieldType(cls, field), + index: fieldIndex(i), + })), ]; const refFields = indexedFields.filter((f) => isRefCounted(f.type)); const tracedFields = traced @@ -1118,6 +1237,11 @@ export function emitClassShapes( if (regions !== null) { nw.push(...regions.newAlloc(cls.name, sizeOf)); defs.push(...regions.classDefinitions(cls, sizeOf)); + } else if (meta.compact && regionRefs) { + // Compressed fields refer to compact instances by their index in the + // program-lifetime region, so every compact instance lives there: + // zeroed, 8-byte aligned and never freed. + nw.push(...plrAllocLines(host, sizeOf)); } else nw.push( ...emitObjectAlloc( diff --git a/packages/compiler/src/backend/llvm/emit-function.ts b/packages/compiler/src/backend/llvm/emit-function.ts index 7bbd3d453..0980925cb 100644 --- a/packages/compiler/src/backend/llvm/emit-function.ts +++ b/packages/compiler/src/backend/llvm/emit-function.ts @@ -153,6 +153,7 @@ export function emitFunction(emitter: LlEmitter, fn: IrFunction): string { : new Map(); emitter.integerViews.clear(); emitter.fieldPointerTags.clear(); + emitter.compressedFieldPtrs.clear(); emitter.integerArrayBindings.clear(); emitter.loopArrayBorrows = emitter.debug === null diff --git a/packages/compiler/src/backend/llvm/emit-module.ts b/packages/compiler/src/backend/llvm/emit-module.ts index 5ccf7ccd8..3d9d41072 100644 --- a/packages/compiler/src/backend/llvm/emit-module.ts +++ b/packages/compiler/src/backend/llvm/emit-module.ts @@ -545,6 +545,7 @@ export function emitModuleParts(emitter: LlEmitter): string[] { ``, `@scr_error_vts = external ${tl}global [${RUNTIME_ERROR_CLASSES.size} x %ScrVt]`, `declare void @scr_init()`, + ...(emitter.usesCompactRefs ? [`declare void @scr_plr_init()`] : []), `declare void @scr_lib_init(i32, ptr)`, ...(emitter.mod.workers ? [`declare void @scr_runtime_workers_v8()`] : []), ...(emitter.stackChecks?.size ? [`declare void @scr_stack_guard_init()`] : []), @@ -837,6 +838,9 @@ export function emitModuleParts(emitter: LlEmitter): string[] { ...(emitter.runtimeAbiMarker ? [` call void @${RUNTIME_ABI_MARKER}()`] : []), ...(emitter.mod.workers ? [` call void @scr_runtime_workers_v8()`] : []), ` call void @scr_init()`, + // Compressed fields hold addresses in the program-lifetime region, which + // is reserved below 32 GiB before compiled code runs. + ...(emitter.usesCompactRefs ? [` call void @scr_plr_init()`] : []), // Each context (the main thread, every worker) installs its stack // guard before running compiled code that checks it. ...(emitter.stackChecks?.size ? [` call void @scr_stack_guard_init()`] : []), diff --git a/packages/compiler/src/backend/llvm/emit-statements.ts b/packages/compiler/src/backend/llvm/emit-statements.ts index 85f6c8dd7..d1dc6369b 100644 --- a/packages/compiler/src/backend/llvm/emit-statements.ts +++ b/packages/compiler/src/backend/llvm/emit-statements.ts @@ -558,7 +558,7 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { emitter.emitPublishedFieldGuard(obj.name, null, s.field); const { ptr, type, inline } = s.kind === "fieldSet" - ? emitter.classFieldPtr(obj.name, s.className, s.field) + ? emitter.classFieldPtr(obj.name, s.className, s.field, "compressed") : emitter.recordFieldPtr(obj.name, s.shapeId, s.field); // A result-slot entry fills zeroed caller storage, each field once. if ( diff --git a/packages/compiler/src/backend/llvm/emitter.ts b/packages/compiler/src/backend/llvm/emitter.ts index 0bdbe23b2..0badf4000 100644 --- a/packages/compiler/src/backend/llvm/emitter.ts +++ b/packages/compiler/src/backend/llvm/emitter.ts @@ -266,6 +266,8 @@ import { classFieldTypes, classMembershipIntervals, classFieldIndex, + compactRefLoadLines, + compactRefStoreLines, classPreLines, classStructSym, programLifetimeClass, @@ -423,6 +425,20 @@ export interface LlvmTargetOptions { /** Translated WebAssembly memories check bounds explicitly instead of * relying on guard pages (wasm-modules.ts wasmBoundsChecks). */ wasmBoundsChecks?: boolean; + /** The executable can reserve its program-lifetime region below 32 GiB + * (lowRegionTarget): fields that refer to compact class instances then + * store the instance's address over 8 in 32 bits (classes.ts + * compactRefLoadLines). Elsewhere they keep 8-byte pointers. */ + lowRegion?: boolean; +} + +/** LlvmTargetOptions.lowRegion for an executable: Linux targets without + * sanitizers, whose address space below 32 GiB is free (ASan keeps its + * shadow memory there; other systems map their own images and libraries + * there). `platform` is a target platform (`linux`, `darwin`, `win32`, + * `wasi`). */ +export function lowRegionTarget(platform: string, sanitize: boolean): boolean { + return platform === "linux" && !sanitize; } export function emitLlvmModule(input: IrModule, options: LlvmTargetOptions = {}): string { @@ -593,6 +609,13 @@ export class LlEmitter { integerArrayBindings = new Set(); readonly fieldAliasTags = new Map(); readonly fieldPointerTags = new Map(); + /** The field pointers (classFieldPtr) of this function whose fields hold + * 32-bit references to compact class instances (LlClassMeta.compressed): + * loadField/loadRef decode them and storeField/storeRef encode them. */ + readonly compressedFieldPtrs = new Set(); + /** Whether a class has compressed fields: main reserves the region before + * compiled code runs (scr_plr_init). */ + usesCompactRefs = false; /** Native class fields with different property names cannot occupy the * same slot of one object. Inherited views of the same property share a @@ -1507,7 +1530,32 @@ export class LlEmitter { this.classMeta, (root) => programLifetimeClass(this.shapeHost, root) && !root.threadSlot, (cls) => classFieldTypes(this.shapeHost, cls, this.int32Slots), + // Executables whose region lies below 32 GiB hold compact class + // instances there (scr_plr_alloc), so fields referring to one store + // a 32-bit reference: the field's type, the class of a + // `C | undefined` or `C | null` pointer, or the reference arm of a + // nullable pointer field, is a compact class. `C | null | undefined` + // keeps the pointer: its null is a sentinel outside the region. + mod.lib === undefined && options.lowRegion === true + ? (cls, i, isCompact) => { + const f = cls.fields[i]!; + if (this.inlineUnions.classField(cls.name, f.name)) return false; + const t = f.type; + if (t.kind === "object") return isCompact(t.className); + if (t.kind !== "union") return false; + const single = this.nullableUnions.single(t.unionId); + if (single !== null) + return ( + single.nullTag < 0 && + single.arm.kind === "object" && + isCompact(single.arm.className) + ); + const nullable = this.nullableFields.get(cls.name, f.name); + return nullable !== null && isCompact(nullable.arm.className); + } + : undefined, ); + this.usesCompactRefs = [...this.classMeta.values()].some((m) => m.compressed.some(Boolean)); for (const [name, rec] of RUNTIME_ERROR_CLASSES) { const meta = this.classMeta.get(name); if (!meta) break; // hand-written IR without the builtin defs: no stamps @@ -3217,15 +3265,47 @@ export class LlEmitter { objName: string, className: string, field: string, - ): { ptr: string; type: IrType; inline: boolean } { + refs: "pointer" | "compressed" = "pointer", + ): { ptr: string; type: IrType; inline: boolean; compressed: boolean } { const meta = this.classMetaOf(className); - const { index, type } = classFieldIndex(meta, field); + const { index, type, compressed } = classFieldIndex(meta, field, refs); const p = this.B.tmp(); this.B.line( `${p} = getelementptr inbounds %${classStructSym(className)}, ptr ${objName}, i64 0, i32 ${index}`, ); this.markFieldPointer(p, field); - return { ptr: p, type, inline: this.inlineUnions.classField(className, field) }; + if (compressed) this.compressedFieldPtrs.add(p); + return { ptr: p, type, inline: this.inlineUnions.classField(className, field), compressed }; + } + + /** Loads the reference a field pointer addresses: a pointer, or the + * decoded 32-bit reference of a compressed field (compressedFieldPtrs). + * `tagged`: the load carries the field's alias tags. */ + loadRef(ptr: string, tagged = true): string { + const B = this.B; + const v = B.tmp(); + const tags = tagged ? this.fieldAliasAttachment(ptr) : ""; + if (!this.compressedFieldPtrs.has(ptr)) { + B.line(`${v} = load ptr, ptr ${ptr}${tags}`); + return v; + } + const idx = B.tmp(); + B.line(`${idx} = load i32, ptr ${ptr}${tags}`); + for (const line of compactRefLoadLines(idx, v, `${v}.r`)) B.line(line.trimStart()); + return v; + } + + /** Stores `value` (a pointer) through a field pointer: as is, or encoded + * as the 32-bit reference of a compressed field. */ + storeRef(ptr: string, value: string): void { + const B = this.B; + if (!this.compressedFieldPtrs.has(ptr)) { + B.line(`store ptr ${value}, ptr ${ptr}${this.fieldAliasAttachment(ptr)}`); + return; + } + const idx = B.tmp(); + for (const line of compactRefStoreLines(value, idx, `${idx}.r`)) B.line(line.trimStart()); + B.line(`store i32 ${idx}, ptr ${ptr}${this.fieldAliasAttachment(ptr)}`); } /** The dynamic class's preorder number (borrowed object; the static class @@ -3357,6 +3437,7 @@ export class LlEmitter { const { tag, bits } = loadInlineUnion(B, ptr); return stackUnionBox(B, this.sizeType, tag, bits); } + if (this.compressedFieldPtrs.has(ptr)) return this.loadRef(ptr); const fieldTy = llFieldType(t, false); const raw = B.tmp(); B.line(`${raw} = load ${fieldTy}, ptr ${ptr}${this.fieldAliasAttachment(ptr)}`); @@ -3383,8 +3464,7 @@ export class LlEmitter { replaceField(ptr: string, type: IrType, inline: boolean, v: LlValue): void { if (!inline && isRefCounted(type)) { this.toHeap(v); - const old = this.B.tmp(); - this.B.line(`${old} = load ptr, ptr ${ptr}`); + const old = this.loadRef(ptr, false); this.storeField(ptr, type, v.name, false); this.releaseHeap(old, type); return; @@ -3408,6 +3488,10 @@ export class LlEmitter { storeInlineUnion(B, ptr, tag, bits); return; } + if (this.compressedFieldPtrs.has(ptr)) { + this.storeRef(ptr, value); + return; + } const fieldTy = llFieldType(t, false); if (fieldTy !== "i8") { B.line(`store ${fieldTy} ${value}, ptr ${ptr}${this.fieldAliasAttachment(ptr)}`); @@ -5182,8 +5266,9 @@ export class LlEmitter { : [ { name: f.name, - index: classFieldIndex(meta, f.name).index, + index: classFieldIndex(meta, f.name, "compressed").index, type: this.nullableFields.storageType(className, f.name, f.type), + compressed: classFieldIndex(meta, f.name, "compressed").compressed, }, ], ), @@ -5390,11 +5475,9 @@ export class LlEmitter { emitUnionProjection(e: IrExpr): LlValue { const nullable = this.nullableFieldGet(e); if (!nullable || e.kind !== "fieldGet") return this.emitReadReceiver(e); - const B = this.B; const receiver = this.emitReadReceiver(e.obj); - const { ptr } = this.classFieldPtr(receiver.name, e.className, e.field); - const p = B.tmp(); - B.line(`${p} = load ptr, ptr ${ptr}${this.fieldAliasAttachment(ptr)}`); + const { ptr } = this.classFieldPtr(receiver.name, e.className, e.field, "compressed"); + const p = this.loadRef(ptr); return { name: this.stackNullableBox(p, nullable), type: e.type }; } @@ -5407,9 +5490,8 @@ export class LlEmitter { if (!nullable || e.kind !== "fieldGet") throw new InternalCompilerError("llvm emitter bug: owned nullable stack of non-field"); const receiver = this.emitReadReceiver(e.obj); - const { ptr } = this.classFieldPtr(receiver.name, e.className, e.field); - const p = this.B.tmp(); - this.B.line(`${p} = load ptr, ptr ${ptr}${this.fieldAliasAttachment(ptr)}`); + const { ptr } = this.classFieldPtr(receiver.name, e.className, e.field, "compressed"); + const p = this.loadRef(ptr); const owner = this.own({ name: this.retainFrame(p, nullable.arm), type: nullable.arm }); return { box: this.stackNullableBox(owner.name, nullable), owner }; } @@ -5486,7 +5568,6 @@ export class LlEmitter { nullable: NullableRefField, value: IrExpr, ): void { - const B = this.B; let next: string; if ( value.kind === "unionWrap" && @@ -5509,10 +5590,9 @@ export class LlEmitter { } else { next = this.unionToNullable(this.emitUnionProjection(value).name, nullable); } - const { ptr } = this.classFieldPtr(obj, className, field); - const old = B.tmp(); - B.line(`${old} = load ptr, ptr ${ptr}`); - B.line(`store ptr ${next}, ptr ${ptr}${this.fieldAliasAttachment(ptr)}`); + const { ptr } = this.classFieldPtr(obj, className, field, "compressed"); + const old = this.loadRef(ptr, false); + this.storeRef(ptr, next); this.releaseHeap(old, nullable.arm); } diff --git a/packages/compiler/src/backend/llvm/expr-control.ts b/packages/compiler/src/backend/llvm/expr-control.ts index fd2061aae..242f9997c 100644 --- a/packages/compiler/src/backend/llvm/expr-control.ts +++ b/packages/compiler/src/backend/llvm/expr-control.ts @@ -510,9 +510,13 @@ export function emitOptionalChainReceiver( // pointer itself, through a private stack box when the union's own // representation is boxed (emitUnionProjection's form). const owner = host.emitReadReceiver(e.receiver.obj); - const { ptr } = host.classFieldPtr(owner.name, e.receiver.className, e.receiver.field); - const p = B.tmp(); - B.line(`${p} = load ptr, ptr ${ptr}${host.fieldAliasAttachment(ptr)}`); + const { ptr } = host.classFieldPtr( + owner.name, + e.receiver.className, + e.receiver.field, + "compressed", + ); + const p = host.loadRef(ptr); r = { name: host.nullableUnions.get(def.id) ? p : host.stackNullableBox(p, nullableField), type: e.receiver.type, diff --git a/packages/compiler/src/backend/llvm/expr-dynamic.ts b/packages/compiler/src/backend/llvm/expr-dynamic.ts index 554306f6e..563a900f8 100644 --- a/packages/compiler/src/backend/llvm/expr-dynamic.ts +++ b/packages/compiler/src/backend/llvm/expr-dynamic.ts @@ -344,7 +344,7 @@ export function emitDynamicExpr( const payload = host.unionPeek(u.name, def.id); const { ptr, type, inline } = arm.kind === "object" - ? host.classFieldPtr(payload, arm.className, e.field) + ? host.classFieldPtr(payload, arm.className, e.field, "compressed") : host.recordFieldPtr(payload, arm.shapeId, e.field); const nullable = arm.kind === "object" ? host.nullableFields.get(arm.className, e.field) : null; diff --git a/packages/compiler/src/backend/llvm/expr-primitives.ts b/packages/compiler/src/backend/llvm/expr-primitives.ts index d6a33ceeb..12e488b6d 100644 --- a/packages/compiler/src/backend/llvm/expr-primitives.ts +++ b/packages/compiler/src/backend/llvm/expr-primitives.ts @@ -1064,13 +1064,17 @@ export function emitRecordExpr( switch (e.kind) { case "fieldGet": { const obj = host.emitReadReceiver(e.obj); - const { ptr, type, inline } = host.classFieldPtr(obj.name, e.className, e.field); + const { ptr, type, inline } = host.classFieldPtr( + obj.name, + e.className, + e.field, + "compressed", + ); if (host.int32Slots.isField(e.className, e.field)) return host.loadInt32Field(ptr, e.type); if (inline) return host.own({ name: host.inlineFieldUnion(ptr, type), type: e.type }); const nullable = host.nullableFieldGet(e); if (nullable) { - const p = B.tmp(); - B.line(`${p} = load ptr, ptr ${ptr}${host.fieldAliasAttachment(ptr)}`); + const p = host.loadRef(ptr); return host.own({ name: host.nullableToOwnedUnion(p, nullable), type: e.type }); } const v = host.loadField(ptr, type, false); diff --git a/packages/compiler/src/backend/llvm/expr-stream-bridges.ts b/packages/compiler/src/backend/llvm/expr-stream-bridges.ts index a4f2ed749..a0a0cf24a 100644 --- a/packages/compiler/src/backend/llvm/expr-stream-bridges.ts +++ b/packages/compiler/src/backend/llvm/expr-stream-bridges.ts @@ -20,7 +20,14 @@ import { } from "../../ir/ir.js"; import { mangleFunction, mangleGlobal, mangleRecordStruct } from "../mangle.js"; import { BlockBuilder } from "./blocks.js"; -import { type LlClassMeta, classFieldIndex, classPreLines, classStructSym } from "./classes.js"; +import { + type LlClassMeta, + classFieldIndex, + classPreLines, + classStructSym, + compactRefLoadLines, + compactRefStoreLines, +} from "./classes.js"; import { SCR_ARR_FIELD, llvmCommentText } from "./common.js"; import { FN_ATTRS, @@ -280,7 +287,7 @@ export function streamTypedRefCommitAdapter( const pending = `f${index}_pending`; const store = `f${index}_store`; const after = `f${index}_after`; - const { index: fieldIndex } = classFieldIndex(meta, field.name); + const { index: fieldIndex, compressed } = classFieldIndex(meta, field.name, "compressed"); const int32 = host.int32Slots.isField(t.className, field.name); const inline = host.inlineUnions.classField(t.className, field.name); const fieldTy = int32 ? "i32" : llFieldType(field.type, inline); @@ -335,7 +342,12 @@ export function streamTypedRefCommitAdapter( ` br i1 %${pending}, label %done, label %${store}`, `${store}:`, ` %f${index}_ptr = getelementptr inbounds %${classStructSym(t.className)}, ptr %target, i64 0, i32 ${fieldIndex}`, - ` %f${index}_old = load ${fieldTy}, ptr %f${index}_ptr`, + ...(compressed + ? [ + ` %f${index}_oldidx = load i32, ptr %f${index}_ptr`, + ...compactRefLoadLines(`%f${index}_oldidx`, `%f${index}_old`, `%f${index}_od`), + ] + : [` %f${index}_old = load ${fieldTy}, ptr %f${index}_ptr`]), ); if (int32) { // int32-slots.ts keeps a field int32 only when no dynamic store in @@ -375,7 +387,12 @@ export function streamTypedRefCommitAdapter( ` %f${index}_pay = load ptr, ptr %f${index}_payp`, ` %f${index}_sel = select i1 %f${index}_isref, ptr %f${index}_pay, ptr null`, ` %f${index}_new = call ptr ${rc.retain}(ptr %f${index}_sel)`, - ` store ptr %f${index}_new, ptr %f${index}_ptr`, + ...(compressed + ? [ + ...compactRefStoreLines(`%f${index}_new`, `%f${index}_newidx`, `%f${index}_ne`), + ` store i32 %f${index}_newidx, ptr %f${index}_ptr`, + ] + : [` store ptr %f${index}_new, ptr %f${index}_ptr`]), ` call void @scr_union_release(ptr %${next})`, ` call void ${rc.release}(ptr %f${index}_old)`, ` br label %${after}`, @@ -398,6 +415,11 @@ export function streamTypedRefCommitAdapter( ` %f${index}_stored = zext i1 %${next} to i8`, ` store i8 %f${index}_stored, ptr %f${index}_ptr`, ); + } else if (compressed) { + lines.push( + ...compactRefStoreLines(`%${next}`, `%f${index}_nextidx`, `%f${index}_nx`), + ` store i32 %f${index}_nextidx, ptr %f${index}_ptr`, + ); } else { lines.push(` store ${fieldTy} %${next}, ptr %f${index}_ptr`); } @@ -832,7 +854,7 @@ export function streamTypedRefMaterializeAdapter( B.condBr(present, yes, afterField); B.startBlock(yes); } - const { index } = classFieldIndex(meta, field.name); + const { index, compressed } = classFieldIndex(meta, field.name, "compressed"); const fieldPtr = B.tmp(); let fieldValue = B.tmp(); B.line( @@ -844,7 +866,12 @@ export function streamTypedRefMaterializeAdapter( B.line(`${fieldValue} = sitofp i32 ${raw} to double`); } else if (host.inlineUnions.classField(t.className, field.name)) fieldValue = loadStructField(B, host.sizeType, fieldPtr, field.type, true); - else B.line(`${fieldValue} = load ${llFieldType(field.type, false)}, ptr ${fieldPtr}`); + else if (compressed) { + const idx = B.tmp(); + B.line(`${idx} = load i32, ptr ${fieldPtr}`); + for (const line of compactRefLoadLines(idx, fieldValue, `${fieldValue}.r`)) + B.line(line.trimStart()); + } else B.line(`${fieldValue} = load ${llFieldType(field.type, false)}, ptr ${fieldPtr}`); if (llFieldType(field.type, false) === "i8") { const boolValue = B.tmp(); B.line(`${boolValue} = trunc i8 ${fieldValue} to i1`); diff --git a/packages/compiler/src/backend/llvm/publish.ts b/packages/compiler/src/backend/llvm/publish.ts index bb7e0c8a8..2f45c3cd2 100644 --- a/packages/compiler/src/backend/llvm/publish.ts +++ b/packages/compiler/src/backend/llvm/publish.ts @@ -25,7 +25,7 @@ import type { IrClassDef, IrRecordShape, IrType, IrUnionDef, SrcLoc } from "../. import { mapOf, STRING, typeKey } from "../../ir/ir.js"; import { mangleClassStruct, mangleRecordStruct } from "../mangle.js"; import { FN_ATTRS } from "./shapes.js"; -import { COMPACT_ID_MASK } from "./classes.js"; +import { COMPACT_ID_MASK, compactRefLoadLines } from "./classes.js"; import { shapeTagFn } from "./nullable-unions.js"; import type { InlineUnionFields } from "./inline-unions.js"; import { LlvmUnsupportedError } from "./unsupported.js"; @@ -69,8 +69,10 @@ export interface PublishClassInfo { idInRc: boolean; /** Instances have the 32-bit header (classes.ts LlClassMeta.compact). */ compact: boolean; - /** The class's own and inherited fields: GEP index and storage type. */ - fields: { name: string; index: number; type: IrType }[]; + /** The class's own and inherited fields: GEP index and storage type; + * `compressed` when the field holds a 32-bit reference (classes.ts + * LlClassMeta.compressed), which the walker decodes. */ + fields: { name: string; index: number; type: IrType; compressed?: boolean }[]; } /** scr_pub_mark's object kinds (SCR_PUB_KIND_* in scr_runtime.h), for the RC audit. */ @@ -536,7 +538,7 @@ export class PublishWalkers { head: string, struct: string, traced: boolean, - members: { name: string; index: number; type: IrType }[], + members: PublishClassInfo["fields"], path: string, loc: SrcLoc, classId = false, @@ -559,7 +561,12 @@ export class PublishWalkers { } lines.push( ` %f${n} = getelementptr inbounds %${struct}, ptr %o, i64 0, i32 ${member.index} ; ${llvmComment(member.name)}`, - ` %v${n} = load ptr, ptr %f${n}`, + ...(member.compressed === true + ? [ + ` %v${n}.i = load i32, ptr %f${n}`, + ...compactRefLoadLines(`%v${n}.i`, `%v${n}`, `%v${n}.d`), + ] + : [` %v${n} = load ptr, ptr %f${n}`]), ...this.push(`%v${n}`, fn, `${n}`, this.compactRef(member.type)), ); n++; diff --git a/packages/compiler/src/backend/llvm/receivers.ts b/packages/compiler/src/backend/llvm/receivers.ts index 50b9485a1..67ca17188 100644 --- a/packages/compiler/src/backend/llvm/receivers.ts +++ b/packages/compiler/src/backend/llvm/receivers.ts @@ -118,7 +118,12 @@ export function emitReadReceiver(emitter: LlEmitter, e: IrExpr): LlValue { const { ptr, type, inline } = emitter.recordFieldPtr(receiver.name, e.shapeId, e.field); return { name: emitter.loadRecordField(ptr, type, inline), type: e.type }; } - const { ptr, type, inline } = emitter.classFieldPtr(receiver.name, e.className, e.field); + const { ptr, type, inline } = emitter.classFieldPtr( + receiver.name, + e.className, + e.field, + "compressed", + ); if (emitter.int32Slots.isField(e.className, e.field)) return emitter.loadInt32Field(ptr, e.type); return { name: emitter.loadField(ptr, type, inline), type: e.type }; diff --git a/packages/compiler/src/index.ts b/packages/compiler/src/index.ts index 92ee6b75e..2b216c77d 100644 --- a/packages/compiler/src/index.ts +++ b/packages/compiler/src/index.ts @@ -67,7 +67,11 @@ import { mobileTargetRefusal, resolveCc, } from "./backend/external-c.js"; -import { emitLlvmModuleSource, LlvmUnsupportedError } from "./backend/llvm/emitter.js"; +import { + emitLlvmModuleSource, + LlvmUnsupportedError, + lowRegionTarget, +} from "./backend/llvm/emitter.js"; import { inlineRcOption } from "./backend/llvm/shapes.js"; import { emitNativeArtifact, @@ -782,6 +786,7 @@ async function prepareExecutableInput( wasi: buildPlatform === "wasi", runtimeAbiMarker: outputKind === "obj", objectAudit: opts.sanitize === true, + lowRegion: lowRegionTarget(buildPlatform, opts.sanitize === true), ...(opts.sanitize === true ? { wasmBoundsChecks: true } : {}), ...inlineRcOption(opts.optimization, opts.sanitize === true), }); @@ -848,6 +853,7 @@ async function prepareExecutableInput( wasi: buildPlatform === "wasi", runtimeAbiMarker: useRuntimePack, objectAudit: opts.sanitize === true, + lowRegion: lowRegionTarget(buildPlatform, opts.sanitize === true), ...(opts.sanitize === true ? { wasmBoundsChecks: true } : {}), ...inlineRcOption(opts.optimization, opts.sanitize === true), ...(opts.detachedExit === true ? { detachedExit: true } : {}), diff --git a/packages/compiler/src/native/prepare.ts b/packages/compiler/src/native/prepare.ts index b90760616..6b0a2fea5 100644 --- a/packages/compiler/src/native/prepare.ts +++ b/packages/compiler/src/native/prepare.ts @@ -7,7 +7,7 @@ import type { CompileLibraryOptions, CompileRequestOptions, } from "../compile-types.js"; -import { emitLlvmModule } from "../backend/llvm/emitter.js"; +import { emitLlvmModule, lowRegionTarget } from "../backend/llvm/emitter.js"; import { inlineRcOption } from "../backend/llvm/shapes.js"; import { executableLinkFeatures } from "../backend/executable-features.js"; import type { NativeLinkFeatures } from "../backend/native-link-info-core.js"; @@ -293,6 +293,7 @@ export function prepareNativeExecutable( wasi: toolchain.target.platform === "wasi", runtimeAbiMarker: outputKind === "obj" || outputKind === "exe", objectAudit: options.sanitize === true, + lowRegion: lowRegionTarget(toolchain.target.platform, options.sanitize === true), ...inlineRcOption(options.optimization, options.sanitize === true), ...(options.detachedExit === true && outputKind === "exe" ? { detachedExit: true } : {}), ...(options.optimization === "dev" && !options.strip diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4636-contract-program-lifetime-references.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4636-contract-program-lifetime-references.ts.json new file mode 100644 index 000000000..a503a5aa0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4636-contract-program-lifetime-references.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4636-contract-program-lifetime-references.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4637-contract-program-lifetime-workers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4637-contract-program-lifetime-workers.ts.json new file mode 100644 index 000000000..c5d09c649 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4637-contract-program-lifetime-workers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4637-contract-program-lifetime-workers.ts" + ], + "diags": [] +} diff --git a/packages/runtime/src/scr_alloc.c b/packages/runtime/src/scr_alloc.c index 8cf14fb7f..4b29b4b51 100644 --- a/packages/runtime/src/scr_alloc.c +++ b/packages/runtime/src/scr_alloc.c @@ -1983,3 +1983,203 @@ void scr_heap_stats(double *total, double *used) { *total = (double)(held + sys_held); *used = (double)(held - (idle < held ? idle : held) + sys_used); } + +/* ── program-lifetime region ──────────────────────────────────────────── + * Instances of compact classes (llvm/classes.ts LlClassMeta.compact) in + * programs built for Linux without sanitizers live in one address range + * reserved for the whole process below 32 GiB, so a field that holds one + * can store its address over 8 in 32 bits (0 stays NULL). The instances + * are never freed. Each thread carves them from its own chunks of + * SCR_PLR_CHUNK bytes; a chunk is taken from the range with one atomic add. + * Pages are committed by first touch and start zeroed. Its strings are + * arrays rather than literals: programs without compact classes then link + * none of this, where literals would stay in the unit's merged strings. */ +#if defined(__linux__) && SIZE_MAX > UINT32_MAX +#include + +#define SCR_PLR_CHUNK ((size_t)1 << 20) +/* References are 32-bit addresses of 8-byte units, so the range ends by + * SCR_PLR_END. It starts at 4 GiB or above, clear of executables loaded low + * and their heaps; a refused size is halved down to SCR_PLR_MIN. */ +#define SCR_PLR_END ((size_t)32 << 30) +#define SCR_PLR_MIN ((size_t)1 << 30) +/* Past its first SCR_PLR_HUGE_AFTER bytes the range uses transparent huge + * pages, as the allocator's slices do (SCR_SA_HUGE_AFTER): a large heap of + * instances takes 512 times fewer page faults and TLB entries, and a small + * program stays on small pages. */ +#define SCR_PLR_HUGE_AFTER ((size_t)8 << 20) + +static char *scr_plr_base; /* the range's start, once reserved */ +static size_t scr_plr_size; +static size_t scr_plr_top; /* atomic */ +#if defined(SCR_WORKERS) || (defined(SCR_LIB) && defined(SCR_THREAD_INSTANCES)) +_Thread_local ScrPlrChunk scr_plr_chunk; +#else +ScrPlrChunk scr_plr_chunk; +#endif + +/* Reserves `size` bytes at `at` exactly; NULL if refused. */ +static char *scr_plr_map(void *at, size_t size) { + int flags = MAP_PRIVATE | MAP_ANON | MAP_NORESERVE; +#ifdef MAP_FIXED_NOREPLACE + flags |= MAP_FIXED_NOREPLACE; +#endif + char *p = mmap(at, size, PROT_READ | PROT_WRITE, flags, -1, 0); + if (p == MAP_FAILED) return NULL; + if (p != (char *)at) { + /* The system took `at` as a hint only (no MAP_FIXED_NOREPLACE). */ + (void)munmap(p, size); + return NULL; + } + return p; +} + +static __attribute__((noinline)) void scr_plr_reserve(void) { + static char lock; + while (__atomic_test_and_set(&lock, __ATOMIC_ACQUIRE)) { + } + if (!__atomic_load_n(&scr_plr_base, __ATOMIC_ACQUIRE)) { + char *p = NULL; + size_t size = 0; + for (size_t start = (size_t)4 << 30; !p && start <= (size_t)16 << 30; start *= 2) { + size = SCR_PLR_END - start; + while (size >= SCR_PLR_MIN && !(p = scr_plr_map((void *)start, size))) size /= 2; + } + if (p) { +#ifdef MADV_HUGEPAGE + (void)madvise(p + SCR_PLR_HUGE_AFTER, size - SCR_PLR_HUGE_AFTER, MADV_HUGEPAGE); +#endif + scr_plr_size = size; + /* The first chunk is never handed out, so every chunk is + * page-aligned. */ + __atomic_store_n(&scr_plr_top, SCR_PLR_CHUNK, __ATOMIC_RELAXED); + __atomic_store_n(&scr_plr_base, p, __ATOMIC_RELEASE); + } + } + __atomic_clear(&lock, __ATOMIC_RELEASE); + if (!scr_plr_base) { + static const char message[] = + "scriptc: cannot reserve address space below 32 GiB for program-lifetime objects\n"; + scr_trap(message); + } +} + +#ifdef SCR_SA_TRIM +/* A worker whose memory goes back when it exits (scr_sa_park_arena: it + * shared nothing) returns its chunks too, when the thread ends, and later + * chunks reuse them. A thread's chunks are linked through their first two + * words (the next chunk and the chunk's size) from scr_plr_mine; the first + * chunk a thread takes registers scr_plr_thread_end. */ +#define SCR_PLR_LINK 16 +static _Thread_local char *scr_plr_mine; +static pthread_key_t scr_plr_end_key; +static pthread_once_t scr_plr_end_once = PTHREAD_ONCE_INIT; +static pthread_mutex_t scr_plr_free_lock = PTHREAD_MUTEX_INITIALIZER; +static char **scr_plr_free; /* returned chunks of SCR_PLR_CHUNK bytes */ +static size_t scr_plr_nfree, scr_plr_free_cap; + +/* Thread exit, after scr_sa_thread_park decided whether the thread's memory + * goes back. SCR_SA_DISCARD=poison makes the chunks inaccessible instead. */ +static void scr_plr_thread_end(void *unused) { + (void)unused; + char *c = scr_plr_mine; + scr_plr_mine = NULL; + if (!scr_sa_discarded) return; + bool poison = scr_sa_discard_mode() == 2; + size_t returned = 0; + while (c) { + char *next = ((char **)c)[0]; + size_t size = ((size_t *)c)[1]; + returned += size; + if (poison) { + (void)mprotect(c, size, PROT_NONE); + } else { + (void)madvise(c, size, MADV_DONTNEED); /* reads as zero again */ + if (size == SCR_PLR_CHUNK) { + pthread_mutex_lock(&scr_plr_free_lock); + if (scr_plr_nfree == scr_plr_free_cap) { + size_t cap = scr_plr_free_cap ? 2 * scr_plr_free_cap : 64; + char **grown = realloc(scr_plr_free, cap * sizeof *grown); + if (grown) { + scr_plr_free = grown; + scr_plr_free_cap = cap; + } + } + if (scr_plr_nfree < scr_plr_free_cap) scr_plr_free[scr_plr_nfree++] = c; + pthread_mutex_unlock(&scr_plr_free_lock); + } + } + c = next; + } + static const char stats_line[] = "scr_sa: thread returned %zu MB of program-lifetime objects\n"; + const char *stats = getenv("SCR_SA_STATS"); + if (stats && stats[0] == '1') fprintf(stderr, stats_line, returned >> 20); +} + +static void scr_plr_end_key_init(void) { + (void)pthread_key_create(&scr_plr_end_key, scr_plr_thread_end); +} + +/* Records the calling thread's new chunk `p` of `size` bytes. */ +static void scr_plr_own(char *p, size_t size) { + if (!scr_plr_mine) { + (void)pthread_once(&scr_plr_end_once, scr_plr_end_key_init); + (void)pthread_setspecific(scr_plr_end_key, p); + } + ((char **)p)[0] = scr_plr_mine; + ((size_t *)p)[1] = size; + scr_plr_mine = p; +} + +static char *scr_plr_reuse(void) { + char *c = NULL; + pthread_mutex_lock(&scr_plr_free_lock); + if (scr_plr_nfree) c = scr_plr_free[--scr_plr_nfree]; + pthread_mutex_unlock(&scr_plr_free_lock); + return c; +} +#else +#define SCR_PLR_LINK 0 +#endif + +static __attribute__((noinline)) void *scr_plr_refill(size_t n) { + if (!__atomic_load_n(&scr_plr_base, __ATOMIC_ACQUIRE)) scr_plr_reserve(); + size_t need = n + SCR_PLR_LINK; + size_t chunk = + need > SCR_PLR_CHUNK ? (need + SCR_PLR_CHUNK - 1) & ~(SCR_PLR_CHUNK - 1) : SCR_PLR_CHUNK; + char *p = NULL; +#ifdef SCR_SA_TRIM + if (chunk == SCR_PLR_CHUNK) p = scr_plr_reuse(); +#endif + if (!p) { + size_t at = __atomic_fetch_add(&scr_plr_top, chunk, __ATOMIC_RELAXED); + if (at + chunk > scr_plr_size || at + chunk < at) { + static const char message[] = "scriptc: out of address space for program-lifetime objects\n"; + scr_trap(message); + } + p = scr_plr_base + at; + } +#ifdef SCR_SA_TRIM + scr_plr_own(p, chunk); +#endif + scr_plr_chunk.next = p + SCR_PLR_LINK + n; + scr_plr_chunk.limit = p + chunk; + return p + SCR_PLR_LINK; +} + +/* Called before compiled code runs (emitted main), so the region exists + * before any reference into it does. */ +void scr_plr_init(void) { + if (!__atomic_load_n(&scr_plr_base, __ATOMIC_ACQUIRE)) scr_plr_reserve(); +} + +void *scr_plr_alloc(size_t n) { + n = (n + 7) & ~(size_t)7; + char *p = scr_plr_chunk.next; + if (p && n <= (size_t)(scr_plr_chunk.limit - p)) { + scr_plr_chunk.next = p + n; + return p; + } + return scr_plr_refill(n); +} +#endif diff --git a/packages/runtime/src/scr_rc.h b/packages/runtime/src/scr_rc.h index 892531965..93fdd7946 100644 --- a/packages/runtime/src/scr_rc.h +++ b/packages/runtime/src/scr_rc.h @@ -308,6 +308,30 @@ void scr_cyc_free(void *obj); /* frees the block, header included */ void *scr_mem_realloc(void *p, size_t n); void *scr_rt_calloc(size_t n); /* emitted-code entry points */ +#if defined(__linux__) && SIZE_MAX > UINT32_MAX +/* The program-lifetime region (scr_alloc.c): compact class instances of + * programs built for Linux without sanitizers (llvm/emitter.ts + * lowRegionTarget), which are never freed, at 8-byte aligned addresses below + * 32 GiB, so their fields can hold address >> 3 in 32 bits (0 is NULL). + * scr_plr_init reserves it before compiled code runs; scr_plr_alloc returns + * zeroed memory. */ +void scr_plr_init(void); +void *scr_plr_alloc(size_t n); +/* The calling script thread's part of the region: emitted allocation fast + * paths take [next, limit) in 8-byte multiples and call scr_plr_alloc when + * it is exhausted (llvm/classes.ts addresses both fields). */ +typedef struct ScrPlrChunk { + char *next; + char *limit; +} ScrPlrChunk; +#if defined(SCR_WORKERS) || (defined(SCR_LIB) && defined(SCR_THREAD_INSTANCES)) +extern _Thread_local ScrPlrChunk scr_plr_chunk; +#else +extern ScrPlrChunk scr_plr_chunk; +#endif +_Static_assert(offsetof(ScrPlrChunk, next) == 0 && offsetof(ScrPlrChunk, limit) == 8, + "llvm/classes.ts addresses ScrPlrChunk fields at these offsets"); +#endif void scr_rt_free(void *p); /* Asks the allocator's pre-fault helper (scr_alloc.c) to fault the pages * of [lo, hi), aligned to 256 KiB, in ahead of use; builds without the diff --git a/scripts/ci-test-costs.json b/scripts/ci-test-costs.json index 949e80dc8..4c4964579 100644 --- a/scripts/ci-test-costs.json +++ b/scripts/ci-test-costs.json @@ -364,6 +364,7 @@ "tests/harness/oci-manifest.test.ts": 3, "tests/harness/opaque-class-view.test.ts": 1743, "tests/harness/process-argv.test.ts": 1923, + "tests/harness/program-lifetime-workers.test.ts": 4200, "tests/harness/project-config.test.ts": 71955, "tests/harness/provenance.test.ts": 3971, "tests/harness/regex.test.ts": 4073, @@ -781,6 +782,7 @@ "tests/harness/oci-manifest.test.ts": 3, "tests/harness/opaque-class-view.test.ts": 2545, "tests/harness/process-argv.test.ts": 2583, + "tests/harness/program-lifetime-workers.test.ts": 5, "tests/harness/project-config.test.ts": 162430, "tests/harness/provenance.test.ts": 3734, "tests/harness/publish-leaks.test.ts": 29487, diff --git a/tests/corpus/4636-contract-program-lifetime-references.ts b/tests/corpus/4636-contract-program-lifetime-references.ts new file mode 100644 index 000000000..1639f640e --- /dev/null +++ b/tests/corpus/4636-contract-program-lifetime-references.ts @@ -0,0 +1,195 @@ +import type { ProgramLifetime } from "@scriptc/types"; + +// ProgramLifetime classes that refer to each other through fields: plain, +// optional (undefined) and nullable (null) references, chains and cycles, +// references inherited from a base class and added by subclasses, beside +// fields of every other kind. Reads, writes, compound and logical +// assignment, optional chaining, identity, Map and Set keys, closures, +// inspection, JSON and unknown values see the same objects. + +abstract class Item implements ProgramLifetime { + readonly id: number; + next: Item | undefined = undefined; + owner: Group | null = null; + label: string; + constructor(id: number, label: string) { + this.id = id; + this.label = label; + } + abstract describe(): string; +} + +class Leaf extends Item { + weight = 1; + twin: Leaf | undefined = undefined; + describe(): string { + return `Leaf(${this.id}:${this.label}, w=${this.weight}, twin=${this.twin?.id ?? "-"})`; + } +} + +class Group extends Item { + first: Item | undefined = undefined; + last: Item | undefined = undefined; + readonly root: Root; + count = 0; + flagged = false; + constructor(id: number, label: string, root: Root) { + super(id, label); + this.root = root; + } + add(item: Item): void { + item.owner = this; + if (this.last === undefined) this.first = item; + else this.last.next = item; + this.last = item; + this.count++; + } + describe(): string { + const parts: string[] = []; + for (let at = this.first; at !== undefined; at = at.next) parts.push(at.describe()); + return `Group(${this.id}:${this.label} [${parts.join(", ")}])`; + } +} + +class Root implements ProgramLifetime { + readonly name: string; + top: Group | undefined = undefined; + self: Root; + readonly groups: Group[] = []; + readonly byLabel = new Map(); + constructor(name: string) { + this.name = name; + this.self = this; + } +} + +class Pair implements ProgramLifetime { + left: Pair | undefined; + right: Pair | null; + readonly tag: string; + constructor(left: Pair | undefined, right: Pair | null, tag: string) { + this.left = left; + this.right = right; + this.tag = tag; + } +} + +// A mortal class holding program-lifetime references. +class Cursor { + at: Item | undefined; + steps = 0; + constructor(at: Item | undefined) { + this.at = at; + } + advance(): boolean { + if (this.at === undefined) return false; + this.at = this.at.next; + this.steps++; + return this.at !== undefined; + } +} + +const root = new Root("root"); +let id = 0; +for (let g = 0; g < 3; g++) { + const group = new Group(id++, `g${g}`, root); + root.groups.push(group); + root.byLabel.set(group.label, group); + for (let i = 0; i < 3 + g; i++) { + const leaf = new Leaf(id++, `l${g}.${i}`); + leaf.weight = g * 10 + i; + group.add(leaf); + root.byLabel.set(leaf.label, leaf); + } +} +root.top = root.groups[0]; +root.groups[0]!.add(root.groups[1]!); +root.groups[1]!.add(root.groups[2]!); + +console.log(root.top?.describe()); +console.log(root.self === root, root.self.self.name, root.top?.root === root); + +// Reads through chains and the owner back references. +const deep = root.byLabel.get("l2.4"); +console.log(deep?.owner?.owner?.owner?.label, deep?.owner?.root.name, deep?.next?.id ?? "end"); +let hops = 0; +for (let at: Item | null = deep ?? null; at !== null; at = at.owner) hops++; +console.log("hops", hops); + +// Writes: replace, clear and relink. +const g1 = root.groups[1]!; +const firstOfG1 = g1.first!; +g1.first = firstOfG1.next; +firstOfG1.next = undefined; +firstOfG1.owner = null; +console.log(g1.describe()); +console.log(firstOfG1.owner === null, firstOfG1.next === undefined, firstOfG1.describe()); + +// Logical and conditional assignment. +const twins: Leaf[] = []; +for (const label of ["l0.0", "l0.1", "l0.2"]) { + const leaf = root.byLabel.get(label); + if (leaf instanceof Leaf) twins.push(leaf); +} +twins[0]!.twin ??= twins[1]; +twins[0]!.twin ??= twins[2]; +twins[1]!.twin ||= twins[0]; +twins[2]!.twin = twins[2]!.twin ?? twins[2]; +twins[2]!.twin &&= twins[1]; +console.log(twins.map((t) => t.describe()).join(" | ")); + +// Identity: Map and Set keys, ===, and arrays of references. +const seen = new Set(); +const visits = new Map(); +for (let round = 0; round < 3; round++) { + for (let at = root.groups[0]!.first; at !== undefined; at = at.next) { + seen.add(at); + visits.set(at, (visits.get(at) ?? 0) + 1); + } +} +console.log(seen.size, [...visits.values()].join(","), seen.has(root.groups[1]!), seen.has(firstOfG1)); +console.log(root.groups.indexOf(g1), root.groups.some((g) => g === firstOfG1)); + +// A mortal cursor and closures that capture program-lifetime objects. +const cursor = new Cursor(root.groups[2]!.first); +while (cursor.advance()) {} +console.log("steps", cursor.steps, cursor.at === undefined); +const readers: (() => string)[] = []; +for (const g of root.groups) readers.push(() => g.last?.label ?? "none"); +root.groups[2]!.last = root.groups[2]!.first; +console.log(readers.map((r) => r()).join(",")); + +// A cycle through null and undefined arms. +const a = new Pair(undefined, null, "a"); +const b = new Pair(a, null, "b"); +a.right = b; +a.left = a; +const c = new Pair(b, a, "c"); +console.log(c.left?.left?.right?.tag, c.right?.left?.tag, b.right, a.left === a); +const pairs = [a, b, c]; +pairs.sort((x, y) => (x.right?.tag ?? "").localeCompare(y.right?.tag ?? "")); +console.log(pairs.map((p) => `${p.tag}<${p.left?.tag ?? "u"},${p.right?.tag ?? "n"}>`).join(" ")); + +// Inspection, JSON and references boxed into unknown. +const solo = new Leaf(100, "solo"); +const other = new Leaf(101, "other"); +solo.twin = other; +console.log(solo); +console.log(JSON.stringify(other)); +console.log(JSON.stringify(new Pair(new Pair(undefined, null, "inner"), null, "outer"))); +console.log(Object.keys(solo).join(",")); +const boxed: unknown[] = [solo, solo.twin, solo.next, solo.owner]; +console.log(boxed.map((v) => typeof v).join(","), boxed[0] === solo, boxed[1] === other); +console.log(boxed.indexOf(other), boxed.includes(undefined), boxed.includes(null)); + +// Many objects with references to their neighbours. +let chain: Leaf | undefined = undefined; +let total = 0; +for (let i = 0; i < 20000; i++) { + const leaf: Leaf = new Leaf(i, "n"); + leaf.twin = chain; + leaf.weight = i % 7; + chain = leaf; +} +for (let at = chain; at !== undefined; at = at.twin) total += at.weight; +console.log("chain", total, chain?.twin?.twin?.id); diff --git a/tests/corpus/4637-contract-program-lifetime-workers.ts b/tests/corpus/4637-contract-program-lifetime-workers.ts new file mode 100644 index 000000000..bccdc240f --- /dev/null +++ b/tests/corpus/4637-contract-program-lifetime-workers.ts @@ -0,0 +1,79 @@ +import { Worker, isMainThread, parentPort, workerData } from "node:worker_threads"; +import type { ProgramLifetime } from "@scriptc/types"; + +// Waves of workers that each build a graph of ProgramLifetime instances +// referring to each other, post a checksum of it and exit without sharing +// anything. scriptc never frees such instances while the worker runs; on +// Linux their memory goes back after the worker exits, like the rest of +// its memory, and later workers reuse it. + +class Item implements ProgramLifetime { + readonly id: number; + next: Item | undefined = undefined; + owner: Group | undefined = undefined; + constructor(id: number) { + this.id = id; + } +} + +class Group implements ProgramLifetime { + readonly name: string; + first: Item | undefined = undefined; + previous: Group | undefined = undefined; + count = 0; + constructor(name: string) { + this.name = name; + } + add(item: Item): void { + item.owner = this; + item.next = this.first; + this.first = item; + this.count++; + } +} + +function build(seed: number, groups: number, items: number): number { + let last: Group | undefined = undefined; + for (let g = 0; g < groups; g++) { + const group: Group = new Group(`g${seed}.${g}`); + group.previous = last; + for (let i = 0; i < items; i++) group.add(new Item(seed * 1000003 + g * items + i)); + last = group; + } + let sum = 0; + for (let group = last; group !== undefined; group = group.previous) { + for (let item = group.first; item !== undefined; item = item.next) { + if (item.owner === group) sum = (sum + item.id * (group.count % 97)) % 1000000007; + } + } + return sum; +} + +function runWorker(seed: number): Promise { + return new Promise((resolve, reject) => { + const worker = new Worker(new URL(import.meta.url), { workerData: seed }); + let sum = -1; + worker.on("message", (value: number) => { + sum = value; + }); + worker.on("error", reject); + worker.on("exit", () => resolve(sum)); + }); +} + +async function main(): Promise { + for (let wave = 0; wave < 3; wave++) { + const first = runWorker(wave * 2); + const second = runWorker(wave * 2 + 1); + console.log(`wave ${wave}: ${await first} ${await second}`); + } + // The workers' memory goes back shortly after the last one exits. + await new Promise((resolve) => setTimeout(resolve, 300)); + console.log("main", build(99, 4, 1000)); +} + +if (isMainThread) { + void main(); +} else { + parentPort!.postMessage(build(workerData as number, 50, 4000)); +} diff --git a/tests/harness/corpus-costs/4636-contract-program-lifetime-references.ts.json b/tests/harness/corpus-costs/4636-contract-program-lifetime-references.ts.json new file mode 100644 index 000000000..93afb36c0 --- /dev/null +++ b/tests/harness/corpus-costs/4636-contract-program-lifetime-references.ts.json @@ -0,0 +1 @@ +{ "plain": 4300, "san": 7900 } diff --git a/tests/harness/corpus-costs/4637-contract-program-lifetime-workers.ts.json b/tests/harness/corpus-costs/4637-contract-program-lifetime-workers.ts.json new file mode 100644 index 000000000..35b1a9df3 --- /dev/null +++ b/tests/harness/corpus-costs/4637-contract-program-lifetime-workers.ts.json @@ -0,0 +1 @@ +{ "plain": 2400, "san": 4000 } diff --git a/tests/harness/program-lifetime-workers.test.ts b/tests/harness/program-lifetime-workers.test.ts new file mode 100644 index 000000000..8172fbcde --- /dev/null +++ b/tests/harness/program-lifetime-workers.test.ts @@ -0,0 +1,48 @@ +/* ProgramLifetime instances that a worker creates are never freed while it + * runs, but on Linux they go back with the rest of its memory when it exits + * without sharing anything. The corpus program pins Node.js parity; this + * suite runs it with the allocator's statistics (SCR_SA_STATS=1) and checks + * that each discarded worker returned its program-lifetime objects. Under + * SCRIPTC_SAN=1 the runtime keeps every worker's memory, so the check does + * not apply. */ +import { execFile } from "node:child_process"; +import { mkdtemp, rm } from "node:fs/promises"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { promisify } from "node:util"; +import { expect, test } from "vitest"; +import { compile } from "@scriptc/compiler"; + +const exec = promisify(execFile); +const program = join(import.meta.dirname, "../corpus/4637-contract-program-lifetime-workers.ts"); +const sanitize = process.env["SCRIPTC_SAN"] === "1"; + +test.skipIf(process.platform !== "linux" || sanitize)( + "workers that exit without sharing return their ProgramLifetime instances", + { timeout: 240_000 }, + async () => { + const outDir = await mkdtemp(join(tmpdir(), "scriptc-program-lifetime-workers-")); + try { + const result = await compile(program, { + backend: "llvm", + outDir, + outPath: join(outDir, "program"), + }); + expect(result.ok, JSON.stringify(result.diagnostics)).toBe(true); + if (!result.ok) return; + const { stdout, stderr } = await exec(result.binaryPath, [], { + env: { ...process.env, SCR_SA_STATS: "1", SCR_SA_DISCARD_DELAY_MS: "0" }, + timeout: 120_000, + }); + expect(stdout).toContain("wave 2: "); + // One line per discarded worker; each built 200,000 items in 50 groups. + const returned = [...stderr.matchAll(/(\d+) MB of program-lifetime objects/g)].map((m) => + Number(m[1]), + ); + expect(returned.length).toBeGreaterThan(0); + for (const mb of returned) expect(mb).toBeGreaterThanOrEqual(4); + } finally { + await rm(outDir, { recursive: true, force: true }); + } + }, +); From 5bdc3be385c8c6e222a229ce9735ab372f8842cf Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Wed, 21 Oct 2026 23:25:48 -0500 Subject: [PATCH 006/102] Name function expressions by their source names in SC6101 and skip type names and generated helpers --- docs/content/docs/coverage.mdx | 2 +- .../src/frontend/lowering/dynamic-tier.ts | 57 ++++++++++++++++--- .../dynamic-tier/function-names.js | 32 +++++++++++ .../dynamic-tier/typed-hot.ts | 22 ++++++- .../coverage-fixtures/dynamic-tier/unnamed.ts | 41 +++++++++++++ tests/harness/coverage.test.ts | 24 +++++++- 6 files changed, 162 insertions(+), 16 deletions(-) create mode 100644 tests/coverage-fixtures/dynamic-tier/function-names.js create mode 100644 tests/coverage-fixtures/dynamic-tier/unnamed.ts diff --git a/docs/content/docs/coverage.mdx b/docs/content/docs/coverage.mdx index d2fc345ad..ae36f736d 100644 --- a/docs/content/docs/coverage.mdx +++ b/docs/content/docs/coverage.mdx @@ -79,7 +79,7 @@ The program compiled. Adding types to these functions lets scriptc compile them Without a profile, a dynamic-tier function counts as likely to run often when a dynamic operation runs on every iteration of one of its loops (a `for` loop's initializer and a `for...of` loop's iterable run once), when a loop calls it, or when it calls itself. A function is named only when its source says why its values are untyped: a value typed `any` (for a `for...of` variable, the value it iterates), an untyped `JSON.parse` result, or an untyped JavaScript file. Dynamic code that runs once, such as setup code that reads an `any` configuration, is not reported, and neither are functions that are dynamic for an operation with no static lowering, which more types would not change. -The warning names at most five functions, most likely to run often first, and gives the total. Dynamic-tier code in npm packages is summarized on one line with each package's function count. A build that comes from the cache repeats the warning. `--no-dynamic-tier-warning` leaves it out, and `--fail-on=dynamic` fails a coverage run on it. +The warning names at most five functions, most likely to run often first, and gives the total. A function expression is named by its own name, else by the variable, property or class field it is assigned to, else as `anonymous function`. Dynamic-tier code in npm packages is summarized on one line with each package's function count. A build that comes from the cache repeats the warning. `--no-dynamic-tier-warning` leaves it out, and `--fail-on=dynamic` fails a coverage run on it. ## Diagnostic codes diff --git a/packages/compiler/src/frontend/lowering/dynamic-tier.ts b/packages/compiler/src/frontend/lowering/dynamic-tier.ts index 72cba9942..0293f9ab7 100644 --- a/packages/compiler/src/frontend/lowering/dynamic-tier.ts +++ b/packages/compiler/src/frontend/lowering/dynamic-tier.ts @@ -172,10 +172,20 @@ function isJsonParse(node: ts.Node | undefined): boolean { ); } +/** Bindings that hold a value: variables, parameters and properties (not + * types, classes or functions, whose names an operand may also mention). */ +const VALUE_BINDING = + ts.SymbolFlags.FunctionScopedVariable | + ts.SymbolFlags.BlockScopedVariable | + ts.SymbolFlags.Property; + /** Why an identifier holds a value without a static type, or null. */ function identifierCause(lowerer: Lowerer, id: ts.Identifier, depth = 0): UntypedCause | null { - const symbol = lowerer.checker.getSymbolAtLocation(id); - const decl = symbol?.declarations?.[0]; + let symbol = lowerer.checker.getSymbolAtLocation(id); + if (symbol !== undefined && (symbol.flags & ts.SymbolFlags.Alias) !== 0) + symbol = lowerer.checker.getAliasedSymbol(symbol); + if (symbol === undefined || (symbol.flags & VALUE_BINDING) === 0) return null; + const decl = symbol.declarations?.[0]; // An unannotated `for (const item of items)` variable: name `items`. if ( depth < 4 && @@ -241,6 +251,9 @@ function causeOf(lowerer: Lowerer, sites: readonly { loc: SrcLoc }[]): UntypedCa return null; } +/** Generated functions (see scanDynamicTier), after any module prefix. */ +const GENERATED = /^%*(?:m\d+\.)?%*(?:dyn|caught|init)\./; + /** The likely-hot dynamic-tier functions of `module` (see the header). */ export function scanDynamicTier(lowerer: Lowerer, module: IrModule): DynamicTierReport { const facts = new Map(); @@ -255,9 +268,9 @@ export function scanDynamicTier(lowerer: Lowerer, module: IrModule): DynamicTier const packages = new Map(); for (const fn of module.functions) { // Generated `%dyn.*` helpers are dynamic operations lowered out of line, - // and `%init.*` is a module's top level: neither is a function to name. - if (fn.tier !== "dynamic" || fn.name.startsWith("%dyn.") || fn.name.startsWith("%init.")) - continue; + // `%caught.*` helpers test caught values, and `%init.*` is a module's top + // level: none is a function to name. + if (fn.tier !== "dynamic" || GENERATED.test(fn.name)) continue; if (isNodeModulesPath(fn.loc.file)) { const name = packageOf(fn.loc.file); packages.set(name, (packages.get(name) ?? 0) + 1); @@ -300,9 +313,35 @@ export function scanDynamicTier(lowerer: Lowerer, module: IrModule): DynamicTier }; } -/** `%%m144.Session.finish` → `Session.finish`, `m163.find` → `find`. */ -function displayName(name: string): string { - return name.replace(/^%+/, "").replace(/^m\d+\./, ""); +/** The name the source binds a function expression to (`totals` in + * `const totals = (rows) => ...`), or null. */ +function boundName(lowerer: Lowerer, loc: SrcLoc): string | null { + const sf = lowerer.program.getSourceFile(loc.file); + if (sf === undefined) return null; + const parent = nodeAt(sf, loc.start, loc.end).parent; + if ( + parent !== undefined && + (ts.isVariableDeclaration(parent) || + ts.isPropertyAssignment(parent) || + ts.isPropertyDeclaration(parent)) && + ts.isIdentifier(parent.name) + ) + return parent.name.text; + return null; +} + +/** A function's name as the source spells it, without a module prefix + * (`%%m144.Session.finish` → `Session.finish`, `m163.find` → `find`). A + * function expression (`%fn`) takes its own name, else the name it is + * bound to, else `anonymous function`. */ +function displayName(lowerer: Lowerer, f: HotDynamicFunction): string { + const plain = f.name + .replace(/^%+/, "") + .replace(/^m\d+\./, "") + .replace(/^%+/, ""); + const lambda = /^fn\d+(?:_(.+))?$/.exec(plain); + if (lambda === null) return plain; + return lambda[1] ?? boundName(lowerer, f.loc) ?? "anonymous function"; } /** SC6101 for the program lowering produced, or null (see the header). @@ -322,7 +361,7 @@ export function dynamicTierWarning( }; return dynamicTierDiag( report.hot.map((f) => ({ - name: displayName(f.name), + name: displayName(lowerer, f), where: where(f.loc), cause: f.cause, hot: f.hot, diff --git a/tests/coverage-fixtures/dynamic-tier/function-names.js b/tests/coverage-fixtures/dynamic-tier/function-names.js new file mode 100644 index 000000000..3d6ab6807 --- /dev/null +++ b/tests/coverage-fixtures/dynamic-tier/function-names.js @@ -0,0 +1,32 @@ +// Function expressions in an untyped JavaScript file: SC6101 names each one +// by its own name, else by the class field, property or variable it is +// assigned to, else as an anonymous function. +class Totals { + sum = (rows) => { + let s = 0; + for (let i = 0; i < rows.length; i++) s += rows[i].n; + return s; + }; +} + +const ops = { + count: (rows) => { + let c = 0; + for (let i = 0; i < rows.length; i++) if (rows[i].n > 1) c++; + return c; + }, +}; + +const named = function scale(rows) { + let s = 0; + for (let i = 0; i < rows.length; i++) s += rows[i].n * 2; + return s; +}; + +const rows = [{ n: 1 }, { n: 2 }]; +const results = [rows].map((list) => { + let s = 0; + for (let i = 0; i < list.length; i++) s += list[i].n; + return s; +}); +console.log(new Totals().sum(rows), ops.count(rows), named(rows), results[0]); diff --git a/tests/coverage-fixtures/dynamic-tier/typed-hot.ts b/tests/coverage-fixtures/dynamic-tier/typed-hot.ts index e72a7ca7a..804170238 100644 --- a/tests/coverage-fixtures/dynamic-tier/typed-hot.ts +++ b/tests/coverage-fixtures/dynamic-tier/typed-hot.ts @@ -1,5 +1,7 @@ -// TypeScript functions that loop over untyped values: an `any` parameter -// and an untyped JSON.parse result (SC6101 names both). +// TypeScript functions that loop over untyped values: an `any` parameter, +// an untyped JSON.parse result and an arrow function's `any` rows (SC6101 +// names all three, the arrow by the name it is bound to). A cast to an +// alias of `any` blames the untyped value it produces, not the alias. function regionTotals(items: any): Map { const out = new Map(); for (const item of items) out.set(item.region, (out.get(item.region) ?? 0) + item.amount); @@ -13,9 +15,23 @@ function countRegions(text: string): number { return n; } +const weights = (rows: any): number => { + let sum = 0; + for (let i = 0; i < rows.length; i++) sum += rows[i].amount; + return sum; +}; + +type Loose = any; + +function entryCount(value: unknown): number { + let n = 0; + for (const key of value as Loose) if (key !== "") n++; + return n; +} + const rows = [ { amount: 3, region: "eu" }, { amount: 4, region: "us" }, ]; for (const [region, total] of regionTotals(rows)) console.log(region, total); -console.log(countRegions(JSON.stringify(rows))); +console.log(countRegions(JSON.stringify(rows)), weights(rows), entryCount(["a", ""])); diff --git a/tests/coverage-fixtures/dynamic-tier/unnamed.ts b/tests/coverage-fixtures/dynamic-tier/unnamed.ts new file mode 100644 index 000000000..bdc53d81f --- /dev/null +++ b/tests/coverage-fixtures/dynamic-tier/unnamed.ts @@ -0,0 +1,41 @@ +// Dynamic loops that SC6101 does not name. `readEntries` loops over +// `unknown` values: the type name `Record` in its cast is not an untyped +// value. `readAll` catches into `Error` while a subclass of `Error` crosses +// into an `any` value, so its catch clause calls a generated check helper, +// which is not a source function. +function parse(text: string): Record | null { + const value: unknown = JSON.parse(text); + return value !== null && typeof value === "object" ? (value as Record) : null; +} + +function readEntries(text: string): Map { + const out = new Map(); + const entries = parse(text)?.["entries"]; + if (entries === null || typeof entries !== "object") return out; + for (const [name, raw] of Object.entries(entries as Record)) { + if (raw === null || typeof raw !== "object") continue; + const e = raw as { dir?: unknown; label?: unknown }; + if (typeof e.dir !== "string") continue; + out.set(name, typeof e.label === "string" ? `${e.dir}:${e.label}` : e.dir); + } + return out; +} + +class ReadError extends Error {} + +function readAll(texts: string[]): string[] { + const out: string[] = []; + for (const text of texts) { + try { + if (text === "") throw new ReadError("empty"); + out.push(text); + } catch (e) { + out.push(`cannot read: ${(e as Error).message}`); + } + } + return out; +} + +const box: any = { error: new ReadError("boxed") }; +console.log(readEntries('{"entries": {"a": {"dir": "x", "label": "y"}}}').size); +console.log(readAll(["one", ""]).join(", "), box.error.message); diff --git a/tests/harness/coverage.test.ts b/tests/harness/coverage.test.ts index ca62352b1..57ac7187c 100644 --- a/tests/harness/coverage.test.ts +++ b/tests/harness/coverage.test.ts @@ -133,9 +133,11 @@ test("likely-hot functions with untyped values report as a performance warning", test("the performance warning names the untyped value of each function", () => { const { coverage } = analyze(fixture("dynamic-tier/typed-hot.ts")); expect(coverage.performance?.[0]?.message.split("\n")).toEqual([ - "2 functions that likely run often use untyped values, which runs slower than typed code:", - " regionTotals (typed-hot.ts:3): `items` is `any`, in a loop", - " countRegions (typed-hot.ts:9): `parsed` holds an untyped `JSON.parse` result, in a loop", + "4 functions that likely run often use untyped values, which runs slower than typed code:", + " regionTotals (typed-hot.ts:5): `items` is `any`, in a loop", + " entryCount (typed-hot.ts:26): `key` is `any`, in a loop", + " countRegions (typed-hot.ts:11): `parsed` holds an untyped `JSON.parse` result, in a loop", + " weights (typed-hot.ts:18): `rows` is `any`, in a loop", ]); }); @@ -146,6 +148,22 @@ test("untyped setup code that runs once reports no performance warning", () => { expect(coveragePasses(coverage, "dynamic")).toBe(true); }); +test("the performance warning names function expressions as the source does", () => { + const { coverage } = analyze(fixture("dynamic-tier/function-names.js")); + expect(coverage.performance?.[0]?.message.split("\n").slice(1)).toEqual([ + " sum (function-names.js:5): untyped JavaScript file, in a loop", + " count (function-names.js:13): untyped JavaScript file, in a loop", + " scale (function-names.js:20): untyped JavaScript file, in a loop", + " anonymous function (function-names.js:27): untyped JavaScript file, in a loop", + ]); +}); + +test("the performance warning names neither type names nor generated helpers", () => { + const { coverage } = analyze(fixture("dynamic-tier/unnamed.ts")); + expect(coverage.diagnostics).toEqual([]); + expect(coverage.performance).toBeUndefined(); +}); + test("dynamic-tier code in npm packages is summarized by package", () => { const { coverage } = analyze(fixture("dynamic-tier/package/main.ts")); expect(coverage.performance?.[0]?.message.split("\n")).toEqual([ From 61f1329b323cefdb7849ea17c7a2292849c2f6e7 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Wed, 21 Oct 2026 23:26:29 -0500 Subject: [PATCH 007/102] Name lowered helpers and closures independently of lowering order Lowering named helpers by the size of their registry at first use (%union.retag.N, %arr.map.N, ...), lifted closures and optional-chain locals by compiler-wide counters (%fnN, chain.N), generic instances by their instance count, and records and unions by creation order (rN, uN). Class expressions, mixin instances, function-local generics, non-exported namespace segments and some module globals carried the byte offset of their declaration. A name therefore depended on which unit lowered first and on the positions of unrelated code. Helpers, instances, records and unions are now named by a hash of the key they are interned by (keyedHelperName), and recursive records and unions by their printed type and declaration. Closures and optional-chain ids are named by their lowering unit, their structural position and a count per key within the unit. Offset-based names use the structural position: the chain of enclosing named declarations and the node's ordinal among same-kind nodes inside the nearest one, so an edit outside that declaration leaves the name unchanged. Two different keys with the same name throw an InternalCompilerError. The module lists its records and unions by id. The generated program is unchanged apart from these names and that order, and test:lowering-order now fails on any name difference. --- package.json | 2 +- packages/compiler/src/contracts/check.ts | 3 +- .../lowering/array-indexed-mutation.ts | 3 +- .../src/frontend/lowering/array-values.ts | 5 +- .../frontend/lowering/builtins/arguments.ts | 3 +- .../lowering/builtins/child-process-async.ts | 3 +- .../lowering/builtins/child-process-sync.ts | 3 +- .../lowering/builtins/disposable-stack.ts | 3 +- .../frontend/lowering/builtins/filesystem.ts | 3 +- .../src/frontend/lowering/builtins/json.ts | 3 +- .../lowering/builtins/operating-system.ts | 7 +- .../frontend/lowering/builtins/performance.ts | 5 +- .../src/frontend/lowering/builtins/process.ts | 5 +- .../frontend/lowering/builtins/promises.ts | 5 +- .../lowering/builtins/promisify-callback.ts | 3 +- .../frontend/lowering/builtins/text-codecs.ts | 3 +- .../src/frontend/lowering/builtins/timers.ts | 2 +- .../src/frontend/lowering/builtins/url.ts | 7 +- .../src/frontend/lowering/builtins/v8.ts | 3 +- .../src/frontend/lowering/call-arguments.ts | 3 +- .../src/frontend/lowering/call-signatures.ts | 7 +- .../src/frontend/lowering/class-assertions.ts | 5 +- .../src/frontend/lowering/class-unions.ts | 3 +- .../lowering/coercions/function-adapters.ts | 11 +- .../frontend/lowering/coercions/structural.ts | 15 +-- .../src/frontend/lowering/coercions/unions.ts | 15 +-- .../frontend/lowering/collection-ingestion.ts | 3 +- .../lowering/containers/array-callbacks.ts | 25 +++-- .../lowering/containers/array-concat.ts | 3 +- .../lowering/containers/array-construction.ts | 7 +- .../lowering/containers/array-methods.ts | 11 +- .../lowering/containers/array-pipelines.ts | 3 +- .../src/frontend/lowering/containers/bytes.ts | 5 +- .../lowering/containers/callback-arguments.ts | 3 +- .../containers/collection-grouping.ts | 5 +- .../lowering/containers/collection-methods.ts | 15 +-- .../lowering/containers/indexed-objects.ts | 15 +-- .../lowering/containers/iterator-helpers.ts | 7 +- .../lowering/containers/string-and-regexp.ts | 11 +- .../lowering/containers/string-replacement.ts | 3 +- .../frontend/lowering/expressions/binary.ts | 3 +- .../lowering/expressions/object-literals.ts | 7 +- .../lowering/expressions/optional-chains.ts | 10 +- .../lowering/expressions/property-access.ts | 3 +- .../lowering/expressions/relational.ts | 5 +- .../frontend/lowering/generic-functions.ts | 17 ++- .../src/frontend/lowering/intern-tables.ts | 7 +- .../frontend/lowering/iterator-adapters.ts | 17 +-- .../frontend/lowering/js-dynamic-objects.ts | 5 +- .../src/frontend/lowering/json-require.ts | 3 +- .../src/frontend/lowering/lifetime-regions.ts | 3 +- .../src/frontend/lowering/lower-assert.ts | 11 +- .../src/frontend/lowering/lower-calls.ts | 49 +++++---- .../src/frontend/lowering/lower-classes.ts | 9 +- .../src/frontend/lowering/lower-dgram.ts | 5 +- .../frontend/lowering/lower-event-emitter.ts | 13 ++- .../src/frontend/lowering/lower-exprs.ts | 9 +- .../src/frontend/lowering/lower-functions.ts | 2 +- .../src/frontend/lowering/lower-inspect.ts | 7 +- .../src/frontend/lowering/lower-mixins.ts | 3 +- .../src/frontend/lowering/lower-mock.ts | 3 +- .../frontend/lowering/lower-modules.test.ts | 4 +- .../src/frontend/lowering/lower-modules.ts | 15 ++- .../src/frontend/lowering/lower-namespaces.ts | 11 +- .../src/frontend/lowering/lower-server.ts | 13 ++- .../src/frontend/lowering/lower-stdlib.ts | 2 +- .../src/frontend/lowering/lower-stream.ts | 15 +-- .../src/frontend/lowering/lower-timers.ts | 7 +- .../src/frontend/lowering/lowerer.test.ts | 30 +++-- .../compiler/src/frontend/lowering/lowerer.ts | 100 ++++++++++++++--- .../src/frontend/lowering/native-ffi.ts | 2 +- .../lowering/object-enumeration-receiver.ts | 3 +- .../src/frontend/lowering/pairs-snapshot.ts | 3 +- .../lowering/promise-executor-adapter.ts | 3 +- .../lowering/require-initialization.ts | 3 +- .../src/frontend/lowering/stable-names.ts | 48 ++++++++ .../src/frontend/lowering/strict-equality.ts | 3 +- .../frontend/lowering/structural-positions.ts | 103 ++++++++++++++++++ packages/compiler/src/frontend/ts7/ast.ts | 90 ++++++++++++++- .../compiler/src/frontend/type-mapper.test.ts | 2 +- packages/compiler/src/frontend/type-mapper.ts | 46 ++++++-- .../test/array-pipeline-fusion.test.ts | 2 +- .../test/format-float-arguments.test.ts | 2 +- .../test/in-runtime-key-emission.test.ts | 2 +- .../compiler/test/type-mapper-unions.test.ts | 3 +- 85 files changed, 693 insertions(+), 256 deletions(-) create mode 100644 packages/compiler/src/frontend/lowering/stable-names.ts create mode 100644 packages/compiler/src/frontend/lowering/structural-positions.ts diff --git a/package.json b/package.json index 5cc30d9f8..d1a8e34ae 100644 --- a/package.json +++ b/package.json @@ -20,7 +20,7 @@ "test:test262": "tsx tests/test262/run.ts", "test:test262:fetch": "node tests/test262/fetch.mjs", "test:cache-identity": "node tests/harness/cache-identity.mjs", - "test:lowering-order": "node scripts/lowering-order.mjs --fail-on content", + "test:lowering-order": "node scripts/lowering-order.mjs --fail-on names", "test:sandbox": "node scripts/sandbox-test.mjs", "test:sandbox:image": "node scripts/sandbox-image.mjs", "test:watch": "vitest", diff --git a/packages/compiler/src/contracts/check.ts b/packages/compiler/src/contracts/check.ts index 5934624bf..c80468961 100644 --- a/packages/compiler/src/contracts/check.ts +++ b/packages/compiler/src/contracts/check.ts @@ -174,7 +174,8 @@ class ContractChecker { return `${owner}.${method[2]}`; } if (fn?.sourceName !== undefined && fn.sourceName !== "") return fn.sourceName; - if (fn !== undefined && /^%fn\d+$/.test(fnName)) return `the function at ${this.where(fn.loc)}`; + if (fn !== undefined && /^%fn\.[0-9a-f]{12}$/.test(fnName)) + return `the function at ${this.where(fn.loc)}`; return fnName.replace(/^%/, ""); } diff --git a/packages/compiler/src/frontend/lowering/array-indexed-mutation.ts b/packages/compiler/src/frontend/lowering/array-indexed-mutation.ts index 6d539212e..0ded460da 100644 --- a/packages/compiler/src/frontend/lowering/array-indexed-mutation.ts +++ b/packages/compiler/src/frontend/lowering/array-indexed-mutation.ts @@ -9,6 +9,7 @@ import { type SrcLoc, typeEquals, } from "../../ir/ir.js"; +import { keyedHelperName } from "./stable-names.js"; import { numLit, varRef } from "../../ir/build.js"; import { typeKey } from "../type-mapper.js"; import type { Lowerer } from "./lowerer.js"; @@ -125,7 +126,7 @@ export function lowerArrayFill( writeNull; let name = lowerer.arrHofHelpers.get(key); if (!name) { - name = "%arr.fill." + lowerer.arrHofHelpers.size; + name = keyedHelperName(lowerer, "%arr.fill", key); lowerer.arrHofHelpers.set(key, name); const a = varRef("a.0", arrType, loc); const n = varRef("n.0", F64, loc); diff --git a/packages/compiler/src/frontend/lowering/array-values.ts b/packages/compiler/src/frontend/lowering/array-values.ts index 0ca8503df..314cdfd24 100644 --- a/packages/compiler/src/frontend/lowering/array-values.ts +++ b/packages/compiler/src/frontend/lowering/array-values.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { InternalCompilerError } from "../../errors.js"; import { dynUndefinedExpr, helperLoc, varRef } from "../../ir/build.js"; import { @@ -252,7 +253,7 @@ export function lowerSafeIndexRead( let name = lowerer.arrHofHelpers.get(key); if (!name) { const at = helperLoc(loc); - name = `%arr.idxOr.${lowerer.arrHofHelpers.size}`; + name = keyedHelperName(lowerer, "%arr.idxOr", key); lowerer.arrHofHelpers.set(key, name); const arrT = arr.type; lowerer.liftedFns.push({ @@ -298,7 +299,7 @@ export function lowerSafeBytesRead( let name = lowerer.arrHofHelpers.get(key); if (!name) { const at = helperLoc(loc); - name = `%bytes.idxOr.${lowerer.arrHofHelpers.size}`; + name = keyedHelperName(lowerer, "%bytes.idxOr", key); lowerer.arrHofHelpers.set(key, name); const b = varRef("b.0", bytesT, at); const i = varRef("i.0", F64, at); diff --git a/packages/compiler/src/frontend/lowering/builtins/arguments.ts b/packages/compiler/src/frontend/lowering/builtins/arguments.ts index 7f862f603..d2fc430dd 100644 --- a/packages/compiler/src/frontend/lowering/builtins/arguments.ts +++ b/packages/compiler/src/frontend/lowering/builtins/arguments.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { BYTES_U8, BOOL, @@ -72,7 +73,7 @@ export function lowerOptionalNumberPredicate( const key = `number.optionalPredicate:${fn}:${typeKey(widened)}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%number.optionalPredicate.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%number.optionalPredicate", key); lowerer.valueHelpers.set(key, helper); const input = varRef("value.0", widened, loc); lowerer.liftedFns.push({ diff --git a/packages/compiler/src/frontend/lowering/builtins/child-process-async.ts b/packages/compiler/src/frontend/lowering/builtins/child-process-async.ts index 5590fbe9f..d0991dce5 100644 --- a/packages/compiler/src/frontend/lowering/builtins/child-process-async.ts +++ b/packages/compiler/src/frontend/lowering/builtins/child-process-async.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { recordToEnvPairs } from "./environment.js"; import { lowerChildArgsArg } from "./child-process.js"; import { boolLit, numLit, varRef } from "../../../ir/build.js"; @@ -218,7 +219,7 @@ function execFileAsyncHelper( const key = shell ? "execAsync" : "execFileAsync"; const existing = lowerer.valueHelpers.get(key); if (existing) return { name: existing, shapeId, envShapeId }; - const name = `%${key}.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, `%${key}`, key); lowerer.valueHelpers.set(key, name); const recT: IrType = { kind: "record", shapeId }; const envRecT: IrType = { kind: "record", shapeId: envShapeId }; diff --git a/packages/compiler/src/frontend/lowering/builtins/child-process-sync.ts b/packages/compiler/src/frontend/lowering/builtins/child-process-sync.ts index 24adcc1ba..b9858e768 100644 --- a/packages/compiler/src/frontend/lowering/builtins/child-process-sync.ts +++ b/packages/compiler/src/frontend/lowering/builtins/child-process-sync.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { recordToEnvPairs } from "./environment.js"; import { lowerChildArgsArg } from "./child-process.js"; import { boolLit, numLit, strLit, varRef } from "../../../ir/build.js"; @@ -541,7 +542,7 @@ function execStdioModeHelper( const key = `cp.stdiomode:${shapeId}:${fd}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = `%cp.stdioMode.${fd}.${lowerer.arrHofHelpers.size}`; + const name = keyedHelperName(lowerer, `%cp.stdioMode.${fd}`, key); lowerer.arrHofHelpers.set(key, name); const optsT: IrType = { kind: "record", shapeId }; diff --git a/packages/compiler/src/frontend/lowering/builtins/disposable-stack.ts b/packages/compiler/src/frontend/lowering/builtins/disposable-stack.ts index 1b9a9c03a..375c3f1e7 100644 --- a/packages/compiler/src/frontend/lowering/builtins/disposable-stack.ts +++ b/packages/compiler/src/frontend/lowering/builtins/disposable-stack.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import * as ts from "../../ts7/adapter.js"; import { type Lowerer } from "../lowerer.js"; import { locOf } from "../../program.js"; @@ -84,7 +85,7 @@ export function lowerDisposableStackUseCall( const key = `disposableStack.use:${className}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%disposableStack.use.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%disposableStack.use", key); lowerer.valueHelpers.set(key, helper); const context = newFnCtx(false, null, null, VOID); lowerer.fnStack.push(context); diff --git a/packages/compiler/src/frontend/lowering/builtins/filesystem.ts b/packages/compiler/src/frontend/lowering/builtins/filesystem.ts index 0e1c062c5..6b988c491 100644 --- a/packages/compiler/src/frontend/lowering/builtins/filesystem.ts +++ b/packages/compiler/src/frontend/lowering/builtins/filesystem.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { dynUndefinedExpr, boolLit, numLit, varRef } from "../../../ir/build.js"; import * as ts from "../../ts7/adapter.js"; import { type Lowerer, ladderFenceExpr } from "../lowerer.js"; @@ -442,7 +443,7 @@ export function lowerStringOrBytesWrite( const key = `fs.${append ? "append" : "write"}:${dataType.unionId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%fs.writeData.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%fs.writeData", key); lowerer.valueHelpers.set(key, helper); const body: IrStmt[] = []; for (let tag = 0; tag < arms.length; tag++) { diff --git a/packages/compiler/src/frontend/lowering/builtins/json.ts b/packages/compiler/src/frontend/lowering/builtins/json.ts index 7eb8aa9b2..64f829865 100644 --- a/packages/compiler/src/frontend/lowering/builtins/json.ts +++ b/packages/compiler/src/frontend/lowering/builtins/json.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { isDateJsonSource } from "./dates.js"; import { dynUndefinedExpr, varRef } from "../../../ir/build.js"; import { InternalCompilerError } from "../../../errors.js"; @@ -253,7 +254,7 @@ function lowerOptionalStringifyRoot( const key = `json.optionalString:${value.type.unionId}:${JSON.stringify(indent)}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%json.optionalString.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%json.optionalString", key); lowerer.valueHelpers.set(key, helper); const input = varRef("value.0", value.type, loc); const serialized: IrExpr = { diff --git a/packages/compiler/src/frontend/lowering/builtins/operating-system.ts b/packages/compiler/src/frontend/lowering/builtins/operating-system.ts index c10465039..ee189a1f3 100644 --- a/packages/compiler/src/frontend/lowering/builtins/operating-system.ts +++ b/packages/compiler/src/frontend/lowering/builtins/operating-system.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { numLit, strLit, varRef } from "../../../ir/build.js"; import * as ts from "../../ts7/adapter.js"; import { type Lowerer } from "../lowerer.js"; @@ -219,7 +220,7 @@ export function lowerOsCpusCall(lowerer: Lowerer, call: ts.CallExpression, loc: const key = `os.cpus:${typeKey(result)}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%os.cpus.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%os.cpus", key); lowerer.valueHelpers.set(key, helper); const index = varRef("i.0", F64, loc); const field = (k: number): IrExpr => ({ @@ -346,7 +347,7 @@ export function lowerPathParseCall( const key = `${fn}:${typeKey(result)}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%path.parse.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%path.parse", key); lowerer.valueHelpers.set(key, helper); const parts = varRef("parts.0", arrayOf(STRING), loc); lowerer.liftedFns.push({ @@ -448,7 +449,7 @@ export function lowerPathFormatCall( const key = `${fn}:${typeKey(recordT)}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%path.format.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%path.format", key); lowerer.valueHelpers.set(key, helper); const object = varRef("object.0", recordT, loc); const read = (name: string): IrExpr => { diff --git a/packages/compiler/src/frontend/lowering/builtins/performance.ts b/packages/compiler/src/frontend/lowering/builtins/performance.ts index 72304e6a9..bae525c17 100644 --- a/packages/compiler/src/frontend/lowering/builtins/performance.ts +++ b/packages/compiler/src/frontend/lowering/builtins/performance.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import * as ts from "../../ts7/adapter.js"; import { type Lowerer } from "../lowerer.js"; import { locOf } from "../../program.js"; @@ -330,7 +331,7 @@ function lowerPerfTimelineCall( const key = `perf.${many ? "entries" : timeline.fn}:${typeKey(result)}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%perf.${many ? "entries" : member}.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, `%perf.${many ? "entries" : member}`, key); lowerer.valueHelpers.set(key, helper); const argsRef = varRef("a.0", DYN, loc); const whichRef = varRef("w.0", F64, loc); @@ -461,7 +462,7 @@ export function perfEntryTag( const key = `perf.tag:${entryT.shapeId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%perf.tag.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%perf.tag", key); lowerer.valueHelpers.set(key, helper); const e = varRef("e.0", entryT, loc); lowerer.liftedFns.push({ diff --git a/packages/compiler/src/frontend/lowering/builtins/process.ts b/packages/compiler/src/frontend/lowering/builtins/process.ts index 25653f541..842f42b57 100644 --- a/packages/compiler/src/frontend/lowering/builtins/process.ts +++ b/packages/compiler/src/frontend/lowering/builtins/process.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { stdinKeypressListener } from "./readline.js"; import { envSnapshotHelper, lowerProcessLoadEnvFile } from "./environment.js"; import { dynUndefinedExpr, boolLit, numLit, strLit, varRef } from "../../../ir/build.js"; @@ -1561,7 +1562,7 @@ export function lowerProcessMethodCall( const key = `${prefix}usage.diff:${prevT.shapeId}:${t.shapeId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%${prefix}usage.diff.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, `%${prefix}usage.diff`, key); lowerer.valueHelpers.set(key, helper); const pRef: IrExpr = { kind: "varRef", localId: "p.0", type: prevT, loc }; const fieldOf = (name: string): IrExpr => ({ @@ -1636,7 +1637,7 @@ export function lowerProcessMethodCall( const key = `process.memoryUsage:${t.shapeId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%process.memoryUsage.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%process.memoryUsage", key); lowerer.valueHelpers.set(key, helper); lowerer.liftedFns.push({ name: helper, diff --git a/packages/compiler/src/frontend/lowering/builtins/promises.ts b/packages/compiler/src/frontend/lowering/builtins/promises.ts index 668ef01f8..75e527aa5 100644 --- a/packages/compiler/src/frontend/lowering/builtins/promises.ts +++ b/packages/compiler/src/frontend/lowering/builtins/promises.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { checkedPromiseAll, thenReader } from "../checked-promise-all.js"; import { InternalCompilerError } from "../../../errors.js"; import * as ts from "../../ts7/adapter.js"; @@ -55,7 +56,7 @@ function lowerTuplePromiseAll( const key = `${elems.map((e) => typeKey(e.type)).join(",")}->${typeKey(resultT.inner)}`; let name = lowerer.arrHofHelpers.get(`promise.allTuple:${key}`); if (name === undefined) { - name = `%promise.allTuple.${lowerer.arrHofHelpers.size}`; + name = keyedHelperName(lowerer, "%promise.allTuple", `promise.allTuple:${key}`); lowerer.arrHofHelpers.set(`promise.allTuple:${key}`, name); const ctx = newFnCtx(false, null, null, resultT.inner); ctx.isAsync = true; @@ -557,7 +558,7 @@ export function lowerPromiseStaticCall( const key = `promise.try:${typeKey(f.type)}:${args.map((a) => typeKey(a.type)).join(",")}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%promise.try.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%promise.try", key); lowerer.arrHofHelpers.set(key, helper); const fRef: IrExpr = { kind: "varRef", localId: "f.0", type: f.type, loc }; const argLocals = args.map((a, i) => ({ id: `a${i}.0`, name: `a${i}`, type: a.type })); diff --git a/packages/compiler/src/frontend/lowering/builtins/promisify-callback.ts b/packages/compiler/src/frontend/lowering/builtins/promisify-callback.ts index 822a4fecc..b4dbbf513 100644 --- a/packages/compiler/src/frontend/lowering/builtins/promisify-callback.ts +++ b/packages/compiler/src/frontend/lowering/builtins/promisify-callback.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import * as ts from "../../ts7/adapter.js"; import { type Lowerer } from "../lowerer.js"; import { varRef } from "../../../ir/build.js"; @@ -170,7 +171,7 @@ function promisifyMaker(lowerer: Lowerer, shape: CallbackShape, loc: SrcLoc): st const key = `promisify:${typeKey(shape.fnT)}=>${typeKey(shape.resultT)}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const base = `%promisify.${lowerer.arrHofHelpers.size}`; + const base = keyedHelperName(lowerer, "%promisify", key); lowerer.arrHofHelpers.set(key, base); const { fnT, resultT, args, callbackT, callbackParamT, inner, error } = shape; const promiseT = resultT.ret; diff --git a/packages/compiler/src/frontend/lowering/builtins/text-codecs.ts b/packages/compiler/src/frontend/lowering/builtins/text-codecs.ts index 7229d5b84..8d47c8e3a 100644 --- a/packages/compiler/src/frontend/lowering/builtins/text-codecs.ts +++ b/packages/compiler/src/frontend/lowering/builtins/text-codecs.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { isBuiltinClassInstance } from "./receiver-types.js"; import { strLit, varRef, dynUndefinedExpr } from "../../../ir/build.js"; import { staticTextDecoderEncoding } from "../text-decoder-encoding.js"; @@ -129,7 +130,7 @@ function stringDecoderHelper( const key = `strdec.${op}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%strdec.${op}.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, `%strdec.${op}`, key); lowerer.valueHelpers.set(key, name); const recT: IrType = { kind: "record", shapeId }; diff --git a/packages/compiler/src/frontend/lowering/builtins/timers.ts b/packages/compiler/src/frontend/lowering/builtins/timers.ts index 2d531663f..d7cbd63b5 100644 --- a/packages/compiler/src/frontend/lowering/builtins/timers.ts +++ b/packages/compiler/src/frontend/lowering/builtins/timers.ts @@ -85,7 +85,7 @@ export function lowerTimersPromisesSetInterval( const genT = timersPromisesIntervalType(lowerer, expr); if (genT === null) lowerer.badType(expr, lowerer.typeOf(expr)); const yielded = lowerer.coerceInto(valueNode, value, genT.yieldT); - const fnName = `%fn${lowerer.lambdaCounter++}_tpInterval`; + const fnName = lowerer.closureName(loc, "_tpInterval"); const msParam: IrLocal = { id: "%tp.ms", name: "delay", type: F64, mutable: false }; const valueParam: IrLocal = { id: "%tp.value", name: "value", type: genT.yieldT, mutable: false }; const promiseVoid: IrType = { kind: "promise", inner: VOID }; diff --git a/packages/compiler/src/frontend/lowering/builtins/url.ts b/packages/compiler/src/frontend/lowering/builtins/url.ts index dca8a7cc0..2a77fa85c 100644 --- a/packages/compiler/src/frontend/lowering/builtins/url.ts +++ b/packages/compiler/src/frontend/lowering/builtins/url.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { nodeThrowExpr, countedFor, strLit, varRef, dynUndefinedExpr } from "../../../ir/build.js"; import * as ts from "../../ts7/adapter.js"; import { type Lowerer, own } from "../lowerer.js"; @@ -292,7 +293,7 @@ function searchParamsFromTuples( const key = `sp.fromTuples:${row.shapeId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%sp.fromTuples.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%sp.fromTuples", key); lowerer.valueHelpers.set(key, helper); const pairsT = init.type; const sp = (): IrExpr => varRef("sp.0", SEARCH_PARAMS_T, loc); @@ -372,7 +373,7 @@ function lowerOptionalStringSearchParams( const key = `sp.optionalString:${init.type.unionId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%sp.optionalString.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%sp.optionalString", key); lowerer.valueHelpers.set(key, helper); const value = varRef("init.0", init.type, loc); lowerer.liftedFns.push({ @@ -678,7 +679,7 @@ function lowerSpForEachCall( const key = `${arity}:${typeKey(fnRet)}`; let helper = lowerer.spHofHelpers.get(key); if (!helper) { - helper = `%sp.forEach.${lowerer.spHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%sp.forEach", key); lowerer.spHofHelpers.set(key, helper); lowerer.liftedFns.push(buildSpForEachFn(helper, arity, fnRet, loc)); } diff --git a/packages/compiler/src/frontend/lowering/builtins/v8.ts b/packages/compiler/src/frontend/lowering/builtins/v8.ts index 3582ce8ae..989a61a3f 100644 --- a/packages/compiler/src/frontend/lowering/builtins/v8.ts +++ b/packages/compiler/src/frontend/lowering/builtins/v8.ts @@ -5,6 +5,7 @@ * spirit of process.memoryUsage(): approximate values, not V8 heap * figures (a compiled binary embeds no V8 engine). Every other member * fences at its use with the by-design reason (builtinFenceHintOf). */ +import { keyedHelperName } from "../stable-names.js"; import { numLit } from "../../../ir/build.js"; import * as ts from "../../ts7/adapter.js"; import { type Lowerer } from "../lowerer.js"; @@ -55,7 +56,7 @@ export function lowerV8HeapStatisticsCall( const key = `v8.getHeapStatistics:${t.shapeId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%v8.getHeapStatistics.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%v8.getHeapStatistics", key); lowerer.valueHelpers.set(key, helper); const sample = (index: number): IrExpr => ({ kind: "libCall", diff --git a/packages/compiler/src/frontend/lowering/call-arguments.ts b/packages/compiler/src/frontend/lowering/call-arguments.ts index 49f7c8ec0..060ffe9d2 100644 --- a/packages/compiler/src/frontend/lowering/call-arguments.ts +++ b/packages/compiler/src/frontend/lowering/call-arguments.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { forwardedTupleType, pureForwardedValues, stripTypeWrappers } from "./typed-arguments.js"; import { dynUndefinedExpr } from "../../ir/build.js"; import { InternalCompilerError } from "../../errors.js"; @@ -753,7 +754,7 @@ function holeReadingLift(lowerer: Lowerer, from: IrType, to: IrType, loc: SrcLoc const key = `arr.holes:${typeKey(elem)}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%arr.holes.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, "%arr.holes", key); lowerer.valueHelpers.set(key, name); lowerer.liftedFns.push( buildArrayConversion( diff --git a/packages/compiler/src/frontend/lowering/call-signatures.ts b/packages/compiler/src/frontend/lowering/call-signatures.ts index 34343ad27..dacb4d324 100644 --- a/packages/compiler/src/frontend/lowering/call-signatures.ts +++ b/packages/compiler/src/frontend/lowering/call-signatures.ts @@ -849,7 +849,10 @@ export function collectSignatureInner(lowerer: Lowerer, decl: ts.FunctionDeclara lowerer.genericFnsBySymbol.set(symbol, { decl, baseName: nameText, - qualifiedName: lowerer.qualify(ts.getSourceFileOfNode(decl), nsPathPrefix(decl) + nameText), + qualifiedName: lowerer.qualify( + ts.getSourceFileOfNode(decl), + nsPathPrefix(lowerer, decl) + nameText, + ), typeParams: [], instances: new Map(), implicitParams: implicit, @@ -897,7 +900,7 @@ export function collectSignatureInner(lowerer: Lowerer, decl: ts.FunctionDeclara // "%default" spelling ('%' cannot appear in a user identifier). name: lowerer.qualify( ts.getSourceFileOfNode(decl), - nsPathPrefix(decl) + (decl.name?.text ?? "%default"), + nsPathPrefix(lowerer, decl) + (decl.name?.text ?? "%default"), ), params, returnType, diff --git a/packages/compiler/src/frontend/lowering/class-assertions.ts b/packages/compiler/src/frontend/lowering/class-assertions.ts index 900c32426..52654fab8 100644 --- a/packages/compiler/src/frontend/lowering/class-assertions.ts +++ b/packages/compiler/src/frontend/lowering/class-assertions.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { nodeThrowExpr, varRef } from "../../ir/build.js"; import { BOOL, @@ -122,7 +123,7 @@ export function checkedClassAssertion( const key = `classassert:${typeKey(source.type)}:${typeKey(target)}`; let name = lowerer.coercions.retags.get(key); if (!name) { - name = `%class.assert.${lowerer.coercions.retags.size}`; + name = keyedHelperName(lowerer, "%class.assert", key); lowerer.coercions.retags.set(key, name); const input = varRef("value.0", source.type, loc); const body: IrStmt[] = []; @@ -228,7 +229,7 @@ export function checkedClassUnionAssertion( const key = `classunionassert:${typeKey(value.type)}:${typeKey(target)}`; let name = lowerer.coercions.retags.get(key); if (!name) { - name = `%class.assert.${lowerer.coercions.retags.size}`; + name = keyedHelperName(lowerer, "%class.assert", key); lowerer.coercions.retags.set(key, name); const input = varRef("value.0", value.type, loc); const locals = [{ id: "value.0", name: "value", type: value.type, mutable: false }]; diff --git a/packages/compiler/src/frontend/lowering/class-unions.ts b/packages/compiler/src/frontend/lowering/class-unions.ts index f52026ba4..0021b2cf8 100644 --- a/packages/compiler/src/frontend/lowering/class-unions.ts +++ b/packages/compiler/src/frontend/lowering/class-unions.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import * as ts from "../ts7/adapter.js"; import { BOOL, typeKey, type IrExpr, type IrStmt, type IrType } from "../../ir/ir.js"; import { nodeThrowExpr, varRef } from "../../ir/build.js"; @@ -132,7 +133,7 @@ export function narrowClassUnion( const key = `classUnion:${source.className}:${target.unionId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%class.union.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%class.union", key); lowerer.valueHelpers.set(key, helper); const input = varRef("value.0", source, loc); // Rank by ancestry before sorting: returning zero for unrelated pairs diff --git a/packages/compiler/src/frontend/lowering/coercions/function-adapters.ts b/packages/compiler/src/frontend/lowering/coercions/function-adapters.ts index ffdac19f0..fe3c14605 100644 --- a/packages/compiler/src/frontend/lowering/coercions/function-adapters.ts +++ b/packages/compiler/src/frontend/lowering/coercions/function-adapters.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { dynUndefinedExpr } from "../../../ir/build.js"; import { buildFunctionAdapter } from "./builders.js"; import { InternalCompilerError } from "../../../errors.js"; @@ -33,7 +34,7 @@ export function funcReturnWidthAdapter( const key = `fn:${typeKey(fromT.ret.elem)}:${typeKey(toT.ret.elem)}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%fn.width.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, "%fn.width", key); lowerer.valueHelpers.set(key, name); lowerer.freshClosureAdapters.add(name); // The returned closure's body: call the captured original, width-map. @@ -163,7 +164,7 @@ function restPackingAdapter( const key = `fnrestadapt:${typeKey(fromT)}:${typeKey(toT)}`; const existing = lowerer.coercions.retags.get(key); if (existing) return existing; - const name = `%fn.adapt.${lowerer.coercions.retags.size}`; + const name = keyedHelperName(lowerer, "%fn.adapt", key); lowerer.coercions.retags.set(key, name); lowerer.freshClosureAdapters.add(name); const fixed = fromT.params.length - 1; @@ -220,7 +221,7 @@ function funcIntoDynRestAdapter( const key = `fnadapt:${typeKey(fromT)}:${typeKey(toT)}`; const existing = lowerer.coercions.retags.get(key); if (existing) return existing; - const name = `%fn.adapt.${lowerer.coercions.retags.size}`; + const name = keyedHelperName(lowerer, "%fn.adapt", key); lowerer.coercions.retags.set(key, name); lowerer.freshClosureAdapters.add(name); const params: IrParam[] = [{ localId: "rest.0", name: "args", type: DYN }]; @@ -376,7 +377,7 @@ export function funcCoerceAdapter( const key = `fnadapt:${typeKey(fromT)}:${typeKey(toT)}`; const existing = lowerer.coercions.retags.get(key); if (existing) return existing; - const name = `%fn.adapt.${lowerer.coercions.retags.size}`; + const name = keyedHelperName(lowerer, "%fn.adapt", key); lowerer.coercions.retags.set(key, name); lowerer.freshClosureAdapters.add(name); const params: IrParam[] = toT.params.map((t, i) => ({ @@ -604,7 +605,7 @@ export function spawnResFnAdapter( const key = `fnspawn:${typeKey(fromT)}:${typeKey(toT)}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%fnval.spawnres.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, "%fnval.spawnres", key); lowerer.valueHelpers.set(key, name); lowerer.freshClosureAdapters.add(name); const params: IrParam[] = toT.params.map((p, i) => ({ diff --git a/packages/compiler/src/frontend/lowering/coercions/structural.ts b/packages/compiler/src/frontend/lowering/coercions/structural.ts index 496a29607..5b5e283b3 100644 --- a/packages/compiler/src/frontend/lowering/coercions/structural.ts +++ b/packages/compiler/src/frontend/lowering/coercions/structural.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { constructedValue } from "../constructor-returns.js"; import { dynUndefinedExpr, varRef } from "../../../ir/build.js"; import type { FieldLift } from "./structural-plans.js"; @@ -253,7 +254,7 @@ export function unionRecordWidthHelper( const key = `unionWidth:${fromId}:${target.shapeId}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%union.record.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, "%union.record", key); lowerer.valueHelpers.set(key, name); const type: IrType = { kind: "union", unionId: fromId }; const value = varRef("value.0", type, loc); @@ -312,7 +313,7 @@ export function recordWidthHelper( const key = `rec:${fromId}:${toId}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%rec.width.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, "%rec.width", key); // Interned BEFORE the body builds: a recursive nested-width field // (self-referential shapes) resolves to this helper itself. lowerer.valueHelpers.set(key, name); @@ -341,7 +342,7 @@ export function tupleArrayWidthHelper( const key = `tuparr:${fromId}:${typeKey(toT.elem)}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%tup.arr.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, "%tup.arr", key); lowerer.valueHelpers.set(key, name); const fromT: IrType = { kind: "record", shapeId: fromId }; const t: IrExpr = { kind: "varRef", localId: "t.0", type: fromT, loc }; @@ -388,7 +389,7 @@ export function emptyArrayLiftHelper( const key = `emptyarr:${typeKey(fromT.elem)}:${typeKey(toT.elem)}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%arr.empty.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, "%arr.empty", key); lowerer.valueHelpers.set(key, name); const a: IrExpr = { kind: "varRef", localId: "a.0", type: fromT, loc }; lowerer.liftedFns.push({ @@ -452,7 +453,7 @@ export function arrayWidthHelper( const key = `arr:${typeKey(fromElem)}:${typeKey(toElem)}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%arr.width.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, "%arr.width", key); lowerer.valueHelpers.set(key, name); const arrT: IrType = { kind: "array", elem: fromElem }; const outT: IrType = { kind: "array", elem: toElem }; @@ -492,7 +493,7 @@ export function objRecordWidthHelper( const key = `obj:${className}:${toId}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%obj.width.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, "%obj.width", key); lowerer.valueHelpers.set(key, name); const fromT: IrType = { kind: "object", className }; lowerer.liftedFns.push(buildRecordProjection(lowerer, name, fromT, to, plan, loc)); @@ -517,7 +518,7 @@ export function recordClassWidthHelper( const key = `cls:${fromId}:${className}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%cls.width.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, "%cls.width", key); lowerer.valueHelpers.set(key, name); lowerer.noteEdge(`%${className}.constructor`); const fromT: IrType = { kind: "record", shapeId: fromId }; diff --git a/packages/compiler/src/frontend/lowering/coercions/unions.ts b/packages/compiler/src/frontend/lowering/coercions/unions.ts index 06c0af9c6..434e687a5 100644 --- a/packages/compiler/src/frontend/lowering/coercions/unions.ts +++ b/packages/compiler/src/frontend/lowering/coercions/unions.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { buildUnionNarrow, unionNarrowFailureMessage } from "../union-narrow.js"; import { isSafeToRepeat } from "../expressions/evaluation-safety.js"; import { nodeThrowExpr } from "../../../ir/build.js"; @@ -147,7 +148,7 @@ export function strandedUnitTrap( const key = `strandunit:${typeKey(expected)}:${expr.type.kind}`; let name = lowerer.coercions.retags.get(key); if (!name) { - name = `%unit.strand.${lowerer.coercions.retags.size}`; + name = keyedHelperName(lowerer, "%unit.strand", key); lowerer.coercions.retags.set(key, name); lowerer.liftedFns.push({ name, @@ -227,7 +228,7 @@ export function strandedCoercionTrap( const key = `strand:${expected.unionId}:${typeKey(src)}`; let name = lowerer.coercions.retags.get(key); if (!name) { - name = `%union.strand.${lowerer.coercions.retags.size}`; + name = keyedHelperName(lowerer, "%union.strand", key); lowerer.coercions.retags.set(key, name); const toT: IrType = { kind: "union", unionId: expected.unionId }; lowerer.liftedFns.push({ @@ -275,7 +276,7 @@ export function recordUnionWrapHelper( const key = `recordWrap:${source.shapeId}:${toId}`; const existing = lowerer.coercions.retags.get(key); if (existing) return existing; - const name = `%record.wrap.${lowerer.coercions.retags.size}`; + const name = keyedHelperName(lowerer, "%record.wrap", key); lowerer.coercions.retags.set(key, name); lowerer.liftedFns.push( buildRecordUnionWrap(name, source, to, plan, loc, (lift, value, dst) => @@ -307,7 +308,7 @@ export function recordUnionRouteHelper( (from, dst) => lowerer.widthLiftPlan(from, dst), ); if (!plan) return null; - const name = `%record.route.${lowerer.coercions.retags.size}`; + const name = keyedHelperName(lowerer, "%record.route", key); lowerer.coercions.retags.set(key, name); lowerer.liftedFns.push( buildRecordUnionWrap(name, source, to, plan, loc, (lift, value, dst) => @@ -352,7 +353,7 @@ export function unionRetagHelper( }); const key = `${fromId}:${toId}:${stranded.join(".")}`; const existing = lowerer.coercions.retags.get(key); - const name = existing ?? `%union.retag.${lowerer.coercions.retags.size}`; + const name = existing ?? keyedHelperName(lowerer, "%union.retag", key); if (!existing) { lowerer.coercions.retags.set(key, name); lowerer.liftedFns.push( @@ -410,7 +411,7 @@ export function narrowedArmHelper( lowerer.coercions.checkedNarrows.add(existing); return existing; } - const name = `%union.narrow.${lowerer.coercions.narrows.size}`; + const name = keyedHelperName(lowerer, "%union.narrow", key); lowerer.coercions.narrows.set(key, name); lowerer.coercions.checkedNarrows.add(name); const fn = buildUnionNarrow(name, from, target, loc, (type) => lowerer.fmt(type)); @@ -587,7 +588,7 @@ export function deferredReadHelper( const key = `deferred:${fromId}:${tag}`; const existing = lowerer.coercions.narrows.get(key); if (existing) return existing; - const name = `%deferred.read.${lowerer.coercions.narrows.size}`; + const name = keyedHelperName(lowerer, "%deferred.read", key); lowerer.coercions.narrows.set(key, name); const dflt: IrExpr = target.kind === "bool" diff --git a/packages/compiler/src/frontend/lowering/collection-ingestion.ts b/packages/compiler/src/frontend/lowering/collection-ingestion.ts index 5d14d5492..8fe2a6bbb 100644 --- a/packages/compiler/src/frontend/lowering/collection-ingestion.ts +++ b/packages/compiler/src/frontend/lowering/collection-ingestion.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import * as ts from "../ts7/adapter.js"; import { InternalCompilerError } from "../../errors.js"; import { typeKey } from "../type-mapper.js"; @@ -197,7 +198,7 @@ export function ingestCollection( const key = `ingest:${input.collection ? typeKey(input.collection) + ":" + input.selection : "cursor:" + typeKey(input.element)}:${typeKey(destination)}:${mapper ? typeKey(mapper.type) : "copy"}`; let name = lowerer.arrHofHelpers.get(key); if (!name) { - name = `%collection.ingest.${lowerer.arrHofHelpers.size}`; + name = keyedHelperName(lowerer, "%collection.ingest", key); lowerer.arrHofHelpers.set(key, name); const context = newFnCtx(false, null, null, destination); lowerer.fnStack.push(context); diff --git a/packages/compiler/src/frontend/lowering/containers/array-callbacks.ts b/packages/compiler/src/frontend/lowering/containers/array-callbacks.ts index eb99592bb..7ca69d9ba 100644 --- a/packages/compiler/src/frontend/lowering/containers/array-callbacks.ts +++ b/packages/compiler/src/frontend/lowering/containers/array-callbacks.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { boolLit, countedFor, numLit, varRef } from "../../../ir/build.js"; import { transformStmtList } from "../../../ir/traverse.js"; import type { ScrDiagnostic } from "../../../diagnostics/diagnostic.js"; @@ -506,7 +507,7 @@ function arrayHofHelper( const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}:${typeKey(outElem)}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`; + const name = keyedHelperName(lowerer, `%arr.${method}`, key); lowerer.arrHofHelpers.set(key, name); lowerer.arrHofInfo.set(name, { method, elem, fnRet, arity, outElem, present, split: !!fastT }); const fn = buildArrayHofFn( @@ -619,7 +620,7 @@ function arrayUnionHofHelper( const key = `union:${method}:${receiverT.unionId}:${typeKey(callbackT)}:${typeKey(resultT)}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = `%arr.union.${lowerer.arrHofHelpers.size}`; + const name = keyedHelperName(lowerer, "%arr.union", key); lowerer.arrHofHelpers.set(key, name); const receiver = varRef("a.0", receiverT, loc); const callback = varRef("f.0", callbackT, loc); @@ -1204,7 +1205,7 @@ function findHelper( const key = `${method}:${typeKey(elem)}:${typeKey(resultT)}:${typeKey(fnRet)}:${arity}${site}${present ? ":present" : ""}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`; + const name = keyedHelperName(lowerer, `%arr.${method}`, key); lowerer.arrHofHelpers.set(key, name); const arrT = arrayOf(elem); const valueT = callbackValueType(lowerer, elem, present); @@ -1304,7 +1305,7 @@ function findIndexHelper( const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`; + const name = keyedHelperName(lowerer, `%arr.${method}`, key); lowerer.arrHofHelpers.set(key, name); if (!last) lowerer.arrHofInfo.set(name, { @@ -1388,7 +1389,7 @@ function someEveryHelper( const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`; + const name = keyedHelperName(lowerer, `%arr.${method}`, key); lowerer.arrHofHelpers.set(key, name); lowerer.arrHofInfo.set(name, { method, @@ -1587,7 +1588,7 @@ function flatMapHelper( const key = `flatMap:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = `%arr.flatMap.${lowerer.arrHofHelpers.size}`; + const name = keyedHelperName(lowerer, "%arr.flatMap", key); lowerer.arrHofHelpers.set(key, name); lowerer.arrHofInfo.set(name, { method: "flatMapArray", @@ -1829,7 +1830,7 @@ function reduceHelper( const key = `${method}:${typeKey(elem)}:${typeKey(accT)}:${typeKey(fnRet)}:${arity}:${hasInit ? "init" : "seed"}${site}${fastT ? ":split" : ""}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`; + const name = keyedHelperName(lowerer, `%arr.${method}`, key); lowerer.arrHofHelpers.set(key, name); if (method === "reduce") lowerer.arrHofInfo.set(name, { @@ -2121,7 +2122,7 @@ export function lowerArraySortCall( const key = `${method}:${typeKey(elem)}:${arity}${native ? ":native" : ""}${keyed ? `:keyed${order}${reads ? `:field${reads.length}` : ""}` : ""}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%arr.${method}.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, `%arr.${method}`, key); lowerer.arrHofHelpers.set(key, helper); const undefinedTag = elem.kind === "union" ? lowerer.armTag(elem.unionId, UNDEFINED_T) : -1; lowerer.liftedFns.push( @@ -2167,7 +2168,7 @@ function sortKeyReader( const cacheKey = `sortKey:${typeKey(elem)}:${sortKeysId(reads.map((read) => ({ order: 1, read })))}`; let reader = lowerer.arrHofHelpers.get(cacheKey); if (!reader) { - reader = `%arr.sortKey.${lowerer.arrHofHelpers.size}`; + reader = keyedHelperName(lowerer, "%arr.sortKey", cacheKey); lowerer.arrHofHelpers.set(cacheKey, reader); lowerer.liftedFns.push(buildSortKeyFn(reader, elem, reads, loc)); } @@ -2308,7 +2309,7 @@ function dynFlatMapHelper(lowerer: Lowerer, elemT: IrType, arity: number, loc: S const key = `dynflatmap:${typeKey(elemT)}:${arity}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = `%dyn.flatmap.${lowerer.arrHofHelpers.size}`; + const name = keyedHelperName(lowerer, "%dyn.flatmap", key); lowerer.arrHofHelpers.set(key, name); lowerer.liftedFns.push(buildDynFlatMapFn(name, elemT, arity, loc)); return name; @@ -2481,7 +2482,7 @@ function dynFilterHelper(lowerer: Lowerer, elemT: IrType, arity: number, loc: Sr const key = `dynfilter:${typeKey(elemT)}:${arity}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = `%dyn.filter.${lowerer.arrHofHelpers.size}`; + const name = keyedHelperName(lowerer, "%dyn.filter", key); lowerer.arrHofHelpers.set(key, name); lowerer.liftedFns.push(buildDynFilterFn(name, elemT, arity, loc)); return name; @@ -2676,7 +2677,7 @@ export function lowerTuplePredicateCall( const key = `tuple.${method}:${typeKey(receiver.type)}:${typeKey(fnArg.type)}:${typeKey(resultT)}:${arity}${callbackSite(fnArg)}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%tuple.${method}.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, `%tuple.${method}`, key); lowerer.arrHofHelpers.set(key, helper); const v = varRef("v.0", elem, loc); const out = varRef("out.0", resultT, loc); diff --git a/packages/compiler/src/frontend/lowering/containers/array-concat.ts b/packages/compiler/src/frontend/lowering/containers/array-concat.ts index 4f6e4ca43..b4e285ee9 100644 --- a/packages/compiler/src/frontend/lowering/containers/array-concat.ts +++ b/packages/compiler/src/frontend/lowering/containers/array-concat.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { identityPreservingWidening } from "../coercions/identity.js"; import { countedFor, numLit, varRef } from "../../../ir/build.js"; import { @@ -28,7 +29,7 @@ export function arrayConcatHelper( const key = `concat:${typeKey(elem)}:${shape.map((type) => (type ? `a:${typeKey(type)}` : "e")).join(";")}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = `%arr.concat.${lowerer.arrHofHelpers.size}`; + const name = keyedHelperName(lowerer, "%arr.concat", key); const arrT = arrayOf(elem); const params = [ { localId: "a.0", name: "a", type: arrT }, diff --git a/packages/compiler/src/frontend/lowering/containers/array-construction.ts b/packages/compiler/src/frontend/lowering/containers/array-construction.ts index 40e4d6436..1f10640c0 100644 --- a/packages/compiler/src/frontend/lowering/containers/array-construction.ts +++ b/packages/compiler/src/frontend/lowering/containers/array-construction.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { generatorDrain } from "../iterator-adapters.js"; import { identityPreservingWidening } from "../coercions/identity.js"; import { liftedFreshSpread } from "../coercions/fresh-spread.js"; @@ -256,7 +257,7 @@ function appendWidenedArrayValues( const key = `insertValues:${typeKey(sourceType.elem)}:${typeKey(elem)}`; let name = lowerer.arrHofHelpers.get(key); if (!name) { - name = `%arr.insertValues.${lowerer.arrHofHelpers.size}`; + name = keyedHelperName(lowerer, "%arr.insertValues", key); lowerer.arrHofHelpers.set(key, name); const outType = arrayOf(elem); const valueType = arrayValueType(lowerer, source.type.elem); @@ -1035,7 +1036,7 @@ export function lowerArrayFromCall( const key = `fromArray:${typeKey(arrT.elem)}:${typeKey(outElem)}:${typeKey(fnRet)}:${arity}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%arr.fromArray.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%arr.fromArray", key); lowerer.arrHofHelpers.set(key, helper); lowerer.liftedFns.push( buildArrayFromArrayFn(lowerer, helper, arrT.elem, outElem, fnRet, arity, loc), @@ -1122,7 +1123,7 @@ export function lowerArrayFromCall( const key = `fromLen:${typeKey(fnRet)}:${arity}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%arr.fromLen.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%arr.fromLen", key); lowerer.arrHofHelpers.set(key, helper); lowerer.liftedFns.push(buildArrayFromLenFn(helper, fnRet, arity, loc)); } diff --git a/packages/compiler/src/frontend/lowering/containers/array-methods.ts b/packages/compiler/src/frontend/lowering/containers/array-methods.ts index e9a130a2d..44182fbda 100644 --- a/packages/compiler/src/frontend/lowering/containers/array-methods.ts +++ b/packages/compiler/src/frontend/lowering/containers/array-methods.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { liftedFreshSpread } from "../coercions/fresh-spread.js"; import { lowerArrayIteratorValue } from "../iterator-adapters.js"; import { identityPreservingWidening } from "../coercions/identity.js"; @@ -1616,7 +1617,7 @@ function arraySearchHelper( const key = `${method}:${typeKey(elem)}:${typeKey(valueT)}:${typeKey(needleT)}:${directNeedle}:${typeKey(fromT)}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`; + const name = keyedHelperName(lowerer, `%arr.${method}`, key); lowerer.arrHofHelpers.set(key, name); const arrT = arrayOf(elem); const resultT = method === "includes" ? BOOL : F64; @@ -1972,7 +1973,7 @@ export function lowerTupleReadMethodCall( let helper = lowerer.arrHofHelpers.get(key); const resultType = method === "includes" ? BOOL : F64; if (!helper) { - helper = `%tuple.${method}.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, `%tuple.${method}`, key); lowerer.arrHofHelpers.set(key, helper); const params = [ { localId: "a.0", name: "a", type: receiver.type }, @@ -2034,7 +2035,7 @@ export function lowerTupleReadMethodCall( const key = `tuple.slice:${typeKey(receiver.type)}:${args.length}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%tuple.slice.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%tuple.slice", key); lowerer.arrHofHelpers.set(key, helper); const params = [receiver, ...args].map((arg, i) => ({ localId: i === 0 ? "a.0" : `arg.${i}`, @@ -2125,7 +2126,7 @@ export function lowerTupleReadMethodCall( const key = `tuple.${method}:${typeKey(receiver.type)}:${typeKey(fnArg.type)}:${typeKey(outElem)}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%tuple.${method}.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, `%tuple.${method}`, key); lowerer.arrHofHelpers.set(key, helper); const out = varRef("out.0", outType, loc); const result = varRef("r.0", ret, loc); @@ -2253,7 +2254,7 @@ function lowerArrayAtCall( const key = `at:${typeKey(elem)}:${typeKey(resultT)}:${typeKey(index.type)}`; let name = lowerer.arrHofHelpers.get(key); if (!name) { - name = `%arr.at.${lowerer.arrHofHelpers.size}`; + name = keyedHelperName(lowerer, "%arr.at", key); lowerer.arrHofHelpers.set(key, name); const arrT = arrayOf(elem); diff --git a/packages/compiler/src/frontend/lowering/containers/array-pipelines.ts b/packages/compiler/src/frontend/lowering/containers/array-pipelines.ts index cf45a7575..180f40435 100644 --- a/packages/compiler/src/frontend/lowering/containers/array-pipelines.ts +++ b/packages/compiler/src/frontend/lowering/containers/array-pipelines.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { boolLit, countedFor, numLit, varRef } from "../../../ir/build.js"; import { BOOL, @@ -851,7 +852,7 @@ class PipelineFusion { if (!built) return null; let name = this.helpers.get(built.key); if (!name) { - name = `%arr.fused.${this.helpers.size}`; + name = keyedHelperName(this.lowerer, "%arr.fused", built.key); this.helpers.set(built.key, name); this.added.push({ ...built.fn, name }); } diff --git a/packages/compiler/src/frontend/lowering/containers/bytes.ts b/packages/compiler/src/frontend/lowering/containers/bytes.ts index bf9821d31..4b20d7bf5 100644 --- a/packages/compiler/src/frontend/lowering/containers/bytes.ts +++ b/packages/compiler/src/frontend/lowering/containers/bytes.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { boolLit, dynUndefinedExpr, numLit, varRef } from "../../../ir/build.js"; import { BUF_NUM_METHODS } from "./buffer-numeric-methods.js"; import * as ts from "../../ts7/adapter.js"; @@ -77,7 +78,7 @@ function lowerBytesSortCall( const cacheKey = `bytes.${method}:${bytesT.elem}:${key}`; let helper = lowerer.arrHofHelpers.get(cacheKey); if (!helper) { - helper = `%bytes.${method}.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, `%bytes.${method}`, cacheKey); lowerer.arrHofHelpers.set(cacheKey, helper); lowerer.liftedFns.push( buildBytesSortFn(helper, bytesT, arity, hasComparator, copyFirst, order, loc), @@ -270,7 +271,7 @@ function bytesCallbackHelper( const key = `bytes.${method}:${bytesT.elem}:${typeKey(resultT)}:${typeKey(fnRet)}:${arity}:${hasInit ? "init" : ""}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = `%bytes.${method}.${lowerer.arrHofHelpers.size}`; + const name = keyedHelperName(lowerer, `%bytes.${method}`, key); lowerer.arrHofHelpers.set(key, name); const reduce = method === "reduce" || method === "reduceRight"; const backward = method === "reduceRight" || method === "findLast" || method === "findLastIndex"; diff --git a/packages/compiler/src/frontend/lowering/containers/callback-arguments.ts b/packages/compiler/src/frontend/lowering/containers/callback-arguments.ts index 18754f088..f39c8e86c 100644 --- a/packages/compiler/src/frontend/lowering/containers/callback-arguments.ts +++ b/packages/compiler/src/frontend/lowering/containers/callback-arguments.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import * as ts from "../../ts7/adapter.js"; import type { Lowerer } from "../lowerer.js"; import { isJsSourceFile, locOf } from "../../program.js"; @@ -285,7 +286,7 @@ export function truthyFilterCallback( const key = `filterBoolean:${typeKey(valueT)}`; let name = lowerer.arrHofHelpers.get(key); if (!name) { - name = `%arr.filterBoolean.${lowerer.arrHofHelpers.size}`; + name = keyedHelperName(lowerer, "%arr.filterBoolean", key); lowerer.arrHofHelpers.set(key, name); const value = varRef("v.0", valueT, loc); lowerer.liftedFns.push({ diff --git a/packages/compiler/src/frontend/lowering/containers/collection-grouping.ts b/packages/compiler/src/frontend/lowering/containers/collection-grouping.ts index 0bf126830..dae68d518 100644 --- a/packages/compiler/src/frontend/lowering/containers/collection-grouping.ts +++ b/packages/compiler/src/frontend/lowering/containers/collection-grouping.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { countedFor, numLit, varRef } from "../../../ir/build.js"; import * as ts from "../../ts7/adapter.js"; import type { Lowerer } from "../lowerer.js"; @@ -104,7 +105,7 @@ export function lowerGroupByStaticCall( const key = `map.groupBy:${typeKey(items.type)}:${typeKey(f.type)}`; let helper = lowerer.mapHofHelpers.get(key); if (!helper) { - helper = `%map.groupBy.${lowerer.mapHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%map.groupBy", key); lowerer.mapHofHelpers.set(key, helper); lowerer.liftedFns.push(buildGroupByFn(lowerer, helper, items.type, f.type, resultT, loc)); } @@ -141,7 +142,7 @@ export function lowerGroupByStaticCall( const key = `object.groupBy:${typeKey(items.type)}:${typeKey(f.type)}`; let helper = lowerer.mapHofHelpers.get(key); if (!helper) { - helper = `%object.groupBy.${lowerer.mapHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%object.groupBy", key); lowerer.mapHofHelpers.set(key, helper); lowerer.liftedFns.push(buildGroupByFn(lowerer, helper, items.type, f.type, resultT, loc)); } diff --git a/packages/compiler/src/frontend/lowering/containers/collection-methods.ts b/packages/compiler/src/frontend/lowering/containers/collection-methods.ts index 370974c85..d3169ec5c 100644 --- a/packages/compiler/src/frontend/lowering/containers/collection-methods.ts +++ b/packages/compiler/src/frontend/lowering/containers/collection-methods.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { nodeThrowExpr, boolLit, countedFor, numLit, strLit, varRef } from "../../../ir/build.js"; import { InternalCompilerError } from "../../../errors.js"; import * as ts from "../../ts7/adapter.js"; @@ -232,7 +233,7 @@ function lowerMapIterDrainCall( const key = `${method}:${typeKey(mapT.key)}:${typeKey(mapT.value)}`; let helper = lowerer.mapHofHelpers.get(key); if (!helper) { - helper = `%map.${method}.${lowerer.mapHofHelpers.size}`; + helper = keyedHelperName(lowerer, `%map.${method}`, key); lowerer.mapHofHelpers.set(key, helper); lowerer.liftedFns.push(buildMapIterDrainFn(helper, mapT, method, elemT, tupleT, loc)); } @@ -348,7 +349,7 @@ export function mapEntriesArray(lowerer: Lowerer, receiver: IrExpr): IrExpr { const key = `entries:${typeKey(mapT.key)}:${typeKey(mapT.value)}`; let helper = lowerer.mapHofHelpers.get(key); if (!helper) { - helper = `%map.entries.${lowerer.mapHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%map.entries", key); lowerer.mapHofHelpers.set(key, helper); lowerer.liftedFns.push( buildMapIterDrainFn(helper, mapT, "entries", tupleT, tupleT, receiver.loc), @@ -519,7 +520,7 @@ export function lowerMapForEachCall( const key = `${typeKey(mapT.key)}:${typeKey(mapT.value)}:${arity}:${typeKey(fnRet)}`; let helper = lowerer.mapHofHelpers.get(key); if (!helper) { - helper = `%map.forEach.${lowerer.mapHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%map.forEach", key); lowerer.mapHofHelpers.set(key, helper); lowerer.liftedFns.push(buildCollectionForEachFn(helper, mapT, arity, fnRet, loc)); } @@ -693,7 +694,7 @@ export function lowerSetForEachCall( const key = `${typeKey(setT.elem)}:${arity}:${typeKey(fnRet)}`; let helper = lowerer.setHofHelpers.get(key); if (!helper) { - helper = `%set.forEach.${lowerer.setHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%set.forEach", key); lowerer.setHofHelpers.set(key, helper); lowerer.liftedFns.push(buildCollectionForEachFn(helper, setT, arity, fnRet, loc)); } @@ -745,7 +746,7 @@ function lowerSetCombineCall( const key = `${name}:${typeKey(setT.elem)}:${typeKey(otherT)}`; let helper = lowerer.setHofHelpers.get(key); if (!helper) { - helper = `%set.${name}.${lowerer.setHofHelpers.size}`; + helper = keyedHelperName(lowerer, `%set.${name}`, key); lowerer.setHofHelpers.set(key, helper); lowerer.liftedFns.push(buildSetCombineFn(helper, name, setT, otherT, loc)); } @@ -1357,7 +1358,7 @@ export function mapFromSeedValue( const key = `checked-seed:${typeKey(mapT)}`; let name = lowerer.mapHofHelpers.get(key); if (!name) { - name = `%map.checkedSeed.${lowerer.mapHofHelpers.size}`; + name = keyedHelperName(lowerer, "%map.checkedSeed", key); lowerer.mapHofHelpers.set(key, name); const source = varRef("source.0", DYN, loc); const entries = varRef("entries.0", DYN, loc); @@ -1457,7 +1458,7 @@ export function mapFromSeedValue( const key = `seed:${typeKey(mapT.key)}:${typeKey(mapT.value)}:${elem.shapeId}`; let helper = lowerer.mapHofHelpers.get(key); if (!helper) { - helper = `%map.seed.${lowerer.mapHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%map.seed", key); lowerer.mapHofHelpers.set(key, helper); lowerer.liftedFns.push(buildMapSeedFn(mapT, helper, seed.type, elem, kT, vT, loc)); } diff --git a/packages/compiler/src/frontend/lowering/containers/indexed-objects.ts b/packages/compiler/src/frontend/lowering/containers/indexed-objects.ts index efc173ffc..b3faf649e 100644 --- a/packages/compiler/src/frontend/lowering/containers/indexed-objects.ts +++ b/packages/compiler/src/frontend/lowering/containers/indexed-objects.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { nullProtoRecordShape, recordNullProtoTest } from "../null-prototype.js"; import { countedFor, numLit, varRef } from "../../../ir/build.js"; import { objectEnumerationReceiver } from "../object-enumeration-receiver.js"; @@ -184,7 +185,7 @@ export function objectIterOverIndexShape( const key = `obj.${member}:ovf:${argIr.shapeId}:${typeKey(resultT)}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%obj.${member}.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, `%obj.${member}`, key); const outRef = varRef("out.0", resultT, loc); const rRef = varRef("r.0", argIr, loc); @@ -608,7 +609,7 @@ function lowerTypedObjectFromEntriesCall( const key = `obj.fromEntries:${argIr.elem.shapeId}:${resultT.shapeId}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%obj.fromEntries.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%obj.fromEntries", key); const tupleT = argIr.elem as IrType & { kind: "record" }; const tRef = varRef("t.0", tupleT, loc); @@ -712,7 +713,7 @@ function lowerFromEntriesStringRows( const key = `obj.fromEntries:strrows:${resultT.shapeId}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%obj.fromEntries.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%obj.fromEntries", key); const tRef = varRef("t.0", rowT, loc); const rowLen: IrExpr = { @@ -931,7 +932,7 @@ export function lowerRecordOvfCaptureHelper( const key = `ovf:${fromId}:${toId}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%rec.capture.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, "%rec.capture", key); lowerer.valueHelpers.set(key, name); const fromT: IrType = { kind: "record", shapeId: fromId }; const toT: IrType = { kind: "record", shapeId: toId }; @@ -1204,7 +1205,7 @@ export function lowerObjectAssignIndexShape( const key = `assign:${targetIr.shapeId}:${plan.fromId}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%obj.assign.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, "%obj.assign", key); lowerer.valueHelpers.set(key, name); const toT: IrType = { kind: "record", shapeId: targetIr.shapeId }; const fromT: IrType = { kind: "record", shapeId: plan.fromId }; @@ -1474,7 +1475,7 @@ export function lowerIndexMergeHelper( .join(","); const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%rec.merge.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, "%rec.merge", key); lowerer.valueHelpers.set(key, name); const toT: IrType = { kind: "record", shapeId: toId }; const ksT = arrayOf(STRING); @@ -1805,7 +1806,7 @@ export function lowerEnvToPairsHelper( const key = `env.pairs:${shapeId}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%env.pairs.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, "%env.pairs", key); lowerer.valueHelpers.set(key, name); const recT: IrType = { kind: "record", shapeId }; const arrT = arrayOf(STRING); diff --git a/packages/compiler/src/frontend/lowering/containers/iterator-helpers.ts b/packages/compiler/src/frontend/lowering/containers/iterator-helpers.ts index c23e6931c..48b4caabd 100644 --- a/packages/compiler/src/frontend/lowering/containers/iterator-helpers.ts +++ b/packages/compiler/src/frontend/lowering/containers/iterator-helpers.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { boolLit, numLit, varRef } from "../../../ir/build.js"; import { InternalCompilerError } from "../../../errors.js"; import * as ts from "../../ts7/adapter.js"; @@ -966,7 +967,7 @@ function lowerFusedChain( const key = `iter:${srcKey}:${stageKeys.join(",")}:${terminal}:${termArgs.map((a) => typeKey(a.type)).join(",")}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%iter.${terminal}.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, `%iter.${terminal}`, key); lowerer.arrHofHelpers.set(key, helper); lowerer.liftedFns.push( buildIterChainFn( @@ -1038,7 +1039,7 @@ function lowerHelperObject( const key = `iterHelper:${stage.kind}:${srcKey}:${typeKey(srcElem)}:${typeKey(arg.type)}:${typeKey(outT)}`; let name = lowerer.arrHofHelpers.get(key); if (!name) { - name = `%iter.${stage.kind}.${lowerer.arrHofHelpers.size}`; + name = keyedHelperName(lowerer, `%iter.${stage.kind}`, key); lowerer.arrHofHelpers.set(key, name); lowerer.liftedFns.push( buildHelperGenFn(lowerer, name, source, srcElem, stage, arg.type, outT, resultType, loc), @@ -1058,7 +1059,7 @@ function internBudgetChecker(lowerer: Lowerer, loc: SrcLoc, srcT: GenType | null const key = srcT === null ? "iter:budget" : `iter:budget:close:${typeKey(srcT)}`; let name = lowerer.arrHofHelpers.get(key); if (name !== undefined) return name; - name = srcT === null ? "%iter.budget" : `%iter.budget.close.${lowerer.arrHofHelpers.size}`; + name = srcT === null ? "%iter.budget" : keyedHelperName(lowerer, "%iter.budget.close", key); lowerer.arrHofHelpers.set(key, name); const v = (): IrExpr => ({ kind: "varRef", localId: "v.0", type: F64, loc }); diff --git a/packages/compiler/src/frontend/lowering/containers/string-and-regexp.ts b/packages/compiler/src/frontend/lowering/containers/string-and-regexp.ts index 9567ee0f6..fe4ddbc6c 100644 --- a/packages/compiler/src/frontend/lowering/containers/string-and-regexp.ts +++ b/packages/compiler/src/frontend/lowering/containers/string-and-regexp.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { matchAllRowsReadByElements } from "./match-row-uses.js"; import { boolLit, @@ -159,7 +160,7 @@ export function lowerStringSplitCall( const key = `str.split:${receiver.type.kind === "union" ? typeKey(receiver.type) : receiver.type.kind}:${typeKey(separator.type)}:${typeKey(limit.type)}:${absent}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%str.split.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%str.split", key); const values = [receiver, separator, limit]; const params = values.map((value, index) => ({ localId: `arg.${index}`, @@ -395,7 +396,7 @@ function stringIndexHelperCall( const key = `str.index:${method}:${typeKey(receiver.type)}:${typeKey(index.type)}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%str.index.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%str.index", key); lowerer.valueHelpers.set(key, helper); const rawReceiver = varRef("arg.0", receiver.type, loc); const rawIndex = varRef("arg.1", index.type, loc); @@ -673,7 +674,7 @@ export function lowerStringPaddingCall( const key = `str.pad:${method}:${values.map((value) => typeKey(value.type)).join(":")}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%str.pad.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%str.pad", key); const params = values.map((value, index) => ({ localId: `arg.${index}`, name: `arg${index}`, @@ -1309,7 +1310,7 @@ export function lowerStringMethodCall( const key = `str.positions:${entry.method}:${typeKey(needle.type)}:${typeKey(position.type)}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%str.positions.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%str.positions", key); const params = [receiver, needle, position].map((arg, index) => ({ localId: `arg.${index}`, name: `arg${index}`, @@ -1411,7 +1412,7 @@ export function lowerStringMethodCall( const key = `str.positions:${entry.method}:${args.map((arg) => typeKey(arg.type)).join(":")}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%str.positions.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%str.positions", key); const params = [receiver, ...args].map((arg, index) => ({ localId: `arg.${index}`, name: `arg${index}`, diff --git a/packages/compiler/src/frontend/lowering/containers/string-replacement.ts b/packages/compiler/src/frontend/lowering/containers/string-replacement.ts index 6856bc50b..780c77d0f 100644 --- a/packages/compiler/src/frontend/lowering/containers/string-replacement.ts +++ b/packages/compiler/src/frontend/lowering/containers/string-replacement.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import * as ts from "../../ts7/adapter.js"; import { BOOL, @@ -162,7 +163,7 @@ function lowerStringReplacementValues( const key = `str.${method}:${typeKey(replacement.type)}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%str.${method}.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, `%str.${method}`, key); lowerer.valueHelpers.set(key, helper); const subject = varRef("s.0", STRING, loc); const needle = varRef("search.0", STRING, loc); diff --git a/packages/compiler/src/frontend/lowering/expressions/binary.ts b/packages/compiler/src/frontend/lowering/expressions/binary.ts index fafbbf695..7e449f12b 100644 --- a/packages/compiler/src/frontend/lowering/expressions/binary.ts +++ b/packages/compiler/src/frontend/lowering/expressions/binary.ts @@ -1,4 +1,5 @@ /* Binary operators: arithmetic, comparisons and equality, logical and nullish pairs, and string conversion for concatenation. */ +import { keyedHelperName } from "../stable-names.js"; import * as ts from "../../ts7/adapter.js"; import { cleanFuncAdaptable } from "../coercions/function-adapters.js"; import { type Lowerer, jsFuncNameOf } from "../lowerer.js"; @@ -801,7 +802,7 @@ function nullProtoToString(lowerer: Lowerer, e: IrExpr, t: IrType & { kind: "rec const key = `nullProtoToString:${t.shapeId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%rec.tostr.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%rec.tostr", key); lowerer.valueHelpers.set(key, helper); const r = varRef("r.0", t, loc); lowerer.liftedFns.push({ diff --git a/packages/compiler/src/frontend/lowering/expressions/object-literals.ts b/packages/compiler/src/frontend/lowering/expressions/object-literals.ts index 565db0cd8..93bf43e95 100644 --- a/packages/compiler/src/frontend/lowering/expressions/object-literals.ts +++ b/packages/compiler/src/frontend/lowering/expressions/object-literals.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { dateJsonType, isDateJsonSource } from "../builtins/dates.js"; import { dynUndefinedExpr, numLit, strLit, varRef } from "../../../ir/build.js"; import { pathModuleValue } from "../lower-builtin-values.js"; @@ -406,7 +407,7 @@ export function lowerDynObjectLiteral( if (!(err instanceof PoisonError) || !pureMember) throw err; const fence = lowerer.deferToRuntimeFence(propDiagsBefore, prop, { kind: "closure", - name: () => `%fn${lowerer.lambdaCounter++}_dynfence`, + name: () => lowerer.closureName(loc, "_dynfence"), returnType: VOID, type: { kind: "func", params: [], ret: VOID }, }); @@ -461,7 +462,7 @@ export function lowerDynObjectLiteral( if (!(err instanceof PoisonError)) throw err; const fence = lowerer.deferToRuntimeFence(convDiagsBefore, prop, { kind: "closure", - name: () => `%fn${lowerer.lambdaCounter++}_dynfence`, + name: () => lowerer.closureName(loc, "_dynfence"), returnType: VOID, type: { kind: "func", params: [], ret: VOID }, }); @@ -2956,7 +2957,7 @@ function lowerDeclaredSpreadMerge( const key = `declmerge-source:${type.shapeId}:${source.shapeId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%rec.declmerge.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%rec.declmerge", key); const sourceType = source.value.type; const destination = varRef("out.0", type, loc); const receiver = varRef("source.0", sourceType, loc); diff --git a/packages/compiler/src/frontend/lowering/expressions/optional-chains.ts b/packages/compiler/src/frontend/lowering/expressions/optional-chains.ts index fbcecdc32..4b8c5692a 100644 --- a/packages/compiler/src/frontend/lowering/expressions/optional-chains.ts +++ b/packages/compiler/src/frontend/lowering/expressions/optional-chains.ts @@ -240,7 +240,7 @@ export function lowerOptionalChain( const receiver = lowerer.runtimeOptionalSourceValue(recvNode, loweredReceiver) ?? loweredReceiver; if (receiver.type.kind === "dyn") { if (dotNode === expr && ts.isCallExpression(expr)) { - const id = `chain.${lowerer.chainCounter++}`; + const id = lowerer.closureName(loc, "", "chain"); const callee: IrExpr = { kind: "chainRecv", id, type: DYN, loc }; const stmts: IrStmt[] = []; let guarded = receiver; @@ -298,7 +298,7 @@ export function lowerOptionalChain( ); } if (dotNode === expr && ts.isElementAccessExpression(expr)) { - const id = `chain.${lowerer.chainCounter++}`; + const id = lowerer.closureName(loc, "", "chain"); const reference: IrExpr = { kind: "chainRecv", id, type: DYN, loc }; lowerer.chainRecvByNode.set(recvNode, reference); lowerer.chainHandled.add(dotNode); @@ -331,7 +331,7 @@ export function lowerOptionalChain( dotNode === expr.expression ) { const m = dotNode.name.text; - const id = `chain.${lowerer.chainCounter++}`; + const id = lowerer.closureName(loc, "", "chain"); const recvRef: IrExpr = { kind: "chainRecv", id, type: DYN, loc: locOf(recvNode) }; lowerer.chainRecvByNode.set(recvNode, recvRef); lowerer.chainHandled.add(dotNode); @@ -358,7 +358,7 @@ export function lowerOptionalChain( } return { kind: "optChain", id, receiver, body, type: DYN, loc }; } - const id = `chain.${lowerer.chainCounter++}`; + const id = lowerer.closureName(loc, "", "chain"); const reference: IrExpr = { kind: "chainRecv", id, type: DYN, loc }; lowerer.chainRecvByNode.set(recvNode, reference); lowerer.chainHandled.add(dotNode); @@ -420,7 +420,7 @@ export function lowerOptionalChain( rest.length === 1 ? rest[0]! : { kind: "union" as const, unionId: lowerer.unions.transform(def, rest) }; - const id = `chain.${lowerer.chainCounter++}`; + const id = lowerer.closureName(loc, "", "chain"); // A single present arm binds its payload. Multiple present arms bind // the original tagged value, then retag inside the guarded body. The // nullish arms never enter that body, and each record keeps its identity. diff --git a/packages/compiler/src/frontend/lowering/expressions/property-access.ts b/packages/compiler/src/frontend/lowering/expressions/property-access.ts index f0b980da0..6c8dfa3bf 100644 --- a/packages/compiler/src/frontend/lowering/expressions/property-access.ts +++ b/packages/compiler/src/frontend/lowering/expressions/property-access.ts @@ -1,4 +1,5 @@ /* Property reads (`a.b`): lowerExprInner's property-access branch, intrinsic and union properties, field reads and targets, and match-group reads. */ +import { keyedHelperName } from "../stable-names.js"; import { staticallySelected } from "../static-typeof.js"; import * as ts from "../../ts7/adapter.js"; import { lowerHistogramProperty } from "../builtins/performance.js"; @@ -2783,7 +2784,7 @@ export function lowerGroupsProjection( const key = `regexgroups:${shapeId}:${groups.map((g) => `${g.name}=${g.index}`).join(",")}:${recvKey}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%regex.groups.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%regex.groups", key); lowerer.valueHelpers.set(key, helper); const body: IrStmt[] = []; const locals: IrLocal[] = [{ id: "m.0", name: "m", type: recv.type, mutable: true }]; diff --git a/packages/compiler/src/frontend/lowering/expressions/relational.ts b/packages/compiler/src/frontend/lowering/expressions/relational.ts index 088b45cff..836391835 100644 --- a/packages/compiler/src/frontend/lowering/expressions/relational.ts +++ b/packages/compiler/src/frontend/lowering/expressions/relational.ts @@ -1,4 +1,5 @@ /* instanceof and in, including private-name and runtime-key in. */ +import { keyedHelperName } from "../stable-names.js"; import * as ts from "../../ts7/adapter.js"; import { builtinClassInstanceOfAny, builtinClassKind } from "../builtins/builtin-class-dyn.js"; import { @@ -647,7 +648,7 @@ export function lowerInstanceOf(lowerer: Lowerer, expr: ts.BinaryExpression, loc const key = `instanceof.union:${unionId}:${target.def.name}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%instanceof.union.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%instanceof.union", key); lowerer.valueHelpers.set(key, helper); const value: IrExpr = { kind: "varRef", localId: "value.0", type: left.type, loc }; const body: IrStmt[] = []; @@ -1847,7 +1848,7 @@ function lowerRuntimeKeyIn( const hkey = `haskey:${recvT.shapeId}`; let helper = lowerer.valueHelpers.get(hkey); if (!helper) { - helper = `%rec.haskey.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%rec.haskey", hkey); lowerer.valueHelpers.set(hkey, helper); const recT: IrType = { kind: "record", shapeId: recvT.shapeId }; diff --git a/packages/compiler/src/frontend/lowering/generic-functions.ts b/packages/compiler/src/frontend/lowering/generic-functions.ts index abcd5a584..daf082db7 100644 --- a/packages/compiler/src/frontend/lowering/generic-functions.ts +++ b/packages/compiler/src/frontend/lowering/generic-functions.ts @@ -1,4 +1,6 @@ import { staticNameBindings } from "./static-function-names.js"; +import { positionTag } from "./structural-positions.js"; +import { keyedHelperName } from "./stable-names.js"; import * as ts from "../ts7/adapter.js"; import { bodyReadsArguments } from "../arguments-usage.js"; import type { Lowerer } from "./lowerer.js"; @@ -229,7 +231,10 @@ export function collectGenericSignature(lowerer: Lowerer, decl: ts.FunctionDecla lowerer.genericFnsBySymbol.set(symbol, { decl, baseName: nameText, - qualifiedName: lowerer.qualify(ts.getSourceFileOfNode(decl), nsPathPrefix(decl) + nameText), + qualifiedName: lowerer.qualify( + ts.getSourceFileOfNode(decl), + nsPathPrefix(lowerer, decl) + nameText, + ), typeParams, instances: new Map(), }); @@ -651,7 +656,7 @@ function internGenericInstance( const typeArgsText = `<${rendered.length > 80 ? rendered.slice(0, 77) + "..." : rendered}>`; inst = { path, - name: `${info.qualifiedName}%${info.instances.size}`, + name: keyedHelperName(lowerer, `${info.qualifiedName}%`, key, ""), ordinal: info.instances.size, params, returnType, @@ -2129,7 +2134,7 @@ function internImplicitInstance( const declared = dynamicBroadPromise ? null : implicitDeclaredReturn(lowerer, info); inst = { path, - name: `${info.qualifiedName}%${info.instances.size}`, + name: keyedHelperName(lowerer, `${info.qualifiedName}%`, key, ""), ordinal: info.instances.size, params: shapes, // The promise callers rely on before the body settles it: the @@ -2317,7 +2322,7 @@ export function implicitLocalFnInfoOf( baseName: name, qualifiedName: lowerer.qualify( ts.getSourceFileOfNode(decl), - nsPathPrefix(stmt ?? decl, decl) + `${name}%l${ts.tokenStartOfNode(decl)}`, + nsPathPrefix(lowerer, stmt ?? decl, decl) + `${name}%l${positionTag(lowerer, decl)}`, ), typeParams: [], instances: new Map(), @@ -2413,7 +2418,7 @@ export function objLitGenericFnInfoOf( baseName: name, qualifiedName: lowerer.qualify( ts.getSourceFileOfNode(fnNode), - `%ol${ts.tokenStartOfNode(fnNode)}.${name}`, + `%ol${positionTag(lowerer, fnNode)}.${name}`, ), typeParams, instances: new Map(), @@ -2559,7 +2564,7 @@ export function bindingGenericFnInfoOf( baseName: name, qualifiedName: lowerer.qualify( ts.getSourceFileOfNode(decl), - nsPathPrefix(stmt ?? decl, decl) + + nsPathPrefix(lowerer, stmt ?? decl, decl) + (topLevel ? name : `${name}%l${ts.tokenStartOfNode(decl)}`), ), typeParams, diff --git a/packages/compiler/src/frontend/lowering/intern-tables.ts b/packages/compiler/src/frontend/lowering/intern-tables.ts index fc69237db..e3f2b0889 100644 --- a/packages/compiler/src/frontend/lowering/intern-tables.ts +++ b/packages/compiler/src/frontend/lowering/intern-tables.ts @@ -23,6 +23,7 @@ * The entry handles that itable.find and itable.insert answer stay inside * these lowerings: f64 locals that only reach toBool and itable.value. * Any other use of the class or its members as values is refused. */ +import { keyedHelperName } from "./stable-names.js"; import { dynUndefinedExpr } from "../../ir/build.js"; import { BOOL, F64, STRING, funcOf, typeKey } from "../../ir/ir.js"; import type { IrExpr, IrFunction, IrStmt, IrType, SrcLoc } from "../../ir/ir.js"; @@ -447,7 +448,11 @@ function helperName(lowerer: Lowerer, member: InternTableMember, signature: stri } function registerHelper(lowerer: Lowerer, member: InternTableMember, signature: string): string { - const name = `%${INTERN_TABLE_CLASS}.${member}.${lowerer.internTableHelpers.size}`; + const name = keyedHelperName( + lowerer, + `%${INTERN_TABLE_CLASS}.${member}`, + `${member}|${signature}`, + ); lowerer.internTableHelpers.set(`${member}|${signature}`, name); return name; } diff --git a/packages/compiler/src/frontend/lowering/iterator-adapters.ts b/packages/compiler/src/frontend/lowering/iterator-adapters.ts index 898c46f20..e50652182 100644 --- a/packages/compiler/src/frontend/lowering/iterator-adapters.ts +++ b/packages/compiler/src/frontend/lowering/iterator-adapters.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { dynUndefinedExpr, varRef } from "../../ir/build.js"; import { BOOL, @@ -86,7 +87,7 @@ function dynIteratorAdapter( const key = `iterAdapt:${typeKey(expected)}`; let name = lowerer.valueHelpers.get(key); if (!name) { - name = `%iter.adapt.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, "%iter.adapt", key); lowerer.valueHelpers.set(key, name); const locals: IrLocal[] = []; const local = (id: string, type: IrType, mutable = false): IrExpr => { @@ -313,7 +314,7 @@ export function lowerCollectionIteratorValue( loc, }; if (!typeEquals(yielded.type, type.yieldT)) return null; - name = `%coll.iter.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, "%coll.iter", key); lowerer.valueHelpers.set(key, name); lowerer.liftedFns.push({ name, @@ -411,7 +412,7 @@ export function lowerBytesIteratorValue( const key = `bytesIter:${method}:${typeKey(bytesT)}:${typeKey(type)}`; let name = lowerer.valueHelpers.get(key); if (!name) { - name = `%bytes.iter.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, "%bytes.iter", key); lowerer.valueHelpers.set(key, name); const list = varRef("list.0", bytesT, loc); const index = varRef("index.0", F64, loc); @@ -517,7 +518,7 @@ export function lowerStringIteratorValue( const key = `strIter:${typeKey(type)}`; let name = lowerer.valueHelpers.get(key); if (!name) { - name = `%str.iter.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, "%str.iter", key); lowerer.valueHelpers.set(key, name); const text = varRef("text.0", STRING, loc); const index = varRef("index.0", F64, loc); @@ -677,7 +678,7 @@ function generatorRetypeAdapter( type: resumeType(expected.nextT), loc, }; - name = `%gen.retype.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, "%gen.retype", key); lowerer.valueHelpers.set(key, name); lowerer.liftedFns.push({ name, @@ -794,7 +795,7 @@ export function generatorDrain( const outRef = varRef("out.0", arrT, loc); const value = lowerer.coerceToExpected(genValue(genRef, loc), elem); if (!typeEquals(value.type, elem)) return null; - name = `%gen.drain.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, "%gen.drain", key); lowerer.valueHelpers.set(key, name); lowerer.liftedFns.push({ name, @@ -856,7 +857,7 @@ export function generatorDrain( if (!raw) return null; const value = lowerer.coerceToExpected(raw, elem); if (!typeEquals(value.type, elem)) return null; - name = `%gen.drain.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, "%gen.drain", key); lowerer.valueHelpers.set(key, name); lowerer.liftedFns.push({ name, @@ -978,7 +979,7 @@ export function lowerArrayIteratorValue( }; } if (!yielded || !typeEquals(yielded.type, type.yieldT)) return null; - name = `%arr.iter.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, "%arr.iter", key); lowerer.valueHelpers.set(key, name); lowerer.liftedFns.push({ name, diff --git a/packages/compiler/src/frontend/lowering/js-dynamic-objects.ts b/packages/compiler/src/frontend/lowering/js-dynamic-objects.ts index b9bbf6216..e27dd4183 100644 --- a/packages/compiler/src/frontend/lowering/js-dynamic-objects.ts +++ b/packages/compiler/src/frontend/lowering/js-dynamic-objects.ts @@ -21,6 +21,7 @@ * files only, and an empty answer leaves every mapping unchanged, so * TypeScript programs and JavaScript that never uses these patterns * compile exactly as before. */ +import { keyedHelperName } from "./stable-names.js"; import * as ts from "../ts7/adapter.js"; import { isJsSourceFile, locOf } from "../program.js"; import { BOOL, DYN, type IrExpr, type IrStmt } from "../../ir/ir.js"; @@ -215,10 +216,10 @@ export function lowerValueReturningConstructorNew( "spread arguments when constructing a class whose constructor returns a value", ); } - const key = `ctorValue:${ts.getSourceFileOfNode(decl).fileName}:${ts.tokenStartOfNode(decl)}`; + const key = `ctorValue:${lowerer.positions.of(decl)}`; let name = lowerer.valueHelpers.get(key); if (name === undefined) { - name = `%ctorValue.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, "%ctorValue", key); lowerer.valueHelpers.set(key, name); const savedClass = lowerer.currentClass; lowerer.currentClass = null; diff --git a/packages/compiler/src/frontend/lowering/json-require.ts b/packages/compiler/src/frontend/lowering/json-require.ts index 927745253..d6c2da571 100644 --- a/packages/compiler/src/frontend/lowering/json-require.ts +++ b/packages/compiler/src/frontend/lowering/json-require.ts @@ -10,6 +10,7 @@ * JSON module is ordinary storage holding that object — destructuring * copies its properties at the require, exactly like Node. ES-module JSON * imports keep their own record (Node's ESM loader caches separately). */ +import { keyedHelperName } from "./stable-names.js"; import * as ts from "../ts7/adapter.js"; import type { Lowerer } from "./lowerer.js"; import { PoisonError } from "./lowerer.js"; @@ -84,7 +85,7 @@ export function collectJsonRequires(lowerer: Lowerer, parts: FileParts[]): void ); throw new PoisonError(); } - const id = `%g.jsonRequire.${lowerer.jsonRequireModules.size}`; + const id = keyedHelperName(lowerer, "%g.jsonRequire", jsonSf.fileName); const global: IrGlobal = { id, name: "%json", type: mapped, mutable: true }; const loadedId = `${id}%loaded`; lowerer.globalsList.push(global, { diff --git a/packages/compiler/src/frontend/lowering/lifetime-regions.ts b/packages/compiler/src/frontend/lowering/lifetime-regions.ts index b212ae473..b684c0395 100644 --- a/packages/compiler/src/frontend/lowering/lifetime-regions.ts +++ b/packages/compiler/src/frontend/lowering/lifetime-regions.ts @@ -14,6 +14,7 @@ * Any other use of the class or its methods as values is refused. The * module is marked lifetimeRegions, which moves every ProgramLifetime * class into counted regions. */ +import { keyedHelperName } from "./stable-names.js"; import { F64, VOID, funcOf, typeKey } from "../../ir/ir.js"; import type { IrExpr, IrFunction, IrStmt, IrType, SrcLoc } from "../../ir/ir.js"; import { experimentalImportOf, lifetimeRegionMemberOf } from "../experimental-import.js"; @@ -152,7 +153,7 @@ function runHelper(lowerer: Lowerer, fnType: IrType & { kind: "func" }, loc: Src const key = typeKey(fnType); const known = lowerer.regionRunHelpers.get(key); if (known !== undefined) return known; - const name = `%${LIFETIME_REGION_CLASS}.run.${lowerer.regionRunHelpers.size}`; + const name = keyedHelperName(lowerer, `%${LIFETIME_REGION_CLASS}.run`, key); lowerer.regionRunHelpers.set(key, name); const regionT = lifetimeRegionType(lowerer); const ret = fnType.ret; diff --git a/packages/compiler/src/frontend/lowering/lower-assert.ts b/packages/compiler/src/frontend/lowering/lower-assert.ts index 460f4d53a..bc51a9382 100644 --- a/packages/compiler/src/frontend/lowering/lower-assert.ts +++ b/packages/compiler/src/frontend/lowering/lower-assert.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { InternalCompilerError } from "../../errors.js"; /* The node:assert lowering (a spoke module like lower-dgram.ts): the * callable module form (`assert(x)` through a default import or a CJS @@ -667,7 +668,7 @@ function partialEqHelper(lowerer: Lowerer, ta: IrType, tb: IrType, loc: SrcLoc): const key = `assert.pdeq:${typeKey(ta)}|${typeKey(tb)}`; const existing = lowerer.assertHelpers.get(key); if (existing) return existing; - const name = `%assert.pdeq.${lowerer.assertHelpers.size}`; + const name = keyedHelperName(lowerer, "%assert.pdeq", key); lowerer.assertHelpers.set(key, name); const a = (): IrExpr => varRef("a.0", ta, loc); const b = (): IrExpr => varRef("b.0", tb, loc); @@ -1280,7 +1281,7 @@ function deepCheckCall( const key = `assert.dcheck:${variant}:${negated}:${typeKey(a.type)}:${typeKey(b.type)}`; let name = lowerer.assertHelpers.get(key); if (!name) { - name = `%assert.dcheck.${lowerer.assertHelpers.size}`; + name = keyedHelperName(lowerer, "%assert.dcheck", key); lowerer.assertHelpers.set(key, name); const pa = varRef("a.0", a.type, loc); const pb = varRef("b.0", b.type, loc); @@ -1844,7 +1845,7 @@ function assertThrowsHelper( const key = `assert.${mode}:${recvIsPromise ? "p" : "f"}:${typeKey(recvType)}:${sig}`; const existing = lowerer.assertHelpers.get(key); if (existing) return existing; - const name = `%assert.${mode}.${lowerer.assertHelpers.size}`; + const name = keyedHelperName(lowerer, `%assert.${mode}`, key); lowerer.assertHelpers.set(key, name); const caughtRef = (): IrExpr => varRef("e.0", CAUGHT, loc); @@ -2293,7 +2294,7 @@ function ifErrorHelper(lowerer: Lowerer, t: IrType & { kind: "union" }, loc: Src const key = `assert.iferr:${typeKey(t)}`; const existing = lowerer.assertHelpers.get(key); if (existing) return existing; - const name = `%assert.iferr.${lowerer.assertHelpers.size}`; + const name = keyedHelperName(lowerer, "%assert.iferr", key); lowerer.assertHelpers.set(key, name); const def = lowerer.unions.get(t.unionId); if (!def) throw new InternalCompilerError(`assert.ifError over unknown union ${t.unionId}`); @@ -2464,7 +2465,7 @@ function deepEqHelper(lowerer: Lowerer, t: IrType, loc: SrcLoc, loose = false): const key = `assert.${prefix}:${typeKey(t)}`; const existing = lowerer.assertHelpers.get(key); if (existing) return existing; - const name = `%assert.${prefix}.${lowerer.assertHelpers.size}`; + const name = keyedHelperName(lowerer, `%assert.${prefix}`, key); lowerer.assertHelpers.set(key, name); const a = (): IrExpr => varRef("a.0", t, loc); diff --git a/packages/compiler/src/frontend/lowering/lower-calls.ts b/packages/compiler/src/frontend/lowering/lower-calls.ts index 7102f37ab..63b8781f2 100644 --- a/packages/compiler/src/frontend/lowering/lower-calls.ts +++ b/packages/compiler/src/frontend/lowering/lower-calls.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { isForwardedTupleSpread, lowerForwardingApply } from "./typed-arguments.js"; import { guardNullProto, nullProtoRecordShape } from "./null-prototype.js"; import { lowerDynStreamMemberCall } from "./dyn-streams.js"; @@ -2094,7 +2095,7 @@ function lowerOptionalNumberDefault( const key = `number.optionalDefault:${widened.unionId}:${dflt}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%number.optionalDefault.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%number.optionalDefault", key); lowerer.valueHelpers.set(key, helper); const input = varRef("value.0", widened, loc); lowerer.liftedFns.push({ @@ -2203,7 +2204,7 @@ function primitiveConversionHandler( const key = `then.${name}:${typeKey(inner)}`; let fnName = lowerer.arrHofHelpers.get(key); if (fnName === undefined) { - fnName = `%then.${name}.${lowerer.arrHofHelpers.size}`; + fnName = keyedHelperName(lowerer, `%then.${name}`, key); lowerer.arrHofHelpers.set(key, fnName); const value = varRef("v.0", inner, loc); let body: IrExpr; @@ -2372,7 +2373,7 @@ function lowerBigIntConstructorValue(lowerer: Lowerer, arg: IrExpr, loc: SrcLoc) const key = `bigint.scalar:${unionId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%bigint.scalar.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%bigint.scalar", key); lowerer.valueHelpers.set(key, helper); const value = varRef("value.0", arg.type, loc); const body: IrStmt[] = []; @@ -3234,7 +3235,7 @@ function lowerScalarUnionNumber( const key = `number.scalar:${arg.type.unionId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%number.scalar.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%number.scalar", key); lowerer.valueHelpers.set(key, helper); const value = varRef("value.0", arg.type, loc); const nan: IrExpr = { @@ -3279,7 +3280,7 @@ function lowerOptionalStringNumber( const key = `${label}.optionalString:${arg.type.unionId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%${label}.optionalString.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, `%${label}.optionalString`, key); lowerer.valueHelpers.set(key, helper); const value = varRef("value.0", arg.type, loc); lowerer.liftedFns.push({ @@ -4706,7 +4707,7 @@ function lowerDefaultToStringCall( const key = `objToStr:${typeKey(recv.type)}${missing ? `:${missing}` : ""}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%obj.tostr.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%obj.tostr", key); lowerer.valueHelpers.set(key, helper); const o = varRef("o.0", recv.type, loc); lowerer.liftedFns.push({ @@ -5393,7 +5394,7 @@ function loweredTemplateStrings( const site = lowerer.globalsList.length; const globalId = `%g.templateStrings.${site}`; const readyId = `%g.templateStringsReady.${site}`; - getter = `%templateStrings.get.${lowerer.valueHelpers.size}`; + getter = keyedHelperName(lowerer, "%templateStrings.get", key); lowerer.valueHelpers.set(key, getter); lowerer.globalsList.push( { id: globalId, name: "%templateStrings", type, mutable: true }, @@ -5574,7 +5575,7 @@ export function lowerPromiseMethodCall( // IS the spec's identity/thrower/no-op substitution for all three // members. An argument expression, when present, is undefined/null // by construction — nothing to evaluate. - const fnName = `%fn${lowerer.lambdaCounter++}_${member}pass`; + const fnName = lowerer.closureName(loc, `_${member}pass`); const funcType: IrType & { kind: "func" } = { kind: "func", params: [promT], ret: promT }; const fnCtx = newFnCtx(true, null, funcType, inner); fnCtx.isAsync = true; @@ -5671,7 +5672,7 @@ export function lowerPromiseMethodCall( // Evaluate both callback expressions before the wrapper runs, in source order. const fulfilled = fulfilledAbsent ? null : boxHandler(fulfilledNode, true); const rejected = rejectedAbsent ? null : boxHandler(rejectedNode, false); - const fnName = `%fn${lowerer.lambdaCounter++}_then2`; + const fnName = lowerer.closureName(loc, "_then2"); const paramTypes: IrType[] = [ promT, ...(fulfilled ? [fulfilled.value.type] : []), @@ -5920,7 +5921,7 @@ export function lowerPromiseMethodCall( ); }; const resultT: IrType & { kind: "promise" } = { kind: "promise", inner: DYN }; - const fnName = `%fn${lowerer.lambdaCounter++}_then`; + const fnName = lowerer.closureName(loc, "_then"); const funcType: IrType & { kind: "func" } = { kind: "func", params: [promT, DYN], @@ -6015,7 +6016,7 @@ export function lowerPromiseMethodCall( ); } const R = resultT.inner; - const fnName = `%fn${lowerer.lambdaCounter++}_then`; + const fnName = lowerer.closureName(loc, "_then"); const funcType: IrType & { kind: "func" } = { kind: "func", params: [promT, cb.type], @@ -6118,7 +6119,7 @@ export function lowerPromiseMethodCall( "finally callbacks with parameters or a return value (use () => { ... })", ); } - const fnName = `%fn${lowerer.lambdaCounter++}_finally`; + const fnName = lowerer.closureName(loc, "_finally"); const funcType: IrType & { kind: "func" } = { kind: "func", params: [promT, cb.type], @@ -6221,7 +6222,7 @@ export function lowerPromiseMethodCall( } if (cb.type.kind === "dyn") { const resultT: IrType & { kind: "promise" } = { kind: "promise", inner: DYN }; - const fnName = `%fn${lowerer.lambdaCounter++}_catchdyn`; + const fnName = lowerer.closureName(loc, "_catchdyn"); const funcType: IrType & { kind: "func" } = { kind: "func", params: [promT, DYN], @@ -6351,7 +6352,7 @@ export function lowerPromiseMethodCall( ); } const R = resultT.inner; - const fnName = `%fn${lowerer.lambdaCounter++}_catch`; + const fnName = lowerer.closureName(loc, "_catch"); const funcType: IrType & { kind: "func" } = { kind: "func", params: [promT], ret: resultT }; const fnCtx = newFnCtx(true, null, funcType, R); fnCtx.isAsync = true; @@ -6588,7 +6589,7 @@ function filterNarrowHelper( const key = `filterNarrow:${test}:${typeKey(elem)}:${typeKey(outElem)}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = `%arr.filterNarrow.${lowerer.arrHofHelpers.size}`; + const name = keyedHelperName(lowerer, "%arr.filterNarrow", key); lowerer.arrHofHelpers.set(key, name); const arrT = arrayOf(elem); @@ -6834,7 +6835,7 @@ export function recordKeysArrayCall( const key = `obj.keys:${argIr.shapeId}:${typeKey(resultT)}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%obj.keys.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%obj.keys", key); const ref: IrExpr = { kind: "varRef", localId: "r.0", type: argIr, loc }; const outRef: IrExpr = { kind: "varRef", localId: "out.0", type: resultT, loc }; lowerer.arrHofHelpers.set(key, helper); @@ -6904,7 +6905,7 @@ function recordHasOwnHelper(lowerer: Lowerer, shapeId: string, loc: SrcLoc): str const key = `obj.hasOwn:${shapeId}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const helper = `%obj.hasOwn.${lowerer.arrHofHelpers.size}`; + const helper = keyedHelperName(lowerer, "%obj.hasOwn", key); lowerer.arrHofHelpers.set(key, helper); const shape = lowerer.shapes.get(shapeId)!; const recT: IrType = { kind: "record", shapeId }; @@ -6989,7 +6990,7 @@ function classAssignHelper( const key = `obj.assignClass:${className}:${srcShapeId}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const helper = `%obj.assignClass.${lowerer.arrHofHelpers.size}`; + const helper = keyedHelperName(lowerer, "%obj.assignClass", key); lowerer.arrHofHelpers.set(key, helper); const sShape = lowerer.shapes.get(srcShapeId)!; const oT: IrType = { kind: "object", className }; @@ -7057,7 +7058,7 @@ function recordAssignHelper( const key = `obj.assign:${targetShapeId}:${srcShapeId}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const helper = `%obj.assign.${lowerer.arrHofHelpers.size}`; + const helper = keyedHelperName(lowerer, "%obj.assign", key); lowerer.arrHofHelpers.set(key, helper); const sShape = lowerer.shapes.get(srcShapeId)!; const tShape = lowerer.shapes.get(targetShapeId)!; @@ -8514,7 +8515,7 @@ function lowerObjectStaticCall( const key = `obj.${member}:${argIr.shapeId}:${typeKey(resultT)}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%obj.${member}.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, `%obj.${member}`, key); const recT = argIr; const ref: IrExpr = { kind: "varRef", localId: "r.0", type: recT, loc }; const outRef: IrExpr = { kind: "varRef", localId: "out.0", type: resultT, loc }; @@ -9150,7 +9151,7 @@ function lowerInlineArrowBind( const length = firstDefault < 0 ? arrow.parameters.nodes.length : firstDefault; const key = `arrow.bind:${typeKey(type)}:${length}`; const existing = lowerer.arrHofHelpers.get(key); - const name = existing ?? `%arrow.bind.${lowerer.arrHofHelpers.size}`; + const name = existing ?? keyedHelperName(lowerer, "%arrow.bind", key); if (!existing) { lowerer.arrHofHelpers.set(key, name); lowerer.freshClosureAdapters.add(name); @@ -10079,7 +10080,7 @@ function lowerUnionObjectDynFieldCall( const receiverRef = varRef(receiverLocal.id, receiverT, loc); let helper = lowerer.unionCallHelpers.get(key); if (!helper) { - helper = `%union.call.${lowerer.unionCallHelpers.size}`; + helper = keyedHelperName(lowerer, "%union.call", key); lowerer.unionCallHelpers.set(key, helper); const receiverRef = varRef("this.0", receiverT, loc); const branch = (plan: (typeof plans)[number]): IrStmt[] => { @@ -10172,7 +10173,7 @@ function unionObjectMethodHelper( const key = `${receiverT.unionId}:${method}:${shapes.map((shape) => `${shape.mode}:${typeKey(shape.type)}`).join(",")}:${typeKey(resultT)}`; const existing = lowerer.unionCallHelpers.get(key); if (existing) return existing; - const name = `%union.call.${lowerer.unionCallHelpers.size}`; + const name = keyedHelperName(lowerer, "%union.call", key); lowerer.unionCallHelpers.set(key, name); // A probe that catches a refusal while the body lowers must not leave // the name registered for a helper that was never emitted. @@ -10366,7 +10367,7 @@ export function lowerStaticNumberGlobal( const key = `parseInt.optional:${unionT.unionId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%parseInt.optional.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%parseInt.optional", key); lowerer.valueHelpers.set(key, helper); const value: IrExpr = { kind: "varRef", localId: "value.0", type: unionT, loc }; const radixRef: IrExpr = { kind: "varRef", localId: "radix.0", type: F64, loc }; diff --git a/packages/compiler/src/frontend/lowering/lower-classes.ts b/packages/compiler/src/frontend/lowering/lower-classes.ts index 790efe988..fcea03790 100644 --- a/packages/compiler/src/frontend/lowering/lower-classes.ts +++ b/packages/compiler/src/frontend/lowering/lower-classes.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { lowerValueReturningConstructorNew } from "./js-dynamic-objects.js"; import { adaptPromiseExecutor } from "./promise-executor-adapter.js"; import { dynUndefinedExpr, nodeThrowExpr, varRef } from "../../ir/build.js"; @@ -4663,7 +4664,7 @@ export function genericClassInstanceType( ); } const ordinal = gci.instances.size; - const name = `${gci.family.def.name}%${ordinal}`; + const name = keyedHelperName(lowerer, `${gci.family.def.name}%`, key, ""); const entry: { name: string; info: ClassInfo | null; poisoned?: boolean } = { name, info: null }; gci.instances.set(key, entry); const bindings = new Map(); @@ -7910,7 +7911,7 @@ export function classIteratorDrainCall( const key = `${cit.className}:${typeKey(outElem)}`; let name = lowerer.iterDrainHelpers.get(key); if (!name) { - name = `%iter.drain.${lowerer.iterDrainHelpers.size}`; + name = keyedHelperName(lowerer, "%iter.drain", key); lowerer.iterDrainHelpers.set(key, name); const recvT: IrType = { kind: "object", className: cit.className }; const recvRef: IrExpr = { kind: "varRef", localId: "r.0", type: recvT, loc }; @@ -8024,7 +8025,7 @@ export function classIteratorRestDrainCall( const key = `it:${cit.iterT.className}`; let name = lowerer.iterDrainHelpers.get(key); if (!name) { - name = `%iter.drain.${lowerer.iterDrainHelpers.size}`; + name = keyedHelperName(lowerer, "%iter.drain", key); lowerer.iterDrainHelpers.set(key, name); const itRef: IrExpr = { kind: "varRef", localId: "it.0", type: cit.iterT, loc }; const outRef: IrExpr = { kind: "varRef", localId: "out.0", type: outT, loc }; @@ -10532,7 +10533,7 @@ export function lowerNew(lowerer: Lowerer, expr: ts.NewExpression): IrExpr { const key = `x509.record:${isBytes ? "bytes" : "str"}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%x509.record.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%x509.record", key); lowerer.valueHelpers.set(key, helper); const dataT = data.type; const dRef: IrExpr = { kind: "varRef", localId: "d.0", type: dataT, loc }; diff --git a/packages/compiler/src/frontend/lowering/lower-dgram.ts b/packages/compiler/src/frontend/lowering/lower-dgram.ts index 5c99ebc82..aa90fc7c7 100644 --- a/packages/compiler/src/frontend/lowering/lower-dgram.ts +++ b/packages/compiler/src/frontend/lowering/lower-dgram.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { dynUndefinedExpr, boolLit } from "../../ir/build.js"; /* The dgram/dns-surface lowering (node:dgram + node:dns — a spoke module * like lower-server.ts): module-function calls (dgram createSocket, dns @@ -357,7 +358,7 @@ function checkedDynPromise( const key = `dns.promise:${typeKey(declared)}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%dns.promise.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%dns.promise", key); lowerer.valueHelpers.set(key, helper); const promiseT: IrType = { kind: "promise", inner: DYN }; lowerer.liftedFns.push({ @@ -891,7 +892,7 @@ export function lowerPromisifiedDnsCall( const key = `dnsPromise:${JSON.stringify(value)}`; let name = lowerer.valueHelpers.get(key); if (!name) { - name = `%dnsPromise.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, "%dnsPromise", key); lowerer.valueHelpers.set(key, name); lowerer.liftedFns.push({ name, diff --git a/packages/compiler/src/frontend/lowering/lower-event-emitter.ts b/packages/compiler/src/frontend/lowering/lower-event-emitter.ts index f472672b2..f105af786 100644 --- a/packages/compiler/src/frontend/lowering/lower-event-emitter.ts +++ b/packages/compiler/src/frontend/lowering/lower-event-emitter.ts @@ -42,6 +42,7 @@ * emit-overrides block at the bottom of this file (per-event * monomorphization of the override body, dispatch on the dynamic class, * super.emit as the prototype chain). */ +import { keyedHelperName } from "./stable-names.js"; import { checkKeypressListener } from "./builtins/readline.js"; import * as ts from "../ts7/adapter.js"; import type { Lowerer } from "./lowerer.js"; @@ -631,7 +632,7 @@ function lowerFlexListenerCall( const key = `emitter.${registering ? "onFlex" : "offDyn"}:${typeKey(recvT)}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%emitter.${registering ? "onFlex" : "offFlex"}.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, `%emitter.${registering ? "onFlex" : "offFlex"}`, key); lowerer.arrHofHelpers.set(key, helper); const params: IrParam[] = [ { localId: "r.0", name: "r", type: recvT }, @@ -850,7 +851,7 @@ function lowerDynListenerCall( const existing = lowerer.arrHofHelpers.get(key); let helper = existing; if (!helper) { - helper = `%emitter.${registering ? "onDyn" : "offDyn"}.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, `%emitter.${registering ? "onDyn" : "offDyn"}`, key); lowerer.arrHofHelpers.set(key, helper); const check: IrStmt = { kind: "exprStmt", @@ -1000,7 +1001,7 @@ export function lowerDynamicEmitterEmit( const key = `emitter.dynEmit:${typeKey(recvT)}:${k}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%emitter.dynEmit.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%emitter.dynEmit", key); lowerer.arrHofHelpers.set(key, helper); const params: IrParam[] = [ { localId: "r.0", name: "r", type: recvT }, @@ -1092,7 +1093,7 @@ export function lowerDynamicEmitterOn( const key = `emitter.dynOn:${typeKey(recvT)}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%emitter.dynOn.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%emitter.dynOn", key); lowerer.arrHofHelpers.set(key, helper); const params: IrParam[] = [ { localId: "r.0", name: "r", type: recvT }, @@ -2359,7 +2360,7 @@ function emitDispatchExpr( const key = `emitter.emitDispatch:${typeKey(recvT)}:${name}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%emitter.emitDispatch.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%emitter.emitDispatch", key); lowerer.arrHofHelpers.set(key, helper); const params: IrParam[] = [ { localId: "r.0", name: "r", type: recvT }, @@ -2424,7 +2425,7 @@ function eventsOnceBoxer( const key = `eventsOnce:${typeKey(fnType)}`; let name = lowerer.valueHelpers.get(key); if (name === undefined) { - name = `%events.onceArgs.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, "%events.onceArgs", key); lowerer.valueHelpers.set(key, name); const params: IrParam[] = tuple.map((type, i) => ({ localId: `%once.a${i}`, diff --git a/packages/compiler/src/frontend/lowering/lower-exprs.ts b/packages/compiler/src/frontend/lowering/lower-exprs.ts index e7a1b79a8..ba96bea8c 100644 --- a/packages/compiler/src/frontend/lowering/lower-exprs.ts +++ b/packages/compiler/src/frontend/lowering/lower-exprs.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { lowerWebAssemblyValue, refuseWebAssemblyUse } from "./builtins/webassembly.js"; import { dynUndefinedExpr, nodeThrowExpr, numLit, strLit, varRef } from "../../ir/build.js"; import { InternalCompilerError } from "../../errors.js"; @@ -2274,7 +2275,11 @@ export function cjsAccessorSnapshotOf( if (!lexerVisibleAccessors(ts.getSourceFileOfNode(getter)).includes(getter)) return null; const call = cjsAccessorCall(lowerer, getter, locOf(getter)); if (call === null) return null; - const snapshot = { id: `%g.cjsSnapshot.${lowerer.cjsAccessorSnapshots.size}`, type: call.type }; + const at = locOf(getter); + const snapshot = { + id: keyedHelperName(lowerer, "%g.cjsSnapshot", `${at.file}:${at.start}:${at.end}`), + type: call.type, + }; lowerer.globalsList.push({ id: snapshot.id, name: "%cjsSnapshot", @@ -2299,7 +2304,7 @@ export function cjsAccessorSnapshotStores( if (getters.length === 0) return []; let readyId = lowerer.cjsSnapshotReady.get(dep); if (readyId === undefined) { - readyId = `%g.cjsSnapshotReady.${lowerer.cjsSnapshotReady.size}`; + readyId = keyedHelperName(lowerer, "%g.cjsSnapshotReady", dep.fileName); lowerer.globalsList.push({ id: readyId, name: "%cjsSnapshotReady", type: BOOL, mutable: true }); lowerer.cjsSnapshotReady.set(dep, readyId); } diff --git a/packages/compiler/src/frontend/lowering/lower-functions.ts b/packages/compiler/src/frontend/lowering/lower-functions.ts index cd8dc31d1..653c0d837 100644 --- a/packages/compiler/src/frontend/lowering/lower-functions.ts +++ b/packages/compiler/src/frontend/lowering/lower-functions.ts @@ -270,7 +270,7 @@ export function lowerLambda( const nameIdent = !ts.isArrowFunction(node) && node.name && ts.isIdentifier(node.name) ? node.name : null; const baseName = nameIdent ? nameIdent.text : ""; - const fnName = `%fn${lowerer.lambdaCounter++}${baseName ? `_${baseName}` : ""}`; + const fnName = lowerer.closureName(locOf(node), baseName ? `_${baseName}` : ""); // Named function expressions/declarations can self-reference by name; an // object-literal method's name is a PROPERTY, not a binding — no self. const selfSymbol = diff --git a/packages/compiler/src/frontend/lowering/lower-inspect.ts b/packages/compiler/src/frontend/lowering/lower-inspect.ts index 4be5d0b7e..1979b43aa 100644 --- a/packages/compiler/src/frontend/lowering/lower-inspect.ts +++ b/packages/compiler/src/frontend/lowering/lower-inspect.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { dynUndefinedExpr, boolLit, @@ -268,7 +269,7 @@ function errorInspectHelper( const key = `insp.userError:${typeKey(t)}`; const existing = lowerer.inspectHelpers.get(key); if (existing) return existing; - const name = `%util.insp.${lowerer.inspectHelpers.size}`; + const name = keyedHelperName(lowerer, "%util.insp", key); lowerer.inspectHelpers.set(key, name); const v = (): IrExpr => varRef("v.0", t, loc); const r = (): IrExpr => varRef("r.0", F64, loc); @@ -1145,7 +1146,7 @@ function inspectHelper(lowerer: Lowerer, t: IrType, loc: SrcLoc): string { const key = `insp:${typeKey(t)}`; const existing = lowerer.inspectHelpers.get(key); if (existing) return existing; - const name = `%util.insp.${lowerer.inspectHelpers.size}`; + const name = keyedHelperName(lowerer, "%util.insp", key); lowerer.inspectHelpers.set(key, name); const v = (): IrExpr => varRef("v.0", t, loc); @@ -2074,7 +2075,7 @@ function formatUnionHelper( const existing = lowerer.inspectHelpers.get(key); if (existing) return existing; const loc = helperLoc(site); - const name = `%util.fmtv.${lowerer.inspectHelpers.size}`; + const name = keyedHelperName(lowerer, "%util.fmtv", key); lowerer.inspectHelpers.set(key, name); const def = lowerer.unions.get(t.unionId); if (!def) throw new InternalCompilerError(`format value over unknown union ${t.unionId}`); diff --git a/packages/compiler/src/frontend/lowering/lower-mixins.ts b/packages/compiler/src/frontend/lowering/lower-mixins.ts index 766059dfb..9de027563 100644 --- a/packages/compiler/src/frontend/lowering/lower-mixins.ts +++ b/packages/compiler/src/frontend/lowering/lower-mixins.ts @@ -34,6 +34,7 @@ * statics-bearing mixin classes outside a plain top-level statement * (their declaration-time code must run exactly where the call * evaluates). */ +import { positionTag } from "./structural-positions.js"; import * as ts from "../ts7/adapter.js"; import type { Lowerer } from "./lowerer.js"; import { PoisonError } from "./lowerer.js"; @@ -452,7 +453,7 @@ function instantiateMixinCall( const base = mixinBaseClassOf(lowerer, call.arguments.nodes[0]!); const instName = lowerer.qualify( ts.getSourceFileOfNode(call), - `%mx${ts.tokenStartOfNode(call)}.${shape.classNode.name?.text ?? ""}`, + `%mx${positionTag(lowerer, call)}.${shape.classNode.name?.text ?? ""}`, ); const ordinal = lowerer.mixinOrdinals.get(shape.classNode) ?? 0; lowerer.mixinOrdinals.set(shape.classNode, ordinal + 1); diff --git a/packages/compiler/src/frontend/lowering/lower-mock.ts b/packages/compiler/src/frontend/lowering/lower-mock.ts index fcc68c787..8c50dee46 100644 --- a/packages/compiler/src/frontend/lowering/lower-mock.ts +++ b/packages/compiler/src/frontend/lowering/lower-mock.ts @@ -17,6 +17,7 @@ * writes the original back on restore(). Each mock registers a closure * that calls its restore() with its tracker (scr_test.c): the module's * `mock`, or the test's t.mock, which is reset when the test ends. */ +import { keyedHelperName } from "./stable-names.js"; import * as ts from "../ts7/adapter.js"; import { BOOL, @@ -136,7 +137,7 @@ function liftOnce( const key = `mock.${role}:${owner}`; const existing = lowerer.assertHelpers.get(key); if (existing) return existing; - const name = `%mock.${role}.${lowerer.assertHelpers.size}`; + const name = keyedHelperName(lowerer, `%mock.${role}`, key); lowerer.assertHelpers.set(key, name); build(name); return name; diff --git a/packages/compiler/src/frontend/lowering/lower-modules.test.ts b/packages/compiler/src/frontend/lowering/lower-modules.test.ts index 84cc96e7d..f1021e4da 100644 --- a/packages/compiler/src/frontend/lowering/lower-modules.test.ts +++ b/packages/compiler/src/frontend/lowering/lower-modules.test.ts @@ -34,7 +34,7 @@ test("retains dependencies from function storage, captures, generator channels a const completed = record("completed"); const body = record("body"); const global = record("global", record("nested")); - const wanted = lowerer.shapes.shapes.map((shape) => shape.id); + const wanted = lowerer.shapes.shapes.map((shape) => shape.id).sort(); record("unused"); const unionId = lowerer.unions.intern([body, UNDEFINED_T]); const unusedUnion = lowerer.unions.intern([F64, UNDEFINED_T]); @@ -162,7 +162,7 @@ test("closes nested structural types and index-signature values", () => { sent = record("sent"), indexed = record("indexed"); const containerId = lowerer.shapes.intern([], false, indexed); - const wanted = lowerer.shapes.shapes.map((shape) => shape.id); + const wanted = lowerer.shapes.shapes.map((shape) => shape.id).sort(); record("unused"); const nested: IrType = { kind: "func", diff --git a/packages/compiler/src/frontend/lowering/lower-modules.ts b/packages/compiler/src/frontend/lowering/lower-modules.ts index d1f276d44..0b99e88d3 100644 --- a/packages/compiler/src/frontend/lowering/lower-modules.ts +++ b/packages/compiler/src/frontend/lowering/lower-modules.ts @@ -1,4 +1,5 @@ import { THREADS_MODULE } from "../threads-import.js"; +import { positionTag } from "./structural-positions.js"; import { EXPERIMENTAL_MODULE } from "../experimental-import.js"; import { dynUndefinedExpr } from "../../ir/build.js"; import { everyStmtList, everyTypeChild } from "../../ir/traverse.js"; @@ -1074,8 +1075,14 @@ export function moduleArtifacts( else delete rest.abstractMethods; return rest; }), - records: lowerer.shapes.shapes.filter((r) => shapeIds.has(r.id)), - unions: lowerer.unions.unions.filter((u) => unionIds.has(u.id)), + // Ids come from what each shape and union is (keyedHelperName), so + // ordering by id gives every lowering order the same module. + records: lowerer.shapes.shapes + .filter((r) => shapeIds.has(r.id)) + .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)), + unions: lowerer.unions.unions + .filter((u) => unionIds.has(u.id)) + .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)), }; } @@ -1677,7 +1684,7 @@ export function collectGlobals( } if (type.kind === "void") lowerer.badType(stmt.name, lowerer.typeOf(stmt.name)); const g: IrGlobal = { - id: `%g.${tag}${nsPathPrefix(stmt)}%alias.${stmt.name.text}%${ts.tokenStartOfNode(stmt)}`, + id: `%g.${tag}${nsPathPrefix(lowerer, stmt)}%alias.${stmt.name.text}%${positionTag(lowerer, stmt)}`, name: stmt.name.text, type, mutable: false, @@ -1754,7 +1761,7 @@ export function collectGlobals( // (`%g.e.A%B.x`), so `namespace A { export const x }` and a // top-level `const x` never collide; non-exported members add the // declaring block's position (block-local bindings). - const nsPrefix = nsPathPrefix(stmt, list.declarations.nodes[0]); + const nsPrefix = nsPathPrefix(lowerer, stmt, list.declarations.nodes[0]); for (const decl of list.declarations.nodes) { // --provenance-sources: an elided pure-annotated dead const in a // fetched source module registers no global (the statement diff --git a/packages/compiler/src/frontend/lowering/lower-namespaces.ts b/packages/compiler/src/frontend/lowering/lower-namespaces.ts index dca835d77..19123dae3 100644 --- a/packages/compiler/src/frontend/lowering/lower-namespaces.ts +++ b/packages/compiler/src/frontend/lowering/lower-namespaces.ts @@ -36,6 +36,7 @@ * of the compiler already takes (a body running before the declaring * statement is not modeled — same as top-level const reads through early * calls). */ +import { positionTag, type PositionTagOwner } from "./structural-positions.js"; import * as ts from "../ts7/adapter.js"; import { packageShimFor } from "../package-shims.js"; import type { Lowerer } from "./lowerer.js"; @@ -164,7 +165,11 @@ function registerTypeOnlyBlocks(lowerer: Lowerer, decl: ts.ModuleDeclaration): v * distinct (resolution is by symbol; names only need uniqueness and * determinism). `modifierDecl` carries the declaration whose modifiers * decide exportedness (the first declarator of a variable statement). */ -export function nsPathPrefix(node: ts.Node, modifierDecl?: ts.Node): string { +export function nsPathPrefix( + owner: PositionTagOwner, + node: ts.Node, + modifierDecl?: ts.Node, +): string { const parent = node.parent; if (parent === undefined || !ts.isModuleBlock(parent)) return ""; const flagsHost = modifierDecl ?? node; @@ -179,10 +184,10 @@ export function nsPathPrefix(node: ts.Node, modifierDecl?: ts.Node): string { const nested = p.parent !== undefined && ts.isModuleBlock(p.parent); const nonExported = nested && (ts.getCombinedModifierFlags(p) & ts.ModifierFlags.Export) === 0; - segs.unshift(p.name.text + (nonExported ? `%${ts.tokenStartOfNode(p)}` : "")); + segs.unshift(p.name.text + (nonExported ? `%${positionTag(owner, p)}` : "")); } } - return `${segs.join("%")}${exported ? "" : `%${ts.tokenStartOfNode(parent)}`}.`; + return `${segs.join("%")}${exported ? "" : `%${positionTag(owner, parent)}`}.`; } /** The registered namespace-block kind a symbol's declaration sits in diff --git a/packages/compiler/src/frontend/lowering/lower-server.ts b/packages/compiler/src/frontend/lowering/lower-server.ts index 058d7874a..94d49d8b3 100644 --- a/packages/compiler/src/frontend/lowering/lower-server.ts +++ b/packages/compiler/src/frontend/lowering/lower-server.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { dynUndefinedExpr, nodeThrowExpr, @@ -183,7 +184,7 @@ export function voidizedCallback(lowerer: Lowerer, cb: IrExpr, loc: SrcLoc): IrE const toT = funcOf([...fromT.params], VOID); const key = `server.voidcb:${typeKey(fromT)}`; const existing = lowerer.arrHofHelpers.get(key); - const name = existing ?? `%server.voidcb.${lowerer.arrHofHelpers.size}`; + const name = existing ?? keyedHelperName(lowerer, "%server.voidcb", key); if (!existing) { lowerer.arrHofHelpers.set(key, name); const impl = `${name}.impl`; @@ -279,7 +280,7 @@ function receiverReturningCall( ): IrExpr { const key = `server.recvret:${fn}:${opts?.prefix?.fn ?? ""}:${(opts?.mainArgIndices ?? []).join(".")}:${callArgs.map((a) => typeKey(a.type)).join(",")}`; const existing = lowerer.arrHofHelpers.get(key); - const name = existing ?? `%server.recvret.${lowerer.arrHofHelpers.size}`; + const name = existing ?? keyedHelperName(lowerer, "%server.recvret", key); if (!existing) { lowerer.arrHofHelpers.set(key, name); const params = callArgs.map((a, i) => ({ localId: `p${i}.0`, name: `p${i}`, type: a.type })); @@ -590,7 +591,7 @@ function h2HeadersCallbackAdapter( ); const key = `h2.hdrcb:${handleKind}:${withStatus}:${typeKey(fromT)}:${shapeId ?? ""}`; const existing = lowerer.arrHofHelpers.get(key); - const name = existing ?? `%h2.hdrcb.${lowerer.arrHofHelpers.size}`; + const name = existing ?? keyedHelperName(lowerer, "%h2.hdrcb", key); if (!existing) { lowerer.arrHofHelpers.set(key, name); const impl = `${name}.impl`; @@ -3583,7 +3584,7 @@ export function lowerCompatReqStreamOptionalCall( type: unionT, loc, }; - const id = `chain.${lowerer.chainCounter++}`; + const id = lowerer.closureName(loc, "", "chain"); const body = lowerH2StreamMethodCall(lowerer, call, call.expression, { kind: "chainRecv", id, @@ -4424,7 +4425,7 @@ function lowerHttpCreateServerForms( const hasMax = opts.maxHeaderSize !== null; const key = `server.opts:${opts.joinDup ? 1 : 0}:${opts.allowMissingHost ? 1 : 0}:${hasBuffer ? 1 : 0}:${hasMax ? 1 : 0}`; const existing = lowerer.arrHofHelpers.get(key); - const name = existing ?? `%server.opts.${lowerer.arrHofHelpers.size}`; + const name = existing ?? keyedHelperName(lowerer, "%server.opts", key); if (!existing) { lowerer.arrHofHelpers.set(key, name); const params = [ @@ -8009,7 +8010,7 @@ function lowerHttpResMethodCall( const all = [...callArgs, cb]; const key = `server.endcb:${fn}:${all.map((a) => typeKey(a.type)).join(",")}`; const existing = lowerer.arrHofHelpers.get(key); - const helper = existing ?? `%server.endcb.${lowerer.arrHofHelpers.size}`; + const helper = existing ?? keyedHelperName(lowerer, "%server.endcb", key); if (!existing) { lowerer.arrHofHelpers.set(key, helper); const params = all.map((a, i) => ({ localId: `p${i}.0`, name: `p${i}`, type: a.type })); diff --git a/packages/compiler/src/frontend/lowering/lower-stdlib.ts b/packages/compiler/src/frontend/lowering/lower-stdlib.ts index 2ad3657c7..0beb24a0e 100644 --- a/packages/compiler/src/frontend/lowering/lower-stdlib.ts +++ b/packages/compiler/src/frontend/lowering/lower-stdlib.ts @@ -2278,7 +2278,7 @@ function lowerStaticNamespaceImport( ): IrExpr { const loc = locOf(call); const resultT: IrType & { kind: "promise" } = { kind: "promise", inner: ns }; - const fnName = `%fn${lowerer.lambdaCounter++}_staticImport`; + const fnName = lowerer.closureName(loc, "_staticImport"); const fnType: IrType & { kind: "func" } = { kind: "func", params: [], ret: resultT }; const fnCtx = newFnCtx(true, null, fnType, ns); fnCtx.isAsync = true; diff --git a/packages/compiler/src/frontend/lowering/lower-stream.ts b/packages/compiler/src/frontend/lowering/lower-stream.ts index b9add95a6..a75ec43b7 100644 --- a/packages/compiler/src/frontend/lowering/lower-stream.ts +++ b/packages/compiler/src/frontend/lowering/lower-stream.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { nodeThrowExpr, boolLit, numLit, strLit } from "../../ir/build.js"; import { hashStreamOf, isHashValueType } from "./builtins/hash-stream.js"; import { InternalCompilerError } from "../../errors.js"; @@ -311,7 +312,7 @@ function lowerStreamCallback( ); } } - const fnName = `%fn${lowerer.lambdaCounter++}_${which}cb`; + const fnName = lowerer.closureName(loc, `_${which}cb`); const fnCtx = newFnCtx(true, null, funcType, funcType.ret); lowerer.fnStack.push(fnCtx); try { @@ -1144,7 +1145,7 @@ function streamMethodWrapper( paramTypes.push(got.type); } const ret = found.sig.ret; - const fnName = `%fn${lowerer.lambdaCounter++}_${which}vt`; + const fnName = lowerer.closureName(loc, `_${which}vt`); const funcType = funcOf([thisType, ...paramTypes], ret); lowerer.fnStack.push(newFnCtx(true, null, funcType, ret)); try { @@ -1690,7 +1691,7 @@ function fromGenHelpers( const key = `streamFromGen:${role}:${typeKey(gen)}`; let name = lowerer.valueHelpers.get(key); if (!name) { - name = `%stream.fromGen.${role}.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, `%stream.fromGen.${role}`, key); lowerer.valueHelpers.set(key, name); lowerer.liftedFns.push({ name, @@ -1779,7 +1780,7 @@ function classIteratorObject( const key = `streamFromIter:${cit.iterT.className}`; let name = lowerer.valueHelpers.get(key); if (!name) { - name = `%stream.fromIter.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, "%stream.fromIter", key); lowerer.valueHelpers.set(key, name); const nextName = `${name}.next`; const nextT = funcOf([], DYN); @@ -1940,7 +1941,7 @@ function classAsyncIteratorObject( const key = `streamFromAsyncIter:${cit.className}`; let name = lowerer.valueHelpers.get(key); if (!name) { - name = `%stream.fromAsyncIter.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, "%stream.fromAsyncIter", key); lowerer.valueHelpers.set(key, name); const it: IrLocal = { id: "it.0", name: "it", type: cit.iterT, mutable: false, boxed: true }; const src: IrLocal = { @@ -2894,7 +2895,7 @@ function pipelineBoxHelper( const key = `pipelineBox:${typeKey(promiseT)}`; let name = lowerer.valueHelpers.get(key); if (!name) { - name = `%stream.pipelineBox.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, "%stream.pipelineBox", key); lowerer.valueHelpers.set(key, name); lowerer.liftedFns.push({ name, @@ -2921,7 +2922,7 @@ function pipelineAbortHelper(lowerer: Lowerer, ac: IrExpr, loc: SrcLoc): IrExpr let name = lowerer.valueHelpers.get(key); const abortT = funcOf([], VOID); if (!name) { - name = `%stream.pipelineAbort.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, "%stream.pipelineAbort", key); lowerer.valueHelpers.set(key, name); const acLocal: IrLocal = { id: "ac.0", name: "ac", type: DYN, mutable: false, boxed: true }; const acRef = varRef(acLocal.id, DYN, loc); diff --git a/packages/compiler/src/frontend/lowering/lower-timers.ts b/packages/compiler/src/frontend/lowering/lower-timers.ts index 7d4bba34b..03c9c5c1f 100644 --- a/packages/compiler/src/frontend/lowering/lower-timers.ts +++ b/packages/compiler/src/frontend/lowering/lower-timers.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { dynUndefinedExpr, numLit, varRef } from "../../ir/build.js"; import * as ts from "../ts7/adapter.js"; import { isJsSourceFile } from "../program.js"; @@ -55,7 +56,7 @@ export function adaptZeroArgTimerCallback( const toT: IrType = { kind: "func", params: [], ret: VOID }; const key = `timer.dropret:${typeKey(fromT)}`; const existing = lowerer.arrHofHelpers.get(key); - const name = existing ?? `%timer.dropret.${lowerer.arrHofHelpers.size}`; + const name = existing ?? keyedHelperName(lowerer, "%timer.dropret", key); if (!existing) { lowerer.arrHofHelpers.set(key, name); lowerer.liftedFns.push( @@ -117,7 +118,7 @@ export function adaptZeroArgTimerCallback( const toT: IrType = { kind: "func", params: [], ret: VOID }; const key = `timer.droparg:${typeKey(fromT)}`; const existing = lowerer.arrHofHelpers.get(key); - const name = existing ?? `%timer.droparg.${lowerer.arrHofHelpers.size}`; + const name = existing ?? keyedHelperName(lowerer, "%timer.droparg", key); if (!existing) { lowerer.arrHofHelpers.set(key, name); lowerer.liftedFns.push( @@ -203,7 +204,7 @@ function makeTimerArgsThunk( const toT: IrType = { kind: "func", params: [], ret: VOID }; const key = `timer.argsthunk:${n}`; const existing = lowerer.arrHofHelpers.get(key); - const name = existing ?? `%timer.argsthunk.${lowerer.arrHofHelpers.size}`; + const name = existing ?? keyedHelperName(lowerer, "%timer.argsthunk", key); if (!existing) { lowerer.arrHofHelpers.set(key, name); const impl = `${name}.impl`; diff --git a/packages/compiler/src/frontend/lowering/lowerer.test.ts b/packages/compiler/src/frontend/lowering/lowerer.test.ts index bacdc7941..750c27694 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.test.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.test.ts @@ -10,6 +10,7 @@ import { } from "../../ir/ir.js"; import type { Node, Program, SourceFile, Symbol, Type } from "../ts7/adapter.js"; import { Lowerer } from "./lowerer.js"; +import { UnionRegistry } from "../type-mapper.js"; import { classMethodValue } from "./class-method-values.js"; const loc = { file: "island.ts", start: 0, end: 1 }; @@ -32,7 +33,7 @@ test("reuses complete copy routes without repeating discriminator planning", () expect(plan).not.toHaveBeenCalled(); expect(lowerer.liftedFns.filter((fn) => fn.name === helper)).toHaveLength(1); const recursive = {} as Type; - lowerer.shapes.recursiveRef(recursive); + lowerer.shapes.recursiveRef(recursive, "Recursive"); lowerer.shapes.finalizeRecursive(recursive, [{ name: "kind", type: STRING }]); expect(lowerer.unionRetagHelper(from, to, loc)).toBe(helper); expect(plan).toHaveBeenCalled(); @@ -54,7 +55,7 @@ test("replans after a recursive union gains its final arms", () => { const lowerer = context(); const recursive = {} as Type; const from = lowerer.unions.intern([UNDEFINED_T, NULL_T]); - const to = lowerer.unions.recursiveRef(recursive); + const to = lowerer.unions.recursiveRef(recursive, "Recursive"); const trapped = lowerer.unionRetagHelper(from, to, loc); expect(trapped).not.toBeNull(); lowerer.unions.finalizeRecursive(recursive, [UNDEFINED_T]); @@ -75,7 +76,7 @@ test("rechecks width conversions after recursive record definitions settle", () const lowerer = context(); const recursive = {} as Type; const source = record(lowerer.shapes.intern([{ name: "value", type: F64 }])); - const target = record(lowerer.shapes.recursiveRef(recursive)); + const target = record(lowerer.shapes.recursiveRef(recursive, "Recursive")); const from = lowerer.unions.intern([source, UNDEFINED_T]); const to = lowerer.unions.intern([target, NULL_T]); expect(lowerer.unionRetagHelper(from, to, loc)).not.toBeNull(); @@ -129,7 +130,7 @@ test("literal ownership is reused across values and rechecked when recursive rec expect(inspect).not.toHaveBeenCalled(); const recursive = {} as Type; - const pendingShape = record(lowerer.shapes.recursiveRef(recursive)); + const pendingShape = record(lowerer.shapes.recursiveRef(recursive, "Recursive")); const pending = lowerer.unions.intern([pendingShape], { field: "kind", cases: [{ tag: 0, values: ["a"] }], @@ -143,7 +144,7 @@ test("literal ownership is reused across values and rechecked when recursive rec test("literal ownership sees a recursive union's finalized discriminator", () => { const lowerer = context(); const recursive = {} as Type; - const union = lowerer.unions.recursiveRef(recursive); + const union = lowerer.unions.recursiveRef(recursive, "Recursive"); const shape = record(lowerer.shapes.intern([{ name: "kind", type: STRING }])); expect(lowerer.literalUnionArm(union, ["ready"])).toBeNull(); lowerer.unions.finalizeRecursive(recursive, [shape], { @@ -182,7 +183,10 @@ test("removing undefined reuses the discriminator transformation without hiding ); const recursive = {} as Type; - const pending: IrType = { kind: "union", unionId: lowerer.unions.recursiveRef(recursive) }; + const pending: IrType = { + kind: "union", + unionId: lowerer.unions.recursiveRef(recursive, "Recursive"), + }; expect(lowerer.stripUndefinedArm(pending)).toEqual(pending); lowerer.unions.finalizeRecursive(recursive, [STRING, UNDEFINED_T]); expect(lowerer.stripUndefinedArm(pending)).toEqual(STRING); @@ -215,7 +219,10 @@ test("adding undefined reuses semantic union transformations and sees recursive expect(lowerer.unions.get(added.unionId)?.discriminant).toEqual(discriminant); const recursive = {} as Type; - const pending: IrType = { kind: "union", unionId: lowerer.unions.recursiveRef(recursive) }; + const pending: IrType = { + kind: "union", + unionId: lowerer.unions.recursiveRef(recursive, "Recursive"), + }; const before = lowerer.withUndefinedArmOf(pending); lowerer.unions.finalizeRecursive(recursive, [a, b], discriminant); expect(lowerer.withUndefinedArmOf(pending)).toEqual(added); @@ -227,13 +234,18 @@ test("adding undefined reuses semantic union transformations and sees recursive test("optional union widening keeps refused and missing contracts current", () => { const lowerer = context(); const recursive = {} as Type; - const pending: IrType = { kind: "union", unionId: lowerer.unions.recursiveRef(recursive) }; + const pending: IrType = { + kind: "union", + unionId: lowerer.unions.recursiveRef(recursive, "Recursive"), + }; expect(lowerer.withUndefinedArmOf(pending)).not.toBeNull(); lowerer.unions.finalizeRecursive(recursive, [{ kind: "date" }, STRING]); expect(lowerer.withUndefinedArmOf(pending)).toBeNull(); expect(lowerer.withUndefinedArmOf(pending)).toBeNull(); - const missing: IrType = { kind: "union", unionId: `u${lowerer.unions.unions.length}` }; + // Union ids come from their arms, so a fresh registry names the union + // this one has not interned yet. + const missing: IrType = { kind: "union", unionId: new UnionRegistry().intern([F64, STRING]) }; expect(lowerer.withUndefinedArmOf(missing)).toBeNull(); expect(lowerer.unions.intern([F64, STRING])).toBe(missing.unionId); expect(lowerer.withUndefinedArmOf(missing)?.kind).toBe("union"); diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts index ee8ba7ecb..687a2fb1a 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -1,4 +1,6 @@ import { relieveHeapPressure } from "../../heap-pressure.js"; +import { keyedHelperName } from "./stable-names.js"; +import { positionTag, StructuralPositions } from "./structural-positions.js"; import { onlyForwarded, stripTypeWrappers } from "./typed-arguments.js"; import { needsGeneralNodeStreams, @@ -1004,6 +1006,11 @@ function lowerShuffle(): ((wave: string[]) => void) | null { * the bodies reachable emit did NOT mark (plus deferred collection * diagnostics nothing flushed), reported separately: whole-program analysis without * letting unreached code fail builds. */ +/** The closure root of an emit-override specialization body. */ +function emitSpecRoot(spec: EmitSpecRequest): string { + return `%emit.${spec.info.def.name}.${spec.event}.${spec.ordinal}`; +} + export function lowerToIr( program: ts.Program, entry: ts.SourceFile, @@ -2801,6 +2808,8 @@ export class Lowerer { /** Generated value helpers, keyed by operation and type. Callers own * their key prefixes; this includes more than structural conversions. */ readonly valueHelpers = new Map(); + /** Each name keyedHelperName made, with a second hash of its key. */ + readonly keyedNameKeys = new Map(); /** structuralNarrowing's assignable classes, keyed by static and * narrowed class name. */ readonly structuralClassPeers = new Map(); @@ -2937,7 +2946,6 @@ export class Lowerer { ctx: FnCtx; } >(); - chainCounter = 0; /** Keyed by program-wide qualified class name (what IR object types carry). */ readonly classes = new Map(); readonly classBySymbol = new Map(); @@ -3167,7 +3175,47 @@ export class Lowerer { * dispatch revision needs no weak-key identity or process-global state. */ errorMethodDispatchRevision: string | null = null; errorPropertyDispatchRevision: string | null = null; - lambdaCounter = 0; + /** Structural source positions (structural-positions.ts) for names that + * stay the same when unrelated code moves. */ + readonly positions = new StructuralPositions(); + + /** The outermost node whose token span is exactly `loc`, or null. */ + nodeAtLoc(loc: SrcLoc): ts.Node | null { + const sf = this.program.getSourceFile(loc.file); + return sf === undefined ? null : (ts.nodeAtSpan(sf, loc.start, loc.end) ?? null); + } + + /** The lowering unit whose name scopes the closures it lifts. */ + private closureRoot = "%pre"; + private readonly closureNameCounts = new Map(); + + /** Runs `fn` with the closures it lifts named under `root`. */ + withClosureRoot(root: string, fn: () => T): T { + const previous = this.closureRoot; + this.closureRoot = root; + try { + return fn(); + } finally { + this.closureRoot = previous; + } + } + + /** The name of a closure (or wrapper) lifted for the source at `loc`: + * `.` of the current lowering unit, the location and + * `suffix`, then `suffix`. A unit that lifts several functions for the same + * location and suffix numbers them in the order it lifts them, so a + * closure's name depends only on its unit, not on which units lowered + * before it. */ + closureName(loc: SrcLoc, suffix = "", prefix = "%fn"): string { + const node = this.nodeAtLoc(loc); + const where = node === null ? `${loc.file}:${loc.start}:${loc.end}` : this.positions.of(node); + const key = `${prefix}|${this.closureRoot}|${where}|${suffix}`; + const first = keyedHelperName(this, prefix, key); + const seen = this.closureNameCounts.get(first) ?? 0; + this.closureNameCounts.set(first, seen + 1); + return (seen === 0 ? first : keyedHelperName(this, prefix, `${key}|${seen}`)) + suffix; + } + readonly preparedClassFactories = new Map(); readonly preparingClassFactories = new Set(); @@ -3808,11 +3856,11 @@ export class Lowerer { })() ? this.qualify( ts.getSourceFileOfNode(decl), - `%cx${ts.tokenStartOfNode(decl)}.${decl.name?.text ?? ""}`, + `%cx${positionTag(this, decl)}.${decl.name?.text ?? ""}`, ) : this.qualify( ts.getSourceFileOfNode(decl), - nsPathPrefix(decl) + (decl.name ? decl.name.text : "%anon"), + nsPathPrefix(this, decl) + (decl.name ? decl.name.text : "%anon"), ); for (let index = this.localClassInstantiations.length - 1; index >= 0; index--) { const entry = this.localClassInstantiations[index]!; @@ -7371,7 +7419,10 @@ export class Lowerer { } for (const decl of fp.classDecls) { const info = this.classes.get(this.classNamer(decl)); - if (info) functions.push(...this.lowerClassMembers(info)); + if (info) + functions.push( + ...this.withClosureRoot(info.def.name, () => this.lowerClassMembers(info)), + ); else if (this.countsSkips()) this.countSkippedBody(decl); } } @@ -7384,7 +7435,10 @@ export class Lowerer { // are reachable by definition, already counted by reachable emit. if (!this.remainder) { for (const fp of parts) { - functions.push(this.lowerFileInit(fp.sf, fp.topStmts, this.initNameOf.get(fp.sf)!)); + const initName = this.initNameOf.get(fp.sf)!; + functions.push( + this.withClosureRoot(initName, () => this.lowerFileInit(fp.sf, fp.topStmts, initName)), + ); } functions.push(this.buildMain()); } @@ -7426,7 +7480,9 @@ export class Lowerer { // default): the diagnostic is recorded — the instance skips // like a signature-blocked function (lowerFunction's rule). try { - functions.push(this.lowerGenericInstance(info, inst)); + functions.push( + this.withClosureRoot(inst.name, () => this.lowerGenericInstance(info, inst)), + ); } catch (e) { if (!(e instanceof PoisonError)) throw e; } @@ -7436,7 +7492,10 @@ export class Lowerer { // instances of its own; the joint fixpoint covers both). while (es < this.emitSpecQueue.length) { try { - const fn = lowerEmitOverrideSpec(this, this.emitSpecQueue[es++]!); + const spec = this.emitSpecQueue[es++]!; + const fn = this.withClosureRoot(emitSpecRoot(spec), () => + lowerEmitOverrideSpec(this, spec), + ); if (fn) functions.push(fn); } catch (e) { if (!(e instanceof PoisonError)) throw e; @@ -7990,7 +8049,9 @@ export class Lowerer { this.genericClassDemandPriority.set(info, ref); instanceFunctions.push( ...this.withGenericDemandOwner(owner, () => - this.shapes.withDeclaredOrderPriority(ref, () => this.lowerClassMembers(info)), + this.shapes.withDeclaredOrderPriority(ref, () => + this.withClosureRoot(info.def.name, () => this.lowerClassMembers(info)), + ), ), ); relieveHeapPressure(); @@ -8017,7 +8078,7 @@ export class Lowerer { instanceFunctions.push( this.withGenericDemandOwner(owner, () => this.shapes.withDeclaredOrderPriority(ref, () => - this.lowerGenericInstance(info, inst), + this.withClosureRoot(inst.name, () => this.lowerGenericInstance(info, inst)), ), ), ); @@ -8050,9 +8111,12 @@ export class Lowerer { ); while (specLowered < waveEnd) { try { - const fn = this.shapes.withDeclaredOrderPriority([4, instanceMetadataOrder++], () => - lowerEmitOverrideSpec(this, this.emitSpecQueue[specLowered++]!), - ); + const fn = this.shapes.withDeclaredOrderPriority([4, instanceMetadataOrder++], () => { + const spec = this.emitSpecQueue[specLowered++]!; + return this.withClosureRoot(emitSpecRoot(spec), () => + lowerEmitOverrideSpec(this, spec), + ); + }); if (fn) instanceFunctions.push(fn); } catch (e) { if (!(e instanceof PoisonError)) throw e; @@ -8080,7 +8144,9 @@ export class Lowerer { initFunctions.push( this.withGenericDemandOwner(owner, () => this.shapes.withDeclaredOrderPriority(priority, () => - this.lowerFileInit(fp.sf, fp.topStmts, this.initNameOf.get(fp.sf)!), + this.withClosureRoot(this.initNameOf.get(fp.sf)!, () => + this.lowerFileInit(fp.sf, fp.topStmts, this.initNameOf.get(fp.sf)!), + ), ), ), ); @@ -8106,7 +8172,9 @@ export class Lowerer { const priority = metadataPriority.get(name) ?? [3, expressionMetadataOrder++]; const owner = demandOwner(priority); const fn = this.withGenericDemandOwner(owner, () => - this.shapes.withDeclaredOrderPriority(priority, unit.lower), + this.shapes.withDeclaredOrderPriority(priority, () => + this.withClosureRoot(name, unit.lower), + ), ); if (fn) loweredUnits.set(name, fn); relieveHeapPressure(); @@ -13489,7 +13557,7 @@ export class Lowerer { const key = `${fn.valueFn ?? fn.fn}:${typeKey(funcType)}:${adapterShape}`; let fnName = this.builtinCallableValueFns.get(key); if (!fnName) { - fnName = `%builtin.value.${fn.valueFn ?? fn.fn}.${this.builtinCallableValueFns.size}`; + fnName = keyedHelperName(this, `%builtin.value.${fn.valueFn ?? fn.fn}`, key); this.builtinCallableValueFns.set(key, fnName); this.builtinCallableValueNames.set(fnName, display.slice(display.lastIndexOf(".") + 1)); const params = funcType.params.map((type, index) => ({ diff --git a/packages/compiler/src/frontend/lowering/native-ffi.ts b/packages/compiler/src/frontend/lowering/native-ffi.ts index 0f932ba93..62f2be9f1 100644 --- a/packages/compiler/src/frontend/lowering/native-ffi.ts +++ b/packages/compiler/src/frontend/lowering/native-ffi.ts @@ -562,7 +562,7 @@ export function lowerFfiMemoryModule(lowerer: Lowerer, loc: SrcLoc): IrExpr { const entries = lowerer.ffiImports .filter((entry) => entry.library !== undefined) .map((entry) => { - const name = `%ffi.module.${lowerer.lambdaCounter++}`; + const name = lowerer.closureName(loc, "", "%ffi.module"); const sourceTypes = ffiSourceParamTypes(entry.params); const locals: IrLocal[] = sourceTypes.map((_, i) => ({ id: `%arg${i}`, diff --git a/packages/compiler/src/frontend/lowering/object-enumeration-receiver.ts b/packages/compiler/src/frontend/lowering/object-enumeration-receiver.ts index 855da3bda..388ac3904 100644 --- a/packages/compiler/src/frontend/lowering/object-enumeration-receiver.ts +++ b/packages/compiler/src/frontend/lowering/object-enumeration-receiver.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { BOOL, STRING, @@ -27,7 +28,7 @@ export function objectEnumerationReceiver( const key = `obj.receiver:${source.unionId}:${expected.shapeId}`; let name = lowerer.arrHofHelpers.get(key); if (name === undefined) { - name = `%obj.receiver.${lowerer.arrHofHelpers.size}`; + name = keyedHelperName(lowerer, "%obj.receiver", key); lowerer.arrHofHelpers.set(key, name); const value = varRef("value.0", source, loc); lowerer.liftedFns.push({ diff --git a/packages/compiler/src/frontend/lowering/pairs-snapshot.ts b/packages/compiler/src/frontend/lowering/pairs-snapshot.ts index 3b33fb0cd..acf7b3bf9 100644 --- a/packages/compiler/src/frontend/lowering/pairs-snapshot.ts +++ b/packages/compiler/src/frontend/lowering/pairs-snapshot.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { arrayOf, BOOL, @@ -49,7 +50,7 @@ export function pairsSnapshotHelper( const key = `${options.keyPrefix}.snapshot:${shapeId}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%${options.keyPrefix}.snapshot.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, `%${options.keyPrefix}.snapshot`, key); lowerer.valueHelpers.set(key, name); const recordType: IrType = { kind: "record", shapeId }; const pairsType = arrayOf(STRING); diff --git a/packages/compiler/src/frontend/lowering/promise-executor-adapter.ts b/packages/compiler/src/frontend/lowering/promise-executor-adapter.ts index 09d228b05..84aa8dac0 100644 --- a/packages/compiler/src/frontend/lowering/promise-executor-adapter.ts +++ b/packages/compiler/src/frontend/lowering/promise-executor-adapter.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { varRef } from "../../ir/build.js"; import { type IrExpr, @@ -40,7 +41,7 @@ export function adaptPromiseExecutor( const key = `promise.executor:${typeKey(execT)}:${typeKey(inner)}`; let name = lowerer.arrHofHelpers.get(key); if (name === undefined) { - name = `%promise.executor.${lowerer.arrHofHelpers.size}`; + name = keyedHelperName(lowerer, "%promise.executor", key); lowerer.arrHofHelpers.set(key, name); const impl = `${name}.impl`; const captured: IrLocal = { id: "f.0", name: "f", type: execT, mutable: false, boxed: true }; diff --git a/packages/compiler/src/frontend/lowering/require-initialization.ts b/packages/compiler/src/frontend/lowering/require-initialization.ts index d979423b0..c8fc9c730 100644 --- a/packages/compiler/src/frontend/lowering/require-initialization.ts +++ b/packages/compiler/src/frontend/lowering/require-initialization.ts @@ -9,6 +9,7 @@ * and every reference that can run earlier checks it first — the same * module.tdzCheck the import-cycle bindings use. A reference whose lowering * leaves no expression to check keeps the SC1013 fence. */ +import { positionTag } from "./structural-positions.js"; import * as ts from "../ts7/adapter.js"; import type { Lowerer } from "./lowerer.js"; import { @@ -119,7 +120,7 @@ export function markRequireEarlyBindings(lowerer: Lowerer): void { const tag = rawTag === "" ? "e." : rawTag.replace(/^%/, ""); const bySymbol = new Map(); for (const { decl } of declared) { - const flagId = `%g.${tag}%required.${ts.tokenStartOfNode(decl)}`; + const flagId = `%g.${tag}%required.${positionTag(lowerer, decl)}`; lowerer.globalsList.push({ id: flagId, name: "%initialized", type: BOOL, mutable: true }); const flag: RequireInitFlag = { flagId, names: new Map() }; for (const id of boundNames(decl.name)) { diff --git a/packages/compiler/src/frontend/lowering/stable-names.ts b/packages/compiler/src/frontend/lowering/stable-names.ts new file mode 100644 index 000000000..8f7d0967e --- /dev/null +++ b/packages/compiler/src/frontend/lowering/stable-names.ts @@ -0,0 +1,48 @@ +import { InternalCompilerError } from "../../errors.js"; + +/** The owner of the names keyedHelperName hands out. */ +export interface KeyedNameOwner { + /** Each keyed name with a second hash of the key it was made from, which + * tells a repeated key from a different key with the same name. */ + readonly keyedNameKeys: Map; +} + +/** 48 bits of two FNV-1a hashes of `key`, as 12 hex digits. */ +function keyHash(key: string): string { + let a = 0x811c9dc5; + let b = 0x01000193 ^ 0x5bd1e995; + for (let i = 0; i < key.length; i++) { + const c = key.charCodeAt(i); + a = Math.imul(a ^ c, 0x01000193); + b = Math.imul(b ^ c, 0x01000193) ^ (b >>> 13); + } + const high = (b >>> 0).toString(16).padStart(8, "0").slice(4); + return high + (a >>> 0).toString(16).padStart(8, "0"); +} + +/** A 32-bit hash of `key` independent of keyHash's bits. */ +function checkHash(key: string): number { + let h = 0x9e3779b9; + for (let i = 0; i < key.length; i++) + h = Math.imul(h ^ key.charCodeAt(i), 0x85ebca6b) ^ (h >>> 15); + return h >>> 0; +} + +/** The name of a helper interned by `key`: ``. It depends only on the key, not on how many helpers were interned + * before, so a helper has the same name whichever unit first needs it. Two + * keys that hash to the same name throw an InternalCompilerError. */ +export function keyedHelperName( + owner: KeyedNameOwner, + prefix: string, + key: string, + separator = ".", +): string { + const name = `${prefix}${separator}${keyHash(key)}`; + const check = checkHash(key); + const previous = owner.keyedNameKeys.get(name); + if (previous === undefined) owner.keyedNameKeys.set(name, check); + else if (previous !== check) + throw new InternalCompilerError(`helper name ${name} is shared by two helper keys`); + return name; +} diff --git a/packages/compiler/src/frontend/lowering/strict-equality.ts b/packages/compiler/src/frontend/lowering/strict-equality.ts index 7b9b6902b..8a87c8111 100644 --- a/packages/compiler/src/frontend/lowering/strict-equality.ts +++ b/packages/compiler/src/frontend/lowering/strict-equality.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { boolLit, varRef } from "../../ir/build.js"; import { BOOL, @@ -135,7 +136,7 @@ export function lowerUnionEquality( loc, ); if (!result) return null; - name = `%value.eq.${lowerer.equalityHelpers.size}`; + name = keyedHelperName(lowerer, "%value.eq", key); lowerer.equalityHelpers.set(key, name); lowerer.liftedFns.push({ name, diff --git a/packages/compiler/src/frontend/lowering/structural-positions.ts b/packages/compiler/src/frontend/lowering/structural-positions.ts new file mode 100644 index 000000000..cdc290b4b --- /dev/null +++ b/packages/compiler/src/frontend/lowering/structural-positions.ts @@ -0,0 +1,103 @@ +import * as ts from "../ts7/adapter.js"; +import { keyedHelperName, type KeyedNameOwner } from "./stable-names.js"; + +/** The declaration kinds whose names anchor the positions inside them. */ +const ANCHOR_KINDS: ReadonlySet = new Set([ + ts.SyntaxKind.FunctionDeclaration, + ts.SyntaxKind.ClassDeclaration, + ts.SyntaxKind.ClassExpression, + ts.SyntaxKind.VariableDeclaration, + ts.SyntaxKind.MethodDeclaration, + ts.SyntaxKind.GetAccessor, + ts.SyntaxKind.SetAccessor, + ts.SyntaxKind.PropertyDeclaration, + ts.SyntaxKind.PropertyAssignment, + ts.SyntaxKind.ModuleDeclaration, + ts.SyntaxKind.EnumDeclaration, + ts.SyntaxKind.Constructor, +]); + +/** The name of `node` when it is a named declaration that anchors the + * positions of the nodes inside it, or null. */ +function anchorName(node: ts.Node): string | null { + return ts.declarationNameAt(node, node.index, ANCHOR_KINDS); +} + +/** The nearest enclosing anchor of `node` (not `node` itself), or its + * source file. */ +function anchorOf(node: ts.Node): ts.Node { + for (let parent = node.parent; parent !== undefined; parent = parent.parent) { + if (ts.isSourceFile(parent) || anchorName(parent) !== null) return parent; + } + return ts.getSourceFileOfNode(node); +} + +/** Source positions that stay the same when code outside the enclosing + * declaration changes. A node's structural position is its file, the chain + * of enclosing named declarations (each with its ordinal among the + * declarations of the same kind and name in its own anchor), and its + * ordinal among the nodes of its kind whose nearest anchor is the same + * declaration. Editing another declaration, or code nested in another + * named declaration of the same anchor, leaves the position unchanged. */ +export class StructuralPositions { + /** Per anchor and key: the indices of the nodes with that key whose + * nearest anchor it is, in preorder (anchoredNodes). */ + private readonly nodesByKey = new Map>(); + private readonly paths = new Map(); + + /** The ordinal of `node` among the nodes of `anchor` with its key. */ + private ordinalIn(anchor: ts.Node, node: ts.Node, key: string): number { + let byKey = this.nodesByKey.get(anchor); + if (byKey === undefined) this.nodesByKey.set(anchor, (byKey = new Map())); + let indices = byKey.get(key); + if (indices === undefined) { + indices = ts.anchoredNodes(anchor, key, ANCHOR_KINDS); + byKey.set(key, indices); + } + // Indices increase in preorder. + let low = 0; + let high = indices.length - 1; + while (low <= high) { + const middle = (low + high) >> 1; + const at = indices[middle]!; + if (at === node.index) return middle; + if (at < node.index) low = middle + 1; + else high = middle - 1; + } + return -1; + } + + /** The anchor chain of `anchor` from the file down. */ + private pathOf(anchor: ts.Node): string { + const cached = this.paths.get(anchor); + if (cached !== undefined) return cached; + let path: string; + if (ts.isSourceFile(anchor)) path = anchor.fileName; + else { + const parent = anchorOf(anchor); + const name = anchorName(anchor); + path = `${this.pathOf(parent)}/${name}#${this.ordinalIn(parent, anchor, `${anchor.kind}:${name}`)}`; + } + this.paths.set(anchor, path); + return path; + } + + /** The structural position of `node`. */ + of(node: ts.Node): string { + const anchor = anchorOf(node); + const name = anchorName(node); + const key = name === null ? `${node.kind}` : `${node.kind}:${name}`; + return `${this.pathOf(anchor)}|${key}#${this.ordinalIn(anchor, node, key)}`; + } +} + +/** The owner of structural positions and the names made from them. */ +export interface PositionTagOwner extends KeyedNameOwner { + readonly positions: StructuralPositions; +} + +/** A short tag for `node`'s structural position, for names that must stay + * unique per source node (class expressions, namespace blocks). */ +export function positionTag(owner: PositionTagOwner, node: ts.Node): string { + return keyedHelperName(owner, "", owner.positions.of(node), ""); +} diff --git a/packages/compiler/src/frontend/ts7/ast.ts b/packages/compiler/src/frontend/ts7/ast.ts index 369213d89..0bddd1a80 100644 --- a/packages/compiler/src/frontend/ts7/ast.ts +++ b/packages/compiler/src/frontend/ts7/ast.ts @@ -47,8 +47,9 @@ import { } from "./ast-guards.generated.js"; import type { Ts7DiagnosticData as Diagnostic } from "./session-schema.generated.js"; import { ModifierFlags, SyntaxKind } from "./enums.js"; -import { AstKind } from "./ast-schema.generated.js"; +import { AstKind, KIND_NODE_LIST } from "./ast-schema.generated.js"; import { PREORDER_LIST } from "./ast-wire.js"; +import { tokenStartOfNode } from "./node-functions.js"; /* ---- everything 7 kept under the same name ---- */ @@ -196,6 +197,93 @@ function walkLinkedPreorder( } } +/** The semantic children of a wire node: list items stand in for their + * list, and attached JSDoc trees are left out (the walkPreorder view). */ +function semanticChildIndices(root: Node, index: number, out: number[]): void { + const wire = root.file.wire; + for (let child = wire.firstChild(index); child !== 0; child = wire.next(child)) { + const kind = wire.kind(child); + if (kind === KIND_NODE_LIST) { + for (let item = wire.firstChild(child); item !== 0; item = wire.next(item)) out.push(item); + } else if (kind !== AstKind.JSDoc) out.push(child); + } +} + +/** The outermost node of `sourceFile` whose token span is exactly + * [start, end), or undefined. Only nodes ending at `end` are + * materialized. */ +export function nodeAtSpan(sourceFile: SourceFile, start: number, end: number): Node | undefined { + const wire = sourceFile.file.wire; + const children: number[] = []; + let index = sourceFile.index; + for (;;) { + children.length = 0; + semanticChildIndices(sourceFile, index, children); + let next = 0; + for (const child of children) { + if (wire.pos(child) > start || wire.end(child) < end) continue; + if (wire.end(child) === end) { + const node = sourceFile.file.node(child); + if (tokenStartOfNode(node) === start) return node; + } + next = child; + break; + } + if (next === 0) return undefined; + index = next; + } +} + +/** The name of the declaration at wire `index` in `root`'s file when its + * kind is in `kinds`: its identifier, private identifier or string literal + * name, "constructor" for a constructor, or null. Reads the wire without + * materializing nodes. */ +export function declarationNameAt( + root: Node, + index: number, + kinds: ReadonlySet, +): string | null { + const wire = root.file.wire; + const kind = wire.kind(index); + if (!kinds.has(kind)) return null; + if (kind === SyntaxKind.Constructor) return "constructor"; + const name = wire.namedChild(index, "name"); + if (name === 0) return null; + const nameKind = wire.kind(name); + if ( + nameKind !== SyntaxKind.Identifier && + nameKind !== SyntaxKind.PrivateIdentifier && + nameKind !== SyntaxKind.StringLiteral + ) + return null; + return wire.text(name) ?? null; +} + +/** The indices, in preorder, of the nodes below `root` that have `key` and + * are not inside a nested named declaration (declarationNameAt with + * `kinds`). A named declaration is keyed `:` and its subtree is + * not visited; other nodes are keyed by their kind. No node is + * materialized. */ +export function anchoredNodes(root: Node, key: string, kinds: ReadonlySet): number[] { + const wire = root.file.wire; + const out: number[] = []; + const children: number[] = []; + const stack: number[] = []; + semanticChildIndices(root, root.index, children); + for (let i = children.length - 1; i >= 0; i--) stack.push(children[i]!); + while (stack.length > 0) { + const index = stack.pop()!; + const kind = wire.kind(index); + const name = declarationNameAt(root, index, kinds); + if ((name === null ? String(kind) : `${kind}:${name}`) === key) out.push(index); + if (name !== null) continue; + children.length = 0; + semanticChildIndices(root, index, children); + for (let i = children.length - 1; i >= 0; i--) stack.push(children[i]!); + } + return out; +} + export function getLineAndCharacterOfPosition( sourceFile: SourceFile, position: number, diff --git a/packages/compiler/src/frontend/type-mapper.test.ts b/packages/compiler/src/frontend/type-mapper.test.ts index cf78554b4..a99eb44cc 100644 --- a/packages/compiler/src/frontend/type-mapper.test.ts +++ b/packages/compiler/src/frontend/type-mapper.test.ts @@ -41,7 +41,7 @@ describe("union arm lookup", () => { test("sees finalized recursive arms after a missing lookup", () => { const unions = new UnionRegistry(); const recursive = {} as Type; - const union = unions.recursiveRef(recursive); + const union = unions.recursiveRef(recursive, "Recursive"); expect(unions.armTag(union, STRING)).toBe(-1); unions.finalizeRecursive(recursive, [ F64, diff --git a/packages/compiler/src/frontend/type-mapper.ts b/packages/compiler/src/frontend/type-mapper.ts index a233f0186..ce73e8bc2 100644 --- a/packages/compiler/src/frontend/type-mapper.ts +++ b/packages/compiler/src/frontend/type-mapper.ts @@ -1,4 +1,5 @@ import { InternalCompilerError } from "../errors.js"; +import { keyedHelperName } from "./lowering/stable-names.js"; import { mockCallRecordType, mockContextType } from "./mock-shapes.js"; import * as ts from "./ts7/adapter.js"; import { bodyReadsArguments } from "./arguments-usage.js"; @@ -252,6 +253,8 @@ function comparePriority(left: DeclaredOrderPriority, right: DeclaredOrderPriori export class ShapeRegistry { /** Existing layouts change only when a recursive placeholder closes. */ revision = 0; + /** Each shape id with a second hash of its key (keyedHelperName). */ + readonly keyedNameKeys = new Map(); private readonly byKey = new Map(); private readonly byId = new Map(); /** Historical emit-order rank of the declaration-order metadata each @@ -270,7 +273,7 @@ export class ShapeRegistry { * writer after all priority candidates have closed. */ private readonly derivedDeclaredOrderFinalizers: (() => void)[] = []; private currentDeclaredOrderPriority: DeclaredOrderPriority = [0, 0]; - /** All interned shapes in first-seen (`r0`, `r1`, ...) order. */ + /** All interned shapes in first-seen order. */ readonly shapes: IrRecordShape[] = []; /** ts.Types currently being mapped — a BACK-REFERENCE to one of these is * the recursive knot (`interface TreeNode { children: TreeNode[] }`): @@ -391,10 +394,12 @@ export class ShapeRegistry { /** The shape id a back-reference to an in-progress type resolves to: * reuses the type's persistent recursive id or mints a PLACEHOLDER * entry (empty fields) the outer frame finalizes. */ - recursiveRef(t: ts.Type): string { + recursiveRef(t: ts.Type, description: string): string { let id = this.recIds.get(t); if (id === undefined) { - id = `r${this.shapes.length}`; + id = keyedHelperName(this, "r", `recursive:${description}`, ""); + if (this.byId.has(id)) + throw new InternalCompilerError(`two recursive types share the description ${description}`); const shape: IrRecordShape = { id, fields: [] }; this.byId.set(id, shape); this.shapes.push(shape); @@ -463,7 +468,7 @@ export class ShapeRegistry { const key = this.keyOf(fields, tuple, indexValue); let id = this.byKey.get(key); if (id === undefined) { - id = `r${this.shapes.length}`; + id = keyedHelperName(this, "r", key, ""); const shape: IrRecordShape = { id, fields, @@ -541,6 +546,17 @@ export class ShapeRegistry { } } +/** A recursive checker type's printed form and first declaration, which + * name its placeholder whichever frame first reaches it. */ +function recursiveTypeName(t: ts.Type, ctx: Pick): string { + const symbol = t.getAliasSymbol() ?? t.getSymbol(); + const declaration = symbol?.declarations[0]; + const where = declaration + ? `${ts.getSourceFileOfNode(declaration).fileName}:${declaration.pos}` + : ""; + return `${ctx.checker.typeToString(t)}@${where}`; +} + /** The frontend's union interner — mirrors ShapeRegistry. A union's * canonical identity includes its typeKey-sorted arms and literal * discriminator contract. An arm's index in that list IS its runtime tag. @@ -548,10 +564,12 @@ export class ShapeRegistry { export class UnionRegistry { /** Existing arm/discriminator contracts change when a placeholder closes. */ revision = 0; + /** Each union id with a second hash of its key (keyedHelperName). */ + readonly keyedNameKeys = new Map(); private readonly byKey = new Map(); private readonly byId = new Map(); private readonly armTags = new Map>(); - /** All interned unions in first-seen (`u0`, `u1`, ...) order. */ + /** All interned unions in first-seen order. */ readonly unions: IrUnionDef[] = []; /** ts.Types currently being mapped — a back-reference to one is the * recursive knot passing through a union (`type Tree = Leaf | Branch` @@ -568,10 +586,12 @@ export class UnionRegistry { /** The union id a back-reference to an in-progress union resolves to: * reuses the type's persistent recursive id or mints a PLACEHOLDER * entry (empty arms) the outer frame finalizes. */ - recursiveRef(t: ts.Type): string { + recursiveRef(t: ts.Type, description: string): string { let id = this.recIds.get(t); if (id === undefined) { - id = `u${this.unions.length}`; + id = keyedHelperName(this, "u", `recursive:${description}`, ""); + if (this.byId.has(id)) + throw new InternalCompilerError(`two recursive types share the description ${description}`); const def: IrUnionDef = { id, arms: [] }; this.byId.set(id, def); this.unions.push(def); @@ -621,7 +641,7 @@ export class UnionRegistry { const key = JSON.stringify([arms.map(typeKey), discriminant]); let id = this.byKey.get(key); if (id === undefined) { - id = `u${this.unions.length}`; + id = keyedHelperName(this, "u", key, ""); const def: IrUnionDef = { id, arms, ...(discriminant ? { discriminant } : {}) }; this.byKey.set(key, id); this.byId.set(id, def); @@ -4651,7 +4671,10 @@ function mapTypeInner(type: ts.Type, ctx: TypeMapperCtx): IrType | null { const knownRecursive = unions.recursiveUnionFor(widened); if (knownRecursive !== undefined) return { kind: "union", unionId: knownRecursive }; if (unions.inProgress.has(widened)) { - return { kind: "union", unionId: unions.recursiveRef(widened) }; + return { + kind: "union", + unionId: unions.recursiveRef(widened, recursiveTypeName(widened, ctx)), + }; } unions.inProgress.add(widened); const sensitivityAtEntry = contextResolutions; @@ -6995,7 +7018,10 @@ function mapRecordType(widened: ts.Type, ctx: TypeMapperCtx): IrType | null { // frame completes (finalizeRecursive below). Backends represent records // as heap references, so the self-reference is an ordinary pointer. if (shapes.inProgress.has(widened)) { - return { kind: "record", shapeId: shapes.recursiveRef(widened) }; + return { + kind: "record", + shapeId: shapes.recursiveRef(widened, recursiveTypeName(widened, ctx)), + }; } shapes.inProgress.add(widened); const sensitivityAtEntry = contextResolutions; diff --git a/packages/compiler/test/array-pipeline-fusion.test.ts b/packages/compiler/test/array-pipeline-fusion.test.ts index f5d743265..55cd0025e 100644 --- a/packages/compiler/test/array-pipeline-fusion.test.ts +++ b/packages/compiler/test/array-pipeline-fusion.test.ts @@ -26,7 +26,7 @@ function helperCalls(fn: IrFunction): string[] { everyStmtList(fn.body, { expr: (e) => { if (e.kind === "call" && e.callee.startsWith("%arr.")) - calls.push(e.callee.replace(/\.\d+$/, "")); + calls.push(e.callee.replace(/\.[0-9a-f]+$/, "")); return true; }, stmt: () => true, diff --git a/packages/compiler/test/format-float-arguments.test.ts b/packages/compiler/test/format-float-arguments.test.ts index e59e023ca..6ce9c4bc0 100644 --- a/packages/compiler/test/format-float-arguments.test.ts +++ b/packages/compiler/test/format-float-arguments.test.ts @@ -27,7 +27,7 @@ test("util.format %f lowers a boolean argument once", async () => { const helpers = mod.functions .map((f) => f.name) .filter((name) => name.startsWith("%arr.")) - .map((name) => name.replace(/\.\d+$/, "")) + .map((name) => name.replace(/\.[0-9a-f]+$/, "")) .sort(); expect(helpers).toEqual(["%arr.every", "%arr.some"]); } finally { diff --git a/packages/compiler/test/in-runtime-key-emission.test.ts b/packages/compiler/test/in-runtime-key-emission.test.ts index aebbb2ea4..589685a7a 100644 --- a/packages/compiler/test/in-runtime-key-emission.test.ts +++ b/packages/compiler/test/in-runtime-key-emission.test.ts @@ -55,7 +55,7 @@ const d: Record = {}; d["a"] = 1; console.log(has(d, "a"), has(d, "b")); `); - const helper = body(llvm, /sc_b?f__x25_rec_haskey_\d+/); + const helper = body(llvm, /sc_b?f__x25_rec_haskey_[0-9a-f]+/); expect(helper).toContain("@scr_map_has_str("); // Not a scan over a fresh key snapshot per probe. expect(helper).not.toContain("@scr_map_keys_js_order("); diff --git a/packages/compiler/test/type-mapper-unions.test.ts b/packages/compiler/test/type-mapper-unions.test.ts index c714df4d7..684960002 100644 --- a/packages/compiler/test/type-mapper-unions.test.ts +++ b/packages/compiler/test/type-mapper-unions.test.ts @@ -139,7 +139,8 @@ describe("checker and synthesized optional union identity", () => { nullable.arms.filter((arm) => arm.kind !== "nullT" && arm.kind !== "undefinedT"), ), ).toBe(required.unionId); - expect(nullable.discriminant!.cases.map((entry) => entry.values)).toEqual([ + // Cases follow the arms, which are ordered by their type keys. + expect(nullable.discriminant!.cases.map((entry) => entry.values).sort()).toEqual([ ["a", "alias"], ["b"], ]); From 97e85bf238e4583ce3daff31577e0d20544c0541 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Wed, 21 Oct 2026 23:35:02 -0500 Subject: [PATCH 008/102] Compile js-yaml and smol-toml statically and match Node --- package.json | 3 +- .../compiler/src/backend/llvm/lib-shared.ts | 9 +- .../lowering/builtins/date-classes.ts | 555 ++++++++++++++++++ .../src/frontend/lowering/builtins/dates.ts | 95 ++- .../src/frontend/lowering/builtins/errors.ts | 111 ++++ .../lowering/class-dynamic-dispatch.ts | 114 +++- .../lowering/class-method-mutations.ts | 3 + .../src/frontend/lowering/class-prototypes.ts | 27 + .../frontend/lowering/class-to-primitive.ts | 51 +- .../frontend/lowering/expressions/binary.ts | 53 +- .../lowering/expressions/element-access.ts | 18 +- .../lowering/expressions/object-literals.ts | 3 + .../lowering/expressions/property-access.ts | 70 ++- .../lowering/expressions/relational.ts | 64 +- .../frontend/lowering/expressions/updates.ts | 60 +- .../src/frontend/lowering/lower-calls.ts | 150 ++++- .../src/frontend/lowering/lower-classes.ts | 79 ++- .../src/frontend/lowering/lower-inspect.ts | 11 +- .../src/frontend/lowering/lower-modules.ts | 2 + .../src/frontend/lowering/lower-stmts.ts | 42 +- .../compiler/src/frontend/lowering/lowerer.ts | 28 +- .../src/frontend/lowering/private-brands.ts | 90 ++- .../src/frontend/lowering/surfaces.ts | 1 + packages/compiler/src/ir/builtin-effects.ts | 4 + .../compiler/src/ir/builtin-signatures.ts | 7 + packages/compiler/src/ir/int32-slots.ts | 1 + packages/compiler/src/ir/tiers.ts | 1 + .../7040-es5-error-constructor.mjs.json | 6 + .../7041-error-called-without-new.mjs.json | 6 + ...42-string-method-names-on-objects.mjs.json | 6 + .../tests/corpus/7043-date-set-time.mjs.json | 6 + .../7044-nested-empty-object-maps.mjs.json | 6 + ...045-instanceof-constructor-values.mjs.json | 6 + .../7046-parse-float-extra-arguments.mjs.json | 6 + .../corpus/7047-dynamic-string-index.mjs.json | 6 + .../7048-unary-number-coercions.mjs.json | 6 + .../7049-member-assignment-values.mjs.json | 6 + .../tests/corpus/7050-date-subclass.mjs.json | 6 + .../corpus/7051-date-subclass-typed.ts.json | 6 + .../7052-date-subclass-dynamic.mjs.json | 6 + ...-private-fields-untyped-receivers.mjs.json | 6 + ...054-let-bindings-with-null-writes.mjs.json | 6 + packages/runtime/src/scr_dyn.h | 38 ++ packages/runtime/src/scr_dyn_invoke.c | 10 + packages/runtime/src/scr_inspect.c | 35 +- packages/runtime/src/scr_json.c | 317 +++++++++- packages/runtime/src/scr_lib.c | 178 +++++- pnpm-lock.yaml | 19 +- tests/corpus/7040-es5-error-constructor.mjs | 79 +++ .../corpus/7041-error-called-without-new.mjs | 40 ++ .../7042-string-method-names-on-objects.mjs | 70 +++ tests/corpus/7043-date-set-time.mjs | 28 + .../corpus/7044-nested-empty-object-maps.mjs | 46 ++ .../7045-instanceof-constructor-values.mjs | 43 ++ .../7046-parse-float-extra-arguments.mjs | 9 + tests/corpus/7047-dynamic-string-index.mjs | 21 + tests/corpus/7048-unary-number-coercions.mjs | 34 ++ .../corpus/7049-member-assignment-values.mjs | 20 + tests/corpus/7050-date-subclass.mjs | 69 +++ tests/corpus/7051-date-subclass-typed.ts | 47 ++ tests/corpus/7052-date-subclass-dynamic.mjs | 43 ++ .../7053-private-fields-untyped-receivers.mjs | 72 +++ .../7054-let-bindings-with-null-writes.mjs | 37 ++ tests/fixtures/npm-static/js-yaml-cli.mjs | 63 ++ tests/fixtures/npm-static/smol-toml-cli.mjs | 68 +++ .../7040-es5-error-constructor.mjs.json | 1 + .../7041-error-called-without-new.mjs.json | 1 + ...42-string-method-names-on-objects.mjs.json | 1 + .../corpus-costs/7043-date-set-time.mjs.json | 1 + .../7044-nested-empty-object-maps.mjs.json | 1 + ...045-instanceof-constructor-values.mjs.json | 1 + .../7046-parse-float-extra-arguments.mjs.json | 1 + .../7047-dynamic-string-index.mjs.json | 1 + .../7048-unary-number-coercions.mjs.json | 1 + .../7049-member-assignment-values.mjs.json | 1 + .../corpus-costs/7050-date-subclass.mjs.json | 1 + .../7051-date-subclass-typed.ts.json | 1 + .../7052-date-subclass-dynamic.mjs.json | 1 + ...-private-fields-untyped-receivers.mjs.json | 1 + ...054-let-bindings-with-null-writes.mjs.json | 1 + tests/harness/npm-static-costs.json | 4 + tests/harness/npm-static.test.ts | 32 + 82 files changed, 3065 insertions(+), 114 deletions(-) create mode 100644 packages/compiler/src/frontend/lowering/builtins/date-classes.ts create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7040-es5-error-constructor.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7041-error-called-without-new.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7042-string-method-names-on-objects.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7043-date-set-time.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7044-nested-empty-object-maps.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7045-instanceof-constructor-values.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7046-parse-float-extra-arguments.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7047-dynamic-string-index.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7048-unary-number-coercions.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7049-member-assignment-values.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7050-date-subclass.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7051-date-subclass-typed.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7052-date-subclass-dynamic.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7053-private-fields-untyped-receivers.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7054-let-bindings-with-null-writes.mjs.json create mode 100644 tests/corpus/7040-es5-error-constructor.mjs create mode 100644 tests/corpus/7041-error-called-without-new.mjs create mode 100644 tests/corpus/7042-string-method-names-on-objects.mjs create mode 100644 tests/corpus/7043-date-set-time.mjs create mode 100644 tests/corpus/7044-nested-empty-object-maps.mjs create mode 100644 tests/corpus/7045-instanceof-constructor-values.mjs create mode 100644 tests/corpus/7046-parse-float-extra-arguments.mjs create mode 100644 tests/corpus/7047-dynamic-string-index.mjs create mode 100644 tests/corpus/7048-unary-number-coercions.mjs create mode 100644 tests/corpus/7049-member-assignment-values.mjs create mode 100644 tests/corpus/7050-date-subclass.mjs create mode 100644 tests/corpus/7051-date-subclass-typed.ts create mode 100644 tests/corpus/7052-date-subclass-dynamic.mjs create mode 100644 tests/corpus/7053-private-fields-untyped-receivers.mjs create mode 100644 tests/corpus/7054-let-bindings-with-null-writes.mjs create mode 100644 tests/fixtures/npm-static/js-yaml-cli.mjs create mode 100644 tests/fixtures/npm-static/smol-toml-cli.mjs create mode 100644 tests/harness/corpus-costs/7040-es5-error-constructor.mjs.json create mode 100644 tests/harness/corpus-costs/7041-error-called-without-new.mjs.json create mode 100644 tests/harness/corpus-costs/7042-string-method-names-on-objects.mjs.json create mode 100644 tests/harness/corpus-costs/7043-date-set-time.mjs.json create mode 100644 tests/harness/corpus-costs/7044-nested-empty-object-maps.mjs.json create mode 100644 tests/harness/corpus-costs/7045-instanceof-constructor-values.mjs.json create mode 100644 tests/harness/corpus-costs/7046-parse-float-extra-arguments.mjs.json create mode 100644 tests/harness/corpus-costs/7047-dynamic-string-index.mjs.json create mode 100644 tests/harness/corpus-costs/7048-unary-number-coercions.mjs.json create mode 100644 tests/harness/corpus-costs/7049-member-assignment-values.mjs.json create mode 100644 tests/harness/corpus-costs/7050-date-subclass.mjs.json create mode 100644 tests/harness/corpus-costs/7051-date-subclass-typed.ts.json create mode 100644 tests/harness/corpus-costs/7052-date-subclass-dynamic.mjs.json create mode 100644 tests/harness/corpus-costs/7053-private-fields-untyped-receivers.mjs.json create mode 100644 tests/harness/corpus-costs/7054-let-bindings-with-null-writes.mjs.json diff --git a/package.json b/package.json index 5cc30d9f8..69177e0e6 100644 --- a/package.json +++ b/package.json @@ -40,10 +40,11 @@ "@scriptc/types": "workspace:*", "@types/node": "^24.0.0", "effect": "3.22.2", - "js-yaml": "4.3.0", + "js-yaml": "4.3.2", "oxfmt": "0.71.0", "oxlint": "1.86.0", "rollup": "4.62.2", + "smol-toml": "1.7.1", "three": "0.186.1", "tsx": "^4.19.0", "typescript": "5.9.3", diff --git a/packages/compiler/src/backend/llvm/lib-shared.ts b/packages/compiler/src/backend/llvm/lib-shared.ts index 8bb8bc3aa..5669704d0 100644 --- a/packages/compiler/src/backend/llvm/lib-shared.ts +++ b/packages/compiler/src/backend/llvm/lib-shared.ts @@ -997,12 +997,15 @@ export const LIB_FN_SYMS: Record = { "dyn.nativeSetIs": "scr_dyn_native_set_is", "dyn.nativeMapIs": "scr_dyn_native_map_is", "dyn.nativeUrlIs": "scr_dyn_native_url_is", - "dyn.nativeDateIs": "scr_dyn_native_date_is", + "dyn.nativeDateIs": "scr_dyn_date_instance_is", + "dyn.nativeDateHandleIs": "scr_dyn_native_date_is", "dyn.globalConstructor": "scr_dyn_global_constructor", "dyn.builtinFunction": "scr_dyn_builtin_function", "date.nativeNew": "scr_dyn_native_date_new", "date.nativeNewFields": "scr_dyn_native_date_new_fields", "date.nativeNewValue": "scr_dyn_native_date_new_value", + "date.argumentsTime": "scr_dyn_date_arguments_time", + "date.classOperation": "scr_date_class_operation_install", "date.checkedValue": "scr_dyn_native_date_value", "dyn.nativeRegexIs": "scr_dyn_native_regex_is", "dyn.toString": "scr_dyn_to_string_argument", @@ -1478,6 +1481,10 @@ export const LIB_FN_SYMS: Record = { "dyn.arrayPrototype": "scr_dyn_array_prototype", "dyn.arrayConstructor": "scr_dyn_array_constructor", "dyn.objectPrototype": "scr_dyn_object_prototype", + "dyn.errorPrototype": "scr_dyn_error_prototype", + "dyn.inheritsErrorPrototype": "scr_dyn_inherits_error_prototype", + "dyn.errorCaptureStackTrace": "scr_dyn_error_capture_stack_trace", + "dyn.errorCaptureStackTraceFunction": "scr_dyn_error_capture_stack_trace_function", "dyn.functionApply": "scr_dyn_function_apply", "dyn.builtinMethod": "scr_dyn_builtin_method", "dyn.classPrototype": "scr_dyn_class_prototype", diff --git a/packages/compiler/src/frontend/lowering/builtins/date-classes.ts b/packages/compiler/src/frontend/lowering/builtins/date-classes.ts new file mode 100644 index 000000000..ac6fe33a9 --- /dev/null +++ b/packages/compiler/src/frontend/lowering/builtins/date-classes.ts @@ -0,0 +1,555 @@ +import * as ts from "../../ts7/adapter.js"; +import { type Lowerer } from "../lowerer.js"; +import { locOf } from "../../program.js"; +import { type ClassInfo } from "../lower-classes.js"; +import { DATE_METHOD_HINT, dateJsonType, dateValueMethod } from "./dates.js"; +import { dynUndefinedExpr, varRef } from "../../../ir/build.js"; +import { + BOOL, + DATE_T, + DYN, + F64, + NULL_T, + STRING, + VOID, + typeKey, + type IrExpr, + type IrStmt, + type IrType, + type SrcLoc, +} from "../../../ir/ir.js"; + +/** The hidden field holding the time value of a class declared `extends + * Date`, the first field of its layout. */ +export const DATE_TIME_FIELD = "%time"; + +/** The class declared `extends Date` at the root of `info`'s base chain, or + * null. */ +export function dateRootOf(info: ClassInfo | null | undefined): ClassInfo | null { + for (let c = info ?? null; c; c = c.base) if (c.extendsDate) return c; + return null; +} + +/** Whether the program declares a class that extends Date. */ +export function programDeclaresDateClass(lowerer: Lowerer): boolean { + for (const info of lowerer.classes.values()) if (info.extendsDate) return true; + return false; +} + +/** The Date.prototype methods a class declared `extends Date` inherits. + * Those without a lowering refuse at the call. */ +const DATE_PROTOTYPE_METHODS: ReadonlySet = new Set([ + "getTime", + "valueOf", + "toISOString", + "toUTCString", + "toJSON", + "toString", + "toDateString", + "toTimeString", + "toGMTString", + "toLocaleString", + "toLocaleDateString", + "toLocaleTimeString", + "getFullYear", + "getUTCFullYear", + "getYear", + "getMonth", + "getUTCMonth", + "getDate", + "getUTCDate", + "getDay", + "getUTCDay", + "getHours", + "getUTCHours", + "getMinutes", + "getUTCMinutes", + "getSeconds", + "getUTCSeconds", + "getMilliseconds", + "getUTCMilliseconds", + "getTimezoneOffset", + "setTime", + "setFullYear", + "setUTCFullYear", + "setYear", + "setMonth", + "setUTCMonth", + "setDate", + "setUTCDate", + "setHours", + "setUTCHours", + "setMinutes", + "setUTCMinutes", + "setSeconds", + "setUTCSeconds", + "setMilliseconds", + "setUTCMilliseconds", +]); + +export const DATE_PROTOTYPE_METHOD_NAMES: readonly string[] = [...DATE_PROTOTYPE_METHODS]; + +export function isDatePrototypeMethod(name: string): boolean { + return DATE_PROTOTYPE_METHODS.has(name); +} + +/** Whether `name` is a Date method an instance of `info` inherits from + * Date.prototype: its class chain is rooted at a class declared `extends + * Date` and declares no member of that name. The runtime's view of the + * instance answers it (scr_dyn_date_class_method). */ +export function dateInheritedMember(lowerer: Lowerer, info: ClassInfo, name: string): boolean { + return ( + dateRootOf(info) !== null && + DATE_PROTOTYPE_METHODS.has(name) && + !lowerer.findMethodOn(info, name) && + !info.fields.has(name) + ); +} + +/** super(...args) in a class declared `extends Date`: the time value the + * Date constructor computes from the argument vector `args` (one dyn + * array), stored in the hidden field. */ +export function dateSuperCall(thisRef: IrExpr, info: ClassInfo, args: IrExpr, loc: SrcLoc): IrStmt { + return { + kind: "fieldSet", + obj: thisRef, + className: info.def.name, + field: DATE_TIME_FIELD, + value: { kind: "libCall", fn: "date.argumentsTime", args: [args], type: DATE_T, loc }, + loc, + }; +} + +/** The time value of `receiver`, an instance of a class rooted at `root`. */ +function timeOf(lowerer: Lowerer, receiver: IrExpr, root: ClassInfo, loc: SrcLoc): IrExpr { + return { + kind: "fieldGet", + obj: lowerer.upcastTo(receiver, root.def.name), + className: root.def.name, + field: DATE_TIME_FIELD, + type: DATE_T, + loc, + }; +} + +/** `receiver.name()` with no arguments where the static class `info` does + * not declare `name`: the subclasses of `info` that declare it run theirs, + * any other instance the Date method. `receiver` is a variable read. */ +function instanceMethodCall( + lowerer: Lowerer, + blame: ts.Node, + info: ClassInfo, + receiver: IrExpr, + name: string, + inherited: IrExpr, + loc: SrcLoc, +): IrExpr { + const found = lowerer.findMethodOn(info, name); + if (found) { + if (found.sig.params.length > 0) + lowerer.unsupported( + "SC1090", + blame, + `a '${name}' declaration with parameters in a class that extends Date, called by an inherited Date method`, + ); + const args: IrExpr[] = []; + if (lowerer.overrideBelow(info, name)) { + lowerer.noteVirtualEdge(info, name); + return { + kind: "virtualCall", + className: info.def.name, + method: name, + args: [lowerer.upcastTo(receiver, info.def.name), ...args], + type: found.sig.ret, + loc, + }; + } + lowerer.noteEdge(`%${found.declarer.def.name}.${name}`); + return { + kind: "call", + callee: `%${found.declarer.def.name}.${name}`, + args: [lowerer.upcastTo(receiver, found.declarer.def.name), ...args], + type: found.sig.ret, + loc, + }; + } + let result = inherited; + // Deeper declarations are tested first. + const declaring: ClassInfo[] = []; + const visit = (c: ClassInfo): void => { + for (const sub of c.subclasses) { + if (sub.methods.has(name)) declaring.push(sub); + else visit(sub); + } + }; + visit(info); + for (const sub of declaring) { + const call = instanceMethodCall( + lowerer, + blame, + sub, + { kind: "downcast", value: receiver, type: { kind: "object", className: sub.def.name }, loc }, + name, + inherited, + loc, + ); + const type = result.type; + result = { + kind: "ternary", + cond: { kind: "instanceOf", value: receiver, className: sub.def.name, type: BOOL, loc }, + then: lowerer.coerceToExpected(call, type), + else_: result, + type, + loc, + }; + } + return result; +} + +/** ToNumber of a call argument. */ +function numberArgument(lowerer: Lowerer, node: ts.Expression | undefined, loc: SrcLoc): IrExpr { + if (!node) return { kind: "numLit", value: Number.NaN, type: F64, loc }; + const value = lowerer.lowerExpr(node); + if (value.type.kind === "f64") return value; + if (value.type.kind === "dyn") + return { kind: "libCall", fn: "dyn.toNumberCoerce", args: [value], type: F64, loc }; + if (lowerer.dynConvertible(value.type)) + return { + kind: "libCall", + fn: "dyn.toNumberCoerce", + args: [{ kind: "dynFrom", value, type: DYN, loc }], + type: F64, + loc, + }; + return lowerer.coerceInto(node, value, F64); +} + +/** A Date.prototype method a class rooted at `root` does not declare, + * called on `receiver` (an instance of `info`, evaluated here once). The + * method reads or sets the hidden time value; toJSON calls the instance's + * toISOString, as Date.prototype.toJSON does. */ +export function lowerInheritedDateMethodCall( + lowerer: Lowerer, + call: ts.CallExpression, + name: string, + info: ClassInfo, + receiver: IrExpr, +): IrExpr { + const root = dateRootOf(info)!; + const loc = locOf(call); + const local = lowerer.declareHiddenLocal("%dateReceiver", receiver.type); + const value = varRef(local.id, receiver.type, loc); + const stmts: IrStmt[] = [{ kind: "varDecl", localId: local.id, init: receiver, loc }]; + const args = call.arguments.nodes; + if (args.some(ts.isSpreadElement)) + lowerer.unsupported("SC1090", call, `spread arguments to 'Date.prototype.${name}'`); + const done = (result: IrExpr): IrExpr => ({ + kind: "seqExpr", + stmts, + result, + type: result.type, + loc, + }); + if (name === "setTime") { + const time = lowerer.declareHiddenLocal("%dateTime", DATE_T); + stmts.push( + { + kind: "varDecl", + localId: time.id, + init: { + kind: "libCall", + fn: "date.newMs", + args: [numberArgument(lowerer, args[0], loc)], + type: DATE_T, + loc, + }, + loc, + }, + ...args.slice(1).map((arg): IrStmt => ({ + kind: "exprStmt", + expr: lowerer.lowerExpr(arg), + loc: locOf(arg), + })), + { + kind: "fieldSet", + obj: lowerer.upcastTo(value, root.def.name), + className: root.def.name, + field: DATE_TIME_FIELD, + value: varRef(time.id, DATE_T, loc), + loc, + }, + ); + return done({ + kind: "libCall", + fn: "date.getTime", + args: [varRef(time.id, DATE_T, loc)], + type: F64, + loc, + }); + } + for (const arg of args) { + if (name !== "toJSON") + lowerer.noLowering(`Date.prototype.${name} with arguments`, call, DATE_METHOD_HINT); + stmts.push({ kind: "exprStmt", expr: lowerer.lowerExpr(arg), loc: locOf(arg) }); + } + if (name === "toJSON") return done(dateClassToJson(lowerer, call, info, value, loc)); + const result = dateValueMethod(name, timeOf(lowerer, value, root, loc), loc); + if (!result) lowerer.noLowering(`Date.prototype.${name}`, call, DATE_METHOD_HINT); + return done(result); +} + +/** Date.prototype.toJSON on `value` (a variable read of an instance of + * `info`): null for an invalid time, else the instance's toISOString(). */ +function dateClassToJson( + lowerer: Lowerer, + blame: ts.Node, + info: ClassInfo, + value: IrExpr, + loc: SrcLoc, +): IrExpr { + const root = dateRootOf(info)!; + const time: IrExpr = { + kind: "libCall", + fn: "date.getTime", + args: [timeOf(lowerer, value, root, loc)], + type: F64, + loc, + }; + const type = dateJsonType(lowerer); + const iso = instanceMethodCall( + lowerer, + blame, + info, + value, + "toISOString", + { + kind: "libCall", + fn: "date.toISOStringValue", + args: [timeOf(lowerer, value, root, loc)], + type: STRING, + loc, + }, + loc, + ); + return { + kind: "ternary", + // An invalid date's time value is NaN, the one value unequal to itself. + cond: { kind: "bin", op: "!==", left: time, right: time, type: BOOL, loc }, + then: lowerer.coerceToExpected({ kind: "unitLit", unit: "null", type: NULL_T, loc }, type), + else_: lowerer.coerceToExpected(iso, type), + type, + loc, + }; +} + +/** `super.name(...)` in a class whose base chain declares no `name`, when + * the chain is rooted at a class declared `extends Date`. */ +export function lowerDateSuperMethodCall( + lowerer: Lowerer, + call: ts.CallExpression, + name: string, + cls: ClassInfo, + thisRef: IrExpr, +): IrExpr | null { + if (!dateRootOf(cls) || !isDatePrototypeMethod(name)) return null; + // Date.prototype.toJSON reads this.toISOString, which this class or a + // subclass may declare. + return lowerInheritedDateMethodCall(lowerer, call, name, cls, thisRef); +} + +const DATE_CLASS_TIME = "%date.classTime"; +const DATE_CLASS_METHOD = "%date.classMethod"; + +/** The classes of a program rooted at a class declared `extends Date`. */ +function dateClasses(lowerer: Lowerer): ClassInfo[] { + return [...lowerer.classes.values()].filter( + (info) => !info.def.runtime && !info.generic && dateRootOf(info) !== null, + ); +} + +const PARAMS = ["op", "value", "argument"]; + +/** A lifted `(op, value, argument)` function over checked-dynamic values. */ +function liftOperation(lowerer: Lowerer, name: string, body: IrStmt[], loc: SrcLoc): void { + lowerer.liftedFns.push({ + name, + params: PARAMS.map((p) => ({ localId: p, name: p, type: DYN })), + returnType: DYN, + locals: PARAMS.map((p) => ({ id: p, name: p, type: DYN, mutable: false })), + body, + loc, + }); +} + +function opIs(code: number, loc: SrcLoc): IrExpr { + return { + kind: "bin", + op: "===", + left: { kind: "dynCheck", value: varRef("op", DYN, loc), type: F64, loc }, + right: { kind: "numLit", value: code, type: F64, loc }, + type: BOOL, + loc, + }; +} + +/** Lifts `%date.classMethod(op, value, argument)` when the program declares + * a class that extends Date: ops 2 to 5 call `value`'s toISOString, + * toJSON(argument), toString and valueOf as checked-dynamic method calls, + * which the class dispatch resolves to each class's declarations and the + * runtime to the inherited Date methods. Called before the class dispatch + * runs over the lowered functions. */ +export function noteDateClassMethods(lowerer: Lowerer): void { + if (lowerer.liftedFnNamed(DATE_CLASS_METHOD)) return; + const classes = dateClasses(lowerer); + if (classes.length === 0) return; + const loc = classes[0]!.def.loc; + const value = varRef("value", DYN, loc); + const body: IrStmt[] = ["toISOString", "toJSON", "toString", "valueOf"].map( + (method, index): IrStmt => ({ + kind: "if", + cond: opIs(index + 2, loc), + then: [ + { + kind: "return", + value: { + kind: "dynInvoke", + recv: value, + method, + calleeName: method, + args: method === "toJSON" ? [varRef("argument", DYN, loc)] : [], + type: DYN, + loc, + }, + loc, + }, + ], + else_: null, + loc, + }), + ); + body.push({ kind: "return", value: dynUndefinedExpr(loc), loc }); + liftOperation(lowerer, DATE_CLASS_METHOD, body, loc); +} + +/** %main's installation of the functions the runtime calls for a + * checked-dynamic value that holds an instance of a class declared `extends + * Date` (scr_date_class_operation_install). `%date.classTime(op, value, + * argument)` answers the time value for op 0 (undefined for any other + * value), sets it from the number `argument` for op 1 and answers the + * class's name for op 6; `%date.classMethod` (noteDateClassMethods) calls + * its methods. */ +export function dateClassOperationPrelude(lowerer: Lowerer, loc: SrcLoc): IrStmt[] { + const classes = dateClasses(lowerer); + if (classes.length === 0) return []; + noteDateClassMethods(lowerer); + const value = varRef("value", DYN, loc); + const argument = varRef("argument", DYN, loc); + const body: IrStmt[] = []; + for (const info of classes) { + const root = dateRootOf(info)!; + const type: IrType = { kind: "object", className: info.def.name }; + const instance: IrExpr = { kind: "dynCheck", value, type, loc }; + body.push({ + kind: "if", + cond: { + kind: "libCall", + fn: "dyn.typedRefIs", + args: [value, { kind: "strLit", value: typeKey(type), type: STRING, loc }], + type: BOOL, + loc, + }, + then: [ + { + kind: "if", + cond: opIs(6, loc), + then: [ + { + kind: "return", + value: { + kind: "dynFrom", + value: { + kind: "strLit", + value: info.def.jsName ?? info.def.name, + type: STRING, + loc, + }, + type: DYN, + loc, + }, + loc, + }, + ], + else_: null, + loc, + }, + { + kind: "if", + cond: opIs(1, loc), + then: [ + { + kind: "fieldSet", + obj: lowerer.upcastTo(instance, root.def.name), + className: root.def.name, + field: DATE_TIME_FIELD, + value: { + kind: "libCall", + fn: "date.newMs", + args: [{ kind: "dynCheck", value: argument, type: F64, loc }], + type: DATE_T, + loc, + }, + loc, + }, + ], + else_: null, + loc, + }, + { + kind: "return", + value: { + kind: "dynFrom", + value: { + kind: "libCall", + fn: "date.getTime", + args: [timeOf(lowerer, instance, root, loc)], + type: F64, + loc, + }, + type: DYN, + loc, + }, + loc, + }, + ], + else_: null, + loc, + }); + } + body.push({ kind: "return", value: dynUndefinedExpr(loc), loc }); + liftOperation(lowerer, DATE_CLASS_TIME, body, loc); + const closure = (fnName: string): IrExpr => ({ + kind: "dynFrom", + value: { + kind: "closure", + fnName, + captures: [], + type: { kind: "func", params: [DYN, DYN, DYN], ret: DYN }, + loc, + }, + type: DYN, + loc, + }); + return [ + { + kind: "exprStmt", + expr: { + kind: "libCall", + fn: "date.classOperation", + args: [closure(DATE_CLASS_TIME), closure(DATE_CLASS_METHOD)], + type: VOID, + loc, + }, + loc, + }, + ]; +} diff --git a/packages/compiler/src/frontend/lowering/builtins/dates.ts b/packages/compiler/src/frontend/lowering/builtins/dates.ts index 31be995e7..a598f4ee6 100644 --- a/packages/compiler/src/frontend/lowering/builtins/dates.ts +++ b/packages/compiler/src/frontend/lowering/builtins/dates.ts @@ -1,6 +1,8 @@ import * as ts from "../../ts7/adapter.js"; import { type Lowerer, own } from "../lowerer.js"; import { locOf } from "../../program.js"; +import { tryLowerExpression } from "../expressions/try-lower-expression.js"; +import { programDeclaresDateClass } from "./date-classes.js"; import { BOOL, F64, @@ -9,6 +11,7 @@ import { type IrStmt, type IrType, NULL_T, + type SrcLoc, STRING, typeKey, } from "../../../ir/ir.js"; @@ -39,7 +42,7 @@ const DATE_TEXT_FNS: ReadonlyMap = new Map([ ["toTimeString", "date.toTimeString"], ]); -const DATE_METHOD_HINT = +export const DATE_METHOD_HINT = "getTime(), valueOf(), toISOString(), toUTCString(), toJSON(), toString(), toDateString(), toTimeString(), the local/UTC calendar getters, and getTimezoneOffset() are supported; Date setters and locale formatters have no lowering"; /** The Date slice: statics plus read-only Date values backed by one @@ -52,7 +55,52 @@ export function lowerDateCall( ): IrExpr | null { if (call.questionDotToken || access.questionDotToken) return null; const loc = locOf(call); - if (lowerer.stdlibGlobalMember(access, "Date") === "now") { + const member = lowerer.stdlibGlobalMember(access, "Date"); + if (member === "now" || member === "parse" || member === "UTC") + return lowerDateStaticCall(lowerer, call, member); + if (lowerer.mapTypeOf(lowerer.typeOf(access.expression))?.kind !== "date") return null; + if (!lowerer.isStdlibMember(access)) return null; + const name = access.name.text; + // A Date a JavaScript file constructs is a mutable object; setTime on + // it takes the dynamic method call. So does every Date method on a + // checked-dynamic receiver when the program declares a class that extends + // Date: the value can be an instance, whose class may declare the method. + if ( + (name === "setTime" || programDeclaresDateClass(lowerer)) && + tryLowerExpression(lowerer, access.expression)?.type.kind === "dyn" + ) + return null; + if (name === "toJSON") return lowerDateToJson(lowerer, call, access); + if (call.arguments.nodes.length !== 0) { + lowerer.noLowering(`Date.prototype.${name} with arguments`, call, DATE_METHOD_HINT); + } + const raw = lowerer.lowerExpr(access.expression); + const receiver: IrExpr = + raw.type.kind === "dyn" + ? { kind: "libCall", fn: "date.checkedValue", args: [raw], type: { kind: "date" }, loc } + : raw; + if (receiver.type.kind !== "date") + lowerer.badType(access.expression, lowerer.typeOf(access.expression)); + const result = dateValueMethod(name, receiver, loc); + if (result) return result; + lowerer.noLowering( + `Date.prototype.${name}`, + call, + DATE_METHOD_HINT, + lowerer.checker.getSymbolAtLocation(access.name), + ); +} + +/** Date.now(), Date.parse(text) and Date.UTC(...), also called through a + * class declared `extends Date`, which inherits them. Null for other + * names. */ +export function lowerDateStaticCall( + lowerer: Lowerer, + call: ts.CallExpression, + name: string, +): IrExpr | null { + const loc = locOf(call); + if (name === "now") { if (call.arguments.nodes.length !== 0) { lowerer.noLowering(`Date.now with ${call.arguments.nodes.length} arguments`, call); } @@ -60,7 +108,7 @@ export function lowerDateCall( } // Date.parse uses the same date-string parser as new Date(dateString) // (V8's grammar in the runtime), so their NaN and TimeClip behavior agree. - if (lowerer.stdlibGlobalMember(access, "Date") === "parse") { + if (name === "parse") { if (call.arguments.nodes.length !== 1 || ts.isSpreadElement(call.arguments.nodes[0]!)) { lowerer.noLowering(`Date.parse with ${call.arguments.nodes.length} arguments`, call); } @@ -72,7 +120,7 @@ export function lowerDateCall( // TimeClip. Omitted trailing arguments complete with the spec's // defaults (month 0, date 1, time parts 0); tsc pins every present // argument to number, so the seven-f64 ABI is exact. - if (lowerer.stdlibGlobalMember(access, "Date") === "UTC") { + if (name === "UTC") { if ( call.arguments.nodes.length < 1 || call.arguments.nodes.length > 7 || @@ -92,49 +140,38 @@ export function lowerDateCall( } return { kind: "libCall", fn: "date.utc", args, type: F64, loc }; } - if (lowerer.mapTypeOf(lowerer.typeOf(access.expression))?.kind !== "date") return null; - if (!lowerer.isStdlibMember(access)) return null; - const name = access.name.text; - if (name === "toJSON") return lowerDateToJson(lowerer, call, access); - if (call.arguments.nodes.length !== 0) { - lowerer.noLowering(`Date.prototype.${name} with arguments`, call, DATE_METHOD_HINT); - } - const raw = lowerer.lowerExpr(access.expression); - const receiver: IrExpr = - raw.type.kind === "dyn" - ? { kind: "libCall", fn: "date.checkedValue", args: [raw], type: { kind: "date" }, loc } - : raw; - if (receiver.type.kind !== "date") - lowerer.badType(access.expression, lowerer.typeOf(access.expression)); + return null; +} + +/** The Date methods without arguments that have a lowering, applied to the + * time value `value` (a `date`): getTime, valueOf, toISOString, + * toUTCString, the calendar getters and the text forms. Null for other + * names. */ +export function dateValueMethod(name: string, value: IrExpr, loc: SrcLoc): IrExpr | null { if (name === "getTime" || name === "valueOf") { return { kind: "libCall", fn: name === "getTime" ? "date.getTime" : "date.valueOf", - args: [receiver], + args: [value], type: F64, loc, }; } if (name === "toISOString") { - return { kind: "libCall", fn: "date.toISOStringValue", args: [receiver], type: STRING, loc }; + return { kind: "libCall", fn: "date.toISOStringValue", args: [value], type: STRING, loc }; } if (name === "toUTCString") { - return { kind: "libCall", fn: "date.toUTCString", args: [receiver], type: STRING, loc }; + return { kind: "libCall", fn: "date.toUTCString", args: [value], type: STRING, loc }; } const fn = own(DATE_GETTER_FNS, name); if (fn !== undefined) { - return { kind: "libCall", fn, args: [receiver], type: F64, loc }; + return { kind: "libCall", fn, args: [value], type: F64, loc }; } const textFn = DATE_TEXT_FNS.get(name); if (textFn !== undefined) { - return { kind: "libCall", fn: textFn, args: [receiver], type: STRING, loc }; + return { kind: "libCall", fn: textFn, args: [value], type: STRING, loc }; } - lowerer.noLowering( - `Date.prototype.${name}`, - call, - DATE_METHOD_HINT, - lowerer.checker.getSymbolAtLocation(access.name), - ); + return null; } /** `d.toJSON(key?)`: Node answers null for an invalid date and the diff --git a/packages/compiler/src/frontend/lowering/builtins/errors.ts b/packages/compiler/src/frontend/lowering/builtins/errors.ts index d95442829..1371769d6 100644 --- a/packages/compiler/src/frontend/lowering/builtins/errors.ts +++ b/packages/compiler/src/frontend/lowering/builtins/errors.ts @@ -1,6 +1,8 @@ import * as ts from "../../ts7/adapter.js"; import { type Lowerer } from "../lowerer.js"; import { locOf } from "../../program.js"; +import { tryLowerExpression } from "../expressions/try-lower-expression.js"; +import { dynUndefinedExpr } from "../../../ir/build.js"; import { BOOL, CAUGHT, @@ -8,6 +10,7 @@ import { DYN_CLASS_PROPERTIES, F64, type IrExpr, + type IrStmt, type IrType, STRING, } from "../../../ir/ir.js"; @@ -267,6 +270,114 @@ function isErrorClassType(lowerer: Lowerer, type: IrType): boolean { ); } +/** Error classes that construct when called without `new`. */ +const CALLABLE_ERROR_CLASSES: ReadonlySet = new Set([ + "%Error", + "%TypeError", + "%RangeError", + "%SyntaxError", + "%ReferenceError", + "%EvalError", + "%URIError", +]); + +/** `Error(message?, options?)` and `Error.call(thisArg, message?, options?)` + * (an ES5 constructor function's `Error.call(this)`), and the same for the + * other standard error classes: called as a function, the constructor + * returns a new error and ignores the receiver. `thisArg` is evaluated + * first. Null for other callees. */ +export function lowerErrorFunctionCall(lowerer: Lowerer, call: ts.CallExpression): IrExpr | null { + if (call.questionDotToken) return null; + let callee = call.expression; + let args = call.arguments.nodes; + let thisArg: ts.Expression | undefined; + const viaCall = + ts.isPropertyAccessExpression(callee) && + !callee.questionDotToken && + callee.name.text === "call" && + ts.isIdentifier(callee.expression); + if (viaCall) { + callee = (callee as ts.PropertyAccessExpression).expression; + thisArg = args[0]; + args = args.slice(1); + } + if (!ts.isIdentifier(callee) || args.some(ts.isSpreadElement)) return null; + if (thisArg && ts.isSpreadElement(thisArg)) return null; + const info = lowerer.builtinErrorInfoOf(lowerer.checker.getSymbolAtLocation(callee)); + if (!info || !CALLABLE_ERROR_CLASSES.has(info.def.name)) return null; + const loc = locOf(call); + const stmts: IrStmt[] = []; + if (thisArg) { + const receiver = lowerer.lowerExpr(thisArg); + if (receiver.kind !== "varRef" && receiver.kind !== "unitLit") + stmts.push({ kind: "exprStmt", expr: receiver, loc: receiver.loc }); + } + const error: IrExpr = { + kind: "libCall", + fn: "error.newOptions", + args: lowerer.errorConstructorArgs(args, loc, call), + type: { kind: "object", className: info.def.name }, + loc, + }; + return stmts.length > 0 + ? { kind: "seqExpr", stmts, result: error, type: error.type, loc } + : error; +} + +/** `Error.captureStackTrace(target[, constructorOpt])` (also called as + * `Error.captureStackTrace?.(...)`, which always calls it). On a + * checked-dynamic target (`this` in a JavaScript constructor function) the + * runtime defines target's `stack`. An instance of a class that extends + * Error derives its stack from its name and message when the stack is + * read, so the call only evaluates its arguments. Both arguments are + * evaluated; the second only selects frames in Node. Null for other + * targets and callees. */ +export function lowerErrorCaptureStackTraceCall( + lowerer: Lowerer, + call: ts.CallExpression, + access: ts.PropertyAccessExpression, +): IrExpr | null { + if (access.questionDotToken) return null; + if (lowerer.stdlibGlobalMember(access, "Error") !== "captureStackTrace") return null; + const args = call.arguments.nodes; + if (args.length < 1 || args.length > 2 || args.some(ts.isSpreadElement)) return null; + const probed = tryLowerExpression(lowerer, args[0]!); + const loc = locOf(call); + if ( + probed?.type.kind === "object" && + (probed.type.className === "%Error" || lowerer.isSubclassOf(probed.type.className, "%Error")) + ) { + const stmts: IrStmt[] = []; + for (const arg of args) { + const value = lowerer.lowerExpr(arg); + if (value.kind !== "varRef") stmts.push({ kind: "exprStmt", expr: value, loc: value.loc }); + } + const result = dynUndefinedExpr(loc); + return stmts.length > 0 ? { kind: "seqExpr", stmts, result, type: DYN, loc } : result; + } + if (probed?.type.kind !== "dyn") return null; + const target = lowerer.lowerExpr(args[0]!); + const result: IrExpr = { + kind: "libCall", + fn: "dyn.errorCaptureStackTrace", + args: [target], + type: DYN, + loc, + }; + if (args.length === 1) return result; + const local = lowerer.declareHiddenLocal("%captureTarget", DYN); + return { + kind: "seqExpr", + stmts: [ + { kind: "varDecl", localId: local.id, init: target, loc }, + { kind: "exprStmt", expr: lowerer.lowerExprExpecting(args[1]!, DYN), loc }, + ], + result: { ...result, args: [{ kind: "varRef", localId: local.id, type: DYN, loc }] }, + type: DYN, + loc, + }; +} + /** `Error.isError(value)`. A catch binding tests its payload against the * Error class, an `unknown` value tests the checked-dynamic tree's error * encoding, and a union tests its runtime tag against the arms whose class diff --git a/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts b/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts index c90e1135b..fefe85d0c 100644 --- a/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts +++ b/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts @@ -2,8 +2,17 @@ import { primitiveConstructorOr } from "./lower-exprs.js"; import { dynUndefinedExpr, helperLoc, nodeThrowExpr, varRef } from "../../ir/build.js"; import { constructedValue } from "./constructor-returns.js"; import { eventTargetApiMembers, eventTargetInheritedMember } from "./lower-event-target.js"; +import { + DATE_PROTOTYPE_METHOD_NAMES, + DATE_TIME_FIELD, + dateInheritedMember, + dateRootOf, + programDeclaresDateClass, +} from "./builtins/date-classes.js"; +import { dateValueMethod } from "./builtins/dates.js"; import { BOOL, + DATE_T, DYN, F64, DYN_CLASS_PROPERTIES as PROPERTY_BAG, @@ -296,6 +305,32 @@ export function classInstanceOf( ); const body: IrStmt[] = prototype ? [ + // In a program that declares a class extending Date, a Date can + // meet a class test (`date instanceof Moment`): its prototype + // chain holds no class prototype. + ...(programDeclaresDateClass(lowerer) + ? [ + { + kind: "if" as const, + cond: { + kind: "libCall" as const, + fn: "dyn.nativeDateHandleIs" as const, + args: [varRef("value", DYN, loc)], + type: BOOL, + loc, + }, + then: [ + { + kind: "return" as const, + value: { kind: "boolLit" as const, value: false, type: BOOL, loc }, + loc, + }, + ], + else_: null, + loc, + }, + ] + : []), { kind: "varDecl", localId: "candidate", init: varRef("value", DYN, loc), loc }, { kind: "while", @@ -2871,6 +2906,7 @@ export class ClassDynamicDispatch { !isClassOwnEnumerableFieldName(dispatch.name) || (!(info.builtinStream !== undefined && streamProperty(dispatch.name)) && !eventTargetInheritedMember(info, dispatch.name) && + !dateInheritedMember(lowerer, info, dispatch.name) && !findMethodOn(lowerer, info, dispatch.name) && !findGenericMethodOn(lowerer, info, dispatch.name) && dispatch.name !== "constructor" && @@ -2987,7 +3023,8 @@ export class ClassDynamicDispatch { ]; if ( ((info.builtinStream !== undefined && streamProperty(name)) || - eventTargetInheritedMember(info, name)) && + eventTargetInheritedMember(info, name) || + dateInheritedMember(lowerer, info, name)) && dispatch.probe ) return [ @@ -3200,6 +3237,9 @@ export class ClassDynamicDispatch { for (const name of [...STREAM_BOOL_PROPERTIES, ...STREAM_NUM_PROPERTIES]) names.add(name); const inherited = eventTargetApiMembers(info); if (inherited) for (const name of inherited) names.add(name); + if (dateRootOf(info)) + for (const name of DATE_PROTOTYPE_METHOD_NAMES) + if (dateInheritedMember(lowerer, info, name)) names.add(name); for (let owner: ClassInfo | null = info; owner; owner = owner.base) { const methodNames = [...owner.methods.keys()]; @@ -3863,6 +3903,70 @@ export class ClassDynamicDispatch { ]; return { kind: "if", cond: condition, then: body, else_: null, loc }; } + // Date.prototype[Symbol.toPrimitive] takes "default" as "string", and a + // class declared `extends Date` inherits Date's toString and valueOf, + // which answer primitives from the time value. + const dateRoot = dateRootOf(info); + if (dateRoot) { + const dateOrder: ("valueOf" | "toString")[] = + hint === "number" ? ["valueOf", "toString"] : ["toString", "valueOf"]; + const { receiver } = this.propertyReceiver(plan, loc); + const body: IrStmt[] = []; + for (const method of dateOrder) { + if (!conversionMethod(lowerer, info, method)) { + const time: IrExpr = { + kind: "fieldGet", + obj: upcastTo(lowerer, receiver, dateRoot.def.name), + className: dateRoot.def.name, + field: DATE_TIME_FIELD, + type: DATE_T, + loc, + }; + body.push({ + kind: "return", + value: lowerer.coerceToExpected(dateValueMethod(method, time, loc)!, DYN), + loc, + }); + break; + } + const result = `%toPrimitive.${method}.${helper.locals.length}`; + helper.locals.push({ id: result, name: method, type: DYN, mutable: false }); + body.push( + { + kind: "varDecl", + localId: result, + init: { + kind: "call", + callee: this.toPrimitiveCall(lowerer, plan, method, 0, loc), + args: [varRef("p.0", DYN, loc)], + type: DYN, + loc, + }, + loc, + }, + { + kind: "if", + cond: isPrimitive(varRef(result, DYN, loc), loc), + then: [{ kind: "return", value: varRef(result, DYN, loc), loc }], + else_: null, + loc, + }, + ); + } + if (body.at(-1)?.kind !== "return") + body.push({ + kind: "return", + value: nodeThrowExpr(1, "", "Cannot convert object to primitive value", DYN, loc), + loc, + }); + return { + kind: "if", + cond: this.propertyReceiver(plan, loc).condition, + then: body, + else_: null, + loc, + }; + } const order: ("valueOf" | "toString")[] = hint === "string" ? ["toString", "valueOf"] : ["valueOf", "toString"]; if (!order.some((method) => conversionMethod(lowerer, info, method))) return null; @@ -4731,9 +4835,11 @@ export class ClassDynamicDispatch { ): IrStmt[] { const { name, write } = dispatch; const loc = dispatch.fn.loc; - // The inherited EventTarget/Event members of a subclass instance: the - // runtime's capsule view answers the accessors and method values. - if (eventTargetInheritedMember(info, name)) { + // The inherited EventTarget/Event members of a subclass instance, and + // the inherited Date methods of an instance of a class declared + // `extends Date`: the runtime's capsule view answers the accessors and + // method values. + if (eventTargetInheritedMember(info, name) || dateInheritedMember(lowerer, info, name)) { const key: IrExpr = { kind: "strLit", value: name, type: STRING, loc }; if (!write) return [ diff --git a/packages/compiler/src/frontend/lowering/class-method-mutations.ts b/packages/compiler/src/frontend/lowering/class-method-mutations.ts index cc8700469..abbaf3a75 100644 --- a/packages/compiler/src/frontend/lowering/class-method-mutations.ts +++ b/packages/compiler/src/frontend/lowering/class-method-mutations.ts @@ -1,3 +1,4 @@ +import { isErrorPrototypeValue } from "./class-prototypes.js"; import * as ts from "../ts7/adapter.js"; import { literalValues } from "../literal-values.js"; import { isJsSourceFile } from "../program.js"; @@ -377,6 +378,8 @@ export function collectClassMethodMutations( node.initializer.kind !== ts.SyntaxKind.MissingDeclaration ) markTarget(node.initializer, node); + if (ts.isPropertyAccessExpression(node) && isErrorPrototypeValue(lowerer, node)) + lowerer.errorPrototypeValues = true; if (ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) { const base = unwrap(node.expression); const prototype = diff --git a/packages/compiler/src/frontend/lowering/class-prototypes.ts b/packages/compiler/src/frontend/lowering/class-prototypes.ts index 4cbd8e5cf..2a05cf977 100644 --- a/packages/compiler/src/frontend/lowering/class-prototypes.ts +++ b/packages/compiler/src/frontend/lowering/class-prototypes.ts @@ -457,6 +457,28 @@ export function isCompiledPrototypeMember( ); } +/** `Error.prototype` read as the checked-dynamic object, as a value or for + * a member other than `toString` and `constructor`, which keep the Error + * class's prototype data (`this.toString !== Error.prototype.toString` + * compares class method values). */ +export function isErrorPrototypeValue( + lowerer: Lowerer, + expr: ts.PropertyAccessExpression, +): boolean { + let node: ts.Node = expr; + while (ts.isParenthesizedExpression(node.parent)) node = node.parent; + const parent = node.parent; + return ( + expr.name.text === "prototype" && + lowerer.isStdlibGlobal(expr.expression, "Error") && + !( + ts.isPropertyAccessExpression(parent) && + parent.expression === node && + (parent.name.text === "toString" || parent.name.text === "constructor") + ) + ); +} + /** Named data and method slots have native descriptors. Bare reflection and * accessor replacement still require a complete view of the prototype. */ export function lowerClassPrototypeData( @@ -469,6 +491,11 @@ export function lowerClassPrototypeData( exactClassOfReceiver(lowerer, expr.expression) ?? (stored?.kind === "classval" ? lowerer.classes.get(stored.className) : undefined); if (!info) return null; + // Error.prototype as a value: the checked-dynamic object an ES5 + // constructor function inherits from (`F.prototype = + // Object.create(Error.prototype)`). + if (isErrorPrototypeValue(lowerer, expr)) + return { kind: "libCall", fn: "dyn.errorPrototype", args: [], type: DYN, loc: locOf(expr) }; // EventEmitter.prototype and the stream prototypes: the untyped // constructor's prototype object (builtin-class-dyn.ts). const builtinKind = builtinClassKind(info.def.name); diff --git a/packages/compiler/src/frontend/lowering/class-to-primitive.ts b/packages/compiler/src/frontend/lowering/class-to-primitive.ts index f3a6b23fa..0b107ab4e 100644 --- a/packages/compiler/src/frontend/lowering/class-to-primitive.ts +++ b/packages/compiler/src/frontend/lowering/class-to-primitive.ts @@ -1,10 +1,21 @@ import { varRef } from "../../ir/build.js"; -import { BOOL, DYN, F64, STRING, type IrExpr, type IrStmt, type IrType } from "../../ir/ir.js"; +import { + BOOL, + DATE_T, + DYN, + F64, + STRING, + type IrExpr, + type IrStmt, + type IrType, +} from "../../ir/ir.js"; import * as ts from "../ts7/adapter.js"; import type { Lowerer } from "./lowerer.js"; import { accessorCall, findMethodOn, type ClassInfo } from "./lower-classes.js"; import { isClassCallback } from "./class-callbacks.js"; import { isSafeToRepeat } from "./expressions/evaluation-safety.js"; +import { DATE_TIME_FIELD, dateRootOf } from "./builtins/date-classes.js"; +import { dateValueMethod } from "./builtins/dates.js"; /** The ToPrimitive hint of a conversion: `String(x)` and template literals * take "string", `+` "default", `Number(x)` "number". */ @@ -13,9 +24,12 @@ export type StringConversionHint = "string" | "default"; type ConversionMethod = "sym:toPrimitive" | "valueOf" | "toString"; -/** How an instance of one class converts: through one of its methods, or - * through Object.prototype.toString ("[object Object]"). */ -type Plan = { method: ConversionMethod; ret: IrType } | { method: null }; +/** How an instance of one class converts: through one of its methods, + * through the Date.prototype method `date` of a class declared `extends + * Date`, or through Object.prototype.toString ("[object Object]"). */ +type Plan = + | { method: ConversionMethod; ret: IrType } + | { method: null; date?: "toString" | "valueOf" }; const PRIMITIVE_KINDS = new Set(["f64", "string", "bool", "bigint", "undefinedT", "nullT"]); @@ -138,6 +152,18 @@ function classConversion( } const convert = (cls: ClassInfo, object: IrExpr): IrExpr => { const plan = plans.get(cls)!; + if (plan.method === null && plan.date) { + const root = dateRootOf(cls)!; + const time: IrExpr = { + kind: "fieldGet", + obj: lowerer.upcastTo(object, root.def.name), + className: root.def.name, + field: DATE_TIME_FIELD, + type: DATE_T, + loc, + }; + return finish(dateValueMethod(plan.date, time, loc)!); + } if (plan.method === null) return finish({ kind: "strLit", value: "[object Object]", type: STRING, loc }); const args: IrExpr[] = @@ -202,7 +228,10 @@ function depth(info: ClassInfo): number { } function samePlan(a: Plan, b: Plan): boolean { - return a.method === b.method; + return ( + a.method === b.method && + (a.method !== null || b.method !== null || a.date === (b as { date?: string }).date) + ); } /** A conversion method the class declares or inherits (a field of that @@ -227,11 +256,17 @@ function planOf(lowerer: Lowerer, info: ClassInfo, hint: ConversionHint, node: t // OrdinaryToPrimitive: "string" tries toString first, which every object // has (Object.prototype.toString answers a string); "default" and // "number" try valueOf first, whose Object.prototype version answers the - // object itself. - const order: ConversionMethod[] = hint === "string" ? ["toString"] : ["valueOf", "toString"]; + // object itself. Date.prototype[Symbol.toPrimitive] takes "default" as + // "string", and Date.prototype answers both methods with primitives. + const date = dateRootOf(info) !== null; + const order: ConversionMethod[] = + hint === "string" || (date && hint === "default") ? ["toString"] : ["valueOf", "toString"]; for (const method of order) { const found = declared(lowerer, info, method); - if (!found) continue; + if (!found) { + if (date && method !== "sym:toPrimitive") return { method: null, date: method }; + continue; + } if (!primitive(lowerer, found.ret)) refuse(lowerer, node, info, `a '${method}' method that can return an object`); return { method, ret: found.ret }; diff --git a/packages/compiler/src/frontend/lowering/expressions/binary.ts b/packages/compiler/src/frontend/lowering/expressions/binary.ts index fafbbf695..ead313a78 100644 --- a/packages/compiler/src/frontend/lowering/expressions/binary.ts +++ b/packages/compiler/src/frontend/lowering/expressions/binary.ts @@ -902,10 +902,15 @@ export function lowerCompoundValueToTarget( // operator on both values, then the checked conversion into the // target's declared type (a string result for a number target throws the // catchable TypeError, as the expanded assignment does). + // A union operand (`fraction += "0"` on a binding the program assigns + // both a number and a string) takes the same runtime operator. if ( - (target.type.kind === "dyn" || rhs.type.kind === "dyn") && - (isJsSourceFile(ts.getSourceFileOfNode(expr)) || - (lowerer.dynConvertible(read.type) && lowerer.dynConvertible(rhs.type))) + ((target.type.kind === "dyn" || rhs.type.kind === "dyn") && + (isJsSourceFile(ts.getSourceFileOfNode(expr)) || + (lowerer.dynConvertible(read.type) && lowerer.dynConvertible(rhs.type)))) || + ((target.type.kind === "union" || rhs.type.kind === "union") && + lowerer.dynConvertible(read.type) && + lowerer.dynConvertible(rhs.type)) ) { const left = lowerer.coerceInto(expr.left, read, DYN); const right = lowerer.coerceInto(expr.right, rhs, DYN); @@ -1276,6 +1281,48 @@ export function lowerBinary(lowerer: Lowerer, expr: ts.BinaryExpression): IrExpr loc, }; } + // `a[k] = b[k] = v` in a JavaScript file: a member write in value + // position lowers as its statement form and yields the value. The + // receiver, the key and the value are evaluated in that order into + // temporaries first. A receiver held in a temporary must be a + // checked-dynamic value, which the temporary shares; any other receiver + // must be a variable or `this`. + if ( + op === ts.SyntaxKind.EqualsToken && + isJsSourceFile(ts.getSourceFileOfNode(expr)) && + (ts.isPropertyAccessExpression(expr.left) || ts.isElementAccessExpression(expr.left)) && + !expr.left.questionDotToken + ) { + const target = expr.left; + const receiverNode = target.expression; + const bareReceiver = + ts.isIdentifier(receiverNode) || receiverNode.kind === ts.SyntaxKind.ThisKeyword; + if (bareReceiver || tryLowerExpression(lowerer, receiverNode)?.type.kind === "dyn") { + const stmts: IrStmt[] = []; + const overrides: { node: ts.Expression; value: IrExpr }[] = []; + const hold = (node: ts.Expression, name: string): IrExpr => { + const value = lowerer.lowerExpr(node); + const local = lowerer.declareHiddenLocal(name, value.type); + stmts.push({ kind: "varDecl", localId: local.id, init: value, loc: value.loc }); + const held = varRef(local.id, value.type, value.loc); + overrides.push({ node, value: held }); + return held; + }; + if (!bareReceiver) hold(receiverNode, "%assignReceiver"); + if ( + ts.isElementAccessExpression(target) && + !ts.isIdentifier(target.argumentExpression) && + !ts.isStringLiteral(target.argumentExpression) && + !ts.isNumericLiteral(target.argumentExpression) + ) + hold(target.argumentExpression, "%assignKey"); + const result = hold(expr.right, "%assignValue"); + stmts.push( + lowerer.withExpressionOverrides(overrides, () => lowerer.lowerExprStatement(expr)), + ); + return { kind: "seqExpr", stmts, result, type: result.type, loc }; + } + } lowerer.unsupported( "SC1090", expr, diff --git a/packages/compiler/src/frontend/lowering/expressions/element-access.ts b/packages/compiler/src/frontend/lowering/expressions/element-access.ts index 74f0be955..3ca1471ae 100644 --- a/packages/compiler/src/frontend/lowering/expressions/element-access.ts +++ b/packages/compiler/src/frontend/lowering/expressions/element-access.ts @@ -616,9 +616,25 @@ export function lowerElementAccess(lowerer: Lowerer, expr: ts.ElementAccessExpre // An indexed string property is absent for non-integer and missing // indexes. charAt has different coercion and out-of-range semantics. const recv = lowerer.lowerExpr(expr.expression); + const rawIndex = lowerer.lowerExpr(expr.argumentExpression); + // A checked-dynamic index (an untyped JavaScript parameter, a parsed + // value) reads the property its key names, as JavaScript does: a code + // unit for an integer index, the length for "length", else undefined. + // The checker's string type does not describe those results, so the + // value stays checked-dynamic and consumers convert it. + if (rawIndex.type.kind === "dyn" && lowerer.dynConvertible(recv.type)) { + const key = lowerRecordPropertyKey(lowerer, rawIndex, expr.argumentExpression); + return { + kind: "dynKeyGet", + value: lowerer.coerceInto(expr.expression, recv, DYN), + key, + type: DYN, + loc: locOf(expr), + }; + } const index = lowerOptionalNumber( lowerer, - lowerer.lowerExpr(expr.argumentExpression), + rawIndex, locOf(expr.argumentExpression), expr.argumentExpression, ); diff --git a/packages/compiler/src/frontend/lowering/expressions/object-literals.ts b/packages/compiler/src/frontend/lowering/expressions/object-literals.ts index 565db0cd8..e4f7d8675 100644 --- a/packages/compiler/src/frontend/lowering/expressions/object-literals.ts +++ b/packages/compiler/src/frontend/lowering/expressions/object-literals.ts @@ -797,6 +797,7 @@ export function lowerObjectLiteral( ): IrExpr { // Unannotated JavaScript accumulator fields have no element contract. // Preserve their checked arrays instead of assigning never[] a numeric ABI. + // An empty object field is a map the program adds keys to. if ( !expected && isJsSourceFile(ts.getSourceFileOfNode(expr)) && @@ -805,6 +806,8 @@ export function lowerObjectLiteral( ts.isPropertyAssignment(prop) && ((ts.isArrayLiteralExpression(prop.initializer) && prop.initializer.elements.nodes.length === 0) || + (ts.isObjectLiteralExpression(prop.initializer) && + prop.initializer.properties.nodes.length === 0) || neverTaintedJsType(lowerer, prop.initializer, lowerer.typeOf(prop.initializer))), ) ) { diff --git a/packages/compiler/src/frontend/lowering/expressions/property-access.ts b/packages/compiler/src/frontend/lowering/expressions/property-access.ts index f0b980da0..895ff5f45 100644 --- a/packages/compiler/src/frontend/lowering/expressions/property-access.ts +++ b/packages/compiler/src/frontend/lowering/expressions/property-access.ts @@ -5,7 +5,11 @@ import { lowerHistogramProperty } from "../builtins/performance.js"; import { staticFunctionNameRead } from "../static-function-names.js"; import { typedArgumentsArity } from "../typed-arguments.js"; import { isThisParameter } from "../call-signatures.js"; -import { localPrivateBrandClass } from "../private-brands.js"; +import { + checkedPrivateValue, + localPrivateBrandClass, + privateNameClass, +} from "../private-brands.js"; import { type Lowerer, PoisonError, jsFuncNameOf, neverTaintedJsType, own } from "../lowerer.js"; import { ARRAY_METHODS, @@ -90,7 +94,7 @@ import { runtimeConstructorReceiver, } from "../builtins/runtime-constructor.js"; import { findGenericMethodOn, lowerStaticFieldRead } from "../lower-classes.js"; -import { lowerClassPrototypeData } from "../class-prototypes.js"; +import { isErrorPrototypeValue, lowerClassPrototypeData } from "../class-prototypes.js"; import { lowerEnumAccess } from "../lower-enums.js"; import { hasOptionalChainGuard, @@ -281,6 +285,24 @@ export function lowerPropertyAccessExpr( expr: ts.PropertyAccessExpression, loc: SrcLoc, ): IrExpr { + // `value.#x` on a checked-dynamic value, or on a checked extraction of + // one: the field of the brand-checked receiver (checkedPrivateValue). + if (ts.isPrivateIdentifier(expr.name)) { + const owner = privateNameClass(lowerer, expr.name); + const field = owner?.fields.get(expr.name.text); + const probed = field ? tryLowerExpression(lowerer, expr.expression) : null; + if (owner && field && probed && checkedDynamicValue(probed)) { + const value = checkedDynamicValue(lowerer.lowerExpr(expr.expression))!; + return { + kind: "fieldGet", + obj: checkedPrivateValue(lowerer, owner, expr, value, loc), + className: owner.def.name, + field: expr.name.text, + type: field, + loc, + }; + } + } if (!expr.questionDotToken) { const navigator = lowerNavigatorMember(lowerer, expr, NODE_COMPAT_VERSION); if (navigator) return navigator; @@ -1664,6 +1686,19 @@ export function lowerIntrinsicProperty( return { kind: "libCall", fn: "dyn.arrayPrototype", args: [], type: DYN, loc: locOf(expr) }; if (lowerer.stdlibGlobalMember(expr, "Object") === "prototype") return { kind: "libCall", fn: "dyn.objectPrototype", args: [], type: DYN, loc: locOf(expr) }; + // Error.prototype as a value (`F.prototype = Object.create(Error.prototype)`) + // and Error.captureStackTrace read as a function (`if + // (Error.captureStackTrace) ...`). + if (isErrorPrototypeValue(lowerer, expr)) + return { kind: "libCall", fn: "dyn.errorPrototype", args: [], type: DYN, loc: locOf(expr) }; + if (lowerer.stdlibGlobalMember(expr, "Error") === "captureStackTrace") + return { + kind: "libCall", + fn: "dyn.errorCaptureStackTraceFunction", + args: [], + type: DYN, + loc: locOf(expr), + }; // Function.prototype as a VALUE (a prototype-chain link: // `Object.setPrototypeOf(F.prototype, Function.prototype)`): one // anonymous function answering undefined, length 0 — a zero-capture @@ -3533,6 +3568,13 @@ export function classFieldTarget( * known class instance OR a record, and the member is a field or (class * receivers) a declared accessor property. Returns the pieces of a * fieldSet/recordSet/accessor-call (minus value/kind) or null. */ +/** The checked-dynamic value `expr` reads: itself, or the value a checked + * extraction validates. Null for other expressions. */ +function checkedDynamicValue(expr: IrExpr): IrExpr | null { + if (expr.type.kind === "dyn") return expr; + return expr.kind === "dynCheck" && expr.value.type.kind === "dyn" ? expr.value : null; +} + export function fieldTarget( lowerer: Lowerer, access: ts.PropertyAccessExpression, @@ -3569,6 +3611,30 @@ export function fieldTarget( return classFieldTarget(lowerer, access.expression, ownerType, access.name.text); } } + // `value.#x = v` on a checked-dynamic value: the field of the + // brand-checked receiver (checkedPrivateValue). + if (ts.isPrivateIdentifier(access.name)) { + const owner = privateNameClass(lowerer, access.name); + const probed = owner?.fields.has(access.name.text) + ? tryLowerExpression(lowerer, access.expression) + : null; + if (owner && probed && checkedDynamicValue(probed)) { + const receiver = checkedPrivateValue( + lowerer, + owner, + access, + checkedDynamicValue(lowerer.lowerExpr(access.expression))!, + locOf(access), + ); + return classFieldTarget( + lowerer, + access.expression, + { kind: "object", className: owner.def.name }, + access.name.text, + receiver, + ); + } + } const stored = ts.isIdentifier(access.expression) ? (lowerer.peekLocal(access.expression)?.type ?? lowerer.globalOf(access.expression)?.type) : undefined; diff --git a/packages/compiler/src/frontend/lowering/expressions/relational.ts b/packages/compiler/src/frontend/lowering/expressions/relational.ts index 088b45cff..37478be0d 100644 --- a/packages/compiler/src/frontend/lowering/expressions/relational.ts +++ b/packages/compiler/src/frontend/lowering/expressions/relational.ts @@ -1,4 +1,5 @@ /* instanceof and in, including private-name and runtime-key in. */ +import { dateRootOf } from "../builtins/date-classes.js"; import * as ts from "../../ts7/adapter.js"; import { builtinClassInstanceOfAny, builtinClassKind } from "../builtins/builtin-class-dyn.js"; import { @@ -265,7 +266,12 @@ export function lowerInstanceOf(lowerer: Lowerer, expr: ts.BinaryExpression, loc stmts: [{ kind: "exprStmt", expr: value, loc }], result: { kind: "boolLit", - value: value.type.kind === (date ? "date" : "url"), + value: + value.type.kind === (date ? "date" : "url") || + // An instance of a class declared `extends Date`. + (date && + value.type.kind === "object" && + dateRootOf(lowerer.classes.get(value.type.className)) !== null), type: BOOL, loc, }, @@ -565,7 +571,33 @@ export function lowerInstanceOf(lowerer: Lowerer, expr: ts.BinaryExpression, loc loc, }; }; - const test = caughtInstanceOf(target); + let test = caughtInstanceOf(target); + // A thrown checked-dynamic object whose prototype chain reaches + // Error.prototype (an ES5 constructor function inheriting from it). + if (target.def.name === "%Error" && lowerer.errorPrototypeValues) { + const value = varRef(caughtLocal.id, CAUGHT, loc); + test = { + kind: "logical", + op: "||", + left: test, + right: { + kind: "logical", + op: "&&", + left: { kind: "caughtTest", value, test: "dynamic", type: BOOL, loc }, + right: { + kind: "libCall", + fn: "dyn.inheritsErrorPrototype", + args: [{ kind: "caughtToDyn", value, type: DYN, loc }], + type: BOOL, + loc, + }, + type: BOOL, + loc, + }, + type: BOOL, + loc, + }; + } return duplex ? { kind: "logical", op: "||", left: test, right: caughtInstanceOf(duplex), type: BOOL, loc } : test; @@ -590,9 +622,35 @@ export function lowerInstanceOf(lowerer: Lowerer, expr: ts.BinaryExpression, loc ) { return classInstanceOf(lowerer, left, target, loc); } - if (left.type.kind === "dyn" && target.def.name === "%Error") { + if (left.type.kind === "dyn" && target.def.name === "%Error" && !lowerer.errorPrototypeValues) { return { kind: "dynTest", test: "error", value: left, type: BOOL, loc }; } + // An object whose prototype chain reaches Error.prototype (an ES5 + // constructor function inheriting from it) is an instance as well. + if (left.type.kind === "dyn" && target.def.name === "%Error") { + const local = lowerer.declareHiddenLocal("%instanceofValue", DYN); + const value = varRef(local.id, DYN, loc); + return { + kind: "seqExpr", + stmts: [{ kind: "varDecl", localId: local.id, init: left, loc }], + result: { + kind: "logical", + op: "||", + left: { kind: "dynTest", test: "error", value, type: BOOL, loc }, + right: { + kind: "libCall", + fn: "dyn.inheritsErrorPrototype", + args: [value], + type: BOOL, + loc, + }, + type: BOOL, + loc, + }, + type: BOOL, + loc, + }; + } // `u instanceof TypeError` (and the other BUILTIN error classes) on a // dyn value: the from_error cache holds the checked-dynamic tree↔error identity edge, // so the runtime resolves the encoding back to its error and asks the diff --git a/packages/compiler/src/frontend/lowering/expressions/updates.ts b/packages/compiler/src/frontend/lowering/expressions/updates.ts index 13baca7d2..128093dad 100644 --- a/packages/compiler/src/frontend/lowering/expressions/updates.ts +++ b/packages/compiler/src/frontend/lowering/expressions/updates.ts @@ -23,6 +23,7 @@ import { type IrExpr, type IrStmt, type IrType, + isUnitType, STRING, type SrcLoc, UNDEFINED_T, @@ -100,6 +101,27 @@ function writeFree(expr: IrExpr): boolean { } } +/** A union unary `+`/`-` converts with the runtime's ToNumber: one with an + * arm other than numbers and units (`string | undefined`). Number and unit + * unions keep their native lowering. */ +function coercedUnion(lowerer: Lowerer, type: IrType): boolean { + if (type.kind !== "union" || !lowerer.dynConvertible(type)) return false; + const arms = lowerer.unions.get(type.unionId)?.arms ?? []; + return arms.some((arm) => arm.kind !== "f64" && !isUnitType(arm)); +} + +/** ToNumber of a boolean: 1 for true, 0 for false. */ +function booleanToNumber(value: IrExpr, loc: SrcLoc): IrExpr { + return { + kind: "ternary", + cond: value, + then: { kind: "numLit", value: 1, type: F64, loc }, + else_: { kind: "numLit", value: 0, type: F64, loc }, + type: F64, + loc, + }; +} + export function lowerPrefixUnary(lowerer: Lowerer, expr: ts.PrefixUnaryExpression): IrExpr { const loc = locOf(expr); switch (expr.operator) { @@ -111,9 +133,25 @@ export function lowerPrefixUnary(lowerer: Lowerer, expr: ts.PrefixUnaryExpressio } // Match the checked numeric boundary used by JS binary arithmetic. const operand = - raw.type.kind === "dyn" && isJsSourceFile(ts.getSourceFileOfNode(expr)) - ? { kind: "dynCheck" as const, value: raw, type: F64, loc } - : lowerOptionalNumber(lowerer, raw, loc, expr.operand); + raw.type.kind === "bool" + ? booleanToNumber(raw, loc) + : coercedUnion(lowerer, raw.type) + ? ({ + kind: "libCall", + fn: "dyn.toNumberCoerce", + args: [{ kind: "dynFrom", value: raw, type: DYN, loc }], + type: F64, + loc, + } satisfies IrExpr) + : raw.type.kind === "dyn" && isJsSourceFile(ts.getSourceFileOfNode(expr)) + ? ({ + kind: "libCall", + fn: "dyn.toNumberCoerce", + args: [raw], + type: F64, + loc, + } satisfies IrExpr) + : lowerOptionalNumber(lowerer, raw, loc, expr.operand); if (operand.type.kind !== "f64") operatorUnsupported(lowerer, expr, "-", [raw.type]); if (operand.kind === "numLit") return { ...operand, value: -operand.value, loc }; return { kind: "unary", op: "-", operand, type: F64, loc }; @@ -123,6 +161,12 @@ export function lowerPrefixUnary(lowerer: Lowerer, expr: ts.PrefixUnaryExpressio if (raw.type.kind === "dyn") { return { kind: "libCall", fn: "dyn.toNumberCoerce", args: [raw], type: F64, loc }; } + // A union of primitives (`+match[1]` over `string | undefined`): ToNumber + // over the boxed value, as for a checked-dynamic operand. + if (coercedUnion(lowerer, raw.type)) { + const boxed: IrExpr = { kind: "dynFrom", value: raw, type: DYN, loc }; + return { kind: "libCall", fn: "dyn.toNumberCoerce", args: [boxed], type: F64, loc }; + } // Unary + is ToNumber; on an already-number operand it's identity, // and a STRING operand runs the runtime's ECMA-exact StringToNumber // (num.fromString — Number(aString)'s lowering, scr_string.c). @@ -130,6 +174,7 @@ export function lowerPrefixUnary(lowerer: Lowerer, expr: ts.PrefixUnaryExpressio if (raw.type.kind === "string") { return { kind: "libCall", fn: "num.fromString", args: [raw], type: F64, loc }; } + if (raw.type.kind === "bool") return booleanToNumber(raw, loc); const classNumber = classToNumberConversion(lowerer, raw, expr.operand, "unary plus"); if (classNumber) return classNumber; const operand = lowerOptionalNumber(lowerer, raw, loc, expr.operand); @@ -321,9 +366,13 @@ export function lowerIncDec( !isJsSourceFile(ts.getSourceFileOfNode(expr)) && raw.type.kind === "dyn" && lowerer.mapTypeOf(lowerer.typeOf(access))?.kind === "f64"; + // A private name is the field of its class (fieldTarget). + const privateName = + ts.isPropertyAccessExpression(access) && ts.isPrivateIdentifier(access.name); if ( (isJsSourceFile(ts.getSourceFileOfNode(expr)) || checkedNumber) && - raw.type.kind === "dyn" + raw.type.kind === "dyn" && + !privateName ) { const receiver = save(raw, "%incrementReceiver"); const key = save( @@ -814,7 +863,8 @@ export function lowerFieldCompoundValue( probed?.type.kind === "classval" ? lowerer.classes.get(probed.type.className) : undefined; if (probed && staticClass && hasRuntimeStatics(staticClass)) probed = lowerer.coerceToExpected(probed, DYN); - if (probed?.type.kind === "dyn") { + // A private name is the field of its class (fieldTarget). + if (probed?.type.kind === "dyn" && !ts.isPrivateIdentifier(access.name)) { const receiver = save(probed, "%compoundReceiver"); const key: IrExpr = { kind: "strLit", diff --git a/packages/compiler/src/frontend/lowering/lower-calls.ts b/packages/compiler/src/frontend/lowering/lower-calls.ts index 7102f37ab..21b974e31 100644 --- a/packages/compiler/src/frontend/lowering/lower-calls.ts +++ b/packages/compiler/src/frontend/lowering/lower-calls.ts @@ -141,7 +141,7 @@ import { lowerCryptoHashMethodCall, lowerPromisifiedCryptoCall, } from "./builtins/crypto.js"; -import { lowerErrorIsErrorCall } from "./builtins/errors.js"; +import { lowerErrorCaptureStackTraceCall, lowerErrorIsErrorCall } from "./builtins/errors.js"; import { lowerPromisifiedDnsCall } from "./lower-dgram.js"; import { lowerDisposableStackUseCall } from "./builtins/disposable-stack.js"; import { @@ -199,6 +199,11 @@ import { import { classCallbackCall, isClassCallback } from "./class-callbacks.js"; import { emitterRooted, lowerEmitterMethodCall } from "./lower-event-emitter.js"; import { eventTargetApiMethod, lowerEventTargetMethodCall } from "./lower-event-target.js"; +import { + dateRootOf, + isDatePrototypeMethod, + lowerInheritedDateMethodCall, +} from "./builtins/date-classes.js"; import { lowerConsoleInstanceCall, lowerConsoleMethodCall, @@ -1554,6 +1559,7 @@ export function lowerCall(lowerer: Lowerer, expr: ts.CallExpression): IrExpr { lowerer.lowerFilterNarrowCall(expr, expr.expression) ?? lowerArrayIsArrayCall(lowerer, expr, expr.expression) ?? lowerErrorIsErrorCall(lowerer, expr, expr.expression) ?? + lowerErrorCaptureStackTraceCall(lowerer, expr, expr.expression) ?? lowerBigIntMethodCall(lowerer, expr, expr.expression) ?? lowerSymbolStaticCall(lowerer, expr, expr.expression) ?? lowerSymbolMethodCall(lowerer, expr, expr.expression) ?? @@ -3727,6 +3733,18 @@ function lowerDynReceiverMethodCall( // IS Node's semantics for every possible dyn value. Shared names would // need a receiver-kind dispatch — they keep the fence. if (DYN_STRING_ONLY_METHODS.has(access.name.text) && !ownCallable) { + // An object-typed receiver the member is missing from (a JavaScript + // module object whose members are assigned in a function body, + // `common.repeat(" ", n)`) holds a string or an object with that + // member: dispatch on the receiver's runtime kind. + if ( + !checkerUntyped && + (lowerer.typeOf(access).flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0 && + !call.questionDotToken && + !access.questionDotToken && + !call.arguments.nodes.some(ts.isSpreadElement) + ) + return lowerStringOrMemberCall(lowerer, call, access, recv); const checked = (): IrExpr => dynStringReceiver(lowerer, recv, access); return ( lowerRegexMethodCall(lowerer, call, access, checked) ?? @@ -3935,6 +3953,98 @@ function lowerDynReceiverMethodCall( }; } +/** `value.name(...args)` on a dyn receiver that may be a string or an + * object: a string runs the String.prototype lowering, any other value + * calls its member. The member is read before the arguments are + * evaluated, and the arguments are evaluated once for either branch. */ +function lowerStringOrMemberCall( + lowerer: Lowerer, + call: ts.CallExpression, + access: ts.PropertyAccessExpression, + recv: IrExpr, +): IrExpr { + const loc = locOf(call); + const receiverLocal = lowerer.declareHiddenLocal("%dynCallReceiver", DYN); + const receiver = varRef(receiverLocal.id, DYN, loc); + const isString: IrExpr = { kind: "dynTest", test: "string", value: receiver, type: BOOL, loc }; + const calleeLocal = lowerer.declareHiddenLocal("%dynCallCallee", DYN); + const callee = varRef(calleeLocal.id, DYN, loc); + const stmts: IrStmt[] = [ + { kind: "varDecl", localId: receiverLocal.id, init: recv, loc }, + { + kind: "varDecl", + localId: calleeLocal.id, + init: { + kind: "ternary", + cond: isString, + then: dynUndefinedExpr(loc), + else_: { + kind: "dynKeyGet", + key: { kind: "strLit", value: access.name.text, type: STRING, loc: locOf(access) }, + value: receiver, + type: DYN, + loc: locOf(access), + }, + type: DYN, + loc, + }, + loc, + }, + ]; + const args = call.arguments.nodes.map((node) => { + const value = lowerer.lowerExpr(node); + const local = lowerer.declareHiddenLocal("%dynCallArg", value.type); + stmts.push({ kind: "varDecl", localId: local.id, init: value, loc: value.loc }); + return { node, value: varRef(local.id, value.type, value.loc) }; + }); + // String.prototype methods ignore arguments past the ones they read. + const arity = DYN_STRING_ONLY_ARITY[access.name.text] ?? call.arguments.nodes.length; + const stringReceiver = (): IrExpr => ({ kind: "dynCheck", value: receiver, type: STRING, loc }); + const lowerString = (): IrExpr | null => + (call.arguments.nodes.length <= arity + ? lowerRegexMethodCall(lowerer, call, access, stringReceiver) + : null) ?? + lowerStringMethodCall( + lowerer, + call, + access, + stringReceiver, + call.arguments.nodes.slice(0, arity), + ); + const stringCall = lowerer.withExpressionOverrides(args, lowerString); + const memberCall: IrExpr = { + kind: "dynCall", + callee, + receiver, + calleeName: ts.getTextOfNode(access), + args: args.map((arg) => lowerer.coerceToExpected(arg.value, DYN)), + type: DYN, + loc, + }; + return { + kind: "seqExpr", + stmts, + result: { + kind: "ternary", + cond: isString, + then: stringCall + ? lowerer.coerceToExpected(stringCall, DYN) + : nodeThrowExpr( + 0, + "SC1090", + `method calls like '${ts.getTextOfNode(access)}' on a string are not supported yet [SC1090 at ${ts.getSourceFileOfNode(call).fileName}:${ts.getLineAndCharacterOfPosition(ts.getSourceFileOfNode(call), ts.tokenStartOfNode(call)).line + 1}]`, + DYN, + loc, + ), + else_: memberCall, + type: DYN, + loc, + }, + type: DYN, + loc, + }; +} + /** Prototype method names of the checked-dynamic tree-representable kinds (String, Array, * Object, Function, Number prototypes): a dyn receiver call on one of * these could be a REAL method on a real value, which a stored-member @@ -4372,6 +4482,29 @@ function isStringMethodName(name: string): boolean { ); } +/** How many arguments each DYN_STRING_ONLY_METHODS method reads. */ +const DYN_STRING_ONLY_ARITY: Readonly> = { + charCodeAt: 1, + charAt: 1, + startsWith: 2, + endsWith: 2, + substring: 2, + repeat: 1, + trim: 0, + trimStart: 0, + trimEnd: 0, + split: 2, + padStart: 2, + padEnd: 2, + toLowerCase: 0, + toUpperCase: 0, + replace: 2, + replaceAll: 2, + match: 1, + matchAll: 1, + search: 1, +}; + /** STR_METHODS ∪ the regex-form names, MINUS everything Array (or any * other dyn kind's prototype) also declares. */ const DYN_STRING_ONLY_METHODS = new Set([ @@ -9670,6 +9803,10 @@ export function lowerObjectMethodCall( if (info && !found && eventTargetApiMethod(info, access.name.text)) { return lowerEventTargetMethodCall(lowerer, call, access, info, lowerReceiver()); } + // The Date methods a class declared `extends Date` does not declare. + if (info && !found && dateRootOf(info) && isDatePrototypeMethod(access.name.text)) { + return lowerInheritedDateMethodCall(lowerer, call, access.name.text, info, lowerReceiver()); + } // GENERIC methods (own type parameters) never enter the methods table: // they monomorphize per call site and dispatch statically // (lowerClassGenericMethodCall has the exactness rules). @@ -10458,6 +10595,17 @@ export function lowerStaticNumberGlobal( : lowerer.lowerExprExpecting(args[0]!, STRING); return { kind: "libCall", fn: "num.parseInt", args: [s, radix], type: F64, loc }; } + // parseFloat takes one argument; Node ignores the rest after evaluating + // them (`parseFloat(text, 10)`). Literal and identifier extras have + // nothing to evaluate. + if ( + name === "parseFloat" && + args.length > 1 && + args + .slice(1) + .every((arg) => ts.isNumericLiteral(arg) || ts.isStringLiteral(arg) || ts.isIdentifier(arg)) + ) + return lowerStaticNumberGlobal(lowerer, name, call, args.slice(0, 1), loc); // STATIC parseFloat over string arguments — parseInt's sibling // (num.parseFloat is ECMA 19.2.4's decimal-literal prefix parse in // scr_string.c). Other argument types retain their native coercion diff --git a/packages/compiler/src/frontend/lowering/lower-classes.ts b/packages/compiler/src/frontend/lowering/lower-classes.ts index 790efe988..9976a37e4 100644 --- a/packages/compiler/src/frontend/lowering/lower-classes.ts +++ b/packages/compiler/src/frontend/lowering/lower-classes.ts @@ -1,3 +1,11 @@ +import { + DATE_TIME_FIELD, + dateRootOf, + dateSuperCall, + isDatePrototypeMethod, + lowerDateSuperMethodCall, +} from "./builtins/date-classes.js"; +import { lowerDateStaticCall } from "./builtins/dates.js"; import { lowerValueReturningConstructorNew } from "./js-dynamic-objects.js"; import { adaptPromiseExecutor } from "./promise-executor-adapter.js"; import { dynUndefinedExpr, nodeThrowExpr, varRef } from "../../ir/build.js"; @@ -564,6 +572,11 @@ export interface ClassInfo { * lower-event-target.ts over any class rooted here. Subclass structs * embed the runtime prefix. */ builtinEventTarget?: "target" | "event"; + /** A class declared `extends Date` (builtins/date-classes.ts): its first + * field is the hidden `%time` value, super() sets it with the Date + * constructor's rules, and the Date methods it does not declare lower + * over that value. Subclasses inherit the field. */ + extendsDate?: true; /** The synthetic LifetimeRegion class (@scriptc/experimental, * lifetime-regions.ts): its constructor is synthesized with the class, * and its methods lower at their call sites. */ @@ -1951,6 +1964,7 @@ export function collectClassShapeInner( : (computedBase?.classInfo ?? null); let genericBase: ts.ExpressionWithTypeArguments | undefined; let callableBase: ClassInfo["callableBase"]; + let extendsDate = false; let factoryBaseExpression: ts.Expression | undefined; const adoptCallableBase = (expression: ts.Expression): boolean => { if (familyMode || inst || mixin) return false; @@ -2151,6 +2165,11 @@ export function collectClassShapeInner( if (t && adoptCallableBase(t.expression)) continue; lowerer.unsupported("SC1090", clause, "extending computed expressions"); } + if (!familyMode && !inst && !mixin && lowerer.isStdlibGlobal(t.expression, "Date")) { + if (t.typeArguments?.nodes) lowerer.unsupported("SC1090", t, "extending generic classes"); + extendsDate = true; + continue; + } const symbol = lowerer.resolveValueSymbol(t.expression); // Extending a REBINDABLE decorated class (analysis already ran — // this collection is a class expression or a generic @@ -4350,7 +4369,8 @@ export function collectClassShapeInner( const ctorParams: ParamShape[] = ctor && !mixinForwarding ? lowerer.paramShapes(ctor.parameters.nodes) - : (base?.ctorParams ?? (callableBase ? [{ type: DYN, mode: "dynRest" }] : [])); + : (base?.ctorParams ?? + (callableBase || extendsDate ? [{ type: DYN, mode: "dynRest" }] : [])); if ( ctor && !mixinForwarding && @@ -4388,6 +4408,7 @@ export function collectClassShapeInner( // Redeclared INHERITED fields contribute no slot (their // initializers assign the prefix slot). fields: [ + ...(extendsDate ? [{ name: DATE_TIME_FIELD, type: DATE_T }] : []), ...(base?.def.fields ?? []), ...fieldOrder .filter((f) => f.redeclared !== true) @@ -4419,6 +4440,7 @@ export function collectClassShapeInner( base, ...(genericBase ? { genericBase } : {}), ...(callableBase ? { callableBase } : {}), + ...(extendsDate ? { extendsDate: true as const } : {}), ...(factoryBaseExpression ? { factoryBaseExpression } : {}), subclasses: [], throwingSetters, @@ -5647,6 +5669,15 @@ export function lowerStaticFieldRead( if (info.classDecorators?.valueGlobalId !== undefined) return null; const loc = locOf(expr); const found = findStaticOn(lowerer, info, expr.name.text); + // A Date static read as a value through a class declared `extends Date`: + // the statics lower only as calls. + if ( + !found && + dateRootOf(info) && + ["now", "parse", "UTC"].includes(expr.name.text) && + !(ts.isCallExpression(expr.parent) && expr.parent.expression === expr) + ) + lowerer.noLowering(`Date.${expr.name.text} read through a class that extends Date`, expr); if (hasRuntimeStatics(info) && !found?.field) return { kind: "dynKeyGet", @@ -6422,6 +6453,12 @@ function staticCallOn( const loc = locOf(call); const runtimeStatic = directRuntimeStaticCall(lowerer, call, access, info, throughValue); if (runtimeStatic) return runtimeStatic; + // Date's statics through a class declared `extends Date` + // (`Moment.UTC(...)`), which inherits them. + if (dateRootOf(info) && !findStaticOn(lowerer, info, access.name.text)) { + const date = lowerDateStaticCall(lowerer, call, access.name.text); + if (date) return date; + } if ( (hasRuntimeStatics(info) && !findStaticOn(lowerer, info, access.name.text)?.field) || (info.callableBase && @@ -7683,7 +7720,7 @@ function lowerClassCtorInner(lowerer: Lowerer, info: ClassInfo): IrFunction { lowerer.ctx.argumentsLocal = local; } body.push(...declared.prologue); - if (!ctorBase && !info.callableBase) { + if (!ctorBase && !info.callableBase && !info.extendsDate) { // Node's base-class order: field initializers run at the start // of construction, the parameter-property assignments open the // constructor body (probed — a field initializer reading a @@ -7695,7 +7732,7 @@ function lowerClassCtorInner(lowerer: Lowerer, info: ClassInfo): IrFunction { body.push(...lowerer.lowerDerivedCtorBody(info, thisLocal)); } } else { - if (ctorBase || info.callableBase) { + if (ctorBase || info.callableBase || info.extendsDate) { // Synthetic forwarding params (the inherited ABI signature). // Nothing references them by symbol — only the super call below, // which forwards the already-completed values UNCHANGED (defaults @@ -8614,12 +8651,14 @@ export function lowerDerivedCtorBody( loc, }, ]; - if (info.callableBase) { + if (info.callableBase || info.extendsDate) { if (superCall.arguments.nodes.some(ts.isSpreadElement)) lowerer.unsupported( "SC1090", superCall, - "spreading explicit super arguments into an ordinary constructor", + info.extendsDate + ? "spreading super arguments into the Date constructor" + : "spreading explicit super arguments into an ordinary constructor", ); const pack: IrExpr = { kind: "dynArrLit", @@ -8804,6 +8843,7 @@ export function superCallStmt( type: { kind: "object", className: info.def.name }, loc, }; + if (info.extendsDate) return dateSuperCall(thisRef, info, args[0]!, loc); if (info.callableBase) return { kind: "exprStmt", @@ -8925,6 +8965,24 @@ export function lowerSuperMethodCall( access: ts.PropertyAccessExpression, ): IrExpr { const cls = lowerer.currentClass; + // `super.toISOString()` in a class declared `extends Date`. + if (cls?.extendsDate && !cls.base) { + const thisL = lowerer.resolveThis(); + if (!thisL) lowerer.unsupported("SC1080", access); + const thisRef: IrExpr = { + kind: "varRef", + localId: thisL.id, + type: thisL.type, + loc: locOf(call), + }; + const date = lowerDateSuperMethodCall(lowerer, call, access.name.text, cls, thisRef); + if (date) return date; + lowerer.unsupported( + "SC1090", + access, + `'super.${access.name.text}' (Date.prototype does not declare it)`, + ); + } if (!cls?.base) { // tsc rejects super outside derived-class bodies first; defensive. lowerer.unsupported("SC1090", access, "'super' outside a derived class"); @@ -8969,6 +9027,17 @@ export function lowerSuperMethodCall( // `super.dispatchEvent(e)`, `super.preventDefault()`: the inherited // runtime members over this method's own `this` (subclasses cannot // override them, so the static answer is the runtime's). + if (dateRootOf(cls.base) && isDatePrototypeMethod(access.name.text)) { + const thisL = lowerer.resolveThis(); + if (!thisL) lowerer.unsupported("SC1080", access); + const thisRef: IrExpr = { + kind: "varRef", + localId: thisL.id, + type: thisL.type, + loc: locOf(call), + }; + return lowerDateSuperMethodCall(lowerer, call, access.name.text, cls.base, thisRef)!; + } if (eventTargetApiMethod(cls.base, access.name.text)) { const thisL = lowerer.resolveThis(); if (!thisL) lowerer.unsupported("SC1080", access); diff --git a/packages/compiler/src/frontend/lowering/lower-inspect.ts b/packages/compiler/src/frontend/lowering/lower-inspect.ts index 4be5d0b7e..6f90b198c 100644 --- a/packages/compiler/src/frontend/lowering/lower-inspect.ts +++ b/packages/compiler/src/frontend/lowering/lower-inspect.ts @@ -45,6 +45,7 @@ import type { ClassInfo } from "./lower-classes.js"; import { isSafeToDiscard, isSafeToRepeat } from "./expressions/evaluation-safety.js"; import { symbolFieldDisplayName } from "./symbol-fields.js"; import { eventTargetRootOf } from "./lower-event-target.js"; +import { dateRootOf } from "./builtins/date-classes.js"; import { lowerSystemErrorMap } from "./lower-system-errors.js"; import { isPerfEntryType, perfEntryJson } from "./builtins/performance.js"; import { recordMayKeepSource, recordSourceTest } from "./record-sources.js"; @@ -804,8 +805,9 @@ function inspectSupport( const info = lowerer.classes.get(t.className); if (!info) return `class '${t.className}' has no inspect lowering`; // EventTarget and Event subclasses render through Node's inspectors - // for those classes (the runtime's capsule view). - if (eventTargetRootOf(info) !== null) return null; + // for those classes (the runtime's capsule view), and so do classes + // declared `extends Date`. + if (eventTargetRootOf(info) !== null || dateRootOf(info) !== null) return null; if (isErrorClass(lowerer, t.className)) { if (userErrorClasses(info).length > 0 && errorHeaderOverridden(lowerer, info)) return "error subclasses whose name, message or stack is an accessor or a prototype property have no inspect lowering yet"; @@ -957,7 +959,10 @@ export function inspectExpr( loc, }; case "object": - if (eventTargetRootOf(lowerer.classes.get(t.className)) !== null) { + if ( + eventTargetRootOf(lowerer.classes.get(t.className)) !== null || + dateRootOf(lowerer.classes.get(t.className)) !== null + ) { return { kind: "libCall", fn: "insp.dyn", diff --git a/packages/compiler/src/frontend/lowering/lower-modules.ts b/packages/compiler/src/frontend/lowering/lower-modules.ts index d1f276d44..e12d90743 100644 --- a/packages/compiler/src/frontend/lowering/lower-modules.ts +++ b/packages/compiler/src/frontend/lowering/lower-modules.ts @@ -148,6 +148,7 @@ import { forkTargetPaths } from "../fork-target.js"; import { workerTargetPaths } from "../worker-target.js"; import { isNativeProxyInitializer } from "./expressions/native-proxy.js"; import { handleEventReaderPrelude } from "./lower-event-target.js"; +import { dateClassOperationPrelude } from "./builtins/date-classes.js"; import { cjsAccessorSnapshotStores, jsHoldsDynObject } from "./lower-exprs.js"; import { keptIdentityAssertion } from "./assertion-identity.js"; @@ -3376,6 +3377,7 @@ export function buildMain(lowerer: Lowerer): IrFunction { ...lowerer.mainPrelude, ...cjsModuleRegistryPrelude(lowerer, loc), ...handleEventReaderPrelude(lowerer, loc), + ...dateClassOperationPrelude(lowerer, loc), ]; const roots = [lowerer.entry, ...lowerer.forkTargets, ...lowerer.workerTargets]; const isAsync = roots.some((root) => lowerer.asyncInitFiles.has(root)); diff --git a/packages/compiler/src/frontend/lowering/lower-stmts.ts b/packages/compiler/src/frontend/lowering/lower-stmts.ts index e3480cf9c..f1bf7c041 100644 --- a/packages/compiler/src/frontend/lowering/lower-stmts.ts +++ b/packages/compiler/src/frontend/lowering/lower-stmts.ts @@ -6110,6 +6110,18 @@ export function jsBindingHasOpenWrites(lowerer: Lowerer, decl: ts.VariableDeclar ) ) return true; + // A write that can store null or undefined into a binding the checker + // types as a primitive (`offset = match[3] || null`): JavaScript files + // are checked without strict null checks, so the declared type does not + // admit them. + const primitive = lowerer.mapTypeOf(lowerer.typeOf(decl.name)); + if ( + (primitive?.kind === "string" || primitive?.kind === "f64" || primitive?.kind === "bool") && + candidates.some( + (node) => node.operatorToken.kind === ts.SyntaxKind.EqualsToken && mayBeNullish(node.right), + ) + ) + return true; // A plain JavaScript write of a value the declared type cannot hold (the // checker does not report it): buffer-crc32 replaces its number[] table // with `new Int32Array(table)`. Only a different representation counts; @@ -6140,6 +6152,31 @@ export function jsBindingHasOpenWrites(lowerer: Lowerer, decl: ts.VariableDeclar }); } +/** Whether `node` can evaluate to null or undefined by its form: the + * literals, `void`, and conditional or logical expressions with such an + * operand in result position. */ +function mayBeNullish(node: ts.Expression): boolean { + while (ts.isParenthesizedExpression(node)) node = node.expression; + if (node.kind === ts.SyntaxKind.NullKeyword || ts.isVoidExpression(node)) return true; + if (ts.isIdentifier(node)) return node.text === "undefined"; + if (ts.isConditionalExpression(node)) + return mayBeNullish(node.whenTrue) || mayBeNullish(node.whenFalse); + if (ts.isBinaryExpression(node)) { + const op = node.operatorToken.kind; + if ( + op === ts.SyntaxKind.BarBarToken || + op === ts.SyntaxKind.QuestionQuestionToken || + op === ts.SyntaxKind.AmpersandAmpersandToken + ) + return ( + mayBeNullish(node.right) || + (op === ts.SyntaxKind.AmpersandAmpersandToken && mayBeNullish(node.left)) + ); + if (op === ts.SyntaxKind.CommaToken) return mayBeNullish(node.right); + } + return false; +} + function immediatelyGuardedAbsenceProbe(lowerer: Lowerer, decl: ts.VariableDeclaration): boolean { const guard = immediateAbsenceGuard(lowerer, decl); // `if (!x)`: the falsy test sees a missing value. @@ -7560,8 +7597,9 @@ export function lowerExprStatement(lowerer: Lowerer, expr: ts.Expression): IrStm // (closures box), the runtime sets the member on OBJ receivers // and throws Node's TypeErrors on the rest. The receiver is // PROBED (tryLowerExpression) and claimed exactly when it lowers to - // dyn; typed receivers keep their own lowerings and fences. - if (!expr.left.questionDotToken) { + // dyn; typed receivers keep their own lowerings and fences. A + // private name is the field of its class (fieldTarget). + if (!expr.left.questionDotToken && !ts.isPrivateIdentifier(expr.left.name)) { const recv = tryLowerExpression(lowerer, expr.left.expression); if (recv && recv.type.kind === "dyn") { const loc = locOf(expr); diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts index ee8ba7ecb..e7ea87867 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -497,7 +497,8 @@ import { lowerTracingChannelProperty, } from "./builtins/async-context.js"; import { lowerDisposableStackNew } from "./builtins/disposable-stack.js"; -import { lowerErrorCodeProperty } from "./builtins/errors.js"; +import { lowerErrorCodeProperty, lowerErrorFunctionCall } from "./builtins/errors.js"; +import { noteDateClassMethods } from "./builtins/date-classes.js"; import { lowerProcessProperty, lowerProcessMethodCall, @@ -2944,6 +2945,10 @@ export class Lowerer { /** Named method slots observed before class collection need a callable * ABI and shared prototype descriptors instead of call-site specialization. */ readonly prototypeMethodAccesses = new Map(); + /** Whether the program reads `Error.prototype`, the checked-dynamic + * object an ES5 constructor function can inherit from: only then can a + * value that is not an Error instance be `instanceof Error`. */ + errorPrototypeValues = false; /** Well-known symbol methods (`sym:iterator`) the program may replace * through a symbol-keyed write: an instance or prototype property, or a * reflection call. */ @@ -8123,6 +8128,7 @@ export class Lowerer { // turn queue more instances. Continue to the joint fixpoint; the initial // queue above is the only portion whose discovery order differed from // historical emit order. + noteDateClassMethods(this); const classDispatch = new ClassDynamicDispatch(extraRoots !== undefined); // Units in declaration order, so the passes below meet functions, and the // classes they collect, in an order that does not depend on lowering order. @@ -12758,6 +12764,25 @@ export class Lowerer { ); } + /** withExpressionOverride for several nodes at once. */ + withExpressionOverrides( + overrides: readonly { node: ts.Expression; value: IrExpr }[], + lower: () => T, + ): T { + const previous = overrides.map((override) => this.chainRecvByNode.get(override.node)); + for (const override of overrides) this.chainRecvByNode.set(override.node, override.value); + try { + return lower(); + } finally { + for (let i = overrides.length - 1; i >= 0; i--) { + const node = overrides[i]!.node; + const value = previous[i]; + if (value) this.chainRecvByNode.set(node, value); + else this.chainRecvByNode.delete(node); + } + } + } + withExpressionOverride(node: ts.Expression, value: IrExpr, lower: () => T): T { const previous = this.chainRecvByNode.get(node); this.chainRecvByNode.set(node, value); @@ -12777,6 +12802,7 @@ export class Lowerer { if (webAssembly !== null) return webAssembly; refuseWebAssemblyUse(this, expr.expression); return ( + lowerErrorFunctionCall(this, expr) ?? lowerLifetimeRegionCall(this, expr) ?? lowerInternTableCall(this, expr) ?? lowerThreadSlotsCall(this, expr) ?? diff --git a/packages/compiler/src/frontend/lowering/private-brands.ts b/packages/compiler/src/frontend/lowering/private-brands.ts index 8507cc81a..c7881bce1 100644 --- a/packages/compiler/src/frontend/lowering/private-brands.ts +++ b/packages/compiler/src/frontend/lowering/private-brands.ts @@ -160,6 +160,60 @@ function brandCall( return { kind: "call", callee: helper, args: [receiver, evaluation], type: resultType, loc }; } +/** The class whose body declares the private name `priv` (the nearest + * enclosing one, as JavaScript scoping resolves it), when it is a + * declaration-level class, or null. */ +export function privateNameClass(lowerer: Lowerer, priv: ts.PrivateIdentifier): ClassInfo | null { + for (let node: ts.Node | undefined = priv.parent; node; node = node.parent) { + if (!ts.isClassDeclaration(node) && !ts.isClassExpression(node)) continue; + const declares = node.members.nodes.some((member) => { + const name = (member as { name?: ts.PropertyName }).name; + return name !== undefined && ts.isPrivateIdentifier(name) && name.text === priv.text; + }); + if (!declares) continue; + const symbol = node.name ? lowerer.checker.getSymbolAtLocation(node.name) : undefined; + const info = + lowerer.currentClass?.decl === node + ? lowerer.currentClass + : symbol + ? lowerer.classBySymbol.get(symbol) + : undefined; + if (!info || info.localClass || info.generic || info.genericInstance) return null; + return info; + } + return null; +} + +/** `value.#x` on a checked-dynamic `value` in a declaration-level class + * `info`: the receiver as an instance of `info` when the value is one (an + * instance of the class or a subclass), else Node's TypeError for a missing + * private member (also for undefined and null). */ +export function checkedPrivateValue( + lowerer: Lowerer, + info: ClassInfo, + access: ts.PropertyAccessExpression, + receiver: IrExpr, + loc: SrcLoc, +): IrExpr { + const use: BrandUse = isPrivateWriteTarget(access) ? "write" : "read"; + const className = info.def.name; + const resultType: IrType = { kind: "object", className }; + const helper = `${PREFIX}${use}:${className}:${access.name.text}`; + if (!lowerer.valueHelpers.has(helper)) { + lowerer.liftedFns.push({ + name: helper, + params: [{ localId: "value.0", name: "value", type: DYN }], + returnType: resultType, + locals: [{ id: "value.0", name: "value", type: DYN, mutable: false }], + // finalizePrivateBrands fills the body. + body: [], + loc: helperLoc(loc), + }); + lowerer.valueHelpers.set(helper, helper); + } + return { kind: "call", callee: helper, args: [receiver], type: resultType, loc }; +} + /** A plain assignment, a destructuring target, or a for-in/of target writes * the field. Compound assignments and updates read it first, and Node * reports the failed read. */ @@ -203,7 +257,9 @@ export function finalizePrivateBrands(lowerer: Lowerer, functions: IrFunction[]) const name = spec.slice(spec.lastIndexOf(":") + 1); const loc = fn.loc; const value = varRef("value.0", DYN, loc); - const evaluation = varRef("class.0", { kind: "classval", className }, loc); + // A declaration-level class has one brand: the helper takes no class. + const evaluation = + fn.params.length > 1 ? varRef("class.0", { kind: "classval", className }, loc) : null; const ownerType: IrType = { kind: "object", className }; const body: IrStmt[] = []; let matches = 0; @@ -218,21 +274,23 @@ export function finalizePrivateBrands(lowerer: Lowerer, functions: IrFunction[]) const local = `receiver.${matches++}`; fn.locals.push({ id: local, name: "receiver", type: ownerType, mutable: false }); const receiver = varRef(local, ownerType, loc); - const sameEvaluation: IrExpr = { - kind: "bin", - op: "===", - left: { - kind: "fieldGet", - obj: receiver, - className, - field: `%classEnvironment:${className}`, - type: evaluation.type, - loc, - }, - right: evaluation, - type: BOOL, - loc, - }; + const sameEvaluation: IrExpr = evaluation + ? { + kind: "bin", + op: "===", + left: { + kind: "fieldGet", + obj: receiver, + className, + field: `%classEnvironment:${className}`, + type: evaluation.type, + loc, + }, + right: evaluation, + type: BOOL, + loc, + } + : { kind: "boolLit", value: true, type: BOOL, loc }; const match = (typed: IrExpr): IrStmt[] => [ { kind: "varDecl", localId: local, init: typed, loc }, { diff --git a/packages/compiler/src/frontend/lowering/surfaces.ts b/packages/compiler/src/frontend/lowering/surfaces.ts index c77938337..adc11e35a 100644 --- a/packages/compiler/src/frontend/lowering/surfaces.ts +++ b/packages/compiler/src/frontend/lowering/surfaces.ts @@ -2262,6 +2262,7 @@ export const AMBIENT_SURFACE_FNS: readonly AmbientSurfaceRow[] = [ "date.newLocal", "date.nativeNewFields", "date.nativeNewValue", + "date.argumentsTime", ], note: "zero arguments, one milliseconds/date-string argument, or local-time year/month fields; values are the read-only TimeClip scalar slice", }, diff --git a/packages/compiler/src/ir/builtin-effects.ts b/packages/compiler/src/ir/builtin-effects.ts index ca8c52118..b899e5277 100644 --- a/packages/compiler/src/ir/builtin-effects.ts +++ b/packages/compiler/src/ir/builtin-effects.ts @@ -534,6 +534,7 @@ export const MAY_THROW_LIB_FNS: ReadonlySet = new Set([ "date.nativeNew", "date.nativeNewFields", "date.nativeNewValue", + "date.argumentsTime", "date.checkedValue", "util.parseArgs", "util.parseEnv", @@ -601,6 +602,9 @@ export const MAY_THROW_LIB_FNS: ReadonlySet = new Set([ "dyn.objCreateWithProperties", "dyn.getPrototype", "dyn.setPrototype", + // Error.captureStackTrace: Node's TypeError for a primitive target, and + // the error string conversion of name and message + "dyn.errorCaptureStackTrace", // a proxy in the prototype chain can throw "dyn.builtinInstanceOf", "dyn.functionInstanceOf", diff --git a/packages/compiler/src/ir/builtin-signatures.ts b/packages/compiler/src/ir/builtin-signatures.ts index fa7876579..182d787c8 100644 --- a/packages/compiler/src/ir/builtin-signatures.ts +++ b/packages/compiler/src/ir/builtin-signatures.ts @@ -272,6 +272,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({ "dyn.nativeMapIs": { argTypes: [DYN], result: BOOL }, "dyn.nativeUrlIs": { argTypes: [DYN], result: BOOL }, "dyn.nativeDateIs": { argTypes: [DYN], result: BOOL }, + "dyn.nativeDateHandleIs": { argTypes: [DYN], result: BOOL }, /** A builtin constructor (`Object`, `Date`, `RegExp`, `Map`, `Set`, * `Promise`, `WeakMap`, `WeakSet`) read as a JavaScript value: one * interned function per name, the same one dynamic values answer for @@ -291,6 +292,8 @@ export const LIB_FN_SIGS = defineLibFnSignatures({ /** `new Date(value)` in JavaScript: a string argument parses with V8's * full date parser; every other value constructs as date.nativeNew. */ "date.nativeNewValue": { argTypes: [DYN], result: DYN }, + "date.argumentsTime": { argTypes: [DYN], result: DATE_T }, + "date.classOperation": { argTypes: [DYN, DYN], result: VOID }, "date.checkedValue": { argTypes: [DYN], result: DATE_T }, "dyn.nativeRegexIs": { argTypes: [DYN], result: BOOL }, /** toString() on a checked-dynamic receiver: runtime kind dispatch @@ -3646,6 +3649,10 @@ export const LIB_FN_SIGS = defineLibFnSignatures({ "dyn.arrayPrototype": { argTypes: [], result: DYN }, "dyn.arrayConstructor": { argTypes: [], result: DYN }, "dyn.objectPrototype": { argTypes: [], result: DYN }, + "dyn.errorPrototype": { argTypes: [], result: DYN }, + "dyn.inheritsErrorPrototype": { argTypes: [DYN], result: BOOL }, + "dyn.errorCaptureStackTrace": { argTypes: [DYN], result: DYN }, + "dyn.errorCaptureStackTraceFunction": { argTypes: [], result: DYN }, "dyn.functionApply": { argTypes: [], result: DYN }, "dyn.builtinMethod": { argTypes: [STRING, STRING], result: DYN }, "dyn.classPrototype": { argTypes: [DYN, DYN], result: DYN }, diff --git a/packages/compiler/src/ir/int32-slots.ts b/packages/compiler/src/ir/int32-slots.ts index 6ff148c55..21223862a 100644 --- a/packages/compiler/src/ir/int32-slots.ts +++ b/packages/compiler/src/ir/int32-slots.ts @@ -349,6 +349,7 @@ const DYN_READ_ONLY = new Set([ "date.nativeNew", "date.nativeNewFields", "date.nativeNewValue", + "date.argumentsTime", // The dynamic operators run the ToPrimitive and coercion helpers of // dyn.compare, dyn.numberConstructor and dyn.toStringCoerce, then build a // fresh number, string or bigint. dyn.increment steps dyn.toNumeric's result. diff --git a/packages/compiler/src/ir/tiers.ts b/packages/compiler/src/ir/tiers.ts index ce2fdf0f4..13c464149 100644 --- a/packages/compiler/src/ir/tiers.ts +++ b/packages/compiler/src/ir/tiers.ts @@ -72,6 +72,7 @@ const DYN_KIND_TESTS: ReadonlySet = new Set([ "dyn.nativeMapIs", "dyn.nativeUrlIs", "dyn.nativeDateIs", + "dyn.nativeDateHandleIs", "dyn.nativeRegexIs", "dyn.dataViewIs", "dyn.typeof", diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7040-es5-error-constructor.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7040-es5-error-constructor.mjs.json new file mode 100644 index 000000000..1a1a6951c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7040-es5-error-constructor.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7040-es5-error-constructor.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7041-error-called-without-new.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7041-error-called-without-new.mjs.json new file mode 100644 index 000000000..f40c04116 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7041-error-called-without-new.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7041-error-called-without-new.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7042-string-method-names-on-objects.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7042-string-method-names-on-objects.mjs.json new file mode 100644 index 000000000..c867cd88c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7042-string-method-names-on-objects.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7042-string-method-names-on-objects.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7043-date-set-time.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7043-date-set-time.mjs.json new file mode 100644 index 000000000..8b369c633 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7043-date-set-time.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7043-date-set-time.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7044-nested-empty-object-maps.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7044-nested-empty-object-maps.mjs.json new file mode 100644 index 000000000..ee3592ba6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7044-nested-empty-object-maps.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7044-nested-empty-object-maps.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7045-instanceof-constructor-values.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7045-instanceof-constructor-values.mjs.json new file mode 100644 index 000000000..530aca0ad --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7045-instanceof-constructor-values.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7045-instanceof-constructor-values.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7046-parse-float-extra-arguments.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7046-parse-float-extra-arguments.mjs.json new file mode 100644 index 000000000..0f37ad2a2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7046-parse-float-extra-arguments.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7046-parse-float-extra-arguments.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7047-dynamic-string-index.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7047-dynamic-string-index.mjs.json new file mode 100644 index 000000000..7cd38cfb9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7047-dynamic-string-index.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7047-dynamic-string-index.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7048-unary-number-coercions.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7048-unary-number-coercions.mjs.json new file mode 100644 index 000000000..10c99f165 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7048-unary-number-coercions.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7048-unary-number-coercions.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7049-member-assignment-values.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7049-member-assignment-values.mjs.json new file mode 100644 index 000000000..5dc066127 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7049-member-assignment-values.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7049-member-assignment-values.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7050-date-subclass.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7050-date-subclass.mjs.json new file mode 100644 index 000000000..fc73bb479 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7050-date-subclass.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7050-date-subclass.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7051-date-subclass-typed.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7051-date-subclass-typed.ts.json new file mode 100644 index 000000000..f37cd9763 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7051-date-subclass-typed.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7051-date-subclass-typed.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7052-date-subclass-dynamic.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7052-date-subclass-dynamic.mjs.json new file mode 100644 index 000000000..7077aa5bb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7052-date-subclass-dynamic.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7052-date-subclass-dynamic.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7053-private-fields-untyped-receivers.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7053-private-fields-untyped-receivers.mjs.json new file mode 100644 index 000000000..d7d8ba2e1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7053-private-fields-untyped-receivers.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7053-private-fields-untyped-receivers.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7054-let-bindings-with-null-writes.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7054-let-bindings-with-null-writes.mjs.json new file mode 100644 index 000000000..25dcd3680 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7054-let-bindings-with-null-writes.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7054-let-bindings-with-null-writes.mjs" + ], + "diags": [] +} diff --git a/packages/runtime/src/scr_dyn.h b/packages/runtime/src/scr_dyn.h index 02c4d828f..5d68b2c6d 100644 --- a/packages/runtime/src/scr_dyn.h +++ b/packages/runtime/src/scr_dyn.h @@ -662,6 +662,40 @@ bool scr_dyn_native_url_is(const ScrDyn *value); ScrDyn *scr_dyn_native_search_params(ScrSearchParams *value); bool scr_dyn_native_search_params_is(const ScrDyn *value); bool scr_dyn_native_date_is(const ScrDyn *value); +/* Instances of program classes declared `extends Date` (scr_lib.c). */ +void scr_date_class_operation_install(ScrDyn *time, ScrDyn *methods); +/* Set by scr_date_class_operation_install; NULL in a program without such + * a class, where every wrapper below answers false or NULL. */ +typedef struct { + bool (*time)(const ScrDyn *value, double *time); + ScrDyn *(*to_json)(const ScrDyn *value, const ScrDyn *key); + ScrDyn *(*to_string)(const ScrDyn *value); + ScrDyn *(*value_of)(const ScrDyn *value); + ScrStr *(*name)(const ScrDyn *value); + ScrDyn *(*method)(const ScrDyn *value, const char *key, size_t key_len); +} ScrDateClassHooks; +extern const ScrDateClassHooks *scr_date_class_hooks; +static inline bool scr_dyn_date_class_time(const ScrDyn *value, double *time) { + return scr_date_class_hooks && scr_date_class_hooks->time(value, time); +} +static inline ScrDyn *scr_dyn_date_class_to_json(const ScrDyn *value, const ScrDyn *key) { + return scr_date_class_hooks->to_json(value, key); +} +static inline ScrDyn *scr_dyn_date_class_to_string(const ScrDyn *value) { + return scr_date_class_hooks->to_string(value); +} +static inline ScrDyn *scr_dyn_date_class_value_of(const ScrDyn *value) { + return scr_date_class_hooks->value_of(value); +} +static inline ScrStr *scr_dyn_date_class_name(const ScrDyn *value) { + return scr_date_class_hooks ? scr_date_class_hooks->name(value) : NULL; +} +static inline ScrDyn *scr_dyn_date_class_method(const ScrDyn *value, const char *key, size_t key_len) { + return scr_date_class_hooks ? scr_date_class_hooks->method(value, key, key_len) : NULL; +} +bool scr_dyn_date_instance_is(const ScrDyn *value); +ScrDyn *scr_dyn_date_class_member(const ScrDyn *d, const char *key, size_t key_len); +double scr_dyn_date_arguments_time(const ScrDyn *arguments); ScrDyn *scr_dyn_native_date_new(const ScrDyn *arguments); ScrDyn *scr_dyn_native_date_new_fields(const ScrDyn *arguments); ScrDyn *scr_dyn_native_date_new_value(const ScrDyn *arguments); @@ -1048,6 +1082,10 @@ ScrStr *scr_dyn_to_string(const ScrDyn *d, const ScrStr *enc); * prototype chain has no toString (Node's answer). */ ScrStr *scr_dyn_to_string_method(const ScrDyn *d, const ScrStr *enc, const ScrStr *what); ScrDyn *scr_dyn_object_prototype(void); +ScrDyn *scr_dyn_error_prototype(void); +bool scr_dyn_inherits_error_prototype(const ScrDyn *value); +ScrDyn *scr_dyn_error_capture_stack_trace(ScrDyn *target); +ScrDyn *scr_dyn_error_capture_stack_trace_function(void); ScrDyn *scr_dyn_function_apply(void); ScrDyn *scr_dyn_reflect_apply(ScrDyn *target, ScrDyn *receiver, ScrDyn *arguments_list); ScrDyn *scr_dyn_apply_array_like(const ScrDyn *target, const ScrDyn *receiver, const ScrDyn *arguments, const char *what); diff --git a/packages/runtime/src/scr_dyn_invoke.c b/packages/runtime/src/scr_dyn_invoke.c index 2a010f213..ec49dd383 100644 --- a/packages/runtime/src/scr_dyn_invoke.c +++ b/packages/runtime/src/scr_dyn_invoke.c @@ -845,6 +845,16 @@ static ScrDyn *scr_dyn_invoke_impl( if (scr_event_ref_hooks && scr_event_ref_hooks->invoke(recv, method, args, argc, what, &fast)) return fast; + /* An inherited Date method of an instance of a class declared `extends + * Date`. */ + ScrDyn *date_method = scr_dyn_date_class_member(recv, method, strlen(method)); + if (date_method) { + scr_dyn_this_push_dyn(recv); + ScrDyn *result = scr_dyn_call(date_method, args, argc, what); + scr_dyn_this_pop(); + scr_dyn_release(date_method); + return result; + } ScrDyn *materialized = scr_dyn_typed_ref_materialize(recv); if (scr_exc_pending()) { scr_dyn_release(materialized); diff --git a/packages/runtime/src/scr_inspect.c b/packages/runtime/src/scr_inspect.c index 223517e92..a4d124ac3 100644 --- a/packages/runtime/src/scr_inspect.c +++ b/packages/runtime/src/scr_inspect.c @@ -1652,7 +1652,40 @@ ScrStr *scr_insp_dyn(ScrDyn *d, double recurse, double depth) { * view of its fields does not carry. */ const ScrStr *name = scr_dyn_typed_ref_class_name(d); ScrStr *out; - if (name && materialized->kind == SCR_DYN_OBJ && + double time; + ScrStr *date_class = materialized->kind == SCR_DYN_OBJ && scr_dyn_date_class_time(d, &time) + ? scr_dyn_date_class_name(d) : NULL; + if (date_class) { + /* An instance of a class declared `extends Date`: the class name and + * the time as Date.prototype.toISOString formats it, then its own + * enumerable properties when it has any. */ + ScrStr *iso = scr_insp_date(time); + InspBuf head = {0}; + ib_bytes(&head, date_class->data, date_class->len); + scr_str_release(date_class); + ib_char(&head, ' '); + ib_bytes(&head, iso->data, iso->len); + scr_str_release(iso); + ScrStr *prefix = ib_take(&head); + bool fields = false; + for (size_t i = 0; i < materialized->v.obj.len && !fields; i++) + fields = materialized->v.obj.entries[i].enumerable; + if (!fields || recurse > depth) { + scr_dyn_release(materialized); + return prefix; + } + char *cls = malloc(prefix->len + 1); + if (!cls) scr_trap("scriptc: out of memory\n"); + memcpy(cls, prefix->data, prefix->len); + cls[prefix->len] = '\0'; + scr_str_release(prefix); + size_t nseen = g_nseen; + g_pending_seen = instance; + out = scr_insp_obj(materialized, recurse, depth, cls); + g_pending_seen = NULL; + if (g_nseen > nseen) g_nseen = nseen; + free(cls); + } else if (name && materialized->kind == SCR_DYN_OBJ && scr_dyn_obj_get(materialized, "%error", 6) == NULL) { char *cls = malloc(name->len + 1); if (!cls) scr_trap("scriptc: out of memory\n"); diff --git a/packages/runtime/src/scr_json.c b/packages/runtime/src/scr_json.c index b8f16630b..549ca9165 100644 --- a/packages/runtime/src/scr_json.c +++ b/packages/runtime/src/scr_json.c @@ -37,6 +37,19 @@ static SCR_TL ScrDyn *scr_builtin_object_prototype; +const ScrDateClassHooks *scr_date_class_hooks; + +/* The checked-dynamic Error.prototype (scr_dyn_error_prototype) is not the + * prototype of scriptc's Error instances, so a change to it would not reach + * them: every mutation throws. */ +static SCR_TL ScrDyn *scr_builtin_error_prototype; +static bool scr_dyn_error_prototype_fence(const ScrDyn *value) { + if (!value || value != scr_builtin_error_prototype) return false; + static const char message[] = "Error.prototype mutation is not supported yet"; + scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020"); + return true; +} + /* Constructor capsules expose identity and name/length, but do not model * per-class static property tables yet. Never report a fabricated empty view. */ static bool scr_dyn_class_reflection_fence(const ScrDyn *value) { @@ -1816,6 +1829,149 @@ ScrDyn *scr_dyn_array_prototype_base(void) { return scr_dyn_retain(scr_builtin_array_prototype); } +/* Error.prototype as a checked-dynamic object, for JavaScript constructor + * functions that inherit from it (`F.prototype = + * Object.create(Error.prototype)`): non-enumerable `constructor`, `name` + * ("Error"), `message` ("") and `toString`, on Object.prototype. The Error + * constructor has no checked-dynamic value, so `constructor` is a function + * named Error that throws when called. */ +static const ScrDyn *scr_dyn_proto_next(const ScrDyn *object); +static void scr_builtin_error_prototype_cleanup(void) { + ScrDyn *prototype = scr_builtin_error_prototype; + scr_builtin_error_prototype = NULL; + scr_dyn_release(prototype); +} +static ScrDyn *scr_error_prototype_to_string(ScrClosure *closure, ScrDyn *const *args, size_t argc) { + (void)closure; (void)args; (void)argc; + ScrDyn *self = scr_dyn_this_get(); + ScrDyn *result = NULL; + if (self->kind == SCR_DYN_OBJ || self->kind == SCR_DYN_ARR || self->kind == SCR_DYN_FUNC) { + ScrStr *text = scr_dyn_error_string(self); + if (text) { + result = scr_dyn_new_str(text); + scr_str_release(text); + } + } else { + ScrJsonBuf message; + scr_jb_init(&message); + scr_jb_puts(&message, "Method Error.prototype.toString called on incompatible receiver "); + ScrStr *shown = self->kind == SCR_DYN_SYMBOL ? self->v.symbol.render(self->v.symbol.value) + : scr_dyn_string_coerce_js(self); + if (shown) { + scr_jb_put_str(&message, shown); + scr_str_release(shown); + } + scr_throw_error(SCR_ERR_TYPE, scr_jb_finish(&message)); + } + scr_dyn_release(self); + return result; +} +static ScrDyn *scr_error_prototype_constructor(ScrClosure *closure, ScrDyn *const *args, size_t argc) { + (void)closure; (void)args; (void)argc; + static const char message[] = "calling Error.prototype.constructor is not supported yet"; + scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020"); + return NULL; +} +static void scr_error_prototype_hide(ScrDyn *object, const char *key, size_t key_len) { + ScrDynEntry *entry = scr_dyn_find_entry(object, key, key_len); + entry->enumerable = false; +} +ScrDyn *scr_dyn_error_prototype(void) { + if (!scr_builtin_error_prototype) { + ScrDyn *prototype = scr_dyn_alloc(SCR_DYN_OBJ); + scr_dyn_obj_set(prototype, "constructor", 11, + scr_dyn_new_func(scr_closure_new(NULL, 0), scr_error_prototype_constructor, 1, "native:Error", "Error")); + scr_error_prototype_hide(prototype, "constructor", 11); + ScrStr *name = scr_str_new("Error", 5); + scr_dyn_obj_set(prototype, "name", 4, scr_dyn_new_str(name)); + scr_str_release(name); + scr_error_prototype_hide(prototype, "name", 4); + ScrStr *empty = scr_str_new("", 0); + scr_dyn_obj_set(prototype, "message", 7, scr_dyn_new_str(empty)); + scr_str_release(empty); + scr_error_prototype_hide(prototype, "message", 7); + scr_dyn_obj_set(prototype, "toString", 8, + scr_dyn_new_func(scr_closure_new(NULL, 0), scr_error_prototype_to_string, 0, "native:Error", "toString")); + scr_error_prototype_hide(prototype, "toString", 8); + scr_builtin_error_prototype = prototype; + scr_atexit(scr_builtin_error_prototype_cleanup); + } + return scr_dyn_retain(scr_builtin_error_prototype); +} + +/* Error.captureStackTrace(target): defines a non-enumerable own `stack` + * on target. Node's value is the Error.prototype.toString text of target + * (read without calling an overriding toString) followed by stack frames; + * here, as for scriptc's own Error instances, it is the text alone. + * Answers undefined, or NULL with the exception pending. */ +ScrDyn *scr_dyn_error_capture_stack_trace(ScrDyn *target) { + /* An instance of a class that extends Error derives its stack from its + * name and message when the stack is read. */ + if (target->kind == SCR_DYN_TYPED_REF) { + ScrDyn *view = scr_dyn_typed_ref_materialize(target); + bool error = view && view->kind == SCR_DYN_OBJ && scr_dyn_obj_get(view, "%error", 6) != NULL; + scr_dyn_release(view); + if (scr_exc_pending()) return NULL; + if (error) return scr_dyn_retain(scr_dyn_undefined()); + } + if (target->kind != SCR_DYN_OBJ) { + if (target->kind == SCR_DYN_ARR || target->kind == SCR_DYN_FUNC || target->kind == SCR_DYN_TYPED_REF || + target->kind == SCR_DYN_HANDLE || target->kind == SCR_DYN_PROXY) { + static const char message[] = "Error.captureStackTrace on this object is not supported yet"; + scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020"); + } else { + static const char message[] = "invalid_argument"; + scr_throw_error_msg(SCR_ERR_TYPE, message, sizeof message - 1); + } + return NULL; + } + ScrDynEntry *existing = scr_dyn_find_entry(target, "stack", 5); + if (existing ? existing->accessor || !existing->configurable : target->non_extensible) { + static const char message[] = "Cannot redefine property: stack"; + static const char extensible[] = "Cannot define property stack, object is not extensible"; + if (existing) scr_throw_error_msg(SCR_ERR_TYPE, message, sizeof message - 1); + else scr_throw_error_msg(SCR_ERR_TYPE, extensible, sizeof extensible - 1); + return NULL; + } + ScrStr *text = scr_dyn_error_string(target); + if (!text) return NULL; + scr_dyn_obj_set_field(target, "stack", 5, scr_dyn_new_str(text)); + scr_str_release(text); + ScrDynEntry *entry = scr_dyn_find_entry(target, "stack", 5); + entry->enumerable = false; + entry->writable = entry->configurable = true; + return scr_dyn_retain(scr_dyn_undefined()); +} +static ScrDyn *scr_error_capture_stack_trace_call(ScrClosure *closure, ScrDyn *const *args, size_t argc) { + (void)closure; + return scr_dyn_error_capture_stack_trace(argc > 0 ? args[0] : scr_dyn_undefined()); +} +/* Error.captureStackTrace read as a value: one function per thread. */ +static SCR_TL ScrDyn *scr_error_capture_stack_trace_fn; +static void scr_error_capture_stack_trace_fn_cleanup(void) { + ScrDyn *function = scr_error_capture_stack_trace_fn; + scr_error_capture_stack_trace_fn = NULL; + scr_dyn_release(function); +} +ScrDyn *scr_dyn_error_capture_stack_trace_function(void) { + if (!scr_error_capture_stack_trace_fn) { + scr_error_capture_stack_trace_fn = scr_dyn_new_func(scr_closure_new(NULL, 0), + scr_error_capture_stack_trace_call, 2, "native:Error", "captureStackTrace"); + scr_atexit(scr_error_capture_stack_trace_fn_cleanup); + } + return scr_dyn_retain(scr_error_capture_stack_trace_fn); +} + +/* `value instanceof Error` for a value that is not an Error instance: true + * when Error.prototype is on its prototype chain. */ +bool scr_dyn_inherits_error_prototype(const ScrDyn *value) { + if (!scr_builtin_error_prototype || !value || value->kind != SCR_DYN_OBJ) return false; + for (const ScrDyn *current = scr_dyn_proto_next(value); current; current = scr_dyn_proto_next(current)) { + if (current == scr_builtin_error_prototype) return true; + } + return false; +} + ScrDyn *scr_dyn_new_arr(void) { return scr_dyn_alloc(SCR_DYN_ARR); } ScrDyn *scr_dyn_new_obj(void) { return scr_dyn_alloc(SCR_DYN_OBJ); } ScrDyn *scr_dyn_new_obj_with_identity( @@ -1847,7 +2003,6 @@ ScrDyn *scr_dyn_new_obj_null_proto(void) { } static const ScrDyn *scr_dyn_chain_link(const ScrDyn *link); -static const ScrDyn *scr_dyn_proto_next(const ScrDyn *object); /* A typed capsule can be a prototype when its checked view is an object. */ static bool scr_dyn_typed_ref_prototype(const ScrDyn *value) { @@ -1942,7 +2097,7 @@ ScrDyn *scr_dyn_set_prototype(ScrDyn *object, ScrDyn *prototype) { object->kind == SCR_DYN_BIGINT || object->kind == SCR_DYN_SYMBOL) { return scr_dyn_prototype_valid(prototype) ? scr_dyn_retain(object) : NULL; } - if (scr_dyn_class_reflection_fence(object) || scr_dyn_class_reflection_fence(prototype)) return NULL; + if (scr_dyn_class_reflection_fence(object) || scr_dyn_error_prototype_fence(object) || scr_dyn_class_reflection_fence(prototype)) return NULL; if (object->kind == SCR_DYN_TYPED_REF) { ScrDyn *view = scr_dyn_typed_ref_materialize(object); if (scr_exc_pending()) { scr_dyn_release(view); return NULL; } @@ -2058,7 +2213,7 @@ static ScrDyn *scr_dyn_fn_existing_table(const ScrDyn *function) { } ScrDyn *scr_dyn_prevent_extensions(ScrDyn *object) { - if (scr_dyn_class_reflection_fence(object)) return NULL; + if (scr_dyn_class_reflection_fence(object) || scr_dyn_error_prototype_fence(object)) return NULL; if (object->kind == SCR_DYN_PROXY) { scr_dyn_proxy_unsupported("Object.preventExtensions"); return NULL; } if (scr_dyn_class_integrity_fence(object, "Object.preventExtensions")) return NULL; ScrDyn *table = scr_dyn_fn_integrity_table(object); @@ -2089,7 +2244,7 @@ bool scr_dyn_is_extensible(ScrDyn *object) { } ScrDyn *scr_dyn_seal(ScrDyn *object) { - if (scr_dyn_class_reflection_fence(object)) return NULL; + if (scr_dyn_class_reflection_fence(object) || scr_dyn_error_prototype_fence(object)) return NULL; if (object->kind == SCR_DYN_PROXY) { scr_dyn_proxy_unsupported("Object.seal"); return NULL; } if (scr_dyn_class_integrity_fence(object, "Object.seal")) return NULL; if (object->symbol_properties) scr_dyn_release(scr_dyn_seal(object->symbol_properties)); @@ -3366,6 +3521,7 @@ const ScrStr *scr_dyn_typed_ref_class_name(const ScrDyn *d) { return ops ? ops->class_name : NULL; } + static bool scr_dyn_name_in_strs(const ScrStr *key, ScrStr *const *names, size_t count) { for (size_t i = 0; i < count; i++) { if (names[i] == key || scr_str_eq(names[i], (ScrStr *)key)) return true; @@ -3457,6 +3613,18 @@ ScrDyn *scr_dyn_index_get(const ScrDyn *d, double index) { } ScrDyn *scr_dyn_typed_ref_string_view(const ScrDyn *d) { + /* An instance of a class declared `extends Date` converts through its + * toString, declared or inherited. With an exception pending the view is + * the empty string. */ + double time; + if (scr_dyn_date_class_time(d, &time)) { + ScrDyn *text = scr_dyn_date_class_to_string(d); + if (text) return text; + ScrStr *empty = scr_str_new("", 0); + ScrDyn *out = scr_dyn_new_str(empty); + scr_str_release(empty); + return out; + } ScrDyn *view = scr_dyn_typed_ref_materialize(d); const char *tag = scr_event_ref_hooks ? scr_event_ref_hooks->string_tag(d) : NULL; if (!tag || view->kind != SCR_DYN_OBJ || scr_dyn_property_owner(view, "toString", 8)) return view; @@ -3467,12 +3635,28 @@ ScrDyn *scr_dyn_typed_ref_string_view(const ScrDyn *d) { return out; } +/* An inherited Date method of an instance of a class declared `extends + * Date`, when the instance's own members do not define `key`: +1, or + * NULL. */ +ScrDyn *scr_dyn_date_class_member(const ScrDyn *d, const char *key, size_t key_len) { + ScrDyn *method = scr_dyn_date_class_method(d, key, key_len); + if (!method) return NULL; + ScrDyn *view = scr_dyn_typed_ref_materialize(d); + bool declared = view && !scr_exc_pending() && scr_dyn_property_owner(view, key, key_len); + scr_dyn_release(view); + if (!declared) return method; + scr_dyn_release(method); + return NULL; +} + ScrDyn *scr_dyn_typed_ref_key_get(const ScrDyn *d, const ScrStr *key) { if (d->v.typed_ref.record) return scr_typed_ref_record_get(d, key); if (scr_event_ref_hooks) { ScrDyn *inherited = scr_event_ref_hooks->get(d, key); if (inherited) return inherited; } + ScrDyn *date_method = scr_dyn_date_class_member(d, key->data, key->len); + if (date_method) return date_method; if (!scr_dyn_typed_ref_array_ops(d)) return NULL; if (scr_typed_ref_is_length(key)) return scr_dyn_new_num((double)((ScrArr *)d->v.typed_ref.ptr)->len); size_t index; @@ -3708,6 +3892,29 @@ ScrDyn *scr_array_buffer_constructor(void) { return scr_dyn_retain(scr_array_buffer_ctor); } +/* `value instanceof C` for C a global constructor held as a value + * (`{ instanceOf: Date }`, scr_dyn_global_constructor): 1 or 0 by the + * value's native kind, or -1 when callee is not one of them, or for Object + * and for class instances, which these kinds cannot answer. A typed record + * or array is none of these kinds. */ +static int scr_dyn_global_constructor_instanceof(const ScrDyn *value, const ScrDyn *callee) { + if (!callee->v.fn.sig || !callee->v.fn.name || strcmp(callee->v.fn.sig, "native:constructor") != 0 || + strcmp(callee->v.fn.name, "Object") == 0) + return -1; + if (value->kind == SCR_DYN_TYPED_REF) + return strncmp(value->v.typed_ref.type_key, "record:", 7) == 0 || scr_dyn_ref_is_array(value) ? 0 : -1; + static const struct { const char *name; int tag; } kinds[] = { + {"Date", SCR_DYNH_DATE}, {"RegExp", SCR_DYNH_REGEXP}, {"Map", SCR_DYNH_MAP}, {"Set", SCR_DYNH_SET}, + {"WeakMap", SCR_DYNH_WEAK_MAP}, {"WeakSet", SCR_DYNH_WEAK_SET}, + }; + if (strcmp(callee->v.fn.name, "Promise") == 0) return value->kind == SCR_DYN_PROMISE; + for (size_t i = 0; i < sizeof kinds / sizeof kinds[0]; i++) { + if (strcmp(callee->v.fn.name, kinds[i].name) == 0) + return value->kind == SCR_DYN_HANDLE && (int)value->v.handle.tag == kinds[i].tag; + } + return -1; +} + bool scr_bytes_instanceof(const ScrDyn *value, const ScrDyn *callee) { if (!callee || callee->kind != SCR_DYN_FUNC) { static const char message[] = "Right-hand side of 'instanceof' is not callable"; @@ -3720,6 +3927,38 @@ bool scr_bytes_instanceof(const ScrDyn *value, const ScrDyn *callee) { if (scr_bytes_ctors[i] && callee->v.fn.clo == scr_bytes_ctors[i]->v.fn.clo) return scr_dyn_typed_array_is(value, (int)i); } + int global = scr_dyn_global_constructor_instanceof(value, callee); + if (global >= 0) return global; + /* An ordinary constructor function (an untyped JavaScript function whose + * prototype is an object): OrdinaryHasInstance walks the value's + * prototype chain for callee.prototype. */ + { + ScrStr *name = scr_str_new("prototype", 9); + ScrDyn *key = scr_dyn_new_str(name); + scr_str_release(name); + ScrDyn *prototype = scr_dyn_reflect_get((ScrDyn *)callee, key, (ScrDyn *)callee); + scr_dyn_release(key); + if (!prototype) return false; /* the read threw: pending */ + if (prototype->kind == SCR_DYN_OBJ) { + bool found = false; + if (value->kind == SCR_DYN_OBJ || value->kind == SCR_DYN_ARR || value->kind == SCR_DYN_FUNC) { + ScrDyn *current = scr_dyn_get_prototype((ScrDyn *)value); + while (current && current->kind != SCR_DYN_NULL) { + if (current == prototype) { + found = true; + break; + } + ScrDyn *next = scr_dyn_get_prototype(current); + scr_dyn_release(current); + current = next; + } + if (current) scr_dyn_release(current); + } + scr_dyn_release(prototype); + return found; + } + scr_dyn_release(prototype); + } static const char message[] = "instanceof against this native constructor is not supported yet"; scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC1090"); return false; @@ -6191,6 +6430,7 @@ void scr_dyn_symbol_key_placeholder(ScrDyn *value, ScrDyn *key) { } void scr_dyn_symbol_key_set(ScrDyn *value, ScrDyn *key, ScrDyn *stored) { + if (scr_dyn_error_prototype_fence(value)) return; ScrDyn *receiver = scr_dyn_symbol_receiver(value); if (!receiver) { if (!scr_exc_pending()) { @@ -6341,6 +6581,7 @@ static bool scr_dyn_fn_property_fence(const ScrStr *key) { } ScrDyn *scr_dyn_define_property(ScrDyn *target, ScrDyn *key, ScrDyn *descriptor) { + if (scr_dyn_error_prototype_fence(target)) return NULL; if (target->kind == SCR_DYN_TYPED_REF) { ScrDyn *view = scr_dyn_typed_ref_materialize(target); ScrDyn *defined = scr_exc_pending() ? NULL : scr_dyn_define_property(view, key, descriptor); @@ -7726,6 +7967,9 @@ ScrStr *scr_dyn_to_string(const ScrDyn *d, const ScrStr *enc) { } } +static ScrStr *scr_dyn_to_string_method_args(const ScrDyn *d, const ScrStr *enc, const ScrStr *what, + ScrDyn *const *args, size_t argc); + /* The METHOD-CALL spelling `d.toString(enc?)` — scr_dyn_to_string with * the one receiver whose prototype LACKS the method carved out: a * null-prototype dictionary (Object.create(null)) has no toString at @@ -7755,7 +7999,10 @@ ScrStr *scr_dyn_to_string_argument(const ScrDyn *d, const ScrDyn *argument, cons scr_throw_error(SCR_ERR_TYPE, scr_jb_finish(&b)); return scr_str_new("", 0); } - return scr_dyn_to_string_method(d, NULL, what); + /* A toString the program defines receives the argument + * (`error.toString(compact)`); undefined passes none. */ + ScrDyn *args[1] = {(ScrDyn *)argument}; + return scr_dyn_to_string_method_args(d, NULL, what, args, argument->kind == SCR_DYN_UNDEF ? 0 : 1); } /* The METHOD-CALL spelling `d.valueOf()`: a primitive answers itself (the @@ -7995,7 +8242,12 @@ bool scr_dyn_number_coerce_js(const ScrDyn *d, double *out) { return false; } if (d->kind == SCR_DYN_TYPED_REF) { - ScrDyn *materialized = scr_dyn_typed_ref_materialize(d); + /* An instance of a class declared `extends Date` converts through its + * valueOf, declared or inherited. */ + double time; + ScrDyn *materialized = scr_dyn_date_class_time(d, &time) ? scr_dyn_date_class_value_of(d) + : scr_dyn_typed_ref_materialize(d); + if (!materialized) return false; bool ok = scr_dyn_number_coerce_js(materialized, out); scr_dyn_release(materialized); return ok; @@ -8098,9 +8350,18 @@ double scr_dyn_number_coerce(const ScrDyn *d) { static ScrDyn *scr_dyn_add_primitive(const ScrDyn *d); /* ToPrimitive with the number hint, which differs from the default hint - * only for a Date: its time value. */ + * only for a Date: its time value, or the valueOf of an instance of a class + * declared `extends Date`. */ static ScrDyn *scr_dyn_number_primitive(const ScrDyn *d) { - return scr_dyn_is_date(d) ? scr_dyn_date_value_of(d) : scr_dyn_add_primitive(d); + if (scr_dyn_is_date(d)) return scr_dyn_date_value_of(d); + double time; + if (d->kind == SCR_DYN_TYPED_REF && scr_dyn_date_class_time(d, &time)) { + ScrDyn *value = scr_dyn_date_class_value_of(d); + ScrDyn *out = value ? scr_dyn_add_primitive(value) : NULL; + scr_dyn_release(value); + return out; + } + return scr_dyn_add_primitive(d); } double scr_dyn_number_constructor(const ScrDyn *d) { @@ -8161,6 +8422,15 @@ static ScrDyn *scr_dyn_add_primitive(const ScrDyn *d) { return NULL; } if (d->kind == SCR_DYN_TYPED_REF) { + /* A Date's default hint is string: an instance of a class declared + * `extends Date` adds through its toString. */ + double time; + if (scr_dyn_date_class_time(d, &time)) { + ScrDyn *text = scr_dyn_date_class_to_string(d); + ScrDyn *out = text ? scr_dyn_add_primitive(text) : NULL; + scr_dyn_release(text); + return out; + } ScrDyn *view = scr_dyn_typed_ref_materialize(d); ScrDyn *out = scr_exc_pending() ? NULL : scr_dyn_add_primitive(view); scr_dyn_release(view); @@ -8580,7 +8850,7 @@ void scr_dyn_arr_named_put(ScrDyn *arr, const char *key, size_t key_len, ScrDyn } void scr_dyn_key_set(ScrDyn *recv, ScrStr *key, ScrDyn *value) { - if (scr_dyn_class_reflection_fence(recv)) return; + if (scr_dyn_class_reflection_fence(recv) || scr_dyn_error_prototype_fence(recv)) return; if (recv->kind == SCR_DYN_PROXY) { scr_dyn_proxy_set(recv, key, value); return; } if (recv->kind == SCR_DYN_TYPED_REF) { if (scr_typed_ref_array_set(recv, key, value)) return; @@ -10408,7 +10678,7 @@ static void scr_json_delete_member(ScrDyn *object, const ScrStr *key) { * arrays, typed references and handles keep their explicit boundary; * deleting from a materialized snapshot would lose the mutation. */ void scr_dyn_key_delete(ScrDyn *recv, const ScrStr *key, bool strict) { - if (scr_dyn_class_reflection_fence(recv)) return; + if (scr_dyn_class_reflection_fence(recv) || scr_dyn_error_prototype_fence(recv)) return; if (recv->kind == SCR_DYN_PROXY) { scr_dyn_proxy_delete(recv, key); return; } if (recv->kind == SCR_DYN_TYPED_REF && recv->v.typed_ref.commit && (!strncmp(recv->v.typed_ref.type_key, "record:", 7) || @@ -10634,6 +10904,16 @@ static bool scr_json_live_container(const ScrDyn *value, bool inspect) { * method, called with the key. Returns the value to serialize (+1), or NULL * with an exception pending. */ static ScrDyn *scr_json_to_json(ScrDyn *value, const ScrStr *key) { + /* An instance of a class declared `extends Date` converts through its + * toJSON, declared or inherited. */ + double time; + if (value->kind == SCR_DYN_TYPED_REF && scr_dyn_date_class_time(value, &time)) { + ScrDyn *name = scr_dyn_new_str((ScrStr *)key); + ScrDyn *converted = scr_dyn_date_class_to_json(value, name); + scr_dyn_release(name); + scr_dyn_release(value); + return converted; + } /* Inspect a typed reference without replacing its live identity. Later * members must read the source again after a callback mutates it. A live * array, or a live record without a `toJSON` field, needs no conversion. */ @@ -12826,7 +13106,7 @@ static void scr_dyn_assign_from(ScrDyn *target, const ScrDyn *src, bool define) * nothing; index-keyed sources (arrays/strings/bytes) copy their index * keys like Node; the remaining kinds have no own enumerable keys. */ ScrDyn *scr_dyn_assign(ScrDyn *target, const ScrDyn *src) { - if (scr_dyn_class_reflection_fence(target) || scr_dyn_class_reflection_fence(src)) return NULL; + if (scr_dyn_class_reflection_fence(target) || scr_dyn_error_prototype_fence(target) || scr_dyn_class_reflection_fence(src)) return NULL; if (target->kind == SCR_DYN_UNDEF || target->kind == SCR_DYN_NULL) { const char *m = "Cannot convert undefined or null to object"; scr_throw_error_msg(SCR_ERR_TYPE, m, strlen(m)); @@ -14620,7 +14900,10 @@ ScrMap *scr_dyn_native_collection_check(const ScrDyn *value, int map, const char return scr_map_retain(value->v.handle.ptr); } -ScrStr *scr_dyn_to_string_method(const ScrDyn *d, const ScrStr *enc, const ScrStr *what) { +/* scr_dyn_to_string_method, passing `args` to a toString the receiver's + * chain defines. */ +static ScrStr *scr_dyn_to_string_method_args(const ScrDyn *d, const ScrStr *enc, const ScrStr *what, + ScrDyn *const *args, size_t argc) { /* Object.create receivers must run their inherited formatter before the * default object tag; Effect shard keys use it to produce distinct hashes. */ const bool object_method = d->kind == SCR_DYN_OBJ && scr_dyn_property_owner(d, "toString", 8); @@ -14629,7 +14912,7 @@ ScrStr *scr_dyn_to_string_method(const ScrDyn *d, const ScrStr *enc, const ScrSt if (scr_exc_pending()) { scr_dyn_release(member); return NULL; } if (member && (object_method || member->kind != SCR_DYN_UNDEF)) { scr_dyn_this_push_dyn(d); - ScrDyn *value = scr_dyn_call(member, NULL, 0, what->data); + ScrDyn *value = scr_dyn_call(member, args, argc, what->data); scr_dyn_this_pop(); scr_dyn_release(member); if (!value) return NULL; @@ -14651,8 +14934,12 @@ ScrStr *scr_dyn_to_string_method(const ScrDyn *d, const ScrStr *enc, const ScrSt return scr_dyn_to_string(d, enc); } +ScrStr *scr_dyn_to_string_method(const ScrDyn *d, const ScrStr *enc, const ScrStr *what) { + return scr_dyn_to_string_method_args(d, enc, what, NULL, 0); +} + ScrDyn *scr_dyn_freeze(ScrDyn *value) { - if (scr_dyn_class_reflection_fence(value)) return NULL; + if (scr_dyn_class_reflection_fence(value) || scr_dyn_error_prototype_fence(value)) return NULL; if (scr_dyn_class_integrity_fence(value, "Object.freeze")) return NULL; ScrDyn *table = scr_dyn_fn_integrity_table(value); if (!table) return scr_dyn_freeze_data(value); @@ -14663,7 +14950,7 @@ ScrDyn *scr_dyn_freeze(ScrDyn *value) { } ScrDyn *scr_dyn_freeze_data(ScrDyn *value) { - if (scr_dyn_class_reflection_fence(value)) return NULL; + if (scr_dyn_class_reflection_fence(value) || scr_dyn_error_prototype_fence(value)) return NULL; if (scr_dyn_class_integrity_fence(value, "Object.freeze")) return NULL; if (value->symbol_properties) scr_dyn_release(scr_dyn_freeze_data(value->symbol_properties)); if (value->kind == SCR_DYN_ARR) { diff --git a/packages/runtime/src/scr_lib.c b/packages/runtime/src/scr_lib.c index 3441e6142..d856e3000 100644 --- a/packages/runtime/src/scr_lib.c +++ b/packages/runtime/src/scr_lib.c @@ -12997,9 +12997,116 @@ bool scr_dyn_native_date_is(const ScrDyn *value) { return value && value->kind == SCR_DYN_HANDLE && value->v.handle.tag == SCR_DYNH_DATE; } +/* Instances of program classes declared `extends Date` keep their time + * value in a compiled field. In checked-dynamic code such an instance is a + * typed reference, and the runtime reaches its time value and methods + * through the functions %main installs (builtins/date-classes.ts), called + * as (op, value, argument): for op 0 the time function answers the time + * value, or undefined for any other value, and for op 1 sets it; for ops 2 + * to 5 the method function calls the instance's toISOString, + * toJSON(argument), toString and valueOf. */ +enum { + SCR_DATE_CLASS_TIME, + SCR_DATE_CLASS_SET_TIME, + SCR_DATE_CLASS_TO_ISO_STRING, + SCR_DATE_CLASS_TO_JSON, + SCR_DATE_CLASS_TO_STRING, + SCR_DATE_CLASS_VALUE_OF, + SCR_DATE_CLASS_NAME, +}; +static SCR_TL ScrDyn *scr_date_class_operation; +static SCR_TL ScrDyn *scr_date_class_methods; + +static void scr_date_class_operation_cleanup(void) { + ScrDyn *operation = scr_date_class_operation; + ScrDyn *methods = scr_date_class_methods; + scr_date_class_operation = scr_date_class_methods = NULL; + scr_dyn_release(operation); + scr_dyn_release(methods); +} + +static bool scr_date_class_time_of(const ScrDyn *value, double *time); +static ScrDyn *scr_date_class_to_json(const ScrDyn *value, const ScrDyn *key); +static ScrDyn *scr_date_class_to_string(const ScrDyn *value); +static ScrDyn *scr_date_class_value_of(const ScrDyn *value); +static ScrStr *scr_date_class_name(const ScrDyn *value); +static ScrDyn *scr_date_class_method(const ScrDyn *value, const char *key, size_t key_len); + +/* The installation also publishes these functions to the rest of the + * runtime (scr_date_class_hooks), so only a program that declares a class + * extending Date links them. */ +static const ScrDateClassHooks scr_date_class_hook_table = { + scr_date_class_time_of, scr_date_class_to_json, scr_date_class_to_string, + scr_date_class_value_of, scr_date_class_name, scr_date_class_method, +}; + +void scr_date_class_operation_install(ScrDyn *time, ScrDyn *methods) { + scr_date_class_hooks = &scr_date_class_hook_table; + if (!scr_date_class_operation) scr_atexit(scr_date_class_operation_cleanup); + scr_dyn_release(scr_date_class_operation); + scr_dyn_release(scr_date_class_methods); + scr_date_class_operation = scr_dyn_retain(time); + scr_date_class_methods = scr_dyn_retain(methods); +} + +/* The installed operation `op` on `value`: +1, or NULL with an exception + * pending. */ +static ScrDyn *scr_date_class_call(int op, const ScrDyn *value, const ScrDyn *argument) { + ScrDyn *code = scr_dyn_new_num(op); + ScrDyn *args[] = { code, (ScrDyn *)value, (ScrDyn *)(argument ? argument : scr_dyn_undefined()) }; + bool time = op < SCR_DATE_CLASS_TO_ISO_STRING || op == SCR_DATE_CLASS_NAME; + ScrDyn *result = scr_dyn_call(time ? scr_date_class_operation : scr_date_class_methods, args, 3, "Date"); + scr_dyn_release(code); + return result; +} + +/* True, with the time value in *time, when `value` holds an instance of a + * class declared `extends Date`. */ +static bool scr_date_class_time_of(const ScrDyn *value, double *time) { + if (!scr_date_class_operation || !value || value->kind != SCR_DYN_TYPED_REF) return false; + ScrDyn *result = scr_date_class_call(SCR_DATE_CLASS_TIME, value, NULL); + bool found = result && result->kind == SCR_DYN_NUM; + if (found) *time = result->v.num; + scr_dyn_release(result); + return found; +} + +/* `value instanceof Date`: a Date, or an instance of a class declared + * `extends Date`. */ +bool scr_dyn_date_instance_is(const ScrDyn *value) { + double time; + return scr_dyn_native_date_is(value) || scr_dyn_date_class_time(value, &time); +} + +/* toJSON(key), toString() or valueOf() of an instance of a class declared + * `extends Date` (scr_dyn_date_class_time answered true): the class's + * declaration or the Date method. +1, or NULL with an exception pending. */ +static ScrDyn *scr_date_class_to_json(const ScrDyn *value, const ScrDyn *key) { + return scr_date_class_call(SCR_DATE_CLASS_TO_JSON, value, key); +} +static ScrDyn *scr_date_class_to_string(const ScrDyn *value) { + return scr_date_class_call(SCR_DATE_CLASS_TO_STRING, value, NULL); +} +static ScrDyn *scr_date_class_value_of(const ScrDyn *value) { + return scr_date_class_call(SCR_DATE_CLASS_VALUE_OF, value, NULL); +} + +/* The name of the class of an instance of a class declared `extends + * Date`: +1, or NULL for any other value. */ +static ScrStr *scr_date_class_name(const ScrDyn *value) { + if (!scr_date_class_operation || !value || value->kind != SCR_DYN_TYPED_REF) return NULL; + ScrDyn *result = scr_date_class_call(SCR_DATE_CLASS_NAME, value, NULL); + ScrStr *name = result && result->kind == SCR_DYN_STR ? scr_str_retain(result->v.str) : NULL; + scr_dyn_release(result); + return name; +} + double scr_dyn_native_date_value(const ScrDyn *value) { - if (!scr_dyn_native_date_is(value)) { scr_dyn_check_fail(NULL, "Date", value); return NAN; } - return ((ScrNativeDate *)value->v.handle.ptr)->milliseconds; + if (scr_dyn_native_date_is(value)) return ((ScrNativeDate *)value->v.handle.ptr)->milliseconds; + double time; + if (scr_dyn_date_class_time(value, &time)) return time; + scr_dyn_check_fail(NULL, "Date", value); + return NAN; } /* Method names without another use in this file, in named arrays (see @@ -13009,13 +13116,14 @@ static const char scr_date_to_time_string_name[] = "toTimeString"; static ScrDyn *scr_native_date_invoke(void *ptr, ScrDyn *self, const char *method, ScrDyn *const *args, size_t argc, const char *what) { - (void)self; (void)args; (void)argc; (void)what; + (void)self; (void)what; double ms = ((ScrNativeDate *)ptr)->milliseconds; if (!strcmp(method, "getTime") || !strcmp(method, "valueOf")) return scr_dyn_new_num(ms); if (!strcmp(method, "toString") || !strcmp(method, scr_date_to_date_string_name) || - !strcmp(method, scr_date_to_time_string_name)) { + !strcmp(method, scr_date_to_time_string_name) || !strcmp(method, "toUTCString")) { ScrStr *text = !strcmp(method, "toString") ? scr_date_to_string(ms) : !strcmp(method, scr_date_to_date_string_name) ? scr_date_to_date_string(ms) + : !strcmp(method, "toUTCString") ? scr_date_to_utc_string(ms) : scr_date_to_time_string(ms); ScrDyn *result = scr_dyn_new_str(text); scr_str_release(text); @@ -13029,6 +13137,12 @@ static ScrDyn *scr_native_date_invoke(void *ptr, ScrDyn *self, const char *metho scr_str_release(text); return result; } + if (!strcmp(method, "setTime")) { + double time = NAN; + if (argc > 0 && !scr_dyn_number_coerce_js(args[0], &time)) return NULL; + ((ScrNativeDate *)ptr)->milliseconds = scr_date_new_ms(time); + return scr_dyn_new_num(((ScrNativeDate *)ptr)->milliseconds); + } #define DATE_GET(name, fn) if (!strcmp(method, name)) return scr_dyn_new_num(fn(ms)) DATE_GET("getFullYear", scr_date_get_full_year_local); DATE_GET("getUTCFullYear", scr_date_get_full_year_utc); @@ -13059,13 +13173,25 @@ ScrDyn *scr_dyn_native_date_new(const ScrDyn *arguments) { else { ScrDyn *value = arguments->v.arr.items[0]; if (scr_dyn_native_date_is(value)) ms = scr_dyn_native_date_value(value); - else if (value->kind == SCR_DYN_STR) ms = scr_date_parse_get_time(value->v.str); + else if (scr_dyn_date_class_time(value, &ms)) { + } else if (value->kind == SCR_DYN_STR) ms = scr_date_parse_get_time(value->v.str); else if (!scr_dyn_number_coerce_js(value, &ms)) return NULL; ms = scr_date_new_ms(ms); } return scr_dyn_native_date_from_ms(ms); } +/* The time value `new Date(...arguments)` constructs (super(...) in a + * class declared `extends Date`), or NaN with an exception pending. */ +double scr_dyn_date_arguments_time(const ScrDyn *arguments) { + ScrDyn *date = arguments->v.arr.len > 1 ? scr_dyn_native_date_new_fields(arguments) + : scr_dyn_native_date_new_value(arguments); + if (!date) return NAN; + double time = ((ScrNativeDate *)date->v.handle.ptr)->milliseconds; + scr_dyn_release(date); + return time; +} + /* new Date(value) in JavaScript: a string parses with the full parser; * every other value takes scr_dyn_native_date_new. */ ScrDyn *scr_dyn_native_date_new_value(const ScrDyn *arguments) { @@ -13092,11 +13218,11 @@ ScrDyn *scr_dyn_native_date_new_fields(const ScrDyn *arguments) { /* The Date.prototype methods scr_native_date_invoke answers. */ static const char *const scr_native_date_methods[] = { "getTime", "valueOf", "toISOString", "toJSON", "toString", scr_date_to_date_string_name, - scr_date_to_time_string_name, + scr_date_to_time_string_name, "toUTCString", "getFullYear", "getUTCFullYear", "getMonth", "getUTCMonth", "getDate", "getUTCDate", "getDay", "getUTCDay", "getHours", "getUTCHours", "getMinutes", "getUTCMinutes", "getSeconds", "getUTCSeconds", "getMilliseconds", - "getUTCMilliseconds", "getTimezoneOffset", + "getUTCMilliseconds", "getTimezoneOffset", "setTime", }; #define SCR_NATIVE_DATE_METHODS (sizeof scr_native_date_methods / sizeof scr_native_date_methods[0]) static SCR_TL ScrDyn *scr_native_date_method_values[SCR_NATIVE_DATE_METHODS]; @@ -13111,13 +13237,34 @@ static void scr_native_date_methods_cleanup(void) { } /* A Date method read as a value and called later: the closure's function - * slot holds the method's name, and the receiver must be a Date. */ + * slot holds the method's name, and the receiver must be a Date. On an + * instance of a class declared `extends Date` the method runs over its + * time value; toJSON calls the instance's toISOString. */ static ScrDyn *scr_native_date_method_call(ScrClosure *closure, ScrDyn *const *args, size_t argc) { const char *method = closure->fn; ScrDyn *self = scr_dyn_this_get(); ScrDyn *result = NULL; + double time; if (scr_dyn_native_date_is(self)) { result = scr_native_date_invoke(self->v.handle.ptr, self, method, args, argc, method); + } else if (scr_dyn_date_class_time(self, &time)) { + if (!strcmp(method, "toJSON")) { + result = isfinite(time) ? scr_date_class_call(SCR_DATE_CLASS_TO_ISO_STRING, self, NULL) + : scr_dyn_new_null(); + } else { + ScrNativeDate date = { 1, time }; + result = scr_native_date_invoke(&date, self, method, args, argc, method); + if (result && date.milliseconds != time && !(isnan(date.milliseconds) && isnan(time))) { + ScrDyn *stored = scr_dyn_new_num(date.milliseconds); + ScrDyn *set = scr_date_class_call(SCR_DATE_CLASS_SET_TIME, self, stored); + scr_dyn_release(stored); + if (!set) { + scr_dyn_release(result); + result = NULL; + } + scr_dyn_release(set); + } + } } else { static const char message[] = "this is not a Date object."; scr_throw_error_msg(SCR_ERR_TYPE, message, sizeof message - 1); @@ -13126,6 +13273,21 @@ static ScrDyn *scr_native_date_method_call(ScrClosure *closure, ScrDyn *const *a return result; } +static ScrDyn *scr_native_date_get(void *ptr, const char *key, size_t key_len); + +/* The Date method `key` as a function value when `value` holds an instance + * of a class declared `extends Date`, or NULL. The class's own members are + * read first, by the caller. */ +static ScrDyn *scr_date_class_method(const ScrDyn *value, const char *key, size_t key_len) { + if (!scr_date_class_operation) return NULL; + bool named = false; + for (size_t i = 0; i < SCR_NATIVE_DATE_METHODS && !named; i++) + named = strlen(scr_native_date_methods[i]) == key_len && !memcmp(scr_native_date_methods[i], key, key_len); + double time; + if (!named || !scr_dyn_date_class_time(value, &time)) return NULL; + return scr_native_date_get(NULL, key, key_len); +} + /* Property reads of a Date: its methods as function values, one per name * and thread, and NULL (undefined) for other names. */ static ScrDyn *scr_native_date_get(void *ptr, const char *key, size_t key_len) { diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 3974f346e..2404c3885 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -30,8 +30,8 @@ importers: specifier: 3.22.2 version: 3.22.2 js-yaml: - specifier: 4.3.0 - version: 4.3.0 + specifier: 4.3.2 + version: 4.3.2 oxfmt: specifier: 0.71.0 version: 0.71.0 @@ -41,6 +41,9 @@ importers: rollup: specifier: 4.62.2 version: 4.62.2 + smol-toml: + specifier: 1.7.1 + version: 1.7.1 three: specifier: 0.186.1 version: 0.186.1 @@ -2089,8 +2092,8 @@ packages: resolution: {integrity: sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==} hasBin: true - js-yaml@4.3.0: - resolution: {integrity: sha512-1td788aAnnZ5qs7V2QIRl1owjtYpbKt749Y3xauqQgwIIGF/xXWz1wMTEBx5O3LK3lXLVuqXPdPxj2BoFHaW9Q==} + js-yaml@4.3.2: + resolution: {integrity: sha512-SFNOvSJ+Dgf/9An904Yx+CgSlIPCkIpao4qo51lpee25TIRejdH3rhR4EZMGoNx3/TP3O+wzWuiTFl4sqbltzA==} hasBin: true json-schema-to-ts@1.6.4: @@ -2458,6 +2461,10 @@ packages: resolution: {integrity: sha512-QlaZEqcAH3/RtNyet1IPIYPsEWAaYyXXv1Krsi+1L/QHppjX4Ifm8MQsBISz9vE8cHicIq3clogsheili5vhaQ==} engines: {node: '>= 18'} + smol-toml@1.7.1: + resolution: {integrity: sha512-PPlsspAZ4jbMBu5DMFhfUGDQLu/vrL4SyBROVS37x8ynnVmFIs1VPBz1Co8Xks3TvpIaZXmU85y4DrQ+UyVFoQ==} + engines: {node: '>= 18'} + source-map-js@1.2.1: resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==} engines: {node: '>=0.10.0'} @@ -4305,7 +4312,7 @@ snapshots: dependencies: argparse: 2.0.1 - js-yaml@4.3.0: + js-yaml@4.3.2: dependencies: argparse: 2.0.1 @@ -4694,6 +4701,8 @@ snapshots: smol-toml@1.5.2: {} + smol-toml@1.7.1: {} + source-map-js@1.2.1: {} srvx@0.11.16: {} diff --git a/tests/corpus/7040-es5-error-constructor.mjs b/tests/corpus/7040-es5-error-constructor.mjs new file mode 100644 index 000000000..977567125 --- /dev/null +++ b/tests/corpus/7040-es5-error-constructor.mjs @@ -0,0 +1,79 @@ +// A constructor function that inherits from Error.prototype, the pre-class +// way of declaring an error type. +function ParseFailure(reason, position) { + Error.call(this); + this.name = "ParseFailure"; + this.reason = reason; + this.position = position; + this.message = reason + (position === undefined ? "" : " at " + position); + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor); + } else { + this.stack = new Error().stack || ""; + } +} +ParseFailure.prototype = Object.create(Error.prototype); +ParseFailure.prototype.constructor = ParseFailure; +ParseFailure.prototype.toString = function toString(compact) { + return this.name + ": " + this.reason + (compact ? "" : " (position " + this.position + ")"); +}; + +const failure = new ParseFailure("unexpected token", 7); +console.log(failure instanceof ParseFailure, failure instanceof Error, failure.constructor === ParseFailure); +console.log(failure.name, "|", failure.message, "|", failure.reason, failure.position); +console.log(failure.toString(), "|", failure.toString(true), "|", String(failure), "|", `${failure}`); +console.log(Object.keys(failure), JSON.stringify(failure)); +console.log(typeof failure.stack, failure.stack.split("\n")[0], Object.keys(failure).includes("stack")); +console.log(Object.prototype.toString.call(failure), Error.isError(failure)); + +try { + throw new ParseFailure("thrown"); +} catch (caught) { + console.log(caught instanceof Error, caught instanceof ParseFailure, caught.reason, caught.message); +} +const values = [new ParseFailure("in a list"), new Error("plain"), { name: "Fake", message: "x" }, "text"]; +console.log(values.map((value) => value instanceof Error)); + +// The inherited members of Error.prototype. +const bare = Object.create(Error.prototype); +console.log(bare instanceof Error, bare.name, JSON.stringify(bare.message), String(bare), Object.keys(bare)); +console.log(Error.prototype.name, JSON.stringify(Error.prototype.message), Error.prototype instanceof Error); +const record = Object.create(Error.prototype); +record.name = "N"; +record.message = "M"; +console.log(String(record), `${Object.create(record)}`); + +// captureStackTrace on other objects: the header follows name and message. +const target = { name: "Custom", message: "details", toString() { return "ignored"; } }; +Error.captureStackTrace(target); +console.log(target.stack.split("\n")[0], Object.keys(target)); +const empty = {}; +Error.captureStackTrace(empty); +console.log(empty.stack.split("\n")[0], typeof Error.captureStackTrace); + +// A subtype of the subtype. +function StrictFailure(reason) { + ParseFailure.call(this, reason, 0); + this.name = "StrictFailure"; +} +StrictFailure.prototype = Object.create(ParseFailure.prototype); +StrictFailure.prototype.constructor = StrictFailure; +const strict = new StrictFailure("strict mode"); +console.log(strict instanceof StrictFailure, strict instanceof ParseFailure, strict instanceof Error, strict.toString(true)); + +// A class that extends Error calls it too, directly or through `?.`. +class TokenError extends Error { + constructor(message) { + super(message); + this.name = "TokenError"; + Error.captureStackTrace(this, TokenError); + } +} +class LexError extends TokenError { + constructor(message) { + super(message), (this.name = "LexError"), Error.captureStackTrace?.(this, this.constructor); + } +} +for (const error of [new TokenError("bad token"), new LexError("bad char")]) { + console.log(error.name, error.message, error.stack.split("\n")[0], error instanceof TokenError, Object.keys(error)); +} diff --git a/tests/corpus/7041-error-called-without-new.mjs b/tests/corpus/7041-error-called-without-new.mjs new file mode 100644 index 000000000..bf1df8e99 --- /dev/null +++ b/tests/corpus/7041-error-called-without-new.mjs @@ -0,0 +1,40 @@ +// The standard error constructors called as functions construct errors too, +// and Function.prototype.call ignores the receiver it is given. +const plain = Error("plain"); +const typed = TypeError("typed"); +const range = RangeError(); +const withCause = Error("wrapped", { cause: plain }); +console.log(plain instanceof Error, plain.message, String(plain)); +console.log(typed instanceof TypeError, typed instanceof Error, typed.name, typed.message); +console.log(range instanceof RangeError, JSON.stringify(range.message), String(range)); +console.log(withCause.cause === plain, withCause.message); +console.log(SyntaxError("s").name, ReferenceError("r").name, EvalError("e").name, URIError("u").name); + +const receiver = { marker: true }; +const called = Error.call(receiver, "via call"); +console.log(called instanceof Error, called.message, Object.keys(receiver), called === receiver); +const typedCall = TypeError.call(null, "typed via call"); +console.log(typedCall instanceof TypeError, typedCall.message); +const noArguments = Error.call(); +console.log(noArguments instanceof Error, JSON.stringify(noArguments.message)); + +let evaluated = 0; +function effect(value) { + evaluated++; + return value; +} +const ordered = Error.call(effect({}), effect("ordered")); +console.log(evaluated, ordered.message); + +function Wrapper(message) { + const base = Error.call(this, message); + this.message = base.message; + this.kind = "wrapper"; +} +const wrapped = new Wrapper("kept"); +console.log(wrapped.message, wrapped.kind, wrapped instanceof Wrapper, wrapped instanceof Error); +try { + throw Error("thrown without new"); +} catch (error) { + console.log(error instanceof Error, error.message); +} diff --git a/tests/corpus/7042-string-method-names-on-objects.mjs b/tests/corpus/7042-string-method-names-on-objects.mjs new file mode 100644 index 000000000..c623f5417 --- /dev/null +++ b/tests/corpus/7042-string-method-names-on-objects.mjs @@ -0,0 +1,70 @@ +// Objects whose members share names with String.prototype methods, filled +// in after their declaration. A call dispatches on the receiver's runtime +// kind: a string runs the String method, any other value its own member. +var helpers = {}; +var initialized; +function setup() { + if (initialized) return helpers; + initialized = true; + function repeat(text, count) { + let out = ""; + for (let i = 0; i < count; i += 1) out += text; + return out; + } + function padStart(text, width, fill) { + let out = String(text); + while (out.length < width) out = fill + out; + return out; + } + helpers.repeat = repeat; + helpers.padStart = padStart; + helpers.trim = function (value) { + return "<" + value + ">"; + }; + helpers.split = (value, separator) => [value, separator, "own"]; + helpers.toUpperCase = () => "own upper"; + return helpers; +} + +const h = setup(); +console.log("[" + h.repeat("ab", 3) + "]", "[" + h.repeat("-", 0) + "]"); +console.log(h.padStart(7, 3, "0"), h.padStart("long", 2, "*")); +console.log(h.trim(" x "), h.split("a,b", ","), h.toUpperCase()); + +const indent = h.repeat(" ", 2); +console.log("[" + indent + "]", indent.length); +const lines = ["one", "two"].map((line, index) => h.padStart(index + 1, 3, " ") + " | " + line); +console.log(lines.join("\n")); + +// The same names on a missing member throw Node's TypeError. +var partial = {}; +function fillPartial() { + partial.present = true; +} +fillPartial(); +try { + partial.repeat("x", 2); +} catch (error) { + console.log(error instanceof TypeError, error.message); +} +try { + partial.trim(); +} catch (error) { + console.log(error instanceof TypeError, error.message); +} + +// Arguments are evaluated once, in order, after the member is read. +const order = []; +var traced = {}; +function fillTraced() { + traced.replace = (a, b) => { + order.push("call"); + return a + b; + }; +} +fillTraced(); +function arg(value) { + order.push("arg " + value); + return value; +} +console.log(traced.replace(arg(1), arg(2)), order.join(", ")); diff --git a/tests/corpus/7043-date-set-time.mjs b/tests/corpus/7043-date-set-time.mjs new file mode 100644 index 000000000..a673c58dc --- /dev/null +++ b/tests/corpus/7043-date-set-time.mjs @@ -0,0 +1,28 @@ +// Date.prototype.setTime on Dates a JavaScript file constructs: the Date +// is one mutable object, so every reference sees the new time value. +function shifted(year, month, day, minutes) { + const date = new Date(Date.UTC(year, month, day, 12, 30, 15, 250)); + if (minutes) date.setTime(date.getTime() - minutes * 60000); + return date; +} +const unchanged = shifted(2001, 1, 3, 0); +const moved = shifted(2001, 1, 3, 90); +console.log(unchanged.toISOString(), moved.toISOString()); + +const alias = moved; +const record = { when: moved }; +console.log(moved.setTime(1000), alias.getTime(), record.when.toISOString()); +console.log(moved.setTime("2500"), moved.getTime(), moved.setTime(1.9), moved.setTime(-1.9)); +console.log(moved.setTime(NaN), moved.getTime(), String(moved), moved.toJSON()); +console.log(moved.setTime(8.64e15), moved.setTime(8.64e15 + 1), moved.setTime(-8.64e15 - 1)); +console.log(Object.is(moved.setTime(-0), 0), moved.setTime(), moved.setTime(true), moved.setTime(null)); +console.log(moved.setTime({ valueOf: () => 86400000 }), moved.toISOString()); +try { + moved.setTime({ valueOf: () => { throw new Error("no time"); } }); +} catch (error) { + console.log(error.message, moved.toISOString()); +} +console.log(JSON.stringify({ at: shifted(1999, 11, 31, 1) })); +const dates = [shifted(2020, 0, 1, 0), shifted(2020, 0, 1, 0)]; +dates.forEach((date, index) => date.setTime(date.getTime() + index * 1000)); +console.log(dates.map((date) => date.getUTCSeconds())); diff --git a/tests/corpus/7044-nested-empty-object-maps.mjs b/tests/corpus/7044-nested-empty-object-maps.mjs new file mode 100644 index 000000000..e8d330f20 --- /dev/null +++ b/tests/corpus/7044-nested-empty-object-maps.mjs @@ -0,0 +1,46 @@ +// Object literals whose fields start as empty objects, used as maps the +// program adds keys to, including chained assignment into two of them. +function index(entries) { + const table = { + first: {}, + second: {}, + all: {}, + lists: { first: [], second: [], all: [] }, + }; + function add(entry) { + if (entry.many) { + table.lists[entry.group].push(entry.name); + table.lists["all"].push(entry.name); + } else { + table[entry.group][entry.name] = table["all"][entry.name] = entry; + } + } + entries.forEach(add); + return table; +} +const table = index([ + { group: "first", name: "a" }, + { group: "second", name: "b" }, + { group: "first", name: "c", many: true }, + { group: "second", name: "a" }, +]); +console.log(Object.keys(table.first), Object.keys(table.second), Object.keys(table.all), table.lists); +console.log(table.all.a === table.second.a, table.first.a.group, table.all.b.name, "c" in table.first); +console.log(JSON.stringify(table)); + +function counters(words) { + const result = { seen: {}, firstAt: {} }; + words.forEach((word, position) => { + result.seen[word] = (result.seen[word] || 0) + 1; + if (!(word in result.firstAt)) result.firstAt[word] = position; + }); + return result; +} +console.log(JSON.stringify(counters(["x", "y", "x", "z", "y", "x"]))); + +const settings = { values: {}, names: {} }; +const key = String(Math.round(1.6)); +settings.values[key] = 2; +settings["names"][key + "!"] = settings.values[key] * 10; +delete settings.values[key]; +console.log(JSON.stringify(settings), Object.keys(settings.values).length); diff --git a/tests/corpus/7045-instanceof-constructor-values.mjs b/tests/corpus/7045-instanceof-constructor-values.mjs new file mode 100644 index 000000000..6b41cfdca --- /dev/null +++ b/tests/corpus/7045-instanceof-constructor-values.mjs @@ -0,0 +1,43 @@ +// `instanceof` against constructors held as values: a property holding a +// global constructor, and constructor functions with prototype chains. +const kinds = [ + { name: "Date", type: Date }, + { name: "RegExp", type: RegExp }, + { name: "Map", type: Map }, + { name: "Set", type: Set }, + { name: "WeakMap", type: WeakMap }, + { name: "Promise", type: Promise }, + { name: "Array", type: Array }, +]; +function classify(value) { + return kinds + .filter((kind) => typeof value === "object" && value !== null && value instanceof kind.type) + .map((kind) => kind.name) + .join("+") || "none"; +} +const samples = [new Date(0), /x/g, new Map([[1, 2]]), new Set([1]), new WeakMap(), Promise.resolve(1), [1, 2], { a: 1 }, null, "text", 4]; +console.log(samples.map(classify).join(" ")); + +function Shape(sides) { + this.sides = sides; +} +Shape.prototype.describe = function () { + return this.sides + " sides"; +}; +function Square() { + Shape.call(this, 4); +} +Square.prototype = Object.create(Shape.prototype); +Square.prototype.constructor = Square; +const square = new Square(); +const shape = new Shape(3); +const types = { Shape, Square }; +console.log(square instanceof types.Shape, square instanceof types.Square, shape instanceof types.Square); +console.log(square.describe(), shape.describe(), Object.create(Square.prototype) instanceof types.Shape); +console.log([square, shape, {}, []].map((value) => value instanceof types.Shape)); +const notCallable = JSON.parse("{}"); +try { + console.log(square instanceof notCallable); +} catch (error) { + console.log(error instanceof TypeError, error.message); +} diff --git a/tests/corpus/7046-parse-float-extra-arguments.mjs b/tests/corpus/7046-parse-float-extra-arguments.mjs new file mode 100644 index 000000000..9046a9145 --- /dev/null +++ b/tests/corpus/7046-parse-float-extra-arguments.mjs @@ -0,0 +1,9 @@ +// parseFloat reads one argument; Node ignores any others. +const radix = 10; +const inputs = ["3.25", " -0.5e2xyz", "0x10", "Infinityx", ".5", "-.e1", "", "1_000"]; +console.log(inputs.map((text) => parseFloat(text, 10))); +console.log(inputs.map((text) => parseFloat(text, radix, "ignored"))); +const fromJson = JSON.parse('{"value":"12.5kg","n":7}'); +console.log(parseFloat(fromJson.value, 10), parseFloat(fromJson.n, radix), Object.is(parseFloat("-0", 10), -0)); +const values = ["1.5", "2.25"].map((text) => parseFloat(text.replace(/_/g, ""), 10)); +console.log(values, values[0] + values[1]); diff --git a/tests/corpus/7047-dynamic-string-index.mjs b/tests/corpus/7047-dynamic-string-index.mjs new file mode 100644 index 000000000..fc81db3ce --- /dev/null +++ b/tests/corpus/7047-dynamic-string-index.mjs @@ -0,0 +1,21 @@ +// Indexing a string with a key whose type is only known at run time reads +// the property the key names: a code unit, the length, or undefined. +function skipSpaces(text, at) { + let c; + while ((c = text[at]) === " " || c === "\t") at++; + return [at, c]; +} +const where = JSON.parse('{"at":2,"name":"length","past":9,"text":"1","neg":-1,"frac":1.5}'); +console.log(skipSpaces("ab \tcd", where.at), skipSpaces("ab", where.past)); +const s = "hello"; +console.log(s[where.at], s[where.name], s[where.past], s[where.text], s[where.neg], s[where.frac]); +console.log(typeof s[where.past], typeof s[where.name], s[where.at] === "l"); +function scan(text, start) { + let out = ""; + for (let i = start; text[i] !== undefined && text[i] !== ";"; i++) out += text[i]; + return out; +} +console.log(scan("key=value;rest", JSON.parse("4")), scan("abc", JSON.parse("1"))); +const codes = []; +for (let i = JSON.parse("0"); i < s.length; i++) codes.push(s[i].charCodeAt(0)); +console.log(codes); diff --git a/tests/corpus/7048-unary-number-coercions.mjs b/tests/corpus/7048-unary-number-coercions.mjs new file mode 100644 index 000000000..4154ae79e --- /dev/null +++ b/tests/corpus/7048-unary-number-coercions.mjs @@ -0,0 +1,34 @@ +// Unary plus and minus on booleans and on values that may be strings or +// undefined, and += on a binding that holds a number or a string. +function step(text, at) { + const open = text[at] === "["; + at += +open; + return [at, +open + +true + +false, -open]; +} +const at = JSON.parse("1"); +console.log(step("a[b", at), step("ab", at)); +let total = 0; +for (const flag of [true, false, true]) total += +flag; +console.log(total, +true, -true, +(1 > 2), -(2 > 1)); + +const match = "2024-01-02".match(/^(\d+)-(\d+)-(\d+)(?:T(\d+))?$/); +console.log(+match[1], +match[4], -match[2], +match[3] + 1, typeof +match[4], -match[4]); +const optional = [undefined, "7", " 8 ", "", "x"]; +console.log(optional.map((value) => +value), optional.map((value) => -value)); + +let fraction = 0; +const digits = "5"; +if (digits) { + fraction = digits.slice(0, 3); + while (fraction.length < 3) fraction += "0"; + fraction = +fraction; +} +console.log(fraction, typeof fraction); +let width = 0; +width = digits.repeat(2); +width += 1; +console.log(width, typeof width); +let label = "x"; +label += 5; +label += true; +console.log(label); diff --git a/tests/corpus/7049-member-assignment-values.mjs b/tests/corpus/7049-member-assignment-values.mjs new file mode 100644 index 000000000..b614ba308 --- /dev/null +++ b/tests/corpus/7049-member-assignment-values.mjs @@ -0,0 +1,20 @@ +// Member assignments used as values: the receiver, the key and the value are +// evaluated in order, and the expression yields the assigned value. +const log = []; +const holder = { get inner() { log.push("receiver"); return this._inner; }, _inner: {} }; +function value(v) { log.push("value"); return v; } +function key(k) { log.push("key"); return k; } +const r = holder.inner[key("k")] = value(5); +console.log(r, log.join(","), holder._inner.k); +const store = JSON.parse('{"a":{},"b":{}}'); +const t = { id: "x" }; +const out = store["a"][t.id] = store.b[t.id] = t; +console.log(out === t, JSON.stringify(store)); +let n; +const arr = [0, 0, 0]; +n = arr[1] = arr[2] = 7; +console.log(n, arr); +function Counter() { this.count = 0; } +Counter.prototype.bump = function () { return (this.count = this.count + 1); }; +const c = new Counter(); +console.log(c.bump(), c.bump(), c.count); diff --git a/tests/corpus/7050-date-subclass.mjs b/tests/corpus/7050-date-subclass.mjs new file mode 100644 index 000000000..c22250fc1 --- /dev/null +++ b/tests/corpus/7050-date-subclass.mjs @@ -0,0 +1,69 @@ +// A class that extends Date: private fields beside the time value, super() +// with each Date constructor form, an overriding toISOString that +// JSON.stringify reaches through Date.prototype.toJSON, and the inherited +// Date methods. +class Moment extends Date { + #zone = "Z"; + #precise = true; + constructor(value, zone) { + if (value === undefined) super(0); + else super(value); + if (zone !== undefined) this.#zone = zone; + } + get zone() { + return this.#zone; + } + coarse() { + this.#precise = false; + return this; + } + toISOString() { + const iso = super.toISOString(); + const base = this.#precise ? iso : iso.slice(0, 19) + "Z"; + return this.#zone === "Z" ? base : base.slice(0, -1) + this.#zone; + } +} + +const fromString = new Moment("2001-02-03T04:05:06.789Z"); +const fromNumber = new Moment(86400000, "+01:00"); +const fromDate = new Moment(new Date(Date.UTC(1999, 11, 31, 23, 59, 59))); +const fromMoment = new Moment(fromString); +const none = new Moment(); +console.log(fromString.toISOString(), fromNumber.toISOString(), fromDate.toISOString()); +console.log(fromMoment.getTime() === fromString.getTime(), none.getTime(), fromNumber.zone); +console.log(fromString.getUTCFullYear(), fromString.getUTCMonth(), fromString.getUTCDate(), fromString.getUTCHours(), fromString.getUTCMilliseconds()); +console.log(fromString instanceof Date, fromString instanceof Moment, new Date(0) instanceof Moment); +console.log(JSON.stringify({ fromString, fromNumber, list: [fromDate.coarse()] })); +console.log(fromNumber.toJSON(), JSON.stringify(fromNumber)); +console.log(String(fromDate).slice(0, 15), `${fromDate}`.slice(0, 15), fromDate.toUTCString()); +console.log(+fromNumber, +fromNumber - 1000, fromNumber.valueOf(), fromNumber + "" === String(fromNumber)); +console.log(fromString > fromNumber, fromString < fromNumber, fromString >= fromMoment); +console.log(fromNumber.setTime(1000), fromNumber.getTime(), fromNumber.toISOString()); +console.log(new Date(fromString).toISOString(), new Date(fromNumber).getTime()); +console.log(fromString, [fromNumber], { d: fromDate }); + +const invalid = new Moment("not a date"); +console.log(Number.isNaN(invalid.getTime()), JSON.stringify({ invalid }), invalid.toJSON(), String(invalid)); +console.log(invalid); +try { + invalid.toISOString(); +} catch (error) { + console.log(error instanceof RangeError, error.message); +} + +class LocalMoment extends Moment { + constructor(value) { + super(value, "local"); + } + toISOString() { + return super.toISOString().replace("local", ""); + } +} +const local = new LocalMoment(0); +console.log(local.toISOString(), JSON.stringify([local]), local instanceof Moment, local.zone); + +// The field constructor and Date's statics, which the subclass inherits. +class Plain extends Date {} +const fields = new Plain(2020, 0, 15, 10, 30); +console.log(fields.getFullYear(), fields.getMonth(), fields.getDate(), fields.getHours(), fields.getMinutes()); +console.log(Plain.UTC(2000, 0, 1), Plain.parse("2000-01-01T00:00:00Z"), typeof Plain.now(), Object.keys(fields)); diff --git a/tests/corpus/7051-date-subclass-typed.ts b/tests/corpus/7051-date-subclass-typed.ts new file mode 100644 index 000000000..e39b5f534 --- /dev/null +++ b/tests/corpus/7051-date-subclass-typed.ts @@ -0,0 +1,47 @@ +// A TypeScript class that extends Date, and a subclass of it: typed calls +// of the inherited Date methods, conversions, comparisons, JSON and +// console output, with the toISOString override visible to toJSON. +class Stamp extends Date { + #precise: boolean; + label = "stamp"; + constructor(value: number | string, precise = false) { + super(value); + this.#precise = precise; + } + override toISOString(): string { + const iso = super.toISOString(); + return this.#precise ? iso : iso.slice(0, 19) + "Z"; + } + shifted(ms: number): Stamp { + return new Stamp(this.getTime() + ms, this.#precise); + } +} + +class Tick extends Stamp { + constructor(value: number) { + super(value, true); + } + seconds(): number { + return this.getUTCSeconds() + this.getUTCMilliseconds() / 1000; + } +} + +const a = new Stamp("2001-02-03T04:05:06.789Z"); +const b = new Tick(1500); +console.log(a.toISOString(), b.toISOString(), a.getTime(), b.seconds()); +console.log(a instanceof Date, b instanceof Stamp, b instanceof Date, a.shifted(1000).toISOString()); +console.log(JSON.stringify({ a, b, list: [a] }), JSON.stringify(a), a.toJSON(), b.toJSON()); +console.log(String(a).slice(0, 15), `${b}`.slice(0, 15), +a, b.valueOf(), a.getTime() - b.getTime()); +console.log(a < b, a > b, a >= b, a == a, a + "!" === String(a) + "!"); +console.log(a); +console.log([b], { b }); +console.log(a.setTime(5000), a.getTime(), a.toISOString(), a.label); + +const items: Stamp[] = [a, b, new Tick(0)]; +items.sort((x, y) => x.getTime() - y.getTime()); +console.log(items.map((s) => s.toISOString()).join(",")); +console.log(items.filter((s) => s instanceof Tick).length); +function describe(value: Stamp | string): string { + return typeof value === "string" ? value : value.toISOString(); +} +console.log(describe(b), describe("text")); diff --git a/tests/corpus/7052-date-subclass-dynamic.mjs b/tests/corpus/7052-date-subclass-dynamic.mjs new file mode 100644 index 000000000..267c01ded --- /dev/null +++ b/tests/corpus/7052-date-subclass-dynamic.mjs @@ -0,0 +1,43 @@ +// Instances of a class that extends Date held in values typed only at run +// time: method calls, method values, conversions and instanceof through +// those values, and JSON and console output of the containers. +class Day extends Date { + #label; + constructor(value, label) { + super(value); + this.#label = label; + } + get label() { + return this.#label; + } + toISOString() { + return super.toISOString().slice(0, 10); + } +} +class Plain extends Date {} + +const box = JSON.parse('{"items":[],"byName":{}}'); +box.items.push(new Day(Date.UTC(2020, 1, 29), "leap"), new Plain(0), new Date(1000), "text"); +box.byName.first = box.items[0]; + +function inspect(value) { + if (!(value instanceof Date)) return "not a date: " + value; + return [value.toISOString(), value.getTime(), value.getUTCDate(), value instanceof Day, value.toJSON()].join(" | "); +} +for (const item of box.items) console.log(inspect(item)); +console.log(JSON.stringify(box)); +console.log(box.byName.first.label, box.byName.first.getUTCFullYear(), String(box.items[1]).slice(0, 15)); +console.log(+box.items[0], box.items[0] - box.items[1], box.items[0] > box.items[2], `${box.items[1]}`.slice(0, 3)); + +const getTime = box.items[0].getTime; +console.log(getTime.call(box.items[1]), getTime.call(box.items[0]), typeof getTime); +const toISO = box.items[0].toISOString; +console.log(toISO.call(box.items[0])); +console.log(box.items[1].setTime(5000), box.items[1].getTime(), box.items[1].toISOString()); +try { + getTime.call({}); +} catch (error) { + console.log(error instanceof TypeError); +} +console.log(box.items); +console.log(new Date(box.items[0]).toISOString(), new Date(box.items[1]).getTime()); diff --git a/tests/corpus/7053-private-fields-untyped-receivers.mjs b/tests/corpus/7053-private-fields-untyped-receivers.mjs new file mode 100644 index 000000000..815f612b0 --- /dev/null +++ b/tests/corpus/7053-private-fields-untyped-receivers.mjs @@ -0,0 +1,72 @@ +// Private fields read and written through receivers whose type is known only +// at run time: static factories and helpers that take the instance as an +// argument, compound assignments and updates, `#x in value`, subclasses, and +// Node's TypeErrors for values that do not carry the field. +class Counter { + #count = 0; + #label = null; + constructor(label) { + this.#label = label; + } + static labeled(label, start) { + let counter = new Counter("pending"); + counter.#label = label; + counter.#count = start; + return counter; + } + static read(counter) { + return [counter.#label, counter.#count]; + } + static bump(counter, by) { + counter.#count += by; + counter.#count++; + ++counter.#count; + return counter.#count; + } + static clear(counter) { + counter.#label = null; + return counter; + } + static owns(value) { + return #count in value; + } + describe() { + return `${this.#label}:${this.#count}`; + } +} +class LimitedCounter extends Counter { + #limit = 3; + static limit(value) { + return value.#limit; + } +} + +const made = Counter.labeled("made", 5); +console.log(made.describe(), Counter.read(made), Counter.bump(made, 10), made.describe()); +const held = JSON.parse('{"list":[]}'); +held.list.push(new Counter("held"), new LimitedCounter("limited")); +for (const item of held.list) console.log(Counter.read(item), Counter.bump(item, 1), item.describe(), Counter.owns(item)); +console.log(LimitedCounter.limit(held.list[1]), Counter.clear(held.list[0]).describe()); +for (const value of [{}, [], null, undefined, 1, "text", held.list[0]]) { + try { + console.log(Counter.read(value)); + } catch (error) { + console.log("read", error instanceof TypeError, error.message); + } + try { + Counter.bump(value, 1); + console.log("bumped"); + } catch (error) { + console.log("bump", error instanceof TypeError, error.message); + } + try { + console.log(LimitedCounter.limit(value)); + } catch (error) { + console.log("limit", error instanceof TypeError, error.message); + } + try { + console.log("owns", Counter.owns(value)); + } catch (error) { + console.log("owns", error instanceof TypeError, error.message); + } +} diff --git a/tests/corpus/7054-let-bindings-with-null-writes.mjs b/tests/corpus/7054-let-bindings-with-null-writes.mjs new file mode 100644 index 000000000..c8ca26a9d --- /dev/null +++ b/tests/corpus/7054-let-bindings-with-null-writes.mjs @@ -0,0 +1,37 @@ +// `let` bindings initialized with a string, number or boolean and later +// assigned values that can be null or undefined. JavaScript files are +// checked without strict null checks, so the declared type of each binding +// is the primitive alone. +const PATTERN = /^(\d+)(?:\.(\d+))?([+-]\d\d:\d\d)?$/; +function parts(text) { + let offset = "Z"; + let fraction = 0; + let signed = false; + const match = text.match(PATTERN); + if (match) { + offset = match[3] || null; + fraction = match[2] ? +match[2] : undefined; + signed = match[3] ? match[3][0] === "-" : null; + } + return [offset, fraction, signed]; +} +console.log(parts("12"), parts("12.5"), parts("12.25-01:00"), parts("x")); + +function pick(flag) { + let name = "default"; + name = flag ? name.toUpperCase() : void 0; + let count = 1; + count = flag && count + 1; + let ready = true; + ready = flag === undefined ? undefined : !flag; + return [name, count, ready, typeof name, typeof count]; +} +console.log(pick(true), pick(false), pick(undefined)); + +let last = "start"; +const seen = []; +for (const value of ["a", null, "b", undefined]) { + last = value ?? null; + seen.push(last === null ? "null" : last.length); +} +console.log(seen, last); diff --git a/tests/fixtures/npm-static/js-yaml-cli.mjs b/tests/fixtures/npm-static/js-yaml-cli.mjs new file mode 100644 index 000000000..8c958cf80 --- /dev/null +++ b/tests/fixtures/npm-static/js-yaml-cli.mjs @@ -0,0 +1,63 @@ +// The published js-yaml package compiled as static modules: loading, dumping, +// schemas, custom types and the YAMLException errors it throws. +import yaml from "js-yaml"; +const text = ` +# config +name: demo +version: 1.2 +count: 0x1F +octal: 0o17 +neg: -12_000 +flt: 6.02e+23 +inf: .inf +nan: .NaN +on: yes +off: false +nil: ~ +date: 2001-12-14 +stamp: 2001-12-14t21:59:43.10-05:00 +str: "quoted \\u263A \\t tab" +single: 'it''s' +multi: | + line one + line two +folded: >- + folded + text +base: &base { a: 1, b: [x, y] } +derived: + <<: *base + c: 3 +list: + - one + - { k: v } + - [1, 2, 3] + - !!str 123 +set: !!set { a, b } +omap: !!omap [ { x: 1 }, { y: 2 } ] +binary: !!binary aGVsbG8= +`; +const doc = yaml.load(text); +console.log(JSON.stringify(doc, (k, v) => (v instanceof Uint8Array ? Array.from(v) : v))); +console.log(doc.stamp instanceof Date, doc.stamp.toISOString(), doc.date.toISOString(), Object.is(doc.nan, NaN) || Number.isNaN(doc.nan)); +const docs = yaml.loadAll("---\na: 1\n---\nb: 2\n...\n"); +console.log(JSON.stringify(docs)); +const items = []; +yaml.loadAll("--- 1\n--- two\n", (d) => items.push(d)); +console.log(items); +console.log(yaml.dump(doc, { sortKeys: true, lineWidth: 40, skipInvalid: true })); +console.log(yaml.dump({ a: "multi\nline\n", b: " lead", c: "yes", d: "123", e: null, f: [], g: {}, h: "x: y", i: -0, j: 1e21 }, { indent: 4 })); +console.log(yaml.dump([{ deep: { er: [1, { z: true }] } }], { flowLevel: 2 })); +console.log(yaml.dump({ s: "a'b\"c", u: "é☺", long: "word ".repeat(30).trim() }, { quotingType: '"', forceQuotes: true })); +for (const bad of ["a: [1", "a: b: c", "- a\nb: 1", "key: 'open", "a: !!int x", "? a\n? a\n", "&x a: *y"]) { + try { yaml.load(bad); console.log("no error", bad); } + catch (e) { console.log(e.name, "|", e.reason, "|", e.mark && e.mark.line, e.mark && e.mark.column, "|", e.message.split("\n")[0]); console.log(e.toString(true)); console.log(String(e).split("\n").length); } +} +try { yaml.load("a: 1\na: 2"); } catch (e) { console.log(e instanceof yaml.YAMLException, e instanceof Error, e.message); } +console.log(JSON.stringify(yaml.load("a: 1\na: 2", { json: true }))); +console.log(JSON.stringify(yaml.load("x: 1", { schema: yaml.JSON_SCHEMA })), JSON.stringify(yaml.load("x: yes", { schema: yaml.FAILSAFE_SCHEMA })), JSON.stringify(yaml.load("x: yes", { schema: yaml.CORE_SCHEMA }))); +const Point = new yaml.Type("!point", { kind: "sequence", construct: (d) => ({ x: d[0], y: d[1] }), instanceOf: Object, represent: (p) => [p.x, p.y] }); +const schema = yaml.DEFAULT_SCHEMA.extend([Point]); +console.log(JSON.stringify(yaml.load("p: !point [3, 4]", { schema }))); +try { yaml.dump({ f() {} }); } catch (e) { console.log(e.name, e.message); } +console.log(yaml.dump({ f() {}, u: undefined, k: 1 }, { skipInvalid: true })); diff --git a/tests/fixtures/npm-static/smol-toml-cli.mjs b/tests/fixtures/npm-static/smol-toml-cli.mjs new file mode 100644 index 000000000..453e16801 --- /dev/null +++ b/tests/fixtures/npm-static/smol-toml-cli.mjs @@ -0,0 +1,68 @@ +// The published smol-toml package compiled as static modules: parsing every +// value kind, the TomlDate subclass of Date, stringify and TomlError. +import { parse, stringify, TomlDate, TomlError } from "smol-toml"; +const text = ` +# a document +title = "TOML \\"example\\"" +int = +99 +neg = -17 +hex = 0xDEADBEEF +oct = 0o755 +bin = 0b1101 +under = 1_000_000 +float = 6.626e-34 +inf = inf +nan = nan +bool = true +odt1 = 1979-05-27T07:32:00Z +odt2 = 1979-05-27T00:32:00-07:00 +odt3 = 1979-05-27T00:32:00.999999-07:00 +ldt = 1979-05-27T07:32:00 +ld = 1979-05-27 +lt = 07:32:00.123 +space = 1979-05-27 07:32:00Z +literal = 'C:\\Users\\nodejs\\templates' +multi = """ +Roses are red +Violets are blue""" +lmulti = ''' +The first newline is +trimmed in raw strings.''' + +[owner] +name = "Tom" +"quoted key" = 1 +dotted.inner.key = "x" + +[database] +ports = [ 8000, 8001, 8002 ] +data = [ ["delta", "phi"], [3.14] ] +temp_targets = { cpu = 79.5, case = 72.0 } + +[[products]] +name = "Hammer" +sku = 738594937 + +[[products]] + +[[products]] +name = "Nail" +color = "gray" +`; +const doc = parse(text); +console.log(JSON.stringify(doc, null, 1)); +for (const key of ["odt1", "odt2", "odt3", "ldt", "ld", "lt", "space"]) { + const d = doc[key]; + console.log(key, d instanceof Date, d instanceof TomlDate, d.isDateTime(), d.isLocal(), d.isDate(), d.isTime(), d.isValid(), d.toISOString(), Number.isNaN(d.getTime()) ? "NaN" : d.getTime()); +} +console.log(Number.isNaN(doc.nan), doc.inf, typeof doc.hex, doc.under); +console.log(stringify(doc)); +console.log(stringify({ a: new Date(0), b: TomlDate.wrapAsLocalDate(new Date(86400000)), c: new TomlDate("10:20:30"), n: [1, [2, 3]], t: { u: { v: "w" } }, s: "quote\" and \\ backslash", f: 1.5, i: 2, big: 2n ** 40n })); +const d = new TomlDate("2020-02-29T12:00:00+01:00"); +console.log(d.toISOString(), JSON.stringify({ d }), String(d.getUTCHours()), d.valueOf()); +const bad = new TomlDate("not a date"); +console.log(bad.isValid(), Number.isNaN(bad.getTime())); +for (const src of ["a = ", "a = 1\na = 2", "[t]\n[t]", "x = [1,", "k = 1979-13-01", "s = \"unterminated", "= 1", "a = 25:00:00"]) { + try { parse(src); console.log("parsed", JSON.stringify(src)); } + catch (e) { console.log(e instanceof TomlError, e instanceof Error, e.name, e.line, e.column, e.message.split("\n")[0]); } +} diff --git a/tests/harness/corpus-costs/7040-es5-error-constructor.mjs.json b/tests/harness/corpus-costs/7040-es5-error-constructor.mjs.json new file mode 100644 index 000000000..40dc942dc --- /dev/null +++ b/tests/harness/corpus-costs/7040-es5-error-constructor.mjs.json @@ -0,0 +1 @@ +{ "plain": 3648, "san": 32315 } diff --git a/tests/harness/corpus-costs/7041-error-called-without-new.mjs.json b/tests/harness/corpus-costs/7041-error-called-without-new.mjs.json new file mode 100644 index 000000000..d5a7a927c --- /dev/null +++ b/tests/harness/corpus-costs/7041-error-called-without-new.mjs.json @@ -0,0 +1 @@ +{ "plain": 2293, "san": 3259 } diff --git a/tests/harness/corpus-costs/7042-string-method-names-on-objects.mjs.json b/tests/harness/corpus-costs/7042-string-method-names-on-objects.mjs.json new file mode 100644 index 000000000..e85a6cc3e --- /dev/null +++ b/tests/harness/corpus-costs/7042-string-method-names-on-objects.mjs.json @@ -0,0 +1 @@ +{ "plain": 2776, "san": 20012 } diff --git a/tests/harness/corpus-costs/7043-date-set-time.mjs.json b/tests/harness/corpus-costs/7043-date-set-time.mjs.json new file mode 100644 index 000000000..cdb4d4f92 --- /dev/null +++ b/tests/harness/corpus-costs/7043-date-set-time.mjs.json @@ -0,0 +1 @@ +{ "plain": 2423, "san": 3371 } diff --git a/tests/harness/corpus-costs/7044-nested-empty-object-maps.mjs.json b/tests/harness/corpus-costs/7044-nested-empty-object-maps.mjs.json new file mode 100644 index 000000000..a7951b37e --- /dev/null +++ b/tests/harness/corpus-costs/7044-nested-empty-object-maps.mjs.json @@ -0,0 +1 @@ +{ "plain": 2671, "san": 3931 } diff --git a/tests/harness/corpus-costs/7045-instanceof-constructor-values.mjs.json b/tests/harness/corpus-costs/7045-instanceof-constructor-values.mjs.json new file mode 100644 index 000000000..1776c882d --- /dev/null +++ b/tests/harness/corpus-costs/7045-instanceof-constructor-values.mjs.json @@ -0,0 +1 @@ +{ "plain": 2726, "san": 4330 } diff --git a/tests/harness/corpus-costs/7046-parse-float-extra-arguments.mjs.json b/tests/harness/corpus-costs/7046-parse-float-extra-arguments.mjs.json new file mode 100644 index 000000000..2e8f43953 --- /dev/null +++ b/tests/harness/corpus-costs/7046-parse-float-extra-arguments.mjs.json @@ -0,0 +1 @@ +{ "plain": 2204, "san": 3269 } diff --git a/tests/harness/corpus-costs/7047-dynamic-string-index.mjs.json b/tests/harness/corpus-costs/7047-dynamic-string-index.mjs.json new file mode 100644 index 000000000..d73f3cccc --- /dev/null +++ b/tests/harness/corpus-costs/7047-dynamic-string-index.mjs.json @@ -0,0 +1 @@ +{ "plain": 2451, "san": 3411 } diff --git a/tests/harness/corpus-costs/7048-unary-number-coercions.mjs.json b/tests/harness/corpus-costs/7048-unary-number-coercions.mjs.json new file mode 100644 index 000000000..710783451 --- /dev/null +++ b/tests/harness/corpus-costs/7048-unary-number-coercions.mjs.json @@ -0,0 +1 @@ +{ "plain": 2478, "san": 3675 } diff --git a/tests/harness/corpus-costs/7049-member-assignment-values.mjs.json b/tests/harness/corpus-costs/7049-member-assignment-values.mjs.json new file mode 100644 index 000000000..551cfbf7b --- /dev/null +++ b/tests/harness/corpus-costs/7049-member-assignment-values.mjs.json @@ -0,0 +1 @@ +{ "plain": 2456, "san": 3617 } diff --git a/tests/harness/corpus-costs/7050-date-subclass.mjs.json b/tests/harness/corpus-costs/7050-date-subclass.mjs.json new file mode 100644 index 000000000..e21289735 --- /dev/null +++ b/tests/harness/corpus-costs/7050-date-subclass.mjs.json @@ -0,0 +1 @@ +{ "plain": 2932, "san": 3727 } diff --git a/tests/harness/corpus-costs/7051-date-subclass-typed.ts.json b/tests/harness/corpus-costs/7051-date-subclass-typed.ts.json new file mode 100644 index 000000000..fad282486 --- /dev/null +++ b/tests/harness/corpus-costs/7051-date-subclass-typed.ts.json @@ -0,0 +1 @@ +{ "plain": 2533, "san": 3429 } diff --git a/tests/harness/corpus-costs/7052-date-subclass-dynamic.mjs.json b/tests/harness/corpus-costs/7052-date-subclass-dynamic.mjs.json new file mode 100644 index 000000000..cabbe475e --- /dev/null +++ b/tests/harness/corpus-costs/7052-date-subclass-dynamic.mjs.json @@ -0,0 +1 @@ +{ "plain": 2740, "san": 3689 } diff --git a/tests/harness/corpus-costs/7053-private-fields-untyped-receivers.mjs.json b/tests/harness/corpus-costs/7053-private-fields-untyped-receivers.mjs.json new file mode 100644 index 000000000..8ebe6846a --- /dev/null +++ b/tests/harness/corpus-costs/7053-private-fields-untyped-receivers.mjs.json @@ -0,0 +1 @@ +{ "plain": 2415, "san": 3338 } diff --git a/tests/harness/corpus-costs/7054-let-bindings-with-null-writes.mjs.json b/tests/harness/corpus-costs/7054-let-bindings-with-null-writes.mjs.json new file mode 100644 index 000000000..d313a64f1 --- /dev/null +++ b/tests/harness/corpus-costs/7054-let-bindings-with-null-writes.mjs.json @@ -0,0 +1 @@ +{ "plain": 2293, "san": 3012 } diff --git a/tests/harness/npm-static-costs.json b/tests/harness/npm-static-costs.json index 2f1cdde1e..1546f8d57 100644 --- a/tests/harness/npm-static-costs.json +++ b/tests/harness/npm-static-costs.json @@ -84,6 +84,8 @@ "the published Effect Function subpath initializes and runs statically": 9097, "the published Effect generator has deterministic native results": 105577, "the published Effect generator logs and completes statically": 112814, + "the published js-yaml loads, dumps and reports errors statically and matches Node": 12728, + "the published smol-toml parses and stringifies statically and matches Node": 11649, "untyped package methods preserve virtual overrides (llvm)": 3065 }, "san": { @@ -171,6 +173,8 @@ "the published Effect Function subpath initializes and runs statically": 8280, "the published Effect generator has deterministic native results": 136502, "the published Effect generator logs and completes statically": 181378, + "the published js-yaml loads, dumps and reports errors statically and matches Node": 35621, + "the published smol-toml parses and stringifies statically and matches Node": 25130, "untyped package methods preserve virtual overrides (llvm)": 2730 } } diff --git a/tests/harness/npm-static.test.ts b/tests/harness/npm-static.test.ts index df82efbcf..7ee76307f 100644 --- a/tests/harness/npm-static.test.ts +++ b/tests/harness/npm-static.test.ts @@ -1175,6 +1175,38 @@ describe(`npm-static pilots${sanitize ? " (sanitized)" : ""}`, () => { effectBuildTimeout, ); + test("the published js-yaml loads, dumps and reports errors statically and matches Node", async () => { + const entry = join(pilotRoot, "js-yaml-cli.mjs"); + const { coverage } = analyze(entry, { npmStatic: ["js-yaml"] }); + expect(coverage.npmStatic).toEqual([{ package: "js-yaml", status: "static" }]); + expect(coverage.diagnostics).toHaveLength(0); + const binary = await buildStatic(entry, ["js-yaml"]); + const [reference, native] = await Promise.all([ + runBinary(process.execPath, [entry]), + runBinary(binary, []), + ]); + expect(native.stdout.toString()).toBe(reference.stdout.toString()); + expect(comparableStderr(native.stderr)).toEqual(reference.stderr); + expect(native.exitCode).toBe(reference.exitCode); + expect(native.exitCode).toBe(0); + }, 300_000); + + test("the published smol-toml parses and stringifies statically and matches Node", async () => { + const entry = join(pilotRoot, "smol-toml-cli.mjs"); + const { coverage } = analyze(entry, { npmStatic: ["smol-toml"] }); + expect(coverage.npmStatic).toEqual([{ package: "smol-toml", status: "static" }]); + expect(coverage.diagnostics).toHaveLength(0); + const binary = await buildStatic(entry, ["smol-toml"]); + const [reference, native] = await Promise.all([ + runBinary(process.execPath, [entry]), + runBinary(binary, []), + ]); + expect(native.stdout.toString()).toBe(reference.stdout.toString()); + expect(comparableStderr(native.stderr)).toEqual(reference.stderr); + expect(native.exitCode).toBe(reference.exitCode); + expect(native.exitCode).toBe(0); + }, 300_000); + test("inferred variadic factories preserve checked callable results", async () => { const entry = join(pilotRoot, "variadic-factory-cli.ts"); const binary = await buildStatic(entry, ["variadic-factory"]); From 42d4ca27f9733f3f64b3d0909bc6042d71a8351c Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Wed, 21 Oct 2026 23:40:42 -0500 Subject: [PATCH 009/102] Run Promise.all of never-suspending async calls in place from stackless async bodies --- packages/compiler/src/backend/llvm/emitter.ts | 215 ++++++++++++++++++ .../compiler/src/backend/llvm/expr-async.ts | 6 + .../compiler/test/await-call-emission.test.ts | 45 ++++ .../7100-promise-all-inline-order.ts.json | 6 + ...7101-promise-all-inline-sync-throw.ts.json | 6 + .../7102-promise-all-inline-kinds.ts.json | 6 + tests/corpus/7100-promise-all-inline-order.ts | 86 +++++++ .../7101-promise-all-inline-sync-throw.ts | 21 ++ tests/corpus/7102-promise-all-inline-kinds.ts | 69 ++++++ .../7100-promise-all-inline-order.ts.json | 1 + ...7101-promise-all-inline-sync-throw.ts.json | 1 + .../7102-promise-all-inline-kinds.ts.json | 1 + 12 files changed, 463 insertions(+) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7100-promise-all-inline-order.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7101-promise-all-inline-sync-throw.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7102-promise-all-inline-kinds.ts.json create mode 100644 tests/corpus/7100-promise-all-inline-order.ts create mode 100644 tests/corpus/7101-promise-all-inline-sync-throw.ts create mode 100644 tests/corpus/7102-promise-all-inline-kinds.ts create mode 100644 tests/harness/corpus-costs/7100-promise-all-inline-order.ts.json create mode 100644 tests/harness/corpus-costs/7101-promise-all-inline-sync-throw.ts.json create mode 100644 tests/harness/corpus-costs/7102-promise-all-inline-kinds.ts.json diff --git a/packages/compiler/src/backend/llvm/emitter.ts b/packages/compiler/src/backend/llvm/emitter.ts index 0bdbe23b2..b306674fc 100644 --- a/packages/compiler/src/backend/llvm/emitter.ts +++ b/packages/compiler/src/backend/llvm/emitter.ts @@ -287,6 +287,7 @@ import { import { arrNewCall, boxAccess, + elemAccess, boxNewCall, boxReleaseSym, computeTraced, @@ -571,6 +572,33 @@ function mentionsLocal(e: IrExpr, localId: string): boolean { return found; } +/** The IR nodes in `body` that name local `id`: its declaration, reads, + * writes and closure captures. */ +function countLocalMentions(body: readonly IrStmt[], id: string): number { + let count = 0; + const visit = (node: unknown): void => { + if (node === null || typeof node !== "object") return; + if (Array.isArray(node)) { + for (const item of node) visit(item); + return; + } + const record = node as Record; + if (record["localId"] === id) count++; + const captures = record["captures"]; + if (Array.isArray(captures)) + for (const c of captures) + if ( + c === id || + (typeof c === "object" && c !== null && (c as { localId?: unknown }).localId === id) + ) + count++; + for (const [key, value] of Object.entries(record)) + if (key !== "type" && key !== "loc" && key !== "captures") visit(value); + }; + visit(body); + return count; +} + export class LlEmitter { localArrayReads = new Map(); loopArrayBorrows: ReadonlySet = new Set(); @@ -864,6 +892,9 @@ export class LlEmitter { /** The async functions whose bodies never suspend and that a direct * await may enter in place (selectStacklessAsync). */ private inlineAwaitable = new Set(); + /** Locals whose array literal emitStmts left for the `await Promise.all` + * that reads them (deferredPromiseAllLocal). */ + private readonly deferredPromiseAllEntries = new Map>(); /** The promise a `return` emitted past its finally regions already * produced for its adopting await (borrowed from the return's parked * slot); that await takes it instead of evaluating its operand. */ @@ -1945,6 +1976,185 @@ export class LlEmitter { this.emitPendingCheck(); return value; } + /** The entries of `Promise.all(arg)` that a stackless coroutine body's + * await may run in place (emitCoroInlinePromiseAll): `arg` is a non-empty + * array literal, or the local whose declaration emitStmts deferred to this + * await (deferredPromiseAllEntries), whose every entry is a call to a + * never-suspending async function, and the result is an array. Null + * otherwise. Consumes a deferred local's entries. */ + inlinePromiseAllEntries(all: ExprOf<"intrinsic">): ExprOf<"arrayLit"> | null { + if (all.name !== "promise.all" || all.type.kind !== "promise") return null; + if (all.type.inner.kind !== "array") return null; + const arg = all.args[0]; + if (arg?.kind === "varRef") { + const deferred = this.deferredPromiseAllEntries.get(arg.localId); + if (deferred === undefined) return null; + this.deferredPromiseAllEntries.delete(arg.localId); + return deferred; + } + return arg?.kind === "arrayLit" && this.promiseAllInlineable(arg) ? arg : null; + } + + /** Whether every entry of `entries` is a call an await could run in place + * (inlineAwaitEligible) that yields its promise's inner type. */ + private promiseAllInlineable(entries: ExprOf<"arrayLit">): boolean { + if (entries.elems.length === 0 || (entries.spreads?.length ?? 0) > 0) return false; + if (entries.type.kind !== "array" || entries.type.elem.kind !== "promise") return false; + const inner = entries.type.elem.inner; + return entries.elems.every((el) => { + if (el.kind !== "call" || !this.inlineAwaitEligible(el.callee)) return false; + const callee = this.fnByName.get(el.callee)!; + return typeEquals(callee.returnType, inner) && !this.callLifetimes.borrowed.has(el.callee); + }); + } + + /** Whether `stmts[i]` declares a local holding an array literal that only + * `stmts[i + 1]` reads, as the operand of `await Promise.all(local)` that + * runs first in that statement and may run its entries in place. Nothing + * runs between the literal and the await, so the await evaluates the + * literal itself (inlinePromiseAllEntries). Debug builds keep the local. */ + deferredPromiseAllLocal(stmts: readonly IrStmt[], i: number): ExprOf<"arrayLit"> | null { + const decl = stmts[i]; + const next = stmts[i + 1]; + if (this.debug !== null || decl?.kind !== "varDecl" || decl.init?.kind !== "arrayLit") + return null; + if (this.currentCoro?.kind !== "async" || next === undefined) return null; + const operand = + next.kind === "varDecl" + ? next.init + : next.kind === "exprStmt" + ? next.expr + : next.kind === "assign" + ? next.value + : null; + if (operand?.kind !== "awaitExpr" || operand.adopt === true) return null; + const all = operand.value; + if (all.kind !== "intrinsic" || all.name !== "promise.all" || all.type.kind !== "promise") + return null; + if (all.type.inner.kind !== "array") return null; + const arg = all.args[0]; + if (arg?.kind !== "varRef" || arg.localId !== decl.localId) return null; + if (!this.promiseAllInlineable(decl.init)) return null; + if (this.currentLocals.get(decl.localId)?.boxed) return null; + // The declaration and this read are the local's only mentions. + return countLocalMentions(this.currentFunctionBody, decl.localId) === 2 ? decl.init : null; + } + + /** A stackless coroutine body's `await Promise.all([f(...), ...])` of + * never-suspending calls, with Promise.all's turns and without its + * promises: the entries run in place in order and their values fill the + * result array. Promise.all queues one reaction job per entry, back to + * back, and the last of them settles the result, whose await then takes a + * turn: here one turn stands for the entries' jobs and a second for the + * await. A throwing entry becomes the rejection the await re-throws from + * its turn; the remaining entries still run, and later throws are handled + * rejections, as Promise.all's subscriptions make them. */ + emitCoroInlinePromiseAll(entries: ExprOf<"arrayLit">, type: IrType): LlValue { + if (type.kind !== "array") + throw new InternalCompilerError("llvm emitter bug: inline Promise.all result"); + const B = this.B; + const elem = type.elem; + const acc = elemAccess(elem); + const values = B.tmp(); + // Up to three values fit in the array's own block (scr_arr_new_*_small). + const small = entries.elems.length <= 3; + B.line( + `${values} = ${arrNewCall(this.shapeHost, elem, small ? "0" : String(entries.elems.length), small)}`, + ); + const out = this.own({ name: values, type }); + this.declare(`declare ptr @scr_promise_new()`); + this.declare(`declare void @scr_promise_reject_pending(ptr)`); + this.declare(`declare void @scr_promise_mark_handled(ptr)`); + const promiseType = entries.type.kind === "array" ? entries.type.elem : type; + // Each entry's rejection, owned by the frame: unobserved until the + // entries have all run, as Promise.all subscribes only then, so an + // entry argument's synchronous throw leaves them unhandled. + const rejections: string[] = []; + for (const entry of entries.elems) { + if (entry.kind !== "call") + throw new InternalCompilerError("llvm emitter bug: inline Promise.all entry"); + const slot = B.tmp(); + B.entryAllocas.push(`${slot} = alloca ptr`); + B.line(`store ptr null, ptr ${slot}`); + this.ownSlot(slot, promiseType); + rejections.push(slot); + const value = emitCallExpr(this, entry, "inline"); + const thrown = B.tmp(); + for (const line of this.pendingTestLines(thrown)) B.line(line.trim()); + const clean = B.newLabel("pa.clean"); + const rejected = B.newLabel("pa.rejected"); + const next = B.newLabel("pa.next"); + B.condBr(thrown, rejected, clean); + B.startBlock(clean); + if (acc === "ref") this.toHeap(value); + this.arrPush(values, acc, value.name); + B.br(next); + B.startBlock(rejected); + const promise = B.tmp(); + B.line(`${promise} = call ptr @scr_promise_new()`); + B.line(`call void @scr_promise_reject_pending(ptr ${promise})`); + B.line(`store ptr ${promise}, ptr ${slot}`); + B.br(next); + B.startBlock(next); + } + // Promise.all's subscriptions handle every rejection, and the first + // (in entry order) rejects the result. + let first = "null"; + for (let k = rejections.length - 1; k >= 0; k--) { + const slot = rejections[k]!; + const rejection = B.tmp(); + const present = B.tmp(); + B.line(`${rejection} = load ptr, ptr ${slot}`); + B.line(`${present} = icmp ne ptr ${rejection}, null`); + const mark = B.newLabel("pa.handled"); + const after = B.newLabel("pa.unrejected"); + B.condBr(present, mark, after); + B.startBlock(mark); + B.line(`call void @scr_promise_mark_handled(ptr ${rejection})`); + B.br(after); + B.startBlock(after); + const chosen = B.tmp(); + B.line(`${chosen} = select i1 ${present}, ptr ${rejection}, ptr ${first}`); + first = chosen; + } + // The entries' reaction jobs. + this.emitCoroAwait(null); + const failed = B.tmp(); + B.line(`${failed} = icmp ne ptr ${first}, null`); + const fulfilled = B.newLabel("pa.fulfilled"); + const rejected = B.newLabel("pa.reject"); + const join = B.newLabel("pa.join"); + B.condBr(failed, rejected, fulfilled); + B.startBlock(fulfilled); + this.emitCoroAwait(null); + B.br(join); + B.startBlock(rejected); + this.declare(`declare void @scr_coro_await_void(ptr)`); + this.emitCoroAwait(first); + B.line(`call void @scr_coro_await_void(ptr ${first})`); + B.br(join); + B.startBlock(join); + // The rejections are released here, only where an entry threw, rather + // than by the frame, which releases each slot whether or not it holds a + // promise. + this.declare(`declare void @scr_promise_release(ptr)`); + for (const slot of rejections) { + const rejection = B.tmp(); + const present = B.tmp(); + B.line(`${rejection} = load ptr, ptr ${slot}`); + B.line(`${present} = icmp ne ptr ${rejection}, null`); + const release = B.newLabel("pa.release"); + const after = B.newLabel("pa.released"); + B.condBr(present, release, after); + B.startBlock(release); + B.line(`call void @scr_promise_release(ptr ${rejection})`); + B.br(after); + B.startBlock(after); + } + this.disownSlots(rejections.map((ptr) => ({ ptr }))); + this.emitPendingCheck(); + return out; + } emitAsyncAwaitCall(fn: IrFunction, argPackLines: string[] | null, adopt = false): string[] { return emitAsyncAwaitCall(this, fn, argPackLines, adopt); } @@ -4499,6 +4709,11 @@ export class LlEmitter { if (this.B.isTerminated()) return; if (cursor) cursor.index = i; this.stmtCursor = cursor; + const deferred = this.deferredPromiseAllLocal(stmts, i); + if (deferred !== null) { + this.deferredPromiseAllEntries.set((stmts[i] as { localId: string }).localId, deferred); + continue; + } this.emitStmt(stmts[i]!); } } finally { diff --git a/packages/compiler/src/backend/llvm/expr-async.ts b/packages/compiler/src/backend/llvm/expr-async.ts index 6da63977d..4d73d0904 100644 --- a/packages/compiler/src/backend/llvm/expr-async.ts +++ b/packages/compiler/src/backend/llvm/expr-async.ts @@ -901,6 +901,12 @@ export function emitAsyncExpr( // the callee's adopting entry. Past finally regions, the return has // already produced the promise (adoptedOperand). const adopted = e.adopt === true ? host.takeAdoptedOperand() : null; + // A stackless coroutine body runs the entries of `Promise.all` of + // never-suspending calls in place and takes Promise.all's turns. + if (adopted === null && e.value.kind === "intrinsic" && host.currentCoro?.kind === "async") { + const entries = host.inlinePromiseAllEntries(e.value); + if (entries !== null) return host.emitCoroInlinePromiseAll(entries, e.type); + } // A stackless coroutine body runs a never-suspending callee in place // and takes the await's turn itself. if (adopted === null && e.value.kind === "call" && host.inlineAwaitEligible(e.value.callee)) { diff --git a/packages/compiler/test/await-call-emission.test.ts b/packages/compiler/test/await-call-emission.test.ts index b206b829b..5d2b614c3 100644 --- a/packages/compiler/test/await-call-emission.test.ts +++ b/packages/compiler/test/await-call-emission.test.ts @@ -262,3 +262,48 @@ void main(); } } }); + +const promiseAllSource = ` +async function leaf(x: number): Promise { + return x + 1; +} +async function literal(x: number): Promise { + const all: number[] = await Promise.all([leaf(x), leaf(x + 1)]); + return all[0]! + all[1]!; +} +async function local(x: number): Promise { + const ps = [leaf(x), leaf(x + 1), leaf(x + 2)]; + const all = await Promise.all(ps); + return all.length; +} +async function reused(x: number): Promise { + const ps = [leaf(x)]; + const all = await Promise.all(ps); + return all.length + ps.length; +} +async function main(): Promise { + console.log((await literal(1)) + (await local(2)) + (await reused(3))); +} +void main(); +`; + +test("a stackless body runs Promise.all of never-suspending calls in place", async () => { + const llvm = await emit(promiseAllSource); + for (const [symbol, calls] of [ + ["sc_f_literal", 2], + ["sc_f_local", 3], + ] as const) { + const body = definition(llvm, symbol); + // The entries run in place and fill the result array; one turn stands + // for Promise.all's reaction jobs and one for the await. + expect(body.match(/call double @sc_ai_leaf\(double/g)?.length, symbol).toBe(calls); + expect(body.match(/call zeroext i1 @scr_coro_hop_prepare\(ptr/g)?.length, symbol).toBe(2); + expect(body, symbol).toContain("call void @scr_promise_mark_handled(ptr"); + expect(body, symbol).not.toContain("@scr_promise_all("); + expect(body, symbol).not.toContain("@sc_as_leaf("); + } + // A local the body reads again keeps its promises. + const reused = definition(llvm, "sc_f_reused"); + expect(reused).toContain("call ptr @sc_as_leaf(double"); + expect(reused).toContain("@scr_promise_all("); +}); diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7100-promise-all-inline-order.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7100-promise-all-inline-order.ts.json new file mode 100644 index 000000000..1dd147700 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7100-promise-all-inline-order.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7100-promise-all-inline-order.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7101-promise-all-inline-sync-throw.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7101-promise-all-inline-sync-throw.ts.json new file mode 100644 index 000000000..9ee756166 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7101-promise-all-inline-sync-throw.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7101-promise-all-inline-sync-throw.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7102-promise-all-inline-kinds.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7102-promise-all-inline-kinds.ts.json new file mode 100644 index 000000000..572b90013 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7102-promise-all-inline-kinds.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7102-promise-all-inline-kinds.ts" + ], + "diags": [] +} diff --git a/tests/corpus/7100-promise-all-inline-order.ts b/tests/corpus/7100-promise-all-inline-order.ts new file mode 100644 index 000000000..b67eca014 --- /dev/null +++ b/tests/corpus/7100-promise-all-inline-order.ts @@ -0,0 +1,86 @@ +// Ordering of `await Promise.all([...])` of never-suspending async calls +// against concurrent microtasks. +const log: string[] = []; + +async function value(n: number): Promise { + log.push(`value ${n}`); + return n * 10; +} +async function fail(tag: string): Promise { + log.push(`fail ${tag}`); + throw new Error(`boom ${tag}`); +} +async function label(s: string): Promise { + log.push(`label ${s}`); + return s.toUpperCase(); +} + +function ticker(name: string, turns: number): Promise { + let p = Promise.resolve(); + for (let i = 0; i < turns; i++) p = p.then(() => void log.push(`${name} tick ${i}`)); + return p; +} + +async function literal(): Promise { + const r: number[] = await Promise.all([value(1), value(2), value(3)]); + log.push(`literal ${r.join(",")}`); +} +async function local(): Promise { + const ps = [value(4), value(5)]; + const r = await Promise.all(ps); + log.push(`local ${r.join(",")}`); +} +async function firstRejects(): Promise { + try { + await Promise.all([fail("a"), value(6), fail("b")]); + log.push("firstRejects resolved"); + } catch (e) { + log.push(`firstRejects caught ${(e as Error).message}`); + } +} +async function middleRejects(): Promise { + const ps = [value(7), fail("c"), value(8)]; + try { + const r = await Promise.all(ps); + log.push(`middleRejects resolved ${r.length}`); + } catch (e) { + log.push(`middleRejects caught ${(e as Error).message}`); + } +} +async function strings(): Promise { + const r: string[] = await Promise.all([label("x"), label("y")]); + log.push(`strings ${r.join("+")}`); +} +async function single(): Promise { + const all: number[] = await Promise.all([value(9)]); + const only = all[0]; + log.push(`single ${only}`); +} +async function reused(): Promise { + const ps = [value(11), value(12)]; + const r = await Promise.all(ps); + log.push(`reused ${r.join(",")} ${ps.length}`); +} +async function afterAssign(): Promise { + let r: number[] = []; + const ps = [value(13)]; + r = await Promise.all(ps); + log.push(`afterAssign ${r.join(",")}`); +} + +async function main(): Promise { + await Promise.all([ + ticker("t", 8), + literal(), + ticker("u", 4), + local(), + firstRejects(), + middleRejects(), + strings(), + single(), + reused(), + afterAssign(), + ]); + for (const line of log) console.log(line); +} +void main(); diff --git a/tests/corpus/7101-promise-all-inline-sync-throw.ts b/tests/corpus/7101-promise-all-inline-sync-throw.ts new file mode 100644 index 000000000..43e3b1167 --- /dev/null +++ b/tests/corpus/7101-promise-all-inline-sync-throw.ts @@ -0,0 +1,21 @@ +// An entry argument that throws synchronously leaves earlier rejections +// unhandled, since Promise.all never runs. +async function fail(tag: string): Promise { + throw new Error(`boom ${tag}`); +} +async function value(n: number): Promise { + return n; +} +function boom(): number { + throw new Error("argument"); +} +async function run(): Promise { + try { + const r: number[] = await Promise.all([fail("first"), value(boom())]); + console.log("resolved", r.length); + } catch (e) { + console.log("caught", (e as Error).message); + } +} +process.on("unhandledRejection", (reason) => console.log("unhandled", (reason as Error).message)); +void run().then(() => console.log("done")); diff --git a/tests/corpus/7102-promise-all-inline-kinds.ts b/tests/corpus/7102-promise-all-inline-kinds.ts new file mode 100644 index 000000000..6036a4d46 --- /dev/null +++ b/tests/corpus/7102-promise-all-inline-kinds.ts @@ -0,0 +1,69 @@ +// `await Promise.all([...])` of never-suspending async calls with number, +// boolean, string and record results, inside loops and larger expressions, +// and an uncaught rejection. +interface Point { + x: number; + y: number; +} +const log: string[] = []; +async function flag(n: number): Promise { + log.push(`flag ${n}`); + return n % 2 === 0; +} +async function point(n: number): Promise { + log.push(`point ${n}`); + return { x: n, y: n * n }; +} +async function count(n: number): Promise { + if (n < 0) throw new RangeError(`negative ${n}`); + return n + 1; +} +function ticker(name: string, turns: number): Promise { + let p = Promise.resolve(); + for (let i = 0; i < turns; i++) p = p.then(() => void log.push(`${name} tick ${i}`)); + return p; +} +async function flags(): Promise { + const r: boolean[] = await Promise.all([flag(1), flag(2)]); + log.push(`flags ${r.join(",")}`); +} +async function points(): Promise { + const ps = [point(1), point(2), point(3)]; + const r = await Promise.all(ps); + let sum = 0; + for (const p of r) sum += p.x + p.y; + log.push(`points ${sum}`); +} +async function loop(): Promise { + let total = 0; + for (let i = 0; i < 3; i++) { + const ps = [count(i), count(i * 2)]; + const r = await Promise.all(ps); + total += r[0]! + r[1]!; + log.push(`loop ${i} ${total}`); + } +} +function sumOf(xs: number[]): number { + let s = 0; + for (const x of xs) s += x; + return s; +} +async function nested(): Promise { + const total = 100 + sumOf(await Promise.all([count(4), count(5)])); + log.push(`nested ${total}`); +} +async function uncaught(): Promise { + const ps = [count(1), count(-2), count(-3)]; + const r = await Promise.all(ps); + log.push(`uncaught resolved ${r.length}`); +} +process.on("unhandledRejection", (reason) => { + const e = reason as Error; + console.log(`unhandled ${e.name} ${e.message}`); +}); +async function main(): Promise { + void uncaught(); + await Promise.all([ticker("t", 6), flags(), points(), loop(), nested()]); + for (const line of log) console.log(line); +} +void main(); diff --git a/tests/harness/corpus-costs/7100-promise-all-inline-order.ts.json b/tests/harness/corpus-costs/7100-promise-all-inline-order.ts.json new file mode 100644 index 000000000..054b3c2b4 --- /dev/null +++ b/tests/harness/corpus-costs/7100-promise-all-inline-order.ts.json @@ -0,0 +1 @@ +{ "plain": 3900, "san": 5000 } diff --git a/tests/harness/corpus-costs/7101-promise-all-inline-sync-throw.ts.json b/tests/harness/corpus-costs/7101-promise-all-inline-sync-throw.ts.json new file mode 100644 index 000000000..71bf780f8 --- /dev/null +++ b/tests/harness/corpus-costs/7101-promise-all-inline-sync-throw.ts.json @@ -0,0 +1 @@ +{ "plain": 2700, "san": 3500 } diff --git a/tests/harness/corpus-costs/7102-promise-all-inline-kinds.ts.json b/tests/harness/corpus-costs/7102-promise-all-inline-kinds.ts.json new file mode 100644 index 000000000..42d31979d --- /dev/null +++ b/tests/harness/corpus-costs/7102-promise-all-inline-kinds.ts.json @@ -0,0 +1 @@ +{ "plain": 3200, "san": 4000 } From 956bdf4ec0045ee6aca671dc720075409bbd7f3b Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Wed, 21 Oct 2026 23:49:13 -0500 Subject: [PATCH 010/102] Bound while-loop counters that nested scans advance A while loop's counter gets an integer range when the loop only adds positive literals to it and its condition bounds it. A counter written inside a nested loop was refused, which is every hand-written scanner: `while (pos < end) { ... while (pos < end && isDigit(...)) pos++; ... }`. A nested while loop may now advance the counter when its own condition bounds it the same way and does not write it. Its passes start at most at that bound, so it leaves the counter at its entry value or at the highest value one of its passes reaches, and the outer loop's range follows from there. Other nested loops, and nested loops that do not bound the counter, still refuse it. --- .../compiler/src/ir/integer-loop-facts.ts | 74 ++++++++++++++++--- .../compiler/src/ir/integer-ranges.test.ts | 68 +++++++++++++++++ 2 files changed, 130 insertions(+), 12 deletions(-) diff --git a/packages/compiler/src/ir/integer-loop-facts.ts b/packages/compiler/src/ir/integer-loop-facts.ts index 23982aa07..b075ef29a 100644 --- a/packages/compiler/src/ir/integer-loop-facts.ts +++ b/packages/compiler/src/ir/integer-loop-facts.ts @@ -246,10 +246,15 @@ export const STRING_MAX_UNITS = 0x7fffffff; /** Bound counters of a while loop by its condition. A counter qualifies when * the loop (condition and body) changes it only by increments of positive - * integer literals outside nested loops, switch and exception regions, and a - * conjunct of the condition compares it below a literal, a binding the loop - * never writes, or the length of a string binding the loop never writes - * (`while (x * x + y * y <= 4 && it < MAX) it++`, `while (pos < text.length)`). + * integer literals outside switch and exception regions and loops other + * than nested while loops, and a conjunct of the condition compares it below + * a literal, a binding the loop never writes, or the length of a string + * binding the loop never writes (`while (x * x + y * y <= 4 && it < MAX) + * it++`, `while (pos < text.length)`). A nested while loop may advance the + * counter only when its own condition bounds it the same way and does not + * write it (a scanner's `while (pos < end && isDigit(...)) pos++`): its + * passes start at most at that bound, so it leaves the counter at its entry + * value or at the highest value one of its passes reaches. * The body runs only after that conjunct held, and the condition never * writes the counter, so every pass starts at most at the conjunct's bound. * The pass then climbs by the increments on its path; an increment inside an @@ -270,19 +275,29 @@ export function guardedLoopCounterFacts( if (opaque || delta === null || delta <= 0 || delta > 2147483647) refused.add(id); else budget.set(id, (budget.get(id) ?? 0) + delta); }; + // Nested while loops outside opaque regions, checked against their own + // conditions once the stable bounds are known. + const nested: (IrStmt & { kind: "while" })[] = []; const expr = (e: IrExpr): boolean => { if (e.kind === "assignExpr") write(e.localId, increment(e.localId, e.value)); if (e.kind === "incDec") write(e.localId, e.op === "+" ? 1 : null); return everyExprChild(e, expr, stmt); }; + const condition = new Set(); const stmt = (s: IrStmt): boolean => { + const bounded = s.kind === "while" && opaque === 0 && !s.labels?.length; const region = - s.kind === "for" || - s.kind === "while" || - s.kind === "doWhile" || - s.kind === "forOf" || - s.kind === "tryCatch" || - s.kind === "switch"; + !bounded && + (s.kind === "for" || + s.kind === "while" || + s.kind === "doWhile" || + s.kind === "forOf" || + s.kind === "tryCatch" || + s.kind === "switch"); + if (bounded) { + nested.push(s); + conditionWrites(s.cond); + } if (region) opaque++; if (s.kind === "assign") write(s.localId, increment(s.localId, s.value)); if (s.kind === "varDecl" || s.kind === "forOf") write(s.localId, null); @@ -293,7 +308,6 @@ export function guardedLoopCounterFacts( }; // The condition is evaluated before every pass; a write there would // separate the compared value from the one the body sees. - const condition = new Set(); const conditionWrites = (e: IrExpr): boolean => { if (e.kind === "assignExpr" || e.kind === "incDec") condition.add(e.localId); return everyExprChild(e, conditionWrites, (s) => { @@ -304,8 +318,9 @@ export function guardedLoopCounterFacts( }); }; conditionWrites(loop.cond); - for (const id of condition) refused.add(id); loop.body.every(stmt); + // Nested loops' conditions are collected during the walk. + for (const id of condition) refused.add(id); const stable = (id: string): boolean => { const local = locals.get(id); return local !== undefined && !local.boxed && !local.tdz && !budget.has(id) && !refused.has(id); @@ -359,6 +374,11 @@ export function guardedLoopCounterFacts( } return ceiling; }; + // A nested while loop advances only the counters its condition bounds. + for (const inner of nested) { + const caps = ceilings(inner.cond); + for (const id of writtenLocals(inner.body)) if (!caps.has(id)) refused.add(id); + } const ceiling = ceilings(loop.cond); for (const id of budget.keys()) { const local = locals.get(id), @@ -416,6 +436,21 @@ function highestCount( count = Math.max(then, else_); } else if (s.kind === "block" && !s.labels?.length) { count = walk(s.body, count); + } else if ( + s.kind === "while" && + !s.labels?.length && + increments(s.cond, true) === 0 && + ceilings(s.cond).has(id) + ) { + // Every pass starts at most at the bound; the loop ends at its entry + // value or where a pass left the counter. + const cap = ceilings(s.cond).get(id)!; + const outer = highest; + highest = cap; + walk(s.body, cap); + const inner = highest; + highest = Math.max(outer, inner); + count = Math.max(count, inner); } else { count += increments(s, false); highest = Math.max(highest, count); @@ -435,6 +470,21 @@ function highestCount( return highest; } +/** The bindings `body` assigns or increments anywhere. */ +function writtenLocals(body: readonly IrStmt[]): Set { + const ids = new Set(); + const expr = (e: IrExpr): boolean => { + if (e.kind === "assignExpr" || e.kind === "incDec") ids.add(e.localId); + return everyExprChild(e, expr, stmt); + }; + const stmt = (s: IrStmt): boolean => { + if (s.kind === "assign") ids.add(s.localId); + return everyStmtChild(s, expr, stmt); + }; + body.every(stmt); + return ids; +} + /** Recognize only exits whose target cannot be inside this statement list. * Labeled blocks, loops, switch and exception regions retain the join. */ export function integerPathFallsThrough(body: readonly IrStmt[]): boolean { diff --git a/packages/compiler/src/ir/integer-ranges.test.ts b/packages/compiler/src/ir/integer-ranges.test.ts index 32caea672..b495eb814 100644 --- a/packages/compiler/src/ir/integer-ranges.test.ts +++ b/packages/compiler/src/ir/integer-ranges.test.ts @@ -797,6 +797,74 @@ test("a while condition on a string's length bounds a counter, and guarded incre expect(run((inside) => [observe(inside), bump, rebound]).after).toBeNull(); }); +test("a nested while loop may advance a counter its own condition bounds", () => { + // while (pos < text.length) { observe(pos); while (pos < text.length && unknown === 1) pos++; pos += 2; } + const text: IrExpr = { loc, kind: "varRef", localId: "text", type: STRING }; + const length: IrExpr = { + loc, + kind: "strIntrinsic", + method: "length", + receiver: text, + args: [], + type: F64, + }; + const bump: IrStmt = { + loc, + kind: "exprStmt", + expr: { loc, kind: "incDec", op: "+", prefix: false, localId: "pos", type: F64 }, + }; + const skip: IrStmt = { loc, kind: "assign", localId: "pos", value: bin("+", ref("pos"), num(2)) }; + const and = (left: IrExpr, right: IrExpr): IrExpr => ({ + loc, + kind: "logical", + op: "&&", + left, + right, + type: BOOL, + }); + const scan = (cond: IrExpr): IrStmt => ({ loc, kind: "while", cond, body: [bump] }); + const run = (inner: IrStmt) => { + const inside = ref("pos"), + after = ref("pos"); + const f = fn([ + { loc, kind: "assign", localId: "pos", value: num(0) }, + { + loc, + kind: "while", + cond: condition("<", ref("pos"), length), + body: [observe(inside), inner, skip], + }, + observe(after), + ]); + f.locals.push( + { id: "pos", name: "pos", type: F64, mutable: true }, + { id: "text", name: "text", type: STRING, mutable: false }, + ); + const ranges = analyzeIntegerRanges(f); + return { inside: ranges.get(inside), after: ranges.get(after) }; + }; + // Each inner pass starts below the length, so the scan stops at it at the + // latest; the skip then adds 2. + const bounded = scan( + and(condition("<", ref("pos"), length), condition("===", ref("unknown"), num(1))), + ); + expect(run(bounded)).toEqual({ + inside: { min: 0, max: 2147483646 }, + after: { min: 0, max: 2147483649 }, + }); + // A nested loop that does not bound the counter, or writes it in its + // condition, leaves it unbounded. + expect(run(scan(condition("===", ref("unknown"), num(1)))).after).toBeNull(); + const writing = scan( + condition( + "<", + { loc, kind: "incDec", op: "+", prefix: true, localId: "pos", type: F64 }, + length, + ), + ); + expect(run(writing).after).toBeNull(); +}); + test("an array length bounds while and for counters even when the body resizes the array", () => { // let i = 0; while (i < items.length) { observe(i); items.push(i); i++; } observe(i); const ARR = { kind: "array", elem: F64 } as const; From 63001cbc136b3f77653750755f20796022507702 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Wed, 21 Oct 2026 23:55:37 -0500 Subject: [PATCH 011/102] Await a suspending stackless callee without its promise --- packages/cli/test/native-link-info.test.ts | 4 +- .../src/backend/llvm/emit-function.ts | 15 ++ packages/compiler/src/backend/llvm/emitter.ts | 66 +++++++++ .../compiler/src/backend/llvm/expr-async.ts | 16 +++ .../compiler/src/backend/llvm/expr-calls.ts | 11 +- packages/compiler/src/backend/mangle.ts | 5 + packages/compiler/src/backend/runtime-abi.ts | 4 +- .../src/backend/runtime-pack-targets.test.ts | 2 +- .../compiler/src/backend/runtime-pack.test.ts | 2 +- .../compiler/test/await-call-emission.test.ts | 52 ++++++- .../test/native-codegen-integration.test.ts | 4 +- .../corpus/7104-direct-await-order.ts.json | 6 + .../corpus/7105-direct-await-context.ts.json | 6 + .../runtime-darwin-arm64/scripts/build.mjs | 2 +- .../runtime-pack-common/scripts/build.mjs | 2 +- packages/runtime/src/scr_async.c | 133 +++++++++++++++++- packages/runtime/src/scr_async.h | 9 ++ packages/runtime/src/scr_console.c | 2 +- packages/runtime/src/scr_core.h | 2 +- tests/corpus/7104-direct-await-order.ts | 96 +++++++++++++ tests/corpus/7105-direct-await-context.ts | 34 +++++ .../7104-direct-await-order.ts.json | 1 + .../7105-direct-await-context.ts.json | 1 + 23 files changed, 452 insertions(+), 23 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7104-direct-await-order.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7105-direct-await-context.ts.json create mode 100644 tests/corpus/7104-direct-await-order.ts create mode 100644 tests/corpus/7105-direct-await-context.ts create mode 100644 tests/harness/corpus-costs/7104-direct-await-order.ts.json create mode 100644 tests/harness/corpus-costs/7105-direct-await-context.ts.json diff --git a/packages/cli/test/native-link-info.test.ts b/packages/cli/test/native-link-info.test.ts index 57c60b1bc..f5ff2642e 100644 --- a/packages/cli/test/native-link-info.test.ts +++ b/packages/cli/test/native-link-info.test.ts @@ -72,7 +72,7 @@ describe.runIf(supported)("macOS arm64 native link info", () => { minimum_os: "14.0", }, program: { object, entry_symbol: "main" }, - runtime_abi: { version: 23, marker: "scr_runtime_abi_v23" }, + runtime_abi: { version: 24, marker: "scr_runtime_abi_v24" }, runtime_pack: { kind: "precompiled", package: "@scriptc/runtime-darwin-arm64", @@ -165,6 +165,6 @@ describe.runIf(supported)("macOS arm64 native link info", () => { () => null, (failure: { stderr?: string }) => failure, ); - expect(error?.stderr).toContain("scr_runtime_abi_v23"); + expect(error?.stderr).toContain("scr_runtime_abi_v24"); }); }); diff --git a/packages/compiler/src/backend/llvm/emit-function.ts b/packages/compiler/src/backend/llvm/emit-function.ts index 7bbd3d453..8c6264e6c 100644 --- a/packages/compiler/src/backend/llvm/emit-function.ts +++ b/packages/compiler/src/backend/llvm/emit-function.ts @@ -35,6 +35,7 @@ import { mangleArgPack, mangleAsyncAdoptCall, mangleAsyncAwaitCall, + mangleAsyncDirectSpawn, mangleAsyncSpawn, mangleBorrowedFunction, mangleClassStruct, @@ -910,6 +911,20 @@ export function emitAsyncScaffolding(emitter: LlEmitter): string[] { for (const line of emitter.emitAsyncAwaitCall(fn, argPackLines, true)) out.push(line); } const stackless = emitter.stacklessAsync.has(fn.name); + if (stackless && emitter.directAwaitCallees.has(fn.name)) { + // A coroutine's direct await: the same prefix, with the promise kept + // inside the returned fiber record. + emitter.declare(`declare ptr @scr_async_spawn_direct(ptr, ptr)`); + out.push( + `define internal ptr @${mangleAsyncDirectSpawn(fn.name)}(${spawnParams.join(", ")}) ${FN_ATTRS} { ; direct spawn ${fn.name}`, + `entry:`, + ...argPackLines, + ` %f = call ptr @scr_async_spawn_direct(ptr @${mangleTrampoline(fn.name)}, ptr %ap)`, + ` ret ptr %f`, + `}`, + ``, + ); + } const spawn = stackless ? "scr_async_spawn_stackless" : "scr_async_spawn"; emitter.declare(`declare ptr @scr_fiber_promise(ptr)`); emitter.declare(`declare ptr @${spawn}(ptr, ptr)`); diff --git a/packages/compiler/src/backend/llvm/emitter.ts b/packages/compiler/src/backend/llvm/emitter.ts index b306674fc..eeb89d953 100644 --- a/packages/compiler/src/backend/llvm/emitter.ts +++ b/packages/compiler/src/backend/llvm/emitter.ts @@ -889,6 +889,9 @@ export class LlEmitter { /** Fiberless async functions a stackless coroutine body awaits directly; * each gets an inline await entry (emitCoroInlineAwait). */ readonly inlineAwaitCallees = new Set(); + /** Stackless async functions some coroutine body awaits directly: each + * gets a direct spawn entry (emitCoroDirectAwait). */ + readonly directAwaitCallees = new Set(); /** The async functions whose bodies never suspend and that a direct * await may enter in place (selectStacklessAsync). */ private inlineAwaitable = new Set(); @@ -1913,6 +1916,69 @@ export class LlEmitter { return fn.captures === undefined; } + /** Whether a stackless coroutine body's `await f(...)` may await f's + * fiber record instead of its promise (emitCoroDirectAwait): f is a + * stackless async function whose direct call an await-call entry could + * take. The await consumes the promise, so nothing else can observe it. + * Worker programs keep the promise for their stop checkpoint. */ + directAwaitEligible(fnName: string): boolean { + if (this.wasi || this.mod.workers === true || this.currentCoro?.kind !== "async") return false; + const fn = this.fnByName.get(fnName); + if (fn === undefined || fn.async !== true || fn.generator !== undefined) return false; + if (!this.stacklessAsync.has(fnName) || fn.captures !== undefined) return false; + if (fn.returnType.kind === "dyn") return false; + return fn.asyncCacheGlobal === undefined && fn.asyncCycleCacheGlobal === undefined; + } + + /** A stackless coroutine body's `await f(...)` of a stackless f, without + * f's promise object: f's prefix runs as the spawn of a fiber record that + * keeps the promise inside. A body still running wakes this coroutine + * when it finishes, where its promise's settlement would wake its one + * waiter; a finished one takes the settled await's turn. The result (or + * the rejection, re-thrown) comes out of the record, which goes. */ + emitCoroDirectAwait(call: ExprOf<"call">, type: IrType): LlValue { + const coro = this.currentCoro; + if (coro === null) + throw new InternalCompilerError("llvm emitter bug: direct await outside a coroutine"); + const B = this.B; + const record = emitCallExpr(this, call, "direct").name; + this.declare(`declare zeroext i1 @scr_coro_direct_prepare(ptr, ptr)`); + const suspend = B.tmp(); + B.line( + `${suspend} = call zeroext i1 @scr_coro_direct_prepare(ptr ${coro.self}, ptr ${record})`, + ); + const park = B.newLabel("await.suspend"); + const ready = B.newLabel("await.ready"); + B.condBr(suspend, park, ready); + B.startBlock(park); + this.emitCoroSuspendPrepared(); + B.br(ready); + B.startBlock(ready); + if (type.kind === "void") { + this.declare(`declare void @scr_coro_direct_void(ptr)`); + B.line(`call void @scr_coro_direct_void(ptr ${record})`); + this.emitPendingCheck(); + return { name: "", type }; + } + const t = B.tmp(); + if (type.kind === "f64" || type.kind === "date") { + 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") { + this.declare(`declare zeroext i1 @scr_coro_direct_bool(ptr)`); + B.line(`${t} = call zeroext i1 @scr_coro_direct_bool(ptr ${record})`); + } else if (type.kind === "string") { + this.declare(`declare ptr @scr_coro_direct_str(ptr)`); + B.line(`${t} = call ptr @scr_coro_direct_str(ptr ${record})`); + } else { + this.declare(`declare ptr @scr_coro_direct_ref(ptr)`); + B.line(`${t} = call ptr @scr_coro_direct_ref(ptr ${record})`); + } + const out = this.own({ name: this.adoptHeap(t, type), type }); + this.emitPendingCheck(); + return out; + } + /** The inline await entry of a fiberless async function (`sc_ai_*`): its * body on the caller's stack (between scr_async_inline_enter/exit when * fiberlessFrames), as in its spawn wrapper, returning the result and diff --git a/packages/compiler/src/backend/llvm/expr-async.ts b/packages/compiler/src/backend/llvm/expr-async.ts index 4d73d0904..b5d765b16 100644 --- a/packages/compiler/src/backend/llvm/expr-async.ts +++ b/packages/compiler/src/backend/llvm/expr-async.ts @@ -918,6 +918,22 @@ export function emitAsyncExpr( return host.emitCoroInlineAwait(e.value, e.adopt === true); } } + // A stackless coroutine body awaits a stackless callee's fiber record + // instead of its promise. + if ( + adopted === null && + e.adopt !== true && + e.value.kind === "call" && + host.directAwaitEligible(e.value.callee) + ) { + const callee = host.fnByName.get(e.value.callee)!; + if ( + typeEquals(callee.returnType, e.type) && + !host.callLifetimes.borrowed.has(e.value.callee) + ) { + return host.emitCoroDirectAwait(e.value, e.type); + } + } if (adopted === null && e.value.kind === "call" && host.awaitCallEligible(e.value.callee)) { const callee = host.fnByName.get(e.value.callee)!; if ( diff --git a/packages/compiler/src/backend/llvm/expr-calls.ts b/packages/compiler/src/backend/llvm/expr-calls.ts index 81c44d5a6..f0aa3b276 100644 --- a/packages/compiler/src/backend/llvm/expr-calls.ts +++ b/packages/compiler/src/backend/llvm/expr-calls.ts @@ -31,6 +31,7 @@ import { mangleFunction, mangleWrapper, mangleVtStruct, + mangleAsyncDirectSpawn, } from "../mangle.js"; import { classEnvironmentIndex, @@ -74,7 +75,7 @@ export function emitCallExpr( | "instanceOf" | "virtualCall" >, - awaitEntry: false | "await" | "adopt" | "inline" = false, + awaitEntry: false | "await" | "adopt" | "inline" | "direct" = false, /** A projection consumes a scalar union result (Int32Abi.union): answer * a private stack box instead of a heap box. */ stackResult = false, @@ -184,6 +185,14 @@ export function emitCallExpr( : `${host.llType(callee.params[i]!.type)} ${a.name}`, ) .join(", "); + if (awaitEntry === "direct") { + // A stackless coroutine's await of a stackless callee: the spawn + // returns the callee's fiber record (emitCoroDirectAwait). + host.directAwaitCallees.add(e.callee); + const record = B.tmp(); + B.line(`${record} = call ptr @${mangleAsyncDirectSpawn(e.callee)}(${argList})`); + return { name: record, type: callee.returnType }; + } if (awaitEntry === "inline") { // A stackless coroutine's await of a fiberless callee: the entry // runs the body in place and leaves a throw pending; the enclosing diff --git a/packages/compiler/src/backend/mangle.ts b/packages/compiler/src/backend/mangle.ts index da6cbe0f5..14736ead7 100644 --- a/packages/compiler/src/backend/mangle.ts +++ b/packages/compiler/src/backend/mangle.ts @@ -195,6 +195,11 @@ export function mangleAsyncAdoptCall(fnName: string): string { export function mangleAsyncInlineAwaitCall(fnName: string): string { return `sc_ai_${sanitize(fnName)}`; } +/** A stackless coroutine body's `await f(...)` of a stackless async f: the + * spawn of f's fiber record, which keeps its promise inside (direct await). */ +export function mangleAsyncDirectSpawn(fnName: string): string { + return `sc_dw_${sanitize(fnName)}`; +} export function mangleTrampoline(fnName: string): string { return `sc_tr_${sanitize(fnName)}`; } diff --git a/packages/compiler/src/backend/runtime-abi.ts b/packages/compiler/src/backend/runtime-abi.ts index 67be86571..5eb24482b 100644 --- a/packages/compiler/src/backend/runtime-abi.ts +++ b/packages/compiler/src/backend/runtime-abi.ts @@ -2,8 +2,8 @@ * of the link contract: a program object keeps this symbol undefined and the * matching runtime defines it, so incompatible manual links fail before the * program can start. */ -export const RUNTIME_ABI_VERSION = 23 as const; -export const RUNTIME_ABI_MARKER = "scr_runtime_abi_v23" as const; +export const RUNTIME_ABI_VERSION = 24 as const; +export const RUNTIME_ABI_MARKER = "scr_runtime_abi_v24" as const; /** Object consumption is useful today, but the complete scr_* surface may * still change before 1.0. The versioned marker prevents accidental mixing; diff --git a/packages/compiler/src/backend/runtime-pack-targets.test.ts b/packages/compiler/src/backend/runtime-pack-targets.test.ts index 19519e1f2..fc7ed9efa 100644 --- a/packages/compiler/src/backend/runtime-pack-targets.test.ts +++ b/packages/compiler/src/backend/runtime-pack-targets.test.ts @@ -52,7 +52,7 @@ async function fixture(target: NativeTargetSpec, workers = false) { object_format: target.objectFormat, minimum_os: target.minimumOs, }, - runtime_abi: { version: 23, marker: "scr_runtime_abi_v23" }, + runtime_abi: { version: 24, marker: "scr_runtime_abi_v24" }, compiler: { command: "fixture", identity: "fixture", target: target.llvmTriple }, macros: { executable: [], excluded: ["SCR_LIB"], sanitizer: "external-toolchain-required" }, flavors: { diff --git a/packages/compiler/src/backend/runtime-pack.test.ts b/packages/compiler/src/backend/runtime-pack.test.ts index ee2301172..5ffb4797d 100644 --- a/packages/compiler/src/backend/runtime-pack.test.ts +++ b/packages/compiler/src/backend/runtime-pack.test.ts @@ -124,7 +124,7 @@ async function fixture(target: NativeTargetSpec = MACOS_ARM64_TARGET) { object_format: target.objectFormat, minimum_os: target.minimumOs, }, - runtime_abi: { version: 23, marker: "scr_runtime_abi_v23" }, + runtime_abi: { version: 24, marker: "scr_runtime_abi_v24" }, compiler: { command: "clang", identity: "fixture clang", diff --git a/packages/compiler/test/await-call-emission.test.ts b/packages/compiler/test/await-call-emission.test.ts index 5d2b614c3..96c039155 100644 --- a/packages/compiler/test/await-call-emission.test.ts +++ b/packages/compiler/test/await-call-emission.test.ts @@ -183,10 +183,16 @@ test("bodies that suspend only at their own awaits compile to stackless coroutin const middle = definition(llvm, "sc_f_middle"); expect(middle).toMatch(/^define internal double @sc_f_middle\(double [^)]*\) #1 /); // Each await prepares its continuation and suspends the coroutine, then - // extracts the settled result; nothing parks the stack it runs on. - expect(middle).toContain("call zeroext i1 @scr_coro_await_prepare(ptr"); - expect(middle).toContain("call double @scr_coro_await_f64(ptr"); - expect(middle).toContain("call ptr @sc_as_slow(double"); + // extracts the settled result; nothing parks the stack it runs on. A + // stackless callee is awaited through its fiber record, without its + // promise (emitCoroDirectAwait). + expect(middle).toContain("call ptr @sc_dw_slow(double"); + expect(middle).toContain("call zeroext i1 @scr_coro_direct_prepare(ptr"); + expect(middle).toContain("call double @scr_coro_direct_f64(ptr"); + expect(middle).not.toContain("@sc_as_slow("); + expect(definition(llvm, "sc_dw_slow")).toContain( + "call ptr @scr_async_spawn_direct(ptr @sc_tr_slow", + ); // A callee that never suspends runs in place; the coroutine takes the // await's turn itself and awaits a rejected promise only on a throw. expect(middle).toContain("call double @sc_ai_leaf(double"); @@ -307,3 +313,41 @@ test("a stackless body runs Promise.all of never-suspending calls in place", asy expect(reused).toContain("call ptr @sc_as_leaf(double"); expect(reused).toContain("@scr_promise_all("); }); + +const directSource = ` +async function slow(x: number): Promise { + await null; + return x + 1; +} +async function direct(x: number): Promise { + return (await slow(x)) * 2; +} +async function adopting(x: number): Promise { + return slow(x); +} +async function kept(x: number): Promise { + const pending = slow(x); + await null; + return await pending; +} +async function main(): Promise { + console.log((await direct(1)) + (await adopting(2)) + (await kept(3))); +} +void main(); +`; + +test("a stackless body awaits a stackless callee's fiber record instead of its promise", async () => { + const llvm = await emit(directSource); + const direct = definition(llvm, "sc_f_direct"); + expect(direct).toContain("call ptr @sc_dw_slow(double"); + expect(direct).toContain("call zeroext i1 @scr_coro_direct_prepare(ptr"); + expect(direct).toContain("call double @scr_coro_direct_f64(ptr"); + expect(direct).not.toContain("@scr_coro_await_prepare("); + // A returned call adopts the callee's promise, and a promise held in a + // local is a value: both keep the promise. + for (const symbol of ["sc_f_adopting", "sc_f_kept"]) { + const body = definition(llvm, symbol); + expect(body, symbol).toContain("call ptr @sc_as_slow(double"); + expect(body, symbol).not.toContain("@sc_dw_slow("); + } +}); diff --git a/packages/compiler/test/native-codegen-integration.test.ts b/packages/compiler/test/native-codegen-integration.test.ts index c0f2cfe84..d8f158ebc 100644 --- a/packages/compiler/test/native-codegen-integration.test.ts +++ b/packages/compiler/test/native-codegen-integration.test.ts @@ -378,7 +378,7 @@ done: expect(await symbols(helperObject, ["-u"])).toEqual(await symbols(clangObject, ["-u"])); expect(await symbols(helperObject, ["-gU"])).toEqual(await symbols(clangObject, ["-gU"])); expect(await symbols(helperObject, ["-gU"])).toEqual(["0000000000000000 T _main"]); - expect(await symbols(helperObject, ["-u"])).toContain("_scr_runtime_abi_v23"); + expect(await symbols(helperObject, ["-u"])).toContain("_scr_runtime_abi_v24"); const clangExe = join(dir, "clang-program"); const linkDriver = join(dir, "clang-driver.c"); @@ -712,7 +712,7 @@ done: .split("\n"); expect(undefinedSymbols).toContain("_sf_scale"); expect(undefinedSymbols).toContain("_sf_callback_mix"); - expect(undefinedSymbols).toContain("_scr_runtime_abi_v23"); + expect(undefinedSymbols).toContain("_scr_runtime_abi_v24"); }); test("helper and clang object paths retain the same outbound FFI C ABI", async () => { diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7104-direct-await-order.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7104-direct-await-order.ts.json new file mode 100644 index 000000000..238ee8fb1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7104-direct-await-order.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7104-direct-await-order.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7105-direct-await-context.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7105-direct-await-context.ts.json new file mode 100644 index 000000000..2ed3b6aec --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7105-direct-await-context.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7105-direct-await-context.ts" + ], + "diags": [] +} diff --git a/packages/runtime-darwin-arm64/scripts/build.mjs b/packages/runtime-darwin-arm64/scripts/build.mjs index 856de4b86..85c5ffb00 100644 --- a/packages/runtime-darwin-arm64/scripts/build.mjs +++ b/packages/runtime-darwin-arm64/scripts/build.mjs @@ -337,7 +337,7 @@ async function build() { package: packageManifest.name, version: packageManifest.version, target: RUNTIME_PACK_MATRIX.target, - runtime_abi: { version: 23, marker: "scr_runtime_abi_v23" }, + runtime_abi: { version: 24, marker: "scr_runtime_abi_v24" }, compiler: { command: compiler, identity: compilerVersion, diff --git a/packages/runtime-pack-common/scripts/build.mjs b/packages/runtime-pack-common/scripts/build.mjs index fa84e9c4d..b242b78aa 100644 --- a/packages/runtime-pack-common/scripts/build.mjs +++ b/packages/runtime-pack-common/scripts/build.mjs @@ -434,7 +434,7 @@ async function build() { package: packageManifest.name, version: packageManifest.version, target: matrix.target, - runtime_abi: { version: 23, marker: "scr_runtime_abi_v23" }, + runtime_abi: { version: 24, marker: "scr_runtime_abi_v24" }, compiler: { command: compiler, identity: compilerVersion, diff --git a/packages/runtime/src/scr_async.c b/packages/runtime/src/scr_async.c index 12cf81f77..db1e54295 100644 --- a/packages/runtime/src/scr_async.c +++ b/packages/runtime/src/scr_async.c @@ -616,6 +616,13 @@ struct ScrFiber { struct ScrFiber *awaiter; /* This fiber was parked by such a child; set before the switch away. */ bool await_parked; + /* A stackless body spawned for a direct await (scr_async_spawn_direct): + * its promise lives in the same block (ScrDirectFiber) and nothing else + * sees it. Once the awaiting coroutine suspends it is direct_awaiter, the + * finished body wakes it in place of the promise's settlement, and the + * awaiter destroys the record when it takes the result. */ + bool direct; + struct ScrFiber *direct_awaiter; #ifdef SCR_ASAN_FIBERS void *fake_stack; /* Live stackless async fibers (scr_async_spawn_stackless) form a list @@ -2138,11 +2145,31 @@ static void scr_prefix_on_fresh_stack(ScrFiber *f, void (*entry)(ScrFiber *, voi } #endif -ScrPromise *scr_async_spawn_stackless(void (*entry)(ScrFiber *, void *), void *argpack) { - ScrFiber *f = scr_mem_calloc(sizeof *f); - if (!f) scr_oom(); +/* A directly awaited body's fiber record and its promise, one block. */ +typedef struct { + ScrFiber fiber; + ScrPromise promise; +} ScrDirectFiber; + +/* Creates a stackless body's fiber and runs its eager prefix, which + * returns at the first suspension or the end. A direct fiber's promise is + * embedded and immortal (retains and releases skip it). */ +static ScrFiber *scr_spawn_stackless_fiber(void (*entry)(ScrFiber *, void *), void *argpack, + bool direct) { + ScrFiber *f; + if (direct) { + ScrDirectFiber *block = scr_mem_calloc(sizeof *block); + if (!block) scr_oom(); + f = &block->fiber; + f->promise = &block->promise; + f->promise->rc = SIZE_MAX; + f->direct = true; + } else { + f = scr_mem_calloc(sizeof *f); + if (!f) scr_oom(); + f->promise = scr_promise_new(); + } scr_fiber_track(f); - f->promise = scr_promise_new(); f->stackless = true; f->als = scr_als_ctx_retain(*SCR_ALS_SLOT()); /* The lifetime region the eager prefix runs in, which every later step @@ -2171,6 +2198,11 @@ ScrPromise *scr_async_spawn_stackless(void (*entry)(ScrFiber *, void *), void *a scr_current = spawner; scr_exc_swap_cell(spawner ? &spawner->exc : NULL); scr_als_active = spawner ? &spawner->als : &scr_als_main_slot; + return f; +} + +ScrPromise *scr_async_spawn_stackless(void (*entry)(ScrFiber *, void *), void *argpack) { + ScrFiber *f = scr_spawn_stackless_fiber(entry, argpack, false); ScrPromise *result = scr_promise_retain(f->promise); if (f->done) { scr_promise_release(f->promise); @@ -2179,6 +2211,14 @@ ScrPromise *scr_async_spawn_stackless(void (*entry)(ScrFiber *, void *), void *a } return result; } + +/* A stackless body that a stackless coroutine awaits right away (the + * compiler's direct await): its promise never escapes, so it is embedded + * in the fiber record, which the awaiter takes the result from + * (scr_coro_direct_*) and then destroys. */ +ScrFiber *scr_async_spawn_direct(void (*entry)(ScrFiber *, void *), void *argpack) { + return scr_spawn_stackless_fiber(entry, argpack, true); +} #endif static void scr_await_park(ScrPromise *p); @@ -2447,7 +2487,28 @@ bool scr_coro_await_prepare(ScrFiber *self, ScrPromise *p) { bool scr_coro_hop_prepare(ScrFiber *self) { return scr_coro_hop_needed(self); } -void scr_coro_async_finish(ScrFiber *self) { scr_fiber_finish(self); } +/* A directly awaited body's end: its awaiter is the promise's only waiter, + * and it observes a rejection when it takes the result, so the body wakes + * it where the settlement would, without the unhandled-rejection ledger. */ +static void scr_direct_finish(ScrFiber *self) { + ScrPromise *p = self->promise; + bool stopped = false; +#ifdef SCR_WORKERS + /* A stop request rejects like the fiber epilogue does (scr_fiber_finish). */ + stopped = scr_context_checkpoint(); +#endif + if (stopped || scr_exc_pending()) scr_promise_reject_from_cell(p, &self->exc); + if (stopped) p->rejection_observed = true; + if (p->state == SCR_PROM_PENDING) + scr_trap("scriptc: internal error: directly awaited body finished unsettled\n"); + self->done = true; + if (self->direct_awaiter != NULL) scr_promise_wake_one(self->direct_awaiter); +} + +void scr_coro_async_finish(ScrFiber *self) { + if (self->direct) scr_direct_finish(self); + else scr_fiber_finish(self); +} /* Extraction after the await's suspension: the promise has settled. */ static bool scr_coro_await_settled(ScrPromise *p) { @@ -2470,6 +2531,66 @@ ScrStr *scr_coro_await_str(ScrPromise *p) { void *scr_coro_await_ref(ScrPromise *p) { return scr_coro_await_settled(p) && p->payload ? p->retain_fn(p->payload) : NULL; } + +/* A direct await of a stackless body (scr_async_spawn_direct): a body + * still running gets the coroutine as its only awaiter, which its finish + * wakes as a settlement wakes a promise's waiter; a finished body is a + * settled promise, which takes one microtask turn. */ +bool scr_coro_direct_prepare(ScrFiber *self, ScrFiber *callee) { + if (!callee->done) { + callee->direct_awaiter = self; + return true; + } + return scr_coro_hop_needed(self); +} + +/* The result of a finished direct body: its promise's settlement, read as + * scr_coro_await_* reads it (a rejection re-throws), then the record goes. */ +static inline void scr_direct_destroy(ScrFiber *f) { + /* Only a rejection reason is left: values moved out, and nothing waits + * on or shares the promise. */ + if (f->promise->payload_kind != SCR_EXC_NONE) scr_promise_release_payload(f->promise); + scr_fiber_destroy(f); + scr_fibers_live--; +} + +void scr_coro_direct_void(ScrFiber *f) { + scr_coro_await_settled(f->promise); + scr_direct_destroy(f); +} +double scr_coro_direct_f64(ScrFiber *f) { + double v = scr_coro_await_settled(f->promise) ? f->promise->f64 : 0; + scr_direct_destroy(f); + return v; +} +bool scr_coro_direct_bool(ScrFiber *f) { + bool v = scr_coro_await_settled(f->promise) ? f->promise->b : false; + scr_direct_destroy(f); + return v; +} +/* String and reference results move out of the record (+1). */ +ScrStr *scr_coro_direct_str(ScrFiber *f) { + ScrPromise *p = f->promise; + ScrStr *v = NULL; + if (scr_coro_await_settled(p)) { + v = (ScrStr *)p->payload; + p->payload = NULL; + p->payload_kind = SCR_EXC_NONE; + } + scr_direct_destroy(f); + return v; +} +void *scr_coro_direct_ref(ScrFiber *f) { + ScrPromise *p = f->promise; + void *v = NULL; + if (scr_coro_await_settled(p)) { + v = p->payload; + p->payload = NULL; + p->payload_kind = SCR_EXC_NONE; + } + scr_direct_destroy(f); + return v; +} #endif /* One microtask hop: park the current fiber on the READY queue itself and @@ -3982,7 +4103,7 @@ static void scr_resume_fiber(ScrFiber *f) { scr_loop_reap = NULL; } #endif - if (f->done) { + if (f->done && !f->direct) { scr_promise_release(f->promise); scr_fiber_destroy(f); scr_fibers_live--; diff --git a/packages/runtime/src/scr_async.h b/packages/runtime/src/scr_async.h index 041d2ea03..827c303f9 100644 --- a/packages/runtime/src/scr_async.h +++ b/packages/runtime/src/scr_async.h @@ -109,6 +109,15 @@ double scr_coro_await_f64(ScrPromise *p); bool scr_coro_await_bool(ScrPromise *p); ScrStr *scr_coro_await_str(ScrPromise *p); /* +1 */ void *scr_coro_await_ref(ScrPromise *p); /* +1 via the stored retain */ +/* A direct await of a stackless body: its promise stays inside the fiber + * record the spawn returns, and the awaiter takes the result from it. */ +ScrFiber *scr_async_spawn_direct(void (*entry)(ScrFiber *, void *), void *argpack); +bool scr_coro_direct_prepare(ScrFiber *self, ScrFiber *callee); +void scr_coro_direct_void(ScrFiber *f); +double scr_coro_direct_f64(ScrFiber *f); +bool scr_coro_direct_bool(ScrFiber *f); +ScrStr *scr_coro_direct_str(ScrFiber *f); /* +1 */ +void *scr_coro_direct_ref(ScrFiber *f); /* +1 */ double scr_await_f64(ScrPromise *p); /* rejected promises re-throw */ bool scr_await_bool(ScrPromise *p); diff --git a/packages/runtime/src/scr_console.c b/packages/runtime/src/scr_console.c index 0afb8981a..c29126a4a 100644 --- a/packages/runtime/src/scr_console.c +++ b/packages/runtime/src/scr_console.c @@ -148,7 +148,7 @@ static void scr_enable_utf8_console_output(void) { } #endif -void scr_runtime_abi_v23(void) {} +void scr_runtime_abi_v24(void) {} void scr_init(void) { #ifdef SCR_WORKERS diff --git a/packages/runtime/src/scr_core.h b/packages/runtime/src/scr_core.h index cdf1061d9..94936a8aa 100644 --- a/packages/runtime/src/scr_core.h +++ b/packages/runtime/src/scr_core.h @@ -81,7 +81,7 @@ void scr_init(void); /* Program objects emitted by the bundled LLVM helper reference this symbol. * Its versioned spelling makes a mismatched manual runtime link fail before * the program can start. */ -void scr_runtime_abi_v23(void); +void scr_runtime_abi_v24(void); void scr_runtime_workers_v8(void); /* ── the trap funnel (scr_console.c; scr_library.c under -DSCR_LIB) ────── diff --git a/tests/corpus/7104-direct-await-order.ts b/tests/corpus/7104-direct-await-order.ts new file mode 100644 index 000000000..ab4f438c4 --- /dev/null +++ b/tests/corpus/7104-direct-await-order.ts @@ -0,0 +1,96 @@ +// A stackless async body awaiting a stackless callee that suspends: +// results of each kind, callees that finish without suspending, nested +// chains, throws before and after the first suspension, and an uncaught +// rejection, against a ticker that logs every microtask turn. +interface Point { + x: number; + y: number; +} +const log: string[] = []; + +async function slowNumber(n: number, turns: number): Promise { + for (let i = 0; i < turns; i++) await null; + log.push(`slowNumber ${n} done`); + return n * 2; +} +async function maybeSuspend(n: number): Promise { + if (n > 0) await null; + log.push(`maybeSuspend ${n}`); + return n + 100; +} +async function slowFlag(n: number): Promise { + await null; + return n % 2 === 0; +} +async function slowLabel(s: string): Promise { + await null; + return `<${s}>`; +} +async function slowPoint(n: number): Promise { + await null; + return { x: n, y: n * n }; +} +async function slowVoid(tag: string): Promise { + await null; + log.push(`slowVoid ${tag}`); +} +async function throwsEarly(n: number): Promise { + if (n > 0) throw new RangeError(`early ${n}`); + await null; + return n; +} +async function throwsLate(n: number): Promise { + await null; + await null; + throw new TypeError(`late ${n}`); +} +async function chain(depth: number): Promise { + await null; + if (depth === 0) return 1; + return 1 + (await chain(depth - 1)); +} +function ticker(name: string, turns: number): Promise { + let p = Promise.resolve(); + for (let i = 0; i < turns; i++) p = p.then(() => void log.push(`${name} tick ${i}`)); + return p; +} + +async function values(): Promise { + const a = await slowNumber(1, 2); + const b = await maybeSuspend(0); + const c = await maybeSuspend(1); + const f = await slowFlag(4); + const s = await slowLabel("x"); + const p = await slowPoint(3); + await slowVoid("v"); + log.push(`values ${a} ${b} ${c} ${f} ${s} ${p.x + p.y}`); +} +async function errors(): Promise { + try { + await throwsEarly(1); + } catch (e) { + log.push(`errors caught ${(e as Error).name} ${(e as Error).message}`); + } + try { + await throwsLate(2); + } catch (e) { + log.push(`errors caught ${(e as Error).name} ${(e as Error).message}`); + } + log.push(`errors ok ${await throwsEarly(0)}`); +} +async function nested(): Promise { + log.push(`nested ${await chain(4)}`); +} +async function uncaught(): Promise { + await slowNumber(9, 1); + await throwsLate(9); + log.push("uncaught resolved"); +} + +process.on("unhandledRejection", (reason) => console.log(`unhandled ${(reason as Error).message}`)); +async function main(): Promise { + void uncaught(); + await Promise.all([ticker("t", 10), values(), ticker("u", 3), errors(), nested()]); + for (const line of log) console.log(line); +} +void main(); diff --git a/tests/corpus/7105-direct-await-context.ts b/tests/corpus/7105-direct-await-context.ts new file mode 100644 index 000000000..c5a6bd40e --- /dev/null +++ b/tests/corpus/7105-direct-await-context.ts @@ -0,0 +1,34 @@ +// AsyncLocalStorage across a stackless body's awaits of stackless callees: +// each callee inherits its caller's store at the call, a store a callee +// enters after its first await stays inside it, and run() scopes survive +// the awaits. +import { AsyncLocalStorage } from "node:async_hooks"; + +const store = new AsyncLocalStorage(); +const log: string[] = []; + +async function read(tag: string): Promise { + await null; + return `${tag}=${store.getStore() ?? "none"}`; +} +async function enters(tag: string): Promise { + await null; + store.enterWith(`inner-${tag}`); + await null; + return `${tag}=${store.getStore() ?? "none"}`; +} +async function body(name: string): Promise { + log.push(await read(`${name}.first`)); + log.push(await enters(`${name}.enters`)); + log.push(await read(`${name}.after`)); +} + +async function main(): Promise { + await Promise.all([ + store.run("a", () => body("a")), + store.run("b", () => body("b")), + body("none"), + ]); + for (const line of log) console.log(line); +} +void main(); diff --git a/tests/harness/corpus-costs/7104-direct-await-order.ts.json b/tests/harness/corpus-costs/7104-direct-await-order.ts.json new file mode 100644 index 000000000..17c78c9c9 --- /dev/null +++ b/tests/harness/corpus-costs/7104-direct-await-order.ts.json @@ -0,0 +1 @@ +{ "plain": 3100, "san": 4100 } diff --git a/tests/harness/corpus-costs/7105-direct-await-context.ts.json b/tests/harness/corpus-costs/7105-direct-await-context.ts.json new file mode 100644 index 000000000..78ee9421a --- /dev/null +++ b/tests/harness/corpus-costs/7105-direct-await-context.ts.json @@ -0,0 +1 @@ +{ "plain": 2300, "san": 3100 } From 561f66cf5b70fdcfeed8cbf93dc8fac02cd981c9 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 00:16:11 -0500 Subject: [PATCH 012/102] Reuse deferred initializer scans while only bindings are pending --- .../deferred-module-initializers.test.ts | 20 + .../lowering/deferred-module-initializers.ts | 354 +++++++++++++----- 2 files changed, 275 insertions(+), 99 deletions(-) diff --git a/packages/compiler/src/frontend/lowering/deferred-module-initializers.test.ts b/packages/compiler/src/frontend/lowering/deferred-module-initializers.test.ts index 53d6bac87..28f05bfce 100644 --- a/packages/compiler/src/frontend/lowering/deferred-module-initializers.test.ts +++ b/packages/compiler/src/frontend/lowering/deferred-module-initializers.test.ts @@ -91,6 +91,26 @@ test("finds replaced blocks and references appended to an existing body in a lat expect(functions[0]!.body).toEqual([{ kind: "block", body: [value(7)], loc }]); }); +test("reuses the scan of an unchanged body while only bindings are pending", () => { + const { initializers, pending, lowerer } = fixture(); + const placeholder = block(loc); + const functions = [fn("init", [placeholder]), fn("use", [value(1)])]; + pending.set("registry", [{ loc, lower: () => [value(7)] }]); + expect(initializers.process(lowerer, functions)).toBe(false); + const walk = vi.spyOn(traversal, "everyStmtList"); + try { + expect(initializers.process(lowerer, functions)).toBe(false); + expect(walk).not.toHaveBeenCalled(); + // A statement added to the same list is found. + functions[1]!.body.push(read("registry")); + expect(initializers.process(lowerer, functions)).toBe(true); + expect(walk.mock.calls.filter(([body]) => body === functions[0]!.body)).toHaveLength(0); + } finally { + walk.mockRestore(); + } + expect(placeholder.body).toEqual([value(7)]); +}); + test("indexes new subtrees for other demanded initializers in the same pass", () => { const { initializers, pending, lowerer } = fixture(); const nestedLoc = { ...loc, start: 10, end: 11 }; diff --git a/packages/compiler/src/frontend/lowering/deferred-module-initializers.ts b/packages/compiler/src/frontend/lowering/deferred-module-initializers.ts index b80eb7ac0..eb22b4085 100644 --- a/packages/compiler/src/frontend/lowering/deferred-module-initializers.ts +++ b/packages/compiler/src/frontend/lowering/deferred-module-initializers.ts @@ -12,6 +12,7 @@ import { } from "./lower-classes.js"; import { classPrototypeData } from "./class-prototypes.js"; import { bindingNeverReassigned } from "./binding-analysis.js"; +import { InternalCompilerError } from "../../errors.js"; /** A registry of existing class/function values allocates data, but does * not execute those bodies. Keep its initializer at its source position @@ -20,6 +21,10 @@ import { bindingNeverReassigned } from "./binding-analysis.js"; export class DeferredModuleInitializers { private readonly pending = new Map IrStmt[] }[]>(); private readonly registryGlobals = new Set(); + /** Every key ever deferred, pending or materialized. */ + private readonly deferredKeys = new Set(); + /** The last scan of each function (scanOf). */ + private readonly scans = new Map(); defer(lowerer: Lowerer, statement: ts.Statement): IrStmt | null { let key: string; @@ -126,6 +131,83 @@ export class DeferredModuleInitializers { process(lowerer: Lowerer, functions: readonly IrFunction[]): boolean { if (this.pending.size === 0) return false; + // Scans keep only the reads of deferred bindings. + for (const key of this.pending.keys()) { + if (this.deferredKeys.has(key)) continue; + this.deferredKeys.add(key); + this.scans.clear(); + } + // Class and prototype keys follow the classes IR types reach, and passes + // change those inside statements they keep (a bag initializer gains a + // prototype). While only bindings are pending, the scans of unchanged + // statement lists are reused; SCRIPTC_CHECK_DEFERRED_SCANS=1 checks each + // such pass against fresh scans. + const bindingsOnly = ![...this.pending.keys()].some( + (key) => key.startsWith("class:") || key.startsWith("prototype:"), + ); + const scans = functions.map((fn) => this.scanOf(lowerer, fn, bindingsOnly)); + const demanded = this.demanded(lowerer, functions, scans); + if (CHECK_SCANS && bindingsOnly) { + const fresh = functions.map((fn) => scanFunction(lowerer, fn, this.deferredKeys)); + const expected = this.demanded(lowerer, functions, fresh); + const blocks = (list: readonly FunctionScan[]): PlaceholderBlock[] => + list.flatMap((scan) => scan.placeholders.filter((block) => block.body.length === 0)); + const reused = blocks(scans); + const live = blocks(fresh); + if ( + [...demanded].join("\0") !== [...expected].join("\0") || + reused.length !== live.length || + reused.some((block, index) => block !== live[index]) + ) + throw new InternalCompilerError( + "reused deferred initializer scans disagree with a fresh scan", + ); + } + if (demanded.size === 0) return false; + // The placeholders come from the scans, which are fresh for every list a + // transform replaced between waves. Each is kept with the functions whose + // bodies hold it. Searching every body again for each initializer would + // make materializing large module registries quadratic in the program size. + const placeholders = new Map(); + const add = (block: PlaceholderBlock, fns: IrFunction[]): void => { + const key = locationKey(block.loc); + const blocks = placeholders.get(key) ?? []; + blocks.push({ block, fns }); + placeholders.set(key, blocks); + }; + functions.forEach((fn, index) => { + for (const block of scans[index]!.placeholders) if (block.body.length === 0) add(block, [fn]); + }); + for (const id of demanded) { + const initialize = this.pending.get(id)!; + this.pending.delete(id); + for (const action of initialize) { + const body = action.lower(); + const holders: IrFunction[] = []; + for (const { block, fns } of placeholders.get(locationKey(action.loc)) ?? []) { + if (block.body.length === 0) { + block.body.push(...body); + holders.push(...fns); + } + } + if (holders.length === 0) continue; + // These bodies changed inside unchanged statement lists. + for (const fn of holders) this.scans.delete(fn); + // An inserted body can introduce a placeholder needed by another + // action in this pass. Unattached bodies are not part of the live IR. + for (const nested of scanStatements(body).placeholders) add(nested, holders); + } + } + return demanded.size !== 0; + } + + /** The pending keys the scanned functions reference, in the order the + * functions and their walks meet them. */ + private demanded( + lowerer: Lowerer, + functions: readonly IrFunction[], + scans: readonly FunctionScan[], + ): Set { const demanded = new Set(); const classHelpers = new Map(); for (const info of lowerer.classes.values()) { @@ -133,116 +215,190 @@ export class DeferredModuleInitializers { if (info.def.prototypeDataHelper) classHelpers.set(info.def.prototypeDataHelper, `prototype:${info.def.name}`); } - const seen = new Set(); - const byName = new Map(functions.map((fn) => [fn.name, fn])); - const inspectedHelpers = new Set(); + const byName = new Map(functions.map((fn, index) => [fn.name, index])); const usedHelpers: string[] = []; - const demandType = (type: IrType): void => { - if (seen.has(type)) return; - seen.add(type); - if (type.kind === "object" || type.kind === "classval") { - for (let info = lowerer.classes.get(type.className); info; info = info.base ?? undefined) { - const key = `class:${info.def.name}`; - if (this.pending.has(key)) demanded.add(key); - const prototype = `prototype:${info.def.name}`; - if (type.kind === "object" && this.pending.has(prototype)) demanded.add(prototype); + const demand = (events: readonly ScanEvent[]): void => { + for (const event of events) { + if (event.kind === "read") { + if (this.pending.has(event.id)) demanded.add(event.id); + } else if (event.kind === "call") { + const owner = classHelpers.get(event.callee); + if (owner) { + if (this.pending.has(owner)) demanded.add(owner); + usedHelpers.push(event.callee); + } + } else { + for ( + let info = lowerer.classes.get(event.className); + info; + info = info.base ?? undefined + ) { + const key = `class:${info.def.name}`; + if (this.pending.has(key)) demanded.add(key); + const prototype = `prototype:${info.def.name}`; + if (event.kind === "object" && this.pending.has(prototype)) demanded.add(prototype); + } } - } else if (type.kind === "array") demandType(type.elem); - else if (type.kind === "union") lowerer.unions.get(type.unionId)?.arms.forEach(demandType); - else if (type.kind === "record") { - const shape = lowerer.shapes.get(type.shapeId); - shape?.fields.forEach((field) => demandType(field.type)); - if (shape?.indexValue) demandType(shape.indexValue); - } else if (type.kind === "func") { - type.params.forEach(demandType); - demandType(type.ret); - } else if (type.kind === "promise") demandType(type.inner); + } }; - for (const fn of functions) { + functions.forEach((fn, index) => { // Prototype helpers are allocated eagerly while collecting metadata. // Their base-helper calls must not make unused classes reachable. - if (classHelpers.has(fn.name)) continue; - fn.params.forEach((param) => demandType(param.type)); - demandType(fn.returnType); - everyStmtList(fn.body, { - stmt: () => true, - expr: (expr) => { - demandType(expr.type); - if (readsBinding(expr) && this.pending.has(expr.localId)) demanded.add(expr.localId); - if (expr.kind === "call") { - const owner = classHelpers.get(expr.callee); - if (owner) { - if (this.pending.has(owner)) demanded.add(owner); - usedHelpers.push(expr.callee); - } - } - return true; - }, - }); - } + if (classHelpers.has(fn.name)) return; + demand(scans[index]!.signature); + demand(scans[index]!.body); + }); + const inspectedHelpers = new Set(); while (usedHelpers.length) { const name = usedHelpers.pop()!; if (inspectedHelpers.has(name)) continue; inspectedHelpers.add(name); - const fn = byName.get(name); - if (!fn) continue; - everyStmtList(fn.body, { - stmt: () => true, - expr: (expr) => { - demandType(expr.type); - if (readsBinding(expr) && this.pending.has(expr.localId)) demanded.add(expr.localId); - if (expr.kind === "call") { - const owner = classHelpers.get(expr.callee); - if (owner) { - if (this.pending.has(owner)) demanded.add(owner); - usedHelpers.push(expr.callee); - } - } - return true; - }, - }); + const index = byName.get(name); + if (index !== undefined) demand(scans[index]!.body); } - if (demanded.size === 0) return false; - // Transforms replace blocks between waves, so index the live placeholders - // anew in each pass. Searching every body again for each initializer makes - // materializing large module registries quadratic in the program size. - const placeholders = new Map[]>(); - const locationKey = (loc: IrStmt["loc"]): string => - JSON.stringify([loc.file, loc.start, loc.end]); - const indexPlaceholders = (body: IrStmt[]): void => { - everyStmtList(body, { - stmt: (statement) => { - if (statement.kind === "block" && statement.body.length === 0) { - const key = locationKey(statement.loc); - const blocks = placeholders.get(key) ?? []; - blocks.push(statement); - placeholders.set(key, blocks); - } - return true; - }, - expr: () => true, - }); - }; - for (const fn of functions) indexPlaceholders(fn.body); - for (const id of demanded) { - const initialize = this.pending.get(id)!; - this.pending.delete(id); - for (const action of initialize) { - const body = action.lower(); - let inserted = false; - for (const block of placeholders.get(locationKey(action.loc)) ?? []) { - if (block.body.length === 0) { - block.body.push(...body); - inserted = true; - } - } - // An inserted body can introduce a placeholder needed by another - // action in this pass. Unattached bodies are not part of the live IR. - if (inserted) indexPlaceholders(body); - } - } - return demanded.size !== 0; + return demanded; } + + /** What `fn` references that can demand an initializer, in the order a + * walk of it meets them. While only bindings are pending (`reuse`), a + * function's scan is reused while its statement list is the same array + * with the same length and the same first and last statements: passes that + * change a body either replace its list or add statements to it, and this + * pass forgets the scan of a function whose placeholder it fills. */ + private scanOf(lowerer: Lowerer, fn: IrFunction, reuse: boolean): FunctionScan { + const cached = this.scans.get(fn); + if ( + reuse && + cached !== undefined && + cached.statements === fn.body && + cached.length === fn.body.length && + cached.first === fn.body[0] && + cached.last === fn.body[fn.body.length - 1] + ) { + return cached; + } + const scan = scanFunction(lowerer, fn, this.deferredKeys); + this.scans.set(fn, scan); + return scan; + } +} + +type PlaceholderBlock = Extract; + +/** One reference a scan records: a class an IR type reaches (`object` also + * reaches its prototype), a binding read, or a call to a class data + * helper. */ +type ScanEvent = + | { kind: "object" | "classval"; className: string } + | { kind: "read"; id: string } + | { kind: "call"; callee: string }; + +interface FunctionScan { + statements: IrStmt[]; + length: number; + first: IrStmt | undefined; + last: IrStmt | undefined; + /** References of the parameter and return types. */ + signature: ScanEvent[]; + /** References of the body's expressions. */ + body: ScanEvent[]; + /** Empty blocks, in walk order: an initializer's position. */ + placeholders: PlaceholderBlock[]; +} + +/** Class data helpers (classStaticData, classPrototypeData). */ +const CLASS_HELPER_PREFIXES = ["%static.data.", "%prototype.data."]; + +/** SCRIPTC_CHECK_DEFERRED_SCANS=1 checks each pass that reuses scans against fresh scans. */ +const CHECK_SCANS = process.env["SCRIPTC_CHECK_DEFERRED_SCANS"] === "1"; + +function locationKey(loc: IrStmt["loc"]): string { + return JSON.stringify([loc.file, loc.start, loc.end]); +} + +/** The references of `fn` (FunctionScan). Each reference is kept at its + * first occurrence, except calls, and only reads of `deferred` keys. */ +function scanFunction( + lowerer: Lowerer, + fn: IrFunction, + deferred: ReadonlySet, +): FunctionScan { + const signature: ScanEvent[] = []; + const typeEvents = typeScanner(lowerer, signature); + for (const param of fn.params) typeEvents(param.type); + typeEvents(fn.returnType); + const { body, placeholders } = scanStatements(fn.body, lowerer, deferred); + return { + statements: fn.body, + length: fn.body.length, + first: fn.body[0], + last: fn.body[fn.body.length - 1], + signature, + body, + placeholders, + }; +} + +/** Records, once each, the classes the types it is given reach. */ +function typeScanner(lowerer: Lowerer, events: ScanEvent[]): (type: IrType) => void { + const seen = new Set(); + const classes = new Set(); + const visit = (type: IrType): void => { + if (seen.has(type)) return; + seen.add(type); + if (type.kind === "object" || type.kind === "classval") { + const key = `${type.kind}:${type.className}`; + if (!classes.has(key)) { + classes.add(key); + events.push({ kind: type.kind, className: type.className }); + } + } else if (type.kind === "array") visit(type.elem); + else if (type.kind === "union") lowerer.unions.get(type.unionId)?.arms.forEach(visit); + else if (type.kind === "record") { + const shape = lowerer.shapes.get(type.shapeId); + shape?.fields.forEach((field) => visit(field.type)); + if (shape?.indexValue) visit(shape.indexValue); + } else if (type.kind === "func") { + type.params.forEach(visit); + visit(type.ret); + } else if (type.kind === "promise") visit(type.inner); + }; + return visit; +} + +/** The references and placeholders of a statement list. Without a lowerer + * it collects only placeholders. */ +function scanStatements( + statements: IrStmt[], + lowerer?: Lowerer, + deferred?: ReadonlySet, +): { body: ScanEvent[]; placeholders: PlaceholderBlock[] } { + const body: ScanEvent[] = []; + const placeholders: PlaceholderBlock[] = []; + const typeEvents = lowerer ? typeScanner(lowerer, body) : null; + const reads = new Set(); + everyStmtList(statements, { + stmt: (statement) => { + if (statement.kind === "block" && statement.body.length === 0) placeholders.push(statement); + return true; + }, + expr: (expr) => { + if (typeEvents === null) return true; + typeEvents(expr.type); + if (readsBinding(expr) && deferred!.has(expr.localId) && !reads.has(expr.localId)) { + reads.add(expr.localId); + body.push({ kind: "read", id: expr.localId }); + } + // Every call, as the helpers are visited from a stack in call order. + if ( + expr.kind === "call" && + CLASS_HELPER_PREFIXES.some((prefix) => expr.callee.startsWith(prefix)) + ) + body.push({ kind: "call", callee: expr.callee }); + return true; + }, + }); + return { body, placeholders }; } /** A read of a binding's current value: a plain read, or an update From 321873b9576c9692d9193c2193b18a7da00d4ccc Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 00:18:36 -0500 Subject: [PATCH 013/102] Compile JavaScript-path calls that Node runs --- .../builtin-apis/streams-and-readline.mdx | 1 + .../compiler/src/backend/llvm/lib-shared.ts | 3 + .../src/frontend/lowering/builtins/atomics.ts | 16 +++-- .../src/frontend/lowering/builtins/numbers.ts | 18 ++--- .../frontend/lowering/builtins/readline.ts | 34 +++++++--- .../lowering/containers/string-and-regexp.ts | 36 ++++++++-- packages/compiler/src/ir/builtin-effects.ts | 3 + .../compiler/src/ir/builtin-signatures.ts | 3 + .../6862-readline-chained-listeners.cjs.json | 6 ++ ...6865-number-parseint-default-radix.ts.json | 6 ++ .../6866-number-parseint-untyped.js.json | 6 ++ .../6867-string-match-optional-regexp.js.json | 6 ++ ...-buffer-from-untyped-array-buffer.cjs.json | 6 ++ .../6869-atomics-untyped-arrays.cjs.json | 6 ++ packages/runtime/src/scr_bytes_io.c | 13 ++++ packages/runtime/src/scr_lib.h | 3 + packages/runtime/src/scr_shared.c | 68 +++++++++++++++++++ .../6862-readline-chained-listeners.cjs | 29 ++++++++ .../6865-number-parseint-default-radix.ts | 16 +++++ tests/corpus/6866-number-parseint-untyped.js | 9 +++ .../6867-string-match-optional-regexp.js | 20 ++++++ .../6868-buffer-from-untyped-array-buffer.cjs | 38 +++++++++++ tests/corpus/6869-atomics-untyped-arrays.cjs | 65 ++++++++++++++++++ .../6862-readline-chained-listeners.cjs.json | 1 + ...6865-number-parseint-default-radix.ts.json | 1 + .../6866-number-parseint-untyped.js.json | 1 + .../6867-string-match-optional-regexp.js.json | 1 + ...-buffer-from-untyped-array-buffer.cjs.json | 1 + .../6869-atomics-untyped-arrays.cjs.json | 1 + 29 files changed, 388 insertions(+), 29 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6862-readline-chained-listeners.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6865-number-parseint-default-radix.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6866-number-parseint-untyped.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6867-string-match-optional-regexp.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6868-buffer-from-untyped-array-buffer.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6869-atomics-untyped-arrays.cjs.json create mode 100644 tests/corpus/6862-readline-chained-listeners.cjs create mode 100644 tests/corpus/6865-number-parseint-default-radix.ts create mode 100644 tests/corpus/6866-number-parseint-untyped.js create mode 100644 tests/corpus/6867-string-match-optional-regexp.js create mode 100644 tests/corpus/6868-buffer-from-untyped-array-buffer.cjs create mode 100644 tests/corpus/6869-atomics-untyped-arrays.cjs create mode 100644 tests/harness/corpus-costs/6862-readline-chained-listeners.cjs.json create mode 100644 tests/harness/corpus-costs/6865-number-parseint-default-radix.ts.json create mode 100644 tests/harness/corpus-costs/6866-number-parseint-untyped.js.json create mode 100644 tests/harness/corpus-costs/6867-string-match-optional-regexp.js.json create mode 100644 tests/harness/corpus-costs/6868-buffer-from-untyped-array-buffer.cjs.json create mode 100644 tests/harness/corpus-costs/6869-atomics-untyped-arrays.cjs.json diff --git a/docs/content/limitations/builtin-apis/streams-and-readline.mdx b/docs/content/limitations/builtin-apis/streams-and-readline.mdx index a21f7a617..046f7d6b5 100644 --- a/docs/content/limitations/builtin-apis/streams-and-readline.mdx +++ b/docs/content/limitations/builtin-apis/streams-and-readline.mdx @@ -19,6 +19,7 @@ Stream constructors accept a `signal` option in an options object literal, and `stream.addAbortSignal` accepts any stream. A `transform` or `flush` option callback whose completion callback types `data` as `any`, as @types/node's `TransformCallback` does, may pass a Buffer, a string, or nothing; any other value throws a TypeError where the callback is called, instead of Node's `ERR_INVALID_ARG_TYPE` stream error. `node:readline` and `node:readline/promises` (also reached as `readline.promises`) interfaces, from `createInterface(options)` or `createInterface(input, output, completer, terminal)`, read `process.stdin` or a readable stream: `question`, `prompt`, `write` (with a key object literal of `name`, `ctrl`, `meta`, and `shift`), `pause`, `resume`, `'line'`/`'close'`/`'pause'`/`'resume'`/`'error'`/`'history'`/`'SIGINT'`/`'SIGTSTP'`/`'SIGCONT'` listeners, and `for await` compile. + `on`, `once`, and `addListener` return the interface, so registrations chain. The `history`, `historySize`, `removeHistoryDuplicates`, `completer`, `tabSize`, and `escapeCodeTimeout` options are validated as in Node. With `terminal: true`, or with no `terminal` option and `process.stdout` as the output when it is a TTY, the interface runs Node's terminal mode: the editing keys, the kill ring, undo and redo, history recording and recall, Tab completion through the completer, Ctrl+C, Ctrl+D, and Ctrl+Z, `TERM=dumb`, and the same escape sequences written to the output. The output's `'resize'` event does not redraw the line. diff --git a/packages/compiler/src/backend/llvm/lib-shared.ts b/packages/compiler/src/backend/llvm/lib-shared.ts index 8bb8bc3aa..683211762 100644 --- a/packages/compiler/src/backend/llvm/lib-shared.ts +++ b/packages/compiler/src/backend/llvm/lib-shared.ts @@ -1037,6 +1037,9 @@ export const LIB_FN_SYMS: Record = { "atomics.op": "scr_atomics_op", "atomics.notify": "scr_atomics_notify", "atomics.wait": "scr_atomics_wait", + "atomics.opDyn": "scr_atomics_op_dyn", + "atomics.waitDyn": "scr_atomics_wait_dyn", + "atomics.notifyDyn": "scr_atomics_notify_dyn", "worker.new": "scr_worker_new", "worker.isMainThread": "scr_context_is_main", "worker.threadId": "scr_context_thread_number", diff --git a/packages/compiler/src/frontend/lowering/builtins/atomics.ts b/packages/compiler/src/frontend/lowering/builtins/atomics.ts index 41e35a511..5c72ed08c 100644 --- a/packages/compiler/src/frontend/lowering/builtins/atomics.ts +++ b/packages/compiler/src/frontend/lowering/builtins/atomics.ts @@ -60,10 +60,14 @@ export function lowerAtomicsCall( // has a concrete typed-array binding. Validate the actual lowered storage. const array = lowerer.lowerExpr(source); const type = array.type; + // An untyped array (a JavaScript `workerData` or field): the runtime + // checks its kind and throws Node's TypeError for any other value. + const dynamic = type?.kind === "dyn"; if ( - type?.kind !== "bytes" || - !["i8", "u8", "i16", "u16", "i32", "u32"].includes(type.elem) || - ((member === "wait" || member === "notify") && type.elem !== "i32") + !dynamic && + (type?.kind !== "bytes" || + !["i8", "u8", "i16", "u16", "i32", "u32"].includes(type.elem) || + ((member === "wait" || member === "notify") && type.elem !== "i32")) ) { lowerer.noLowering( `Atomics.${member} over this array`, @@ -82,7 +86,7 @@ export function lowerAtomicsCall( if (member === "wait") return { kind: "libCall", - fn: "atomics.wait", + fn: dynamic ? "atomics.waitDyn" : "atomics.wait", args: [array, index, arg(2, 0), arg(3, Infinity)], type: STRING, loc, @@ -90,14 +94,14 @@ export function lowerAtomicsCall( if (member === "notify") return { kind: "libCall", - fn: "atomics.notify", + fn: dynamic ? "atomics.notifyDyn" : "atomics.notify", args: [array, index, arg(2, Infinity)], type: F64, loc, }; return { kind: "libCall", - fn: "atomics.op", + fn: dynamic ? "atomics.opDyn" : "atomics.op", args: [array, index, arg(2, 0), arg(3, 0), number(operation)], type: F64, loc, diff --git a/packages/compiler/src/frontend/lowering/builtins/numbers.ts b/packages/compiler/src/frontend/lowering/builtins/numbers.ts index 18ca0f1f3..1ff35fbb5 100644 --- a/packages/compiler/src/frontend/lowering/builtins/numbers.ts +++ b/packages/compiler/src/frontend/lowering/builtins/numbers.ts @@ -72,17 +72,14 @@ export function lowerNumberStaticCall( return { kind: "libCall", fn, args: [arg], type: BOOL, loc }; } if (member === "parseFloat" || member === "parseInt") { - const want = member === "parseFloat" ? 1 : 2; - if (call.arguments.nodes.length !== want) { - lowerer.noLowering( - `Number.${member} with ${call.arguments.nodes.length} argument${call.arguments.nodes.length === 1 ? "" : "s"}`, - call, - member === "parseInt" ? "pass an explicit radix: Number.parseInt(s, 10)" : undefined, - ); + const count = call.arguments.nodes.length; + if (count < 1 || count > (member === "parseFloat" ? 1 : 2)) { + lowerer.noLowering(`Number.${member} with ${count} argument${count === 1 ? "" : "s"}`, call); } // Number.parseFloat/Number.parseInt ARE the global parsers: over a // string argument they lower to the same static parse (parseInt with - // its explicit radix); only the coercing argument shapes are refused. + // its radix, or radix 0 when it is missing); only the coercing argument + // shapes are refused. const probed = tryLowerExpression(lowerer, call.arguments.nodes[0]!); if (probed !== null && isStringLike(lowerer, probed.type)) { const parsed = lowerStaticNumberGlobal(lowerer, member, call, call.arguments.nodes, loc); @@ -101,7 +98,10 @@ export function lowerNumberStaticCall( }; if (member === "parseFloat") return { kind: "libCall", fn: "num.parseFloat", args: [text], type: F64, loc }; - const radix = lowerer.lowerExprExpecting(call.arguments.nodes[1]!, F64); + const radixNode = call.arguments.nodes[1]; + const radix: IrExpr = radixNode + ? lowerer.lowerExprExpecting(radixNode, F64) + : { kind: "numLit", value: 0, type: F64, loc }; return { kind: "libCall", fn: "num.parseInt", args: [text, radix], type: F64, loc }; } const argText = diff --git a/packages/compiler/src/frontend/lowering/builtins/readline.ts b/packages/compiler/src/frontend/lowering/builtins/readline.ts index ede65d788..846b9a926 100644 --- a/packages/compiler/src/frontend/lowering/builtins/readline.ts +++ b/packages/compiler/src/frontend/lowering/builtins/readline.ts @@ -353,7 +353,8 @@ function lowerPromptArg(lowerer: Lowerer, node: ts.Expression): { value: IrExpr; * - on/once/addListener for 'line' ((input: string) or no parameters), * 'error' ((err: Error) or no parameters), 'history' ((history: * string[]) or no parameters), and 'close'/'pause'/'resume'/'SIGINT'/ - * 'SIGTSTP'/'SIGCONT' (no parameters), as statements. + * 'SIGTSTP'/'SIGCONT' (no parameters); as an expression the call yields + * the interface, so registrations chain. * Everything else the lib declares fences member-qualified. Null for * non-Interface receivers. */ export function lowerReadlineMethodCall( @@ -505,14 +506,19 @@ export function lowerReadlineMethodCall( `${RL_EVENT_LIST} are the supported readline events`, ); } - if (!ts.isExpressionStatement(call.parent)) { - lowerer.unsupported( - "SC1090", - call, - "chaining readline listener registration (register each listener as its own statement)", - ); - } - const recv = receiver(); + // As an expression (`rl.on("line", f).on("close", g)`), the call + // registers the listener and yields the interface, as Node's on() does. + const recvLocal = ts.isExpressionStatement(call.parent) + ? undefined + : lowerer.declareHiddenLocal("%readlineListener", F64); + const saved: IrStmt[] = + recvLocal === undefined + ? [] + : [{ kind: "varDecl", localId: recvLocal.id, init: receiver(), loc }]; + const recv: IrExpr = + recvLocal === undefined + ? receiver() + : { kind: "varRef", localId: recvLocal.id, type: F64, loc }; const cb = lowerer.lowerExpr(args[1]!); const want = event === "line" @@ -547,13 +553,21 @@ export function lowerReadlineMethodCall( : `'${event}' listeners with parameters or a return value (use ())`, ); } - return { + const register: IrExpr = { kind: "libCall", fn: "rl.on", args: [recv, numLit(ev, loc), cb, boolLit(name === "once", loc)], type: VOID, loc, }; + if (recvLocal === undefined) return register; + return { + kind: "seqExpr", + stmts: [...saved, { kind: "exprStmt", expr: register, loc }], + result: { kind: "varRef", localId: recvLocal.id, type: F64, loc }, + type: F64, + loc, + }; } lowerer.noLowering( `readline.Interface.${name}`, diff --git a/packages/compiler/src/frontend/lowering/containers/string-and-regexp.ts b/packages/compiler/src/frontend/lowering/containers/string-and-regexp.ts index 9567ee0f6..38865093f 100644 --- a/packages/compiler/src/frontend/lowering/containers/string-and-regexp.ts +++ b/packages/compiler/src/frontend/lowering/containers/string-and-regexp.ts @@ -919,12 +919,12 @@ export function lowerRegexMethodCall( })(); if ((receiverKind === "string" || nullableStringRecv) && name === "match") { const arg0 = call.arguments.nodes[0]; - if (!arg0 || lowerer.mapTypeOf(lowerer.typeOf(arg0))?.kind !== "regex") return null; // string-pattern match: the SC2020 fence + if (!arg0 || !isRegexPatternArgument(lowerer, arg0)) return null; // string-pattern match: the SC2020 fence if (call.arguments.nodes.length !== 1) return null; const receiver = nullableStringRecv ? lowerMethodReceiver(lowerer, access.expression, STRING, access.name.text) : lowerReceiver(); - const re = lowerer.lowerExprExpecting(arg0, { kind: "regex" }); + const re = lowerRegexPatternArgument(lowerer, arg0); // RegExpMatchArray | null maps to the string[] | null union by // itself; intern it directly when the checker's spelling doesn't — // or when it maps to something WIDER (an optional-chain call node @@ -982,10 +982,10 @@ export function lowerRegexMethodCall( // 0, exactly Node. Never throws. if (receiverKind === "string" && name === "search") { const arg0 = call.arguments.nodes[0]; - if (!arg0 || lowerer.mapTypeOf(lowerer.typeOf(arg0))?.kind !== "regex") return null; // string-pattern form: the SC2020 fence + if (!arg0 || !isRegexPatternArgument(lowerer, arg0)) return null; // string-pattern form: the SC2020 fence if (call.arguments.nodes.length !== 1) return null; const receiver = lowerReceiver(); - const re = lowerer.lowerExprExpecting(arg0, { kind: "regex" }); + const re = lowerRegexPatternArgument(lowerer, arg0); return { kind: "regexIntrinsic", method: "search", receiver, args: [re], type: F64, loc }; } if (receiverKind === "string" && (name === "replace" || name === "replaceAll")) { @@ -1920,3 +1920,31 @@ export function lowerDynPrimitiveMethodCall( ); return seq(stmts, result); } + +/** Whether the pattern of `match` or `search` is a RegExp, or a RegExp that + * may be undefined (`s.match(patterns[i])` under noUncheckedIndexedAccess). */ +function isRegexPatternArgument(lowerer: Lowerer, node: ts.Expression): boolean { + const t = lowerer.mapTypeOf(lowerer.typeOf(node)); + if (t?.kind === "regex") return true; + if (t?.kind !== "union") return false; + const arms = lowerer.unions.get(t.unionId)?.arms ?? []; + return ( + arms.length === 2 && + arms.some((arm) => arm.kind === "regex") && + arms.some((arm) => arm.kind === "undefinedT") + ); +} + +/** The pattern of `match` or `search` as a RegExp: an undefined pattern is + * `new RegExp(undefined)`, the empty pattern, as in Node. */ +function lowerRegexPatternArgument(lowerer: Lowerer, node: ts.Expression): IrExpr { + const regex: IrType = { kind: "regex" }; + const empty: IrExpr = { + kind: "regexLit", + pattern: "(?:)", + flags: "", + type: regex, + loc: locOf(node), + }; + return lowerOptionalArgument(lowerer, node, regex, empty); +} diff --git a/packages/compiler/src/ir/builtin-effects.ts b/packages/compiler/src/ir/builtin-effects.ts index ca8c52118..482739db5 100644 --- a/packages/compiler/src/ir/builtin-effects.ts +++ b/packages/compiler/src/ir/builtin-effects.ts @@ -97,6 +97,9 @@ export const MAY_THROW_LIB_FNS: ReadonlySet = new Set([ "atomics.op", "atomics.wait", "atomics.notify", + "atomics.opDyn", + "atomics.waitDyn", + "atomics.notifyDyn", "arrayBuffer.byteLengthGetter", "arrayBuffer.viewU8C", "arrayBuffer.viewI8", diff --git a/packages/compiler/src/ir/builtin-signatures.ts b/packages/compiler/src/ir/builtin-signatures.ts index fa7876579..49683550e 100644 --- a/packages/compiler/src/ir/builtin-signatures.ts +++ b/packages/compiler/src/ir/builtin-signatures.ts @@ -1252,6 +1252,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({ "atomics.wait": { argTypes: [bytesOf("i32"), F64, F64, F64], result: STRING }, "atomics.notify": { argTypes: [bytesOf("i32"), F64, F64], result: F64 }, "atomics.op": { argTypes: [null, F64, F64, F64, F64], result: F64 }, + "atomics.opDyn": { argTypes: [DYN, F64, F64, F64, F64], result: F64 }, + "atomics.waitDyn": { argTypes: [DYN, F64, F64, F64], result: STRING }, + "atomics.notifyDyn": { argTypes: [DYN, F64, F64], result: F64 }, "worker.new": { argTypes: [F64, STRING, DYN], result: DYN }, "worker.isMainThread": { argTypes: [], result: BOOL }, "worker.threadId": { argTypes: [], result: F64 }, diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6862-readline-chained-listeners.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6862-readline-chained-listeners.cjs.json new file mode 100644 index 000000000..5beb42eaf --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6862-readline-chained-listeners.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6862-readline-chained-listeners.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6865-number-parseint-default-radix.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6865-number-parseint-default-radix.ts.json new file mode 100644 index 000000000..225f2c462 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6865-number-parseint-default-radix.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6865-number-parseint-default-radix.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6866-number-parseint-untyped.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6866-number-parseint-untyped.js.json new file mode 100644 index 000000000..f000b3a36 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6866-number-parseint-untyped.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6866-number-parseint-untyped.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6867-string-match-optional-regexp.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6867-string-match-optional-regexp.js.json new file mode 100644 index 000000000..1d1105bab --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6867-string-match-optional-regexp.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6867-string-match-optional-regexp.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6868-buffer-from-untyped-array-buffer.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6868-buffer-from-untyped-array-buffer.cjs.json new file mode 100644 index 000000000..baa6e1935 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6868-buffer-from-untyped-array-buffer.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6868-buffer-from-untyped-array-buffer.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6869-atomics-untyped-arrays.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6869-atomics-untyped-arrays.cjs.json new file mode 100644 index 000000000..f91624eb9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6869-atomics-untyped-arrays.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6869-atomics-untyped-arrays.cjs" + ], + "diags": [] +} diff --git a/packages/runtime/src/scr_bytes_io.c b/packages/runtime/src/scr_bytes_io.c index 5532d96da..ac8fad02e 100644 --- a/packages/runtime/src/scr_bytes_io.c +++ b/packages/runtime/src/scr_bytes_io.c @@ -1299,8 +1299,19 @@ ScrBytes *scr_buffer_concat_len_dyn(const ScrDyn *list, double total) { return scr_buffer_concat_dyn_impl(list, total, true); } +/* Buffer.from(arrayBuffer) over a checked value: a Buffer over all of the + * ArrayBuffer or SharedArrayBuffer that shares its memory, as in Node. A + * second argument would be the byte offset, and an encoding name converts + * to NaN, which is offset 0. */ +static ScrBytes *scr_buffer_from_storage(const ScrDyn *storage) { + ScrBytes *out = scr_bytes_buffer_view(storage->v.handle.ptr, SCR_BYTES_U8, 0, false, 0); + if (out) out->is_buffer = true; + return out; +} + ScrBytes *scr_buffer_from_dyn(const ScrDyn *value, const ScrStr *encoding) { if (value->kind == SCR_DYN_STR) return scr_bytes_from_str(value->v.str, encoding); + if (scr_buffer_storage_is(value)) return scr_buffer_from_storage(value); if (value->kind == SCR_DYN_BYTES) return scr_bytes_convert(SCR_BYTES_U8, value->v.bytes); if (value->kind == SCR_DYN_ARR) { return scr_buffer_from_array_like(value, (double)value->v.arr.len); @@ -1344,6 +1355,8 @@ ScrBytes *scr_buffer_from_dyn_pooled(const ScrDyn *value, const ScrStr *encoding if (value->kind == SCR_DYN_STR) return scr_buffer_from_str(value->v.str, encoding); if (value->kind == SCR_DYN_BYTES && !value->v.bytes->is_data_view) return scr_buffer_from_bytes(value->v.bytes); + /* A view of an ArrayBuffer shares its memory, so it never comes from the pool. */ + if (scr_buffer_storage_is(value)) return scr_buffer_from_storage(value); ScrBytes *out = scr_buffer_from_dyn(value, encoding); if (!out) return NULL; out->is_buffer = true; diff --git a/packages/runtime/src/scr_lib.h b/packages/runtime/src/scr_lib.h index 1b859cea1..3ce18d793 100644 --- a/packages/runtime/src/scr_lib.h +++ b/packages/runtime/src/scr_lib.h @@ -365,6 +365,9 @@ typedef struct ScrBytes ScrBytes; ScrStr *scr_atomics_wait(ScrBytes *, double, double, double); double scr_atomics_notify(ScrBytes *, double, double); double scr_atomics_op(ScrBytes *, double, double, double, double); +double scr_atomics_op_dyn(const ScrDyn *, double, double, double, double); +ScrStr *scr_atomics_wait_dyn(const ScrDyn *, double, double, double); +double scr_atomics_notify_dyn(const ScrDyn *, double, double); /* isatty(3) over an fd (0/1/2): a real boolean — false where Node's * non-TTY streams expose undefined (SEMANTICS.md). stdin_destroy is a diff --git a/packages/runtime/src/scr_shared.c b/packages/runtime/src/scr_shared.c index 2dac5a4d1..6505a71ab 100644 --- a/packages/runtime/src/scr_shared.c +++ b/packages/runtime/src/scr_shared.c @@ -7,7 +7,9 @@ #include "scr_numeric.h" #include #include +#include #include +#include #include #if defined(SCR_WORKERS) || (defined(SCR_LIB) && defined(SCR_THREAD_INSTANCES)) #ifdef _WIN32 @@ -360,3 +362,69 @@ double scr_atomics_notify(ScrBytes *bytes, double index, double count) { scr_wait_unlock(bucket); return notified; } + +/* V8's text for a value in the TypeErrors below: a typed array as + * [object Int8Array] and so on, an array as [object Array], an ArrayBuffer + * or other native object as #, an object as #, and + * other values as String() gives them (undefined and null by name). */ +static ScrStr *scr_atomics_value_text(const ScrDyn *value) { + char text[64]; + int n; + if (value->kind == SCR_DYN_BYTES) { + if (value->v.bytes->is_data_view) n = snprintf(text, sizeof text, "#"); + else n = snprintf(text, sizeof text, "[object %s]", scr_bytes_elem_name(value->v.bytes->elem)); + } else if (value->kind == SCR_DYN_ARR) { + n = snprintf(text, sizeof text, "[object Array]"); + } else if (value->kind == SCR_DYN_HANDLE) { + n = snprintf(text, sizeof text, "#<%s>", scr_dyn_handle_ops_of(value)->cls); + } else if (value->kind == SCR_DYN_OBJ) { + const char *name = scr_dyn_class_name(value); + n = snprintf(text, sizeof text, "#<%s>", name ? name : "Object"); + } else if (value->kind == SCR_DYN_TYPED_REF && scr_dyn_typed_ref_class_name(value)) { + const ScrStr *name = scr_dyn_typed_ref_class_name(value); + n = snprintf(text, sizeof text, "#<%.*s>", (int)name->len, (const char *)name->data); + } else if (value->kind == SCR_DYN_UNDEF) { + n = snprintf(text, sizeof text, "undefined"); + } else if (value->kind == SCR_DYN_NULL) { + n = snprintf(text, sizeof text, "null"); + } else { + return scr_dyn_to_string(value, NULL); + } + return scr_str_new(text, n < (int)sizeof text ? (size_t)n : sizeof text - 1); +} + +/* The integer typed array an untyped Atomics argument holds, or NULL with + * Node's TypeError pending. `waitable` requires an Int32Array, as wait and + * notify do. */ +static ScrBytes *scr_atomics_dyn_array(const ScrDyn *value, bool waitable) { + if (value->kind == SCR_DYN_BYTES && !value->v.bytes->is_data_view) { + ScrBytesElem elem = value->v.bytes->elem; + bool integer = elem == SCR_BYTES_I8 || elem == SCR_BYTES_U8 || elem == SCR_BYTES_I16 || + elem == SCR_BYTES_U16 || elem == SCR_BYTES_I32 || elem == SCR_BYTES_U32; + if (waitable ? elem == SCR_BYTES_I32 : integer) return value->v.bytes; + } + ScrStr *shown = scr_atomics_value_text(value); + if (!shown) return NULL; + const char *tail = waitable ? " is not an int32 or BigInt64 typed array." : " is not an integer typed array."; + ScrStr *parts[2] = {shown, scr_str_new(tail, strlen(tail))}; + ScrStr *message = scr_str_concat_parts(parts, 2); + scr_str_release(parts[0]); + scr_str_release(parts[1]); + scr_throw_error(SCR_ERR_TYPE, message); + return NULL; +} + +double scr_atomics_op_dyn(const ScrDyn *array, double index, double value, double replacement, double operation) { + ScrBytes *bytes = scr_atomics_dyn_array(array, false); + return bytes ? scr_atomics_op(bytes, index, value, replacement, operation) : 0; +} + +ScrStr *scr_atomics_wait_dyn(const ScrDyn *array, double index, double expected, double timeout) { + ScrBytes *bytes = scr_atomics_dyn_array(array, true); + return bytes ? scr_atomics_wait(bytes, index, expected, timeout) : NULL; +} + +double scr_atomics_notify_dyn(const ScrDyn *array, double index, double count) { + ScrBytes *bytes = scr_atomics_dyn_array(array, true); + return bytes ? scr_atomics_notify(bytes, index, count) : 0; +} diff --git a/tests/corpus/6862-readline-chained-listeners.cjs b/tests/corpus/6862-readline-chained-listeners.cjs new file mode 100644 index 000000000..78c05063f --- /dev/null +++ b/tests/corpus/6862-readline-chained-listeners.cjs @@ -0,0 +1,29 @@ +// Chained readline listener registration: on(), once() and addListener() +// return the interface, so `createInterface(...).on('line', f).on('close', g)` +// registers both listeners, in order, on the same interface; a chain's value +// is the interface itself. +'use strict'; +const readline = require('node:readline'); +const { Readable } = require('node:stream'); + +const lines = []; +readline + .createInterface({ input: Readable.from(['alpha\nbeta\n', 'gamma\n']), terminal: false }) + .on('line', (line) => lines.push(line)) + .once('line', (line) => console.log('first line', line)) + .on('close', () => console.log('lines', lines.length, lines.join(','))); + +const rl = readline.createInterface({ input: Readable.from(['one\ntwo']) }); +const same = rl.on('line', (line) => console.log('rl line', line)).addListener('close', () => { + console.log('rl close'); +}); +console.log('chain returns the interface', same === rl); + +let count = 0; +readline + .createInterface({ input: Readable.from(['x\ny\nz\n']) }) + .on('line', () => { + count++; + }) + .on('pause', () => console.log('pause after', count)) + .on('close', () => console.log('count', count)); diff --git a/tests/corpus/6865-number-parseint-default-radix.ts b/tests/corpus/6865-number-parseint-default-radix.ts new file mode 100644 index 000000000..dc6d2a4ad --- /dev/null +++ b/tests/corpus/6865-number-parseint-default-radix.ts @@ -0,0 +1,16 @@ +// Number.parseInt without a radix parses as the global parseInt does: radix +// 10, or 16 after a 0x prefix, after leading whitespace and a sign, stopping +// at the first character that is not a digit. +const inputs = ["42", " 17px", "0x1F", "-0x10", "0X0a", "08", "010", "1e3", "", " ", "abc", " -0", "+12", "9007199254740993", "0b11", "0o17", "\t\n 99 bottles", "١٢", "-", "0x"]; +for (const text of inputs) { + const parsed = Number.parseInt(text); + console.log(JSON.stringify(text), Object.is(parsed, -0) ? "-0" : String(parsed), parsed === parseInt(text)); +} + +function depth(arg: string | undefined): number { + return Math.max(6, Number.parseInt(arg ?? "10")); +} +console.log("depth", depth(process.argv[2]), depth("21"), depth("3")); + +const sizes = "640x480".split("x").map((part) => Number.parseInt(part)); +console.log("sizes", sizes[0]! * sizes[1]!); diff --git a/tests/corpus/6866-number-parseint-untyped.js b/tests/corpus/6866-number-parseint-untyped.js new file mode 100644 index 000000000..48223bd9b --- /dev/null +++ b/tests/corpus/6866-number-parseint-untyped.js @@ -0,0 +1,9 @@ +// Number.parseInt over untyped values in JavaScript, with and without a +// radix: the argument converts with ToString first ("undefined", "null", +// "1,2" for an array), then parses as the global parseInt does. +const config = JSON.parse('{"port":"8080","hex":"0xff","list":[3,4],"flag":true,"none":null}'); +for (const key of ["port", "hex", "list", "flag", "none", "missing"]) { + const value = config[key]; + console.log(key, Number.parseInt(value), Number.parseInt(value, 16), Number.parseInt(value, 36)); +} +console.log("argv", Number.parseInt(process.argv[2])); diff --git a/tests/corpus/6867-string-match-optional-regexp.js b/tests/corpus/6867-string-match-optional-regexp.js new file mode 100644 index 000000000..e847bda36 --- /dev/null +++ b/tests/corpus/6867-string-match-optional-regexp.js @@ -0,0 +1,20 @@ +// String match and search in JavaScript with a pattern that may be undefined +// (a Map lookup or an array read): a RegExp matches as usual, and an +// undefined pattern is `new RegExp(undefined)`, the empty pattern. +const text = 'agggtaaa tttaccct agggtaaa'; +const patterns = new Map([ + ['forward', /agggtaaa/g], + ['either', /agggtaaa|tttaccct/gi], + ['first', /t+a/], +]); +for (const name of ['forward', 'either', 'first', 'missing']) { + const re = patterns.get(name); + const m = text.match(re); + console.log(name, m === null ? null : m.length, m === null ? '' : JSON.stringify([...m]), text.search(re)); +} + +const list = [/a(g+)/, /x/]; +for (let i = 0; i < 3; i++) { + const m = text.match(list[i]); + console.log(i, m === null ? 'null' : `${m[0]} at ${m.index} ${m[1] ?? ''}`, text.search(list[i])); +} diff --git a/tests/corpus/6868-buffer-from-untyped-array-buffer.cjs b/tests/corpus/6868-buffer-from-untyped-array-buffer.cjs new file mode 100644 index 000000000..f525f24cf --- /dev/null +++ b/tests/corpus/6868-buffer-from-untyped-array-buffer.cjs @@ -0,0 +1,38 @@ +// Buffer.from over an untyped ArrayBuffer or SharedArrayBuffer (read from a +// Map, an untyped object field or a worker message): the Buffer covers the +// whole buffer and shares its memory, in both directions, as in Node. An +// encoding name in the second argument converts to byte offset 0. +'use strict'; +const { Worker, isMainThread, parentPort, workerData } = require('node:worker_threads'); + +if (isMainThread) { + const store = new Map(); + store.set('plain', new ArrayBuffer(6)); + store.set('shared', new SharedArrayBuffer(6)); + for (const key of ['plain', 'shared']) { + const storage = store.get(key); + const buf = Buffer.from(storage); + buf[1] = 0x41; + new Uint8Array(storage)[2] = 0x42; + console.log(key, buf.length, Buffer.isBuffer(buf), buf.toString('hex'), new Uint8Array(storage).join(',')); + const encoded = Buffer.from(storage, 'utf8'); + console.log(key, 'with encoding', encoded.length, encoded.toString('hex')); + } + + const holder = JSON.parse('{}'); + holder.data = new ArrayBuffer(3); + const view = Buffer.from(holder.data); + view.write('xyz'); + console.log('field', Buffer.from(holder.data).toString()); + + const sab = new SharedArrayBuffer(8); + const worker = new Worker(__filename, { workerData: sab }); + worker.on('message', (message) => { + const seen = Buffer.from(message.storage); + console.log('worker wrote', seen.toString('latin1'), new Uint8Array(sab).join(',')); + }); +} else { + const out = Buffer.from(workerData); + out.write('shared!'); + parentPort.postMessage({ storage: workerData }); +} diff --git a/tests/corpus/6869-atomics-untyped-arrays.cjs b/tests/corpus/6869-atomics-untyped-arrays.cjs new file mode 100644 index 000000000..18fe07319 --- /dev/null +++ b/tests/corpus/6869-atomics-untyped-arrays.cjs @@ -0,0 +1,65 @@ +// Atomics over untyped arrays in JavaScript: a worker's workerData carries +// Int32Array and Uint8Array views of a SharedArrayBuffer, and load, store, +// add, sub, and, or, xor, exchange, compareExchange, wait and notify run on +// them as on typed bindings. Other values throw Node's +// TypeError, and an index outside the array Node's RangeError. The results +// go to an untyped array. +'use strict'; +const { Worker, isMainThread, parentPort, workerData } = require('node:worker_threads'); + +const lines = []; +function attempt(label, run) { + try { + run(); + lines.push(`${label} ok`); + } catch (error) { + lines.push(`${label} ${error.name} ${error.message}`); + } +} + +if (isMainThread) { + const sab = new SharedArrayBuffer(16); + const counters = new Int32Array(sab); + const worker = new Worker(__filename, { workerData: { counters, bytes: new Uint8Array(sab, 8, 8) } }); + worker.on('message', (message) => { + if (message === 'ready') { + Atomics.store(counters, 1, 42); + console.log('notified', Atomics.notify(counters, 1, 1) >= 0); + return; + } + for (const line of message.lines) console.log(line); + console.log('worker results', JSON.stringify(message.out)); + console.log('counters', Array.from(counters).join(',')); + }); +} else { + const counters = workerData.counters; + const bytes = workerData.bytes; + const out = []; + out.push(Atomics.add(counters, 0, 5), Atomics.sub(counters, 0, 2), Atomics.load(counters, 0)); + out.push(Atomics.or(counters, 2, 6), Atomics.and(counters, 2, 3), Atomics.xor(counters, 2, 1), Atomics.load(counters, 2)); + out.push(Atomics.exchange(counters, 3, 9), Atomics.compareExchange(counters, 3, 9, 11), Atomics.compareExchange(counters, 3, 0, 1)); + out.push(Atomics.add(bytes, 0, 300), Atomics.load(bytes, 0), Atomics.sub(bytes, 1, 1), Atomics.load(bytes, 1)); + out.push(Atomics.load(counters, 1.9), Atomics.load(counters, NaN)); + attempt('index past the end', () => { + Atomics.load(counters, 4); + }); + attempt('negative index', () => { + Atomics.add(bytes, -1, 1); + }); + const values = [[], {}, undefined, null, 5, 'text', new Float64Array(2), new Map(), new ArrayBuffer(4), new DataView(new ArrayBuffer(4))]; + for (const value of values) { + attempt('load', () => { + Atomics.load(value, 0); + }); + attempt('notify', () => { + Atomics.notify(value, 0); + }); + } + attempt('wait on Uint8Array', () => { + Atomics.wait(bytes, 0, 0, 0); + }); + out.push(Atomics.wait(counters, 1, 0, 0)); + parentPort.postMessage('ready'); + out.push(Atomics.wait(counters, 1, 0, 5000) === 'ok' || Atomics.load(counters, 1) === 42); + parentPort.postMessage({ out, lines }); +} diff --git a/tests/harness/corpus-costs/6862-readline-chained-listeners.cjs.json b/tests/harness/corpus-costs/6862-readline-chained-listeners.cjs.json new file mode 100644 index 000000000..5c8f4dafd --- /dev/null +++ b/tests/harness/corpus-costs/6862-readline-chained-listeners.cjs.json @@ -0,0 +1 @@ +{ "plain": 1930, "san": 4280 } diff --git a/tests/harness/corpus-costs/6865-number-parseint-default-radix.ts.json b/tests/harness/corpus-costs/6865-number-parseint-default-radix.ts.json new file mode 100644 index 000000000..ad095e0af --- /dev/null +++ b/tests/harness/corpus-costs/6865-number-parseint-default-radix.ts.json @@ -0,0 +1 @@ +{ "plain": 1940, "san": 4550 } diff --git a/tests/harness/corpus-costs/6866-number-parseint-untyped.js.json b/tests/harness/corpus-costs/6866-number-parseint-untyped.js.json new file mode 100644 index 000000000..03bfc0b22 --- /dev/null +++ b/tests/harness/corpus-costs/6866-number-parseint-untyped.js.json @@ -0,0 +1 @@ +{ "plain": 1830, "san": 3890 } diff --git a/tests/harness/corpus-costs/6867-string-match-optional-regexp.js.json b/tests/harness/corpus-costs/6867-string-match-optional-regexp.js.json new file mode 100644 index 000000000..f6a23dfa9 --- /dev/null +++ b/tests/harness/corpus-costs/6867-string-match-optional-regexp.js.json @@ -0,0 +1 @@ +{ "plain": 1960, "san": 4170 } diff --git a/tests/harness/corpus-costs/6868-buffer-from-untyped-array-buffer.cjs.json b/tests/harness/corpus-costs/6868-buffer-from-untyped-array-buffer.cjs.json new file mode 100644 index 000000000..a1967e528 --- /dev/null +++ b/tests/harness/corpus-costs/6868-buffer-from-untyped-array-buffer.cjs.json @@ -0,0 +1 @@ +{ "plain": 2070, "san": 4110 } diff --git a/tests/harness/corpus-costs/6869-atomics-untyped-arrays.cjs.json b/tests/harness/corpus-costs/6869-atomics-untyped-arrays.cjs.json new file mode 100644 index 000000000..114626b53 --- /dev/null +++ b/tests/harness/corpus-costs/6869-atomics-untyped-arrays.cjs.json @@ -0,0 +1 @@ +{ "plain": 2500, "san": 4710 } From 71dccbb8a837820ff56fad25d367fc76d3688810 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 00:31:48 -0500 Subject: [PATCH 014/102] Declare runtime ABI 24 in the native toolchain test's runtime pack fixture The toolchain integrity test builds a runtime pack manifest by hand. It still declared ABI 23 after the runtime ABI moved to 24, so the staging check rejected the pack instead of staging it. --- tests/harness/self-hosting-native-toolchain.test.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/harness/self-hosting-native-toolchain.test.ts b/tests/harness/self-hosting-native-toolchain.test.ts index 6d028d597..7da7626b7 100644 --- a/tests/harness/self-hosting-native-toolchain.test.ts +++ b/tests/harness/self-hosting-native-toolchain.test.ts @@ -105,7 +105,7 @@ for (const backend of ["llvm"] as const) { object_format: target.objectFormat, minimum_os: target.minimumOs, }, - runtime_abi: { version: 23, marker: "scr_runtime_abi_v23" }, + runtime_abi: { version: 24, marker: "scr_runtime_abi_v24" }, compiler: { command: "fixture", identity: "fixture", target: target.llvmTriple }, macros: { executable: [], excluded: [], sanitizer: "external-toolchain-required" }, flavors: { From 2d353e6bbe58f399e087fec007beb02138d44279 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 00:33:54 -0500 Subject: [PATCH 015/102] Compute Math.pow(2, n) for integer exponents from the result's bits --- .../src/backend/llvm/lib-filesystem.ts | 62 +++++++++++++++++++ .../corpus/6863-math-pow-base-two.ts.json | 6 ++ packages/runtime/src/scr_lib.c | 11 ++++ tests/corpus/6863-math-pow-base-two.ts | 51 +++++++++++++++ .../6863-math-pow-base-two.ts.json | 1 + 5 files changed, 131 insertions(+) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6863-math-pow-base-two.ts.json create mode 100644 tests/corpus/6863-math-pow-base-two.ts create mode 100644 tests/harness/corpus-costs/6863-math-pow-base-two.ts.json diff --git a/packages/compiler/src/backend/llvm/lib-filesystem.ts b/packages/compiler/src/backend/llvm/lib-filesystem.ts index 358b21c4f..6d5fe652d 100644 --- a/packages/compiler/src/backend/llvm/lib-filesystem.ts +++ b/packages/compiler/src/backend/llvm/lib-filesystem.ts @@ -969,6 +969,64 @@ export function emitPathUrlLibCall(host: LlvmEmitterContext, e: LibCallExpr): Ll return host.emitGenericLibCall(e); } +/** Math.pow(2, n): for an integer n from -1074 to 1023 the result is the + * power of two whose bits are its exponent field (or, below -1022, one + * mantissa bit of a subnormal), the value pow returns. Other exponents call + * scr_math_pow. */ +function emitPowerOfTwo(host: LlvmEmitterContext, n: string): string { + const B = host.B; + const check = B.newLabel("pow2.check"); + const exact = B.newLabel("pow2.exact"); + const call = B.newLabel("pow2.call"); + const join = B.newLabel("pow2.join"); + const low = B.tmp(); + const high = B.tmp(); + const inRange = B.tmp(); + B.line(`${low} = fcmp oge double ${n}, ${f64Lit(-1074)}`); + B.line(`${high} = fcmp ole double ${n}, ${f64Lit(1023)}`); + B.line(`${inRange} = and i1 ${low}, ${high}`); + B.condBr(inRange, check, call); + B.startBlock(check); + const int = B.tmp(); + const back = B.tmp(); + const integral = B.tmp(); + B.line(`${int} = fptosi double ${n} to i32`); + B.line(`${back} = sitofp i32 ${int} to double`); + B.line(`${integral} = fcmp oeq double ${back}, ${n}`); + B.condBr(integral, exact, call); + B.startBlock(exact); + const normal = B.tmp(); + const biased = B.tmp(); + const biasedWide = B.tmp(); + const normalBits = B.tmp(); + const shift = B.tmp(); + const shiftWide = B.tmp(); + const subnormalBits = B.tmp(); + const bits = B.tmp(); + const power = B.tmp(); + B.line(`${normal} = icmp sge i32 ${int}, -1022`); + B.line(`${biased} = add i32 ${int}, 1023`); + B.line(`${biasedWide} = zext i32 ${biased} to i64`); + B.line(`${normalBits} = shl i64 ${biasedWide}, 52`); + B.line(`${shift} = add i32 ${int}, 1074`); + B.line(`${shiftWide} = zext i32 ${shift} to i64`); + B.line(`${subnormalBits} = shl i64 1, ${shiftWide}`); + B.line(`${bits} = select i1 ${normal}, i64 ${normalBits}, i64 ${subnormalBits}`); + B.line(`${power} = bitcast i64 ${bits} to double`); + const exactEnd = B.currentLabel(); + B.br(join); + B.startBlock(call); + host.declare(`declare double @scr_math_pow(double, double)`); + const called = B.tmp(); + B.line(`${called} = call double @scr_math_pow(double ${f64Lit(2)}, double ${n})`); + const callEnd = B.currentLabel(); + B.br(join); + B.startBlock(join); + const out = B.tmp(); + B.line(`${out} = phi double [ ${power}, %${exactEnd} ], [ ${called}, %${callEnd} ]`); + return out; +} + export function emitPrimitiveLibCall(host: LlvmEmitterContext, e: LibCallExpr): LlValue { const B = host.B; if (e.fn === "math.min" || e.fn === "math.max") { @@ -986,6 +1044,10 @@ export function emitPrimitiveLibCall(host: LlvmEmitterContext, e: LibCallExpr): const v = host.emitExpr(e.args[0]!); return { name: emitTruncF64(host, v.name), type: e.type }; } + if (e.fn === "math.pow" && e.args[0]!.kind === "numLit" && e.args[0]!.value === 2) { + const v = host.emitExpr(e.args[1]!); + return { name: emitPowerOfTwo(host, v.name), type: e.type }; + } if (e.fn === "math.floor" || e.fn === "math.ceil") { const intr = e.fn === "math.floor" ? "floor" : "ceil"; const v = host.emitExpr(e.args[0]!); diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6863-math-pow-base-two.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6863-math-pow-base-two.ts.json new file mode 100644 index 000000000..4e09ac362 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6863-math-pow-base-two.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6863-math-pow-base-two.ts" + ], + "diags": [] +} diff --git a/packages/runtime/src/scr_lib.c b/packages/runtime/src/scr_lib.c index 3441e6142..ee4c34592 100644 --- a/packages/runtime/src/scr_lib.c +++ b/packages/runtime/src/scr_lib.c @@ -6821,6 +6821,17 @@ double scr_math_round(double x) { * powers, follow libm. */ double scr_math_pow(double base, double exponent) { if (isnan(exponent) || (isinf(exponent) && fabs(base) == 1.0)) return NAN; + /* 2 ** n for an integer n in the double range is an exact power of two, + * the value pow returns; its bits are the exponent alone. */ + if (base == 2.0 && exponent >= -1074.0 && exponent <= 1023.0) { + int32_t n = (int32_t)exponent; + if ((double)n == exponent) { + uint64_t bits = n >= -1022 ? (uint64_t)(n + 1023) << 52 : UINT64_C(1) << (n + 1074); + double result; + memcpy(&result, &bits, sizeof result); + return result; + } + } return pow(base, exponent); } diff --git a/tests/corpus/6863-math-pow-base-two.ts b/tests/corpus/6863-math-pow-base-two.ts new file mode 100644 index 000000000..fa965382d --- /dev/null +++ b/tests/corpus/6863-math-pow-base-two.ts @@ -0,0 +1,51 @@ +// Math.pow(2, n) with a literal base of 2 and with a base of 2 in a variable, +// over every integer exponent from -1080 to 1030: subnormal results down to +// 2 ** -1074, zero below it, Infinity above 1023. Non-integer, signed-zero, +// infinite and NaN exponents, and bases next to 2, take the general path. +function bits(x: number): string { + const view = new DataView(new ArrayBuffer(8)); + view.setFloat64(0, x); + return view.getBigUint64(0).toString(16).padStart(16, "0"); +} + +function show(label: string, x: number): void { + console.log(label, bits(x), Object.is(x, -0) ? "-0" : String(x)); +} + +let base = 2; +if (process.argv.length > 99) base = 3; + +let literalDigest = 0n; +let variableDigest = 0n; +let mismatches = 0; +for (let n = -1080; n <= 1030; n++) { + const literal = Math.pow(2, n); + const variable = Math.pow(base, n); + literalDigest = (literalDigest * 31n + BigInt(`0x${bits(literal)}`)) & 0xffffffffffffffffn; + variableDigest = (variableDigest * 31n + BigInt(`0x${bits(variable)}`)) & 0xffffffffffffffffn; + if (!Object.is(literal, variable)) mismatches++; + if (n <= -1070 || (n >= -1025 && n <= -1019) || (n >= -2 && n <= 2) || (n >= 51 && n <= 54) || n >= 1021) { + show(`2 ** ${n}`, literal); + } +} +console.log("digests", literalDigest.toString(16), variableDigest.toString(16), "mismatches", mismatches); + +const exponents = [0.5, -0.5, 1.5, -0, 0, 1e-300, -1e-300, 1023.0000001, 1022.9999999, -1074.5, -1073.5, Infinity, -Infinity, NaN, 52.999999999999996, 2 ** 31, -(2 ** 31)]; +for (const e of exponents) { + show(`literal ${e}`, Math.pow(2, e)); + show(`variable ${e}`, Math.pow(base, e)); +} +for (const b of [-2, 2.0000000000000004, 1.9999999999999998, 4, 0.5]) { + show(`${b} ** 10`, Math.pow(b, 10)); + show(`${b} ** -3`, Math.pow(b, -3)); +} + +// In a loop that masks values, as a k-mer counter does. +let key = 0; +let total = 0; +for (let i = 0; i < 100000; i++) { + const length = (i % 18) + 1; + key = (key * 4 + (i % 4)) % Math.pow(2, 2 * length); + total += key - Math.floor(key / Math.pow(2, length)) * Math.pow(2, length); +} +console.log("masked total", total); diff --git a/tests/harness/corpus-costs/6863-math-pow-base-two.ts.json b/tests/harness/corpus-costs/6863-math-pow-base-two.ts.json new file mode 100644 index 000000000..3b43cd660 --- /dev/null +++ b/tests/harness/corpus-costs/6863-math-pow-base-two.ts.json @@ -0,0 +1 @@ +{ "plain": 2110, "san": 4860 } From 47ba594c3f687bee589c2137fd6995678f10eb52 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 00:34:51 -0500 Subject: [PATCH 016/102] Check every type a package type reaches before re-exporting it as a data shape The data-shape check answered a type that refers back to a type still being checked as a data shape and recorded that answer before the outer check finished. With `Branch { child: Tree; handle: Handle }` and `Tree { parent: Branch | null }`, checking Branch first recorded Tree as a data shape, and Tree was re-exported although Branch reaches an interface with a method. The check now walks every type reachable from the queried one before it records any of them as a data shape, and records the types on the path to a non-data type as non-data. --- .../npm-static-type-exports-host.test.ts | 59 +++++++++++++++ .../frontend/npm-static-type-exports-host.ts | 75 ++++++++++++------- 2 files changed, 109 insertions(+), 25 deletions(-) create mode 100644 packages/compiler/src/frontend/npm-static-type-exports-host.test.ts diff --git a/packages/compiler/src/frontend/npm-static-type-exports-host.test.ts b/packages/compiler/src/frontend/npm-static-type-exports-host.test.ts new file mode 100644 index 000000000..e37283fe6 --- /dev/null +++ b/packages/compiler/src/frontend/npm-static-type-exports-host.test.ts @@ -0,0 +1,59 @@ +import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { afterAll, expect, test } from "vitest"; +import { nodeFrontendServices } from "./services-node.js"; +import { npmStaticTypeExportPlan } from "./npm-static-type-exports-host.js"; + +const dirs: string[] = []; +afterAll(() => { + for (const dir of dirs) rmSync(dir, { recursive: true, force: true }); +}); + +/** A program directory with one package whose .d.ts is `declarations`; + * returns the program's entry path. */ +function fixture(declarations: string): string { + const dir = mkdtempSync(join(tmpdir(), "scriptc-type-exports-")); + dirs.push(dir); + const lib = join(dir, "node_modules", "pkg", "lib"); + mkdirSync(lib, { recursive: true }); + writeFileSync( + join(dir, "node_modules", "pkg", "package.json"), + JSON.stringify({ name: "pkg", main: "./lib/index.js", types: "./lib/index.d.ts" }), + ); + writeFileSync(join(lib, "index.d.ts"), declarations); + writeFileSync(join(lib, "index.js"), "exports.grow = function grow(into) {};\n"); + writeFileSync(join(dir, "main.ts"), 'import { grow } from "pkg";\n'); + return join(dir, "main.ts"); +} + +/** The type names the runtime entry's typedefs re-export. */ +function reexported(entry: string): string[] { + const plan = npmStaticTypeExportPlan(nodeFrontendServices(), entry, ["pkg"]); + const block = [...plan.typedefs.values()].join("\n"); + return [...block.matchAll(/@typedef \{[^}]*\} (\w+)/g)].map((m) => m[1]!); +} + +test("only data shapes are re-exported", () => { + const entry = fixture(`export interface Point { x: number; y: number } +export interface Handle { close(): void } +export type Label = { text: string; at: Point }; +export type Callback = (point: Point) => void; +export interface Holder { handle: Handle } +export declare function grow(into: Point[]): void; +`); + expect(reexported(entry)).toEqual(["Point", "Label"]); +}); + +test("mutually recursive types are data shapes only when every type they reach is", () => { + // Branch is checked first and reaches Tree, which refers back to Branch: + // Tree is a data shape only if Branch is, and Branch holds a Handle. + const entry = fixture(`export interface Branch { child: Tree; handle: Handle } +export interface Tree { name: string; parent: Branch | null } +export interface Handle { close(): void } +export interface Node { value: number; next: List } +export interface List { head: Node | null } +export declare function grow(into: Tree[]): void; +`); + expect(reexported(entry)).toEqual(["Node", "List"]); +}); diff --git a/packages/compiler/src/frontend/npm-static-type-exports-host.ts b/packages/compiler/src/frontend/npm-static-type-exports-host.ts index 3c196e6a7..8a61ed62b 100644 --- a/packages/compiler/src/frontend/npm-static-type-exports-host.ts +++ b/packages/compiler/src/frontend/npm-static-type-exports-host.ts @@ -154,32 +154,57 @@ export function npmStaticTypeExportPlan( // package's declaration files do not declare is a global (`Array`, // `Record`, `Date`); a class, a value or an import from another package // is not a data shape. + // + // `referencesOf` answers one name: null when it is not a data shape by + // itself, otherwise the names it refers to. + type Ref = { file: string; name: string }; + const referencesOf = (file: string, name: string): Ref[] | null => { + const ex = declarationExports(file); + if (ex === null) return null; + const local = ex.locals.get(name); + if (local !== undefined) + return local.behavior ? null : local.references.map((r) => ({ file, name: r })); + if (ex.valueNames.has(name)) return null; + const from = ex.imports.get(name); + if (from !== undefined) { + const target = declarationTargetOf(file, from.specifier); + return target === null ? null : [{ file: target, name: from.local }]; + } + const reexport = typesOf(file, new Set()).types.get(name); + if (reexport !== undefined) return [{ file: reexport.file, name: reexport.decl.declared }]; + return []; + }; + // A name is a data shape when every name reachable from it is one by + // itself. `isData` walks everything reachable before it records any name + // as a data shape, so a type in a reference cycle is not recorded while + // another type in the cycle is still unchecked. const dataMemo = new Map(); - const isData = (file: string, name: string, visiting: Set): boolean => { - const key = `${file}\0${name}`; - const memo = dataMemo.get(key); - if (memo !== undefined) return memo; - if (visiting.has(key)) return true; // a recursive shape - visiting.add(key); - const answer = ((): boolean => { - const ex = declarationExports(file); - if (ex === null) return false; - const local = ex.locals.get(name); - if (local !== undefined) - return !local.behavior && local.references.every((r) => isData(file, r, visiting)); - if (ex.valueNames.has(name)) return false; - const from = ex.imports.get(name); - if (from !== undefined) { - const target = declarationTargetOf(file, from.specifier); - return target !== null && isData(target, from.local, visiting); + const isData = (file: string, name: string): boolean => { + const keyOf = (ref: Ref): string => `${ref.file}\0${ref.name}`; + // Each reached name, by key, with the key of the name it was reached from. + const reachedFrom = new Map([[keyOf({ file, name }), null]]); + const queue: Ref[] = [{ file, name }]; + for (let i = 0; i < queue.length; i++) { + const ref = queue[i]!; + const key = keyOf(ref); + const memo = dataMemo.get(key); + if (memo === true) continue; + const next = memo === false ? null : referencesOf(ref.file, ref.name); + if (next === null) { + // Every name on the path to this one reaches a non-data type. + for (let k: string | null = key; k !== null; k = reachedFrom.get(k) ?? null) + dataMemo.set(k, false); + return false; } - const reexport = typesOf(file, new Set()).types.get(name); - if (reexport !== undefined) return isData(reexport.file, reexport.decl.declared, visiting); - return true; - })(); - visiting.delete(key); - dataMemo.set(key, answer); - return answer; + for (const target of next) { + const targetKey = keyOf(target); + if (reachedFrom.has(targetKey)) continue; + reachedFrom.set(targetKey, key); + queue.push(target); + } + } + for (const key of reachedFrom.keys()) dataMemo.set(key, true); + return true; }; for (const pkg of packages) { const declared = resolveBareModule(entryPath, pkg, "types-only"); @@ -198,7 +223,7 @@ export function npmStaticTypeExportPlan( ({ decl, file }) => !values.has(decl.name) && !declaredByRuntime.has(decl.name) && - isData(file, decl.declared, new Set()), + isData(file, decl.declared), ) .map(({ decl }) => decl); if (exported.length === 0) continue; From 140b1f397fa6c293ed7d06ee9405a11e89ee0af0 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 00:35:17 -0500 Subject: [PATCH 017/102] Reject DiffieHellman secrets of 0, 1 and p - 1 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit computeSecret now fails with ERR_CRYPTO_OPERATION_FAILED ("Failed to compute shared secret") when the exponentiation yields 0, 1 or p - 1, as Node's OpenSSL derivation does: such a secret is predictable, from a peer key of small order or a composite modulus. 6708 covers a secret of 1 and of p - 1 (peer keys of order 3 and 6 modulo a 512-bit prime with p ≡ 1 mod 6) and of 0 (a peer key sharing the factor of a square modulus). --- packages/runtime/src/scr_dh.c | 7 +++++-- tests/corpus/6708-dh-errors.js | 28 ++++++++++++++++++++++++++++ 2 files changed, 33 insertions(+), 2 deletions(-) diff --git a/packages/runtime/src/scr_dh.c b/packages/runtime/src/scr_dh.c index c514b45ba..351d97a0f 100644 --- a/packages/runtime/src/scr_dh.c +++ b/packages/runtime/src/scr_dh.c @@ -1058,7 +1058,9 @@ static bool sd_derives(const ScDh *d) { } /* computeSecret(key, inputEncoding, outputEncoding): key^priv mod p, - * padded to the prime's length. */ + * padded to the prime's length. A secret of 0, 1 or p - 1 is predictable + * (a peer key of small order, or a composite modulus), so it fails like + * OpenSSL's derivation does. */ static ScrDyn *sd_compute_secret(ScDh *d, const ScrDyn *key, const ScrDyn *in_enc, const ScrDyn *out_enc) { ScrBytes *bytes = ca_key_bytes(SD_SUBJECT, key, in_enc); if (!bytes) return NULL; @@ -1073,7 +1075,8 @@ static ScrDyn *sd_compute_secret(ScDh *d, const ScrDyn *key, const ScrDyn *in_en sd_throw(SCR_ERR_RANGE, "ERR_CRYPTO_INVALID_KEYLEN", "Supplied key is too small"); } else if (mbedtls_mpi_cmp_mpi(&peer, &bound) >= 0) { sd_throw(SCR_ERR_RANGE, "ERR_CRYPTO_INVALID_KEYLEN", "Supplied key is too large"); - } else if (!d->has_priv || (!d->group && !sd_derives(d)) || !sd_exp(&secret, &peer, &d->priv, &d->p)) { + } else if (!d->has_priv || (!d->group && !sd_derives(d)) || !sd_exp(&secret, &peer, &d->priv, &d->p) || + mbedtls_mpi_cmp_int(&secret, 1) <= 0 || mbedtls_mpi_cmp_mpi(&secret, &bound) == 0) { sd_operation_failed("Failed to compute shared secret"); } else { size_t len = mbedtls_mpi_size(&d->p); diff --git a/tests/corpus/6708-dh-errors.js b/tests/corpus/6708-dh-errors.js index e092da727..0c711c96d 100644 --- a/tests/corpus/6708-dh-errors.js +++ b/tests/corpus/6708-dh-errors.js @@ -145,3 +145,31 @@ attempt("p 23 generator 30", () => loose(crypto.createDiffieHellman(Buffer.from([23]), 30).setPrivateKey(Buffer.from([2]))).generateKeys(), ); attempt("p 9", () => loose(crypto.createDiffieHellman(Buffer.from([9])).setPrivateKey(Buffer.from([3]))).generateKeys()); + +// Secrets of 0, 1 and p - 1 fail like any other derivation failure: a peer +// key of order 3 or 6 modulo a prime with p ≡ 1 (mod 6), and a peer key +// sharing the factor of a square modulus. +const smooth = Buffer.from( + "ce306415e770bb1cde0380e3c5cf4e8110b5c8e82ca36b1d9074fa1e9d1ed41b0ae295f19288302647d2da0003fcac6fa21d8953afce2c30171844815ec7d6df", + "hex", +); +const orderThree = Buffer.from( + "6be4b47bb9f8143334dab6349ac191ef7208ae3d5e684a2c318d43acc45ebd2a27d79b075c6e14a4e6a75899d98ce05af71ef05e1869b1add76d1622ab5e7b1d", + "hex", +); +const orderSix = Buffer.from( + "624baf9a2d78a6e9a928caaf2b0dbc919ead1aaace3b20f15ee7b671d8c016f0e30afaea361a1b81612b81662a6fcc14aafe98f597647a823fab2e5eb3695bc2", + "hex", +); +function withPrivateKey(modulus, key) { + const dh = crypto.createDiffieHellman(modulus); + dh.setPrivateKey(Buffer.from([key])); + return dh; +} +attempt("secret 1", () => withPrivateKey(smooth, 3).computeSecret(orderThree).toString("hex")); +attempt("secret p - 1", () => withPrivateKey(smooth, 3).computeSecret(orderSix).toString("hex")); +attempt("secret of order 3, key 4", () => withPrivateKey(smooth, 4).computeSecret(orderThree).toString("hex").slice(0, 16)); +const factor = BigInt("0xdf22630cec2362c510f444af6784da7a3a714ed787eb3d6bf9158d18c087cc5d"); +const square = Buffer.from((factor * factor).toString(16).padStart(128, "0"), "hex"); +const factorKey = Buffer.from(factor.toString(16).padStart(128, "0"), "hex"); +attempt("secret 0", () => withPrivateKey(square, 2).computeSecret(factorKey).toString("hex")); From 8bbccee4f61efe8912096dbbf953f6b8f2853596 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 00:37:37 -0500 Subject: [PATCH 018/102] Read and write shared typed-array elements inline --- .../compiler/src/backend/llvm/expr-bytes.ts | 120 +++++++++++++----- .../test/bytes-element-emission.test.ts | 16 ++- .../6864-shared-typed-array-elements.ts.json | 6 + .../6864-shared-typed-array-elements.ts | 120 ++++++++++++++++++ .../6864-shared-typed-array-elements.ts.json | 1 + 5 files changed, 228 insertions(+), 35 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6864-shared-typed-array-elements.ts.json create mode 100644 tests/corpus/6864-shared-typed-array-elements.ts create mode 100644 tests/harness/corpus-costs/6864-shared-typed-array-elements.ts.json diff --git a/packages/compiler/src/backend/llvm/expr-bytes.ts b/packages/compiler/src/backend/llvm/expr-bytes.ts index 485b7a6b3..d36001bf6 100644 --- a/packages/compiler/src/backend/llvm/expr-bytes.ts +++ b/packages/compiler/src/backend/llvm/expr-bytes.ts @@ -176,10 +176,10 @@ export function emitBytesLength( return { name: out, type: F64 }; } -/** Worker programs: a view of a SharedArrayBuffer (`shared` is fixed before - * script code can see the view) is read and written by the runtime under - * its shared-memory lock; every other buffer belongs to this thread and - * takes the ordinary inline path. The test follows the index check: a +/** Worker programs: an element of a view of a SharedArrayBuffer (`shared` is + * fixed before script code can see the view) is read and written with one + * relaxed atomic access of its width, as the runtime's shared accessors do; + * every other buffer belongs to this thread and takes the ordinary path. The test follows the index check: a * view's length never changes, so both paths use the one checked integer * index. Branches to the returned label for a thread-owned buffer and * continues in the shared block. */ @@ -276,8 +276,9 @@ function emitBytesLoad( * shared. An integer element joins as its 32-bit value and converts to a * number after the join, as the local load does, so compares and * ToInt32/ToUint32 of the result stay integer operations. The shared read - * is an ordinary call: another thread's write must stay visible to a loop - * that reads the same element again. */ + * is a monotonic atomic load, which LLVM neither hoists nor merges: another + * thread's write stays visible to a loop that reads the same element again. + * Float16 elements read through the runtime. */ function emitSharedOrLocalLoad( host: LlvmEmitterContext, elem: IrBytesElem, @@ -286,12 +287,18 @@ function emitSharedOrLocalLoad( ): LlValue { const B = host.B; const floating = elem === "f16" || elem === "f32" || elem === "f64"; - const fn = floating ? "scr_bytes_shared_get_f64" : "scr_bytes_shared_get_int"; - const ret = floating ? "double" : "i32"; - host.declare(`declare ${ret} @${fn}(ptr, ${host.sizeType})`); const local = emitSharedBytesSplit(host, receiver); - const shared = B.tmp(); - B.line(`${shared} = call ${ret} @${fn}(ptr ${receiver}, ${host.sizeType} ${idx}) cold`); + let shared: string; + if (elem === "f16") { + host.declare(`declare double @scr_bytes_shared_get_f64(ptr, ${host.sizeType})`); + shared = B.tmp(); + B.line( + `${shared} = call double @scr_bytes_shared_get_f64(ptr ${receiver}, ${host.sizeType} ${idx}) cold`, + ); + } else { + const loaded = emitSharedLoadAt(host, elem, host.emitBytesData(receiver), idx); + shared = loaded.uint32 ?? loaded.name; + } const sharedDone = B.newLabel("bytes.shared.done"); B.br(sharedDone); B.startBlock(local); @@ -316,6 +323,43 @@ function emitSharedOrLocalLoad( return { name: out, type: F64, uint32: u32 }; } +/** The element at a checked index of a shared view, given its data pointer: + * a relaxed atomic load of the element's width, aligned as shared views + * are. Not for Float16 elements. */ +function emitSharedLoadAt( + host: LlvmEmitterContext, + elem: IrBytesElem, + data: string, + idx: string, +): LlValue { + const B = host.B; + const size = BYTES_ELEMENT_SIZE[elem]; + const p = B.tmp(); + if (elem === "f32" || elem === "f64") { + const ty = elem === "f32" ? "float" : "double"; + const raw = B.tmp(); + B.line(`${p} = getelementptr inbounds ${ty}, ptr ${data}, ${host.sizeType} ${idx}`); + B.line(`${raw} = load atomic ${ty}, ptr ${p} monotonic, align ${size}`); + if (elem === "f64") return { name: raw, type: F64 }; + const out = B.tmp(); + B.line(`${out} = fpext float ${raw} to double`); + return { name: out, type: F64 }; + } + const bits = size * 8; + const raw = B.tmp(); + B.line(`${p} = getelementptr inbounds i${bits}, ptr ${data}, ${host.sizeType} ${idx}`); + B.line(`${raw} = load atomic i${bits}, ptr ${p} monotonic, align ${size}`); + const signed = elem === "i8" || elem === "i16" || elem === "i32"; + let wide = raw; + if (bits < 32) { + wide = B.tmp(); + B.line(`${wide} = ${signed ? "sext" : "zext"} i${bits} ${raw} to i32`); + } + const out = B.tmp(); + B.line(`${out} = ${signed ? "sitofp" : "uitofp"} i32 ${wide} to double`); + return { name: out, type: F64, uint32: wide }; +} + /** The element at a checked index of a thread-owned view, given its data * pointer. */ function emitBytesLoadAt( @@ -477,7 +521,7 @@ export function emitBytesSet( const done = B.newLabel("bytes.store.done"); const data = host.emitBytesData(receiver); const idx = emitBytesIndex(host, receiver, index, indexExpr, done, inBounds); - if (host.mod.workers) { + if (host.mod.workers && elem === "f16") { host.declare(`declare void @scr_bytes_shared_set(ptr, ${host.sizeType}, double)`); const local = emitSharedBytesSplit(host, receiver); B.line( @@ -498,32 +542,48 @@ export function emitBytesSet( elem === "f16" || elem === "f32" || elem === "f64" ? null : host.emitToUint32(value.name, expr, value.uint32); - const p = B.tmp(); if (elem === "f16") { // One round-to-nearest-even step from the double, in the runtime. host.declare(`declare zeroext i16 @scr_f16_from_f64(double)`); const narrowed = B.tmp(); + const p = B.tmp(); B.line(`${narrowed} = call zeroext i16 @scr_f16_from_f64(double ${value.name})`); B.line(`${p} = getelementptr inbounds i16, ptr ${data}, ${host.sizeType} ${idx}`); B.line(`store i16 ${narrowed}, ptr ${p}, align 1${bytesElementAlias(host)}`); - } else if (BYTES_ELEMENT_SIZE[elem] < 4) { - const bits = BYTES_ELEMENT_SIZE[elem] * 8; - const byte = B.tmp(); - B.line(`${byte} = trunc i32 ${stored!} to i${bits}`); - B.line(`${p} = getelementptr inbounds i${bits}, ptr ${data}, ${host.sizeType} ${idx}`); - B.line(`store i${bits} ${byte}, ptr ${p}, align 1${bytesElementAlias(host)}`); - } else if (elem === "f32") { - const narrowed = B.tmp(); - B.line(`${narrowed} = fptrunc double ${value.name} to float`); - B.line(`${p} = getelementptr inbounds float, ptr ${data}, ${host.sizeType} ${idx}`); - B.line(`store float ${narrowed}, ptr ${p}, align 1${bytesElementAlias(host)}`); - } else if (elem === "f64") { - B.line(`${p} = getelementptr inbounds double, ptr ${data}, ${host.sizeType} ${idx}`); - B.line(`store double ${value.name}, ptr ${p}, align 1${bytesElementAlias(host)}`); - } else { - B.line(`${p} = getelementptr inbounds i32, ptr ${data}, ${host.sizeType} ${idx}`); - B.line(`store i32 ${stored!}, ptr ${p}, align 1${bytesElementAlias(host)}`); + B.br(done); + B.startBlock(done); + return; } + // The element's bits as an LLVM value of the element's width. + let ty: string; + let operand: string; + if (BYTES_ELEMENT_SIZE[elem] < 4) { + ty = `i${BYTES_ELEMENT_SIZE[elem] * 8}`; + operand = B.tmp(); + B.line(`${operand} = trunc i32 ${stored!} to ${ty}`); + } else if (elem === "f32") { + ty = "float"; + operand = B.tmp(); + B.line(`${operand} = fptrunc double ${value.name} to float`); + } else if (elem === "f64") { + ty = "double"; + operand = value.name; + } else { + ty = "i32"; + operand = stored!; + } + if (host.mod.workers) { + // A shared view's element takes a relaxed atomic store of its width. + const local = emitSharedBytesSplit(host, receiver); + const p = B.tmp(); + B.line(`${p} = getelementptr inbounds ${ty}, ptr ${data}, ${host.sizeType} ${idx}`); + B.line(`store atomic ${ty} ${operand}, ptr ${p} monotonic, align ${BYTES_ELEMENT_SIZE[elem]}`); + B.br(done); + B.startBlock(local); + } + const p = B.tmp(); + B.line(`${p} = getelementptr inbounds ${ty}, ptr ${data}, ${host.sizeType} ${idx}`); + B.line(`store ${ty} ${operand}, ptr ${p}, align 1${bytesElementAlias(host)}`); B.br(done); B.startBlock(done); } diff --git a/packages/compiler/test/bytes-element-emission.test.ts b/packages/compiler/test/bytes-element-emission.test.ts index 9a241b854..505b51963 100644 --- a/packages/compiler/test/bytes-element-emission.test.ts +++ b/packages/compiler/test/bytes-element-emission.test.ts @@ -335,11 +335,17 @@ test("a body mutation keeps the byte loop on the general f64 path", () => { test("worker programs read and write shared views at the checked integer index", () => { const ll = emitLlvmModule({ ...fixture(), workers: true }); - // The shared path receives the index the inline path checked, as an integer, - // and integer elements come back as 32-bit values. - expect(ll).toMatch(/call i32 @scr_bytes_shared_get_int\(ptr %\w+, i64 %?\w+\) cold/); - expect(ll).toMatch(/call double @scr_bytes_shared_get_f64\(ptr %\w+, i64 %?\w+\) cold/); - expect(ll).toMatch(/call void @scr_bytes_shared_set\(ptr %\w+, i64 %?\w+, double %?[\w.]+\)/); + // The shared path uses the index the inline path checked, as an integer: + // each element is one relaxed atomic access of its width, aligned to it. + expect(ll).toMatch(/load atomic i8, ptr %\w+ monotonic, align 1/); + expect(ll).toMatch(/load atomic i32, ptr %\w+ monotonic, align 4/); + expect(ll).toMatch(/load atomic float, ptr %\w+ monotonic, align 4/); + expect(ll).toMatch(/store atomic i8 [%\w.]+, ptr %\w+ monotonic, align 1/); + expect(ll).toMatch(/store atomic i32 [%\w.]+, ptr %\w+ monotonic, align 4/); + expect(ll).toMatch(/store atomic float [%\w.]+, ptr %\w+ monotonic, align 4/); + expect(ll).not.toContain("@scr_bytes_shared_get_int"); + expect(ll).not.toContain("@scr_bytes_shared_get_f64"); + expect(ll).not.toContain("@scr_bytes_shared_set"); expect(ll).not.toContain("@scr_bytes_get_or_nan"); expect(ll).not.toContain("@scr_bytes_set("); // Both paths join as one integer, which converts to a number after the join. diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6864-shared-typed-array-elements.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6864-shared-typed-array-elements.ts.json new file mode 100644 index 000000000..2a7203ef0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6864-shared-typed-array-elements.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6864-shared-typed-array-elements.ts" + ], + "diags": [] +} diff --git a/tests/corpus/6864-shared-typed-array-elements.ts b/tests/corpus/6864-shared-typed-array-elements.ts new file mode 100644 index 000000000..ee3ecef32 --- /dev/null +++ b/tests/corpus/6864-shared-typed-array-elements.ts @@ -0,0 +1,120 @@ +// Element reads and writes of typed arrays over a SharedArrayBuffer, for every +// element kind, from the main thread and from a worker: each kind's +// conversion on write (wrapping, clamping, rounding to float32 and float16), +// NaN, -0 and the infinities, and values one thread writes and the other +// reads after a message. A worker loop that reads a flag without Atomics +// sees the main thread's write. +import { isMainThread, parentPort, Worker, workerData } from "node:worker_threads"; + +const KINDS = 10; + +const VALUES = [0, -0, 1, -1, 1.5, 2.5, -2.5, 127, 128, 255, 256, -129, 65535, 65536, 2 ** 31, -(2 ** 31) - 1, 2 ** 32 + 7, 0.1, 1e40, -1e-50, NaN, Infinity, -Infinity]; +const LENGTH = VALUES.length; + +interface Views { + i8: Int8Array; + u8: Uint8Array; + u8c: Uint8ClampedArray; + i16: Int16Array; + u16: Uint16Array; + i32: Int32Array; + u32: Uint32Array; + f16: Float16Array; + f32: Float32Array; + f64: Float64Array; +} + +/** One region of LENGTH elements per kind, each aligned to 8 bytes. */ +function viewsOf(sab: SharedArrayBuffer): Views { + const region = LENGTH * 8; + return { + i8: new Int8Array(sab, 0 * region, LENGTH), + u8: new Uint8Array(sab, 1 * region, LENGTH), + u8c: new Uint8ClampedArray(sab, 2 * region, LENGTH), + i16: new Int16Array(sab, 3 * region, LENGTH), + u16: new Uint16Array(sab, 4 * region, LENGTH), + i32: new Int32Array(sab, 5 * region, LENGTH), + u32: new Uint32Array(sab, 6 * region, LENGTH), + f16: new Float16Array(sab, 7 * region, LENGTH), + f32: new Float32Array(sab, 8 * region, LENGTH), + f64: new Float64Array(sab, 9 * region, LENGTH), + }; +} + +function show(x: number): string { + return Object.is(x, -0) ? "-0" : String(x); +} + +/** Writes VALUES (scaled by `scale`) through every view. */ +function writeAll(v: Views, scale: number): void { + for (let i = 0; i < LENGTH; i++) { + const x = VALUES[i]! * scale; + v.i8[i] = x; + v.u8[i] = x; + v.u8c[i] = x; + v.i16[i] = x; + v.u16[i] = x; + v.i32[i] = x; + v.u32[i] = x; + v.f16[i] = x; + v.f32[i] = x; + v.f64[i] = x; + } +} + +/** Every element of every view, read one at a time, and a sum per view. */ +function readAll(v: Views): string[] { + const lines: string[] = []; + const row = (kind: string, read: (i: number) => number): void => { + const cells: string[] = []; + for (let i = 0; i < LENGTH; i++) cells.push(show(read(i))); + lines.push(`${kind}: ${cells.join(" ")}`); + }; + row("Int8Array", (i) => v.i8[i]!); + row("Uint8Array", (i) => v.u8[i]!); + row("Uint8ClampedArray", (i) => v.u8c[i]!); + row("Int16Array", (i) => v.i16[i]!); + row("Uint16Array", (i) => v.u16[i]!); + row("Int32Array", (i) => v.i32[i]!); + row("Uint32Array", (i) => v.u32[i]!); + row("Float16Array", (i) => v.f16[i]!); + row("Float32Array", (i) => v.f32[i]!); + row("Float64Array", (i) => v.f64[i]!); + let total = 0; + for (let i = 0; i < LENGTH; i++) total += v.i32[i]! + v.u16[i]! + (v.u8c[i]! | 0); + lines.push(`integer total ${total}`); + return lines; +} + +if (isMainThread) { + const sab = new SharedArrayBuffer(KINDS * LENGTH * 8 + 16); + const views = viewsOf(sab); + const flag = new Int32Array(sab, KINDS * LENGTH * 8, 2); + writeAll(views, 1); + console.log("main wrote, main reads"); + for (const line of readAll(views)) console.log(line); + + const worker = new Worker(new URL(import.meta.url), { workerData: sab }); + worker.on("message", (lines: string[]) => { + if (lines.length === 1) { + console.log(lines[0]); + return; + } + console.log("main wrote, worker reads; worker wrote, main reads"); + for (const line of lines) console.log(line); + for (const line of readAll(views)) console.log(line); + flag[1] = 7; + flag[0] = 1; + }); +} else { + const sab = workerData as SharedArrayBuffer; + const views = viewsOf(sab); + const flag = new Int32Array(sab, KINDS * LENGTH * 8, 2); + const seen = readAll(views); + writeAll(views, -3); + parentPort!.postMessage(seen); + while (flag[0] === 0) { + // Spin until the main thread's write is visible. + } + parentPort!.postMessage([`worker saw the flag, then ${flag[1]}`]); +} diff --git a/tests/harness/corpus-costs/6864-shared-typed-array-elements.ts.json b/tests/harness/corpus-costs/6864-shared-typed-array-elements.ts.json new file mode 100644 index 000000000..5ec5d60dc --- /dev/null +++ b/tests/harness/corpus-costs/6864-shared-typed-array-elements.ts.json @@ -0,0 +1 @@ +{ "plain": 2290, "san": 5070 } From b59da7529e2a04baa94402c5a1ced0194623451c Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 00:44:22 -0500 Subject: [PATCH 019/102] Leave counters unbounded when a nested scan is not walked pass by pass highestCount walks a nested while loop from its bound only when the loop is a statement of the body or of its blocks and branches. A nested scan inside a labeled block or an expression reached the generic branch, which counted its increments once although the loop can repeat them. Such a loop now leaves the counter without a range. --- .../compiler/src/ir/integer-loop-facts.ts | 21 ++++++++++++++----- .../compiler/src/ir/integer-ranges.test.ts | 9 ++++++++ 2 files changed, 25 insertions(+), 5 deletions(-) diff --git a/packages/compiler/src/ir/integer-loop-facts.ts b/packages/compiler/src/ir/integer-loop-facts.ts index b075ef29a..31edc2f48 100644 --- a/packages/compiler/src/ir/integer-loop-facts.ts +++ b/packages/compiler/src/ir/integer-loop-facts.ts @@ -395,11 +395,15 @@ export function guardedLoopCounterFacts( /** The largest value counter `id` takes in one pass of `body`, which starts * at most at `entry`. The caller has checked that the body changes the - * counter only by positive literal increments outside nested loops, switch, - * exception and labeled regions, so those regions leave it unchanged, and - * every exit from a straight-line path leaves the body. An `if` whose - * condition does not write the counter caps it in the then branch by the - * condition's bounds; any other statement adds the increments it holds. */ + * counter only by positive literal increments outside switch, exception and + * labeled loop regions and loops other than nested while loops whose + * conditions bound it, and every exit from a straight-line path leaves the + * body. An `if` whose condition does not write the counter caps it in the + * then branch by the condition's bounds. A nested while loop that is a + * statement of the body, or of its blocks and branches, is walked from its + * bound; any other statement adds the increments it holds, and one that + * holds a loop writing the counter (in an expression or a labeled block) + * leaves it unbounded. */ function highestCount( body: readonly IrStmt[], id: string, @@ -416,6 +420,13 @@ function highestCount( }; const stmt = (x: IrStmt): boolean => { if (x.kind === "assign" && x.localId === id) total += increment(id, x.value) ?? 0; + // A loop reached here, inside an expression or a labeled region rather + // than through `walk`, can repeat its increments: no bound. + if ( + (x.kind === "while" || x.kind === "doWhile" || x.kind === "for" || x.kind === "forOf") && + writtenLocals([x]).has(id) + ) + total = Infinity; return everyStmtChild(x, expr, stmt); }; if (expression) expr(e as IrExpr); diff --git a/packages/compiler/src/ir/integer-ranges.test.ts b/packages/compiler/src/ir/integer-ranges.test.ts index b495eb814..fcb040275 100644 --- a/packages/compiler/src/ir/integer-ranges.test.ts +++ b/packages/compiler/src/ir/integer-ranges.test.ts @@ -863,6 +863,15 @@ test("a nested while loop may advance a counter its own condition bounds", () => ), ); expect(run(writing).after).toBeNull(); + // The same scan inside a labeled block or an expression is not walked + // pass by pass; its increments could repeat, so the counter stays unbounded. + expect(run({ loc, kind: "block", labels: ["scan"], body: [bounded] }).after).toBeNull(); + const inExpression: IrStmt = { + loc, + kind: "exprStmt", + expr: { loc, kind: "seqExpr", stmts: [bounded], result: num(0), type: F64 }, + }; + expect(run(inExpression).after).toBeNull(); }); test("an array length bounds while and for counters even when the body resizes the array", () => { From 728dc6cd51cdfdd45db3a8402481c82c49bda970 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 00:47:17 -0500 Subject: [PATCH 020/102] Count program-lifetime objects in memoryUsage and fix the runtime tests - process.memoryUsage(): heapTotal counts the region's chunks that threads hold, minus the chunks discarded workers returned, and heapUsed counts them less the tails threads left unused when they moved to a new chunk. - The region builds only where it can be used: Linux runtimes with the size-class allocator, which excludes the sanitizer runtimes (scriptc keeps 8-byte references there). The standalone allocator, cycle and young-nursery tests link again: the allocator test defines the scr_trap its region needs, and checks the region (below 32 GiB, aligned, zeroed, chunks larger than one, heap statistics, threads). - scr_plr_chunk has an initializer, like the other runtime globals. --- packages/runtime/src/scr_alloc.c | 42 +++++++++++++++-- packages/runtime/src/scr_alloc.test.c | 67 +++++++++++++++++++++++++++ packages/runtime/src/scr_rc.h | 2 +- 3 files changed, 106 insertions(+), 5 deletions(-) diff --git a/packages/runtime/src/scr_alloc.c b/packages/runtime/src/scr_alloc.c index 4b29b4b51..f2304aace 100644 --- a/packages/runtime/src/scr_alloc.c +++ b/packages/runtime/src/scr_alloc.c @@ -1930,6 +1930,10 @@ void scr_mem_order_for_free(void **ptrs, size_t n, size_t offset) { * mallinfo2, the Darwin malloc zones, the Windows CRT heap, or the * sanitizer's allocator in sanitized builds). Walks the free lists, so * the cost grows with the number of free blocks. */ +#if defined(__linux__) && SCR_SMALL_ALLOC +static void scr_plr_heap_stats(size_t *held, size_t *used); +#endif + void scr_heap_stats(double *total, double *used) { size_t held = 0, idle = 0; #if SCR_SMALL_ALLOC @@ -1979,6 +1983,13 @@ void scr_heap_stats(double *total, double *used) { sys_held = s.committed; sys_used = s.allocated; } +#endif +#if defined(__linux__) && SCR_SMALL_ALLOC + /* Compact class instances (the program-lifetime region below). */ + size_t region_held, region_used; + scr_plr_heap_stats(®ion_held, ®ion_used); + sys_held += region_held; + sys_used += region_used; #endif *total = (double)(held + sys_held); *used = (double)(held - (idle < held ? idle : held) + sys_used); @@ -1986,7 +1997,8 @@ void scr_heap_stats(double *total, double *used) { /* ── program-lifetime region ──────────────────────────────────────────── * Instances of compact classes (llvm/classes.ts LlClassMeta.compact) in - * programs built for Linux without sanitizers live in one address range + * programs built for Linux without sanitizers (runtimes with the size-class + * allocator, SCR_SMALL_ALLOC) live in one address range * reserved for the whole process below 32 GiB, so a field that holds one * can store its address over 8 in 32 bits (0 stays NULL). The instances * are never freed. Each thread carves them from its own chunks of @@ -1994,7 +2006,7 @@ void scr_heap_stats(double *total, double *used) { * Pages are committed by first touch and start zeroed. Its strings are * arrays rather than literals: programs without compact classes then link * none of this, where literals would stay in the unit's merged strings. */ -#if defined(__linux__) && SIZE_MAX > UINT32_MAX +#if defined(__linux__) && SCR_SMALL_ALLOC #include #define SCR_PLR_CHUNK ((size_t)1 << 20) @@ -2012,10 +2024,13 @@ void scr_heap_stats(double *total, double *used) { static char *scr_plr_base; /* the range's start, once reserved */ static size_t scr_plr_size; static size_t scr_plr_top; /* atomic */ +/* Bytes of the chunks threads hold, and of the tails they left unused when + * they moved to a new chunk (scr_heap_stats); atomic. */ +static size_t scr_plr_held, scr_plr_waste; #if defined(SCR_WORKERS) || (defined(SCR_LIB) && defined(SCR_THREAD_INSTANCES)) -_Thread_local ScrPlrChunk scr_plr_chunk; +_Thread_local ScrPlrChunk scr_plr_chunk = {NULL, NULL}; #else -ScrPlrChunk scr_plr_chunk; +ScrPlrChunk scr_plr_chunk = {NULL, NULL}; #endif /* Reserves `size` bytes at `at` exactly; NULL if refused. */ @@ -2072,6 +2087,7 @@ static __attribute__((noinline)) void scr_plr_reserve(void) { * chunk a thread takes registers scr_plr_thread_end. */ #define SCR_PLR_LINK 16 static _Thread_local char *scr_plr_mine; +static _Thread_local size_t scr_plr_mine_waste; /* this thread's part of scr_plr_waste */ static pthread_key_t scr_plr_end_key; static pthread_once_t scr_plr_end_once = PTHREAD_ONCE_INIT; static pthread_mutex_t scr_plr_free_lock = PTHREAD_MUTEX_INITIALIZER; @@ -2112,6 +2128,9 @@ static void scr_plr_thread_end(void *unused) { c = next; } static const char stats_line[] = "scr_sa: thread returned %zu MB of program-lifetime objects\n"; + __atomic_fetch_sub(&scr_plr_held, returned, __ATOMIC_RELAXED); + __atomic_fetch_sub(&scr_plr_waste, scr_plr_mine_waste, __ATOMIC_RELAXED); + scr_plr_mine_waste = 0; const char *stats = getenv("SCR_SA_STATS"); if (stats && stats[0] == '1') fprintf(stderr, stats_line, returned >> 20); } @@ -2162,6 +2181,14 @@ static __attribute__((noinline)) void *scr_plr_refill(size_t n) { #ifdef SCR_SA_TRIM scr_plr_own(p, chunk); #endif + if (scr_plr_chunk.next) { + size_t left = (size_t)(scr_plr_chunk.limit - scr_plr_chunk.next); + __atomic_fetch_add(&scr_plr_waste, left, __ATOMIC_RELAXED); +#ifdef SCR_SA_TRIM + scr_plr_mine_waste += left; +#endif + } + __atomic_fetch_add(&scr_plr_held, chunk, __ATOMIC_RELAXED); scr_plr_chunk.next = p + SCR_PLR_LINK + n; scr_plr_chunk.limit = p + chunk; return p + SCR_PLR_LINK; @@ -2173,6 +2200,13 @@ void scr_plr_init(void) { if (!__atomic_load_n(&scr_plr_base, __ATOMIC_ACQUIRE)) scr_plr_reserve(); } +static void scr_plr_heap_stats(size_t *held, size_t *used) { + size_t h = __atomic_load_n(&scr_plr_held, __ATOMIC_RELAXED); + size_t w = __atomic_load_n(&scr_plr_waste, __ATOMIC_RELAXED); + *held = h; + *used = w < h ? h - w : 0; +} + void *scr_plr_alloc(size_t n) { n = (n + 7) & ~(size_t)7; char *p = scr_plr_chunk.next; diff --git a/packages/runtime/src/scr_alloc.test.c b/packages/runtime/src/scr_alloc.test.c index 2d8024c6d..e20c0733b 100644 --- a/packages/runtime/src/scr_alloc.test.c +++ b/packages/runtime/src/scr_alloc.test.c @@ -10,6 +10,13 @@ static bool owned(const void *p) { return (uintptr_t)p - scr_sa.base < scr_sa.span; } #endif +/* The allocator unit needs only scr_trap from the rest of the runtime: the + * program-lifetime region stops the program through it. */ +_Noreturn void scr_trap(const char *msg) { + fputs(msg, stderr); + abort(); +} + static void fill(unsigned char *p, size_t n, unsigned char seed) { for (size_t i = 0; i < n; i++) p[i] = (unsigned char)(seed + i * 7); } @@ -962,6 +969,60 @@ static void check_discard(void) { } #endif +#if defined(__linux__) && SCR_SMALL_ALLOC +/* The program-lifetime region hands out zeroed, 8-byte aligned blocks below + * 32 GiB, in order from the calling thread's chunk; a block larger than a + * chunk gets chunks of its own. Heap statistics count the chunks. Builds + * with AddressSanitizer have no region (its shadow memory takes the range), + * and scriptc builds with sanitizers keep pointers instead. */ +static void check_program_lifetime_region(void) { + double total0, used0, total1, used1; + scr_heap_stats(&total0, &used0); + scr_plr_init(); + unsigned char *a = scr_plr_alloc(20), *b = scr_plr_alloc(40); + assert(((uintptr_t)a & 7) == 0 && b == a + 24); + assert((uintptr_t)a >= ((uintptr_t)4 << 30) && (uintptr_t)b + 40 <= ((uintptr_t)32 << 30)); + for (size_t i = 0; i < 40; i++) assert(b[i] == 0); + size_t n = (size_t)3 << 20; + unsigned char *big = scr_plr_alloc(n); + assert(((uintptr_t)big & 7) == 0 && (uintptr_t)big + n <= ((uintptr_t)32 << 30)); + for (size_t i = 0; i < n; i += 4096) assert(big[i] == 0); + fill(big, n, 3); + verify(big, n, 3); + scr_heap_stats(&total1, &used1); + assert(total1 - total0 >= (double)n && used1 - used0 >= (double)n && used1 <= total1); +} + +#ifdef SCR_WORKERS +/* Threads carve the region concurrently: every block is zeroed and keeps + * what its thread wrote. */ +#define REGION_THREADS 4u +#define REGION_BLOCKS 20000u +static unsigned char *region_blocks[REGION_THREADS][REGION_BLOCKS]; + +static void *region_alloc(void *arg) { + unsigned t = (unsigned)(uintptr_t)arg; + for (unsigned i = 0; i < REGION_BLOCKS; i++) { + unsigned char *p = scr_plr_alloc(24); + for (size_t k = 0; k < 24; k++) assert(p[k] == 0); + fill(p, 24, (unsigned char)(t * 31 + i)); + region_blocks[t][i] = p; + } + return NULL; +} + +static void check_program_lifetime_region_threads(void) { + pthread_t threads[REGION_THREADS]; + for (unsigned t = 0; t < REGION_THREADS; t++) + assert(pthread_create(&threads[t], NULL, region_alloc, (void *)(uintptr_t)t) == 0); + for (unsigned t = 0; t < REGION_THREADS; t++) assert(pthread_join(threads[t], NULL) == 0); + for (unsigned t = 0; t < REGION_THREADS; t++) + for (unsigned i = 0; i < REGION_BLOCKS; i++) + verify(region_blocks[t][i], 24, (unsigned char)(t * 31 + i)); +} +#endif +#endif + int main(void) { #if SCR_SMALL_ALLOC check_slice_growth(); /* first: its class must be untouched */ @@ -975,6 +1036,12 @@ int main(void) { #if SCR_SMALL_ALLOC && defined(__linux__) && defined(__GLIBC__) check_heap_huge_pages(); #endif +#if defined(__linux__) && SCR_SMALL_ALLOC + check_program_lifetime_region(); +#ifdef SCR_WORKERS + check_program_lifetime_region_threads(); +#endif +#endif #if defined(SCR_WORKERS) && SCR_SMALL_ALLOC /* A short discard delay, which stays at its start until check_discard_delay_grows. */ setenv("SCR_SA_DISCARD_DELAY_MS", "100", 1); diff --git a/packages/runtime/src/scr_rc.h b/packages/runtime/src/scr_rc.h index 93fdd7946..7a921b451 100644 --- a/packages/runtime/src/scr_rc.h +++ b/packages/runtime/src/scr_rc.h @@ -308,7 +308,7 @@ void scr_cyc_free(void *obj); /* frees the block, header included */ void *scr_mem_realloc(void *p, size_t n); void *scr_rt_calloc(size_t n); /* emitted-code entry points */ -#if defined(__linux__) && SIZE_MAX > UINT32_MAX +#if defined(__linux__) && SCR_SMALL_ALLOC /* The program-lifetime region (scr_alloc.c): compact class instances of * programs built for Linux without sanitizers (llvm/emitter.ts * lowRegionTarget), which are never freed, at 8-byte aligned addresses below From f1e6addc819ecde9d205be4af5fd5dc2c67d830e Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 00:51:27 -0500 Subject: [PATCH 021/102] Encode messages into one block sized to their contents An encoded message allocated a node array (four nodes of 184 bytes to start, trimmed when encoding ended), a property array per object, a copy of every key and string, and the encoder's visit, identity and stack arrays. A port that queues many messages kept all of it until delivery: a {id, name} object took 15 allocations and 1.9 KB, and most of postMessage's time went into page faults on that memory. - The encoder builds nodes, properties and visits in arrays that start on the stack (8 entries), keeps borrowed references to keys and strings, and copies the result into one allocation: the header, the nodes, the properties grouped by node, the typed records and the text. A node is 40 bytes; the per-kind fields share a union. ArrayBuffer contents stay in their own allocation. - Decoding uses stack arrays for messages of up to 8 nodes and allocates the storage table only when the message has ArrayBuffer contents. - Freeing a message frees the block, and walks the nodes only when the message holds ports, native handles or ArrayBuffer contents. - The publication check reads the root before collecting the graph, so a message whose root is not frozen allocates nothing for it. The same object message now takes 4 allocations and 302 bytes, and a number 3 allocations and 129 bytes. bench/channel-messages runs in 161 ms instead of 250 ms (Node: 340 ms), with a peak RSS of 45 MB instead of 115 MB, and bench/worker-messages in 273 ms instead of 348 ms. --- packages/runtime/src/scr_message.c | 512 ++++++++++++++++-------- packages/runtime/src/scr_message.test.c | 79 ++++ 2 files changed, 414 insertions(+), 177 deletions(-) diff --git a/packages/runtime/src/scr_message.c b/packages/runtime/src/scr_message.c index cd0e92740..5e1bce37f 100644 --- a/packages/runtime/src/scr_message.c +++ b/packages/runtime/src/scr_message.c @@ -21,7 +21,7 @@ typedef enum { /* A typed value published with @scriptc/threads (immortal), delivered as * a fresh typed-ref capsule over the same pointer. */ SCR_MESSAGE_TYPED_REF, - /* A transferred MessagePort: its channel end (+1), the side in number. */ + /* A transferred MessagePort: its channel end (+1) and side. */ SCR_MESSAGE_PORT, /* A native handle cloned through its unit's ScrDynHandleTransfer. */ SCR_MESSAGE_HANDLE, @@ -30,67 +30,109 @@ typedef enum { const ScrMessagePortOps *scr_message_port_ops = NULL; typedef struct { - char *key; + const char *key; size_t length; size_t value; bool hidden; /* an Error's non-enumerable or inherited property */ } ScrMessageProperty; +/* SCR_MESSAGE_TYPED_REF: the capsule's process-wide adapters and type key + * (vtables, adapters and type keys are shared by every thread). */ typedef struct { - ScrMessageKind kind; - double number; - unsigned char *data; - ScrSharedBytes *shared; - size_t length; - ScrMessageProperty *properties; - size_t count; - size_t capacity; - size_t storage; - size_t offset; - ScrBytesElem element; - bool data_view; - ScrDyn *published; /* SCR_MESSAGE_PUBLISHED: immortal root, owns nothing */ - ScrChannel *channel; /* SCR_MESSAGE_PORT */ - /* SCR_MESSAGE_HANDLE: the owning unit's hooks and its payload (+1). */ - const ScrDynHandleTransfer *transfer; - void *payload; - /* SCR_MESSAGE_TYPED_REF: the capsule's process-wide adapters and type key - * (vtables, adapters and type keys are shared by every thread). */ - struct { - void *ptr; - void *(*retain)(void *); - void (*release)(void *); - const char *type_key; - size_t type_key_len; - ScrDyn *(*materialize)(void *); - void (*commit)(void *, const ScrDyn *); - bool traced; - } typed; + void *ptr; + void *(*retain)(void *); + void (*release)(void *); + const char *type_key; + size_t type_key_len; + ScrDyn *(*materialize)(void *); + void (*commit)(void *, const ScrDyn *); + bool traced; +} ScrMessageTyped; + +typedef struct { + unsigned char kind; /* ScrMessageKind */ + unsigned char element; /* SCR_MESSAGE_BYTES: ScrBytesElem */ + bool data_view; /* SCR_MESSAGE_BYTES */ + uint32_t count; /* properties */ + const ScrMessageProperty *properties; + union { + double number; /* BOOL and NUMBER; ERROR: the error kind */ + /* STRING and BIGINT: the text, in the message block. STORAGE: the + * copied bytes (owned) or the shared backing (+1). */ + struct { + char *data; + ScrSharedBytes *shared; + size_t length; + } text; + /* BYTES and ARRAY_BUFFER: the STORAGE node; BYTES: the view. */ + struct { + size_t storage; + size_t offset; + size_t length; + } view; + size_t length; /* ARRAY */ + ScrDyn *published; /* PUBLISHED: immortal root, owns nothing */ + struct { + ScrChannel *channel; /* +1 */ + int side; + } port; + /* HANDLE: the owning unit's hooks and its payload (+1). */ + struct { + const ScrDynHandleTransfer *transfer; + void *payload; + } handle; + const ScrMessageTyped *typed; /* TYPED_REF, in the message block */ + size_t typed_index; /* TYPED_REF while encoding */ + } v; } ScrMessageNode; +/* A message is one allocation: this header, then the nodes, the + * properties, the typed records and the text (keys, strings and bigints), + * sized to the message. A queued message holds nothing else, apart from + * the bytes of STORAGE nodes. */ struct ScrMessage { ScrMessageNode *nodes; size_t count; - size_t capacity; + bool storage; /* has STORAGE nodes */ + bool releases; /* has STORAGE, PORT or HANDLE nodes, which own resources */ }; typedef struct { const ScrDyn *input; ScrDyn *view; ScrDyn *keys; + ScrStr *text; /* a STRING or BIGINT node's text, until the message is packed */ size_t cursor; bool uncaught; /* an Error encoded as an uncaught exception */ } ScrMessageVisit; +typedef struct { + ScrMessageProperty property; + size_t owner; +} ScrMessagePending; + typedef struct { const void *identity; unsigned domain; size_t node; } ScrMessageIdentity; +/* The encoder's arrays start inline, so a message of up to this many nodes + * and properties allocates only its block. */ +#define SCR_MESSAGE_INLINE 8 + typedef struct { - ScrMessage *message; + ScrMessageNode *nodes; ScrMessageVisit *visits; + size_t count; + size_t capacity; + ScrMessagePending *properties; /* in the order they were reached */ + size_t property_count; + size_t property_capacity; + ScrMessageTyped *typed; + size_t typed_count; + size_t typed_capacity; + size_t text; /* bytes of text in the message block */ ScrMessageIdentity *identities; size_t identity_count; size_t identity_capacity; @@ -99,8 +141,36 @@ typedef struct { size_t stack_capacity; const ScrDyn *transfer; /* the transfer list (a dyn array), or NULL */ bool uncaught; /* the next value is an uncaught exception or its cause */ + bool storage; + bool releases; + ScrMessageNode inline_nodes[SCR_MESSAGE_INLINE]; + ScrMessageVisit inline_visits[SCR_MESSAGE_INLINE]; + ScrMessagePending inline_properties[SCR_MESSAGE_INLINE]; + ScrMessageIdentity inline_identities[2 * SCR_MESSAGE_INLINE]; + size_t inline_stack[SCR_MESSAGE_INLINE]; } ScrMessageEncoder; +static void scr_message_encoder_init(ScrMessageEncoder *encoder, const ScrDyn *transfer, bool uncaught) { + encoder->nodes = encoder->inline_nodes; + encoder->visits = encoder->inline_visits; + encoder->count = 0; + encoder->capacity = SCR_MESSAGE_INLINE; + encoder->properties = encoder->inline_properties; + encoder->property_count = 0; + encoder->property_capacity = SCR_MESSAGE_INLINE; + encoder->typed = NULL; + encoder->typed_count = encoder->typed_capacity = 0; + encoder->text = 0; + encoder->identities = NULL; + encoder->identity_count = encoder->identity_capacity = 0; + encoder->stack = encoder->inline_stack; + encoder->depth = 0; + encoder->stack_capacity = SCR_MESSAGE_INLINE; + encoder->transfer = transfer; + encoder->uncaught = uncaught; + encoder->storage = encoder->releases = false; +} + static bool scr_message_listed(const ScrMessageEncoder *encoder, const ScrDyn *value) { if (!encoder->transfer) return false; for (size_t i = 0; i < encoder->transfer->v.arr.len; i++) { @@ -122,30 +192,42 @@ static size_t scr_message_grow(size_t capacity) { return capacity ? capacity * 2 : 4; } -static unsigned char *scr_message_copy(const void *data, size_t length) { +/* Moves an encoder array of count items to a new one of capacity items, + * freeing the old one unless it is the inline array. */ +static void *scr_message_regrow(void *items, size_t count, size_t capacity, size_t size, + const void *inline_items) { + void *grown = scr_message_alloc(capacity, size); + if (count) memcpy(grown, items, count * size); + if (items != inline_items) free(items); + return grown; +} + +static char *scr_message_copy(const void *data, size_t length) { if (length == SIZE_MAX) scr_trap("scriptc: message too large\n"); - unsigned char *copy = scr_message_alloc(length + 1, 1); + char *copy = scr_message_alloc(length + 1, 1); if (length) memcpy(copy, data, length); return copy; } +/* Reserves text (and its terminator) in the message block. */ +static void scr_message_text(ScrMessageEncoder *encoder, size_t length) { + if (length >= SIZE_MAX - encoder->text) scr_trap("scriptc: message too large\n"); + encoder->text += length + 1; +} + static size_t scr_message_node(ScrMessageEncoder *encoder) { - ScrMessage *message = encoder->message; - if (message->count == message->capacity) { - size_t capacity = scr_message_grow(message->capacity); - ScrMessageNode *nodes = scr_message_alloc(capacity, sizeof(*nodes)); - ScrMessageVisit *visits = scr_message_alloc(capacity, sizeof(*visits)); - if (message->count) { - memcpy(nodes, message->nodes, message->count * sizeof(*nodes)); - memcpy(visits, encoder->visits, message->count * sizeof(*visits)); - } - free(message->nodes); - free(encoder->visits); - message->nodes = nodes; - encoder->visits = visits; - message->capacity = capacity; + if (encoder->count == encoder->capacity) { + size_t capacity = scr_message_grow(encoder->capacity); + encoder->nodes = scr_message_regrow(encoder->nodes, encoder->count, capacity, + sizeof(*encoder->nodes), encoder->inline_nodes); + encoder->visits = scr_message_regrow(encoder->visits, encoder->count, capacity, + sizeof(*encoder->visits), encoder->inline_visits); + encoder->capacity = capacity; } - return message->count++; + size_t id = encoder->count++; + memset(&encoder->nodes[id], 0, sizeof(encoder->nodes[id])); + memset(&encoder->visits[id], 0, sizeof(encoder->visits[id])); + return id; } static size_t scr_message_hash(const void *identity, unsigned domain) { @@ -171,7 +253,11 @@ static size_t scr_message_find(const ScrMessageEncoder *encoder, const void *ide static void scr_message_identify(ScrMessageEncoder *encoder, const void *identity, unsigned domain, size_t node) { if (!identity) return; - if (encoder->identity_count >= encoder->identity_capacity / 2) { + if (!encoder->identity_capacity) { + encoder->identity_capacity = sizeof encoder->inline_identities / sizeof encoder->inline_identities[0]; + encoder->identities = encoder->inline_identities; + memset(encoder->identities, 0, sizeof encoder->inline_identities); + } else if (encoder->identity_count >= encoder->identity_capacity / 2) { size_t capacity = scr_message_grow(encoder->identity_capacity); ScrMessageIdentity *entries = scr_message_alloc(capacity, sizeof(*entries)); for (size_t i = 0; i < encoder->identity_capacity; i++) { @@ -181,7 +267,7 @@ static void scr_message_identify(ScrMessageEncoder *encoder, const void *identit while (entries[slot].identity) slot = (slot + 1) & (capacity - 1); entries[slot] = entry; } - free(encoder->identities); + if (encoder->identities != encoder->inline_identities) free(encoder->identities); encoder->identities = entries; encoder->identity_capacity = capacity; } @@ -194,10 +280,8 @@ static void scr_message_identify(ScrMessageEncoder *encoder, const void *identit static void scr_message_push(ScrMessageEncoder *encoder, size_t node) { if (encoder->depth == encoder->stack_capacity) { size_t capacity = scr_message_grow(encoder->stack_capacity); - size_t *stack = scr_message_alloc(capacity, sizeof(*stack)); - if (encoder->depth) memcpy(stack, encoder->stack, encoder->depth * sizeof(*stack)); - free(encoder->stack); - encoder->stack = stack; + encoder->stack = scr_message_regrow(encoder->stack, encoder->depth, capacity, + sizeof(*encoder->stack), encoder->inline_stack); encoder->stack_capacity = capacity; } encoder->stack[encoder->depth++] = node; @@ -209,13 +293,14 @@ static size_t scr_message_storage(ScrMessageEncoder *encoder, const ScrBytes *by if (found != SIZE_MAX) return found; size_t node = scr_message_node(encoder); scr_message_identify(encoder, owner, SCR_MESSAGE_STORAGE + 1, node); - ScrMessageNode *storage = &encoder->message->nodes[node]; + ScrMessageNode *storage = &encoder->nodes[node]; storage->kind = SCR_MESSAGE_STORAGE; size_t size = scr_bytes_elem_size(owner->elem); if (owner->len > SIZE_MAX / size) scr_trap("scriptc: message too large\n"); - storage->length = owner->len * size; - if (owner->shared) storage->shared = scr_shared_retain(owner->shared); - else storage->data = scr_message_copy(owner->data, storage->length); + storage->v.text.length = owner->len * size; + if (owner->shared) storage->v.text.shared = scr_shared_retain(owner->shared); + else storage->v.text.data = scr_message_copy(owner->data, storage->v.text.length); + encoder->storage = encoder->releases = true; return node; } @@ -285,39 +370,43 @@ static size_t scr_message_value(ScrMessageEncoder *encoder, const ScrDyn *input) SCR_RC_PUBLISHED(input->v.typed_ref.ptr)) { scr_sa_thread_shares(); encoder->visits[id].view = (ScrDyn *)input; - ScrMessageNode *node = &encoder->message->nodes[id]; + ScrMessageNode *node = &encoder->nodes[id]; + if (encoder->typed_count == encoder->typed_capacity) { + size_t capacity = scr_message_grow(encoder->typed_capacity); + encoder->typed = scr_message_regrow(encoder->typed, encoder->typed_count, capacity, + sizeof(*encoder->typed), NULL); + encoder->typed_capacity = capacity; + } node->kind = SCR_MESSAGE_TYPED_REF; - node->typed.ptr = input->v.typed_ref.ptr; - node->typed.retain = input->v.typed_ref.retain; - node->typed.release = input->v.typed_ref.release; - node->typed.type_key = input->v.typed_ref.type_key; - node->typed.type_key_len = input->v.typed_ref.type_key_len; - node->typed.materialize = input->v.typed_ref.materialize; - node->typed.commit = input->v.typed_ref.commit; - node->typed.traced = input->v.typed_ref.traced; + node->v.typed_index = encoder->typed_count; + encoder->typed[encoder->typed_count++] = (ScrMessageTyped){ + input->v.typed_ref.ptr, input->v.typed_ref.retain, input->v.typed_ref.release, + input->v.typed_ref.type_key, input->v.typed_ref.type_key_len, input->v.typed_ref.materialize, + input->v.typed_ref.commit, input->v.typed_ref.traced, + }; if (getenv("SCRIPTC_PUBLISH_TRACE")) - fprintf(stderr, "scriptc: published %.*s shared by reference\n", (int)node->typed.type_key_len, - node->typed.type_key); + fprintf(stderr, "scriptc: published %.*s shared by reference\n", (int)input->v.typed_ref.type_key_len, + input->v.typed_ref.type_key); return id; } if ((input->kind == SCR_DYN_OBJ || input->kind == SCR_DYN_ARR) && input->rc == SIZE_MAX) { scr_sa_thread_shares(); encoder->visits[id].view = (ScrDyn *)input; - ScrMessageNode *node = &encoder->message->nodes[id]; + ScrMessageNode *node = &encoder->nodes[id]; node->kind = SCR_MESSAGE_PUBLISHED; - node->published = (ScrDyn *)input; + node->v.published = (ScrDyn *)input; return id; } ScrDyn *value = input->kind == SCR_DYN_TYPED_REF ? scr_dyn_typed_ref_materialize(input) : (ScrDyn *)input; encoder->visits[id].view = value; if (!value || scr_exc_pending()) return SIZE_MAX; - ScrMessageNode *node = &encoder->message->nodes[id]; + ScrMessageNode *node = &encoder->nodes[id]; ScrError *error = scr_errdyn_err_of(input); if (!error && value != input) error = scr_errdyn_err_of(value); if (error && uncaught && error->vt != &scr_error_vts[SCR_ERR_DOMEX]) { node->kind = SCR_MESSAGE_ERROR; - node->number = scr_message_error_kind(error); + node->v.number = scr_message_error_kind(error); scr_error_release(error); encoder->visits[id].uncaught = true; encoder->visits[id].keys = scr_message_uncaught_keys(value); @@ -327,7 +416,7 @@ static size_t scr_message_value(ScrMessageEncoder *encoder, const ScrDyn *input) } if (error) { node->kind = SCR_MESSAGE_ERROR; - node->number = SCR_ERR_ERROR; + node->v.number = SCR_ERR_ERROR; static const char *const names[] = { "Error", "TypeError", "RangeError", "SyntaxError", "ReferenceError", "EvalError", "URIError", }; @@ -336,7 +425,7 @@ static size_t scr_message_value(ScrMessageEncoder *encoder, const ScrDyn *input) }; for (size_t i = 0; i < sizeof names / sizeof names[0]; i++) if (error->name->len == strlen(names[i]) && !memcmp(error->name->data, names[i], error->name->len)) - node->number = kinds[i]; + node->v.number = kinds[i]; ScrDyn *keys = scr_dyn_new_arr(); static const char *const fields[] = {"message", "stack", "cause"}; for (size_t i = 0; i < sizeof fields / sizeof fields[0]; i++) { @@ -353,26 +442,28 @@ static size_t scr_message_value(ScrMessageEncoder *encoder, const ScrDyn *input) switch (value->kind) { case SCR_DYN_UNDEF: node->kind = SCR_MESSAGE_UNDEFINED; break; case SCR_DYN_NULL: node->kind = SCR_MESSAGE_NULL; break; - case SCR_DYN_BOOL: node->kind = SCR_MESSAGE_BOOL; node->number = value->v.b; break; - case SCR_DYN_NUM: node->kind = SCR_MESSAGE_NUMBER; node->number = value->v.num; break; + case SCR_DYN_BOOL: node->kind = SCR_MESSAGE_BOOL; node->v.number = value->v.b; break; + case SCR_DYN_NUM: node->kind = SCR_MESSAGE_NUMBER; node->v.number = value->v.num; break; case SCR_DYN_STR: + /* The text is copied into the message block when it is packed. */ node->kind = SCR_MESSAGE_STRING; - node->length = value->v.str->len; - node->data = scr_message_copy(value->v.str->data, node->length); + encoder->visits[id].text = scr_str_retain(value->v.str); + node->v.text.length = value->v.str->len; + scr_message_text(encoder, node->v.text.length); break; case SCR_DYN_BIGINT: { ScrStr *text = scr_bigint_to_string(value->v.bigint, 10); if (!text) return SIZE_MAX; node->kind = SCR_MESSAGE_BIGINT; - node->length = text->len; - node->data = scr_message_copy(text->data, text->len); - scr_str_release(text); + encoder->visits[id].text = text; + node->v.text.length = text->len; + scr_message_text(encoder, node->v.text.length); break; } case SCR_DYN_ARR: case SCR_DYN_OBJ: node->kind = value->kind == SCR_DYN_ARR ? SCR_MESSAGE_ARRAY : SCR_MESSAGE_OBJECT; - node->length = value->kind == SCR_DYN_ARR ? value->v.arr.len : 0; + if (value->kind == SCR_DYN_ARR) node->v.length = value->v.arr.len; encoder->visits[id].keys = scr_dyn_own_keys(value); if (!encoder->visits[id].keys) return SIZE_MAX; scr_message_push(encoder, id); @@ -389,8 +480,9 @@ static size_t scr_message_value(ScrMessageEncoder *encoder, const ScrDyn *input) return SIZE_MAX; } node->kind = SCR_MESSAGE_PORT; - node->channel = channel; - node->number = side; + node->v.port.channel = channel; + node->v.port.side = side; + encoder->releases = true; break; } bool buffer = scr_buffer_storage_is(value); @@ -402,21 +494,22 @@ static size_t scr_message_value(ScrMessageEncoder *encoder, const ScrDyn *input) if (scr_exc_pending()) return SIZE_MAX; goto unsupported; } - node = &encoder->message->nodes[id]; + node = &encoder->nodes[id]; node->kind = SCR_MESSAGE_HANDLE; - node->transfer = transfer; - node->payload = payload; + node->v.handle.transfer = transfer; + node->v.handle.payload = payload; + encoder->releases = true; break; } const ScrBytes *bytes = buffer ? value->v.handle.ptr : value->v.bytes; size_t storage = scr_message_storage(encoder, bytes); /* Adding the storage node can reallocate the node array. */ - node = &encoder->message->nodes[id]; + node = &encoder->nodes[id]; node->kind = buffer ? SCR_MESSAGE_ARRAY_BUFFER : SCR_MESSAGE_BYTES; - node->storage = storage; - node->element = bytes->elem; - node->length = bytes->len; - node->offset = (size_t)(bytes->data - (bytes->backing ? bytes->backing : bytes)->data); + node->v.view.storage = storage; + node->element = (unsigned char)bytes->elem; + node->v.view.length = bytes->len; + node->v.view.offset = (size_t)(bytes->data - (bytes->backing ? bytes->backing : bytes)->data); node->data_view = bytes->is_data_view; break; } @@ -430,21 +523,20 @@ unsupported: static void scr_message_property(ScrMessageEncoder *encoder, size_t id, const ScrStr *key, size_t value, bool hidden) { - ScrMessageNode *node = &encoder->message->nodes[id]; - if (node->count == node->capacity) { - size_t capacity = scr_message_grow(node->capacity); - ScrMessageProperty *properties = scr_message_alloc(capacity, sizeof(*properties)); - if (node->count) memcpy(properties, node->properties, node->count * sizeof(*properties)); - free(node->properties); - node->properties = properties; - node->capacity = capacity; + if (encoder->property_count == encoder->property_capacity) { + size_t capacity = scr_message_grow(encoder->property_capacity); + encoder->properties = scr_message_regrow(encoder->properties, encoder->property_count, capacity, + sizeof(*encoder->properties), encoder->inline_properties); + encoder->property_capacity = capacity; } - node->properties[node->count++] = (ScrMessageProperty){ - (char *)scr_message_copy(key->data, key->len), key->len, value, hidden, - }; + ScrMessageNode *node = &encoder->nodes[id]; + if (node->count == UINT32_MAX) scr_trap("scriptc: message too large\n"); + node->count++; + scr_message_text(encoder, key->len); + /* The key stays alive in the owner's key list until the message is packed. */ + encoder->properties[encoder->property_count++] = (ScrMessagePending){{key->data, key->len, value, hidden}, id}; } - /* ── publication: zero-copy delivery of deeply frozen plain-data graphs ── * Structured clone of a graph that is immutable on BOTH sides is observably * a share, as long as the receiver freezes what it receives (Node's clone is @@ -558,7 +650,8 @@ static ScrMessage *scr_message_try_publish(const ScrDyn *value) { if (!scr_publish_enabled || (value->kind != SCR_DYN_OBJ && value->kind != SCR_DYN_ARR)) return NULL; ScrMessage *message = NULL; ScrPublish p = {0}; - if (value->rc == SIZE_MAX || scr_publish_collect(&p, (ScrDyn *)value)) { + /* Most messages are not frozen: check the root before collecting. */ + if (value->rc == SIZE_MAX || (scr_publish_container_ok(value) && scr_publish_collect(&p, (ScrDyn *)value))) { for (size_t i = 0; i < p.count; i++) { ScrDyn *d = p.nodes[i]; if ((uintptr_t)d & 1) { @@ -582,11 +675,11 @@ static ScrMessage *scr_message_try_publish(const ScrDyn *value) { } } scr_sa_thread_shares(); - message = scr_message_alloc(1, sizeof(*message)); - message->nodes = scr_message_alloc(1, sizeof(*message->nodes)); - message->count = message->capacity = 1; + message = scr_message_alloc(1, sizeof(*message) + sizeof(*message->nodes)); + message->nodes = (ScrMessageNode *)(message + 1); + message->count = 1; message->nodes[0].kind = SCR_MESSAGE_PUBLISHED; - message->nodes[0].published = (ScrDyn *)value; + message->nodes[0].v.published = (ScrDyn *)value; if (getenv("SCRIPTC_PUBLISH_TRACE")) fprintf(stderr, "scriptc: published %zu nodes zero-copy%s\n", p.count, value->rc == SIZE_MAX && !p.count ? " (already published)" : ""); @@ -599,13 +692,14 @@ static ScrMessage *scr_message_try_publish(const ScrDyn *value) { } static ScrMessage *scr_message_encode_with(const ScrDyn *value, const ScrDyn *transfer); -static ScrMessage *scr_message_encode_run(ScrMessageEncoder encoder, const ScrDyn *value); +static ScrMessage *scr_message_encode_run(ScrMessageEncoder *encoder, const ScrDyn *value); ScrMessage *scr_message_encode(const ScrDyn *value) { return scr_message_encode_with(value, NULL); } ScrMessage *scr_message_encode_uncaught(const ScrDyn *value) { - ScrMessage *message = scr_message_alloc(1, sizeof(*message)); - return scr_message_encode_run((ScrMessageEncoder){.message = message, .uncaught = true}, value); + ScrMessageEncoder encoder; + scr_message_encoder_init(&encoder, NULL, true); + return scr_message_encode_run(&encoder, value); } ScrMessage *scr_message_encode_transfer(const ScrDyn *value, const ScrDyn *transfer) { @@ -635,19 +729,87 @@ ScrMessage *scr_message_encode_transfer(const ScrDyn *value, const ScrDyn *trans static ScrMessage *scr_message_encode_with(const ScrDyn *value, const ScrDyn *transfer) { ScrMessage *published = transfer ? NULL : scr_message_try_publish(value); if (published) return published; - ScrMessage *message = scr_message_alloc(1, sizeof(*message)); - return scr_message_encode_run((ScrMessageEncoder){.message = message, .transfer = transfer}, value); + ScrMessageEncoder encoder; + scr_message_encoder_init(&encoder, transfer, false); + return scr_message_encode_run(&encoder, value); } -static ScrMessage *scr_message_encode_run(ScrMessageEncoder encoder, const ScrDyn *value) { - ScrMessage *message = encoder.message; - if (scr_message_value(&encoder, value) == SIZE_MAX) goto done; - while (encoder.depth && !scr_exc_pending()) { - size_t id = encoder.stack[encoder.depth - 1]; - ScrMessageVisit *visit = &encoder.visits[id]; - if (visit->cursor == visit->keys->v.arr.len) { encoder.depth--; continue; } +/* Releases what a node owns: a STORAGE node's bytes, a PORT node's + * channel end and a HANDLE node's payload. */ +static void scr_message_drop(ScrMessageNode *node) { + switch (node->kind) { + case SCR_MESSAGE_STORAGE: + free(node->v.text.data); + scr_shared_release(node->v.text.shared); + break; + case SCR_MESSAGE_PORT: scr_message_port_ops->release(node->v.port.channel); break; + case SCR_MESSAGE_HANDLE: node->v.handle.transfer->drop(node->v.handle.payload); break; + default: break; + } +} + +/* Copies the encoded nodes into one block: the header, the nodes, the + * properties grouped by node (in the order they were reached), the typed + * records and the text. */ +static ScrMessage *scr_message_pack(ScrMessageEncoder *encoder) { + size_t count = encoder->count; + size_t properties = encoder->property_count; + size_t typed = encoder->typed_count; + size_t size = sizeof(ScrMessage); + size_t sizes[] = { + count, sizeof(ScrMessageNode), properties, sizeof(ScrMessageProperty), typed, sizeof(ScrMessageTyped), + }; + for (size_t i = 0; i < sizeof sizes / sizeof sizes[0]; i += 2) { + if (sizes[i] > (SIZE_MAX - size) / sizes[i + 1]) scr_trap("scriptc: message too large\n"); + size += sizes[i] * sizes[i + 1]; + } + if (encoder->text > SIZE_MAX - size) scr_trap("scriptc: message too large\n"); + ScrMessage *message = malloc(size + encoder->text); + if (!message) scr_trap("scriptc: out of memory\n"); + ScrMessageNode *nodes = (ScrMessageNode *)(message + 1); + ScrMessageProperty *slots = (ScrMessageProperty *)(nodes + count); + ScrMessageTyped *records = (ScrMessageTyped *)(slots + properties); + char *text = (char *)(records + typed); + *message = (ScrMessage){nodes, count, encoder->storage, encoder->releases}; + memcpy(nodes, encoder->nodes, count * sizeof(*nodes)); + if (typed) memcpy(records, encoder->typed, typed * sizeof(*records)); + size_t first = 0; + for (size_t i = 0; i < count; i++) { + ScrMessageNode *node = &nodes[i]; + node->properties = slots + first; + first += node->count; + node->count = 0; + if (node->kind == SCR_MESSAGE_STRING || node->kind == SCR_MESSAGE_BIGINT) { + memcpy(text, encoder->visits[i].text->data, node->v.text.length); + text[node->v.text.length] = 0; + node->v.text.data = text; + text += node->v.text.length + 1; + } else if (node->kind == SCR_MESSAGE_TYPED_REF) { + node->v.typed = &records[node->v.typed_index]; + } + } + for (size_t i = 0; i < properties; i++) { + const ScrMessagePending *pending = &encoder->properties[i]; + ScrMessageNode *node = &nodes[pending->owner]; + ScrMessageProperty *slot = (ScrMessageProperty *)&node->properties[node->count++]; + *slot = pending->property; + memcpy(text, pending->property.key, pending->property.length); + text[pending->property.length] = 0; + slot->key = text; + text += pending->property.length + 1; + } + return message; +} + +static ScrMessage *scr_message_encode_run(ScrMessageEncoder *encoder, const ScrDyn *value) { + ScrMessage *message = NULL; + if (scr_message_value(encoder, value) == SIZE_MAX) goto done; + while (encoder->depth && !scr_exc_pending()) { + size_t id = encoder->stack[encoder->depth - 1]; + ScrMessageVisit *visit = &encoder->visits[id]; + if (visit->cursor == visit->keys->v.arr.len) { encoder->depth--; continue; } ScrDyn *key = visit->keys->v.arr.items[visit->cursor++]; - bool error = message->nodes[id].kind == SCR_MESSAGE_ERROR; + bool error = encoder->nodes[id].kind == SCR_MESSAGE_ERROR; if (key->kind != SCR_DYN_STR || (!error && !scr_dyn_property_is_enumerable(visit->view, key->v.str))) continue; ScrDyn *child = scr_dyn_bag_get(visit->view, key->v.str, visit->view); if (!child || scr_exc_pending()) { scr_dyn_release(child); break; } @@ -657,33 +819,30 @@ static ScrMessage *scr_message_encode_run(ScrMessageEncoder encoder, const ScrDy * and symbols, and serializes its cause the same way. */ if (child->kind == SCR_DYN_FUNC || child->kind == SCR_DYN_SYMBOL) { scr_dyn_release(child); continue; } hidden = !scr_dyn_has_own(visit->view, key->v.str) || !scr_dyn_property_is_enumerable(visit->view, key->v.str); - encoder.uncaught = key->v.str->len == 5 && !memcmp(key->v.str->data, "cause", 5); + encoder->uncaught = key->v.str->len == 5 && !memcmp(key->v.str->data, "cause", 5); } - size_t next = scr_message_value(&encoder, child); + size_t next = scr_message_value(encoder, child); scr_dyn_release(child); if (next == SIZE_MAX) break; - scr_message_property(&encoder, id, key->v.str, next, hidden); + scr_message_property(encoder, id, key->v.str, next, hidden); } done: - for (size_t i = 0; i < message->count; i++) { - ScrMessageVisit *visit = &encoder.visits[i]; + if (!scr_exc_pending()) message = scr_message_pack(encoder); + else + for (size_t i = 0; i < encoder->count; i++) scr_message_drop(&encoder->nodes[i]); + for (size_t i = 0; i < encoder->count; i++) { + ScrMessageVisit *visit = &encoder->visits[i]; scr_dyn_release(visit->keys); if (visit->view != visit->input) scr_dyn_release(visit->view); scr_dyn_release((ScrDyn *)visit->input); + scr_str_release(visit->text); } - free(encoder.visits); - free(encoder.identities); - free(encoder.stack); - if (scr_exc_pending()) { scr_message_free(message); return NULL; } - /* A queued message keeps its nodes until it is received: drop the - * growth slack. */ - if (message->count && message->count < message->capacity) { - ScrMessageNode *nodes = realloc(message->nodes, message->count * sizeof(*nodes)); - if (nodes) { - message->nodes = nodes; - message->capacity = message->count; - } - } + if (encoder->nodes != encoder->inline_nodes) free(encoder->nodes); + if (encoder->visits != encoder->inline_visits) free(encoder->visits); + if (encoder->properties != encoder->inline_properties) free(encoder->properties); + if (encoder->identities != encoder->inline_identities) free(encoder->identities); + if (encoder->stack != encoder->inline_stack) free(encoder->stack); + free(encoder->typed); return message; } @@ -732,26 +891,31 @@ static void scr_message_tag_document(const ScrMessage *message, ScrDyn **values) ScrDyn *scr_message_decode(const ScrMessage *message) { if (message->count == 1 && message->nodes[0].kind == SCR_MESSAGE_PUBLISHED) - return scr_dyn_retain(message->nodes[0].published); - ScrDyn **values = scr_message_alloc(message->count, sizeof(*values)); - ScrBytes **storage = scr_message_alloc(message->count, sizeof(*storage)); - for (size_t i = 0; i < message->count; i++) { + return scr_dyn_retain(message->nodes[0].v.published); + ScrDyn *inline_values[SCR_MESSAGE_INLINE]; + ScrDyn **values = message->count <= SCR_MESSAGE_INLINE + ? inline_values : scr_message_alloc(message->count, sizeof(*values)); + memset(values, 0, message->count * sizeof(*values)); + ScrBytes **storage = message->storage ? scr_message_alloc(message->count, sizeof(*storage)) : NULL; + for (size_t i = 0; storage && i < message->count; i++) { const ScrMessageNode *node = &message->nodes[i]; if (node->kind != SCR_MESSAGE_STORAGE) continue; - storage[i] = node->shared ? scr_shared_wrap(node->shared) : scr_bytes_new(SCR_BYTES_U8, (double)node->length); + storage[i] = node->v.text.shared ? scr_shared_wrap(node->v.text.shared) + : scr_bytes_new(SCR_BYTES_U8, (double)node->v.text.length); if (!storage[i]) goto done; - if (!node->shared && node->length) memcpy(storage[i]->data, node->data, node->length); + if (!node->v.text.shared && node->v.text.length) + memcpy(storage[i]->data, node->v.text.data, node->v.text.length); } for (size_t i = 0; i < message->count; i++) { const ScrMessageNode *node = &message->nodes[i]; switch (node->kind) { case SCR_MESSAGE_UNDEFINED: values[i] = scr_dyn_retain(scr_dyn_undefined()); break; case SCR_MESSAGE_NULL: values[i] = scr_dyn_new_null(); break; - case SCR_MESSAGE_BOOL: values[i] = scr_dyn_new_bool(node->number != 0); break; - case SCR_MESSAGE_NUMBER: values[i] = scr_dyn_new_num(node->number); break; + case SCR_MESSAGE_BOOL: values[i] = scr_dyn_new_bool(node->v.number != 0); break; + case SCR_MESSAGE_NUMBER: values[i] = scr_dyn_new_num(node->v.number); break; case SCR_MESSAGE_STRING: case SCR_MESSAGE_BIGINT: { - ScrStr *text = scr_str_new((const char *)node->data, node->length); + ScrStr *text = scr_str_new(node->v.text.data, node->v.text.length); if (node->kind == SCR_MESSAGE_STRING) values[i] = scr_dyn_new_str(text); else { ScrBigInt *integer = scr_bigint_parse(text); @@ -762,19 +926,19 @@ ScrDyn *scr_message_decode(const ScrMessage *message) { } case SCR_MESSAGE_ARRAY: values[i] = scr_dyn_new_arr(); - for (size_t j = 0; j < node->length; j++) scr_dyn_arr_push_hole(values[i]); + for (size_t j = 0; j < node->v.length; j++) scr_dyn_arr_push_hole(values[i]); break; case SCR_MESSAGE_OBJECT: values[i] = scr_dyn_new_obj(); break; case SCR_MESSAGE_ERROR: { scr_error_set_traced(); - ScrError *error = scr_error_new((int)node->number, NULL); + ScrError *error = scr_error_new((int)node->v.number, NULL); values[i] = scr_dyn_from_error(error); scr_error_release(error); break; } case SCR_MESSAGE_BYTES: { - ScrBytes *bytes = scr_bytes_buffer_view(storage[node->storage], node->element, - (double)node->offset, true, (double)node->length); + ScrBytes *bytes = scr_bytes_buffer_view(storage[node->v.view.storage], (ScrBytesElem)node->element, + (double)node->v.view.offset, true, (double)node->v.view.length); if (bytes) { bytes->is_data_view = node->data_view; values[i] = scr_dyn_new_bytes(bytes); @@ -783,19 +947,21 @@ ScrDyn *scr_message_decode(const ScrMessage *message) { break; } case SCR_MESSAGE_ARRAY_BUFFER: - values[i] = scr_array_buffer_from_bytes(storage[node->storage]); + values[i] = scr_array_buffer_from_bytes(storage[node->v.view.storage]); break; case SCR_MESSAGE_STORAGE: continue; - case SCR_MESSAGE_PUBLISHED: values[i] = scr_dyn_retain(node->published); break; - case SCR_MESSAGE_TYPED_REF: - values[i] = (node->typed.traced ? scr_dyn_new_typed_ref_traced : scr_dyn_new_typed_ref)( - node->typed.ptr, node->typed.retain, node->typed.release, node->typed.type_key, - node->typed.type_key_len, node->typed.materialize, node->typed.commit); + case SCR_MESSAGE_PUBLISHED: values[i] = scr_dyn_retain(node->v.published); break; + case SCR_MESSAGE_TYPED_REF: { + const ScrMessageTyped *typed = node->v.typed; + values[i] = (typed->traced ? scr_dyn_new_typed_ref_traced : scr_dyn_new_typed_ref)( + typed->ptr, typed->retain, typed->release, typed->type_key, typed->type_key_len, + typed->materialize, typed->commit); break; + } case SCR_MESSAGE_PORT: - values[i] = scr_message_port_ops->adopt(node->channel, (int)node->number); + values[i] = scr_message_port_ops->adopt(node->v.port.channel, node->v.port.side); break; - case SCR_MESSAGE_HANDLE: values[i] = node->transfer->adopt(node->payload); break; + case SCR_MESSAGE_HANDLE: values[i] = node->v.handle.transfer->adopt(node->v.handle.payload); break; } if (!values[i] || scr_exc_pending()) goto done; } @@ -805,7 +971,7 @@ ScrDyn *scr_message_decode(const ScrMessage *message) { const ScrMessageProperty *property = &node->properties[j]; ScrDyn *value = scr_dyn_retain(values[property->value]); if (node->kind == SCR_MESSAGE_ARRAY) { - size_t index = scr_message_array_index(property->key, property->length, node->length); + size_t index = scr_message_array_index(property->key, property->length, node->v.length); if (index != SIZE_MAX) { values[i]->v.arr.items[index] = value; values[i]->v.arr.presence[index] = 1; @@ -841,24 +1007,16 @@ done:; ScrDyn *result = !scr_exc_pending() ? scr_dyn_retain(values[0]) : NULL; for (size_t i = 0; i < message->count; i++) { scr_dyn_release(values[i]); - scr_bytes_release(storage[i]); + if (storage) scr_bytes_release(storage[i]); } - free(values); + if (values != inline_values) free(values); free(storage); return result; } void scr_message_free(ScrMessage *message) { if (!message) return; - for (size_t i = 0; i < message->count; i++) { - ScrMessageNode *node = &message->nodes[i]; - for (size_t j = 0; j < node->count; j++) free(node->properties[j].key); - free(node->properties); - free(node->data); - scr_shared_release(node->shared); - if (node->kind == SCR_MESSAGE_PORT) scr_message_port_ops->release(node->channel); - if (node->kind == SCR_MESSAGE_HANDLE) node->transfer->drop(node->payload); - } - free(message->nodes); + if (message->releases) + for (size_t i = 0; i < message->count; i++) scr_message_drop(&message->nodes[i]); free(message); } diff --git a/packages/runtime/src/scr_message.test.c b/packages/runtime/src/scr_message.test.c index a6c940783..bdabc4d12 100644 --- a/packages/runtime/src/scr_message.test.c +++ b/packages/runtime/src/scr_message.test.c @@ -172,6 +172,84 @@ static void check_documents(void) { scr_message_free(message); } +/* A message larger than the encoder's inline arrays (nodes, properties, + * identities and the visit stack) keeps its key order, shared values and + * text, and an encode started from a getter during another encode + * produces its own message. */ +static SCR_TL ScrMessage *nested_message; +static ScrDyn *nested_getter(ScrClosure *closure, ScrDyn *const *args, size_t argc) { + (void)closure; (void)args; (void)argc; + ScrDyn *inner = scr_dyn_new_arr(); + scr_dyn_arr_push(inner, scr_dyn_new_num(41)); + nested_message = scr_message_encode(inner); + scr_dyn_release(inner); + return scr_dyn_new_num(42); +} + +static void check_large(void) { + ScrDyn *root = scr_dyn_new_obj(); + ScrDyn *shared = scr_dyn_new_obj(); + put_number(shared, "shared", 1); + ScrDyn *chain = root; + char key[32]; + for (int i = 0; i < 40; i++) { + ScrDyn *item = scr_dyn_new_obj(); + put_number(item, "index", i); + snprintf(key, sizeof key, "label-%d", i); + ScrStr *text = scr_str_new(key, strlen(key)); + scr_dyn_obj_set(item, "label", 5, scr_dyn_new_str(text)); + scr_str_release(text); + scr_dyn_obj_set(item, "shared", 6, scr_dyn_retain(shared)); + snprintf(key, sizeof key, "item%d", i); + scr_dyn_obj_set(root, key, strlen(key), item); + /* A chain 40 objects deep grows the visit stack. */ + ScrDyn *next = scr_dyn_new_obj(); + scr_dyn_obj_set(chain, "next", 4, next); + chain = next; + } + scr_dyn_release(shared); + ScrClosure *closure = scr_closure_new(NULL, 0); + ScrDyn *descriptor = scr_dyn_new_obj(); + scr_dyn_obj_set(descriptor, "get", 3, scr_dyn_new_func(closure, nested_getter, 0, "", "")); + scr_dyn_obj_set(descriptor, "enumerable", 10, scr_dyn_new_bool(true)); + ScrStr *name = scr_str_new("nested", 6); + ScrDyn *name_value = scr_dyn_new_str(name); + scr_dyn_release(scr_dyn_define_property(root, name_value, descriptor)); + scr_dyn_release(name_value); + scr_dyn_release(descriptor); + scr_str_release(name); + ScrMessage *message = scr_message_encode(root); + assert(message && !scr_exc_pending() && nested_message); + scr_dyn_release(root); + scr_collect_cycles(); + ScrDyn *decoded = scr_message_decode(message); + assert(decoded && !scr_exc_pending()); + assert(decoded->v.obj.len == 42); + assert(decoded->v.obj.entries[0].key_len == 5 && !memcmp(decoded->v.obj.entries[0].key, "item0", 5)); + assert(decoded->v.obj.entries[41].key_len == 6 && !memcmp(decoded->v.obj.entries[41].key, "nested", 6)); + assert(scr_dyn_obj_get(decoded, "nested", 6)->v.num == 42); + ScrDyn *first = scr_dyn_obj_get(decoded, "item0", 5); + for (int i = 0; i < 40; i++) { + snprintf(key, sizeof key, "item%d", i); + ScrDyn *item = scr_dyn_obj_get(decoded, key, strlen(key)); + assert(item && scr_dyn_obj_get(item, "index", 5)->v.num == i); + assert(scr_dyn_obj_get(item, "shared", 6) == scr_dyn_obj_get(first, "shared", 6)); + snprintf(key, sizeof key, "label-%d", i); + ScrStr *label = scr_dyn_obj_get(item, "label", 5)->v.str; + assert(label->len == strlen(key) && !memcmp(label->data, key, label->len)); + } + ScrDyn *link = decoded; + for (int i = 0; i < 40; i++) link = scr_dyn_obj_get(link, "next", 4); + assert(link && link->kind == SCR_DYN_OBJ && link->v.obj.len == 0); + scr_dyn_release(decoded); + ScrDyn *inner = scr_message_decode(nested_message); + assert(inner && inner->v.arr.len == 1 && inner->v.arr.items[0]->v.num == 41); + scr_dyn_release(inner); + scr_collect_cycles(); + scr_message_free(nested_message); + scr_message_free(message); +} + /* A link-gated unit's handle crosses threads through the transfer hooks in * its ops: share on the sender, adopt on the receiver, drop with the * message. The test borrows the last capacity slot, which no unit uses, so @@ -297,6 +375,7 @@ int main(void) { check_getters(); check_rejection(); check_documents(); + check_large(); check_handle_transfer(); scr_context_cleanup(); puts("message graphs preserve identity, sparse values, byte aliases and getter order"); From 1a51223cd6f4b4899761a7ec8da3378e0f048c68 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 01:01:01 -0500 Subject: [PATCH 022/102] Say where the region's trap and memoryUsage accounting come from Comments only: scr_trap is the runtime's failure path and the standalone allocator test defines its own, and the region's chunks count in process.memoryUsage() through scr_heap_stats. --- packages/runtime/src/scr_alloc.c | 4 ++++ packages/runtime/src/scr_lib.h | 3 ++- 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/packages/runtime/src/scr_alloc.c b/packages/runtime/src/scr_alloc.c index f2304aace..3a36f672e 100644 --- a/packages/runtime/src/scr_alloc.c +++ b/packages/runtime/src/scr_alloc.c @@ -2072,6 +2072,8 @@ static __attribute__((noinline)) void scr_plr_reserve(void) { } } __atomic_clear(&lock, __ATOMIC_RELEASE); + /* scr_trap is the runtime's failure path (scr_exception.c); the + * allocator's standalone test defines its own (scr_alloc.test.c). */ if (!scr_plr_base) { static const char message[] = "scriptc: cannot reserve address space below 32 GiB for program-lifetime objects\n"; @@ -2188,6 +2190,8 @@ static __attribute__((noinline)) void *scr_plr_refill(size_t n) { scr_plr_mine_waste += left; #endif } + /* process.memoryUsage() counts the chunk in heapTotal and heapUsed + * (scr_heap_stats, scr_plr_heap_stats). */ __atomic_fetch_add(&scr_plr_held, chunk, __ATOMIC_RELAXED); scr_plr_chunk.next = p + SCR_PLR_LINK + n; scr_plr_chunk.limit = p + chunk; diff --git a/packages/runtime/src/scr_lib.h b/packages/runtime/src/scr_lib.h index 1b859cea1..411d1e684 100644 --- a/packages/runtime/src/scr_lib.h +++ b/packages/runtime/src/scr_lib.h @@ -238,7 +238,8 @@ double scr_process_memory_usage_field(double k); double scr_process_rss(void); /* The runtime heap's footprint (scr_alloc.c): bytes held from the system * and bytes in live allocations, for the calling thread's allocator plus - * the system allocator where it reports them. */ + * the system allocator where it reports them, plus the program-lifetime + * region's chunks (compact class instances). */ void scr_heap_stats(double *total, double *used); /* process.ppid: the parent's pid at the time of the read. */ double scr_process_ppid(void); From 93e13f49a0d0e44896769ec157bd24b153b73492 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 01:06:31 -0500 Subject: [PATCH 023/102] Keep structural names apart by declaration kind and name recursive types by position Structural positions named an enclosing declaration by its name and its ordinal among the declarations of the same kind and name, without the kind. A getter and the setter of the same property, or a class and the namespace merged with it, therefore had the same path, and local classes declared in both shared one class. The path now includes the kind, and interfaces and type aliases anchor the positions inside them. Recursive record and union placeholders were named by their printed type and the byte offset of their declaration. A comment or blank line above the type renamed them, and two instantiations that print alike (type arguments that are type parameters or classes of one name from different declarations) threw an InternalCompilerError. Placeholders are now named by the printed type and the structural position of the declaration, and the same for up to three levels of type arguments. A description that two types still share gets a numbered suffix for the later one. --- .../src/frontend/lowering/lowerer.test.ts | 16 +-- .../compiler/src/frontend/lowering/lowerer.ts | 1 + .../frontend/lowering/structural-positions.ts | 16 ++- .../compiler/src/frontend/type-mapper.test.ts | 2 +- packages/compiler/src/frontend/type-mapper.ts | 78 +++++++++--- packages/compiler/test/stable-names.test.ts | 112 ++++++++++++++++++ 6 files changed, 192 insertions(+), 33 deletions(-) create mode 100644 packages/compiler/test/stable-names.test.ts diff --git a/packages/compiler/src/frontend/lowering/lowerer.test.ts b/packages/compiler/src/frontend/lowering/lowerer.test.ts index 750c27694..7fbb9661f 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.test.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.test.ts @@ -33,7 +33,7 @@ test("reuses complete copy routes without repeating discriminator planning", () expect(plan).not.toHaveBeenCalled(); expect(lowerer.liftedFns.filter((fn) => fn.name === helper)).toHaveLength(1); const recursive = {} as Type; - lowerer.shapes.recursiveRef(recursive, "Recursive"); + lowerer.shapes.recursiveRef(recursive, () => "Recursive"); lowerer.shapes.finalizeRecursive(recursive, [{ name: "kind", type: STRING }]); expect(lowerer.unionRetagHelper(from, to, loc)).toBe(helper); expect(plan).toHaveBeenCalled(); @@ -55,7 +55,7 @@ test("replans after a recursive union gains its final arms", () => { const lowerer = context(); const recursive = {} as Type; const from = lowerer.unions.intern([UNDEFINED_T, NULL_T]); - const to = lowerer.unions.recursiveRef(recursive, "Recursive"); + const to = lowerer.unions.recursiveRef(recursive, () => "Recursive"); const trapped = lowerer.unionRetagHelper(from, to, loc); expect(trapped).not.toBeNull(); lowerer.unions.finalizeRecursive(recursive, [UNDEFINED_T]); @@ -76,7 +76,7 @@ test("rechecks width conversions after recursive record definitions settle", () const lowerer = context(); const recursive = {} as Type; const source = record(lowerer.shapes.intern([{ name: "value", type: F64 }])); - const target = record(lowerer.shapes.recursiveRef(recursive, "Recursive")); + const target = record(lowerer.shapes.recursiveRef(recursive, () => "Recursive")); const from = lowerer.unions.intern([source, UNDEFINED_T]); const to = lowerer.unions.intern([target, NULL_T]); expect(lowerer.unionRetagHelper(from, to, loc)).not.toBeNull(); @@ -130,7 +130,7 @@ test("literal ownership is reused across values and rechecked when recursive rec expect(inspect).not.toHaveBeenCalled(); const recursive = {} as Type; - const pendingShape = record(lowerer.shapes.recursiveRef(recursive, "Recursive")); + const pendingShape = record(lowerer.shapes.recursiveRef(recursive, () => "Recursive")); const pending = lowerer.unions.intern([pendingShape], { field: "kind", cases: [{ tag: 0, values: ["a"] }], @@ -144,7 +144,7 @@ test("literal ownership is reused across values and rechecked when recursive rec test("literal ownership sees a recursive union's finalized discriminator", () => { const lowerer = context(); const recursive = {} as Type; - const union = lowerer.unions.recursiveRef(recursive, "Recursive"); + const union = lowerer.unions.recursiveRef(recursive, () => "Recursive"); const shape = record(lowerer.shapes.intern([{ name: "kind", type: STRING }])); expect(lowerer.literalUnionArm(union, ["ready"])).toBeNull(); lowerer.unions.finalizeRecursive(recursive, [shape], { @@ -185,7 +185,7 @@ test("removing undefined reuses the discriminator transformation without hiding const recursive = {} as Type; const pending: IrType = { kind: "union", - unionId: lowerer.unions.recursiveRef(recursive, "Recursive"), + unionId: lowerer.unions.recursiveRef(recursive, () => "Recursive"), }; expect(lowerer.stripUndefinedArm(pending)).toEqual(pending); lowerer.unions.finalizeRecursive(recursive, [STRING, UNDEFINED_T]); @@ -221,7 +221,7 @@ test("adding undefined reuses semantic union transformations and sees recursive const recursive = {} as Type; const pending: IrType = { kind: "union", - unionId: lowerer.unions.recursiveRef(recursive, "Recursive"), + unionId: lowerer.unions.recursiveRef(recursive, () => "Recursive"), }; const before = lowerer.withUndefinedArmOf(pending); lowerer.unions.finalizeRecursive(recursive, [a, b], discriminant); @@ -236,7 +236,7 @@ test("optional union widening keeps refused and missing contracts current", () = const recursive = {} as Type; const pending: IrType = { kind: "union", - unionId: lowerer.unions.recursiveRef(recursive, "Recursive"), + unionId: lowerer.unions.recursiveRef(recursive, () => "Recursive"), }; expect(lowerer.withUndefinedArmOf(pending)).not.toBeNull(); lowerer.unions.finalizeRecursive(recursive, [{ kind: "date" }, STRING]); diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts index 687a2fb1a..3f8a0a66e 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -3568,6 +3568,7 @@ export class Lowerer { this.checker = program.getTypeChecker(); this.typeCtx = { checker: this.checker, + positionOf: (node) => this.positions.of(node), shapes: this.shapes, unions: this.unions, classNamer: this.classNamer, diff --git a/packages/compiler/src/frontend/lowering/structural-positions.ts b/packages/compiler/src/frontend/lowering/structural-positions.ts index cdc290b4b..ea8535d9e 100644 --- a/packages/compiler/src/frontend/lowering/structural-positions.ts +++ b/packages/compiler/src/frontend/lowering/structural-positions.ts @@ -15,6 +15,8 @@ const ANCHOR_KINDS: ReadonlySet = new Set([ ts.SyntaxKind.ModuleDeclaration, ts.SyntaxKind.EnumDeclaration, ts.SyntaxKind.Constructor, + ts.SyntaxKind.InterfaceDeclaration, + ts.SyntaxKind.TypeAliasDeclaration, ]); /** The name of `node` when it is a named declaration that anchors the @@ -34,10 +36,10 @@ function anchorOf(node: ts.Node): ts.Node { /** Source positions that stay the same when code outside the enclosing * declaration changes. A node's structural position is its file, the chain - * of enclosing named declarations (each with its ordinal among the - * declarations of the same kind and name in its own anchor), and its - * ordinal among the nodes of its kind whose nearest anchor is the same - * declaration. Editing another declaration, or code nested in another + * of enclosing named declarations (each with its kind, its name and its + * ordinal among the declarations of the same kind and name in its own + * anchor), and its ordinal among the nodes of its kind whose nearest anchor + * is the same declaration. Editing another declaration, or code nested in another * named declaration of the same anchor, leaves the position unchanged. */ export class StructuralPositions { /** Per anchor and key: the indices of the nodes with that key whose @@ -75,8 +77,10 @@ export class StructuralPositions { if (ts.isSourceFile(anchor)) path = anchor.fileName; else { const parent = anchorOf(anchor); - const name = anchorName(anchor); - path = `${this.pathOf(parent)}/${name}#${this.ordinalIn(parent, anchor, `${anchor.kind}:${name}`)}`; + // The kind keeps declarations of one name apart: a getter and its + // setter, or a class and the namespace merged with it. + const key = `${anchor.kind}:${anchorName(anchor)}`; + path = `${this.pathOf(parent)}/${key}#${this.ordinalIn(parent, anchor, key)}`; } this.paths.set(anchor, path); return path; diff --git a/packages/compiler/src/frontend/type-mapper.test.ts b/packages/compiler/src/frontend/type-mapper.test.ts index a99eb44cc..163ba7b9e 100644 --- a/packages/compiler/src/frontend/type-mapper.test.ts +++ b/packages/compiler/src/frontend/type-mapper.test.ts @@ -41,7 +41,7 @@ describe("union arm lookup", () => { test("sees finalized recursive arms after a missing lookup", () => { const unions = new UnionRegistry(); const recursive = {} as Type; - const union = unions.recursiveRef(recursive, "Recursive"); + const union = unions.recursiveRef(recursive, () => "Recursive"); expect(unions.armTag(union, STRING)).toBe(-1); unions.finalizeRecursive(recursive, [ F64, diff --git a/packages/compiler/src/frontend/type-mapper.ts b/packages/compiler/src/frontend/type-mapper.ts index ce73e8bc2..79091cadc 100644 --- a/packages/compiler/src/frontend/type-mapper.ts +++ b/packages/compiler/src/frontend/type-mapper.ts @@ -1,5 +1,5 @@ import { InternalCompilerError } from "../errors.js"; -import { keyedHelperName } from "./lowering/stable-names.js"; +import { keyedHelperName, type KeyedNameOwner } from "./lowering/stable-names.js"; import { mockCallRecordType, mockContextType } from "./mock-shapes.js"; import * as ts from "./ts7/adapter.js"; import { bodyReadsArguments } from "./arguments-usage.js"; @@ -393,13 +393,12 @@ export class ShapeRegistry { /** The shape id a back-reference to an in-progress type resolves to: * reuses the type's persistent recursive id or mints a PLACEHOLDER - * entry (empty fields) the outer frame finalizes. */ - recursiveRef(t: ts.Type, description: string): string { + * entry (empty fields) the outer frame finalizes. `describe` names a new + * placeholder (recursiveTypeName). */ + recursiveRef(t: ts.Type, describe: () => string): string { let id = this.recIds.get(t); if (id === undefined) { - id = keyedHelperName(this, "r", `recursive:${description}`, ""); - if (this.byId.has(id)) - throw new InternalCompilerError(`two recursive types share the description ${description}`); + id = recursivePlaceholderName(this, "r", describe(), (name) => this.byId.has(name)); const shape: IrRecordShape = { id, fields: [] }; this.byId.set(id, shape); this.shapes.push(shape); @@ -546,15 +545,55 @@ export class ShapeRegistry { } } -/** A recursive checker type's printed form and first declaration, which - * name its placeholder whichever frame first reaches it. */ -function recursiveTypeName(t: ts.Type, ctx: Pick): string { +/** The id of a recursive placeholder described by `description`. Two + * different types can still share a description (recursiveTypeName stops + * after a few levels of type arguments); the later one takes the first free + * name with a numbered suffix. */ +function recursivePlaceholderName( + owner: KeyedNameOwner, + prefix: string, + description: string, + taken: (name: string) => boolean, +): string { + let name = keyedHelperName(owner, prefix, `recursive:${description}`, ""); + for (let n = 1; taken(name); n++) + name = keyedHelperName(owner, prefix, `recursive:${description}#${n}`, ""); + return name; +} + +/** How many levels of type arguments recursiveTypeName describes. */ +const RECURSIVE_NAME_DEPTH = 3; + +/** A recursive checker type's description, which names its placeholder + * whichever frame first reaches it: its printed form, the structural + * position of its first declaration, and the same for its type arguments + * (two instantiations print the same when their type arguments are type + * parameters or classes of the same name from different declarations). */ +function recursiveTypeName( + t: ts.Type, + ctx: Pick, + depth = 0, +): string { const symbol = t.getAliasSymbol() ?? t.getSymbol(); const declaration = symbol?.declarations[0]; const where = declaration - ? `${ts.getSourceFileOfNode(declaration).fileName}:${declaration.pos}` + ? (ctx.positionOf?.(declaration) ?? + `${ts.getSourceFileOfNode(declaration).fileName}:${declaration.pos}`) : ""; - return `${ctx.checker.typeToString(t)}@${where}`; + let description = `${ctx.checker.typeToString(t)}@${where}`; + if (depth < RECURSIVE_NAME_DEPTH) { + const aliasArguments = + t.getAliasSymbol() !== undefined ? (t.getAliasTypeArguments() ?? []) : []; + const typeArguments = + aliasArguments.length > 0 + ? aliasArguments + : t.isTypeReference() + ? ctx.checker.getTypeArguments(t) + : []; + if (typeArguments.length > 0) + description += `<${typeArguments.map((arg) => recursiveTypeName(arg, ctx, depth + 1)).join(",")}>`; + } + return description; } /** The frontend's union interner — mirrors ShapeRegistry. A union's @@ -585,13 +624,12 @@ export class UnionRegistry { /** The union id a back-reference to an in-progress union resolves to: * reuses the type's persistent recursive id or mints a PLACEHOLDER - * entry (empty arms) the outer frame finalizes. */ - recursiveRef(t: ts.Type, description: string): string { + * entry (empty arms) the outer frame finalizes. `describe` names a new + * placeholder (recursiveTypeName). */ + recursiveRef(t: ts.Type, describe: () => string): string { let id = this.recIds.get(t); if (id === undefined) { - id = keyedHelperName(this, "u", `recursive:${description}`, ""); - if (this.byId.has(id)) - throw new InternalCompilerError(`two recursive types share the description ${description}`); + id = recursivePlaceholderName(this, "u", describe(), (name) => this.byId.has(name)); const def: IrUnionDef = { id, arms: [] }; this.byId.set(id, def); this.unions.push(def); @@ -1135,6 +1173,10 @@ export interface TypeMapperCtx { * empty object type rule in the object mapping). */ emptyLiteralArm?: boolean; checker: ts.TypeChecker; + /** The structural position of a declaration (structural-positions.ts), + * which names recursive placeholders independently of where unrelated + * code sits. The Lowerer supplies it. */ + positionOf?: (node: ts.Node) => string; /** JavaScript declarations whose instance or object-literal types only * the checked-dynamic representation holds (js-dynamic-objects.ts). * Absent when the program has none: every mapping is unchanged. */ @@ -4673,7 +4715,7 @@ function mapTypeInner(type: ts.Type, ctx: TypeMapperCtx): IrType | null { if (unions.inProgress.has(widened)) { return { kind: "union", - unionId: unions.recursiveRef(widened, recursiveTypeName(widened, ctx)), + unionId: unions.recursiveRef(widened, () => recursiveTypeName(widened, ctx)), }; } unions.inProgress.add(widened); @@ -7020,7 +7062,7 @@ function mapRecordType(widened: ts.Type, ctx: TypeMapperCtx): IrType | null { if (shapes.inProgress.has(widened)) { return { kind: "record", - shapeId: shapes.recursiveRef(widened, recursiveTypeName(widened, ctx)), + shapeId: shapes.recursiveRef(widened, () => recursiveTypeName(widened, ctx)), }; } shapes.inProgress.add(widened); diff --git a/packages/compiler/test/stable-names.test.ts b/packages/compiler/test/stable-names.test.ts new file mode 100644 index 000000000..720472556 --- /dev/null +++ b/packages/compiler/test/stable-names.test.ts @@ -0,0 +1,112 @@ +import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { expect, test } from "vitest"; +import { compile, deserializeModule, type IrModule } from "../src/index.js"; + +/** Lowers each source in turn as the same file, so names that include the + * file's path compare equal. */ +async function lower(...sources: string[]): Promise { + const dir = await mkdtemp(join(tmpdir(), "scriptc-stable-names-")); + try { + const entry = join(dir, "main.ts"); + const outPath = join(dir, "main.ir.json"); + const modules: IrModule[] = []; + for (const source of sources) { + await writeFile(entry, source); + const result = await compile(entry, { outDir: dir, outPath, outputKind: "ir" }); + if (!result.ok) + throw new Error(result.diagnostics.map((d) => `${d.code}: ${d.message}`).join("\n")); + modules.push(deserializeModule(await readFile(outPath, "utf8"))); + } + return modules; + } finally { + await rm(dir, { recursive: true, force: true }); + } +} + +function names(mod: IrModule): string[] { + return [ + ...mod.records.map((record) => record.id), + ...mod.unions.map((union) => union.id), + ...mod.functions.map((fn) => fn.name), + ...mod.classes.map((cls) => cls.name), + ].sort(); +} + +const recursive = ` +type Tree = { value: number; children: Tree[]; parent: Tree | null }; +function total(tree: Tree): number { + let sum = tree.value; + for (const child of tree.children) sum += total(child); + return sum; +} +const root: Tree = { value: 1, children: [], parent: null }; +root.children.push({ value: 2, children: [], parent: root }); +console.log(total(root)); +`; + +test("recursive record and union ids do not depend on the code above the type", async () => { + const [before, after] = await lower( + recursive, + `// A comment above the type.\n\ntype Unrelated = { name: string };\n\n${recursive}`, + ); + expect(before.records.some((record) => record.fields.some((f) => f.name === "children"))).toBe( + true, + ); + expect(names(after)).toEqual(names(before)); +}); + +test("recursive instantiations that print alike get distinct placeholders", async () => { + const [mod] = await lower(` +namespace A { + export class Item { + a = 1; + } +} +namespace B { + export class Item { + b = "b"; + } +} +type Chain = { item: T; next: Chain | null }; +const first: Chain = { item: new A.Item(), next: null }; +const second: Chain = { item: new B.Item(), next: null }; +first.next = { item: new A.Item(), next: null }; +second.next = { item: new B.Item(), next: null }; +console.log(first.next.item.a, second.next.item.b); +`); + const chains = mod.records.filter((record) => record.fields.some((f) => f.name === "next")); + expect(new Set(chains.map((record) => record.id)).size).toBe(chains.length); + expect(chains.length).toBeGreaterThanOrEqual(2); +}); + +test("a getter and a setter of one name keep their local classes apart", async () => { + const [mod] = await lower(` +class Box { + private v = 0; + get value(): number { + class Local { + n(): number { + return 1; + } + } + return new Local().n() + this.v; + } + set value(x: number) { + class Local { + n(): number { + return 2; + } + } + this.v = x * new Local().n(); + } +} +const box = new Box(); +box.value = 5; +console.log(box.value); +`); + const locals = mod.classes.filter((cls) => cls.name.includes("Local")); + expect(locals).toHaveLength(2); + expect(locals[0]!.name).not.toBe(locals[1]!.name); +}); From d68b73e3b4636308cb16fdecc21b4c5d03aa3e03 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 01:10:25 -0500 Subject: [PATCH 024/102] Extend a generic factory's local class returned through a constructor type A generic factory declared to return a constructor type (`Struct = (abstract new () => S) & { decode }`) whose every return gives back one of its own local classes (`return Base as Struct`) is now that local class's factory: each instance has its own class, the result maps to the class value while the instance lowers and at its calls, and `class X extends struct(...)` extends it like a factory returning the class directly. Before, the result type mapped to nothing (SC2008) and the extends clause refused as a computed expression. Static methods of a function-local class in a TypeScript file now lower as the class value's runtime statics, as they already do in JavaScript files: they read the enclosing function's bindings, call each other through `this`, and inherit into a subclass. Before, they refused with SC1090. Static fields and static blocks of such classes keep the fence. Fixes #1372 Co-authored-by: blurname <50226652+blurname@users.noreply.github.com> --- .../local-class-expressions.mdx | 3 +- .../frontend/lowering/generic-functions.ts | 123 ++++++++++++++++-- .../src/frontend/lowering/lower-classes.ts | 10 +- .../compiler/src/frontend/lowering/lowerer.ts | 10 ++ packages/compiler/src/frontend/type-mapper.ts | 11 ++ .../6912-extend-factory-local-class.ts.json | 6 + .../corpus/6912-extend-factory-local-class.ts | 67 ++++++++++ .../6912-extend-factory-local-class.ts.json | 1 + 8 files changed, 218 insertions(+), 13 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6912-extend-factory-local-class.ts.json create mode 100644 tests/corpus/6912-extend-factory-local-class.ts create mode 100644 tests/harness/corpus-costs/6912-extend-factory-local-class.ts.json diff --git a/docs/content/limitations/types-and-class-definitions/local-class-expressions.mdx b/docs/content/limitations/types-and-class-definitions/local-class-expressions.mdx index 8b653b25e..173bdc0c6 100644 --- a/docs/content/limitations/types-and-class-definitions/local-class-expressions.mdx +++ b/docs/content/limitations/types-and-class-definitions/local-class-expressions.mdx @@ -1,4 +1,5 @@ -- **Local class expressions:** Static members, decorators, private brands, generic members, and references through the class's internal name are unsupported. +- **Local class expressions:** Static fields and static blocks in TypeScript files, decorators, private brands, generic members, and references through the class's internal name are unsupported. + Static methods read the enclosing function's bindings and are inherited by subclasses. Supported expressions preserve fresh constructor identity and shared captures across constructors, methods, accessors, and arrow fields. Local inheritance requires a compiled base class. Constructors retain identity, `typeof`, `name`, and `length` through `unknown`; cast back to their exact type before construction. diff --git a/packages/compiler/src/frontend/lowering/generic-functions.ts b/packages/compiler/src/frontend/lowering/generic-functions.ts index abcd5a584..0f549d889 100644 --- a/packages/compiler/src/frontend/lowering/generic-functions.ts +++ b/packages/compiler/src/frontend/lowering/generic-functions.ts @@ -129,6 +129,10 @@ export interface GenericInstance { tsBindings?: Map; /** Rendered type arguments ("") for diagnostics. */ typeArgsText: string; + /** A factory returning one of its local classes through a declared + * constructor type: that type (by id) and the class value it maps to + * while the body lowers (Lowerer.instanceResultClass). */ + resultClass?: { declared: number; value: IrType }; /** Implicit instances only: param symbol → the call site's (widened) * checker type, consulted by the Lowerer's typeOf while this instance's * body lowers (the implicit twin of `bindings`). */ @@ -468,7 +472,8 @@ function localClassResultInstance( params: ParamShape[], retTs: ts.Type, ): GenericInstance | null { - if (!localClassOfResult(lowerer, info, retTs)) return null; + const resultClass = localClassOfResult(lowerer, info, retTs); + if (!resultClass) return null; const tsBindings = new Map(); const bindings = lowerer.inferTypeParamBindings(expr, info, rsig, tsBindings); const bindingKey = info.typeParams @@ -483,12 +488,29 @@ function localClassResultInstance( tsBindings, }); if (inst.returnType !== pending) return inst; - const returnType = withInstanceScope(lowerer, info, inst, () => lowerer.mapTypeOf(retTs)); + // A result typed by a declared constructor type rather than the class + // (`Struct`) is the class value of the local class the body returns. + const declaredResult = info.decl.type + ? lowerer.checker.getTypeFromTypeNode(info.decl.type) + : undefined; + const viaConstructorType = retTs.getSymbol()?.valueDeclaration !== resultClass; + const returnType = withInstanceScope(lowerer, info, inst, () => { + if (!viaConstructorType) return lowerer.mapTypeOf(retTs); + const classSymbol = resultClass.name + ? lowerer.checker.getSymbolAtLocation(resultClass.name) + : undefined; + return classSymbol ? lowerer.mapTypeOf(lowerer.checker.getTypeOfSymbol(classSymbol)) : null; + }); if (!returnType) { fenceGenericSignatureResult(lowerer, expr, retTs); lowerer.badType(expr, retTs); } inst.returnType = returnType; + if (viaConstructorType && returnType.kind === "classval") { + if (declaredResult) inst.resultClass = { declared: declaredResult.id, value: returnType }; + if (lowerer.typeParamBindings === null) lowerer.localClassValueTypes.set(retTs.id, returnType); + return inst; + } // Values of the class outside the factory (`const b = new B()`, `b.read()`) // carry the instantiated checker type; record which class it names. A // call inside another generic instance can have a type that depends on @@ -563,12 +585,94 @@ function localClassOfResult( type: ts.Type, ): ts.ClassLikeDeclaration | null { const symbol = type.getSymbol(); - if (!symbol || !(symbol.flags & ts.SymbolFlags.Class)) return null; - const decl = symbol.valueDeclaration; - if (!decl || !(ts.isClassExpression(decl) || ts.isClassDeclaration(decl))) return null; - for (let parent = decl.parent; parent && !ts.isSourceFile(parent); parent = parent.parent) - if (parent === info.decl) return decl; - return null; + const decl = symbol && symbol.flags & ts.SymbolFlags.Class ? symbol.valueDeclaration : undefined; + if (decl && (ts.isClassExpression(decl) || ts.isClassDeclaration(decl))) + return declaredInside(decl, info.decl) ? decl : null; + // A result typed by a constructor type (`Struct`, `new () => S`) whose + // every return gives back the one local class, through parentheses and + // assertions (`return Base as Struct`). + // A mixin (a class extending one of the function's parameters) keeps the + // mixin instantiation, which keys on the argument class. + if (lowerer.checker.getConstructSignatures(type).length === 0) return null; + const returned = returnedLocalClass(lowerer, info); + return returned && !extendsParameter(lowerer, returned, info) ? returned : null; +} + +function extendsParameter( + lowerer: Lowerer, + decl: ts.ClassLikeDeclaration, + info: GenericFnInfo, +): boolean { + const params = new Set(); + const fn = info.decl as { parameters?: { nodes: readonly ts.ParameterDeclaration[] } }; + for (const param of fn.parameters?.nodes ?? []) { + const symbol = ts.isIdentifier(param.name) + ? lowerer.checker.getSymbolAtLocation(param.name) + : undefined; + if (symbol !== undefined) params.add(symbol); + } + for (const clause of decl.heritageClauses?.nodes ?? []) + for (const base of clause.types.nodes) { + const symbol = ts.isIdentifier(base.expression) + ? lowerer.checker.getSymbolAtLocation(base.expression) + : undefined; + if (symbol !== undefined && params.has(symbol)) return true; + } + return false; +} + +function declaredInside(node: ts.Node, owner: ts.Node): boolean { + for (let parent = node.parent; parent && !ts.isSourceFile(parent); parent = parent.parent) + if (parent === owner) return true; + return false; +} + +/** The local class every return of `info`'s body gives back, or null when a + * return gives anything else (or nothing). Nested functions and classes keep + * their own returns. */ +function returnedLocalClass(lowerer: Lowerer, info: GenericFnInfo): ts.ClassLikeDeclaration | null { + const fn = info.decl as ts.Node & { body?: ts.Node }; + const body = fn.body; + if (!body) return null; + const classOf = (node: ts.Expression): ts.ClassLikeDeclaration | null => { + let expr = node; + while ( + ts.isParenthesizedExpression(expr) || + ts.isAsExpression(expr) || + ts.isSatisfiesExpression(expr) || + ts.isNonNullExpression(expr) + ) + expr = expr.expression; + if (ts.isClassExpression(expr)) return declaredInside(expr, info.decl) ? expr : null; + if (!ts.isIdentifier(expr)) return null; + const declaration = lowerer.checker.getSymbolAtLocation(expr)?.valueDeclaration; + return declaration && + ts.isClassDeclaration(declaration) && + declaredInside(declaration, info.decl) + ? declaration + : null; + }; + if (!ts.isBlock(body)) return classOf(body as ts.Expression); + let found: ts.ClassLikeDeclaration | null = null; + let valid = true; + const visit = (node: ts.Node): void => { + if ( + !valid || + ts.isFunctionLike(node) || + ts.isClassDeclaration(node) || + ts.isClassExpression(node) + ) + return; + if (ts.isReturnStatement(node)) { + const returned = node.expression ? classOf(node.expression) : null; + if (!returned || (found !== null && found !== returned)) valid = false; + else found = returned; + return; + } + ts.forEachChild(node, visit); + }; + ts.forEachChild(body, visit); + return valid ? found : null; } /** Runs `fn` under an instance's type bindings and local-class names, as @@ -583,14 +687,17 @@ function withInstanceScope( const prevTsBindings = lowerer.typeParamTsBindings; const previousPath = lowerer.genericInstantiationPath; const prevContext = lowerer.instantiationContext; + const prevResultClass = lowerer.instanceResultClass; lowerer.typeParamBindings = inst.bindings; lowerer.typeParamTsBindings = inst.tsBindings ?? null; lowerer.genericInstantiationPath = inst.path; lowerer.instantiationContext = `instantiating '${info.baseName}' with ${inst.typeArgsText}`; + lowerer.instanceResultClass = inst.resultClass ?? null; lowerer.localClassInstantiations.push({ owner: info.decl, name: inst.name }); try { return fn(); } finally { + lowerer.instanceResultClass = prevResultClass; lowerer.localClassInstantiations.pop(); lowerer.typeParamBindings = prevBindings; lowerer.typeParamTsBindings = prevTsBindings; diff --git a/packages/compiler/src/frontend/lowering/lower-classes.ts b/packages/compiler/src/frontend/lowering/lower-classes.ts index 790efe988..505b4d709 100644 --- a/packages/compiler/src/frontend/lowering/lower-classes.ts +++ b/packages/compiler/src/frontend/lowering/lower-classes.ts @@ -2404,7 +2404,8 @@ export function collectClassShapeInner( for (const member of decl.members.nodes) { if ( (functionLocalClass(decl) || checkedStatics) && - isJsSourceFile(ts.getSourceFileOfNode(decl)) && + (isJsSourceFile(ts.getSourceFileOfNode(decl)) || + (functionLocalClass(decl) && ts.isMethodDeclaration(member))) && (ts.isClassStaticBlockDeclaration(member) || ts .getModifiers(member) @@ -5872,9 +5873,10 @@ export function lowerClassExpressionInfo( decoratorNodesOf(member).length || (!isJsSourceFile(ts.getSourceFileOfNode(expr)) && (ts.isClassStaticBlockDeclaration(member) || - ts - .getModifiers(member) - ?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword))) || + (!ts.isMethodDeclaration(member) && + ts + .getModifiers(member) + ?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword)))) || (ts.isMethodDeclaration(member) && member.typeParameters?.nodes.length), )) ) { diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts index ee8ba7ecb..c1074f0a5 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -2171,6 +2171,12 @@ export class Lowerer { /** Instance types (by checker type id) of the local classes generic * factory calls return, and the per-instance class each names. */ readonly localClassInstanceTypes = new Map(); + /** A generic factory's instantiated result type → the class value of the + * local class it returns (TypeMapperCtx.localClassValue). */ + readonly localClassValueTypes = new Map(); + /** While a generic factory instance lowers: its declared result type → the + * class value of the local class it returns. */ + instanceResultClass: { declared: number; value: IrType } | null = null; /** The ts-level twin of typeParamBindings, non-null while a CALL-keyed * instance body lowers: type-parameter symbol → the bound CHECKER type, * consulted where the mapped IrType has already widened away information @@ -3529,6 +3535,10 @@ export class Lowerer { genericClassInstance: (decl, ref, mapArgument) => this.genericClassInstanceType(decl, ref, mapArgument), runtimeClassValue: (type) => runtimeClassValueOfType(this, type), + localClassValue: (type) => + this.instanceResultClass?.declared === type.id + ? this.instanceResultClass.value + : (this.localClassValueTypes.get(type.id) ?? null), mixinClassInstance: (decl) => this.mixinTypeContext && this.mixinTypeContext.classNode === decl ? { kind: "object", className: this.mixinTypeContext.className } diff --git a/packages/compiler/src/frontend/type-mapper.ts b/packages/compiler/src/frontend/type-mapper.ts index a233f0186..25b8c45a9 100644 --- a/packages/compiler/src/frontend/type-mapper.ts +++ b/packages/compiler/src/frontend/type-mapper.ts @@ -1114,6 +1114,12 @@ export interface TypeMapperCtx { * only the literal's objects, so it maps to the empty record (see the * empty object type rule in the object mapping). */ emptyLiteralArm?: boolean; + /** The class value a generic factory's result type names when the factory + * returns one of its own local classes through a constructor type + * (`function struct(v: S): Struct { class Base {}; return Base as + * Struct; }`), by the checker type: the declared result inside the + * instance being lowered, the instantiated result at its calls. */ + localClassValue?: (type: ts.Type) => IrType | null; checker: ts.TypeChecker; /** JavaScript declarations whose instance or object-literal types only * the checked-dynamic representation holds (js-dynamic-objects.ts). @@ -1653,6 +1659,11 @@ export function mapType(type: ts.Type, ctx: TypeMapperCtx): IrType | null { return STRING; if (flags & (ts.TypeFlags.Boolean | ts.TypeFlags.BooleanLiteral)) return BOOL; } + const localValue = ctx.localClassValue?.(type); + if (localValue) { + contextResolutions++; + return localValue; + } const topLevel = mapTypeDepth === 0; const typeId = (type as { id?: number }).id; const memoizable = typeId !== undefined && (ctx.canMemoizeType?.() ?? true); diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6912-extend-factory-local-class.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6912-extend-factory-local-class.ts.json new file mode 100644 index 000000000..5fc7da1eb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6912-extend-factory-local-class.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6912-extend-factory-local-class.ts" + ], + "diags": [] +} diff --git a/tests/corpus/6912-extend-factory-local-class.ts b/tests/corpus/6912-extend-factory-local-class.ts new file mode 100644 index 000000000..8848280e2 --- /dev/null +++ b/tests/corpus/6912-extend-factory-local-class.ts @@ -0,0 +1,67 @@ +// A generic factory returns its own local class through a declared +// constructor type, and a class extends the factory's result. The local +// class's static methods read the factory's parameter, inherit into the +// subclass, and call each other through `this`. +type Struct = (abstract new () => S) & { readonly decode: (value: unknown) => S }; +function struct(value: S): Struct { + abstract class Base { + static decode(_input: unknown): S { + return value; + } + } + return Base as Struct; +} +class Counter extends struct({ value: 42 }) {} +console.log(Counter.decode(null).value); + +type Named = (new (label: string) => { label: string; payload: T }) & { + readonly describe: () => string; + readonly make: (label: string) => { label: string; payload: T }; +}; +function named(kind: string, payload: T): Named { + class Entry { + label: string; + payload: T; + constructor(label: string) { + this.label = label; + this.payload = payload; + } + static describe(): string { + return `entry of ${kind}`; + } + static make(label: string): Entry { + return new this(label); + } + } + return Entry; +} +class Tag extends named("tag", [1, 2, 3]) { + shout(): string { + return this.label.toUpperCase(); + } +} +const tag = new Tag("hello"); +console.log(tag.shout(), tag.payload.join("+"), Tag.describe()); +const made = Tag.make("made"); +console.log(made.label, made.payload.length); + +const Flags = named("flag", { on: true }); +const flag = new Flags("first"); +console.log(flag.label, flag.payload.on, Flags.describe()); +const Other = named("other", 5); +console.log(Other.describe(), new Other("x").payload, Flags.describe()); + +// A function-local class's static methods read the function's parameter and +// call each other through `this`. +function twice(n: number): number { + class K { + static double(): number { + return n * 2; + } + static quad(): number { + return this.double() * 2; + } + } + return K.double() + K.quad(); +} +console.log(twice(3), twice(5)); diff --git a/tests/harness/corpus-costs/6912-extend-factory-local-class.ts.json b/tests/harness/corpus-costs/6912-extend-factory-local-class.ts.json new file mode 100644 index 000000000..a44d195f2 --- /dev/null +++ b/tests/harness/corpus-costs/6912-extend-factory-local-class.ts.json @@ -0,0 +1 @@ +{ "plain": 3633, "san": 5578 } From 0763610e93a464943833a0ccb498bf193d2f6eb0 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 01:11:37 -0500 Subject: [PATCH 025/102] Version loops to a typed array's length on every typed array they index A loop such as `for (let i = 0; i < out.length; i++) out[i] = x[i] * y[i]` keeps its integer induction, and the version guard now also receives the loop's counted form, so it covers the accesses of `x` and `y` at the counter. Before, only counted loops (`i < n`) passed a counter to the guard, and loops to a length kept one bounds check per access of every other typed array, which kept LLVM from vectorizing them. Adds the typed-array-kernels runtime workload: element-wise loops over Float64Array, Float32Array, Uint8Array and Int32Array, and RGBA to gray. --- benchmarks/runtime/README.md | 1 + .../workloads/typed-array-kernels.json | 6 + .../runtime/workloads/typed-array-kernels.ts | 92 +++++++++++ .../backend/llvm/bytes-loop-versions.test.ts | 41 +++++ .../src/backend/llvm/emit-statements.ts | 21 ++- ...2-typed-array-length-loop-versions.ts.json | 6 + ...3-typed-array-length-loop-bindings.ts.json | 6 + .../6992-typed-array-length-loop-versions.ts | 141 +++++++++++++++++ .../6993-typed-array-length-loop-bindings.ts | 146 ++++++++++++++++++ ...2-typed-array-length-loop-versions.ts.json | 1 + ...3-typed-array-length-loop-bindings.ts.json | 1 + 11 files changed, 458 insertions(+), 4 deletions(-) create mode 100644 benchmarks/runtime/workloads/typed-array-kernels.json create mode 100644 benchmarks/runtime/workloads/typed-array-kernels.ts create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6992-typed-array-length-loop-versions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6993-typed-array-length-loop-bindings.ts.json create mode 100644 tests/corpus/6992-typed-array-length-loop-versions.ts create mode 100644 tests/corpus/6993-typed-array-length-loop-bindings.ts create mode 100644 tests/harness/corpus-costs/6992-typed-array-length-loop-versions.ts.json create mode 100644 tests/harness/corpus-costs/6993-typed-array-length-loop-bindings.ts.json diff --git a/benchmarks/runtime/README.md b/benchmarks/runtime/README.md index d736a4ed4..1acdc9ce7 100644 --- a/benchmarks/runtime/README.md +++ b/benchmarks/runtime/README.md @@ -26,6 +26,7 @@ Application-shaped workloads for measuring the speed of compiled executables. Ea | `region-builds` | cpu | a watch-mode build loop over `LifetimeRegion`: each build binds a program in a new region and releases the previous one, which a cache keeps referenced for two builds | | `template-render` | cpu | template literals, escaping, `map`/`join` | | `thread-slots`, `thread-slots-cache` | cpu | worker threads reading one published type graph from an `InternTable` and keeping per-thread state for each type they visit: a `ThreadSlots` family, or a direct-mapped cache by id in front of a `Map` by id (the `-cache` entry); under Node.js both are per thread | +| `typed-array-kernels` | cpu | element-wise loops that run to one typed array's length and index others at the same position: `Float64Array` axpy, `Float32Array` blend, `Uint8Array` mask, wrapping `Int32Array` add, RGBA to gray | | `typed-array-scan`, `typed-array-scan-workers` | cpu | element-by-element scan loops over `Uint8Array`, `Uint16Array`, `Int32Array` and `Float64Array`; the second entry is a worker-enabled executable (it can start a worker), so each access also checks for shared storage | | `unicode-lexer` | cpu | a hand-written lexer over a 2.7M-unit bundled module whose comments and strings are in several languages: `charCodeAt` scans, line starts | | `validate-errors` | cpu | throw/catch on a fraction of inputs, small call chains | diff --git a/benchmarks/runtime/workloads/typed-array-kernels.json b/benchmarks/runtime/workloads/typed-array-kernels.json new file mode 100644 index 000000000..fff290679 --- /dev/null +++ b/benchmarks/runtime/workloads/typed-array-kernels.json @@ -0,0 +1,6 @@ +{ + "entry": "workloads/typed-array-kernels.ts", + "args": [ + "1" + ] +} diff --git a/benchmarks/runtime/workloads/typed-array-kernels.ts b/benchmarks/runtime/workloads/typed-array-kernels.ts new file mode 100644 index 000000000..87c227bbc --- /dev/null +++ b/benchmarks/runtime/workloads/typed-array-kernels.ts @@ -0,0 +1,92 @@ +// Element-wise loops over several typed arrays: each loop runs to one +// array's length and reads or writes the others at the same index. + +function axpy(a: number, x: Float64Array, y: Float64Array, out: Float64Array): void { + for (let i = 0; i < out.length; i++) out[i] = a * x[i]! + y[i]!; +} + +function blend(t: number, a: Float32Array, b: Float32Array, out: Float32Array): void { + for (let i = 0; i < out.length; i++) out[i] = a[i]! * (1 - t) + b[i]! * t; +} + +function mask(data: Uint8Array, key: Uint8Array, out: Uint8Array): void { + for (let i = 0; i < out.length; i++) out[i] = data[i]! ^ key[i]!; +} + +function addWrap(a: Int32Array, b: Int32Array, out: Int32Array): void { + for (let i = 0; i < out.length; i++) out[i] = (a[i]! + b[i]!) | 0; +} + +function gray(rgba: Uint8Array, out: Uint8Array): void { + for (let i = 0; i < out.length; i++) { + const j = i * 4; + out[i] = (rgba[j]! * 77 + rgba[j + 1]! * 150 + rgba[j + 2]! * 29) >> 8; + } +} + +const scale = Number(process.argv[2] ?? "1"); +const n = 1 << 16; +const x = new Float64Array(n); +const y = new Float64Array(n); +const d = new Float64Array(n); +const fa = new Float32Array(n); +const fb = new Float32Array(n); +const fo = new Float32Array(n); +const data = new Uint8Array(n); +const key = new Uint8Array(n); +const masked = new Uint8Array(n); +const ia = new Int32Array(n); +const ib = new Int32Array(n); +const io = new Int32Array(n); +const rgba = new Uint8Array(n * 4); +const luma = new Uint8Array(n); +let state = 2463534242; +const next = (): number => { + state ^= state << 13; + state ^= state >>> 17; + state ^= state << 5; + return state >>> 0; +}; +for (let i = 0; i < n; i++) { + x[i] = (next() % 20000) / 100 - 100; + y[i] = (next() % 20000) / 100; + fa[i] = (next() % 1000) / 7; + fb[i] = (next() % 1000) / 9; + data[i] = next() & 255; + key[i] = next() & 255; + ia[i] = next() | 0; + ib[i] = next() | 0; +} +for (let i = 0; i < rgba.length; i++) rgba[i] = next() & 255; + +const rounds = Math.round(1200 * scale); +let f64Sum = 0; +let f32Sum = 0; +let byteSum = 0; +let intSum = 0; +let lumaSum = 0; +for (let r = 0; r < rounds; r++) { + // Change one input element per round so no round repeats the last. + const at = (r * 7919) & (n - 1); + x[at] = r; + fa[at] = r; + data[at] = r & 255; + ia[at] = r * 65537; + rgba[at * 4] = r & 255; + axpy(1.5, x, y, d); + blend((r & 15) / 16, fa, fb, fo); + mask(data, key, masked); + addWrap(ia, ib, io); + gray(rgba, luma); + const probe = (r * 104729) & (n - 1); + f64Sum += d[probe]!; + f32Sum += fo[probe]!; + byteSum += masked[probe]!; + intSum = (intSum + io[probe]!) | 0; + lumaSum += luma[probe]!; +} +console.log(`float64 ${f64Sum.toFixed(3)}`); +console.log(`float32 ${f32Sum.toFixed(3)}`); +console.log(`uint8 ${byteSum}`); +console.log(`int32 ${intSum}`); +console.log(`gray ${lumaSum}`); diff --git a/packages/compiler/src/backend/llvm/bytes-loop-versions.test.ts b/packages/compiler/src/backend/llvm/bytes-loop-versions.test.ts index ddcfd667d..ea568bc3f 100644 --- a/packages/compiler/src/backend/llvm/bytes-loop-versions.test.ts +++ b/packages/compiler/src/backend/llvm/bytes-loop-versions.test.ts @@ -209,6 +209,47 @@ test("emitted loops version the body and tag typed-array memory", () => { expect(elements).not.toBe(header); }); +test("loops to a typed array's length version the other typed arrays they index", () => { + const length = (receiver: IrExpr): IrExpr => ({ + kind: "bytesIntrinsic", + method: "length", + receiver, + args: [], + type: F64, + loc, + }); + const emit = (body: IrStmt[]): string => { + const mod: IrModule = { + irVersion: 17, + sourceFile: loc.file, + entry: "__main", + functions: [ + { name: "__main", params: [], returnType: VOID, locals: [], body: [], loc }, + fn(body), + ], + }; + return /^define internal [^\n]*@sc_bf_kernel[^]*?^}/m.exec(emitLlvmModule(mod))![0]; + }; + // for (let i = 0; i < out.length; i++) out[i] = src[i] * 2 + const scaled = set(ref("out", f64s), ref("i"), bin("*", get(ref("src", f64s), ref("i")), num(2))); + const body = emit([counted([scaled], length(ref("out", f64s)))]); + const fast = /^bytes\.version\.fast\d+:$[^]*?^bytes\.version\.done\d+:$/m.exec(body)![0]; + // The loop keeps its integer induction, and the fast copy reads `src` + // unchecked. + expect(body).toContain("integer induction i"); + expect(fast).not.toContain("bytes.index"); + expect(body.slice(0, body.indexOf(fast))).toContain("bytes.index.invalid"); + // A body that rebinds `src` keeps one checked loop. + const rebound = emit([ + counted( + [scaled, { kind: "assign", localId: "src", value: ref("out", f64s), loc }], + length(ref("out", f64s)), + ), + ]); + expect(rebound).not.toContain("bytes.version.fast"); + expect(rebound).toContain("bytes.index.invalid"); +}); + test("Float16Array accesses version in elements and share the element tag", () => { const f16s: IrType = { kind: "bytes", elem: "f16" }; const withHalves = (body: IrStmt[]): IrFunction => { diff --git a/packages/compiler/src/backend/llvm/emit-statements.ts b/packages/compiler/src/backend/llvm/emit-statements.ts index d1dc6369b..433029651 100644 --- a/packages/compiler/src/backend/llvm/emit-statements.ts +++ b/packages/compiler/src/backend/llvm/emit-statements.ts @@ -945,12 +945,25 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { B.startBlock(done); break; } - const version = + const versionable = emitter.bytesLoopVersionsEnabled && emitter.bytesLoopVersioning.size < MAX_BYTES_LOOP_VERSION_DEPTH && - !emitter.bytesLoopVersioning.has(s) - ? emitter.matchBytesLoopVersion(s, countedLoop) - : null; + !emitter.bytesLoopVersioning.has(s); + // A loop to a typed array's or an array's length keeps its integer + // induction. Its counted form only gives the version guard the + // counter's iteration space, so the guard also covers accesses of + // other typed arrays at the counter, such as `x[i]` and `y[i]` in + // `for (let i = 0; i < out.length; i++) out[i] = x[i] * y[i]`. + const versionCounted = + versionable && !countedLoop && integerLoop && emitter.countedLoopsEnabled + ? matchIntegerCountedForLoop( + s, + emitter.numericLocals, + emitter.integerRanges, + emitter.unaliasedArrays, + ) + : countedLoop; + const version = versionable ? emitter.matchBytesLoopVersion(s, versionCounted) : null; if (version) { const fast = B.newLabel("bytes.version.fast"), slow = B.newLabel("bytes.version.slow"), diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6992-typed-array-length-loop-versions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6992-typed-array-length-loop-versions.ts.json new file mode 100644 index 000000000..2d7025954 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6992-typed-array-length-loop-versions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6992-typed-array-length-loop-versions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6993-typed-array-length-loop-bindings.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6993-typed-array-length-loop-bindings.ts.json new file mode 100644 index 000000000..43b9c5f09 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6993-typed-array-length-loop-bindings.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6993-typed-array-length-loop-bindings.ts" + ], + "diags": [] +} diff --git a/tests/corpus/6992-typed-array-length-loop-versions.ts b/tests/corpus/6992-typed-array-length-loop-versions.ts new file mode 100644 index 000000000..eb08f7145 --- /dev/null +++ b/tests/corpus/6992-typed-array-length-loop-versions.ts @@ -0,0 +1,141 @@ +// Loops bounded by one typed array's length that index other typed arrays: +// equal and different lengths, offsets, mixed element types and views that +// share a buffer. Out-of-bounds reads give undefined (NaN in arithmetic) and +// out-of-bounds writes are ignored, whichever array is shorter. + +function mulInto(x: Float32Array, y: Float32Array, out: Float32Array): void { + for (let i = 0; i < out.length; i++) out[i] = x[i]! * y[i]!; +} + +function axpy(a: number, x: Float64Array, y: Float64Array, out: Float64Array): void { + for (let i = 0; i < out.length; i++) out[i] = a * x[i]! + y[i]!; +} + +function xorInto(a: Uint8Array, b: Uint8Array, out: Uint8Array): void { + for (let i = 0; i < out.length; i++) out[i] = a[i]! ^ b[i]!; +} + +function addWrap(a: Int32Array, b: Int32Array, out: Int32Array): void { + for (let i = 0; i < out.length; i++) out[i] = (a[i]! + b[i]!) | 0; +} + +function narrow(src: Float64Array, i8: Int8Array, u16: Uint16Array, u32: Uint32Array): void { + for (let i = 0; i < src.length; i++) { + i8[i] = src[i]!; + u16[i] = src[i]!; + u32[i] = src[i]!; + } +} + +function neighbors(a: Int32Array, out: Int32Array): void { + for (let i = 0; i < a.length; i++) out[i] = a[i + 1]! - a[i]!; +} + +function previous(a: Float64Array, out: Float64Array): void { + for (let i = 0; i < out.length; i++) out[i] = a[i - 1]!; +} + +function gray(px: Uint8Array, out: Uint8Array): void { + for (let i = 0; i < out.length; i++) { + const j = i * 4; + out[i] = (px[j]! * 77 + px[j + 1]! * 150 + px[j + 2]! * 29) >> 8; + } +} + +function sumPairs(a: Float64Array, b: Float64Array): number { + let s = 0; + for (let i = 0; i < a.length; i++) s += a[i]! * b[i]!; + return s; +} + +function shiftUp(view: Uint8Array, from: Uint8Array): void { + for (let i = 0; i < view.length; i++) view[i] = from[i]! + 1; +} + +const n = 37; +const fx = new Float32Array(n); +const fy = new Float32Array(n); +const dx = new Float64Array(n); +const dy = new Float64Array(n); +const ba = new Uint8Array(n); +const bb = new Uint8Array(n); +const ia = new Int32Array(n); +const ib = new Int32Array(n); +for (let i = 0; i < n; i++) { + fx[i] = i / 3; + fy[i] = 0.1 * i - 1.7; + dx[i] = i * 1.25 - 9; + dy[i] = (i * 7) % 11; + ba[i] = (i * 29) & 255; + bb[i] = (i * 113 + 7) & 255; + ia[i] = i * 0x3fffffff; + ib[i] = i * -0x2ffffff1; +} + +const fo = new Float32Array(n); +mulInto(fx, fy, fo); +console.log("f32", fo.join(",")); +const shortF = new Float32Array(5); +mulInto(fx, fy.subarray(0, 3), shortF); +console.log("f32 short input", shortF.join(",")); +const longF = new Float32Array(n + 4); +mulInto(fx, fy, longF); +console.log("f32 long output", longF.subarray(n - 2).join(",")); + +const dout = new Float64Array(n); +axpy(-2.5, dx, dy, dout); +console.log("axpy", dout.join(",")); +axpy(0.5, dx.subarray(10), dy, dout); +console.log("axpy short x", dout.subarray(20).join(",")); + +const bo = new Uint8Array(n); +xorInto(ba, bb, bo); +console.log("xor", bo.join(",")); +const io = new Int32Array(n); +addWrap(ia, ib, io); +console.log("i32", io.join(",")); + +const src = new Float64Array([0, -1, 1.5, -128.5, 255.7, 256, 65535.9, -65537, 4294967296.5, NaN, Infinity, -0]); +const i8 = new Int8Array(src.length); +const u16 = new Uint16Array(src.length - 2); +const u32 = new Uint32Array(src.length + 1); +narrow(src, i8, u16, u32); +console.log("narrow", i8.join(","), "|", u16.join(","), "|", u32.join(",")); + +const diff = new Int32Array(n); +neighbors(ia, diff); +console.log("neighbors", diff.subarray(n - 3).join(",")); +const before = new Float64Array(4); +previous(dx, before); +console.log("previous", before.join(",")); + +const px = new Uint8Array(n * 4); +for (let i = 0; i < px.length; i++) px[i] = (i * 53) & 255; +const g = new Uint8Array(n); +gray(px, g); +console.log("gray", g.join(",")); +const wide = new Uint8Array(n + 3); +gray(px, wide); +console.log("gray past input", wide.subarray(n - 1).join(",")); + +console.log("dot", sumPairs(dx, dy), sumPairs(dx, dy.subarray(0, 30))); + +// Views of one buffer: writes through one are visible to reads through the +// other on later iterations. +const buffer = new Uint8Array(24); +for (let i = 0; i < buffer.length; i++) buffer[i] = (i * 37) & 255; +shiftUp(buffer.subarray(1), buffer); +console.log("overlap forward", buffer.join(",")); +for (let i = 0; i < buffer.length; i++) buffer[i] = (i * 37) & 255; +shiftUp(buffer, buffer.subarray(1)); +console.log("overlap backward", buffer.join(",")); +const shared = new ArrayBuffer(64); +const asFloat = new Float32Array(shared); +const asBytes = new Uint8Array(shared, 4, 16); +for (let i = 0; i < asFloat.length; i++) asFloat[i] = i + 0.5; +const fromBytes = new Float32Array(16); +for (let i = 0; i < fromBytes.length; i++) { + asBytes[i] = i * 3; + fromBytes[i] = asFloat[i]!; +} +console.log("mixed views", fromBytes.join(","), asBytes.join(",")); diff --git a/tests/corpus/6993-typed-array-length-loop-bindings.ts b/tests/corpus/6993-typed-array-length-loop-bindings.ts new file mode 100644 index 000000000..e4b242b28 --- /dev/null +++ b/tests/corpus/6993-typed-array-length-loop-bindings.ts @@ -0,0 +1,146 @@ +// Loops bounded by a typed array's length whose bindings change while they +// run, that leave early, or that run at module level, in generators and in +// async functions. Each keeps the reads, writes and bounds the source names +// on every iteration. + +function swapBound(a: Float64Array, b: Float64Array, out: Float64Array): number { + let n = 0; + for (let i = 0; i < a.length; i++) { + out[i] = a[i]! + b[i]!; + n++; + if (i === 2) a = b; + } + return n; +} + +function swapOperand(a: Int16Array, b: Int16Array, out: Int16Array): void { + for (let i = 0; i < out.length; i++) { + out[i] = a[i]! * 3; + if (i === 3) a = b; + } +} + +function closureSwap(a: Uint16Array, b: Uint16Array, out: Uint16Array): void { + const swap = (): void => { + out = b; + }; + for (let i = 0; i < out.length; i++) { + out[i] = a[i]! + 1000; + if (i === 1) swap(); + } +} + +function firstAbove(values: Float32Array, limits: Float32Array): number { + for (let i = 0; i < values.length; i++) { + if (values[i]! > limits[i]!) return i; + } + return -1; +} + +function copyUntilZero(src: Uint8Array, out: Uint8Array): number { + let copied = 0; + for (let i = 0; i < src.length; i++) { + if (src[i] === 0) break; + out[i] = src[i]!; + copied++; + } + return copied; +} + +function checkedScale(src: Int32Array, out: Int32Array): void { + for (let i = 0; i < src.length; i++) { + if (src[i]! < 0) throw new RangeError(`negative at ${i}: ${src[i]}`); + out[i] = src[i]! * 2; + } +} + +function fromList(values: number[], out: Float64Array): void { + for (let i = 0; i < values.length; i++) { + out[i] = values[i]! / 2; + if (values.length < 6) values.push(i * 10); + } +} + +function rows(table: Uint32Array[], totals: Uint32Array): void { + for (let r = 0; r < table.length; r++) { + const row = table[r]!; + let sum = 0; + for (let c = 0; c < row.length; c++) sum += row[c]! * (c + 1); + totals[r] = sum; + } +} + +function* pairs(a: Int8Array, b: Int8Array): Generator { + for (let i = 0; i < a.length; i++) yield a[i]! * b[i]!; +} + +async function addLater(a: Float64Array, b: Float64Array, out: Float64Array): Promise { + for (let i = 0; i < out.length; i++) { + out[i] = a[i]! + b[i]!; + if (i % 2 === 0) await null; + } +} + +const a = new Float64Array([1, 2, 3, 4, 5, 6]); +const b = new Float64Array([10, 20, 30]); +const sum = new Float64Array(8); +console.log("swap bound", swapBound(a, b, sum), sum.join(",")); + +const s16 = new Int16Array([1, -2, 3, -4, 5, -6, 7]); +const t16 = new Int16Array([100, 200, 300, 400, 500, 600]); +const o16 = new Int16Array(7); +swapOperand(s16, t16, o16); +console.log("swap operand", o16.join(",")); + +const u = new Uint16Array([5, 6, 7, 8]); +const other = new Uint16Array(2); +const first = new Uint16Array(4); +closureSwap(u, other, first); +console.log("closure swap", first.join(","), other.join(",")); + +const values = new Float32Array([0.5, 1.5, 2.5, 3.5]); +console.log("first above", firstAbove(values, new Float32Array([1, 1, 1, 1]))); +console.log("first above short", firstAbove(values, new Float32Array([9]))); +console.log("first above none", firstAbove(values, new Float32Array([9, 9, 9, 9]))); + +const text = new Uint8Array([72, 105, 33, 0, 88]); +const copy = new Uint8Array(2); +console.log("copy", copyUntilZero(text, copy), copy.join(",")); + +const ints = new Int32Array([4, 8, -15, 16]); +const doubled = new Int32Array(4); +try { + checkedScale(ints, doubled); +} catch (error) { + console.log((error as Error).name, (error as Error).message, doubled.join(",")); +} + +const list = [3, 5]; +const halves = new Float64Array(5); +fromList(list, halves); +console.log("from list", list.join(","), halves.join(",")); + +const table = [new Uint32Array([1, 2, 3]), new Uint32Array([]), new Uint32Array([4294967295, 1])]; +const totals = new Uint32Array(4); +rows(table, totals); +console.log("rows", totals.join(",")); + +console.log("pairs", [...pairs(new Int8Array([1, -2, 3, 127]), new Int8Array([4, 5, -6]))].join(",")); + +const left = new Float64Array([0.25, 0.5, 0.75, 1]); +const right = new Float64Array([1, 2, 3, 4, 5]); +const later = new Float64Array(5); +const pending = addLater(left, right, later); +console.log("before await", later.join(",")); + +// Module-level bindings, including one a loop body reassigns. +let source = new Uint8Array([9, 8, 7, 6, 5]); +const replacement = new Uint8Array([1, 2]); +const target = new Uint8Array(5); +for (let i = 0; i < source.length; i++) { + target[i] = source[i]! + 100; + if (i === 1) source = replacement; +} +console.log("module", target.join(","), source.join(",")); + +pending.then(() => console.log("after await", later.join(","))); diff --git a/tests/harness/corpus-costs/6992-typed-array-length-loop-versions.ts.json b/tests/harness/corpus-costs/6992-typed-array-length-loop-versions.ts.json new file mode 100644 index 000000000..26208456e --- /dev/null +++ b/tests/harness/corpus-costs/6992-typed-array-length-loop-versions.ts.json @@ -0,0 +1 @@ +{ "plain": 3800, "san": 5600 } diff --git a/tests/harness/corpus-costs/6993-typed-array-length-loop-bindings.ts.json b/tests/harness/corpus-costs/6993-typed-array-length-loop-bindings.ts.json new file mode 100644 index 000000000..a6e281d1e --- /dev/null +++ b/tests/harness/corpus-costs/6993-typed-array-length-loop-bindings.ts.json @@ -0,0 +1 @@ +{ "plain": 2700, "san": 4000 } From c081d5a3a771da3b09b3c6d6ec4d90f3e311bb3e Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 01:16:55 -0500 Subject: [PATCH 026/102] Apply the byte offset in Buffer.from over untyped ArrayBuffers Buffer.from(arrayBuffer, byteOffset) with an untyped ArrayBuffer or SharedArrayBuffer now returns a Buffer from that offset to the end, as Node's fromArrayBuffer does, where the offset was dropped and the Buffer covered the whole buffer. --- .../compiler/src/backend/llvm/lib-shared.ts | 1 + .../src/frontend/lowering/containers/bytes.ts | 11 +++-- packages/compiler/src/ir/builtin-effects.ts | 1 + .../compiler/src/ir/builtin-signatures.ts | 1 + packages/runtime/src/scr_bytes.h | 1 + packages/runtime/src/scr_bytes_io.c | 43 +++++++++++++++++-- .../6868-buffer-from-untyped-array-buffer.cjs | 22 +++++++++- 7 files changed, 71 insertions(+), 9 deletions(-) diff --git a/packages/compiler/src/backend/llvm/lib-shared.ts b/packages/compiler/src/backend/llvm/lib-shared.ts index 683211762..cf2255f89 100644 --- a/packages/compiler/src/backend/llvm/lib-shared.ts +++ b/packages/compiler/src/backend/llvm/lib-shared.ts @@ -448,6 +448,7 @@ export const LIB_FN_SYMS: Record = { "buffer.poolFromArray": "scr_buffer_from_arr", "buffer.poolFromDyn": "scr_buffer_from_dyn_pooled", "buffer.poolFromDynRef": "scr_buffer_from_dyn_ref_pooled", + "buffer.poolFromDynOffset": "scr_buffer_from_dyn_offset_pooled", "buffer.poolSize": "scr_buffer_pool_size", "buffer.setPoolSize": "scr_buffer_set_pool_size", "buffer.byteLenDyn": "scr_buffer_byte_length_dyn", diff --git a/packages/compiler/src/frontend/lowering/containers/bytes.ts b/packages/compiler/src/frontend/lowering/containers/bytes.ts index bf9821d31..afd108eb4 100644 --- a/packages/compiler/src/frontend/lowering/containers/bytes.ts +++ b/packages/compiler/src/frontend/lowering/containers/bytes.ts @@ -1743,8 +1743,9 @@ function knownBufferProducer( /** Buffer.from over a checked-dynamic source and encoding, both already in * repeatable locals: Node's fromString takes utf8 for an absent, non-string - * or empty encoding and throws ERR_UNKNOWN_ENCODING for an unknown name; - * other sources ignore the encoding. */ + * or empty encoding and throws ERR_UNKNOWN_ENCODING for an unknown name; an + * ArrayBuffer takes the second argument as its byte offset; other sources + * ignore it. */ function dynBufferFromParts(source: IrExpr, encoding: IrExpr, loc: SrcLoc): IrExpr { const utf8: IrExpr = { kind: "strLit", value: "utf8", type: STRING, loc }; const isString = (x: IrExpr): IrExpr => ({ @@ -1786,10 +1787,12 @@ function dynBufferFromParts(source: IrExpr, encoding: IrExpr, loc: SrcLoc): IrEx type: BYTES_U8, loc, }, + // An ArrayBuffer takes the second argument as its byte offset + // (scr_buffer_from_dyn_offset_pooled); other values convert with utf8. else_: { kind: "libCall", - fn: "buffer.poolFromDynRef", - args: [source, utf8], + fn: "buffer.poolFromDynOffset", + args: [source, encoding], type: BYTES_U8, loc, }, diff --git a/packages/compiler/src/ir/builtin-effects.ts b/packages/compiler/src/ir/builtin-effects.ts index 482739db5..ae6b663ca 100644 --- a/packages/compiler/src/ir/builtin-effects.ts +++ b/packages/compiler/src/ir/builtin-effects.ts @@ -789,6 +789,7 @@ export const MAY_THROW_LIB_FNS: ReadonlySet = new Set([ "buffer.poolFromArray", "buffer.poolFromDyn", "buffer.poolFromDynRef", + "buffer.poolFromDynOffset", // The checked-dynamic compare/equals validators: Node's argument // ladders throw ERR_INVALID_ARG_TYPE / ERR_OUT_OF_RANGE catchably. "buffer.compareChk", diff --git a/packages/compiler/src/ir/builtin-signatures.ts b/packages/compiler/src/ir/builtin-signatures.ts index 49683550e..c92cd40d4 100644 --- a/packages/compiler/src/ir/builtin-signatures.ts +++ b/packages/compiler/src/ir/builtin-signatures.ts @@ -2921,6 +2921,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({ "buffer.poolFromDyn": { argTypes: [DYN, STRING], result: BYTES_U8 }, /** poolFromDyn that also copies an array crossing by reference. */ "buffer.poolFromDynRef": { argTypes: [DYN, STRING], result: BYTES_U8 }, + "buffer.poolFromDynOffset": { argTypes: [DYN, DYN], result: BYTES_U8 }, "buffer.poolSize": { argTypes: [], result: F64 }, "buffer.setPoolSize": { argTypes: [F64], result: VOID }, /** Buffer.byteLength(string, enc) — enc a NORMALIZED literal like diff --git a/packages/runtime/src/scr_bytes.h b/packages/runtime/src/scr_bytes.h index 9c81caea5..9b382dda5 100644 --- a/packages/runtime/src/scr_bytes.h +++ b/packages/runtime/src/scr_bytes.h @@ -397,6 +397,7 @@ ScrBytes *scr_buffer_from_bytes(const ScrBytes *src); /* a copy of any typed arr ScrBytes *scr_buffer_from_arr(const ScrArr *arr); /* number[] */ ScrBytes *scr_buffer_from_dyn_pooled(const ScrDyn *value, const ScrStr *encoding); ScrBytes *scr_buffer_from_dyn_ref_pooled(const ScrDyn *value, const ScrStr *encoding); +ScrBytes *scr_buffer_from_dyn_offset_pooled(const ScrDyn *value, const ScrDyn *second); ScrBytes *scr_buffer_concat(const ScrArr *list); ScrBytes *scr_buffer_concat_len(const ScrArr *list, double total); /* The untyped-list forms: Node's ERR_INVALID_ARG_TYPE checks on the list diff --git a/packages/runtime/src/scr_bytes_io.c b/packages/runtime/src/scr_bytes_io.c index ac8fad02e..bd79d9089 100644 --- a/packages/runtime/src/scr_bytes_io.c +++ b/packages/runtime/src/scr_bytes_io.c @@ -1300,9 +1300,10 @@ ScrBytes *scr_buffer_concat_len_dyn(const ScrDyn *list, double total) { } /* Buffer.from(arrayBuffer) over a checked value: a Buffer over all of the - * ArrayBuffer or SharedArrayBuffer that shares its memory, as in Node. A - * second argument would be the byte offset, and an encoding name converts - * to NaN, which is offset 0. */ + * ArrayBuffer or SharedArrayBuffer that shares its memory, as in Node. The + * calls that reach it have no second argument or a literal encoding name, + * which as a byte offset converts to NaN, offset 0; other second arguments + * take scr_buffer_from_dyn_offset_pooled, which applies the offset. */ static ScrBytes *scr_buffer_from_storage(const ScrDyn *storage) { ScrBytes *out = scr_bytes_buffer_view(storage->v.handle.ptr, SCR_BYTES_U8, 0, false, 0); if (out) out->is_buffer = true; @@ -1381,6 +1382,42 @@ ScrBytes *scr_buffer_from_dyn_ref_pooled(const ScrDyn *value, const ScrStr *enco return scr_buffer_from_dyn_pooled(value, encoding); } +/* Buffer.from(value, second) over checked values whose second argument is + * not a literal encoding name: an ArrayBuffer or SharedArrayBuffer takes it + * as the byte offset, as Node's fromArrayBuffer does (undefined and NaN are + * 0, the rest of the buffer is the length, ERR_BUFFER_OUT_OF_BOUNDS past the + * end); other values convert as scr_buffer_from_dyn_ref_pooled with utf8. */ +ScrBytes *scr_buffer_from_dyn_offset_pooled(const ScrDyn *value, const ScrDyn *second) { + if (!scr_buffer_storage_is(value)) { + ScrStr *utf8 = scr_str_new("utf8", 4); + ScrBytes *out = scr_buffer_from_dyn_ref_pooled(value, utf8); + scr_str_release(utf8); + return out; + } + double offset = 0; + if (second->kind != SCR_DYN_UNDEF) { + if (!scr_dyn_number_coerce_js(second, &offset)) return NULL; + if (isnan(offset)) offset = 0; + } + ScrBytes *storage = value->v.handle.ptr; + ScrBytes *owner = storage->backing ? storage->backing : storage; + if ((double)scr_bytes_byte_len(owner) - offset < 0) { + static const char msg[] = "\"offset\" is outside of buffer bounds"; + scr_throw_error_msg_code(SCR_ERR_RANGE, msg, sizeof msg - 1, "ERR_BUFFER_OUT_OF_BOUNDS"); + return NULL; + } + double start = trunc(offset); + if (start < 0) { + char msg[96]; + int n = snprintf(msg, sizeof msg, "Start offset %.0f is outside the bounds of the buffer", start); + scr_throw_error_msg(SCR_ERR_RANGE, msg, (size_t)n); + return NULL; + } + ScrBytes *out = scr_bytes_buffer_view(storage, SCR_BYTES_U8, start, false, 0); + if (out) out->is_buffer = true; + return out; +} + /* new Buffer(number, encoding) — the deprecated ctor's string arm with a * non-string first argument: Node's exact ERR_INVALID_ARG_TYPE (the * throwing path never fires DEP0005, so compiled silence matches). */ diff --git a/tests/corpus/6868-buffer-from-untyped-array-buffer.cjs b/tests/corpus/6868-buffer-from-untyped-array-buffer.cjs index f525f24cf..e30b5873e 100644 --- a/tests/corpus/6868-buffer-from-untyped-array-buffer.cjs +++ b/tests/corpus/6868-buffer-from-untyped-array-buffer.cjs @@ -1,7 +1,8 @@ // Buffer.from over an untyped ArrayBuffer or SharedArrayBuffer (read from a // Map, an untyped object field or a worker message): the Buffer covers the -// whole buffer and shares its memory, in both directions, as in Node. An -// encoding name in the second argument converts to byte offset 0. +// buffer from its byte offset (the second argument) and shares its memory, in +// both directions, as in Node. An encoding name or NaN in the second argument +// is offset 0; an offset past the end throws ERR_BUFFER_OUT_OF_BOUNDS. 'use strict'; const { Worker, isMainThread, parentPort, workerData } = require('node:worker_threads'); @@ -19,6 +20,23 @@ if (isMainThread) { console.log(key, 'with encoding', encoded.length, encoded.toString('hex')); } + const offsets = new Map(); + offsets.set('storage', new ArrayBuffer(8)); + const storage = offsets.get('storage'); + for (const offset of [2, 1.5, '3', NaN, null, undefined, true, 8, 9, -1, -0.5]) { + try { + const view = Buffer.from(storage, offset); + view.fill(offset === 2 ? 0x11 : 0); + console.log('offset', String(offset), view.byteOffset, view.length, new Uint8Array(storage).join(',')); + } catch (error) { + console.log('offset', String(offset), error.name, error.code, error.message); + } + } + const sharedOffsets = new Map([['s', new SharedArrayBuffer(6)]]); + const tail = Buffer.from(sharedOffsets.get('s'), 4); + tail[0] = 0x7f; + console.log('shared offset', tail.length, new Uint8Array(sharedOffsets.get('s')).join(',')); + const holder = JSON.parse('{}'); holder.data = new ArrayBuffer(3); const view = Buffer.from(holder.data); From 777bfb43f2e126e5d5fa0f8046eca3944d87548d Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 01:40:17 -0500 Subject: [PATCH 027/102] Revert "Name lowered helpers and closures independently of lowering order" This reverts #1750 (05e2f404d), which made main CI fail. --- package.json | 2 +- packages/compiler/src/contracts/check.ts | 3 +- .../lowering/array-indexed-mutation.ts | 3 +- .../src/frontend/lowering/array-values.ts | 5 +- .../frontend/lowering/builtins/arguments.ts | 3 +- .../lowering/builtins/child-process-async.ts | 3 +- .../lowering/builtins/child-process-sync.ts | 3 +- .../lowering/builtins/disposable-stack.ts | 3 +- .../frontend/lowering/builtins/filesystem.ts | 3 +- .../src/frontend/lowering/builtins/json.ts | 3 +- .../lowering/builtins/operating-system.ts | 7 +- .../frontend/lowering/builtins/performance.ts | 5 +- .../src/frontend/lowering/builtins/process.ts | 5 +- .../frontend/lowering/builtins/promises.ts | 5 +- .../lowering/builtins/promisify-callback.ts | 3 +- .../frontend/lowering/builtins/text-codecs.ts | 3 +- .../src/frontend/lowering/builtins/timers.ts | 2 +- .../src/frontend/lowering/builtins/url.ts | 7 +- .../src/frontend/lowering/builtins/v8.ts | 3 +- .../src/frontend/lowering/call-arguments.ts | 3 +- .../src/frontend/lowering/call-signatures.ts | 7 +- .../src/frontend/lowering/class-assertions.ts | 5 +- .../src/frontend/lowering/class-unions.ts | 3 +- .../lowering/coercions/function-adapters.ts | 11 +- .../frontend/lowering/coercions/structural.ts | 15 ++- .../src/frontend/lowering/coercions/unions.ts | 15 ++- .../frontend/lowering/collection-ingestion.ts | 3 +- .../lowering/containers/array-callbacks.ts | 25 ++-- .../lowering/containers/array-concat.ts | 3 +- .../lowering/containers/array-construction.ts | 7 +- .../lowering/containers/array-methods.ts | 11 +- .../lowering/containers/array-pipelines.ts | 3 +- .../src/frontend/lowering/containers/bytes.ts | 5 +- .../lowering/containers/callback-arguments.ts | 3 +- .../containers/collection-grouping.ts | 5 +- .../lowering/containers/collection-methods.ts | 15 ++- .../lowering/containers/indexed-objects.ts | 15 ++- .../lowering/containers/iterator-helpers.ts | 7 +- .../lowering/containers/string-and-regexp.ts | 11 +- .../lowering/containers/string-replacement.ts | 3 +- .../frontend/lowering/expressions/binary.ts | 3 +- .../lowering/expressions/object-literals.ts | 7 +- .../lowering/expressions/optional-chains.ts | 10 +- .../lowering/expressions/property-access.ts | 3 +- .../lowering/expressions/relational.ts | 5 +- .../frontend/lowering/generic-functions.ts | 17 +-- .../src/frontend/lowering/intern-tables.ts | 7 +- .../frontend/lowering/iterator-adapters.ts | 17 ++- .../frontend/lowering/js-dynamic-objects.ts | 5 +- .../src/frontend/lowering/json-require.ts | 3 +- .../src/frontend/lowering/lifetime-regions.ts | 3 +- .../src/frontend/lowering/lower-assert.ts | 11 +- .../src/frontend/lowering/lower-calls.ts | 49 ++++---- .../src/frontend/lowering/lower-classes.ts | 9 +- .../src/frontend/lowering/lower-dgram.ts | 5 +- .../frontend/lowering/lower-event-emitter.ts | 13 +- .../src/frontend/lowering/lower-exprs.ts | 9 +- .../src/frontend/lowering/lower-functions.ts | 2 +- .../src/frontend/lowering/lower-inspect.ts | 7 +- .../src/frontend/lowering/lower-mixins.ts | 3 +- .../src/frontend/lowering/lower-mock.ts | 3 +- .../frontend/lowering/lower-modules.test.ts | 4 +- .../src/frontend/lowering/lower-modules.ts | 15 +-- .../src/frontend/lowering/lower-namespaces.ts | 11 +- .../src/frontend/lowering/lower-server.ts | 13 +- .../src/frontend/lowering/lower-stdlib.ts | 2 +- .../src/frontend/lowering/lower-stream.ts | 15 ++- .../src/frontend/lowering/lower-timers.ts | 7 +- .../src/frontend/lowering/lowerer.test.ts | 30 ++--- .../compiler/src/frontend/lowering/lowerer.ts | 101 +++------------- .../src/frontend/lowering/native-ffi.ts | 2 +- .../lowering/object-enumeration-receiver.ts | 3 +- .../src/frontend/lowering/pairs-snapshot.ts | 3 +- .../lowering/promise-executor-adapter.ts | 3 +- .../lowering/require-initialization.ts | 3 +- .../src/frontend/lowering/stable-names.ts | 48 -------- .../src/frontend/lowering/strict-equality.ts | 3 +- .../frontend/lowering/structural-positions.ts | 107 ----------------- packages/compiler/src/frontend/ts7/ast.ts | 90 +------------- .../compiler/src/frontend/type-mapper.test.ts | 2 +- packages/compiler/src/frontend/type-mapper.ts | 92 ++------------ .../test/array-pipeline-fusion.test.ts | 2 +- .../test/format-float-arguments.test.ts | 2 +- .../test/in-runtime-key-emission.test.ts | 2 +- packages/compiler/test/stable-names.test.ts | 112 ------------------ .../compiler/test/type-mapper-unions.test.ts | 3 +- 86 files changed, 258 insertions(+), 854 deletions(-) delete mode 100644 packages/compiler/src/frontend/lowering/stable-names.ts delete mode 100644 packages/compiler/src/frontend/lowering/structural-positions.ts delete mode 100644 packages/compiler/test/stable-names.test.ts diff --git a/package.json b/package.json index d1a8e34ae..5cc30d9f8 100644 --- a/package.json +++ b/package.json @@ -20,7 +20,7 @@ "test:test262": "tsx tests/test262/run.ts", "test:test262:fetch": "node tests/test262/fetch.mjs", "test:cache-identity": "node tests/harness/cache-identity.mjs", - "test:lowering-order": "node scripts/lowering-order.mjs --fail-on names", + "test:lowering-order": "node scripts/lowering-order.mjs --fail-on content", "test:sandbox": "node scripts/sandbox-test.mjs", "test:sandbox:image": "node scripts/sandbox-image.mjs", "test:watch": "vitest", diff --git a/packages/compiler/src/contracts/check.ts b/packages/compiler/src/contracts/check.ts index c80468961..5934624bf 100644 --- a/packages/compiler/src/contracts/check.ts +++ b/packages/compiler/src/contracts/check.ts @@ -174,8 +174,7 @@ class ContractChecker { return `${owner}.${method[2]}`; } if (fn?.sourceName !== undefined && fn.sourceName !== "") return fn.sourceName; - if (fn !== undefined && /^%fn\.[0-9a-f]{12}$/.test(fnName)) - return `the function at ${this.where(fn.loc)}`; + if (fn !== undefined && /^%fn\d+$/.test(fnName)) return `the function at ${this.where(fn.loc)}`; return fnName.replace(/^%/, ""); } diff --git a/packages/compiler/src/frontend/lowering/array-indexed-mutation.ts b/packages/compiler/src/frontend/lowering/array-indexed-mutation.ts index 0ded460da..6d539212e 100644 --- a/packages/compiler/src/frontend/lowering/array-indexed-mutation.ts +++ b/packages/compiler/src/frontend/lowering/array-indexed-mutation.ts @@ -9,7 +9,6 @@ import { type SrcLoc, typeEquals, } from "../../ir/ir.js"; -import { keyedHelperName } from "./stable-names.js"; import { numLit, varRef } from "../../ir/build.js"; import { typeKey } from "../type-mapper.js"; import type { Lowerer } from "./lowerer.js"; @@ -126,7 +125,7 @@ export function lowerArrayFill( writeNull; let name = lowerer.arrHofHelpers.get(key); if (!name) { - name = keyedHelperName(lowerer, "%arr.fill", key); + name = "%arr.fill." + lowerer.arrHofHelpers.size; lowerer.arrHofHelpers.set(key, name); const a = varRef("a.0", arrType, loc); const n = varRef("n.0", F64, loc); diff --git a/packages/compiler/src/frontend/lowering/array-values.ts b/packages/compiler/src/frontend/lowering/array-values.ts index 314cdfd24..0ca8503df 100644 --- a/packages/compiler/src/frontend/lowering/array-values.ts +++ b/packages/compiler/src/frontend/lowering/array-values.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "./stable-names.js"; import { InternalCompilerError } from "../../errors.js"; import { dynUndefinedExpr, helperLoc, varRef } from "../../ir/build.js"; import { @@ -253,7 +252,7 @@ export function lowerSafeIndexRead( let name = lowerer.arrHofHelpers.get(key); if (!name) { const at = helperLoc(loc); - name = keyedHelperName(lowerer, "%arr.idxOr", key); + name = `%arr.idxOr.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, name); const arrT = arr.type; lowerer.liftedFns.push({ @@ -299,7 +298,7 @@ export function lowerSafeBytesRead( let name = lowerer.arrHofHelpers.get(key); if (!name) { const at = helperLoc(loc); - name = keyedHelperName(lowerer, "%bytes.idxOr", key); + name = `%bytes.idxOr.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, name); const b = varRef("b.0", bytesT, at); const i = varRef("i.0", F64, at); diff --git a/packages/compiler/src/frontend/lowering/builtins/arguments.ts b/packages/compiler/src/frontend/lowering/builtins/arguments.ts index d2fc430dd..7f862f603 100644 --- a/packages/compiler/src/frontend/lowering/builtins/arguments.ts +++ b/packages/compiler/src/frontend/lowering/builtins/arguments.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "../stable-names.js"; import { BYTES_U8, BOOL, @@ -73,7 +72,7 @@ export function lowerOptionalNumberPredicate( const key = `number.optionalPredicate:${fn}:${typeKey(widened)}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%number.optionalPredicate", key); + helper = `%number.optionalPredicate.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, helper); const input = varRef("value.0", widened, loc); lowerer.liftedFns.push({ diff --git a/packages/compiler/src/frontend/lowering/builtins/child-process-async.ts b/packages/compiler/src/frontend/lowering/builtins/child-process-async.ts index d0991dce5..5590fbe9f 100644 --- a/packages/compiler/src/frontend/lowering/builtins/child-process-async.ts +++ b/packages/compiler/src/frontend/lowering/builtins/child-process-async.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "../stable-names.js"; import { recordToEnvPairs } from "./environment.js"; import { lowerChildArgsArg } from "./child-process.js"; import { boolLit, numLit, varRef } from "../../../ir/build.js"; @@ -219,7 +218,7 @@ function execFileAsyncHelper( const key = shell ? "execAsync" : "execFileAsync"; const existing = lowerer.valueHelpers.get(key); if (existing) return { name: existing, shapeId, envShapeId }; - const name = keyedHelperName(lowerer, `%${key}`, key); + const name = `%${key}.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); const recT: IrType = { kind: "record", shapeId }; const envRecT: IrType = { kind: "record", shapeId: envShapeId }; diff --git a/packages/compiler/src/frontend/lowering/builtins/child-process-sync.ts b/packages/compiler/src/frontend/lowering/builtins/child-process-sync.ts index b9858e768..24adcc1ba 100644 --- a/packages/compiler/src/frontend/lowering/builtins/child-process-sync.ts +++ b/packages/compiler/src/frontend/lowering/builtins/child-process-sync.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "../stable-names.js"; import { recordToEnvPairs } from "./environment.js"; import { lowerChildArgsArg } from "./child-process.js"; import { boolLit, numLit, strLit, varRef } from "../../../ir/build.js"; @@ -542,7 +541,7 @@ function execStdioModeHelper( const key = `cp.stdiomode:${shapeId}:${fd}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, `%cp.stdioMode.${fd}`, key); + const name = `%cp.stdioMode.${fd}.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, name); const optsT: IrType = { kind: "record", shapeId }; diff --git a/packages/compiler/src/frontend/lowering/builtins/disposable-stack.ts b/packages/compiler/src/frontend/lowering/builtins/disposable-stack.ts index 375c3f1e7..1b9a9c03a 100644 --- a/packages/compiler/src/frontend/lowering/builtins/disposable-stack.ts +++ b/packages/compiler/src/frontend/lowering/builtins/disposable-stack.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "../stable-names.js"; import * as ts from "../../ts7/adapter.js"; import { type Lowerer } from "../lowerer.js"; import { locOf } from "../../program.js"; @@ -85,7 +84,7 @@ export function lowerDisposableStackUseCall( const key = `disposableStack.use:${className}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%disposableStack.use", key); + helper = `%disposableStack.use.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, helper); const context = newFnCtx(false, null, null, VOID); lowerer.fnStack.push(context); diff --git a/packages/compiler/src/frontend/lowering/builtins/filesystem.ts b/packages/compiler/src/frontend/lowering/builtins/filesystem.ts index 6b988c491..0e1c062c5 100644 --- a/packages/compiler/src/frontend/lowering/builtins/filesystem.ts +++ b/packages/compiler/src/frontend/lowering/builtins/filesystem.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "../stable-names.js"; import { dynUndefinedExpr, boolLit, numLit, varRef } from "../../../ir/build.js"; import * as ts from "../../ts7/adapter.js"; import { type Lowerer, ladderFenceExpr } from "../lowerer.js"; @@ -443,7 +442,7 @@ export function lowerStringOrBytesWrite( const key = `fs.${append ? "append" : "write"}:${dataType.unionId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%fs.writeData", key); + helper = `%fs.writeData.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, helper); const body: IrStmt[] = []; for (let tag = 0; tag < arms.length; tag++) { diff --git a/packages/compiler/src/frontend/lowering/builtins/json.ts b/packages/compiler/src/frontend/lowering/builtins/json.ts index 64f829865..7eb8aa9b2 100644 --- a/packages/compiler/src/frontend/lowering/builtins/json.ts +++ b/packages/compiler/src/frontend/lowering/builtins/json.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "../stable-names.js"; import { isDateJsonSource } from "./dates.js"; import { dynUndefinedExpr, varRef } from "../../../ir/build.js"; import { InternalCompilerError } from "../../../errors.js"; @@ -254,7 +253,7 @@ function lowerOptionalStringifyRoot( const key = `json.optionalString:${value.type.unionId}:${JSON.stringify(indent)}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%json.optionalString", key); + helper = `%json.optionalString.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, helper); const input = varRef("value.0", value.type, loc); const serialized: IrExpr = { diff --git a/packages/compiler/src/frontend/lowering/builtins/operating-system.ts b/packages/compiler/src/frontend/lowering/builtins/operating-system.ts index ee189a1f3..c10465039 100644 --- a/packages/compiler/src/frontend/lowering/builtins/operating-system.ts +++ b/packages/compiler/src/frontend/lowering/builtins/operating-system.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "../stable-names.js"; import { numLit, strLit, varRef } from "../../../ir/build.js"; import * as ts from "../../ts7/adapter.js"; import { type Lowerer } from "../lowerer.js"; @@ -220,7 +219,7 @@ export function lowerOsCpusCall(lowerer: Lowerer, call: ts.CallExpression, loc: const key = `os.cpus:${typeKey(result)}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%os.cpus", key); + helper = `%os.cpus.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, helper); const index = varRef("i.0", F64, loc); const field = (k: number): IrExpr => ({ @@ -347,7 +346,7 @@ export function lowerPathParseCall( const key = `${fn}:${typeKey(result)}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%path.parse", key); + helper = `%path.parse.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, helper); const parts = varRef("parts.0", arrayOf(STRING), loc); lowerer.liftedFns.push({ @@ -449,7 +448,7 @@ export function lowerPathFormatCall( const key = `${fn}:${typeKey(recordT)}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%path.format", key); + helper = `%path.format.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, helper); const object = varRef("object.0", recordT, loc); const read = (name: string): IrExpr => { diff --git a/packages/compiler/src/frontend/lowering/builtins/performance.ts b/packages/compiler/src/frontend/lowering/builtins/performance.ts index bae525c17..72304e6a9 100644 --- a/packages/compiler/src/frontend/lowering/builtins/performance.ts +++ b/packages/compiler/src/frontend/lowering/builtins/performance.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "../stable-names.js"; import * as ts from "../../ts7/adapter.js"; import { type Lowerer } from "../lowerer.js"; import { locOf } from "../../program.js"; @@ -331,7 +330,7 @@ function lowerPerfTimelineCall( const key = `perf.${many ? "entries" : timeline.fn}:${typeKey(result)}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, `%perf.${many ? "entries" : member}`, key); + helper = `%perf.${many ? "entries" : member}.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, helper); const argsRef = varRef("a.0", DYN, loc); const whichRef = varRef("w.0", F64, loc); @@ -462,7 +461,7 @@ export function perfEntryTag( const key = `perf.tag:${entryT.shapeId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%perf.tag", key); + helper = `%perf.tag.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, helper); const e = varRef("e.0", entryT, loc); lowerer.liftedFns.push({ diff --git a/packages/compiler/src/frontend/lowering/builtins/process.ts b/packages/compiler/src/frontend/lowering/builtins/process.ts index 842f42b57..25653f541 100644 --- a/packages/compiler/src/frontend/lowering/builtins/process.ts +++ b/packages/compiler/src/frontend/lowering/builtins/process.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "../stable-names.js"; import { stdinKeypressListener } from "./readline.js"; import { envSnapshotHelper, lowerProcessLoadEnvFile } from "./environment.js"; import { dynUndefinedExpr, boolLit, numLit, strLit, varRef } from "../../../ir/build.js"; @@ -1562,7 +1561,7 @@ export function lowerProcessMethodCall( const key = `${prefix}usage.diff:${prevT.shapeId}:${t.shapeId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, `%${prefix}usage.diff`, key); + helper = `%${prefix}usage.diff.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, helper); const pRef: IrExpr = { kind: "varRef", localId: "p.0", type: prevT, loc }; const fieldOf = (name: string): IrExpr => ({ @@ -1637,7 +1636,7 @@ export function lowerProcessMethodCall( const key = `process.memoryUsage:${t.shapeId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%process.memoryUsage", key); + helper = `%process.memoryUsage.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, helper); lowerer.liftedFns.push({ name: helper, diff --git a/packages/compiler/src/frontend/lowering/builtins/promises.ts b/packages/compiler/src/frontend/lowering/builtins/promises.ts index 75e527aa5..668ef01f8 100644 --- a/packages/compiler/src/frontend/lowering/builtins/promises.ts +++ b/packages/compiler/src/frontend/lowering/builtins/promises.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "../stable-names.js"; import { checkedPromiseAll, thenReader } from "../checked-promise-all.js"; import { InternalCompilerError } from "../../../errors.js"; import * as ts from "../../ts7/adapter.js"; @@ -56,7 +55,7 @@ function lowerTuplePromiseAll( const key = `${elems.map((e) => typeKey(e.type)).join(",")}->${typeKey(resultT.inner)}`; let name = lowerer.arrHofHelpers.get(`promise.allTuple:${key}`); if (name === undefined) { - name = keyedHelperName(lowerer, "%promise.allTuple", `promise.allTuple:${key}`); + name = `%promise.allTuple.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(`promise.allTuple:${key}`, name); const ctx = newFnCtx(false, null, null, resultT.inner); ctx.isAsync = true; @@ -558,7 +557,7 @@ export function lowerPromiseStaticCall( const key = `promise.try:${typeKey(f.type)}:${args.map((a) => typeKey(a.type)).join(",")}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%promise.try", key); + helper = `%promise.try.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, helper); const fRef: IrExpr = { kind: "varRef", localId: "f.0", type: f.type, loc }; const argLocals = args.map((a, i) => ({ id: `a${i}.0`, name: `a${i}`, type: a.type })); diff --git a/packages/compiler/src/frontend/lowering/builtins/promisify-callback.ts b/packages/compiler/src/frontend/lowering/builtins/promisify-callback.ts index b4dbbf513..822a4fecc 100644 --- a/packages/compiler/src/frontend/lowering/builtins/promisify-callback.ts +++ b/packages/compiler/src/frontend/lowering/builtins/promisify-callback.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "../stable-names.js"; import * as ts from "../../ts7/adapter.js"; import { type Lowerer } from "../lowerer.js"; import { varRef } from "../../../ir/build.js"; @@ -171,7 +170,7 @@ function promisifyMaker(lowerer: Lowerer, shape: CallbackShape, loc: SrcLoc): st const key = `promisify:${typeKey(shape.fnT)}=>${typeKey(shape.resultT)}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const base = keyedHelperName(lowerer, "%promisify", key); + const base = `%promisify.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, base); const { fnT, resultT, args, callbackT, callbackParamT, inner, error } = shape; const promiseT = resultT.ret; diff --git a/packages/compiler/src/frontend/lowering/builtins/text-codecs.ts b/packages/compiler/src/frontend/lowering/builtins/text-codecs.ts index 8d47c8e3a..7229d5b84 100644 --- a/packages/compiler/src/frontend/lowering/builtins/text-codecs.ts +++ b/packages/compiler/src/frontend/lowering/builtins/text-codecs.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "../stable-names.js"; import { isBuiltinClassInstance } from "./receiver-types.js"; import { strLit, varRef, dynUndefinedExpr } from "../../../ir/build.js"; import { staticTextDecoderEncoding } from "../text-decoder-encoding.js"; @@ -130,7 +129,7 @@ function stringDecoderHelper( const key = `strdec.${op}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, `%strdec.${op}`, key); + const name = `%strdec.${op}.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); const recT: IrType = { kind: "record", shapeId }; diff --git a/packages/compiler/src/frontend/lowering/builtins/timers.ts b/packages/compiler/src/frontend/lowering/builtins/timers.ts index d7cbd63b5..2d531663f 100644 --- a/packages/compiler/src/frontend/lowering/builtins/timers.ts +++ b/packages/compiler/src/frontend/lowering/builtins/timers.ts @@ -85,7 +85,7 @@ export function lowerTimersPromisesSetInterval( const genT = timersPromisesIntervalType(lowerer, expr); if (genT === null) lowerer.badType(expr, lowerer.typeOf(expr)); const yielded = lowerer.coerceInto(valueNode, value, genT.yieldT); - const fnName = lowerer.closureName(loc, "_tpInterval"); + const fnName = `%fn${lowerer.lambdaCounter++}_tpInterval`; const msParam: IrLocal = { id: "%tp.ms", name: "delay", type: F64, mutable: false }; const valueParam: IrLocal = { id: "%tp.value", name: "value", type: genT.yieldT, mutable: false }; const promiseVoid: IrType = { kind: "promise", inner: VOID }; diff --git a/packages/compiler/src/frontend/lowering/builtins/url.ts b/packages/compiler/src/frontend/lowering/builtins/url.ts index 2a77fa85c..dca8a7cc0 100644 --- a/packages/compiler/src/frontend/lowering/builtins/url.ts +++ b/packages/compiler/src/frontend/lowering/builtins/url.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "../stable-names.js"; import { nodeThrowExpr, countedFor, strLit, varRef, dynUndefinedExpr } from "../../../ir/build.js"; import * as ts from "../../ts7/adapter.js"; import { type Lowerer, own } from "../lowerer.js"; @@ -293,7 +292,7 @@ function searchParamsFromTuples( const key = `sp.fromTuples:${row.shapeId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%sp.fromTuples", key); + helper = `%sp.fromTuples.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, helper); const pairsT = init.type; const sp = (): IrExpr => varRef("sp.0", SEARCH_PARAMS_T, loc); @@ -373,7 +372,7 @@ function lowerOptionalStringSearchParams( const key = `sp.optionalString:${init.type.unionId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%sp.optionalString", key); + helper = `%sp.optionalString.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, helper); const value = varRef("init.0", init.type, loc); lowerer.liftedFns.push({ @@ -679,7 +678,7 @@ function lowerSpForEachCall( const key = `${arity}:${typeKey(fnRet)}`; let helper = lowerer.spHofHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%sp.forEach", key); + helper = `%sp.forEach.${lowerer.spHofHelpers.size}`; lowerer.spHofHelpers.set(key, helper); lowerer.liftedFns.push(buildSpForEachFn(helper, arity, fnRet, loc)); } diff --git a/packages/compiler/src/frontend/lowering/builtins/v8.ts b/packages/compiler/src/frontend/lowering/builtins/v8.ts index 989a61a3f..3582ce8ae 100644 --- a/packages/compiler/src/frontend/lowering/builtins/v8.ts +++ b/packages/compiler/src/frontend/lowering/builtins/v8.ts @@ -5,7 +5,6 @@ * spirit of process.memoryUsage(): approximate values, not V8 heap * figures (a compiled binary embeds no V8 engine). Every other member * fences at its use with the by-design reason (builtinFenceHintOf). */ -import { keyedHelperName } from "../stable-names.js"; import { numLit } from "../../../ir/build.js"; import * as ts from "../../ts7/adapter.js"; import { type Lowerer } from "../lowerer.js"; @@ -56,7 +55,7 @@ export function lowerV8HeapStatisticsCall( const key = `v8.getHeapStatistics:${t.shapeId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%v8.getHeapStatistics", key); + helper = `%v8.getHeapStatistics.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, helper); const sample = (index: number): IrExpr => ({ kind: "libCall", diff --git a/packages/compiler/src/frontend/lowering/call-arguments.ts b/packages/compiler/src/frontend/lowering/call-arguments.ts index 060ffe9d2..49f7c8ec0 100644 --- a/packages/compiler/src/frontend/lowering/call-arguments.ts +++ b/packages/compiler/src/frontend/lowering/call-arguments.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "./stable-names.js"; import { forwardedTupleType, pureForwardedValues, stripTypeWrappers } from "./typed-arguments.js"; import { dynUndefinedExpr } from "../../ir/build.js"; import { InternalCompilerError } from "../../errors.js"; @@ -754,7 +753,7 @@ function holeReadingLift(lowerer: Lowerer, from: IrType, to: IrType, loc: SrcLoc const key = `arr.holes:${typeKey(elem)}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, "%arr.holes", key); + const name = `%arr.holes.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); lowerer.liftedFns.push( buildArrayConversion( diff --git a/packages/compiler/src/frontend/lowering/call-signatures.ts b/packages/compiler/src/frontend/lowering/call-signatures.ts index dacb4d324..34343ad27 100644 --- a/packages/compiler/src/frontend/lowering/call-signatures.ts +++ b/packages/compiler/src/frontend/lowering/call-signatures.ts @@ -849,10 +849,7 @@ export function collectSignatureInner(lowerer: Lowerer, decl: ts.FunctionDeclara lowerer.genericFnsBySymbol.set(symbol, { decl, baseName: nameText, - qualifiedName: lowerer.qualify( - ts.getSourceFileOfNode(decl), - nsPathPrefix(lowerer, decl) + nameText, - ), + qualifiedName: lowerer.qualify(ts.getSourceFileOfNode(decl), nsPathPrefix(decl) + nameText), typeParams: [], instances: new Map(), implicitParams: implicit, @@ -900,7 +897,7 @@ export function collectSignatureInner(lowerer: Lowerer, decl: ts.FunctionDeclara // "%default" spelling ('%' cannot appear in a user identifier). name: lowerer.qualify( ts.getSourceFileOfNode(decl), - nsPathPrefix(lowerer, decl) + (decl.name?.text ?? "%default"), + nsPathPrefix(decl) + (decl.name?.text ?? "%default"), ), params, returnType, diff --git a/packages/compiler/src/frontend/lowering/class-assertions.ts b/packages/compiler/src/frontend/lowering/class-assertions.ts index 52654fab8..900c32426 100644 --- a/packages/compiler/src/frontend/lowering/class-assertions.ts +++ b/packages/compiler/src/frontend/lowering/class-assertions.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "./stable-names.js"; import { nodeThrowExpr, varRef } from "../../ir/build.js"; import { BOOL, @@ -123,7 +122,7 @@ export function checkedClassAssertion( const key = `classassert:${typeKey(source.type)}:${typeKey(target)}`; let name = lowerer.coercions.retags.get(key); if (!name) { - name = keyedHelperName(lowerer, "%class.assert", key); + name = `%class.assert.${lowerer.coercions.retags.size}`; lowerer.coercions.retags.set(key, name); const input = varRef("value.0", source.type, loc); const body: IrStmt[] = []; @@ -229,7 +228,7 @@ export function checkedClassUnionAssertion( const key = `classunionassert:${typeKey(value.type)}:${typeKey(target)}`; let name = lowerer.coercions.retags.get(key); if (!name) { - name = keyedHelperName(lowerer, "%class.assert", key); + name = `%class.assert.${lowerer.coercions.retags.size}`; lowerer.coercions.retags.set(key, name); const input = varRef("value.0", value.type, loc); const locals = [{ id: "value.0", name: "value", type: value.type, mutable: false }]; diff --git a/packages/compiler/src/frontend/lowering/class-unions.ts b/packages/compiler/src/frontend/lowering/class-unions.ts index 0021b2cf8..f52026ba4 100644 --- a/packages/compiler/src/frontend/lowering/class-unions.ts +++ b/packages/compiler/src/frontend/lowering/class-unions.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "./stable-names.js"; import * as ts from "../ts7/adapter.js"; import { BOOL, typeKey, type IrExpr, type IrStmt, type IrType } from "../../ir/ir.js"; import { nodeThrowExpr, varRef } from "../../ir/build.js"; @@ -133,7 +132,7 @@ export function narrowClassUnion( const key = `classUnion:${source.className}:${target.unionId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%class.union", key); + helper = `%class.union.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, helper); const input = varRef("value.0", source, loc); // Rank by ancestry before sorting: returning zero for unrelated pairs diff --git a/packages/compiler/src/frontend/lowering/coercions/function-adapters.ts b/packages/compiler/src/frontend/lowering/coercions/function-adapters.ts index fe3c14605..ffdac19f0 100644 --- a/packages/compiler/src/frontend/lowering/coercions/function-adapters.ts +++ b/packages/compiler/src/frontend/lowering/coercions/function-adapters.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "../stable-names.js"; import { dynUndefinedExpr } from "../../../ir/build.js"; import { buildFunctionAdapter } from "./builders.js"; import { InternalCompilerError } from "../../../errors.js"; @@ -34,7 +33,7 @@ export function funcReturnWidthAdapter( const key = `fn:${typeKey(fromT.ret.elem)}:${typeKey(toT.ret.elem)}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, "%fn.width", key); + const name = `%fn.width.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); lowerer.freshClosureAdapters.add(name); // The returned closure's body: call the captured original, width-map. @@ -164,7 +163,7 @@ function restPackingAdapter( const key = `fnrestadapt:${typeKey(fromT)}:${typeKey(toT)}`; const existing = lowerer.coercions.retags.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, "%fn.adapt", key); + const name = `%fn.adapt.${lowerer.coercions.retags.size}`; lowerer.coercions.retags.set(key, name); lowerer.freshClosureAdapters.add(name); const fixed = fromT.params.length - 1; @@ -221,7 +220,7 @@ function funcIntoDynRestAdapter( const key = `fnadapt:${typeKey(fromT)}:${typeKey(toT)}`; const existing = lowerer.coercions.retags.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, "%fn.adapt", key); + const name = `%fn.adapt.${lowerer.coercions.retags.size}`; lowerer.coercions.retags.set(key, name); lowerer.freshClosureAdapters.add(name); const params: IrParam[] = [{ localId: "rest.0", name: "args", type: DYN }]; @@ -377,7 +376,7 @@ export function funcCoerceAdapter( const key = `fnadapt:${typeKey(fromT)}:${typeKey(toT)}`; const existing = lowerer.coercions.retags.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, "%fn.adapt", key); + const name = `%fn.adapt.${lowerer.coercions.retags.size}`; lowerer.coercions.retags.set(key, name); lowerer.freshClosureAdapters.add(name); const params: IrParam[] = toT.params.map((t, i) => ({ @@ -605,7 +604,7 @@ export function spawnResFnAdapter( const key = `fnspawn:${typeKey(fromT)}:${typeKey(toT)}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, "%fnval.spawnres", key); + const name = `%fnval.spawnres.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); lowerer.freshClosureAdapters.add(name); const params: IrParam[] = toT.params.map((p, i) => ({ diff --git a/packages/compiler/src/frontend/lowering/coercions/structural.ts b/packages/compiler/src/frontend/lowering/coercions/structural.ts index 5b5e283b3..496a29607 100644 --- a/packages/compiler/src/frontend/lowering/coercions/structural.ts +++ b/packages/compiler/src/frontend/lowering/coercions/structural.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "../stable-names.js"; import { constructedValue } from "../constructor-returns.js"; import { dynUndefinedExpr, varRef } from "../../../ir/build.js"; import type { FieldLift } from "./structural-plans.js"; @@ -254,7 +253,7 @@ export function unionRecordWidthHelper( const key = `unionWidth:${fromId}:${target.shapeId}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, "%union.record", key); + const name = `%union.record.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); const type: IrType = { kind: "union", unionId: fromId }; const value = varRef("value.0", type, loc); @@ -313,7 +312,7 @@ export function recordWidthHelper( const key = `rec:${fromId}:${toId}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, "%rec.width", key); + const name = `%rec.width.${lowerer.valueHelpers.size}`; // Interned BEFORE the body builds: a recursive nested-width field // (self-referential shapes) resolves to this helper itself. lowerer.valueHelpers.set(key, name); @@ -342,7 +341,7 @@ export function tupleArrayWidthHelper( const key = `tuparr:${fromId}:${typeKey(toT.elem)}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, "%tup.arr", key); + const name = `%tup.arr.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); const fromT: IrType = { kind: "record", shapeId: fromId }; const t: IrExpr = { kind: "varRef", localId: "t.0", type: fromT, loc }; @@ -389,7 +388,7 @@ export function emptyArrayLiftHelper( const key = `emptyarr:${typeKey(fromT.elem)}:${typeKey(toT.elem)}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, "%arr.empty", key); + const name = `%arr.empty.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); const a: IrExpr = { kind: "varRef", localId: "a.0", type: fromT, loc }; lowerer.liftedFns.push({ @@ -453,7 +452,7 @@ export function arrayWidthHelper( const key = `arr:${typeKey(fromElem)}:${typeKey(toElem)}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, "%arr.width", key); + const name = `%arr.width.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); const arrT: IrType = { kind: "array", elem: fromElem }; const outT: IrType = { kind: "array", elem: toElem }; @@ -493,7 +492,7 @@ export function objRecordWidthHelper( const key = `obj:${className}:${toId}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, "%obj.width", key); + const name = `%obj.width.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); const fromT: IrType = { kind: "object", className }; lowerer.liftedFns.push(buildRecordProjection(lowerer, name, fromT, to, plan, loc)); @@ -518,7 +517,7 @@ export function recordClassWidthHelper( const key = `cls:${fromId}:${className}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, "%cls.width", key); + const name = `%cls.width.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); lowerer.noteEdge(`%${className}.constructor`); const fromT: IrType = { kind: "record", shapeId: fromId }; diff --git a/packages/compiler/src/frontend/lowering/coercions/unions.ts b/packages/compiler/src/frontend/lowering/coercions/unions.ts index 434e687a5..06c0af9c6 100644 --- a/packages/compiler/src/frontend/lowering/coercions/unions.ts +++ b/packages/compiler/src/frontend/lowering/coercions/unions.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "../stable-names.js"; import { buildUnionNarrow, unionNarrowFailureMessage } from "../union-narrow.js"; import { isSafeToRepeat } from "../expressions/evaluation-safety.js"; import { nodeThrowExpr } from "../../../ir/build.js"; @@ -148,7 +147,7 @@ export function strandedUnitTrap( const key = `strandunit:${typeKey(expected)}:${expr.type.kind}`; let name = lowerer.coercions.retags.get(key); if (!name) { - name = keyedHelperName(lowerer, "%unit.strand", key); + name = `%unit.strand.${lowerer.coercions.retags.size}`; lowerer.coercions.retags.set(key, name); lowerer.liftedFns.push({ name, @@ -228,7 +227,7 @@ export function strandedCoercionTrap( const key = `strand:${expected.unionId}:${typeKey(src)}`; let name = lowerer.coercions.retags.get(key); if (!name) { - name = keyedHelperName(lowerer, "%union.strand", key); + name = `%union.strand.${lowerer.coercions.retags.size}`; lowerer.coercions.retags.set(key, name); const toT: IrType = { kind: "union", unionId: expected.unionId }; lowerer.liftedFns.push({ @@ -276,7 +275,7 @@ export function recordUnionWrapHelper( const key = `recordWrap:${source.shapeId}:${toId}`; const existing = lowerer.coercions.retags.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, "%record.wrap", key); + const name = `%record.wrap.${lowerer.coercions.retags.size}`; lowerer.coercions.retags.set(key, name); lowerer.liftedFns.push( buildRecordUnionWrap(name, source, to, plan, loc, (lift, value, dst) => @@ -308,7 +307,7 @@ export function recordUnionRouteHelper( (from, dst) => lowerer.widthLiftPlan(from, dst), ); if (!plan) return null; - const name = keyedHelperName(lowerer, "%record.route", key); + const name = `%record.route.${lowerer.coercions.retags.size}`; lowerer.coercions.retags.set(key, name); lowerer.liftedFns.push( buildRecordUnionWrap(name, source, to, plan, loc, (lift, value, dst) => @@ -353,7 +352,7 @@ export function unionRetagHelper( }); const key = `${fromId}:${toId}:${stranded.join(".")}`; const existing = lowerer.coercions.retags.get(key); - const name = existing ?? keyedHelperName(lowerer, "%union.retag", key); + const name = existing ?? `%union.retag.${lowerer.coercions.retags.size}`; if (!existing) { lowerer.coercions.retags.set(key, name); lowerer.liftedFns.push( @@ -411,7 +410,7 @@ export function narrowedArmHelper( lowerer.coercions.checkedNarrows.add(existing); return existing; } - const name = keyedHelperName(lowerer, "%union.narrow", key); + const name = `%union.narrow.${lowerer.coercions.narrows.size}`; lowerer.coercions.narrows.set(key, name); lowerer.coercions.checkedNarrows.add(name); const fn = buildUnionNarrow(name, from, target, loc, (type) => lowerer.fmt(type)); @@ -588,7 +587,7 @@ export function deferredReadHelper( const key = `deferred:${fromId}:${tag}`; const existing = lowerer.coercions.narrows.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, "%deferred.read", key); + const name = `%deferred.read.${lowerer.coercions.narrows.size}`; lowerer.coercions.narrows.set(key, name); const dflt: IrExpr = target.kind === "bool" diff --git a/packages/compiler/src/frontend/lowering/collection-ingestion.ts b/packages/compiler/src/frontend/lowering/collection-ingestion.ts index 8fe2a6bbb..5d14d5492 100644 --- a/packages/compiler/src/frontend/lowering/collection-ingestion.ts +++ b/packages/compiler/src/frontend/lowering/collection-ingestion.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "./stable-names.js"; import * as ts from "../ts7/adapter.js"; import { InternalCompilerError } from "../../errors.js"; import { typeKey } from "../type-mapper.js"; @@ -198,7 +197,7 @@ export function ingestCollection( const key = `ingest:${input.collection ? typeKey(input.collection) + ":" + input.selection : "cursor:" + typeKey(input.element)}:${typeKey(destination)}:${mapper ? typeKey(mapper.type) : "copy"}`; let name = lowerer.arrHofHelpers.get(key); if (!name) { - name = keyedHelperName(lowerer, "%collection.ingest", key); + name = `%collection.ingest.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, name); const context = newFnCtx(false, null, null, destination); lowerer.fnStack.push(context); diff --git a/packages/compiler/src/frontend/lowering/containers/array-callbacks.ts b/packages/compiler/src/frontend/lowering/containers/array-callbacks.ts index 7ca69d9ba..eb99592bb 100644 --- a/packages/compiler/src/frontend/lowering/containers/array-callbacks.ts +++ b/packages/compiler/src/frontend/lowering/containers/array-callbacks.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "../stable-names.js"; import { boolLit, countedFor, numLit, varRef } from "../../../ir/build.js"; import { transformStmtList } from "../../../ir/traverse.js"; import type { ScrDiagnostic } from "../../../diagnostics/diagnostic.js"; @@ -507,7 +506,7 @@ function arrayHofHelper( const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}:${typeKey(outElem)}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, `%arr.${method}`, key); + const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, name); lowerer.arrHofInfo.set(name, { method, elem, fnRet, arity, outElem, present, split: !!fastT }); const fn = buildArrayHofFn( @@ -620,7 +619,7 @@ function arrayUnionHofHelper( const key = `union:${method}:${receiverT.unionId}:${typeKey(callbackT)}:${typeKey(resultT)}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, "%arr.union", key); + const name = `%arr.union.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, name); const receiver = varRef("a.0", receiverT, loc); const callback = varRef("f.0", callbackT, loc); @@ -1205,7 +1204,7 @@ function findHelper( const key = `${method}:${typeKey(elem)}:${typeKey(resultT)}:${typeKey(fnRet)}:${arity}${site}${present ? ":present" : ""}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, `%arr.${method}`, key); + const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, name); const arrT = arrayOf(elem); const valueT = callbackValueType(lowerer, elem, present); @@ -1305,7 +1304,7 @@ function findIndexHelper( const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, `%arr.${method}`, key); + const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, name); if (!last) lowerer.arrHofInfo.set(name, { @@ -1389,7 +1388,7 @@ function someEveryHelper( const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, `%arr.${method}`, key); + const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, name); lowerer.arrHofInfo.set(name, { method, @@ -1588,7 +1587,7 @@ function flatMapHelper( const key = `flatMap:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, "%arr.flatMap", key); + const name = `%arr.flatMap.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, name); lowerer.arrHofInfo.set(name, { method: "flatMapArray", @@ -1830,7 +1829,7 @@ function reduceHelper( const key = `${method}:${typeKey(elem)}:${typeKey(accT)}:${typeKey(fnRet)}:${arity}:${hasInit ? "init" : "seed"}${site}${fastT ? ":split" : ""}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, `%arr.${method}`, key); + const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, name); if (method === "reduce") lowerer.arrHofInfo.set(name, { @@ -2122,7 +2121,7 @@ export function lowerArraySortCall( const key = `${method}:${typeKey(elem)}:${arity}${native ? ":native" : ""}${keyed ? `:keyed${order}${reads ? `:field${reads.length}` : ""}` : ""}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, `%arr.${method}`, key); + helper = `%arr.${method}.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, helper); const undefinedTag = elem.kind === "union" ? lowerer.armTag(elem.unionId, UNDEFINED_T) : -1; lowerer.liftedFns.push( @@ -2168,7 +2167,7 @@ function sortKeyReader( const cacheKey = `sortKey:${typeKey(elem)}:${sortKeysId(reads.map((read) => ({ order: 1, read })))}`; let reader = lowerer.arrHofHelpers.get(cacheKey); if (!reader) { - reader = keyedHelperName(lowerer, "%arr.sortKey", cacheKey); + reader = `%arr.sortKey.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(cacheKey, reader); lowerer.liftedFns.push(buildSortKeyFn(reader, elem, reads, loc)); } @@ -2309,7 +2308,7 @@ function dynFlatMapHelper(lowerer: Lowerer, elemT: IrType, arity: number, loc: S const key = `dynflatmap:${typeKey(elemT)}:${arity}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, "%dyn.flatmap", key); + const name = `%dyn.flatmap.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, name); lowerer.liftedFns.push(buildDynFlatMapFn(name, elemT, arity, loc)); return name; @@ -2482,7 +2481,7 @@ function dynFilterHelper(lowerer: Lowerer, elemT: IrType, arity: number, loc: Sr const key = `dynfilter:${typeKey(elemT)}:${arity}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, "%dyn.filter", key); + const name = `%dyn.filter.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, name); lowerer.liftedFns.push(buildDynFilterFn(name, elemT, arity, loc)); return name; @@ -2677,7 +2676,7 @@ export function lowerTuplePredicateCall( const key = `tuple.${method}:${typeKey(receiver.type)}:${typeKey(fnArg.type)}:${typeKey(resultT)}:${arity}${callbackSite(fnArg)}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, `%tuple.${method}`, key); + helper = `%tuple.${method}.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, helper); const v = varRef("v.0", elem, loc); const out = varRef("out.0", resultT, loc); diff --git a/packages/compiler/src/frontend/lowering/containers/array-concat.ts b/packages/compiler/src/frontend/lowering/containers/array-concat.ts index b4e285ee9..4f6e4ca43 100644 --- a/packages/compiler/src/frontend/lowering/containers/array-concat.ts +++ b/packages/compiler/src/frontend/lowering/containers/array-concat.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "../stable-names.js"; import { identityPreservingWidening } from "../coercions/identity.js"; import { countedFor, numLit, varRef } from "../../../ir/build.js"; import { @@ -29,7 +28,7 @@ export function arrayConcatHelper( const key = `concat:${typeKey(elem)}:${shape.map((type) => (type ? `a:${typeKey(type)}` : "e")).join(";")}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, "%arr.concat", key); + const name = `%arr.concat.${lowerer.arrHofHelpers.size}`; const arrT = arrayOf(elem); const params = [ { localId: "a.0", name: "a", type: arrT }, diff --git a/packages/compiler/src/frontend/lowering/containers/array-construction.ts b/packages/compiler/src/frontend/lowering/containers/array-construction.ts index 1f10640c0..40e4d6436 100644 --- a/packages/compiler/src/frontend/lowering/containers/array-construction.ts +++ b/packages/compiler/src/frontend/lowering/containers/array-construction.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "../stable-names.js"; import { generatorDrain } from "../iterator-adapters.js"; import { identityPreservingWidening } from "../coercions/identity.js"; import { liftedFreshSpread } from "../coercions/fresh-spread.js"; @@ -257,7 +256,7 @@ function appendWidenedArrayValues( const key = `insertValues:${typeKey(sourceType.elem)}:${typeKey(elem)}`; let name = lowerer.arrHofHelpers.get(key); if (!name) { - name = keyedHelperName(lowerer, "%arr.insertValues", key); + name = `%arr.insertValues.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, name); const outType = arrayOf(elem); const valueType = arrayValueType(lowerer, source.type.elem); @@ -1036,7 +1035,7 @@ export function lowerArrayFromCall( const key = `fromArray:${typeKey(arrT.elem)}:${typeKey(outElem)}:${typeKey(fnRet)}:${arity}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%arr.fromArray", key); + helper = `%arr.fromArray.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, helper); lowerer.liftedFns.push( buildArrayFromArrayFn(lowerer, helper, arrT.elem, outElem, fnRet, arity, loc), @@ -1123,7 +1122,7 @@ export function lowerArrayFromCall( const key = `fromLen:${typeKey(fnRet)}:${arity}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%arr.fromLen", key); + helper = `%arr.fromLen.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, helper); lowerer.liftedFns.push(buildArrayFromLenFn(helper, fnRet, arity, loc)); } diff --git a/packages/compiler/src/frontend/lowering/containers/array-methods.ts b/packages/compiler/src/frontend/lowering/containers/array-methods.ts index 44182fbda..e9a130a2d 100644 --- a/packages/compiler/src/frontend/lowering/containers/array-methods.ts +++ b/packages/compiler/src/frontend/lowering/containers/array-methods.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "../stable-names.js"; import { liftedFreshSpread } from "../coercions/fresh-spread.js"; import { lowerArrayIteratorValue } from "../iterator-adapters.js"; import { identityPreservingWidening } from "../coercions/identity.js"; @@ -1617,7 +1616,7 @@ function arraySearchHelper( const key = `${method}:${typeKey(elem)}:${typeKey(valueT)}:${typeKey(needleT)}:${directNeedle}:${typeKey(fromT)}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, `%arr.${method}`, key); + const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, name); const arrT = arrayOf(elem); const resultT = method === "includes" ? BOOL : F64; @@ -1973,7 +1972,7 @@ export function lowerTupleReadMethodCall( let helper = lowerer.arrHofHelpers.get(key); const resultType = method === "includes" ? BOOL : F64; if (!helper) { - helper = keyedHelperName(lowerer, `%tuple.${method}`, key); + helper = `%tuple.${method}.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, helper); const params = [ { localId: "a.0", name: "a", type: receiver.type }, @@ -2035,7 +2034,7 @@ export function lowerTupleReadMethodCall( const key = `tuple.slice:${typeKey(receiver.type)}:${args.length}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%tuple.slice", key); + helper = `%tuple.slice.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, helper); const params = [receiver, ...args].map((arg, i) => ({ localId: i === 0 ? "a.0" : `arg.${i}`, @@ -2126,7 +2125,7 @@ export function lowerTupleReadMethodCall( const key = `tuple.${method}:${typeKey(receiver.type)}:${typeKey(fnArg.type)}:${typeKey(outElem)}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, `%tuple.${method}`, key); + helper = `%tuple.${method}.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, helper); const out = varRef("out.0", outType, loc); const result = varRef("r.0", ret, loc); @@ -2254,7 +2253,7 @@ function lowerArrayAtCall( const key = `at:${typeKey(elem)}:${typeKey(resultT)}:${typeKey(index.type)}`; let name = lowerer.arrHofHelpers.get(key); if (!name) { - name = keyedHelperName(lowerer, "%arr.at", key); + name = `%arr.at.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, name); const arrT = arrayOf(elem); diff --git a/packages/compiler/src/frontend/lowering/containers/array-pipelines.ts b/packages/compiler/src/frontend/lowering/containers/array-pipelines.ts index 180f40435..cf45a7575 100644 --- a/packages/compiler/src/frontend/lowering/containers/array-pipelines.ts +++ b/packages/compiler/src/frontend/lowering/containers/array-pipelines.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "../stable-names.js"; import { boolLit, countedFor, numLit, varRef } from "../../../ir/build.js"; import { BOOL, @@ -852,7 +851,7 @@ class PipelineFusion { if (!built) return null; let name = this.helpers.get(built.key); if (!name) { - name = keyedHelperName(this.lowerer, "%arr.fused", built.key); + name = `%arr.fused.${this.helpers.size}`; this.helpers.set(built.key, name); this.added.push({ ...built.fn, name }); } diff --git a/packages/compiler/src/frontend/lowering/containers/bytes.ts b/packages/compiler/src/frontend/lowering/containers/bytes.ts index 4b20d7bf5..bf9821d31 100644 --- a/packages/compiler/src/frontend/lowering/containers/bytes.ts +++ b/packages/compiler/src/frontend/lowering/containers/bytes.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "../stable-names.js"; import { boolLit, dynUndefinedExpr, numLit, varRef } from "../../../ir/build.js"; import { BUF_NUM_METHODS } from "./buffer-numeric-methods.js"; import * as ts from "../../ts7/adapter.js"; @@ -78,7 +77,7 @@ function lowerBytesSortCall( const cacheKey = `bytes.${method}:${bytesT.elem}:${key}`; let helper = lowerer.arrHofHelpers.get(cacheKey); if (!helper) { - helper = keyedHelperName(lowerer, `%bytes.${method}`, cacheKey); + helper = `%bytes.${method}.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(cacheKey, helper); lowerer.liftedFns.push( buildBytesSortFn(helper, bytesT, arity, hasComparator, copyFirst, order, loc), @@ -271,7 +270,7 @@ function bytesCallbackHelper( const key = `bytes.${method}:${bytesT.elem}:${typeKey(resultT)}:${typeKey(fnRet)}:${arity}:${hasInit ? "init" : ""}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, `%bytes.${method}`, key); + const name = `%bytes.${method}.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, name); const reduce = method === "reduce" || method === "reduceRight"; const backward = method === "reduceRight" || method === "findLast" || method === "findLastIndex"; diff --git a/packages/compiler/src/frontend/lowering/containers/callback-arguments.ts b/packages/compiler/src/frontend/lowering/containers/callback-arguments.ts index f39c8e86c..18754f088 100644 --- a/packages/compiler/src/frontend/lowering/containers/callback-arguments.ts +++ b/packages/compiler/src/frontend/lowering/containers/callback-arguments.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "../stable-names.js"; import * as ts from "../../ts7/adapter.js"; import type { Lowerer } from "../lowerer.js"; import { isJsSourceFile, locOf } from "../../program.js"; @@ -286,7 +285,7 @@ export function truthyFilterCallback( const key = `filterBoolean:${typeKey(valueT)}`; let name = lowerer.arrHofHelpers.get(key); if (!name) { - name = keyedHelperName(lowerer, "%arr.filterBoolean", key); + name = `%arr.filterBoolean.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, name); const value = varRef("v.0", valueT, loc); lowerer.liftedFns.push({ diff --git a/packages/compiler/src/frontend/lowering/containers/collection-grouping.ts b/packages/compiler/src/frontend/lowering/containers/collection-grouping.ts index dae68d518..0bf126830 100644 --- a/packages/compiler/src/frontend/lowering/containers/collection-grouping.ts +++ b/packages/compiler/src/frontend/lowering/containers/collection-grouping.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "../stable-names.js"; import { countedFor, numLit, varRef } from "../../../ir/build.js"; import * as ts from "../../ts7/adapter.js"; import type { Lowerer } from "../lowerer.js"; @@ -105,7 +104,7 @@ export function lowerGroupByStaticCall( const key = `map.groupBy:${typeKey(items.type)}:${typeKey(f.type)}`; let helper = lowerer.mapHofHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%map.groupBy", key); + helper = `%map.groupBy.${lowerer.mapHofHelpers.size}`; lowerer.mapHofHelpers.set(key, helper); lowerer.liftedFns.push(buildGroupByFn(lowerer, helper, items.type, f.type, resultT, loc)); } @@ -142,7 +141,7 @@ export function lowerGroupByStaticCall( const key = `object.groupBy:${typeKey(items.type)}:${typeKey(f.type)}`; let helper = lowerer.mapHofHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%object.groupBy", key); + helper = `%object.groupBy.${lowerer.mapHofHelpers.size}`; lowerer.mapHofHelpers.set(key, helper); lowerer.liftedFns.push(buildGroupByFn(lowerer, helper, items.type, f.type, resultT, loc)); } diff --git a/packages/compiler/src/frontend/lowering/containers/collection-methods.ts b/packages/compiler/src/frontend/lowering/containers/collection-methods.ts index d3169ec5c..370974c85 100644 --- a/packages/compiler/src/frontend/lowering/containers/collection-methods.ts +++ b/packages/compiler/src/frontend/lowering/containers/collection-methods.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "../stable-names.js"; import { nodeThrowExpr, boolLit, countedFor, numLit, strLit, varRef } from "../../../ir/build.js"; import { InternalCompilerError } from "../../../errors.js"; import * as ts from "../../ts7/adapter.js"; @@ -233,7 +232,7 @@ function lowerMapIterDrainCall( const key = `${method}:${typeKey(mapT.key)}:${typeKey(mapT.value)}`; let helper = lowerer.mapHofHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, `%map.${method}`, key); + helper = `%map.${method}.${lowerer.mapHofHelpers.size}`; lowerer.mapHofHelpers.set(key, helper); lowerer.liftedFns.push(buildMapIterDrainFn(helper, mapT, method, elemT, tupleT, loc)); } @@ -349,7 +348,7 @@ export function mapEntriesArray(lowerer: Lowerer, receiver: IrExpr): IrExpr { const key = `entries:${typeKey(mapT.key)}:${typeKey(mapT.value)}`; let helper = lowerer.mapHofHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%map.entries", key); + helper = `%map.entries.${lowerer.mapHofHelpers.size}`; lowerer.mapHofHelpers.set(key, helper); lowerer.liftedFns.push( buildMapIterDrainFn(helper, mapT, "entries", tupleT, tupleT, receiver.loc), @@ -520,7 +519,7 @@ export function lowerMapForEachCall( const key = `${typeKey(mapT.key)}:${typeKey(mapT.value)}:${arity}:${typeKey(fnRet)}`; let helper = lowerer.mapHofHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%map.forEach", key); + helper = `%map.forEach.${lowerer.mapHofHelpers.size}`; lowerer.mapHofHelpers.set(key, helper); lowerer.liftedFns.push(buildCollectionForEachFn(helper, mapT, arity, fnRet, loc)); } @@ -694,7 +693,7 @@ export function lowerSetForEachCall( const key = `${typeKey(setT.elem)}:${arity}:${typeKey(fnRet)}`; let helper = lowerer.setHofHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%set.forEach", key); + helper = `%set.forEach.${lowerer.setHofHelpers.size}`; lowerer.setHofHelpers.set(key, helper); lowerer.liftedFns.push(buildCollectionForEachFn(helper, setT, arity, fnRet, loc)); } @@ -746,7 +745,7 @@ function lowerSetCombineCall( const key = `${name}:${typeKey(setT.elem)}:${typeKey(otherT)}`; let helper = lowerer.setHofHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, `%set.${name}`, key); + helper = `%set.${name}.${lowerer.setHofHelpers.size}`; lowerer.setHofHelpers.set(key, helper); lowerer.liftedFns.push(buildSetCombineFn(helper, name, setT, otherT, loc)); } @@ -1358,7 +1357,7 @@ export function mapFromSeedValue( const key = `checked-seed:${typeKey(mapT)}`; let name = lowerer.mapHofHelpers.get(key); if (!name) { - name = keyedHelperName(lowerer, "%map.checkedSeed", key); + name = `%map.checkedSeed.${lowerer.mapHofHelpers.size}`; lowerer.mapHofHelpers.set(key, name); const source = varRef("source.0", DYN, loc); const entries = varRef("entries.0", DYN, loc); @@ -1458,7 +1457,7 @@ export function mapFromSeedValue( const key = `seed:${typeKey(mapT.key)}:${typeKey(mapT.value)}:${elem.shapeId}`; let helper = lowerer.mapHofHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%map.seed", key); + helper = `%map.seed.${lowerer.mapHofHelpers.size}`; lowerer.mapHofHelpers.set(key, helper); lowerer.liftedFns.push(buildMapSeedFn(mapT, helper, seed.type, elem, kT, vT, loc)); } diff --git a/packages/compiler/src/frontend/lowering/containers/indexed-objects.ts b/packages/compiler/src/frontend/lowering/containers/indexed-objects.ts index b3faf649e..efc173ffc 100644 --- a/packages/compiler/src/frontend/lowering/containers/indexed-objects.ts +++ b/packages/compiler/src/frontend/lowering/containers/indexed-objects.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "../stable-names.js"; import { nullProtoRecordShape, recordNullProtoTest } from "../null-prototype.js"; import { countedFor, numLit, varRef } from "../../../ir/build.js"; import { objectEnumerationReceiver } from "../object-enumeration-receiver.js"; @@ -185,7 +184,7 @@ export function objectIterOverIndexShape( const key = `obj.${member}:ovf:${argIr.shapeId}:${typeKey(resultT)}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, `%obj.${member}`, key); + helper = `%obj.${member}.${lowerer.arrHofHelpers.size}`; const outRef = varRef("out.0", resultT, loc); const rRef = varRef("r.0", argIr, loc); @@ -609,7 +608,7 @@ function lowerTypedObjectFromEntriesCall( const key = `obj.fromEntries:${argIr.elem.shapeId}:${resultT.shapeId}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%obj.fromEntries", key); + helper = `%obj.fromEntries.${lowerer.arrHofHelpers.size}`; const tupleT = argIr.elem as IrType & { kind: "record" }; const tRef = varRef("t.0", tupleT, loc); @@ -713,7 +712,7 @@ function lowerFromEntriesStringRows( const key = `obj.fromEntries:strrows:${resultT.shapeId}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%obj.fromEntries", key); + helper = `%obj.fromEntries.${lowerer.arrHofHelpers.size}`; const tRef = varRef("t.0", rowT, loc); const rowLen: IrExpr = { @@ -932,7 +931,7 @@ export function lowerRecordOvfCaptureHelper( const key = `ovf:${fromId}:${toId}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, "%rec.capture", key); + const name = `%rec.capture.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); const fromT: IrType = { kind: "record", shapeId: fromId }; const toT: IrType = { kind: "record", shapeId: toId }; @@ -1205,7 +1204,7 @@ export function lowerObjectAssignIndexShape( const key = `assign:${targetIr.shapeId}:${plan.fromId}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, "%obj.assign", key); + const name = `%obj.assign.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); const toT: IrType = { kind: "record", shapeId: targetIr.shapeId }; const fromT: IrType = { kind: "record", shapeId: plan.fromId }; @@ -1475,7 +1474,7 @@ export function lowerIndexMergeHelper( .join(","); const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, "%rec.merge", key); + const name = `%rec.merge.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); const toT: IrType = { kind: "record", shapeId: toId }; const ksT = arrayOf(STRING); @@ -1806,7 +1805,7 @@ export function lowerEnvToPairsHelper( const key = `env.pairs:${shapeId}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, "%env.pairs", key); + const name = `%env.pairs.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); const recT: IrType = { kind: "record", shapeId }; const arrT = arrayOf(STRING); diff --git a/packages/compiler/src/frontend/lowering/containers/iterator-helpers.ts b/packages/compiler/src/frontend/lowering/containers/iterator-helpers.ts index 48b4caabd..c23e6931c 100644 --- a/packages/compiler/src/frontend/lowering/containers/iterator-helpers.ts +++ b/packages/compiler/src/frontend/lowering/containers/iterator-helpers.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "../stable-names.js"; import { boolLit, numLit, varRef } from "../../../ir/build.js"; import { InternalCompilerError } from "../../../errors.js"; import * as ts from "../../ts7/adapter.js"; @@ -967,7 +966,7 @@ function lowerFusedChain( const key = `iter:${srcKey}:${stageKeys.join(",")}:${terminal}:${termArgs.map((a) => typeKey(a.type)).join(",")}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, `%iter.${terminal}`, key); + helper = `%iter.${terminal}.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, helper); lowerer.liftedFns.push( buildIterChainFn( @@ -1039,7 +1038,7 @@ function lowerHelperObject( const key = `iterHelper:${stage.kind}:${srcKey}:${typeKey(srcElem)}:${typeKey(arg.type)}:${typeKey(outT)}`; let name = lowerer.arrHofHelpers.get(key); if (!name) { - name = keyedHelperName(lowerer, `%iter.${stage.kind}`, key); + name = `%iter.${stage.kind}.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, name); lowerer.liftedFns.push( buildHelperGenFn(lowerer, name, source, srcElem, stage, arg.type, outT, resultType, loc), @@ -1059,7 +1058,7 @@ function internBudgetChecker(lowerer: Lowerer, loc: SrcLoc, srcT: GenType | null const key = srcT === null ? "iter:budget" : `iter:budget:close:${typeKey(srcT)}`; let name = lowerer.arrHofHelpers.get(key); if (name !== undefined) return name; - name = srcT === null ? "%iter.budget" : keyedHelperName(lowerer, "%iter.budget.close", key); + name = srcT === null ? "%iter.budget" : `%iter.budget.close.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, name); const v = (): IrExpr => ({ kind: "varRef", localId: "v.0", type: F64, loc }); diff --git a/packages/compiler/src/frontend/lowering/containers/string-and-regexp.ts b/packages/compiler/src/frontend/lowering/containers/string-and-regexp.ts index fe4ddbc6c..9567ee0f6 100644 --- a/packages/compiler/src/frontend/lowering/containers/string-and-regexp.ts +++ b/packages/compiler/src/frontend/lowering/containers/string-and-regexp.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "../stable-names.js"; import { matchAllRowsReadByElements } from "./match-row-uses.js"; import { boolLit, @@ -160,7 +159,7 @@ export function lowerStringSplitCall( const key = `str.split:${receiver.type.kind === "union" ? typeKey(receiver.type) : receiver.type.kind}:${typeKey(separator.type)}:${typeKey(limit.type)}:${absent}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%str.split", key); + helper = `%str.split.${lowerer.valueHelpers.size}`; const values = [receiver, separator, limit]; const params = values.map((value, index) => ({ localId: `arg.${index}`, @@ -396,7 +395,7 @@ function stringIndexHelperCall( const key = `str.index:${method}:${typeKey(receiver.type)}:${typeKey(index.type)}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%str.index", key); + helper = `%str.index.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, helper); const rawReceiver = varRef("arg.0", receiver.type, loc); const rawIndex = varRef("arg.1", index.type, loc); @@ -674,7 +673,7 @@ export function lowerStringPaddingCall( const key = `str.pad:${method}:${values.map((value) => typeKey(value.type)).join(":")}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%str.pad", key); + helper = `%str.pad.${lowerer.valueHelpers.size}`; const params = values.map((value, index) => ({ localId: `arg.${index}`, name: `arg${index}`, @@ -1310,7 +1309,7 @@ export function lowerStringMethodCall( const key = `str.positions:${entry.method}:${typeKey(needle.type)}:${typeKey(position.type)}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%str.positions", key); + helper = `%str.positions.${lowerer.valueHelpers.size}`; const params = [receiver, needle, position].map((arg, index) => ({ localId: `arg.${index}`, name: `arg${index}`, @@ -1412,7 +1411,7 @@ export function lowerStringMethodCall( const key = `str.positions:${entry.method}:${args.map((arg) => typeKey(arg.type)).join(":")}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%str.positions", key); + helper = `%str.positions.${lowerer.valueHelpers.size}`; const params = [receiver, ...args].map((arg, index) => ({ localId: `arg.${index}`, name: `arg${index}`, diff --git a/packages/compiler/src/frontend/lowering/containers/string-replacement.ts b/packages/compiler/src/frontend/lowering/containers/string-replacement.ts index 780c77d0f..6856bc50b 100644 --- a/packages/compiler/src/frontend/lowering/containers/string-replacement.ts +++ b/packages/compiler/src/frontend/lowering/containers/string-replacement.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "../stable-names.js"; import * as ts from "../../ts7/adapter.js"; import { BOOL, @@ -163,7 +162,7 @@ function lowerStringReplacementValues( const key = `str.${method}:${typeKey(replacement.type)}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, `%str.${method}`, key); + helper = `%str.${method}.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, helper); const subject = varRef("s.0", STRING, loc); const needle = varRef("search.0", STRING, loc); diff --git a/packages/compiler/src/frontend/lowering/expressions/binary.ts b/packages/compiler/src/frontend/lowering/expressions/binary.ts index 7e449f12b..fafbbf695 100644 --- a/packages/compiler/src/frontend/lowering/expressions/binary.ts +++ b/packages/compiler/src/frontend/lowering/expressions/binary.ts @@ -1,5 +1,4 @@ /* Binary operators: arithmetic, comparisons and equality, logical and nullish pairs, and string conversion for concatenation. */ -import { keyedHelperName } from "../stable-names.js"; import * as ts from "../../ts7/adapter.js"; import { cleanFuncAdaptable } from "../coercions/function-adapters.js"; import { type Lowerer, jsFuncNameOf } from "../lowerer.js"; @@ -802,7 +801,7 @@ function nullProtoToString(lowerer: Lowerer, e: IrExpr, t: IrType & { kind: "rec const key = `nullProtoToString:${t.shapeId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%rec.tostr", key); + helper = `%rec.tostr.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, helper); const r = varRef("r.0", t, loc); lowerer.liftedFns.push({ diff --git a/packages/compiler/src/frontend/lowering/expressions/object-literals.ts b/packages/compiler/src/frontend/lowering/expressions/object-literals.ts index 93bf43e95..565db0cd8 100644 --- a/packages/compiler/src/frontend/lowering/expressions/object-literals.ts +++ b/packages/compiler/src/frontend/lowering/expressions/object-literals.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "../stable-names.js"; import { dateJsonType, isDateJsonSource } from "../builtins/dates.js"; import { dynUndefinedExpr, numLit, strLit, varRef } from "../../../ir/build.js"; import { pathModuleValue } from "../lower-builtin-values.js"; @@ -407,7 +406,7 @@ export function lowerDynObjectLiteral( if (!(err instanceof PoisonError) || !pureMember) throw err; const fence = lowerer.deferToRuntimeFence(propDiagsBefore, prop, { kind: "closure", - name: () => lowerer.closureName(loc, "_dynfence"), + name: () => `%fn${lowerer.lambdaCounter++}_dynfence`, returnType: VOID, type: { kind: "func", params: [], ret: VOID }, }); @@ -462,7 +461,7 @@ export function lowerDynObjectLiteral( if (!(err instanceof PoisonError)) throw err; const fence = lowerer.deferToRuntimeFence(convDiagsBefore, prop, { kind: "closure", - name: () => lowerer.closureName(loc, "_dynfence"), + name: () => `%fn${lowerer.lambdaCounter++}_dynfence`, returnType: VOID, type: { kind: "func", params: [], ret: VOID }, }); @@ -2957,7 +2956,7 @@ function lowerDeclaredSpreadMerge( const key = `declmerge-source:${type.shapeId}:${source.shapeId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%rec.declmerge", key); + helper = `%rec.declmerge.${lowerer.valueHelpers.size}`; const sourceType = source.value.type; const destination = varRef("out.0", type, loc); const receiver = varRef("source.0", sourceType, loc); diff --git a/packages/compiler/src/frontend/lowering/expressions/optional-chains.ts b/packages/compiler/src/frontend/lowering/expressions/optional-chains.ts index 4b8c5692a..fbcecdc32 100644 --- a/packages/compiler/src/frontend/lowering/expressions/optional-chains.ts +++ b/packages/compiler/src/frontend/lowering/expressions/optional-chains.ts @@ -240,7 +240,7 @@ export function lowerOptionalChain( const receiver = lowerer.runtimeOptionalSourceValue(recvNode, loweredReceiver) ?? loweredReceiver; if (receiver.type.kind === "dyn") { if (dotNode === expr && ts.isCallExpression(expr)) { - const id = lowerer.closureName(loc, "", "chain"); + const id = `chain.${lowerer.chainCounter++}`; const callee: IrExpr = { kind: "chainRecv", id, type: DYN, loc }; const stmts: IrStmt[] = []; let guarded = receiver; @@ -298,7 +298,7 @@ export function lowerOptionalChain( ); } if (dotNode === expr && ts.isElementAccessExpression(expr)) { - const id = lowerer.closureName(loc, "", "chain"); + const id = `chain.${lowerer.chainCounter++}`; const reference: IrExpr = { kind: "chainRecv", id, type: DYN, loc }; lowerer.chainRecvByNode.set(recvNode, reference); lowerer.chainHandled.add(dotNode); @@ -331,7 +331,7 @@ export function lowerOptionalChain( dotNode === expr.expression ) { const m = dotNode.name.text; - const id = lowerer.closureName(loc, "", "chain"); + const id = `chain.${lowerer.chainCounter++}`; const recvRef: IrExpr = { kind: "chainRecv", id, type: DYN, loc: locOf(recvNode) }; lowerer.chainRecvByNode.set(recvNode, recvRef); lowerer.chainHandled.add(dotNode); @@ -358,7 +358,7 @@ export function lowerOptionalChain( } return { kind: "optChain", id, receiver, body, type: DYN, loc }; } - const id = lowerer.closureName(loc, "", "chain"); + const id = `chain.${lowerer.chainCounter++}`; const reference: IrExpr = { kind: "chainRecv", id, type: DYN, loc }; lowerer.chainRecvByNode.set(recvNode, reference); lowerer.chainHandled.add(dotNode); @@ -420,7 +420,7 @@ export function lowerOptionalChain( rest.length === 1 ? rest[0]! : { kind: "union" as const, unionId: lowerer.unions.transform(def, rest) }; - const id = lowerer.closureName(loc, "", "chain"); + const id = `chain.${lowerer.chainCounter++}`; // A single present arm binds its payload. Multiple present arms bind // the original tagged value, then retag inside the guarded body. The // nullish arms never enter that body, and each record keeps its identity. diff --git a/packages/compiler/src/frontend/lowering/expressions/property-access.ts b/packages/compiler/src/frontend/lowering/expressions/property-access.ts index 6c8dfa3bf..f0b980da0 100644 --- a/packages/compiler/src/frontend/lowering/expressions/property-access.ts +++ b/packages/compiler/src/frontend/lowering/expressions/property-access.ts @@ -1,5 +1,4 @@ /* Property reads (`a.b`): lowerExprInner's property-access branch, intrinsic and union properties, field reads and targets, and match-group reads. */ -import { keyedHelperName } from "../stable-names.js"; import { staticallySelected } from "../static-typeof.js"; import * as ts from "../../ts7/adapter.js"; import { lowerHistogramProperty } from "../builtins/performance.js"; @@ -2784,7 +2783,7 @@ export function lowerGroupsProjection( const key = `regexgroups:${shapeId}:${groups.map((g) => `${g.name}=${g.index}`).join(",")}:${recvKey}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%regex.groups", key); + helper = `%regex.groups.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, helper); const body: IrStmt[] = []; const locals: IrLocal[] = [{ id: "m.0", name: "m", type: recv.type, mutable: true }]; diff --git a/packages/compiler/src/frontend/lowering/expressions/relational.ts b/packages/compiler/src/frontend/lowering/expressions/relational.ts index 836391835..088b45cff 100644 --- a/packages/compiler/src/frontend/lowering/expressions/relational.ts +++ b/packages/compiler/src/frontend/lowering/expressions/relational.ts @@ -1,5 +1,4 @@ /* instanceof and in, including private-name and runtime-key in. */ -import { keyedHelperName } from "../stable-names.js"; import * as ts from "../../ts7/adapter.js"; import { builtinClassInstanceOfAny, builtinClassKind } from "../builtins/builtin-class-dyn.js"; import { @@ -648,7 +647,7 @@ export function lowerInstanceOf(lowerer: Lowerer, expr: ts.BinaryExpression, loc const key = `instanceof.union:${unionId}:${target.def.name}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%instanceof.union", key); + helper = `%instanceof.union.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, helper); const value: IrExpr = { kind: "varRef", localId: "value.0", type: left.type, loc }; const body: IrStmt[] = []; @@ -1848,7 +1847,7 @@ function lowerRuntimeKeyIn( const hkey = `haskey:${recvT.shapeId}`; let helper = lowerer.valueHelpers.get(hkey); if (!helper) { - helper = keyedHelperName(lowerer, "%rec.haskey", hkey); + helper = `%rec.haskey.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(hkey, helper); const recT: IrType = { kind: "record", shapeId: recvT.shapeId }; diff --git a/packages/compiler/src/frontend/lowering/generic-functions.ts b/packages/compiler/src/frontend/lowering/generic-functions.ts index daf082db7..abcd5a584 100644 --- a/packages/compiler/src/frontend/lowering/generic-functions.ts +++ b/packages/compiler/src/frontend/lowering/generic-functions.ts @@ -1,6 +1,4 @@ import { staticNameBindings } from "./static-function-names.js"; -import { positionTag } from "./structural-positions.js"; -import { keyedHelperName } from "./stable-names.js"; import * as ts from "../ts7/adapter.js"; import { bodyReadsArguments } from "../arguments-usage.js"; import type { Lowerer } from "./lowerer.js"; @@ -231,10 +229,7 @@ export function collectGenericSignature(lowerer: Lowerer, decl: ts.FunctionDecla lowerer.genericFnsBySymbol.set(symbol, { decl, baseName: nameText, - qualifiedName: lowerer.qualify( - ts.getSourceFileOfNode(decl), - nsPathPrefix(lowerer, decl) + nameText, - ), + qualifiedName: lowerer.qualify(ts.getSourceFileOfNode(decl), nsPathPrefix(decl) + nameText), typeParams, instances: new Map(), }); @@ -656,7 +651,7 @@ function internGenericInstance( const typeArgsText = `<${rendered.length > 80 ? rendered.slice(0, 77) + "..." : rendered}>`; inst = { path, - name: keyedHelperName(lowerer, `${info.qualifiedName}%`, key, ""), + name: `${info.qualifiedName}%${info.instances.size}`, ordinal: info.instances.size, params, returnType, @@ -2134,7 +2129,7 @@ function internImplicitInstance( const declared = dynamicBroadPromise ? null : implicitDeclaredReturn(lowerer, info); inst = { path, - name: keyedHelperName(lowerer, `${info.qualifiedName}%`, key, ""), + name: `${info.qualifiedName}%${info.instances.size}`, ordinal: info.instances.size, params: shapes, // The promise callers rely on before the body settles it: the @@ -2322,7 +2317,7 @@ export function implicitLocalFnInfoOf( baseName: name, qualifiedName: lowerer.qualify( ts.getSourceFileOfNode(decl), - nsPathPrefix(lowerer, stmt ?? decl, decl) + `${name}%l${positionTag(lowerer, decl)}`, + nsPathPrefix(stmt ?? decl, decl) + `${name}%l${ts.tokenStartOfNode(decl)}`, ), typeParams: [], instances: new Map(), @@ -2418,7 +2413,7 @@ export function objLitGenericFnInfoOf( baseName: name, qualifiedName: lowerer.qualify( ts.getSourceFileOfNode(fnNode), - `%ol${positionTag(lowerer, fnNode)}.${name}`, + `%ol${ts.tokenStartOfNode(fnNode)}.${name}`, ), typeParams, instances: new Map(), @@ -2564,7 +2559,7 @@ export function bindingGenericFnInfoOf( baseName: name, qualifiedName: lowerer.qualify( ts.getSourceFileOfNode(decl), - nsPathPrefix(lowerer, stmt ?? decl, decl) + + nsPathPrefix(stmt ?? decl, decl) + (topLevel ? name : `${name}%l${ts.tokenStartOfNode(decl)}`), ), typeParams, diff --git a/packages/compiler/src/frontend/lowering/intern-tables.ts b/packages/compiler/src/frontend/lowering/intern-tables.ts index e3f2b0889..fc69237db 100644 --- a/packages/compiler/src/frontend/lowering/intern-tables.ts +++ b/packages/compiler/src/frontend/lowering/intern-tables.ts @@ -23,7 +23,6 @@ * The entry handles that itable.find and itable.insert answer stay inside * these lowerings: f64 locals that only reach toBool and itable.value. * Any other use of the class or its members as values is refused. */ -import { keyedHelperName } from "./stable-names.js"; import { dynUndefinedExpr } from "../../ir/build.js"; import { BOOL, F64, STRING, funcOf, typeKey } from "../../ir/ir.js"; import type { IrExpr, IrFunction, IrStmt, IrType, SrcLoc } from "../../ir/ir.js"; @@ -448,11 +447,7 @@ function helperName(lowerer: Lowerer, member: InternTableMember, signature: stri } function registerHelper(lowerer: Lowerer, member: InternTableMember, signature: string): string { - const name = keyedHelperName( - lowerer, - `%${INTERN_TABLE_CLASS}.${member}`, - `${member}|${signature}`, - ); + const name = `%${INTERN_TABLE_CLASS}.${member}.${lowerer.internTableHelpers.size}`; lowerer.internTableHelpers.set(`${member}|${signature}`, name); return name; } diff --git a/packages/compiler/src/frontend/lowering/iterator-adapters.ts b/packages/compiler/src/frontend/lowering/iterator-adapters.ts index e50652182..898c46f20 100644 --- a/packages/compiler/src/frontend/lowering/iterator-adapters.ts +++ b/packages/compiler/src/frontend/lowering/iterator-adapters.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "./stable-names.js"; import { dynUndefinedExpr, varRef } from "../../ir/build.js"; import { BOOL, @@ -87,7 +86,7 @@ function dynIteratorAdapter( const key = `iterAdapt:${typeKey(expected)}`; let name = lowerer.valueHelpers.get(key); if (!name) { - name = keyedHelperName(lowerer, "%iter.adapt", key); + name = `%iter.adapt.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); const locals: IrLocal[] = []; const local = (id: string, type: IrType, mutable = false): IrExpr => { @@ -314,7 +313,7 @@ export function lowerCollectionIteratorValue( loc, }; if (!typeEquals(yielded.type, type.yieldT)) return null; - name = keyedHelperName(lowerer, "%coll.iter", key); + name = `%coll.iter.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); lowerer.liftedFns.push({ name, @@ -412,7 +411,7 @@ export function lowerBytesIteratorValue( const key = `bytesIter:${method}:${typeKey(bytesT)}:${typeKey(type)}`; let name = lowerer.valueHelpers.get(key); if (!name) { - name = keyedHelperName(lowerer, "%bytes.iter", key); + name = `%bytes.iter.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); const list = varRef("list.0", bytesT, loc); const index = varRef("index.0", F64, loc); @@ -518,7 +517,7 @@ export function lowerStringIteratorValue( const key = `strIter:${typeKey(type)}`; let name = lowerer.valueHelpers.get(key); if (!name) { - name = keyedHelperName(lowerer, "%str.iter", key); + name = `%str.iter.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); const text = varRef("text.0", STRING, loc); const index = varRef("index.0", F64, loc); @@ -678,7 +677,7 @@ function generatorRetypeAdapter( type: resumeType(expected.nextT), loc, }; - name = keyedHelperName(lowerer, "%gen.retype", key); + name = `%gen.retype.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); lowerer.liftedFns.push({ name, @@ -795,7 +794,7 @@ export function generatorDrain( const outRef = varRef("out.0", arrT, loc); const value = lowerer.coerceToExpected(genValue(genRef, loc), elem); if (!typeEquals(value.type, elem)) return null; - name = keyedHelperName(lowerer, "%gen.drain", key); + name = `%gen.drain.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); lowerer.liftedFns.push({ name, @@ -857,7 +856,7 @@ export function generatorDrain( if (!raw) return null; const value = lowerer.coerceToExpected(raw, elem); if (!typeEquals(value.type, elem)) return null; - name = keyedHelperName(lowerer, "%gen.drain", key); + name = `%gen.drain.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); lowerer.liftedFns.push({ name, @@ -979,7 +978,7 @@ export function lowerArrayIteratorValue( }; } if (!yielded || !typeEquals(yielded.type, type.yieldT)) return null; - name = keyedHelperName(lowerer, "%arr.iter", key); + name = `%arr.iter.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); lowerer.liftedFns.push({ name, diff --git a/packages/compiler/src/frontend/lowering/js-dynamic-objects.ts b/packages/compiler/src/frontend/lowering/js-dynamic-objects.ts index e27dd4183..b9bbf6216 100644 --- a/packages/compiler/src/frontend/lowering/js-dynamic-objects.ts +++ b/packages/compiler/src/frontend/lowering/js-dynamic-objects.ts @@ -21,7 +21,6 @@ * files only, and an empty answer leaves every mapping unchanged, so * TypeScript programs and JavaScript that never uses these patterns * compile exactly as before. */ -import { keyedHelperName } from "./stable-names.js"; import * as ts from "../ts7/adapter.js"; import { isJsSourceFile, locOf } from "../program.js"; import { BOOL, DYN, type IrExpr, type IrStmt } from "../../ir/ir.js"; @@ -216,10 +215,10 @@ export function lowerValueReturningConstructorNew( "spread arguments when constructing a class whose constructor returns a value", ); } - const key = `ctorValue:${lowerer.positions.of(decl)}`; + const key = `ctorValue:${ts.getSourceFileOfNode(decl).fileName}:${ts.tokenStartOfNode(decl)}`; let name = lowerer.valueHelpers.get(key); if (name === undefined) { - name = keyedHelperName(lowerer, "%ctorValue", key); + name = `%ctorValue.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); const savedClass = lowerer.currentClass; lowerer.currentClass = null; diff --git a/packages/compiler/src/frontend/lowering/json-require.ts b/packages/compiler/src/frontend/lowering/json-require.ts index d6c2da571..927745253 100644 --- a/packages/compiler/src/frontend/lowering/json-require.ts +++ b/packages/compiler/src/frontend/lowering/json-require.ts @@ -10,7 +10,6 @@ * JSON module is ordinary storage holding that object — destructuring * copies its properties at the require, exactly like Node. ES-module JSON * imports keep their own record (Node's ESM loader caches separately). */ -import { keyedHelperName } from "./stable-names.js"; import * as ts from "../ts7/adapter.js"; import type { Lowerer } from "./lowerer.js"; import { PoisonError } from "./lowerer.js"; @@ -85,7 +84,7 @@ export function collectJsonRequires(lowerer: Lowerer, parts: FileParts[]): void ); throw new PoisonError(); } - const id = keyedHelperName(lowerer, "%g.jsonRequire", jsonSf.fileName); + const id = `%g.jsonRequire.${lowerer.jsonRequireModules.size}`; const global: IrGlobal = { id, name: "%json", type: mapped, mutable: true }; const loadedId = `${id}%loaded`; lowerer.globalsList.push(global, { diff --git a/packages/compiler/src/frontend/lowering/lifetime-regions.ts b/packages/compiler/src/frontend/lowering/lifetime-regions.ts index b684c0395..b212ae473 100644 --- a/packages/compiler/src/frontend/lowering/lifetime-regions.ts +++ b/packages/compiler/src/frontend/lowering/lifetime-regions.ts @@ -14,7 +14,6 @@ * Any other use of the class or its methods as values is refused. The * module is marked lifetimeRegions, which moves every ProgramLifetime * class into counted regions. */ -import { keyedHelperName } from "./stable-names.js"; import { F64, VOID, funcOf, typeKey } from "../../ir/ir.js"; import type { IrExpr, IrFunction, IrStmt, IrType, SrcLoc } from "../../ir/ir.js"; import { experimentalImportOf, lifetimeRegionMemberOf } from "../experimental-import.js"; @@ -153,7 +152,7 @@ function runHelper(lowerer: Lowerer, fnType: IrType & { kind: "func" }, loc: Src const key = typeKey(fnType); const known = lowerer.regionRunHelpers.get(key); if (known !== undefined) return known; - const name = keyedHelperName(lowerer, `%${LIFETIME_REGION_CLASS}.run`, key); + const name = `%${LIFETIME_REGION_CLASS}.run.${lowerer.regionRunHelpers.size}`; lowerer.regionRunHelpers.set(key, name); const regionT = lifetimeRegionType(lowerer); const ret = fnType.ret; diff --git a/packages/compiler/src/frontend/lowering/lower-assert.ts b/packages/compiler/src/frontend/lowering/lower-assert.ts index bc51a9382..460f4d53a 100644 --- a/packages/compiler/src/frontend/lowering/lower-assert.ts +++ b/packages/compiler/src/frontend/lowering/lower-assert.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "./stable-names.js"; import { InternalCompilerError } from "../../errors.js"; /* The node:assert lowering (a spoke module like lower-dgram.ts): the * callable module form (`assert(x)` through a default import or a CJS @@ -668,7 +667,7 @@ function partialEqHelper(lowerer: Lowerer, ta: IrType, tb: IrType, loc: SrcLoc): const key = `assert.pdeq:${typeKey(ta)}|${typeKey(tb)}`; const existing = lowerer.assertHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, "%assert.pdeq", key); + const name = `%assert.pdeq.${lowerer.assertHelpers.size}`; lowerer.assertHelpers.set(key, name); const a = (): IrExpr => varRef("a.0", ta, loc); const b = (): IrExpr => varRef("b.0", tb, loc); @@ -1281,7 +1280,7 @@ function deepCheckCall( const key = `assert.dcheck:${variant}:${negated}:${typeKey(a.type)}:${typeKey(b.type)}`; let name = lowerer.assertHelpers.get(key); if (!name) { - name = keyedHelperName(lowerer, "%assert.dcheck", key); + name = `%assert.dcheck.${lowerer.assertHelpers.size}`; lowerer.assertHelpers.set(key, name); const pa = varRef("a.0", a.type, loc); const pb = varRef("b.0", b.type, loc); @@ -1845,7 +1844,7 @@ function assertThrowsHelper( const key = `assert.${mode}:${recvIsPromise ? "p" : "f"}:${typeKey(recvType)}:${sig}`; const existing = lowerer.assertHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, `%assert.${mode}`, key); + const name = `%assert.${mode}.${lowerer.assertHelpers.size}`; lowerer.assertHelpers.set(key, name); const caughtRef = (): IrExpr => varRef("e.0", CAUGHT, loc); @@ -2294,7 +2293,7 @@ function ifErrorHelper(lowerer: Lowerer, t: IrType & { kind: "union" }, loc: Src const key = `assert.iferr:${typeKey(t)}`; const existing = lowerer.assertHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, "%assert.iferr", key); + const name = `%assert.iferr.${lowerer.assertHelpers.size}`; lowerer.assertHelpers.set(key, name); const def = lowerer.unions.get(t.unionId); if (!def) throw new InternalCompilerError(`assert.ifError over unknown union ${t.unionId}`); @@ -2465,7 +2464,7 @@ function deepEqHelper(lowerer: Lowerer, t: IrType, loc: SrcLoc, loose = false): const key = `assert.${prefix}:${typeKey(t)}`; const existing = lowerer.assertHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, `%assert.${prefix}`, key); + const name = `%assert.${prefix}.${lowerer.assertHelpers.size}`; lowerer.assertHelpers.set(key, name); const a = (): IrExpr => varRef("a.0", t, loc); diff --git a/packages/compiler/src/frontend/lowering/lower-calls.ts b/packages/compiler/src/frontend/lowering/lower-calls.ts index 63b8781f2..7102f37ab 100644 --- a/packages/compiler/src/frontend/lowering/lower-calls.ts +++ b/packages/compiler/src/frontend/lowering/lower-calls.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "./stable-names.js"; import { isForwardedTupleSpread, lowerForwardingApply } from "./typed-arguments.js"; import { guardNullProto, nullProtoRecordShape } from "./null-prototype.js"; import { lowerDynStreamMemberCall } from "./dyn-streams.js"; @@ -2095,7 +2094,7 @@ function lowerOptionalNumberDefault( const key = `number.optionalDefault:${widened.unionId}:${dflt}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%number.optionalDefault", key); + helper = `%number.optionalDefault.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, helper); const input = varRef("value.0", widened, loc); lowerer.liftedFns.push({ @@ -2204,7 +2203,7 @@ function primitiveConversionHandler( const key = `then.${name}:${typeKey(inner)}`; let fnName = lowerer.arrHofHelpers.get(key); if (fnName === undefined) { - fnName = keyedHelperName(lowerer, `%then.${name}`, key); + fnName = `%then.${name}.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, fnName); const value = varRef("v.0", inner, loc); let body: IrExpr; @@ -2373,7 +2372,7 @@ function lowerBigIntConstructorValue(lowerer: Lowerer, arg: IrExpr, loc: SrcLoc) const key = `bigint.scalar:${unionId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%bigint.scalar", key); + helper = `%bigint.scalar.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, helper); const value = varRef("value.0", arg.type, loc); const body: IrStmt[] = []; @@ -3235,7 +3234,7 @@ function lowerScalarUnionNumber( const key = `number.scalar:${arg.type.unionId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%number.scalar", key); + helper = `%number.scalar.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, helper); const value = varRef("value.0", arg.type, loc); const nan: IrExpr = { @@ -3280,7 +3279,7 @@ function lowerOptionalStringNumber( const key = `${label}.optionalString:${arg.type.unionId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, `%${label}.optionalString`, key); + helper = `%${label}.optionalString.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, helper); const value = varRef("value.0", arg.type, loc); lowerer.liftedFns.push({ @@ -4707,7 +4706,7 @@ function lowerDefaultToStringCall( const key = `objToStr:${typeKey(recv.type)}${missing ? `:${missing}` : ""}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%obj.tostr", key); + helper = `%obj.tostr.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, helper); const o = varRef("o.0", recv.type, loc); lowerer.liftedFns.push({ @@ -5394,7 +5393,7 @@ function loweredTemplateStrings( const site = lowerer.globalsList.length; const globalId = `%g.templateStrings.${site}`; const readyId = `%g.templateStringsReady.${site}`; - getter = keyedHelperName(lowerer, "%templateStrings.get", key); + getter = `%templateStrings.get.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, getter); lowerer.globalsList.push( { id: globalId, name: "%templateStrings", type, mutable: true }, @@ -5575,7 +5574,7 @@ export function lowerPromiseMethodCall( // IS the spec's identity/thrower/no-op substitution for all three // members. An argument expression, when present, is undefined/null // by construction — nothing to evaluate. - const fnName = lowerer.closureName(loc, `_${member}pass`); + const fnName = `%fn${lowerer.lambdaCounter++}_${member}pass`; const funcType: IrType & { kind: "func" } = { kind: "func", params: [promT], ret: promT }; const fnCtx = newFnCtx(true, null, funcType, inner); fnCtx.isAsync = true; @@ -5672,7 +5671,7 @@ export function lowerPromiseMethodCall( // Evaluate both callback expressions before the wrapper runs, in source order. const fulfilled = fulfilledAbsent ? null : boxHandler(fulfilledNode, true); const rejected = rejectedAbsent ? null : boxHandler(rejectedNode, false); - const fnName = lowerer.closureName(loc, "_then2"); + const fnName = `%fn${lowerer.lambdaCounter++}_then2`; const paramTypes: IrType[] = [ promT, ...(fulfilled ? [fulfilled.value.type] : []), @@ -5921,7 +5920,7 @@ export function lowerPromiseMethodCall( ); }; const resultT: IrType & { kind: "promise" } = { kind: "promise", inner: DYN }; - const fnName = lowerer.closureName(loc, "_then"); + const fnName = `%fn${lowerer.lambdaCounter++}_then`; const funcType: IrType & { kind: "func" } = { kind: "func", params: [promT, DYN], @@ -6016,7 +6015,7 @@ export function lowerPromiseMethodCall( ); } const R = resultT.inner; - const fnName = lowerer.closureName(loc, "_then"); + const fnName = `%fn${lowerer.lambdaCounter++}_then`; const funcType: IrType & { kind: "func" } = { kind: "func", params: [promT, cb.type], @@ -6119,7 +6118,7 @@ export function lowerPromiseMethodCall( "finally callbacks with parameters or a return value (use () => { ... })", ); } - const fnName = lowerer.closureName(loc, "_finally"); + const fnName = `%fn${lowerer.lambdaCounter++}_finally`; const funcType: IrType & { kind: "func" } = { kind: "func", params: [promT, cb.type], @@ -6222,7 +6221,7 @@ export function lowerPromiseMethodCall( } if (cb.type.kind === "dyn") { const resultT: IrType & { kind: "promise" } = { kind: "promise", inner: DYN }; - const fnName = lowerer.closureName(loc, "_catchdyn"); + const fnName = `%fn${lowerer.lambdaCounter++}_catchdyn`; const funcType: IrType & { kind: "func" } = { kind: "func", params: [promT, DYN], @@ -6352,7 +6351,7 @@ export function lowerPromiseMethodCall( ); } const R = resultT.inner; - const fnName = lowerer.closureName(loc, "_catch"); + const fnName = `%fn${lowerer.lambdaCounter++}_catch`; const funcType: IrType & { kind: "func" } = { kind: "func", params: [promT], ret: resultT }; const fnCtx = newFnCtx(true, null, funcType, R); fnCtx.isAsync = true; @@ -6589,7 +6588,7 @@ function filterNarrowHelper( const key = `filterNarrow:${test}:${typeKey(elem)}:${typeKey(outElem)}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, "%arr.filterNarrow", key); + const name = `%arr.filterNarrow.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, name); const arrT = arrayOf(elem); @@ -6835,7 +6834,7 @@ export function recordKeysArrayCall( const key = `obj.keys:${argIr.shapeId}:${typeKey(resultT)}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%obj.keys", key); + helper = `%obj.keys.${lowerer.arrHofHelpers.size}`; const ref: IrExpr = { kind: "varRef", localId: "r.0", type: argIr, loc }; const outRef: IrExpr = { kind: "varRef", localId: "out.0", type: resultT, loc }; lowerer.arrHofHelpers.set(key, helper); @@ -6905,7 +6904,7 @@ function recordHasOwnHelper(lowerer: Lowerer, shapeId: string, loc: SrcLoc): str const key = `obj.hasOwn:${shapeId}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const helper = keyedHelperName(lowerer, "%obj.hasOwn", key); + const helper = `%obj.hasOwn.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, helper); const shape = lowerer.shapes.get(shapeId)!; const recT: IrType = { kind: "record", shapeId }; @@ -6990,7 +6989,7 @@ function classAssignHelper( const key = `obj.assignClass:${className}:${srcShapeId}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const helper = keyedHelperName(lowerer, "%obj.assignClass", key); + const helper = `%obj.assignClass.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, helper); const sShape = lowerer.shapes.get(srcShapeId)!; const oT: IrType = { kind: "object", className }; @@ -7058,7 +7057,7 @@ function recordAssignHelper( const key = `obj.assign:${targetShapeId}:${srcShapeId}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const helper = keyedHelperName(lowerer, "%obj.assign", key); + const helper = `%obj.assign.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, helper); const sShape = lowerer.shapes.get(srcShapeId)!; const tShape = lowerer.shapes.get(targetShapeId)!; @@ -8515,7 +8514,7 @@ function lowerObjectStaticCall( const key = `obj.${member}:${argIr.shapeId}:${typeKey(resultT)}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, `%obj.${member}`, key); + helper = `%obj.${member}.${lowerer.arrHofHelpers.size}`; const recT = argIr; const ref: IrExpr = { kind: "varRef", localId: "r.0", type: recT, loc }; const outRef: IrExpr = { kind: "varRef", localId: "out.0", type: resultT, loc }; @@ -9151,7 +9150,7 @@ function lowerInlineArrowBind( const length = firstDefault < 0 ? arrow.parameters.nodes.length : firstDefault; const key = `arrow.bind:${typeKey(type)}:${length}`; const existing = lowerer.arrHofHelpers.get(key); - const name = existing ?? keyedHelperName(lowerer, "%arrow.bind", key); + const name = existing ?? `%arrow.bind.${lowerer.arrHofHelpers.size}`; if (!existing) { lowerer.arrHofHelpers.set(key, name); lowerer.freshClosureAdapters.add(name); @@ -10080,7 +10079,7 @@ function lowerUnionObjectDynFieldCall( const receiverRef = varRef(receiverLocal.id, receiverT, loc); let helper = lowerer.unionCallHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%union.call", key); + helper = `%union.call.${lowerer.unionCallHelpers.size}`; lowerer.unionCallHelpers.set(key, helper); const receiverRef = varRef("this.0", receiverT, loc); const branch = (plan: (typeof plans)[number]): IrStmt[] => { @@ -10173,7 +10172,7 @@ function unionObjectMethodHelper( const key = `${receiverT.unionId}:${method}:${shapes.map((shape) => `${shape.mode}:${typeKey(shape.type)}`).join(",")}:${typeKey(resultT)}`; const existing = lowerer.unionCallHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, "%union.call", key); + const name = `%union.call.${lowerer.unionCallHelpers.size}`; lowerer.unionCallHelpers.set(key, name); // A probe that catches a refusal while the body lowers must not leave // the name registered for a helper that was never emitted. @@ -10367,7 +10366,7 @@ export function lowerStaticNumberGlobal( const key = `parseInt.optional:${unionT.unionId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%parseInt.optional", key); + helper = `%parseInt.optional.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, helper); const value: IrExpr = { kind: "varRef", localId: "value.0", type: unionT, loc }; const radixRef: IrExpr = { kind: "varRef", localId: "radix.0", type: F64, loc }; diff --git a/packages/compiler/src/frontend/lowering/lower-classes.ts b/packages/compiler/src/frontend/lowering/lower-classes.ts index fcea03790..790efe988 100644 --- a/packages/compiler/src/frontend/lowering/lower-classes.ts +++ b/packages/compiler/src/frontend/lowering/lower-classes.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "./stable-names.js"; import { lowerValueReturningConstructorNew } from "./js-dynamic-objects.js"; import { adaptPromiseExecutor } from "./promise-executor-adapter.js"; import { dynUndefinedExpr, nodeThrowExpr, varRef } from "../../ir/build.js"; @@ -4664,7 +4663,7 @@ export function genericClassInstanceType( ); } const ordinal = gci.instances.size; - const name = keyedHelperName(lowerer, `${gci.family.def.name}%`, key, ""); + const name = `${gci.family.def.name}%${ordinal}`; const entry: { name: string; info: ClassInfo | null; poisoned?: boolean } = { name, info: null }; gci.instances.set(key, entry); const bindings = new Map(); @@ -7911,7 +7910,7 @@ export function classIteratorDrainCall( const key = `${cit.className}:${typeKey(outElem)}`; let name = lowerer.iterDrainHelpers.get(key); if (!name) { - name = keyedHelperName(lowerer, "%iter.drain", key); + name = `%iter.drain.${lowerer.iterDrainHelpers.size}`; lowerer.iterDrainHelpers.set(key, name); const recvT: IrType = { kind: "object", className: cit.className }; const recvRef: IrExpr = { kind: "varRef", localId: "r.0", type: recvT, loc }; @@ -8025,7 +8024,7 @@ export function classIteratorRestDrainCall( const key = `it:${cit.iterT.className}`; let name = lowerer.iterDrainHelpers.get(key); if (!name) { - name = keyedHelperName(lowerer, "%iter.drain", key); + name = `%iter.drain.${lowerer.iterDrainHelpers.size}`; lowerer.iterDrainHelpers.set(key, name); const itRef: IrExpr = { kind: "varRef", localId: "it.0", type: cit.iterT, loc }; const outRef: IrExpr = { kind: "varRef", localId: "out.0", type: outT, loc }; @@ -10533,7 +10532,7 @@ export function lowerNew(lowerer: Lowerer, expr: ts.NewExpression): IrExpr { const key = `x509.record:${isBytes ? "bytes" : "str"}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%x509.record", key); + helper = `%x509.record.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, helper); const dataT = data.type; const dRef: IrExpr = { kind: "varRef", localId: "d.0", type: dataT, loc }; diff --git a/packages/compiler/src/frontend/lowering/lower-dgram.ts b/packages/compiler/src/frontend/lowering/lower-dgram.ts index aa90fc7c7..5c99ebc82 100644 --- a/packages/compiler/src/frontend/lowering/lower-dgram.ts +++ b/packages/compiler/src/frontend/lowering/lower-dgram.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "./stable-names.js"; import { dynUndefinedExpr, boolLit } from "../../ir/build.js"; /* The dgram/dns-surface lowering (node:dgram + node:dns — a spoke module * like lower-server.ts): module-function calls (dgram createSocket, dns @@ -358,7 +357,7 @@ function checkedDynPromise( const key = `dns.promise:${typeKey(declared)}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%dns.promise", key); + helper = `%dns.promise.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, helper); const promiseT: IrType = { kind: "promise", inner: DYN }; lowerer.liftedFns.push({ @@ -892,7 +891,7 @@ export function lowerPromisifiedDnsCall( const key = `dnsPromise:${JSON.stringify(value)}`; let name = lowerer.valueHelpers.get(key); if (!name) { - name = keyedHelperName(lowerer, "%dnsPromise", key); + name = `%dnsPromise.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); lowerer.liftedFns.push({ name, diff --git a/packages/compiler/src/frontend/lowering/lower-event-emitter.ts b/packages/compiler/src/frontend/lowering/lower-event-emitter.ts index f105af786..f472672b2 100644 --- a/packages/compiler/src/frontend/lowering/lower-event-emitter.ts +++ b/packages/compiler/src/frontend/lowering/lower-event-emitter.ts @@ -42,7 +42,6 @@ * emit-overrides block at the bottom of this file (per-event * monomorphization of the override body, dispatch on the dynamic class, * super.emit as the prototype chain). */ -import { keyedHelperName } from "./stable-names.js"; import { checkKeypressListener } from "./builtins/readline.js"; import * as ts from "../ts7/adapter.js"; import type { Lowerer } from "./lowerer.js"; @@ -632,7 +631,7 @@ function lowerFlexListenerCall( const key = `emitter.${registering ? "onFlex" : "offDyn"}:${typeKey(recvT)}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, `%emitter.${registering ? "onFlex" : "offFlex"}`, key); + helper = `%emitter.${registering ? "onFlex" : "offFlex"}.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, helper); const params: IrParam[] = [ { localId: "r.0", name: "r", type: recvT }, @@ -851,7 +850,7 @@ function lowerDynListenerCall( const existing = lowerer.arrHofHelpers.get(key); let helper = existing; if (!helper) { - helper = keyedHelperName(lowerer, `%emitter.${registering ? "onDyn" : "offDyn"}`, key); + helper = `%emitter.${registering ? "onDyn" : "offDyn"}.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, helper); const check: IrStmt = { kind: "exprStmt", @@ -1001,7 +1000,7 @@ export function lowerDynamicEmitterEmit( const key = `emitter.dynEmit:${typeKey(recvT)}:${k}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%emitter.dynEmit", key); + helper = `%emitter.dynEmit.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, helper); const params: IrParam[] = [ { localId: "r.0", name: "r", type: recvT }, @@ -1093,7 +1092,7 @@ export function lowerDynamicEmitterOn( const key = `emitter.dynOn:${typeKey(recvT)}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%emitter.dynOn", key); + helper = `%emitter.dynOn.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, helper); const params: IrParam[] = [ { localId: "r.0", name: "r", type: recvT }, @@ -2360,7 +2359,7 @@ function emitDispatchExpr( const key = `emitter.emitDispatch:${typeKey(recvT)}:${name}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = keyedHelperName(lowerer, "%emitter.emitDispatch", key); + helper = `%emitter.emitDispatch.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, helper); const params: IrParam[] = [ { localId: "r.0", name: "r", type: recvT }, @@ -2425,7 +2424,7 @@ function eventsOnceBoxer( const key = `eventsOnce:${typeKey(fnType)}`; let name = lowerer.valueHelpers.get(key); if (name === undefined) { - name = keyedHelperName(lowerer, "%events.onceArgs", key); + name = `%events.onceArgs.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); const params: IrParam[] = tuple.map((type, i) => ({ localId: `%once.a${i}`, diff --git a/packages/compiler/src/frontend/lowering/lower-exprs.ts b/packages/compiler/src/frontend/lowering/lower-exprs.ts index ba96bea8c..e7a1b79a8 100644 --- a/packages/compiler/src/frontend/lowering/lower-exprs.ts +++ b/packages/compiler/src/frontend/lowering/lower-exprs.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "./stable-names.js"; import { lowerWebAssemblyValue, refuseWebAssemblyUse } from "./builtins/webassembly.js"; import { dynUndefinedExpr, nodeThrowExpr, numLit, strLit, varRef } from "../../ir/build.js"; import { InternalCompilerError } from "../../errors.js"; @@ -2275,11 +2274,7 @@ export function cjsAccessorSnapshotOf( if (!lexerVisibleAccessors(ts.getSourceFileOfNode(getter)).includes(getter)) return null; const call = cjsAccessorCall(lowerer, getter, locOf(getter)); if (call === null) return null; - const at = locOf(getter); - const snapshot = { - id: keyedHelperName(lowerer, "%g.cjsSnapshot", `${at.file}:${at.start}:${at.end}`), - type: call.type, - }; + const snapshot = { id: `%g.cjsSnapshot.${lowerer.cjsAccessorSnapshots.size}`, type: call.type }; lowerer.globalsList.push({ id: snapshot.id, name: "%cjsSnapshot", @@ -2304,7 +2299,7 @@ export function cjsAccessorSnapshotStores( if (getters.length === 0) return []; let readyId = lowerer.cjsSnapshotReady.get(dep); if (readyId === undefined) { - readyId = keyedHelperName(lowerer, "%g.cjsSnapshotReady", dep.fileName); + readyId = `%g.cjsSnapshotReady.${lowerer.cjsSnapshotReady.size}`; lowerer.globalsList.push({ id: readyId, name: "%cjsSnapshotReady", type: BOOL, mutable: true }); lowerer.cjsSnapshotReady.set(dep, readyId); } diff --git a/packages/compiler/src/frontend/lowering/lower-functions.ts b/packages/compiler/src/frontend/lowering/lower-functions.ts index 653c0d837..cd8dc31d1 100644 --- a/packages/compiler/src/frontend/lowering/lower-functions.ts +++ b/packages/compiler/src/frontend/lowering/lower-functions.ts @@ -270,7 +270,7 @@ export function lowerLambda( const nameIdent = !ts.isArrowFunction(node) && node.name && ts.isIdentifier(node.name) ? node.name : null; const baseName = nameIdent ? nameIdent.text : ""; - const fnName = lowerer.closureName(locOf(node), baseName ? `_${baseName}` : ""); + const fnName = `%fn${lowerer.lambdaCounter++}${baseName ? `_${baseName}` : ""}`; // Named function expressions/declarations can self-reference by name; an // object-literal method's name is a PROPERTY, not a binding — no self. const selfSymbol = diff --git a/packages/compiler/src/frontend/lowering/lower-inspect.ts b/packages/compiler/src/frontend/lowering/lower-inspect.ts index 1979b43aa..4be5d0b7e 100644 --- a/packages/compiler/src/frontend/lowering/lower-inspect.ts +++ b/packages/compiler/src/frontend/lowering/lower-inspect.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "./stable-names.js"; import { dynUndefinedExpr, boolLit, @@ -269,7 +268,7 @@ function errorInspectHelper( const key = `insp.userError:${typeKey(t)}`; const existing = lowerer.inspectHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, "%util.insp", key); + const name = `%util.insp.${lowerer.inspectHelpers.size}`; lowerer.inspectHelpers.set(key, name); const v = (): IrExpr => varRef("v.0", t, loc); const r = (): IrExpr => varRef("r.0", F64, loc); @@ -1146,7 +1145,7 @@ function inspectHelper(lowerer: Lowerer, t: IrType, loc: SrcLoc): string { const key = `insp:${typeKey(t)}`; const existing = lowerer.inspectHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, "%util.insp", key); + const name = `%util.insp.${lowerer.inspectHelpers.size}`; lowerer.inspectHelpers.set(key, name); const v = (): IrExpr => varRef("v.0", t, loc); @@ -2075,7 +2074,7 @@ function formatUnionHelper( const existing = lowerer.inspectHelpers.get(key); if (existing) return existing; const loc = helperLoc(site); - const name = keyedHelperName(lowerer, "%util.fmtv", key); + const name = `%util.fmtv.${lowerer.inspectHelpers.size}`; lowerer.inspectHelpers.set(key, name); const def = lowerer.unions.get(t.unionId); if (!def) throw new InternalCompilerError(`format value over unknown union ${t.unionId}`); diff --git a/packages/compiler/src/frontend/lowering/lower-mixins.ts b/packages/compiler/src/frontend/lowering/lower-mixins.ts index 9de027563..766059dfb 100644 --- a/packages/compiler/src/frontend/lowering/lower-mixins.ts +++ b/packages/compiler/src/frontend/lowering/lower-mixins.ts @@ -34,7 +34,6 @@ * statics-bearing mixin classes outside a plain top-level statement * (their declaration-time code must run exactly where the call * evaluates). */ -import { positionTag } from "./structural-positions.js"; import * as ts from "../ts7/adapter.js"; import type { Lowerer } from "./lowerer.js"; import { PoisonError } from "./lowerer.js"; @@ -453,7 +452,7 @@ function instantiateMixinCall( const base = mixinBaseClassOf(lowerer, call.arguments.nodes[0]!); const instName = lowerer.qualify( ts.getSourceFileOfNode(call), - `%mx${positionTag(lowerer, call)}.${shape.classNode.name?.text ?? ""}`, + `%mx${ts.tokenStartOfNode(call)}.${shape.classNode.name?.text ?? ""}`, ); const ordinal = lowerer.mixinOrdinals.get(shape.classNode) ?? 0; lowerer.mixinOrdinals.set(shape.classNode, ordinal + 1); diff --git a/packages/compiler/src/frontend/lowering/lower-mock.ts b/packages/compiler/src/frontend/lowering/lower-mock.ts index 8c50dee46..fcc68c787 100644 --- a/packages/compiler/src/frontend/lowering/lower-mock.ts +++ b/packages/compiler/src/frontend/lowering/lower-mock.ts @@ -17,7 +17,6 @@ * writes the original back on restore(). Each mock registers a closure * that calls its restore() with its tracker (scr_test.c): the module's * `mock`, or the test's t.mock, which is reset when the test ends. */ -import { keyedHelperName } from "./stable-names.js"; import * as ts from "../ts7/adapter.js"; import { BOOL, @@ -137,7 +136,7 @@ function liftOnce( const key = `mock.${role}:${owner}`; const existing = lowerer.assertHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, `%mock.${role}`, key); + const name = `%mock.${role}.${lowerer.assertHelpers.size}`; lowerer.assertHelpers.set(key, name); build(name); return name; diff --git a/packages/compiler/src/frontend/lowering/lower-modules.test.ts b/packages/compiler/src/frontend/lowering/lower-modules.test.ts index f1021e4da..84cc96e7d 100644 --- a/packages/compiler/src/frontend/lowering/lower-modules.test.ts +++ b/packages/compiler/src/frontend/lowering/lower-modules.test.ts @@ -34,7 +34,7 @@ test("retains dependencies from function storage, captures, generator channels a const completed = record("completed"); const body = record("body"); const global = record("global", record("nested")); - const wanted = lowerer.shapes.shapes.map((shape) => shape.id).sort(); + const wanted = lowerer.shapes.shapes.map((shape) => shape.id); record("unused"); const unionId = lowerer.unions.intern([body, UNDEFINED_T]); const unusedUnion = lowerer.unions.intern([F64, UNDEFINED_T]); @@ -162,7 +162,7 @@ test("closes nested structural types and index-signature values", () => { sent = record("sent"), indexed = record("indexed"); const containerId = lowerer.shapes.intern([], false, indexed); - const wanted = lowerer.shapes.shapes.map((shape) => shape.id).sort(); + const wanted = lowerer.shapes.shapes.map((shape) => shape.id); record("unused"); const nested: IrType = { kind: "func", diff --git a/packages/compiler/src/frontend/lowering/lower-modules.ts b/packages/compiler/src/frontend/lowering/lower-modules.ts index 0b99e88d3..d1f276d44 100644 --- a/packages/compiler/src/frontend/lowering/lower-modules.ts +++ b/packages/compiler/src/frontend/lowering/lower-modules.ts @@ -1,5 +1,4 @@ import { THREADS_MODULE } from "../threads-import.js"; -import { positionTag } from "./structural-positions.js"; import { EXPERIMENTAL_MODULE } from "../experimental-import.js"; import { dynUndefinedExpr } from "../../ir/build.js"; import { everyStmtList, everyTypeChild } from "../../ir/traverse.js"; @@ -1075,14 +1074,8 @@ export function moduleArtifacts( else delete rest.abstractMethods; return rest; }), - // Ids come from what each shape and union is (keyedHelperName), so - // ordering by id gives every lowering order the same module. - records: lowerer.shapes.shapes - .filter((r) => shapeIds.has(r.id)) - .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)), - unions: lowerer.unions.unions - .filter((u) => unionIds.has(u.id)) - .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)), + records: lowerer.shapes.shapes.filter((r) => shapeIds.has(r.id)), + unions: lowerer.unions.unions.filter((u) => unionIds.has(u.id)), }; } @@ -1684,7 +1677,7 @@ export function collectGlobals( } if (type.kind === "void") lowerer.badType(stmt.name, lowerer.typeOf(stmt.name)); const g: IrGlobal = { - id: `%g.${tag}${nsPathPrefix(lowerer, stmt)}%alias.${stmt.name.text}%${positionTag(lowerer, stmt)}`, + id: `%g.${tag}${nsPathPrefix(stmt)}%alias.${stmt.name.text}%${ts.tokenStartOfNode(stmt)}`, name: stmt.name.text, type, mutable: false, @@ -1761,7 +1754,7 @@ export function collectGlobals( // (`%g.e.A%B.x`), so `namespace A { export const x }` and a // top-level `const x` never collide; non-exported members add the // declaring block's position (block-local bindings). - const nsPrefix = nsPathPrefix(lowerer, stmt, list.declarations.nodes[0]); + const nsPrefix = nsPathPrefix(stmt, list.declarations.nodes[0]); for (const decl of list.declarations.nodes) { // --provenance-sources: an elided pure-annotated dead const in a // fetched source module registers no global (the statement diff --git a/packages/compiler/src/frontend/lowering/lower-namespaces.ts b/packages/compiler/src/frontend/lowering/lower-namespaces.ts index 19123dae3..dca835d77 100644 --- a/packages/compiler/src/frontend/lowering/lower-namespaces.ts +++ b/packages/compiler/src/frontend/lowering/lower-namespaces.ts @@ -36,7 +36,6 @@ * of the compiler already takes (a body running before the declaring * statement is not modeled — same as top-level const reads through early * calls). */ -import { positionTag, type PositionTagOwner } from "./structural-positions.js"; import * as ts from "../ts7/adapter.js"; import { packageShimFor } from "../package-shims.js"; import type { Lowerer } from "./lowerer.js"; @@ -165,11 +164,7 @@ function registerTypeOnlyBlocks(lowerer: Lowerer, decl: ts.ModuleDeclaration): v * distinct (resolution is by symbol; names only need uniqueness and * determinism). `modifierDecl` carries the declaration whose modifiers * decide exportedness (the first declarator of a variable statement). */ -export function nsPathPrefix( - owner: PositionTagOwner, - node: ts.Node, - modifierDecl?: ts.Node, -): string { +export function nsPathPrefix(node: ts.Node, modifierDecl?: ts.Node): string { const parent = node.parent; if (parent === undefined || !ts.isModuleBlock(parent)) return ""; const flagsHost = modifierDecl ?? node; @@ -184,10 +179,10 @@ export function nsPathPrefix( const nested = p.parent !== undefined && ts.isModuleBlock(p.parent); const nonExported = nested && (ts.getCombinedModifierFlags(p) & ts.ModifierFlags.Export) === 0; - segs.unshift(p.name.text + (nonExported ? `%${positionTag(owner, p)}` : "")); + segs.unshift(p.name.text + (nonExported ? `%${ts.tokenStartOfNode(p)}` : "")); } } - return `${segs.join("%")}${exported ? "" : `%${positionTag(owner, parent)}`}.`; + return `${segs.join("%")}${exported ? "" : `%${ts.tokenStartOfNode(parent)}`}.`; } /** The registered namespace-block kind a symbol's declaration sits in diff --git a/packages/compiler/src/frontend/lowering/lower-server.ts b/packages/compiler/src/frontend/lowering/lower-server.ts index 94d49d8b3..058d7874a 100644 --- a/packages/compiler/src/frontend/lowering/lower-server.ts +++ b/packages/compiler/src/frontend/lowering/lower-server.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "./stable-names.js"; import { dynUndefinedExpr, nodeThrowExpr, @@ -184,7 +183,7 @@ export function voidizedCallback(lowerer: Lowerer, cb: IrExpr, loc: SrcLoc): IrE const toT = funcOf([...fromT.params], VOID); const key = `server.voidcb:${typeKey(fromT)}`; const existing = lowerer.arrHofHelpers.get(key); - const name = existing ?? keyedHelperName(lowerer, "%server.voidcb", key); + const name = existing ?? `%server.voidcb.${lowerer.arrHofHelpers.size}`; if (!existing) { lowerer.arrHofHelpers.set(key, name); const impl = `${name}.impl`; @@ -280,7 +279,7 @@ function receiverReturningCall( ): IrExpr { const key = `server.recvret:${fn}:${opts?.prefix?.fn ?? ""}:${(opts?.mainArgIndices ?? []).join(".")}:${callArgs.map((a) => typeKey(a.type)).join(",")}`; const existing = lowerer.arrHofHelpers.get(key); - const name = existing ?? keyedHelperName(lowerer, "%server.recvret", key); + const name = existing ?? `%server.recvret.${lowerer.arrHofHelpers.size}`; if (!existing) { lowerer.arrHofHelpers.set(key, name); const params = callArgs.map((a, i) => ({ localId: `p${i}.0`, name: `p${i}`, type: a.type })); @@ -591,7 +590,7 @@ function h2HeadersCallbackAdapter( ); const key = `h2.hdrcb:${handleKind}:${withStatus}:${typeKey(fromT)}:${shapeId ?? ""}`; const existing = lowerer.arrHofHelpers.get(key); - const name = existing ?? keyedHelperName(lowerer, "%h2.hdrcb", key); + const name = existing ?? `%h2.hdrcb.${lowerer.arrHofHelpers.size}`; if (!existing) { lowerer.arrHofHelpers.set(key, name); const impl = `${name}.impl`; @@ -3584,7 +3583,7 @@ export function lowerCompatReqStreamOptionalCall( type: unionT, loc, }; - const id = lowerer.closureName(loc, "", "chain"); + const id = `chain.${lowerer.chainCounter++}`; const body = lowerH2StreamMethodCall(lowerer, call, call.expression, { kind: "chainRecv", id, @@ -4425,7 +4424,7 @@ function lowerHttpCreateServerForms( const hasMax = opts.maxHeaderSize !== null; const key = `server.opts:${opts.joinDup ? 1 : 0}:${opts.allowMissingHost ? 1 : 0}:${hasBuffer ? 1 : 0}:${hasMax ? 1 : 0}`; const existing = lowerer.arrHofHelpers.get(key); - const name = existing ?? keyedHelperName(lowerer, "%server.opts", key); + const name = existing ?? `%server.opts.${lowerer.arrHofHelpers.size}`; if (!existing) { lowerer.arrHofHelpers.set(key, name); const params = [ @@ -8010,7 +8009,7 @@ function lowerHttpResMethodCall( const all = [...callArgs, cb]; const key = `server.endcb:${fn}:${all.map((a) => typeKey(a.type)).join(",")}`; const existing = lowerer.arrHofHelpers.get(key); - const helper = existing ?? keyedHelperName(lowerer, "%server.endcb", key); + const helper = existing ?? `%server.endcb.${lowerer.arrHofHelpers.size}`; if (!existing) { lowerer.arrHofHelpers.set(key, helper); const params = all.map((a, i) => ({ localId: `p${i}.0`, name: `p${i}`, type: a.type })); diff --git a/packages/compiler/src/frontend/lowering/lower-stdlib.ts b/packages/compiler/src/frontend/lowering/lower-stdlib.ts index 0beb24a0e..2ad3657c7 100644 --- a/packages/compiler/src/frontend/lowering/lower-stdlib.ts +++ b/packages/compiler/src/frontend/lowering/lower-stdlib.ts @@ -2278,7 +2278,7 @@ function lowerStaticNamespaceImport( ): IrExpr { const loc = locOf(call); const resultT: IrType & { kind: "promise" } = { kind: "promise", inner: ns }; - const fnName = lowerer.closureName(loc, "_staticImport"); + const fnName = `%fn${lowerer.lambdaCounter++}_staticImport`; const fnType: IrType & { kind: "func" } = { kind: "func", params: [], ret: resultT }; const fnCtx = newFnCtx(true, null, fnType, ns); fnCtx.isAsync = true; diff --git a/packages/compiler/src/frontend/lowering/lower-stream.ts b/packages/compiler/src/frontend/lowering/lower-stream.ts index a75ec43b7..b9add95a6 100644 --- a/packages/compiler/src/frontend/lowering/lower-stream.ts +++ b/packages/compiler/src/frontend/lowering/lower-stream.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "./stable-names.js"; import { nodeThrowExpr, boolLit, numLit, strLit } from "../../ir/build.js"; import { hashStreamOf, isHashValueType } from "./builtins/hash-stream.js"; import { InternalCompilerError } from "../../errors.js"; @@ -312,7 +311,7 @@ function lowerStreamCallback( ); } } - const fnName = lowerer.closureName(loc, `_${which}cb`); + const fnName = `%fn${lowerer.lambdaCounter++}_${which}cb`; const fnCtx = newFnCtx(true, null, funcType, funcType.ret); lowerer.fnStack.push(fnCtx); try { @@ -1145,7 +1144,7 @@ function streamMethodWrapper( paramTypes.push(got.type); } const ret = found.sig.ret; - const fnName = lowerer.closureName(loc, `_${which}vt`); + const fnName = `%fn${lowerer.lambdaCounter++}_${which}vt`; const funcType = funcOf([thisType, ...paramTypes], ret); lowerer.fnStack.push(newFnCtx(true, null, funcType, ret)); try { @@ -1691,7 +1690,7 @@ function fromGenHelpers( const key = `streamFromGen:${role}:${typeKey(gen)}`; let name = lowerer.valueHelpers.get(key); if (!name) { - name = keyedHelperName(lowerer, `%stream.fromGen.${role}`, key); + name = `%stream.fromGen.${role}.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); lowerer.liftedFns.push({ name, @@ -1780,7 +1779,7 @@ function classIteratorObject( const key = `streamFromIter:${cit.iterT.className}`; let name = lowerer.valueHelpers.get(key); if (!name) { - name = keyedHelperName(lowerer, "%stream.fromIter", key); + name = `%stream.fromIter.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); const nextName = `${name}.next`; const nextT = funcOf([], DYN); @@ -1941,7 +1940,7 @@ function classAsyncIteratorObject( const key = `streamFromAsyncIter:${cit.className}`; let name = lowerer.valueHelpers.get(key); if (!name) { - name = keyedHelperName(lowerer, "%stream.fromAsyncIter", key); + name = `%stream.fromAsyncIter.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); const it: IrLocal = { id: "it.0", name: "it", type: cit.iterT, mutable: false, boxed: true }; const src: IrLocal = { @@ -2895,7 +2894,7 @@ function pipelineBoxHelper( const key = `pipelineBox:${typeKey(promiseT)}`; let name = lowerer.valueHelpers.get(key); if (!name) { - name = keyedHelperName(lowerer, "%stream.pipelineBox", key); + name = `%stream.pipelineBox.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); lowerer.liftedFns.push({ name, @@ -2922,7 +2921,7 @@ function pipelineAbortHelper(lowerer: Lowerer, ac: IrExpr, loc: SrcLoc): IrExpr let name = lowerer.valueHelpers.get(key); const abortT = funcOf([], VOID); if (!name) { - name = keyedHelperName(lowerer, "%stream.pipelineAbort", key); + name = `%stream.pipelineAbort.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); const acLocal: IrLocal = { id: "ac.0", name: "ac", type: DYN, mutable: false, boxed: true }; const acRef = varRef(acLocal.id, DYN, loc); diff --git a/packages/compiler/src/frontend/lowering/lower-timers.ts b/packages/compiler/src/frontend/lowering/lower-timers.ts index 03c9c5c1f..7d4bba34b 100644 --- a/packages/compiler/src/frontend/lowering/lower-timers.ts +++ b/packages/compiler/src/frontend/lowering/lower-timers.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "./stable-names.js"; import { dynUndefinedExpr, numLit, varRef } from "../../ir/build.js"; import * as ts from "../ts7/adapter.js"; import { isJsSourceFile } from "../program.js"; @@ -56,7 +55,7 @@ export function adaptZeroArgTimerCallback( const toT: IrType = { kind: "func", params: [], ret: VOID }; const key = `timer.dropret:${typeKey(fromT)}`; const existing = lowerer.arrHofHelpers.get(key); - const name = existing ?? keyedHelperName(lowerer, "%timer.dropret", key); + const name = existing ?? `%timer.dropret.${lowerer.arrHofHelpers.size}`; if (!existing) { lowerer.arrHofHelpers.set(key, name); lowerer.liftedFns.push( @@ -118,7 +117,7 @@ export function adaptZeroArgTimerCallback( const toT: IrType = { kind: "func", params: [], ret: VOID }; const key = `timer.droparg:${typeKey(fromT)}`; const existing = lowerer.arrHofHelpers.get(key); - const name = existing ?? keyedHelperName(lowerer, "%timer.droparg", key); + const name = existing ?? `%timer.droparg.${lowerer.arrHofHelpers.size}`; if (!existing) { lowerer.arrHofHelpers.set(key, name); lowerer.liftedFns.push( @@ -204,7 +203,7 @@ function makeTimerArgsThunk( const toT: IrType = { kind: "func", params: [], ret: VOID }; const key = `timer.argsthunk:${n}`; const existing = lowerer.arrHofHelpers.get(key); - const name = existing ?? keyedHelperName(lowerer, "%timer.argsthunk", key); + const name = existing ?? `%timer.argsthunk.${lowerer.arrHofHelpers.size}`; if (!existing) { lowerer.arrHofHelpers.set(key, name); const impl = `${name}.impl`; diff --git a/packages/compiler/src/frontend/lowering/lowerer.test.ts b/packages/compiler/src/frontend/lowering/lowerer.test.ts index 7fbb9661f..bacdc7941 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.test.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.test.ts @@ -10,7 +10,6 @@ import { } from "../../ir/ir.js"; import type { Node, Program, SourceFile, Symbol, Type } from "../ts7/adapter.js"; import { Lowerer } from "./lowerer.js"; -import { UnionRegistry } from "../type-mapper.js"; import { classMethodValue } from "./class-method-values.js"; const loc = { file: "island.ts", start: 0, end: 1 }; @@ -33,7 +32,7 @@ test("reuses complete copy routes without repeating discriminator planning", () expect(plan).not.toHaveBeenCalled(); expect(lowerer.liftedFns.filter((fn) => fn.name === helper)).toHaveLength(1); const recursive = {} as Type; - lowerer.shapes.recursiveRef(recursive, () => "Recursive"); + lowerer.shapes.recursiveRef(recursive); lowerer.shapes.finalizeRecursive(recursive, [{ name: "kind", type: STRING }]); expect(lowerer.unionRetagHelper(from, to, loc)).toBe(helper); expect(plan).toHaveBeenCalled(); @@ -55,7 +54,7 @@ test("replans after a recursive union gains its final arms", () => { const lowerer = context(); const recursive = {} as Type; const from = lowerer.unions.intern([UNDEFINED_T, NULL_T]); - const to = lowerer.unions.recursiveRef(recursive, () => "Recursive"); + const to = lowerer.unions.recursiveRef(recursive); const trapped = lowerer.unionRetagHelper(from, to, loc); expect(trapped).not.toBeNull(); lowerer.unions.finalizeRecursive(recursive, [UNDEFINED_T]); @@ -76,7 +75,7 @@ test("rechecks width conversions after recursive record definitions settle", () const lowerer = context(); const recursive = {} as Type; const source = record(lowerer.shapes.intern([{ name: "value", type: F64 }])); - const target = record(lowerer.shapes.recursiveRef(recursive, () => "Recursive")); + const target = record(lowerer.shapes.recursiveRef(recursive)); const from = lowerer.unions.intern([source, UNDEFINED_T]); const to = lowerer.unions.intern([target, NULL_T]); expect(lowerer.unionRetagHelper(from, to, loc)).not.toBeNull(); @@ -130,7 +129,7 @@ test("literal ownership is reused across values and rechecked when recursive rec expect(inspect).not.toHaveBeenCalled(); const recursive = {} as Type; - const pendingShape = record(lowerer.shapes.recursiveRef(recursive, () => "Recursive")); + const pendingShape = record(lowerer.shapes.recursiveRef(recursive)); const pending = lowerer.unions.intern([pendingShape], { field: "kind", cases: [{ tag: 0, values: ["a"] }], @@ -144,7 +143,7 @@ test("literal ownership is reused across values and rechecked when recursive rec test("literal ownership sees a recursive union's finalized discriminator", () => { const lowerer = context(); const recursive = {} as Type; - const union = lowerer.unions.recursiveRef(recursive, () => "Recursive"); + const union = lowerer.unions.recursiveRef(recursive); const shape = record(lowerer.shapes.intern([{ name: "kind", type: STRING }])); expect(lowerer.literalUnionArm(union, ["ready"])).toBeNull(); lowerer.unions.finalizeRecursive(recursive, [shape], { @@ -183,10 +182,7 @@ test("removing undefined reuses the discriminator transformation without hiding ); const recursive = {} as Type; - const pending: IrType = { - kind: "union", - unionId: lowerer.unions.recursiveRef(recursive, () => "Recursive"), - }; + const pending: IrType = { kind: "union", unionId: lowerer.unions.recursiveRef(recursive) }; expect(lowerer.stripUndefinedArm(pending)).toEqual(pending); lowerer.unions.finalizeRecursive(recursive, [STRING, UNDEFINED_T]); expect(lowerer.stripUndefinedArm(pending)).toEqual(STRING); @@ -219,10 +215,7 @@ test("adding undefined reuses semantic union transformations and sees recursive expect(lowerer.unions.get(added.unionId)?.discriminant).toEqual(discriminant); const recursive = {} as Type; - const pending: IrType = { - kind: "union", - unionId: lowerer.unions.recursiveRef(recursive, () => "Recursive"), - }; + const pending: IrType = { kind: "union", unionId: lowerer.unions.recursiveRef(recursive) }; const before = lowerer.withUndefinedArmOf(pending); lowerer.unions.finalizeRecursive(recursive, [a, b], discriminant); expect(lowerer.withUndefinedArmOf(pending)).toEqual(added); @@ -234,18 +227,13 @@ test("adding undefined reuses semantic union transformations and sees recursive test("optional union widening keeps refused and missing contracts current", () => { const lowerer = context(); const recursive = {} as Type; - const pending: IrType = { - kind: "union", - unionId: lowerer.unions.recursiveRef(recursive, () => "Recursive"), - }; + const pending: IrType = { kind: "union", unionId: lowerer.unions.recursiveRef(recursive) }; expect(lowerer.withUndefinedArmOf(pending)).not.toBeNull(); lowerer.unions.finalizeRecursive(recursive, [{ kind: "date" }, STRING]); expect(lowerer.withUndefinedArmOf(pending)).toBeNull(); expect(lowerer.withUndefinedArmOf(pending)).toBeNull(); - // Union ids come from their arms, so a fresh registry names the union - // this one has not interned yet. - const missing: IrType = { kind: "union", unionId: new UnionRegistry().intern([F64, STRING]) }; + const missing: IrType = { kind: "union", unionId: `u${lowerer.unions.unions.length}` }; expect(lowerer.withUndefinedArmOf(missing)).toBeNull(); expect(lowerer.unions.intern([F64, STRING])).toBe(missing.unionId); expect(lowerer.withUndefinedArmOf(missing)?.kind).toBe("union"); diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts index 3f8a0a66e..ee8ba7ecb 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -1,6 +1,4 @@ import { relieveHeapPressure } from "../../heap-pressure.js"; -import { keyedHelperName } from "./stable-names.js"; -import { positionTag, StructuralPositions } from "./structural-positions.js"; import { onlyForwarded, stripTypeWrappers } from "./typed-arguments.js"; import { needsGeneralNodeStreams, @@ -1006,11 +1004,6 @@ function lowerShuffle(): ((wave: string[]) => void) | null { * the bodies reachable emit did NOT mark (plus deferred collection * diagnostics nothing flushed), reported separately: whole-program analysis without * letting unreached code fail builds. */ -/** The closure root of an emit-override specialization body. */ -function emitSpecRoot(spec: EmitSpecRequest): string { - return `%emit.${spec.info.def.name}.${spec.event}.${spec.ordinal}`; -} - export function lowerToIr( program: ts.Program, entry: ts.SourceFile, @@ -2808,8 +2801,6 @@ export class Lowerer { /** Generated value helpers, keyed by operation and type. Callers own * their key prefixes; this includes more than structural conversions. */ readonly valueHelpers = new Map(); - /** Each name keyedHelperName made, with a second hash of its key. */ - readonly keyedNameKeys = new Map(); /** structuralNarrowing's assignable classes, keyed by static and * narrowed class name. */ readonly structuralClassPeers = new Map(); @@ -2946,6 +2937,7 @@ export class Lowerer { ctx: FnCtx; } >(); + chainCounter = 0; /** Keyed by program-wide qualified class name (what IR object types carry). */ readonly classes = new Map(); readonly classBySymbol = new Map(); @@ -3175,47 +3167,7 @@ export class Lowerer { * dispatch revision needs no weak-key identity or process-global state. */ errorMethodDispatchRevision: string | null = null; errorPropertyDispatchRevision: string | null = null; - /** Structural source positions (structural-positions.ts) for names that - * stay the same when unrelated code moves. */ - readonly positions = new StructuralPositions(); - - /** The outermost node whose token span is exactly `loc`, or null. */ - nodeAtLoc(loc: SrcLoc): ts.Node | null { - const sf = this.program.getSourceFile(loc.file); - return sf === undefined ? null : (ts.nodeAtSpan(sf, loc.start, loc.end) ?? null); - } - - /** The lowering unit whose name scopes the closures it lifts. */ - private closureRoot = "%pre"; - private readonly closureNameCounts = new Map(); - - /** Runs `fn` with the closures it lifts named under `root`. */ - withClosureRoot(root: string, fn: () => T): T { - const previous = this.closureRoot; - this.closureRoot = root; - try { - return fn(); - } finally { - this.closureRoot = previous; - } - } - - /** The name of a closure (or wrapper) lifted for the source at `loc`: - * `.` of the current lowering unit, the location and - * `suffix`, then `suffix`. A unit that lifts several functions for the same - * location and suffix numbers them in the order it lifts them, so a - * closure's name depends only on its unit, not on which units lowered - * before it. */ - closureName(loc: SrcLoc, suffix = "", prefix = "%fn"): string { - const node = this.nodeAtLoc(loc); - const where = node === null ? `${loc.file}:${loc.start}:${loc.end}` : this.positions.of(node); - const key = `${prefix}|${this.closureRoot}|${where}|${suffix}`; - const first = keyedHelperName(this, prefix, key); - const seen = this.closureNameCounts.get(first) ?? 0; - this.closureNameCounts.set(first, seen + 1); - return (seen === 0 ? first : keyedHelperName(this, prefix, `${key}|${seen}`)) + suffix; - } - + lambdaCounter = 0; readonly preparedClassFactories = new Map(); readonly preparingClassFactories = new Set(); @@ -3568,7 +3520,6 @@ export class Lowerer { this.checker = program.getTypeChecker(); this.typeCtx = { checker: this.checker, - positionOf: (node) => this.positions.of(node), shapes: this.shapes, unions: this.unions, classNamer: this.classNamer, @@ -3857,11 +3808,11 @@ export class Lowerer { })() ? this.qualify( ts.getSourceFileOfNode(decl), - `%cx${positionTag(this, decl)}.${decl.name?.text ?? ""}`, + `%cx${ts.tokenStartOfNode(decl)}.${decl.name?.text ?? ""}`, ) : this.qualify( ts.getSourceFileOfNode(decl), - nsPathPrefix(this, decl) + (decl.name ? decl.name.text : "%anon"), + nsPathPrefix(decl) + (decl.name ? decl.name.text : "%anon"), ); for (let index = this.localClassInstantiations.length - 1; index >= 0; index--) { const entry = this.localClassInstantiations[index]!; @@ -7420,10 +7371,7 @@ export class Lowerer { } for (const decl of fp.classDecls) { const info = this.classes.get(this.classNamer(decl)); - if (info) - functions.push( - ...this.withClosureRoot(info.def.name, () => this.lowerClassMembers(info)), - ); + if (info) functions.push(...this.lowerClassMembers(info)); else if (this.countsSkips()) this.countSkippedBody(decl); } } @@ -7436,10 +7384,7 @@ export class Lowerer { // are reachable by definition, already counted by reachable emit. if (!this.remainder) { for (const fp of parts) { - const initName = this.initNameOf.get(fp.sf)!; - functions.push( - this.withClosureRoot(initName, () => this.lowerFileInit(fp.sf, fp.topStmts, initName)), - ); + functions.push(this.lowerFileInit(fp.sf, fp.topStmts, this.initNameOf.get(fp.sf)!)); } functions.push(this.buildMain()); } @@ -7481,9 +7426,7 @@ export class Lowerer { // default): the diagnostic is recorded — the instance skips // like a signature-blocked function (lowerFunction's rule). try { - functions.push( - this.withClosureRoot(inst.name, () => this.lowerGenericInstance(info, inst)), - ); + functions.push(this.lowerGenericInstance(info, inst)); } catch (e) { if (!(e instanceof PoisonError)) throw e; } @@ -7493,10 +7436,7 @@ export class Lowerer { // instances of its own; the joint fixpoint covers both). while (es < this.emitSpecQueue.length) { try { - const spec = this.emitSpecQueue[es++]!; - const fn = this.withClosureRoot(emitSpecRoot(spec), () => - lowerEmitOverrideSpec(this, spec), - ); + const fn = lowerEmitOverrideSpec(this, this.emitSpecQueue[es++]!); if (fn) functions.push(fn); } catch (e) { if (!(e instanceof PoisonError)) throw e; @@ -8050,9 +7990,7 @@ export class Lowerer { this.genericClassDemandPriority.set(info, ref); instanceFunctions.push( ...this.withGenericDemandOwner(owner, () => - this.shapes.withDeclaredOrderPriority(ref, () => - this.withClosureRoot(info.def.name, () => this.lowerClassMembers(info)), - ), + this.shapes.withDeclaredOrderPriority(ref, () => this.lowerClassMembers(info)), ), ); relieveHeapPressure(); @@ -8079,7 +8017,7 @@ export class Lowerer { instanceFunctions.push( this.withGenericDemandOwner(owner, () => this.shapes.withDeclaredOrderPriority(ref, () => - this.withClosureRoot(inst.name, () => this.lowerGenericInstance(info, inst)), + this.lowerGenericInstance(info, inst), ), ), ); @@ -8112,12 +8050,9 @@ export class Lowerer { ); while (specLowered < waveEnd) { try { - const fn = this.shapes.withDeclaredOrderPriority([4, instanceMetadataOrder++], () => { - const spec = this.emitSpecQueue[specLowered++]!; - return this.withClosureRoot(emitSpecRoot(spec), () => - lowerEmitOverrideSpec(this, spec), - ); - }); + const fn = this.shapes.withDeclaredOrderPriority([4, instanceMetadataOrder++], () => + lowerEmitOverrideSpec(this, this.emitSpecQueue[specLowered++]!), + ); if (fn) instanceFunctions.push(fn); } catch (e) { if (!(e instanceof PoisonError)) throw e; @@ -8145,9 +8080,7 @@ export class Lowerer { initFunctions.push( this.withGenericDemandOwner(owner, () => this.shapes.withDeclaredOrderPriority(priority, () => - this.withClosureRoot(this.initNameOf.get(fp.sf)!, () => - this.lowerFileInit(fp.sf, fp.topStmts, this.initNameOf.get(fp.sf)!), - ), + this.lowerFileInit(fp.sf, fp.topStmts, this.initNameOf.get(fp.sf)!), ), ), ); @@ -8173,9 +8106,7 @@ export class Lowerer { const priority = metadataPriority.get(name) ?? [3, expressionMetadataOrder++]; const owner = demandOwner(priority); const fn = this.withGenericDemandOwner(owner, () => - this.shapes.withDeclaredOrderPriority(priority, () => - this.withClosureRoot(name, unit.lower), - ), + this.shapes.withDeclaredOrderPriority(priority, unit.lower), ); if (fn) loweredUnits.set(name, fn); relieveHeapPressure(); @@ -13558,7 +13489,7 @@ export class Lowerer { const key = `${fn.valueFn ?? fn.fn}:${typeKey(funcType)}:${adapterShape}`; let fnName = this.builtinCallableValueFns.get(key); if (!fnName) { - fnName = keyedHelperName(this, `%builtin.value.${fn.valueFn ?? fn.fn}`, key); + fnName = `%builtin.value.${fn.valueFn ?? fn.fn}.${this.builtinCallableValueFns.size}`; this.builtinCallableValueFns.set(key, fnName); this.builtinCallableValueNames.set(fnName, display.slice(display.lastIndexOf(".") + 1)); const params = funcType.params.map((type, index) => ({ diff --git a/packages/compiler/src/frontend/lowering/native-ffi.ts b/packages/compiler/src/frontend/lowering/native-ffi.ts index 62f2be9f1..0f932ba93 100644 --- a/packages/compiler/src/frontend/lowering/native-ffi.ts +++ b/packages/compiler/src/frontend/lowering/native-ffi.ts @@ -562,7 +562,7 @@ export function lowerFfiMemoryModule(lowerer: Lowerer, loc: SrcLoc): IrExpr { const entries = lowerer.ffiImports .filter((entry) => entry.library !== undefined) .map((entry) => { - const name = lowerer.closureName(loc, "", "%ffi.module"); + const name = `%ffi.module.${lowerer.lambdaCounter++}`; const sourceTypes = ffiSourceParamTypes(entry.params); const locals: IrLocal[] = sourceTypes.map((_, i) => ({ id: `%arg${i}`, diff --git a/packages/compiler/src/frontend/lowering/object-enumeration-receiver.ts b/packages/compiler/src/frontend/lowering/object-enumeration-receiver.ts index 388ac3904..855da3bda 100644 --- a/packages/compiler/src/frontend/lowering/object-enumeration-receiver.ts +++ b/packages/compiler/src/frontend/lowering/object-enumeration-receiver.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "./stable-names.js"; import { BOOL, STRING, @@ -28,7 +27,7 @@ export function objectEnumerationReceiver( const key = `obj.receiver:${source.unionId}:${expected.shapeId}`; let name = lowerer.arrHofHelpers.get(key); if (name === undefined) { - name = keyedHelperName(lowerer, "%obj.receiver", key); + name = `%obj.receiver.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, name); const value = varRef("value.0", source, loc); lowerer.liftedFns.push({ diff --git a/packages/compiler/src/frontend/lowering/pairs-snapshot.ts b/packages/compiler/src/frontend/lowering/pairs-snapshot.ts index acf7b3bf9..3b33fb0cd 100644 --- a/packages/compiler/src/frontend/lowering/pairs-snapshot.ts +++ b/packages/compiler/src/frontend/lowering/pairs-snapshot.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "./stable-names.js"; import { arrayOf, BOOL, @@ -50,7 +49,7 @@ export function pairsSnapshotHelper( const key = `${options.keyPrefix}.snapshot:${shapeId}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = keyedHelperName(lowerer, `%${options.keyPrefix}.snapshot`, key); + const name = `%${options.keyPrefix}.snapshot.${lowerer.valueHelpers.size}`; lowerer.valueHelpers.set(key, name); const recordType: IrType = { kind: "record", shapeId }; const pairsType = arrayOf(STRING); diff --git a/packages/compiler/src/frontend/lowering/promise-executor-adapter.ts b/packages/compiler/src/frontend/lowering/promise-executor-adapter.ts index 84aa8dac0..09d228b05 100644 --- a/packages/compiler/src/frontend/lowering/promise-executor-adapter.ts +++ b/packages/compiler/src/frontend/lowering/promise-executor-adapter.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "./stable-names.js"; import { varRef } from "../../ir/build.js"; import { type IrExpr, @@ -41,7 +40,7 @@ export function adaptPromiseExecutor( const key = `promise.executor:${typeKey(execT)}:${typeKey(inner)}`; let name = lowerer.arrHofHelpers.get(key); if (name === undefined) { - name = keyedHelperName(lowerer, "%promise.executor", key); + name = `%promise.executor.${lowerer.arrHofHelpers.size}`; lowerer.arrHofHelpers.set(key, name); const impl = `${name}.impl`; const captured: IrLocal = { id: "f.0", name: "f", type: execT, mutable: false, boxed: true }; diff --git a/packages/compiler/src/frontend/lowering/require-initialization.ts b/packages/compiler/src/frontend/lowering/require-initialization.ts index c8fc9c730..d979423b0 100644 --- a/packages/compiler/src/frontend/lowering/require-initialization.ts +++ b/packages/compiler/src/frontend/lowering/require-initialization.ts @@ -9,7 +9,6 @@ * and every reference that can run earlier checks it first — the same * module.tdzCheck the import-cycle bindings use. A reference whose lowering * leaves no expression to check keeps the SC1013 fence. */ -import { positionTag } from "./structural-positions.js"; import * as ts from "../ts7/adapter.js"; import type { Lowerer } from "./lowerer.js"; import { @@ -120,7 +119,7 @@ export function markRequireEarlyBindings(lowerer: Lowerer): void { const tag = rawTag === "" ? "e." : rawTag.replace(/^%/, ""); const bySymbol = new Map(); for (const { decl } of declared) { - const flagId = `%g.${tag}%required.${positionTag(lowerer, decl)}`; + const flagId = `%g.${tag}%required.${ts.tokenStartOfNode(decl)}`; lowerer.globalsList.push({ id: flagId, name: "%initialized", type: BOOL, mutable: true }); const flag: RequireInitFlag = { flagId, names: new Map() }; for (const id of boundNames(decl.name)) { diff --git a/packages/compiler/src/frontend/lowering/stable-names.ts b/packages/compiler/src/frontend/lowering/stable-names.ts deleted file mode 100644 index 8f7d0967e..000000000 --- a/packages/compiler/src/frontend/lowering/stable-names.ts +++ /dev/null @@ -1,48 +0,0 @@ -import { InternalCompilerError } from "../../errors.js"; - -/** The owner of the names keyedHelperName hands out. */ -export interface KeyedNameOwner { - /** Each keyed name with a second hash of the key it was made from, which - * tells a repeated key from a different key with the same name. */ - readonly keyedNameKeys: Map; -} - -/** 48 bits of two FNV-1a hashes of `key`, as 12 hex digits. */ -function keyHash(key: string): string { - let a = 0x811c9dc5; - let b = 0x01000193 ^ 0x5bd1e995; - for (let i = 0; i < key.length; i++) { - const c = key.charCodeAt(i); - a = Math.imul(a ^ c, 0x01000193); - b = Math.imul(b ^ c, 0x01000193) ^ (b >>> 13); - } - const high = (b >>> 0).toString(16).padStart(8, "0").slice(4); - return high + (a >>> 0).toString(16).padStart(8, "0"); -} - -/** A 32-bit hash of `key` independent of keyHash's bits. */ -function checkHash(key: string): number { - let h = 0x9e3779b9; - for (let i = 0; i < key.length; i++) - h = Math.imul(h ^ key.charCodeAt(i), 0x85ebca6b) ^ (h >>> 15); - return h >>> 0; -} - -/** The name of a helper interned by `key`: ``. It depends only on the key, not on how many helpers were interned - * before, so a helper has the same name whichever unit first needs it. Two - * keys that hash to the same name throw an InternalCompilerError. */ -export function keyedHelperName( - owner: KeyedNameOwner, - prefix: string, - key: string, - separator = ".", -): string { - const name = `${prefix}${separator}${keyHash(key)}`; - const check = checkHash(key); - const previous = owner.keyedNameKeys.get(name); - if (previous === undefined) owner.keyedNameKeys.set(name, check); - else if (previous !== check) - throw new InternalCompilerError(`helper name ${name} is shared by two helper keys`); - return name; -} diff --git a/packages/compiler/src/frontend/lowering/strict-equality.ts b/packages/compiler/src/frontend/lowering/strict-equality.ts index 8a87c8111..7b9b6902b 100644 --- a/packages/compiler/src/frontend/lowering/strict-equality.ts +++ b/packages/compiler/src/frontend/lowering/strict-equality.ts @@ -1,4 +1,3 @@ -import { keyedHelperName } from "./stable-names.js"; import { boolLit, varRef } from "../../ir/build.js"; import { BOOL, @@ -136,7 +135,7 @@ export function lowerUnionEquality( loc, ); if (!result) return null; - name = keyedHelperName(lowerer, "%value.eq", key); + name = `%value.eq.${lowerer.equalityHelpers.size}`; lowerer.equalityHelpers.set(key, name); lowerer.liftedFns.push({ name, diff --git a/packages/compiler/src/frontend/lowering/structural-positions.ts b/packages/compiler/src/frontend/lowering/structural-positions.ts deleted file mode 100644 index ea8535d9e..000000000 --- a/packages/compiler/src/frontend/lowering/structural-positions.ts +++ /dev/null @@ -1,107 +0,0 @@ -import * as ts from "../ts7/adapter.js"; -import { keyedHelperName, type KeyedNameOwner } from "./stable-names.js"; - -/** The declaration kinds whose names anchor the positions inside them. */ -const ANCHOR_KINDS: ReadonlySet = new Set([ - ts.SyntaxKind.FunctionDeclaration, - ts.SyntaxKind.ClassDeclaration, - ts.SyntaxKind.ClassExpression, - ts.SyntaxKind.VariableDeclaration, - ts.SyntaxKind.MethodDeclaration, - ts.SyntaxKind.GetAccessor, - ts.SyntaxKind.SetAccessor, - ts.SyntaxKind.PropertyDeclaration, - ts.SyntaxKind.PropertyAssignment, - ts.SyntaxKind.ModuleDeclaration, - ts.SyntaxKind.EnumDeclaration, - ts.SyntaxKind.Constructor, - ts.SyntaxKind.InterfaceDeclaration, - ts.SyntaxKind.TypeAliasDeclaration, -]); - -/** The name of `node` when it is a named declaration that anchors the - * positions of the nodes inside it, or null. */ -function anchorName(node: ts.Node): string | null { - return ts.declarationNameAt(node, node.index, ANCHOR_KINDS); -} - -/** The nearest enclosing anchor of `node` (not `node` itself), or its - * source file. */ -function anchorOf(node: ts.Node): ts.Node { - for (let parent = node.parent; parent !== undefined; parent = parent.parent) { - if (ts.isSourceFile(parent) || anchorName(parent) !== null) return parent; - } - return ts.getSourceFileOfNode(node); -} - -/** Source positions that stay the same when code outside the enclosing - * declaration changes. A node's structural position is its file, the chain - * of enclosing named declarations (each with its kind, its name and its - * ordinal among the declarations of the same kind and name in its own - * anchor), and its ordinal among the nodes of its kind whose nearest anchor - * is the same declaration. Editing another declaration, or code nested in another - * named declaration of the same anchor, leaves the position unchanged. */ -export class StructuralPositions { - /** Per anchor and key: the indices of the nodes with that key whose - * nearest anchor it is, in preorder (anchoredNodes). */ - private readonly nodesByKey = new Map>(); - private readonly paths = new Map(); - - /** The ordinal of `node` among the nodes of `anchor` with its key. */ - private ordinalIn(anchor: ts.Node, node: ts.Node, key: string): number { - let byKey = this.nodesByKey.get(anchor); - if (byKey === undefined) this.nodesByKey.set(anchor, (byKey = new Map())); - let indices = byKey.get(key); - if (indices === undefined) { - indices = ts.anchoredNodes(anchor, key, ANCHOR_KINDS); - byKey.set(key, indices); - } - // Indices increase in preorder. - let low = 0; - let high = indices.length - 1; - while (low <= high) { - const middle = (low + high) >> 1; - const at = indices[middle]!; - if (at === node.index) return middle; - if (at < node.index) low = middle + 1; - else high = middle - 1; - } - return -1; - } - - /** The anchor chain of `anchor` from the file down. */ - private pathOf(anchor: ts.Node): string { - const cached = this.paths.get(anchor); - if (cached !== undefined) return cached; - let path: string; - if (ts.isSourceFile(anchor)) path = anchor.fileName; - else { - const parent = anchorOf(anchor); - // The kind keeps declarations of one name apart: a getter and its - // setter, or a class and the namespace merged with it. - const key = `${anchor.kind}:${anchorName(anchor)}`; - path = `${this.pathOf(parent)}/${key}#${this.ordinalIn(parent, anchor, key)}`; - } - this.paths.set(anchor, path); - return path; - } - - /** The structural position of `node`. */ - of(node: ts.Node): string { - const anchor = anchorOf(node); - const name = anchorName(node); - const key = name === null ? `${node.kind}` : `${node.kind}:${name}`; - return `${this.pathOf(anchor)}|${key}#${this.ordinalIn(anchor, node, key)}`; - } -} - -/** The owner of structural positions and the names made from them. */ -export interface PositionTagOwner extends KeyedNameOwner { - readonly positions: StructuralPositions; -} - -/** A short tag for `node`'s structural position, for names that must stay - * unique per source node (class expressions, namespace blocks). */ -export function positionTag(owner: PositionTagOwner, node: ts.Node): string { - return keyedHelperName(owner, "", owner.positions.of(node), ""); -} diff --git a/packages/compiler/src/frontend/ts7/ast.ts b/packages/compiler/src/frontend/ts7/ast.ts index 0bddd1a80..369213d89 100644 --- a/packages/compiler/src/frontend/ts7/ast.ts +++ b/packages/compiler/src/frontend/ts7/ast.ts @@ -47,9 +47,8 @@ import { } from "./ast-guards.generated.js"; import type { Ts7DiagnosticData as Diagnostic } from "./session-schema.generated.js"; import { ModifierFlags, SyntaxKind } from "./enums.js"; -import { AstKind, KIND_NODE_LIST } from "./ast-schema.generated.js"; +import { AstKind } from "./ast-schema.generated.js"; import { PREORDER_LIST } from "./ast-wire.js"; -import { tokenStartOfNode } from "./node-functions.js"; /* ---- everything 7 kept under the same name ---- */ @@ -197,93 +196,6 @@ function walkLinkedPreorder( } } -/** The semantic children of a wire node: list items stand in for their - * list, and attached JSDoc trees are left out (the walkPreorder view). */ -function semanticChildIndices(root: Node, index: number, out: number[]): void { - const wire = root.file.wire; - for (let child = wire.firstChild(index); child !== 0; child = wire.next(child)) { - const kind = wire.kind(child); - if (kind === KIND_NODE_LIST) { - for (let item = wire.firstChild(child); item !== 0; item = wire.next(item)) out.push(item); - } else if (kind !== AstKind.JSDoc) out.push(child); - } -} - -/** The outermost node of `sourceFile` whose token span is exactly - * [start, end), or undefined. Only nodes ending at `end` are - * materialized. */ -export function nodeAtSpan(sourceFile: SourceFile, start: number, end: number): Node | undefined { - const wire = sourceFile.file.wire; - const children: number[] = []; - let index = sourceFile.index; - for (;;) { - children.length = 0; - semanticChildIndices(sourceFile, index, children); - let next = 0; - for (const child of children) { - if (wire.pos(child) > start || wire.end(child) < end) continue; - if (wire.end(child) === end) { - const node = sourceFile.file.node(child); - if (tokenStartOfNode(node) === start) return node; - } - next = child; - break; - } - if (next === 0) return undefined; - index = next; - } -} - -/** The name of the declaration at wire `index` in `root`'s file when its - * kind is in `kinds`: its identifier, private identifier or string literal - * name, "constructor" for a constructor, or null. Reads the wire without - * materializing nodes. */ -export function declarationNameAt( - root: Node, - index: number, - kinds: ReadonlySet, -): string | null { - const wire = root.file.wire; - const kind = wire.kind(index); - if (!kinds.has(kind)) return null; - if (kind === SyntaxKind.Constructor) return "constructor"; - const name = wire.namedChild(index, "name"); - if (name === 0) return null; - const nameKind = wire.kind(name); - if ( - nameKind !== SyntaxKind.Identifier && - nameKind !== SyntaxKind.PrivateIdentifier && - nameKind !== SyntaxKind.StringLiteral - ) - return null; - return wire.text(name) ?? null; -} - -/** The indices, in preorder, of the nodes below `root` that have `key` and - * are not inside a nested named declaration (declarationNameAt with - * `kinds`). A named declaration is keyed `:` and its subtree is - * not visited; other nodes are keyed by their kind. No node is - * materialized. */ -export function anchoredNodes(root: Node, key: string, kinds: ReadonlySet): number[] { - const wire = root.file.wire; - const out: number[] = []; - const children: number[] = []; - const stack: number[] = []; - semanticChildIndices(root, root.index, children); - for (let i = children.length - 1; i >= 0; i--) stack.push(children[i]!); - while (stack.length > 0) { - const index = stack.pop()!; - const kind = wire.kind(index); - const name = declarationNameAt(root, index, kinds); - if ((name === null ? String(kind) : `${kind}:${name}`) === key) out.push(index); - if (name !== null) continue; - children.length = 0; - semanticChildIndices(root, index, children); - for (let i = children.length - 1; i >= 0; i--) stack.push(children[i]!); - } - return out; -} - export function getLineAndCharacterOfPosition( sourceFile: SourceFile, position: number, diff --git a/packages/compiler/src/frontend/type-mapper.test.ts b/packages/compiler/src/frontend/type-mapper.test.ts index 163ba7b9e..cf78554b4 100644 --- a/packages/compiler/src/frontend/type-mapper.test.ts +++ b/packages/compiler/src/frontend/type-mapper.test.ts @@ -41,7 +41,7 @@ describe("union arm lookup", () => { test("sees finalized recursive arms after a missing lookup", () => { const unions = new UnionRegistry(); const recursive = {} as Type; - const union = unions.recursiveRef(recursive, () => "Recursive"); + const union = unions.recursiveRef(recursive); expect(unions.armTag(union, STRING)).toBe(-1); unions.finalizeRecursive(recursive, [ F64, diff --git a/packages/compiler/src/frontend/type-mapper.ts b/packages/compiler/src/frontend/type-mapper.ts index 79091cadc..a233f0186 100644 --- a/packages/compiler/src/frontend/type-mapper.ts +++ b/packages/compiler/src/frontend/type-mapper.ts @@ -1,5 +1,4 @@ import { InternalCompilerError } from "../errors.js"; -import { keyedHelperName, type KeyedNameOwner } from "./lowering/stable-names.js"; import { mockCallRecordType, mockContextType } from "./mock-shapes.js"; import * as ts from "./ts7/adapter.js"; import { bodyReadsArguments } from "./arguments-usage.js"; @@ -253,8 +252,6 @@ function comparePriority(left: DeclaredOrderPriority, right: DeclaredOrderPriori export class ShapeRegistry { /** Existing layouts change only when a recursive placeholder closes. */ revision = 0; - /** Each shape id with a second hash of its key (keyedHelperName). */ - readonly keyedNameKeys = new Map(); private readonly byKey = new Map(); private readonly byId = new Map(); /** Historical emit-order rank of the declaration-order metadata each @@ -273,7 +270,7 @@ export class ShapeRegistry { * writer after all priority candidates have closed. */ private readonly derivedDeclaredOrderFinalizers: (() => void)[] = []; private currentDeclaredOrderPriority: DeclaredOrderPriority = [0, 0]; - /** All interned shapes in first-seen order. */ + /** All interned shapes in first-seen (`r0`, `r1`, ...) order. */ readonly shapes: IrRecordShape[] = []; /** ts.Types currently being mapped — a BACK-REFERENCE to one of these is * the recursive knot (`interface TreeNode { children: TreeNode[] }`): @@ -393,12 +390,11 @@ export class ShapeRegistry { /** The shape id a back-reference to an in-progress type resolves to: * reuses the type's persistent recursive id or mints a PLACEHOLDER - * entry (empty fields) the outer frame finalizes. `describe` names a new - * placeholder (recursiveTypeName). */ - recursiveRef(t: ts.Type, describe: () => string): string { + * entry (empty fields) the outer frame finalizes. */ + recursiveRef(t: ts.Type): string { let id = this.recIds.get(t); if (id === undefined) { - id = recursivePlaceholderName(this, "r", describe(), (name) => this.byId.has(name)); + id = `r${this.shapes.length}`; const shape: IrRecordShape = { id, fields: [] }; this.byId.set(id, shape); this.shapes.push(shape); @@ -467,7 +463,7 @@ export class ShapeRegistry { const key = this.keyOf(fields, tuple, indexValue); let id = this.byKey.get(key); if (id === undefined) { - id = keyedHelperName(this, "r", key, ""); + id = `r${this.shapes.length}`; const shape: IrRecordShape = { id, fields, @@ -545,57 +541,6 @@ export class ShapeRegistry { } } -/** The id of a recursive placeholder described by `description`. Two - * different types can still share a description (recursiveTypeName stops - * after a few levels of type arguments); the later one takes the first free - * name with a numbered suffix. */ -function recursivePlaceholderName( - owner: KeyedNameOwner, - prefix: string, - description: string, - taken: (name: string) => boolean, -): string { - let name = keyedHelperName(owner, prefix, `recursive:${description}`, ""); - for (let n = 1; taken(name); n++) - name = keyedHelperName(owner, prefix, `recursive:${description}#${n}`, ""); - return name; -} - -/** How many levels of type arguments recursiveTypeName describes. */ -const RECURSIVE_NAME_DEPTH = 3; - -/** A recursive checker type's description, which names its placeholder - * whichever frame first reaches it: its printed form, the structural - * position of its first declaration, and the same for its type arguments - * (two instantiations print the same when their type arguments are type - * parameters or classes of the same name from different declarations). */ -function recursiveTypeName( - t: ts.Type, - ctx: Pick, - depth = 0, -): string { - const symbol = t.getAliasSymbol() ?? t.getSymbol(); - const declaration = symbol?.declarations[0]; - const where = declaration - ? (ctx.positionOf?.(declaration) ?? - `${ts.getSourceFileOfNode(declaration).fileName}:${declaration.pos}`) - : ""; - let description = `${ctx.checker.typeToString(t)}@${where}`; - if (depth < RECURSIVE_NAME_DEPTH) { - const aliasArguments = - t.getAliasSymbol() !== undefined ? (t.getAliasTypeArguments() ?? []) : []; - const typeArguments = - aliasArguments.length > 0 - ? aliasArguments - : t.isTypeReference() - ? ctx.checker.getTypeArguments(t) - : []; - if (typeArguments.length > 0) - description += `<${typeArguments.map((arg) => recursiveTypeName(arg, ctx, depth + 1)).join(",")}>`; - } - return description; -} - /** The frontend's union interner — mirrors ShapeRegistry. A union's * canonical identity includes its typeKey-sorted arms and literal * discriminator contract. An arm's index in that list IS its runtime tag. @@ -603,12 +548,10 @@ function recursiveTypeName( export class UnionRegistry { /** Existing arm/discriminator contracts change when a placeholder closes. */ revision = 0; - /** Each union id with a second hash of its key (keyedHelperName). */ - readonly keyedNameKeys = new Map(); private readonly byKey = new Map(); private readonly byId = new Map(); private readonly armTags = new Map>(); - /** All interned unions in first-seen order. */ + /** All interned unions in first-seen (`u0`, `u1`, ...) order. */ readonly unions: IrUnionDef[] = []; /** ts.Types currently being mapped — a back-reference to one is the * recursive knot passing through a union (`type Tree = Leaf | Branch` @@ -624,12 +567,11 @@ export class UnionRegistry { /** The union id a back-reference to an in-progress union resolves to: * reuses the type's persistent recursive id or mints a PLACEHOLDER - * entry (empty arms) the outer frame finalizes. `describe` names a new - * placeholder (recursiveTypeName). */ - recursiveRef(t: ts.Type, describe: () => string): string { + * entry (empty arms) the outer frame finalizes. */ + recursiveRef(t: ts.Type): string { let id = this.recIds.get(t); if (id === undefined) { - id = recursivePlaceholderName(this, "u", describe(), (name) => this.byId.has(name)); + id = `u${this.unions.length}`; const def: IrUnionDef = { id, arms: [] }; this.byId.set(id, def); this.unions.push(def); @@ -679,7 +621,7 @@ export class UnionRegistry { const key = JSON.stringify([arms.map(typeKey), discriminant]); let id = this.byKey.get(key); if (id === undefined) { - id = keyedHelperName(this, "u", key, ""); + id = `u${this.unions.length}`; const def: IrUnionDef = { id, arms, ...(discriminant ? { discriminant } : {}) }; this.byKey.set(key, id); this.byId.set(id, def); @@ -1173,10 +1115,6 @@ export interface TypeMapperCtx { * empty object type rule in the object mapping). */ emptyLiteralArm?: boolean; checker: ts.TypeChecker; - /** The structural position of a declaration (structural-positions.ts), - * which names recursive placeholders independently of where unrelated - * code sits. The Lowerer supplies it. */ - positionOf?: (node: ts.Node) => string; /** JavaScript declarations whose instance or object-literal types only * the checked-dynamic representation holds (js-dynamic-objects.ts). * Absent when the program has none: every mapping is unchanged. */ @@ -4713,10 +4651,7 @@ function mapTypeInner(type: ts.Type, ctx: TypeMapperCtx): IrType | null { const knownRecursive = unions.recursiveUnionFor(widened); if (knownRecursive !== undefined) return { kind: "union", unionId: knownRecursive }; if (unions.inProgress.has(widened)) { - return { - kind: "union", - unionId: unions.recursiveRef(widened, () => recursiveTypeName(widened, ctx)), - }; + return { kind: "union", unionId: unions.recursiveRef(widened) }; } unions.inProgress.add(widened); const sensitivityAtEntry = contextResolutions; @@ -7060,10 +6995,7 @@ function mapRecordType(widened: ts.Type, ctx: TypeMapperCtx): IrType | null { // frame completes (finalizeRecursive below). Backends represent records // as heap references, so the self-reference is an ordinary pointer. if (shapes.inProgress.has(widened)) { - return { - kind: "record", - shapeId: shapes.recursiveRef(widened, () => recursiveTypeName(widened, ctx)), - }; + return { kind: "record", shapeId: shapes.recursiveRef(widened) }; } shapes.inProgress.add(widened); const sensitivityAtEntry = contextResolutions; diff --git a/packages/compiler/test/array-pipeline-fusion.test.ts b/packages/compiler/test/array-pipeline-fusion.test.ts index 55cd0025e..f5d743265 100644 --- a/packages/compiler/test/array-pipeline-fusion.test.ts +++ b/packages/compiler/test/array-pipeline-fusion.test.ts @@ -26,7 +26,7 @@ function helperCalls(fn: IrFunction): string[] { everyStmtList(fn.body, { expr: (e) => { if (e.kind === "call" && e.callee.startsWith("%arr.")) - calls.push(e.callee.replace(/\.[0-9a-f]+$/, "")); + calls.push(e.callee.replace(/\.\d+$/, "")); return true; }, stmt: () => true, diff --git a/packages/compiler/test/format-float-arguments.test.ts b/packages/compiler/test/format-float-arguments.test.ts index 6ce9c4bc0..e59e023ca 100644 --- a/packages/compiler/test/format-float-arguments.test.ts +++ b/packages/compiler/test/format-float-arguments.test.ts @@ -27,7 +27,7 @@ test("util.format %f lowers a boolean argument once", async () => { const helpers = mod.functions .map((f) => f.name) .filter((name) => name.startsWith("%arr.")) - .map((name) => name.replace(/\.[0-9a-f]+$/, "")) + .map((name) => name.replace(/\.\d+$/, "")) .sort(); expect(helpers).toEqual(["%arr.every", "%arr.some"]); } finally { diff --git a/packages/compiler/test/in-runtime-key-emission.test.ts b/packages/compiler/test/in-runtime-key-emission.test.ts index 589685a7a..aebbb2ea4 100644 --- a/packages/compiler/test/in-runtime-key-emission.test.ts +++ b/packages/compiler/test/in-runtime-key-emission.test.ts @@ -55,7 +55,7 @@ const d: Record = {}; d["a"] = 1; console.log(has(d, "a"), has(d, "b")); `); - const helper = body(llvm, /sc_b?f__x25_rec_haskey_[0-9a-f]+/); + const helper = body(llvm, /sc_b?f__x25_rec_haskey_\d+/); expect(helper).toContain("@scr_map_has_str("); // Not a scan over a fresh key snapshot per probe. expect(helper).not.toContain("@scr_map_keys_js_order("); diff --git a/packages/compiler/test/stable-names.test.ts b/packages/compiler/test/stable-names.test.ts deleted file mode 100644 index 720472556..000000000 --- a/packages/compiler/test/stable-names.test.ts +++ /dev/null @@ -1,112 +0,0 @@ -import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises"; -import { tmpdir } from "node:os"; -import { join } from "node:path"; -import { expect, test } from "vitest"; -import { compile, deserializeModule, type IrModule } from "../src/index.js"; - -/** Lowers each source in turn as the same file, so names that include the - * file's path compare equal. */ -async function lower(...sources: string[]): Promise { - const dir = await mkdtemp(join(tmpdir(), "scriptc-stable-names-")); - try { - const entry = join(dir, "main.ts"); - const outPath = join(dir, "main.ir.json"); - const modules: IrModule[] = []; - for (const source of sources) { - await writeFile(entry, source); - const result = await compile(entry, { outDir: dir, outPath, outputKind: "ir" }); - if (!result.ok) - throw new Error(result.diagnostics.map((d) => `${d.code}: ${d.message}`).join("\n")); - modules.push(deserializeModule(await readFile(outPath, "utf8"))); - } - return modules; - } finally { - await rm(dir, { recursive: true, force: true }); - } -} - -function names(mod: IrModule): string[] { - return [ - ...mod.records.map((record) => record.id), - ...mod.unions.map((union) => union.id), - ...mod.functions.map((fn) => fn.name), - ...mod.classes.map((cls) => cls.name), - ].sort(); -} - -const recursive = ` -type Tree = { value: number; children: Tree[]; parent: Tree | null }; -function total(tree: Tree): number { - let sum = tree.value; - for (const child of tree.children) sum += total(child); - return sum; -} -const root: Tree = { value: 1, children: [], parent: null }; -root.children.push({ value: 2, children: [], parent: root }); -console.log(total(root)); -`; - -test("recursive record and union ids do not depend on the code above the type", async () => { - const [before, after] = await lower( - recursive, - `// A comment above the type.\n\ntype Unrelated = { name: string };\n\n${recursive}`, - ); - expect(before.records.some((record) => record.fields.some((f) => f.name === "children"))).toBe( - true, - ); - expect(names(after)).toEqual(names(before)); -}); - -test("recursive instantiations that print alike get distinct placeholders", async () => { - const [mod] = await lower(` -namespace A { - export class Item { - a = 1; - } -} -namespace B { - export class Item { - b = "b"; - } -} -type Chain = { item: T; next: Chain | null }; -const first: Chain = { item: new A.Item(), next: null }; -const second: Chain = { item: new B.Item(), next: null }; -first.next = { item: new A.Item(), next: null }; -second.next = { item: new B.Item(), next: null }; -console.log(first.next.item.a, second.next.item.b); -`); - const chains = mod.records.filter((record) => record.fields.some((f) => f.name === "next")); - expect(new Set(chains.map((record) => record.id)).size).toBe(chains.length); - expect(chains.length).toBeGreaterThanOrEqual(2); -}); - -test("a getter and a setter of one name keep their local classes apart", async () => { - const [mod] = await lower(` -class Box { - private v = 0; - get value(): number { - class Local { - n(): number { - return 1; - } - } - return new Local().n() + this.v; - } - set value(x: number) { - class Local { - n(): number { - return 2; - } - } - this.v = x * new Local().n(); - } -} -const box = new Box(); -box.value = 5; -console.log(box.value); -`); - const locals = mod.classes.filter((cls) => cls.name.includes("Local")); - expect(locals).toHaveLength(2); - expect(locals[0]!.name).not.toBe(locals[1]!.name); -}); diff --git a/packages/compiler/test/type-mapper-unions.test.ts b/packages/compiler/test/type-mapper-unions.test.ts index 684960002..c714df4d7 100644 --- a/packages/compiler/test/type-mapper-unions.test.ts +++ b/packages/compiler/test/type-mapper-unions.test.ts @@ -139,8 +139,7 @@ describe("checker and synthesized optional union identity", () => { nullable.arms.filter((arm) => arm.kind !== "nullT" && arm.kind !== "undefinedT"), ), ).toBe(required.unionId); - // Cases follow the arms, which are ordered by their type keys. - expect(nullable.discriminant!.cases.map((entry) => entry.values).sort()).toEqual([ + expect(nullable.discriminant!.cases.map((entry) => entry.values)).toEqual([ ["a", "alias"], ["b"], ]); From d426960f454e86bc8f53226e59b5a4db256f317c Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 01:55:38 -0500 Subject: [PATCH 028/102] Make Cipheriv and Decipheriv Transforms and accept function stages anywhere in pipeline() Cipheriv and Decipheriv values are Transforms, as in Node: they can be written and ended, piped into, used as pipeline() and stream/promises pipeline stages, composed, read, iterated with for await, read by stream/consumers, passed to finished(), and listened to, and their stream properties read as in Node. Each chunk goes through the cipher's update(), and the end pushes final() or reports its error through 'error'; writing after final() throws out of write(). The stream unit builds a cipher's Transform on its first stream use from operations the cipher's handle provides (ScrDynHandleOps.transform), so programs that use ciphers without streams link as before. The cipher is a collector-headered object behind a traced handle: its Transform's steps hold it, and the pair is reclaimed as a cycle. Through untyped values, in a program that uses streams, a cipher's stream properties and its on, once, off, pipe, unpipe, read, pause, resume, setEncoding, write, end, destroy, cork and uncork members run on its Transform; other stream members throw a coded SC2020 error. A Transform holds a write's callback while its readable side is at the high-water mark and runs it at the next read, and runs it on a tick once the readable side has ended, as Transform._write does. write() on a PassThrough, a Transform, a Hash or a cipher used to return true however much the readable side buffered. zlib streams applied the rule already and keep their timing. pipeline() accepts function stages anywhere among its streams, so runs of async generator stages can sit on both sides of a stream. A stage can be named by a function declaration, or a const bound to a function expression, that nothing reassigns; its body lowers again at the pipeline with its source typed by the pipeline. The source can also be an array, a string, a synchronous generator object, or a synchronous generator function without parameters: an async generator steps the source's iterator and yields each element, and the next stage receives each element on the same tick as with Node's for await over the source. The runtime's function-stage entry points take a bitmask of the function positions and one (next, read, return) helper triple for each generator pumped into a stream, so RUNTIME_ABI_VERSION is now 25. In JavaScript, the chunks a stage receives from the previous stage's generator read as the strings or Buffers it yields, so their string and Buffer methods compile. Corpus 7055-7059 cover cipher streams in TypeScript and JavaScript, their errors, close order and backpressure, the pipeline stages and sources with their tick order, and Transform backpressure. --- .../limitations/builtin-apis/crypto.mdx | 5 +- .../builtin-apis/streams-and-readline.mdx | 8 +- .../src/generated/node-v24-compatibility.json | 24 +- .../generated/node-v24-internal.json | 45 ++ internal/compatibility/src/generate.mjs | 2 +- internal/compatibility/static-support.json | 6 +- packages/cli/test/native-link-info.test.ts | 4 +- .../ambient/scriptc-node-fallback.d.ts | 7 +- .../compiler/src/backend/llvm/lib-shared.ts | 1 + .../compiler/src/backend/llvm/lib-stream.ts | 29 +- packages/compiler/src/backend/runtime-abi.ts | 4 +- .../src/backend/runtime-pack-targets.test.ts | 2 +- .../compiler/src/backend/runtime-pack.test.ts | 2 +- .../src/frontend/lowering/binding-analysis.ts | 10 +- .../src/frontend/lowering/builtins/crypto.ts | 5 +- .../frontend/lowering/builtins/hash-stream.ts | 133 +++++- .../src/frontend/lowering/containers/bytes.ts | 11 +- .../lowering/containers/iterator-helpers.ts | 4 +- .../src/frontend/lowering/dyn-streams.ts | 2 +- .../lowering/expressions/property-access.ts | 3 + .../src/frontend/lowering/lower-stmts.ts | 10 +- .../src/frontend/lowering/lower-stream.ts | 424 ++++++++++++++---- .../compiler/src/frontend/lowering/lowerer.ts | 15 +- packages/compiler/src/ir/builtin-effects.ts | 1 + .../compiler/src/ir/builtin-signatures.ts | 35 +- packages/compiler/src/ir/runtime-features.ts | 1 + packages/compiler/src/ir/validate.ts | 33 +- .../test/native-codegen-integration.test.ts | 4 +- .../tests/corpus/7055-cipher-streams.ts.json | 6 + .../corpus/7056-cipher-stream-errors.ts.json | 6 + .../tests/corpus/7057-cipher-streams.mjs.json | 6 + .../7058-pipeline-function-stages.mjs.json | 6 + .../7059-transform-backpressure.ts.json | 6 + .../runtime-darwin-arm64/scripts/build.mjs | 2 +- .../runtime-pack-common/scripts/build.mjs | 2 +- packages/runtime/src/scr_cipher.c | 132 +++++- packages/runtime/src/scr_console.c | 2 +- packages/runtime/src/scr_core.h | 2 +- packages/runtime/src/scr_dyn.h | 29 ++ packages/runtime/src/scr_json.c | 3 + packages/runtime/src/scr_stream.c | 386 ++++++++++++---- packages/runtime/src/scr_stream.h | 64 +-- packages/runtime/src/scr_stream_dyn.c | 5 +- packages/runtime/src/scr_zlib_stream.c | 3 +- tests/corpus/7055-cipher-streams.ts | 182 ++++++++ tests/corpus/7056-cipher-stream-errors.ts | 111 +++++ tests/corpus/7057-cipher-streams.mjs | 85 ++++ .../corpus/7058-pipeline-function-stages.mjs | 180 ++++++++ tests/corpus/7059-transform-backpressure.ts | 90 ++++ .../corpus-costs/7055-cipher-streams.ts.json | 1 + .../7056-cipher-stream-errors.ts.json | 1 + .../corpus-costs/7057-cipher-streams.mjs.json | 1 + .../7058-pipeline-function-stages.mjs.json | 1 + .../7059-transform-backpressure.ts.json | 1 + .../self-hosting-native-toolchain.test.ts | 2 +- 55 files changed, 1803 insertions(+), 342 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7055-cipher-streams.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7056-cipher-stream-errors.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7057-cipher-streams.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7058-pipeline-function-stages.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7059-transform-backpressure.ts.json create mode 100644 tests/corpus/7055-cipher-streams.ts create mode 100644 tests/corpus/7056-cipher-stream-errors.ts create mode 100644 tests/corpus/7057-cipher-streams.mjs create mode 100644 tests/corpus/7058-pipeline-function-stages.mjs create mode 100644 tests/corpus/7059-transform-backpressure.ts create mode 100644 tests/harness/corpus-costs/7055-cipher-streams.ts.json create mode 100644 tests/harness/corpus-costs/7056-cipher-stream-errors.ts.json create mode 100644 tests/harness/corpus-costs/7057-cipher-streams.mjs.json create mode 100644 tests/harness/corpus-costs/7058-pipeline-function-stages.mjs.json create mode 100644 tests/harness/corpus-costs/7059-transform-backpressure.ts.json diff --git a/docs/content/limitations/builtin-apis/crypto.mdx b/docs/content/limitations/builtin-apis/crypto.mdx index 3c830c63d..9ca6bfff4 100644 --- a/docs/content/limitations/builtin-apis/crypto.mdx +++ b/docs/content/limitations/builtin-apis/crypto.mdx @@ -8,7 +8,10 @@ `randomFill`, `randomFillSync` (every view kind and ArrayBuffer), `randomInt`, `randomUUID`, and `randomUUIDv7` follow Node 24.22, including callback timing; a `randomInt` callback whose error parameter is typed `Error | null` receives `null` where Node passes `undefined`. Scrypt supports its default parameters, numeric options, aliases, and memory limit. Both KDFs accept strings, Buffers, numeric typed arrays, DataViews, and fixed-length ArrayBuffers. - `createCipheriv` and `createDecipheriv` support aes-128, aes-192, and aes-256 in CBC, CTR, and GCM modes and chacha20-poly1305, on native targets, through `update()`, `final()`, `setAAD()`, `setAutoPadding()`, `getAuthTag()`, and `setAuthTag()`; other ciphers, cipher streams, and wasm32-wasi builds are refused. + `createCipheriv` and `createDecipheriv` support aes-128, aes-192, and aes-256 in CBC, CTR, and GCM modes and chacha20-poly1305, on native targets, through `update()`, `final()`, `setAAD()`, `setAutoPadding()`, `getAuthTag()`, and `setAuthTag()`; other ciphers and wasm32-wasi builds are refused. + Cipheriv and Decipheriv values are also Transforms: they can be written, piped into, used as `pipeline()` stages, read, iterated with `for await`, and listened to, and their stream properties read as in Node; written chunks go through `update()`, and the end pushes `final()` or reports its error through `'error'`. + Through `unknown` and `any` slots and untyped JavaScript, in a program that uses streams, their stream properties and their `on`, `once`, `off`, `pipe`, `unpipe`, `read`, `pause`, `resume`, `setEncoding`, `write`, `end`, `destroy`, `cork`, and `uncork` members work; `write` and `end` take no encoding or callback there, and the other stream members throw a coded SC2020 error. + Hash, Hmac, Cipheriv, and Decipheriv streams count a written string's bytes in `writableLength`, where Node counts the string's length. Decrypting chacha20-poly1305 without an authentication tag fails in `final()`; Node 24.22 returns unverified plaintext. After `update()` fails, for example past the AES-GCM limit of 2^36 - 32 bytes per message, every later call on that cipher throws; Node still lets `final()` run. An output encoding that is a function or an instance of a class defining `toString` throws a coded SC2020 error. diff --git a/docs/content/limitations/builtin-apis/streams-and-readline.mdx b/docs/content/limitations/builtin-apis/streams-and-readline.mdx index a21f7a617..b7c2e062e 100644 --- a/docs/content/limitations/builtin-apis/streams-and-readline.mdx +++ b/docs/content/limitations/builtin-apis/streams-and-readline.mdx @@ -3,14 +3,16 @@ `readable.pipe(process.stdout)` and `readable.pipe(process.stderr)` compile and, as in Node, do not end the process stream. When an untyped value reaches `NodeJS.ReadableStream` or `NodeJS.WritableStream`, those two interfaces hold any value, so JavaScript stream objects (constructor-function streams, plain objects with `on` and `pipe`) pass through TypeScript functions typed with them and come back to JavaScript as the same objects. Member calls on such a value use the native stream when it is one and call the object's own members otherwise; `readable.pipe()` into a JavaScript destination follows Node's pipe protocol. - A `pipeline` stage and a `for await` source that arrive as untyped values must be native streams at run time; other values throw a not-supported error. + A `pipeline` stage and a `for await` source that arrive as untyped values must be native streams, or `Cipheriv` and `Decipheriv` values, at run time; other values throw a not-supported error. Native streams expose no `emit` to JavaScript, so a JavaScript stream whose own `pipe()` emits on its destination (the legacy `Stream` pipe) cannot pipe into one. `Readable.from` accepts arrays, Sets, Map and Set iterators, generators, async generators, and class iterables and async iterables whose values are strings or Buffers, and in JavaScript any iterable or async iterable of them; a stream that mixes strings and Buffers is unsupported. In JavaScript, a sync iterator value with a `then` method that is not a promise, and an object whose `[Symbol.asyncIterator]` or `[Symbol.iterator]` method is a generator method, are unsupported. Object-mode streams of other values (including `Readable.from` over a `Map`, whose values are entry arrays) are unsupported. - `pipeline` accepts one run of function stages: async generator functions between streams (`async function* (source)`, iterating `source` with `for await`), an async generator source function (`async function* ({ signal })`), and an async function destination whose value resolves the promise form and reaches the callback's second argument. + `pipeline` accepts function stages anywhere among its streams: async generator functions (`async function* (source)`, iterating `source` with `for await`), an async generator source function (`async function* ({ signal })`), and an async function destination whose value resolves the promise form and reaches the callback's second argument. + A stage is written inline, or named by a function declaration or a `const` bound to a function expression that nothing reassigns. + The source may also be an array, a string, a synchronous generator object, or a synchronous generator function without parameters; their elements reach the next stage on the same ticks as in Node. Stages may take the `{ signal }` argument. - An async generator function as the destination, using the PassThrough that `pipeline()` returns for a function destination, several runs of function stages, and function stages together with pipeline options are unsupported. + An async generator function as the destination, using the PassThrough that `pipeline()` returns for a function destination, and function stages or iterable sources together with pipeline options are unsupported. `Readable.from` accepts `objectMode` and `highWaterMark` options. The `Readable` operators (`map`, `filter`, `forEach`, `toArray`, `some`, `find`, `every`, `flatMap`, `drop`, `take`, and `reduce`) accept `concurrency`, `highWaterMark`, and `signal` options; their callbacks take only the chunk, `map` returns strings or Buffers, and `flatMap` returns strings or arrays of them. `readable.compose` is unsupported. diff --git a/docs/src/generated/node-v24-compatibility.json b/docs/src/generated/node-v24-compatibility.json index 66b0ba3dd..d77322eb5 100644 --- a/docs/src/generated/node-v24-compatibility.json +++ b/docs/src/generated/node-v24-compatibility.json @@ -12581,7 +12581,7 @@ }, "static": { "status": "partial", - "detail": "Matches Node's update() output lengths, padding, authentication tags, string encodings, and state errors for the supported ciphers; the stream.Transform interface is refused.", + "detail": "Matches Node's update() output lengths, padding, authentication tags, string encodings, and state errors for the supported ciphers, and its stream.Transform behavior: chunks written through update(), final() pushed at the end, and its errors reported through 'error'.", "verification": "test-backed" } }, @@ -12604,7 +12604,7 @@ }, "static": { "status": "partial", - "detail": "Matches Node's update() output lengths, padding, authentication tags, string encodings, and state errors for the supported ciphers; the stream.Transform interface is refused.", + "detail": "Matches Node's update() output lengths, padding, authentication tags, string encodings, and state errors for the supported ciphers, and its stream.Transform behavior: chunks written through update(), final() pushed at the end, and its errors reported through 'error'.", "verification": "test-backed" } }, @@ -12627,7 +12627,7 @@ }, "static": { "status": "partial", - "detail": "Matches Node's update() output lengths, padding, authentication tags, string encodings, and state errors for the supported ciphers; the stream.Transform interface is refused.", + "detail": "Matches Node's update() output lengths, padding, authentication tags, string encodings, and state errors for the supported ciphers, and its stream.Transform behavior: chunks written through update(), final() pushed at the end, and its errors reported through 'error'.", "verification": "test-backed" } }, @@ -12650,7 +12650,7 @@ }, "static": { "status": "partial", - "detail": "Matches Node's update() output lengths, padding, authentication tags, string encodings, and state errors for the supported ciphers; the stream.Transform interface is refused.", + "detail": "Matches Node's update() output lengths, padding, authentication tags, string encodings, and state errors for the supported ciphers, and its stream.Transform behavior: chunks written through update(), final() pushed at the end, and its errors reported through 'error'.", "verification": "test-backed" } }, @@ -12673,7 +12673,7 @@ }, "static": { "status": "partial", - "detail": "Matches Node's update() output lengths, padding, authentication tags, string encodings, and state errors for the supported ciphers; the stream.Transform interface is refused.", + "detail": "Matches Node's update() output lengths, padding, authentication tags, string encodings, and state errors for the supported ciphers, and its stream.Transform behavior: chunks written through update(), final() pushed at the end, and its errors reported through 'error'.", "verification": "test-backed" } }, @@ -12696,7 +12696,7 @@ }, "static": { "status": "partial", - "detail": "Matches Node's update() output lengths, padding, authentication tags, string encodings, and state errors for the supported ciphers; the stream.Transform interface is refused.", + "detail": "Matches Node's update() output lengths, padding, authentication tags, string encodings, and state errors for the supported ciphers, and its stream.Transform behavior: chunks written through update(), final() pushed at the end, and its errors reported through 'error'.", "verification": "test-backed" } }, @@ -12719,7 +12719,7 @@ }, "static": { "status": "partial", - "detail": "Matches Node's update() output lengths, padding, authentication tags, string encodings, and state errors for the supported ciphers; the stream.Transform interface is refused.", + "detail": "Matches Node's update() output lengths, padding, authentication tags, string encodings, and state errors for the supported ciphers, and its stream.Transform behavior: chunks written through update(), final() pushed at the end, and its errors reported through 'error'.", "verification": "test-backed" } }, @@ -12742,7 +12742,7 @@ }, "static": { "status": "partial", - "detail": "Matches Node's update() output lengths, padding, authentication tags, string encodings, and state errors for the supported ciphers; the stream.Transform interface is refused.", + "detail": "Matches Node's update() output lengths, padding, authentication tags, string encodings, and state errors for the supported ciphers, and its stream.Transform behavior: chunks written through update(), final() pushed at the end, and its errors reported through 'error'.", "verification": "test-backed" } }, @@ -12765,7 +12765,7 @@ }, "static": { "status": "partial", - "detail": "Matches Node's update() output lengths, padding, authentication tags, string encodings, and state errors for the supported ciphers; the stream.Transform interface is refused.", + "detail": "Matches Node's update() output lengths, padding, authentication tags, string encodings, and state errors for the supported ciphers, and its stream.Transform behavior: chunks written through update(), final() pushed at the end, and its errors reported through 'error'.", "verification": "test-backed" } }, @@ -12788,7 +12788,7 @@ }, "static": { "status": "partial", - "detail": "Matches Node's update() output lengths, padding, authentication tags, string encodings, and state errors for the supported ciphers; the stream.Transform interface is refused.", + "detail": "Matches Node's update() output lengths, padding, authentication tags, string encodings, and state errors for the supported ciphers, and its stream.Transform behavior: chunks written through update(), final() pushed at the end, and its errors reported through 'error'.", "verification": "test-backed" } }, @@ -12811,7 +12811,7 @@ }, "static": { "status": "partial", - "detail": "Matches Node's update() output lengths, padding, authentication tags, string encodings, and state errors for the supported ciphers; the stream.Transform interface is refused.", + "detail": "Matches Node's update() output lengths, padding, authentication tags, string encodings, and state errors for the supported ciphers, and its stream.Transform behavior: chunks written through update(), final() pushed at the end, and its errors reported through 'error'.", "verification": "test-backed" } }, @@ -12834,7 +12834,7 @@ }, "static": { "status": "partial", - "detail": "Matches Node's update() output lengths, padding, authentication tags, string encodings, and state errors for the supported ciphers; the stream.Transform interface is refused.", + "detail": "Matches Node's update() output lengths, padding, authentication tags, string encodings, and state errors for the supported ciphers, and its stream.Transform behavior: chunks written through update(), final() pushed at the end, and its errors reported through 'error'.", "verification": "test-backed" } }, diff --git a/internal/compatibility/generated/node-v24-internal.json b/internal/compatibility/generated/node-v24-internal.json index c6a7a102c..537b8f05a 100644 --- a/internal/compatibility/generated/node-v24-internal.json +++ b/internal/compatibility/generated/node-v24-internal.json @@ -19313,6 +19313,9 @@ "tests/corpus/6703-ecdh-private-keys.ts", "tests/corpus/6704-ecdh-set-public-key.cjs", "tests/corpus/6705-ecdh-handles.ts", + "tests/corpus/7055-cipher-streams.ts", + "tests/corpus/7056-cipher-stream-errors.ts", + "tests/corpus/7057-cipher-streams.mjs", "tests/corpus/node24-crypto-kdf-errors.ts", "tests/corpus/node24-crypto-kdf-options.ts", "tests/corpus/node24-crypto-kdf.ts", @@ -19700,6 +19703,9 @@ "tests/corpus/5257-cipher-vectors.ts", "tests/corpus/5258-cipher-handles.js", "tests/corpus/5259-cipher-chunked.ts", + "tests/corpus/7055-cipher-streams.ts", + "tests/corpus/7056-cipher-stream-errors.ts", + "tests/corpus/7057-cipher-streams.mjs", "tests/fixtures/node-types/cipher.ts" ] }, @@ -19736,6 +19742,9 @@ "tests/corpus/5257-cipher-vectors.ts", "tests/corpus/5258-cipher-handles.js", "tests/corpus/5259-cipher-chunked.ts", + "tests/corpus/7055-cipher-streams.ts", + "tests/corpus/7056-cipher-stream-errors.ts", + "tests/corpus/7057-cipher-streams.mjs", "tests/fixtures/node-types/cipher.ts" ] }, @@ -21734,6 +21743,9 @@ "tests/corpus/5257-cipher-vectors.ts", "tests/corpus/5258-cipher-handles.js", "tests/corpus/5259-cipher-chunked.ts", + "tests/corpus/7055-cipher-streams.ts", + "tests/corpus/7056-cipher-stream-errors.ts", + "tests/corpus/7057-cipher-streams.mjs", "tests/fixtures/node-types/cipher.ts" ] }, @@ -21770,6 +21782,9 @@ "tests/corpus/5257-cipher-vectors.ts", "tests/corpus/5258-cipher-handles.js", "tests/corpus/5259-cipher-chunked.ts", + "tests/corpus/7055-cipher-streams.ts", + "tests/corpus/7056-cipher-stream-errors.ts", + "tests/corpus/7057-cipher-streams.mjs", "tests/fixtures/node-types/cipher.ts" ] }, @@ -21806,6 +21821,9 @@ "tests/corpus/5257-cipher-vectors.ts", "tests/corpus/5258-cipher-handles.js", "tests/corpus/5259-cipher-chunked.ts", + "tests/corpus/7055-cipher-streams.ts", + "tests/corpus/7056-cipher-stream-errors.ts", + "tests/corpus/7057-cipher-streams.mjs", "tests/fixtures/node-types/cipher.ts" ] }, @@ -21842,6 +21860,9 @@ "tests/corpus/5257-cipher-vectors.ts", "tests/corpus/5258-cipher-handles.js", "tests/corpus/5259-cipher-chunked.ts", + "tests/corpus/7055-cipher-streams.ts", + "tests/corpus/7056-cipher-stream-errors.ts", + "tests/corpus/7057-cipher-streams.mjs", "tests/fixtures/node-types/cipher.ts" ] }, @@ -21878,6 +21899,9 @@ "tests/corpus/5257-cipher-vectors.ts", "tests/corpus/5258-cipher-handles.js", "tests/corpus/5259-cipher-chunked.ts", + "tests/corpus/7055-cipher-streams.ts", + "tests/corpus/7056-cipher-stream-errors.ts", + "tests/corpus/7057-cipher-streams.mjs", "tests/fixtures/node-types/cipher.ts" ] }, @@ -21914,6 +21938,9 @@ "tests/corpus/5257-cipher-vectors.ts", "tests/corpus/5258-cipher-handles.js", "tests/corpus/5259-cipher-chunked.ts", + "tests/corpus/7055-cipher-streams.ts", + "tests/corpus/7056-cipher-stream-errors.ts", + "tests/corpus/7057-cipher-streams.mjs", "tests/fixtures/node-types/cipher.ts" ] }, @@ -21950,6 +21977,9 @@ "tests/corpus/5257-cipher-vectors.ts", "tests/corpus/5258-cipher-handles.js", "tests/corpus/5259-cipher-chunked.ts", + "tests/corpus/7055-cipher-streams.ts", + "tests/corpus/7056-cipher-stream-errors.ts", + "tests/corpus/7057-cipher-streams.mjs", "tests/fixtures/node-types/cipher.ts" ] }, @@ -21986,6 +22016,9 @@ "tests/corpus/5257-cipher-vectors.ts", "tests/corpus/5258-cipher-handles.js", "tests/corpus/5259-cipher-chunked.ts", + "tests/corpus/7055-cipher-streams.ts", + "tests/corpus/7056-cipher-stream-errors.ts", + "tests/corpus/7057-cipher-streams.mjs", "tests/fixtures/node-types/cipher.ts" ] }, @@ -22022,6 +22055,9 @@ "tests/corpus/5257-cipher-vectors.ts", "tests/corpus/5258-cipher-handles.js", "tests/corpus/5259-cipher-chunked.ts", + "tests/corpus/7055-cipher-streams.ts", + "tests/corpus/7056-cipher-stream-errors.ts", + "tests/corpus/7057-cipher-streams.mjs", "tests/fixtures/node-types/cipher.ts" ] }, @@ -22058,6 +22094,9 @@ "tests/corpus/5257-cipher-vectors.ts", "tests/corpus/5258-cipher-handles.js", "tests/corpus/5259-cipher-chunked.ts", + "tests/corpus/7055-cipher-streams.ts", + "tests/corpus/7056-cipher-stream-errors.ts", + "tests/corpus/7057-cipher-streams.mjs", "tests/fixtures/node-types/cipher.ts" ] }, @@ -22094,6 +22133,9 @@ "tests/corpus/5257-cipher-vectors.ts", "tests/corpus/5258-cipher-handles.js", "tests/corpus/5259-cipher-chunked.ts", + "tests/corpus/7055-cipher-streams.ts", + "tests/corpus/7056-cipher-stream-errors.ts", + "tests/corpus/7057-cipher-streams.mjs", "tests/fixtures/node-types/cipher.ts" ] }, @@ -22130,6 +22172,9 @@ "tests/corpus/5257-cipher-vectors.ts", "tests/corpus/5258-cipher-handles.js", "tests/corpus/5259-cipher-chunked.ts", + "tests/corpus/7055-cipher-streams.ts", + "tests/corpus/7056-cipher-stream-errors.ts", + "tests/corpus/7057-cipher-streams.mjs", "tests/fixtures/node-types/cipher.ts" ] }, diff --git a/internal/compatibility/src/generate.mjs b/internal/compatibility/src/generate.mjs index 9bd3927b8..cf77c1f84 100644 --- a/internal/compatibility/src/generate.mjs +++ b/internal/compatibility/src/generate.mjs @@ -594,7 +594,7 @@ function publicDetail(tier) { return "Matches Node's key formats, point encodings, private-key range checks, key-pair checks and errors on the supported curves; ECDH.convertKey is supported, and property reads and writes are refused."; } if (/^compiler-dedicated:(?:Cipheriv|Decipheriv|cipher\.|decipher\.)/.test(source)) { - return "Matches Node's update() output lengths, padding, authentication tags, string encodings, and state errors for the supported ciphers; the stream.Transform interface is refused."; + return "Matches Node's update() output lengths, padding, authentication tags, string encodings, and state errors for the supported ciphers, and its stream.Transform behavior: chunks written through update(), final() pushed at the end, and its errors reported through 'error'."; } if (source.startsWith("compiler-dedicated:")) return "Implemented by a dedicated static compiler/runtime path."; diff --git a/internal/compatibility/static-support.json b/internal/compatibility/static-support.json index 23c7a159b..0e608148f 100644 --- a/internal/compatibility/static-support.json +++ b/internal/compatibility/static-support.json @@ -42,8 +42,8 @@ "node-builtin.child_process": ["tests/corpus/1361-spawn-events.ts", "tests/corpus/1565-spawn-pipe-streams.ts", "tests/corpus/2911-execfile-callback.ts", "tests/corpus/2939-child-shell-text.ts", "tests/corpus/2946-child-fork-ipc/main.ts", "tests/corpus/3127-spawn-runtime-options.ts", "tests/corpus/3130-child-generic-streams.ts", "tests/corpus/3131-child-rest-listeners.js", "tests/corpus/3132-child-generic-stream-completion.ts"], "node-builtin.cluster": ["tests/corpus/957-builtins-namespace.ts"], "node-builtin.console": ["tests/corpus/console-imports.cjs", "tests/corpus/2440-console-inspect-args.ts", "tests/corpus/console-native-value.js", "tests/harness/npm-static.test.ts"], - "node-builtin.crypto.createCipheriv": ["tests/corpus/5250-cipher-aes-gcm.ts", "tests/corpus/5251-cipher-aes-cbc.ts", "tests/corpus/5252-cipher-aes-ctr.ts", "tests/corpus/5253-cipher-chacha20-poly1305.ts", "tests/corpus/5254-cipher-errors.js", "tests/corpus/5255-cipher-encodings.cjs", "tests/corpus/5256-cipher-deprecation.cjs", "tests/corpus/5257-cipher-vectors.ts", "tests/corpus/5258-cipher-handles.js", "tests/corpus/5259-cipher-chunked.ts", "tests/fixtures/node-types/cipher.ts"], - "node-builtin.crypto.createDecipheriv": ["tests/corpus/5250-cipher-aes-gcm.ts", "tests/corpus/5251-cipher-aes-cbc.ts", "tests/corpus/5252-cipher-aes-ctr.ts", "tests/corpus/5253-cipher-chacha20-poly1305.ts", "tests/corpus/5254-cipher-errors.js", "tests/corpus/5255-cipher-encodings.cjs", "tests/corpus/5256-cipher-deprecation.cjs", "tests/corpus/5257-cipher-vectors.ts", "tests/corpus/5258-cipher-handles.js", "tests/corpus/5259-cipher-chunked.ts", "tests/fixtures/node-types/cipher.ts"], + "node-builtin.crypto.createCipheriv": ["tests/corpus/5250-cipher-aes-gcm.ts", "tests/corpus/5251-cipher-aes-cbc.ts", "tests/corpus/5252-cipher-aes-ctr.ts", "tests/corpus/5253-cipher-chacha20-poly1305.ts", "tests/corpus/5254-cipher-errors.js", "tests/corpus/5255-cipher-encodings.cjs", "tests/corpus/5256-cipher-deprecation.cjs", "tests/corpus/5257-cipher-vectors.ts", "tests/corpus/5258-cipher-handles.js", "tests/corpus/5259-cipher-chunked.ts", "tests/corpus/7055-cipher-streams.ts", "tests/corpus/7056-cipher-stream-errors.ts", "tests/corpus/7057-cipher-streams.mjs", "tests/fixtures/node-types/cipher.ts"], + "node-builtin.crypto.createDecipheriv": ["tests/corpus/5250-cipher-aes-gcm.ts", "tests/corpus/5251-cipher-aes-cbc.ts", "tests/corpus/5252-cipher-aes-ctr.ts", "tests/corpus/5253-cipher-chacha20-poly1305.ts", "tests/corpus/5254-cipher-errors.js", "tests/corpus/5255-cipher-encodings.cjs", "tests/corpus/5256-cipher-deprecation.cjs", "tests/corpus/5257-cipher-vectors.ts", "tests/corpus/5258-cipher-handles.js", "tests/corpus/5259-cipher-chunked.ts", "tests/corpus/7055-cipher-streams.ts", "tests/corpus/7056-cipher-stream-errors.ts", "tests/corpus/7057-cipher-streams.mjs", "tests/fixtures/node-types/cipher.ts"], "node-builtin.crypto.createECDH": ["tests/corpus/6700-ecdh-shared-secret.ts", "tests/corpus/6701-ecdh-formats.ts", "tests/corpus/6702-ecdh-errors.js", "tests/corpus/6703-ecdh-private-keys.ts", "tests/corpus/6704-ecdh-set-public-key.cjs", "tests/corpus/6705-ecdh-handles.ts", "tests/fixtures/node-types/ecdh.ts"], "node-builtin.crypto": ["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"], "node-builtin.dgram": ["tests/corpus/2597-dgram-send-ladders.cjs"], @@ -412,7 +412,7 @@ { "symbols": ["assert.partialDeepStrictEqual"], "status": "partial", "evidence": ["tests/corpus/5517-assert-partial-deep-equal.js", "tests/corpus/5518-assert-partial-deep-typed.ts", "tests/corpus/5519-assert-partial-deep-typed-edges.ts"] }, { "symbols": ["assert.deepEqual", "assert.notDeepEqual"], "status": "partial", "evidence": ["tests/corpus/5513-assert-deep-equal-loose.js", "tests/corpus/5514-assert-deep-equal-typed.ts", "tests/corpus/5516-assert-deep-equal-edges.js"] }, { "symbols": ["assert", "assert.ok", "assert.equal", "assert.notEqual", "assert.strictEqual", "assert.notStrictEqual", "assert.deepStrictEqual", "assert.notDeepStrictEqual", "assert.fail", "assert.match", "assert.doesNotMatch", "assert.throws", "assert.rejects", "assert.ifError"], "status": "partial", "evidence": ["tests/corpus/1600-assert-passing.ts", "tests/corpus/1604-assert-deep-structures.ts", "tests/corpus/1609-assert-async.ts", "tests/corpus/1721-assert-throws-regex-class.ts", "tests/corpus/2936-static-loose-equality.ts", "tests/corpus/5515-assert-deep-strict-typed-messages.ts"] }, - { "chapter": "crypto", "symbols": ["Cipheriv", "cipher.update", "cipher.final", "cipher.setAAD", "cipher.getAuthTag", "cipher.setAutoPadding", "Decipheriv", "decipher.update", "decipher.final", "decipher.setAAD", "decipher.setAuthTag", "decipher.setAutoPadding"], "status": "partial", "evidence": ["tests/corpus/5250-cipher-aes-gcm.ts", "tests/corpus/5251-cipher-aes-cbc.ts", "tests/corpus/5252-cipher-aes-ctr.ts", "tests/corpus/5253-cipher-chacha20-poly1305.ts", "tests/corpus/5254-cipher-errors.js", "tests/corpus/5255-cipher-encodings.cjs", "tests/corpus/5256-cipher-deprecation.cjs", "tests/corpus/5257-cipher-vectors.ts", "tests/corpus/5258-cipher-handles.js", "tests/corpus/5259-cipher-chunked.ts", "tests/fixtures/node-types/cipher.ts"] }, + { "chapter": "crypto", "symbols": ["Cipheriv", "cipher.update", "cipher.final", "cipher.setAAD", "cipher.getAuthTag", "cipher.setAutoPadding", "Decipheriv", "decipher.update", "decipher.final", "decipher.setAAD", "decipher.setAuthTag", "decipher.setAutoPadding"], "status": "partial", "evidence": ["tests/corpus/5250-cipher-aes-gcm.ts", "tests/corpus/5251-cipher-aes-cbc.ts", "tests/corpus/5252-cipher-aes-ctr.ts", "tests/corpus/5253-cipher-chacha20-poly1305.ts", "tests/corpus/5254-cipher-errors.js", "tests/corpus/5255-cipher-encodings.cjs", "tests/corpus/5256-cipher-deprecation.cjs", "tests/corpus/5257-cipher-vectors.ts", "tests/corpus/5258-cipher-handles.js", "tests/corpus/5259-cipher-chunked.ts", "tests/corpus/7055-cipher-streams.ts", "tests/corpus/7056-cipher-stream-errors.ts", "tests/corpus/7057-cipher-streams.mjs", "tests/fixtures/node-types/cipher.ts"] }, { "chapter": "crypto", "symbols": ["ECDH", "ecdh.computeSecret", "ecdh.generateKeys", "ecdh.getPrivateKey", "ecdh.getPublicKey", "ecdh.setPrivateKey", "ecdh.setPublicKey"], "status": "partial", "evidence": ["tests/corpus/6700-ecdh-shared-secret.ts", "tests/corpus/6701-ecdh-formats.ts", "tests/corpus/6702-ecdh-errors.js", "tests/corpus/6703-ecdh-private-keys.ts", "tests/corpus/6704-ecdh-set-public-key.cjs", "tests/corpus/6705-ecdh-handles.ts", "tests/fixtures/node-types/ecdh.ts"] }, { "chapter": "errors", "symbols": ["ERR_CRYPTO_ECDH_INVALID_FORMAT", "ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY"], "status": "partial", "evidence": ["tests/corpus/6702-ecdh-errors.js"] }, { "symbols": ["crypto.createHash", "Hash", "hash.update", "hash.digest", "hash.copy", "crypto.createHmac", "Hmac", "hmac.update", "hmac.digest", "crypto.hash", "crypto.pbkdf2", "crypto.pbkdf2Sync"], "status": "partial", "evidence": ["tests/corpus/5760-crypto-hash-stream.ts", "tests/corpus/5768-crypto-hash-unknown.ts", "tests/corpus/5769-crypto-hash-unknown.cjs", "tests/corpus/5761-crypto-hash-stream-states.ts", "tests/corpus/5762-crypto-hash-stream.cjs", "tests/corpus/2890-crypto-static-utility.ts", "tests/corpus/node24-crypto-sha2.ts", "tests/corpus/5435-crypto-hash-algorithms.ts", "tests/corpus/5436-crypto-hash-names.js", "tests/corpus/5437-crypto-hmac-algorithms.ts", "tests/corpus/5438-crypto-kdf-digests.ts", "tests/corpus/5440-crypto-hash-encodings.js", "tests/corpus/5441-crypto-hash-output-length.ts", "tests/harness/npm-static.test.ts"] }, diff --git a/packages/cli/test/native-link-info.test.ts b/packages/cli/test/native-link-info.test.ts index f5ff2642e..56ca46878 100644 --- a/packages/cli/test/native-link-info.test.ts +++ b/packages/cli/test/native-link-info.test.ts @@ -72,7 +72,7 @@ describe.runIf(supported)("macOS arm64 native link info", () => { minimum_os: "14.0", }, program: { object, entry_symbol: "main" }, - runtime_abi: { version: 24, marker: "scr_runtime_abi_v24" }, + runtime_abi: { version: 25, marker: "scr_runtime_abi_v25" }, runtime_pack: { kind: "precompiled", package: "@scriptc/runtime-darwin-arm64", @@ -165,6 +165,6 @@ describe.runIf(supported)("macOS arm64 native link info", () => { () => null, (failure: { stderr?: string }) => failure, ); - expect(error?.stderr).toContain("scr_runtime_abi_v24"); + expect(error?.stderr).toContain("scr_runtime_abi_v25"); }); }); diff --git a/packages/compiler/ambient/scriptc-node-fallback.d.ts b/packages/compiler/ambient/scriptc-node-fallback.d.ts index dbb3cd8fd..16d7b9845 100644 --- a/packages/compiler/ambient/scriptc-node-fallback.d.ts +++ b/packages/compiler/ambient/scriptc-node-fallback.d.ts @@ -2852,7 +2852,8 @@ declare module "crypto" { ): void; export type BinaryLike = string | ArrayBuffer | ArrayBufferView; /* Cipheriv/Decipheriv: aes-128/192/256 in cbc, ctr, and gcm modes and - * chacha20-poly1305. The stream.Transform members are not declared. */ + * chacha20-poly1305. Both are Transforms: written chunks go through + * update(), and the end pushes final(). */ export type CipherGCMTypes = "aes-128-gcm" | "aes-192-gcm" | "aes-256-gcm"; export type CipherChaCha20Poly1305Types = "chacha20-poly1305"; export type CipherKey = BinaryLike | KeyObject; @@ -2862,7 +2863,7 @@ declare module "crypto" { export interface CipherChaCha20Poly1305Options { authTagLength?: number; } - export interface Cipheriv { + export interface Cipheriv extends Transform { update(data: string | ArrayBufferView): Buffer; update(data: string, inputEncoding: BufferEncoding): Buffer; update(data: ArrayBufferView, inputEncoding: undefined, outputEncoding: BufferEncoding): string; @@ -2883,7 +2884,7 @@ declare module "crypto" { setAAD(buffer: ArrayBufferView, options?: { plaintextLength: number }): this; getAuthTag(): Buffer; } - export interface Decipheriv { + export interface Decipheriv extends Transform { update(data: ArrayBufferView): Buffer; update(data: string, inputEncoding: BufferEncoding): Buffer; update(data: ArrayBufferView, inputEncoding: undefined, outputEncoding: BufferEncoding): string; diff --git a/packages/compiler/src/backend/llvm/lib-shared.ts b/packages/compiler/src/backend/llvm/lib-shared.ts index 8bb8bc3aa..524d5939d 100644 --- a/packages/compiler/src/backend/llvm/lib-shared.ts +++ b/packages/compiler/src/backend/llvm/lib-shared.ts @@ -754,6 +754,7 @@ export const LIB_FN_SYMS: Record = { "procStream.write": "scr_proc_stream_write", "stream.stdioWritable": "scr_stream_stdio_writable", "stream.unboxDyn": "scr_stream_unbox_dyn", + "stream.handleStream": "scr_stream_handle", "stream.pipeDyn": "scr_stream_pipe_dyn", "stream.unpipeDyn": "scr_stream_unpipe_dyn", "process.kill": "scr_process_kill_named", diff --git a/packages/compiler/src/backend/llvm/lib-stream.ts b/packages/compiler/src/backend/llvm/lib-stream.ts index d3b4b1f5b..5d198d306 100644 --- a/packages/compiler/src/backend/llvm/lib-stream.ts +++ b/packages/compiler/src/backend/llvm/lib-stream.ts @@ -2,6 +2,7 @@ import { InternalCompilerError } from "../../errors.js"; import type { LlvmEmitterContext, LibCallExpr, LlValue } from "./expr-context.js"; import { f64Lit } from "./common.js"; +import { pipelinePumpedRuns } from "../../ir/builtin-signatures.js"; const STREAM_CANONICAL_CBS: Record = { readable: ["r", "d"], @@ -662,14 +663,14 @@ export function emitStreamLibCall(host: LlvmEmitterContext, e: LibCallExpr): LlV e.fn === "stream.pipelineStages" || e.fn === "stream.pipelineStagesDyn" ) { - // (n, at, k, flags, mask, s1..sn, stage1..stagek, (next, read, - // return)?, box?, (signal, abort)?[, cb]): the streams and the stage - // closures ride stack arrays; absent groups pass null. - const [nArg, atArg, kArg, flagsArg, maskArg] = e.args; + // (n, k, positions, flags, mask, s1..sn, stage1..stagek, helpers..., + // box?, (signal, abort)?[, cb]): the streams, the stage closures and + // the helpers ride stack arrays; absent groups pass null. + const [nArg, kArg, positionsArg, flagsArg, maskArg] = e.args; if ( nArg?.kind !== "numLit" || - atArg?.kind !== "numLit" || kArg?.kind !== "numLit" || + positionsArg?.kind !== "numLit" || flagsArg?.kind !== "numLit" || maskArg?.kind !== "numLit" ) @@ -677,6 +678,7 @@ export function emitStreamLibCall(host: LlvmEmitterContext, e: LibCallExpr): LlV const n = nArg.value; const k = kArg.value; const flags = flagsArg.value; + const helperCount = 3 * pipelinePumpedRuns(n + k, positionsArg.value); const args = e.args.map((a) => host.emitExpr(a)); const packed = (from: number, count: number): string => { if (count === 0) return "null"; @@ -691,20 +693,17 @@ export function emitStreamLibCall(host: LlvmEmitterContext, e: LibCallExpr): LlV }; const streams = packed(5, n); const stages = packed(5 + n, k); - let at = 5 + n + k; + const helpers = packed(5 + n + k, helperCount); + let at = 5 + n + k + helperCount; const take = (present: boolean): string => (present ? args[at++]!.name : "null"); - const hasHelpers = (flags & 8) !== 0; - const next = take(hasHelpers); - const read = take(hasHelpers); - const ret = take(hasHelpers); - const box = take((flags & 16) !== 0); + const box = take(((flags >> 1) & 3) === 2); const signal = take((flags & 32) !== 0); const abort = take((flags & 32) !== 0); const head = - `double ${f64Lit(n)}, ptr ${streams}, double ${f64Lit(atArg.value)}, double ${f64Lit(k)}, ` + - `ptr ${stages}, double ${f64Lit(flags)}, double ${f64Lit(maskArg.value)}, ` + - `ptr ${next}, ptr ${read}, ptr ${ret}, ptr ${box}, ptr ${signal}, ptr ${abort}`; - const params = "double, ptr, double, double, ptr, double, double, ptr, ptr, ptr, ptr, ptr, ptr"; + `double ${f64Lit(n)}, ptr ${streams}, double ${f64Lit(k)}, ptr ${stages}, ` + + `double ${f64Lit(positionsArg.value)}, double ${f64Lit(flags)}, double ${f64Lit(maskArg.value)}, ` + + `ptr ${helpers}, ptr ${box}, ptr ${signal}, ptr ${abort}`; + const params = "double, ptr, double, ptr, double, double, double, ptr, ptr, ptr, ptr"; const t = B.tmp(); if (e.fn === "sp.pipelineStages") { host.declare(`declare ptr @scr_sp_pipeline_stages(${params})`); diff --git a/packages/compiler/src/backend/runtime-abi.ts b/packages/compiler/src/backend/runtime-abi.ts index 5eb24482b..f02510338 100644 --- a/packages/compiler/src/backend/runtime-abi.ts +++ b/packages/compiler/src/backend/runtime-abi.ts @@ -2,8 +2,8 @@ * of the link contract: a program object keeps this symbol undefined and the * matching runtime defines it, so incompatible manual links fail before the * program can start. */ -export const RUNTIME_ABI_VERSION = 24 as const; -export const RUNTIME_ABI_MARKER = "scr_runtime_abi_v24" as const; +export const RUNTIME_ABI_VERSION = 25 as const; +export const RUNTIME_ABI_MARKER = "scr_runtime_abi_v25" as const; /** Object consumption is useful today, but the complete scr_* surface may * still change before 1.0. The versioned marker prevents accidental mixing; diff --git a/packages/compiler/src/backend/runtime-pack-targets.test.ts b/packages/compiler/src/backend/runtime-pack-targets.test.ts index fc7ed9efa..8bdbc8492 100644 --- a/packages/compiler/src/backend/runtime-pack-targets.test.ts +++ b/packages/compiler/src/backend/runtime-pack-targets.test.ts @@ -52,7 +52,7 @@ async function fixture(target: NativeTargetSpec, workers = false) { object_format: target.objectFormat, minimum_os: target.minimumOs, }, - runtime_abi: { version: 24, marker: "scr_runtime_abi_v24" }, + runtime_abi: { version: 25, marker: "scr_runtime_abi_v25" }, compiler: { command: "fixture", identity: "fixture", target: target.llvmTriple }, macros: { executable: [], excluded: ["SCR_LIB"], sanitizer: "external-toolchain-required" }, flavors: { diff --git a/packages/compiler/src/backend/runtime-pack.test.ts b/packages/compiler/src/backend/runtime-pack.test.ts index 5ffb4797d..a3ac9fe5d 100644 --- a/packages/compiler/src/backend/runtime-pack.test.ts +++ b/packages/compiler/src/backend/runtime-pack.test.ts @@ -124,7 +124,7 @@ async function fixture(target: NativeTargetSpec = MACOS_ARM64_TARGET) { object_format: target.objectFormat, minimum_os: target.minimumOs, }, - runtime_abi: { version: 24, marker: "scr_runtime_abi_v24" }, + runtime_abi: { version: 25, marker: "scr_runtime_abi_v25" }, compiler: { command: "clang", identity: "fixture clang", diff --git a/packages/compiler/src/frontend/lowering/binding-analysis.ts b/packages/compiler/src/frontend/lowering/binding-analysis.ts index 83b9aa6f9..1987c86ba 100644 --- a/packages/compiler/src/frontend/lowering/binding-analysis.ts +++ b/packages/compiler/src/frontend/lowering/binding-analysis.ts @@ -10,7 +10,13 @@ import { isGenericCallableMemberType } from "../type-mapper.js"; * Sound file-locally for module-scope bindings because ESM import * bindings are read-only — no other file can write one. Cached per * symbol (the scan walks the whole file once). */ -export function bindingNeverReassigned(lowerer: Lowerer, sym: ts.Symbol, decl: ts.Node): boolean { +export function bindingNeverReassigned( + lowerer: Lowerer, + sym: ts.Symbol, + decl: ts.Node, + resolve: (ident: ts.Identifier) => ts.Symbol | null | undefined = (ident) => + lowerer.resolveValueSymbol(ident), +): boolean { const cached = lowerer.neverReassignedCache.get(sym); if (cached !== undefined) return cached; let written = false; @@ -18,7 +24,7 @@ export function bindingNeverReassigned(lowerer: Lowerer, sym: ts.Symbol, decl: t // identifiers pay a symbol resolution. const symText = ts.symbolName(sym); const namesSym = (e: ts.Node): boolean => - ts.isIdentifier(e) && e.text === symText && lowerer.resolveValueSymbol(e) === sym; + ts.isIdentifier(e) && e.text === symText && resolve(e) === sym; const scanTarget = (t: ts.Expression): void => { let e: ts.Expression = t; while (ts.isParenthesizedExpression(e)) e = e.expression; diff --git a/packages/compiler/src/frontend/lowering/builtins/crypto.ts b/packages/compiler/src/frontend/lowering/builtins/crypto.ts index f4270dbe8..3dd3a4278 100644 --- a/packages/compiler/src/frontend/lowering/builtins/crypto.ts +++ b/packages/compiler/src/frontend/lowering/builtins/crypto.ts @@ -907,7 +907,8 @@ export function v8CalleeText(node: ts.Expression): string { /** Calls on native Cipheriv/Decipheriv handles dispatch through the * handle's methods with checked-dynamic arguments. The stream.Transform - * members the classes inherit are refused. */ + * members the classes inherit lower over the cipher's Transform + * (lowerHashStreamCall, which runs first); other members are refused. */ export function lowerCipherMethodCall( lowerer: Lowerer, call: ts.CallExpression, @@ -920,7 +921,7 @@ export function lowerCipherMethodCall( lowerer.noLowering( `Cipheriv/Decipheriv.${name}`, call, - "update(), final(), setAAD(), setAutoPadding(), getAuthTag(), and setAuthTag() are supported; cipher streams are not", + "update(), final(), setAAD(), setAutoPadding(), getAuthTag(), setAuthTag(), and the stream members are supported", ); } if (call.arguments.nodes.some(ts.isSpreadElement)) diff --git a/packages/compiler/src/frontend/lowering/builtins/hash-stream.ts b/packages/compiler/src/frontend/lowering/builtins/hash-stream.ts index 382d15eaf..f2f3625dd 100644 --- a/packages/compiler/src/frontend/lowering/builtins/hash-stream.ts +++ b/packages/compiler/src/frontend/lowering/builtins/hash-stream.ts @@ -1,17 +1,27 @@ import * as ts from "../../ts7/adapter.js"; import { type Lowerer } from "../lowerer.js"; import { locOf } from "../../program.js"; +import type { SrcLoc } from "../../../ir/ir.js"; import { varRef } from "../../../ir/build.js"; -import { type IrExpr, type IrType } from "../../../ir/ir.js"; +import { type IrExpr, type IrStmt, type IrType } from "../../../ir/ir.js"; +import { withStreamReceiver } from "../dyn-streams.js"; import { EMITTER_API_MEMBERS } from "../lower-classes.js"; import { lowerEmitterMethodCall } from "../lower-event-emitter.js"; -import { STREAM_API_MEMBERS, STREAM_OPERATORS, lowerStreamMethodCall } from "../lower-stream.js"; +import { + STREAM_API_MEMBERS, + STREAM_OPERATORS, + lowerStreamMethodCall, + lowerStreamProperty, +} from "../lower-stream.js"; +import { isCipherType } from "./crypto.js"; -/* node:crypto's Hash and Hmac are Transforms: a value written, read, - * listened to, or piped as a stream reads and writes through its own - * native Transform (scr_stream.c), created on first use. update() and - * digest() keep the value's static lowering; the stream members lower - * through the stream and emitter spokes over that Transform. */ +/* node:crypto's Hash, Hmac, Cipheriv and Decipheriv are Transforms: a + * value written, read, listened to, or piped as a stream reads and writes + * through its own native Transform, which scr_stream.c creates on first + * use. update(), digest() and final() keep the value's own lowering; the + * stream members lower through the stream and emitter spokes over that + * Transform. A Hash or Hmac is known by its IR type; a cipher is a + * checked-dynamic handle and is known by its checker type. */ const TRANSFORM_CLASS = "%Transform"; const TRANSFORM: IrType = { kind: "object", className: TRANSFORM_CLASS }; @@ -20,6 +30,12 @@ export function isHashValueType(type: IrType | null | undefined): boolean { return type?.kind === "cryptoHash" || type?.kind === "cryptoHmac"; } +/** Whether `node` evaluates to a Hash, Hmac, Cipheriv or Decipheriv. */ +export function isValueStream(lowerer: Lowerer, node: ts.Expression): boolean { + const type = lowerer.typeOf(node); + return isHashValueType(lowerer.mapTypeOf(type)) || isCipherType(lowerer, type); +} + /** The Transform of a lowered Hash or Hmac value (+1). A pipe * destination or pipeline stage (`piped`) also keeps the value alive * until its stream flushes or is destroyed. */ @@ -33,9 +49,27 @@ export function hashStreamOf(value: IrExpr, piped = false): IrExpr { }; } -/** A stream member called on a Hash or Hmac (`hash.write(chunk)`, - * `hash.on("data", cb)`, `hash.setEncoding("hex")`). Members that answer - * the stream (`this`) answer the Hash itself. */ +/** The Transform of a lowered Hash, Hmac, Cipheriv or Decipheriv value + * (+1), with hashStreamOf's `piped` (a cipher's stream always holds its + * cipher). */ +export function valueStreamOf(value: IrExpr, piped = false): IrExpr { + if (isHashValueType(value.type)) return hashStreamOf(value, piped); + // A value already lowered as its stream (addAbortSignal answers the + // Transform it was given, which its generic signature types as the + // cipher). + if (value.type.kind === "object") return value; + return { + kind: "libCall", + fn: "stream.handleStream", + args: [value], + type: TRANSFORM, + loc: value.loc, + }; +} + +/** A stream member called on a Hash, Hmac, Cipheriv or Decipheriv + * (`hash.write(chunk)`, `cipher.on("data", cb)`, `hash.setEncoding("hex")`). + * Members that answer the stream (`this`) answer the value itself. */ export function lowerHashStreamCall( lowerer: Lowerer, call: ts.CallExpression, @@ -45,21 +79,48 @@ export function lowerHashStreamCall( const name = access.name.text; const streamMember = STREAM_API_MEMBERS.has(name) || STREAM_OPERATORS.has(name); if (!streamMember && !EMITTER_API_MEMBERS.has(name)) return null; - if (!isHashValueType(lowerer.mapTypeOf(lowerer.typeOf(access.expression)))) return null; + if (!isValueStream(lowerer, access.expression)) return null; const info = lowerer.classes.get(TRANSFORM_CLASS); if (!info) return null; - const loc = locOf(call); - const hash = lowerer.lowerExpr(access.expression); - const local = lowerer.declareHiddenLocal("%hash", hash.type); - // The spokes lower the receiver to the value's Transform. - lowerer.hashStreamReceivers.set(access.expression, { localId: local.id, type: hash.type }); + return withValueStreamReceiver(lowerer, access.expression, locOf(call), () => + streamMember + ? lowerStreamMethodCall(lowerer, call, access, info) + : lowerEmitterMethodCall(lowerer, call, access, info), + ); +} + +/** A stream property read on a Hash, Hmac, Cipheriv or Decipheriv + * (`cipher.destroyed`, `hash.readableEnded`). */ +export function lowerValueStreamProperty( + lowerer: Lowerer, + expr: ts.PropertyAccessExpression, +): IrExpr | null { + if (expr.questionDotToken || !isValueStream(lowerer, expr.expression)) return null; + const info = lowerer.classes.get(TRANSFORM_CLASS); + if (!info) return null; + return withValueStreamReceiver(lowerer, expr.expression, locOf(expr), () => + lowerStreamProperty(lowerer, expr, info), + ); +} + +/** Evaluates the value `receiver` names once into a hidden local and runs + * `lower` with the receiver lowering to that value's Transform. A result + * typed as the Transform (a member that answers `this`) answers the value + * itself. */ +function withValueStreamReceiver( + lowerer: Lowerer, + receiver: ts.Expression, + loc: SrcLoc, + lower: () => IrExpr | null, +): IrExpr | null { + const value = lowerer.lowerExpr(receiver); + const local = lowerer.declareHiddenLocal("%streamValue", value.type); + lowerer.valueStreamReceivers.set(receiver, { localId: local.id, type: value.type }); let lowered: IrExpr | null; try { - lowered = streamMember - ? lowerStreamMethodCall(lowerer, call, access, info) - : lowerEmitterMethodCall(lowerer, call, access, info); + lowered = lower(); } finally { - lowerer.hashStreamReceivers.delete(access.expression); + lowerer.valueStreamReceivers.delete(receiver); } if (!lowered) return null; const answersStream = @@ -68,16 +129,42 @@ export function lowerHashStreamCall( ? { kind: "seqExpr", stmts: [{ kind: "exprStmt", expr: lowered, loc }], - result: varRef(local.id, hash.type, loc), - type: hash.type, + result: varRef(local.id, value.type, loc), + type: value.type, loc, } : lowered; return { kind: "seqExpr", - stmts: [{ kind: "varDecl", localId: local.id, init: hash, loc }], + stmts: [{ kind: "varDecl", localId: local.id, init: value, loc }], result, type: result.type, loc, }; } + +/** `for await (const chunk of value)` over a Hash, Hmac, Cipheriv or + * Decipheriv: the loop iterates the value's Transform. */ +export function lowerForAwaitValueStream( + lowerer: Lowerer, + stmt: ts.ForOfStatement, + lowerLoop: () => IrStmt | null, +): IrStmt | null { + if (!isValueStream(lowerer, stmt.expression)) return null; + const loc = locOf(stmt.expression); + const local = lowerer.declareHiddenLocal("%streamIterated", TRANSFORM); + const init = valueStreamOf(lowerer.lowerExpr(stmt.expression)); + const loop = withStreamReceiver( + lowerer, + stmt.expression, + varRef(local.id, TRANSFORM, loc), + TRANSFORM, + lowerLoop, + ); + if (loop === null) return null; + return { + kind: "block", + body: [{ kind: "varDecl", localId: local.id, init, loc }, loop], + loc: locOf(stmt), + }; +} diff --git a/packages/compiler/src/frontend/lowering/containers/bytes.ts b/packages/compiler/src/frontend/lowering/containers/bytes.ts index 4b20d7bf5..32fb03644 100644 --- a/packages/compiler/src/frontend/lowering/containers/bytes.ts +++ b/packages/compiler/src/frontend/lowering/containers/bytes.ts @@ -1078,11 +1078,20 @@ export function lowerBytesMethodCall( // Array-toString (comma join), a different operation: fenced. const declaredOnBuffer = (() => { const nameSym = lowerer.checker.getSymbolAtLocation(access.name); - return ( + if ( nameSym !== undefined && nameSym.declarations.some( (d) => ts.isInterfaceDeclaration(d.parent) && d.parent.name.text === "Buffer", ) + ) + return true; + // A receiver the lowering types as a Buffer where the checker says + // `any` (a JavaScript pipeline stage's chunk). + const receiverSym = lowerer.typeOf(access.expression).getSymbol(); + return ( + receiverSym !== undefined && + ts.symbolName(receiverSym) === "Buffer" && + receiverSym.declarations.some((d) => lowerer.isStdlibFile(ts.getSourceFileOfNode(d))) ); })(); if (receiverIr.elem !== "u8" || !declaredOnBuffer) { diff --git a/packages/compiler/src/frontend/lowering/containers/iterator-helpers.ts b/packages/compiler/src/frontend/lowering/containers/iterator-helpers.ts index 48b4caabd..ba5d0684d 100644 --- a/packages/compiler/src/frontend/lowering/containers/iterator-helpers.ts +++ b/packages/compiler/src/frontend/lowering/containers/iterator-helpers.ts @@ -1223,7 +1223,7 @@ class HostFrame implements ChainFrame { /** The locals and parameters of a lifted helper function under * construction. */ -class LiftedFrame implements ChainFrame { +export class LiftedFrame implements ChainFrame { readonly locals: IrLocal[] = []; readonly params: IrParam[] = []; private n = 0; @@ -1253,7 +1253,7 @@ class LiftedFrame implements ChainFrame { * step leave it unclosed, as in Node. The generator counts as unfinished * before the first step, so a `pre` that breaks at once (take(0)) closes * a source it never pulled. `genT` must be stepDrivable. */ -function driveGenerator( +export function driveGenerator( lowerer: Lowerer, frame: ChainFrame, genId: string, diff --git a/packages/compiler/src/frontend/lowering/dyn-streams.ts b/packages/compiler/src/frontend/lowering/dyn-streams.ts index 2ac09e8e5..2167eba23 100644 --- a/packages/compiler/src/frontend/lowering/dyn-streams.ts +++ b/packages/compiler/src/frontend/lowering/dyn-streams.ts @@ -76,7 +76,7 @@ function dynNativeStream( /** Runs `lower` with `node` lowering to `value` and its member calls taking * `type` as the receiver representation. */ -function withStreamReceiver( +export function withStreamReceiver( lowerer: Lowerer, node: ts.Expression, value: IrExpr, diff --git a/packages/compiler/src/frontend/lowering/expressions/property-access.ts b/packages/compiler/src/frontend/lowering/expressions/property-access.ts index 6c8dfa3bf..4d8e4d52c 100644 --- a/packages/compiler/src/frontend/lowering/expressions/property-access.ts +++ b/packages/compiler/src/frontend/lowering/expressions/property-access.ts @@ -132,6 +132,7 @@ import { lowerProtocolPropertyRead } from "../class-protocol-dispatch.js"; import { lowerReadlineProperty } from "../builtins/readline.js"; import { lowerEventStaticProperty } from "../builtins/numbers.js"; import { lowerStreamProperty, lowerStreamStateProperty, streamSidesOf } from "../lower-stream.js"; +import { lowerValueStreamProperty } from "../builtins/hash-stream.js"; import { lowerEventObjectProperty } from "../lower-event-target.js"; import { iteratorResultValueRead } from "../lower-generators.js"; import { lowerGlobalValue } from "../lower-global-value.js"; @@ -3995,6 +3996,8 @@ function lowerStreamObjectProperty( expr: ts.PropertyAccessExpression, ): IrExpr | null { if (expr.questionDotToken && !lowerer.chainHandled.has(expr)) return null; + const valueStream = lowerValueStreamProperty(lowerer, expr); + if (valueStream) return valueStream; const recvT = lowerer.mapTypeOf(lowerer.typeOf(expr.expression)); if (recvT?.kind !== "object") return null; const info = lowerer.classes.get(recvT.className); diff --git a/packages/compiler/src/frontend/lowering/lower-stmts.ts b/packages/compiler/src/frontend/lowering/lower-stmts.ts index e3480cf9c..bc3d2e869 100644 --- a/packages/compiler/src/frontend/lowering/lower-stmts.ts +++ b/packages/compiler/src/frontend/lowering/lower-stmts.ts @@ -3,6 +3,7 @@ import { declaredMemberOf, isPromisePrototypeRead } from "./expressions/property import { hostsAll } from "./expressions/hosted-narrowing.js"; import { requestGeneralStreamSurface } from "./general-streams.js"; import { lowerForAwaitDynStream } from "./dyn-streams.js"; +import { lowerForAwaitValueStream } from "./builtins/hash-stream.js"; import { lowerChildPropertyWrite } from "./handle-properties.js"; import { matchAllRowsReadByElements, @@ -9390,10 +9391,11 @@ export function lowerForOf(lowerer: Lowerer, stmt: ts.ForOfStatement): IrStmt { ) { return lowerForAwaitStdin(lowerer, stmt); } - // A checked-dynamic NodeJS.ReadableStream iterates its native stream. - const dynStream = lowerForAwaitDynStream(lowerer, stmt, () => - lowerForAwaitBuiltin(lowerer, stmt), - ); + // A checked-dynamic NodeJS.ReadableStream iterates its native stream, + // and a Hash, Hmac, Cipheriv or Decipheriv iterates its Transform. + const dynStream = + lowerForAwaitDynStream(lowerer, stmt, () => lowerForAwaitBuiltin(lowerer, stmt)) ?? + lowerForAwaitValueStream(lowerer, stmt, () => lowerForAwaitBuiltin(lowerer, stmt)); if (dynStream) return dynStream; const builtin = lowerForAwaitBuiltin(lowerer, stmt); if (builtin) return builtin; diff --git a/packages/compiler/src/frontend/lowering/lower-stream.ts b/packages/compiler/src/frontend/lowering/lower-stream.ts index a75ec43b7..ab21b8a7e 100644 --- a/packages/compiler/src/frontend/lowering/lower-stream.ts +++ b/packages/compiler/src/frontend/lowering/lower-stream.ts @@ -1,6 +1,6 @@ import { keyedHelperName } from "./stable-names.js"; import { nodeThrowExpr, boolLit, numLit, strLit } from "../../ir/build.js"; -import { hashStreamOf, isHashValueType } from "./builtins/hash-stream.js"; +import { isValueStream, valueStreamOf } from "./builtins/hash-stream.js"; import { InternalCompilerError } from "../../errors.js"; /* The node:stream lowering (the spoke-module pattern, like * lower-event-emitter.ts): construction of the five runtime stream classes @@ -52,7 +52,10 @@ import { dynUndefinedExpr, varRef } from "../../ir/build.js"; import { genResultRecord } from "../type-mapper.js"; import { noteUntypedStreamFlow, requestGeneralStreamSurface } from "./general-streams.js"; import { dynNativeBranch } from "./dyn-streams.js"; +import { bindingNeverReassigned } from "./binding-analysis.js"; import { extractIteratorValue, genStep, genValue, stepDrivable } from "./lower-generators.js"; +import { LiftedFrame, driveGenerator } from "./containers/iterator-helpers.js"; +import { lowerArrayIteratorValue, lowerStringIteratorValue } from "./iterator-adapters.js"; import { BOOL, DYN, @@ -74,6 +77,7 @@ import { funcOf, typeEquals, typeKey, + UNDEFINED_T, } from "../../ir/ir.js"; const BYTES = BYTES_U8; @@ -2084,10 +2088,10 @@ function lowerStreamArg( what: "finished" | "pipeline" | "addAbortSignal" | "compose", ): IrExpr { const lowered = lowerer.lowerExpr(node); - // A Hash or Hmac stage is its Transform; pipeline and compose stages - // keep the value alive until the stream settles. - const v = isHashValueType(lowered.type) - ? hashStreamOf(lowered, what === "pipeline" || what === "compose") + // A Hash, Hmac, Cipheriv or Decipheriv stage is its Transform; pipeline + // and compose stages keep the value alive until the stream settles. + const v = isValueStream(lowerer, node) + ? valueStreamOf(lowered, what === "pipeline" || what === "compose") : lowered; // A checked-dynamic pipeline stage (an untyped source or destination): // a boxed native stream unwraps at run time; other values (iterables, @@ -2429,10 +2433,10 @@ export function lowerStreamModuleCall( ? pipelineOptions(lowerer, lastArg) : null; const stageArgs = opts ? args.slice(0, -1) : args; - if (stageArgs.some(isPipelineFunctionStage)) { + if (hasPipelineFunctionStage(lowerer, stageArgs)) { if (opts) { lowerer.noLowering( - "pipeline with function stages and options", + "pipeline with function stages or iterable sources and options", lastArg, "pipeline(source, async function* (source) { ... }, destination) without options is supported", ); @@ -2503,7 +2507,10 @@ export function lowerStreamModuleCall( // (finished/pipeline throw synchronously; consumers do not). A // sync throw here would be observably wrong timing, so the // provable case takes the named fence instead. - const argV = lowerer.lowerExpr(args[0]!); + // A Hash, Hmac, Cipheriv or Decipheriv is read through its Transform. + const argV = isValueStream(lowerer, args[0]!) + ? valueStreamOf(lowerer.lowerExpr(args[0]!)) + : lowerer.lowerExpr(args[0]!); const argInfo = argV.type.kind === "object" ? lowerer.classes.get(argV.type.className) : undefined; if (argV.type.kind !== "dyn" && !streamSidesOf(lowerer, argInfo)) { @@ -2621,7 +2628,7 @@ export function lowerStreamModuleCall( "the supported form is pipeline(source, ...streams, callback)", ); } - if (args.slice(0, -1).some(isPipelineFunctionStage)) { + if (hasPipelineFunctionStage(lowerer, args.slice(0, -1))) { const staged = lowerPipelineStages(lowerer, args.slice(0, -1), loc); if (staged.dest !== 0) { // callback(err, value): the destination's value reaches the @@ -2680,19 +2687,215 @@ export function lowerStreamModuleCall( return null; } -/** A pipeline() argument written as a function: an async generator - * function stage. */ -function isPipelineFunctionStage(node: ts.Expression): boolean { - return ts.isFunctionExpression(node) || ts.isArrowFunction(node); +/** A pipeline() function stage: an inline function or arrow function, or + * an identifier bound to a function declaration or to a `const` + * initialized with one, which nothing reassigns. */ +type StageFunction = ts.FunctionExpression | ts.ArrowFunction | ts.FunctionDeclaration; + +/** The function a pipeline() argument writes or names, or null when the + * argument is not a function stage. */ +function pipelineStageFunction(lowerer: Lowerer, node: ts.Expression): StageFunction | null { + if (ts.isFunctionExpression(node) || ts.isArrowFunction(node)) return node; + if (!ts.isIdentifier(node)) return null; + // The stage lowers the declaration's body again with its source typed + // by the pipeline, so resolving it here must not report what collecting + // the declaration's own signature deferred (resolveValueSymbol would). + const resolve = (ident: ts.Identifier): ts.Symbol | undefined => { + const found = lowerer.checker.getSymbolAtLocation(ident); + return found && found.flags & ts.SymbolFlags.Alias + ? lowerer.checker.getAliasedSymbol(found) + : found; + }; + const symbol = resolve(node); + const declarations = symbol?.declarations ?? []; + const bodies = declarations.filter((d) => !ts.isFunctionDeclaration(d) || d.body !== undefined); + if (!symbol || bodies.length !== 1) return null; + const decl = bodies[0]!; + if (lowerer.isStdlibFile(ts.getSourceFileOfNode(decl))) return null; + if (ts.isFunctionDeclaration(decl)) { + return bindingNeverReassigned(lowerer, symbol, decl, resolve) ? decl : null; + } + if ( + ts.isVariableDeclaration(decl) && + decl.initializer && + ts.isVariableDeclarationList(decl.parent) && + (decl.parent.flags & ts.NodeFlags.Const) !== 0 + ) { + let init: ts.Expression = decl.initializer; + while (ts.isParenthesizedExpression(init)) init = init.expression; + if (ts.isFunctionExpression(init) || ts.isArrowFunction(init)) return init; + } + return null; } -/** The lowered function stages of a pipeline: the libcall head [n, at, k, - * flags, mask, streams..., stages..., (next, read, return)?, box?, +function hasPipelineFunctionStage(lowerer: Lowerer, args: readonly ts.Expression[]): boolean { + return ( + args.some((a) => pipelineStageFunction(lowerer, a) !== null) || + (args.length > 0 && iterableSourceType(lowerer, args[0]!) !== null) + ); +} + +type SyncGenType = IrType & { kind: "generator" }; + +/** The element type of a pipeline source that is an iterable value (an + * array, a string or a synchronous generator object), or null. */ +function iterableSourceType(lowerer: Lowerer, node: ts.Expression): IrType | null { + if (pipelineStageFunction(lowerer, node) !== null) return null; + let t: IrType | null; + try { + t = lowerer.mapTypeOf(lowerer.typeOf(node)); + } catch { + return null; + } + if (t?.kind === "array") return t.elem; + if (t?.kind === "string") return STRING; + if (t?.kind === "generator" && t.async !== true && stepDrivable(t)) return t.yieldT; + return null; +} + +/** A pipeline source that is an iterable value or a synchronous generator + * function without parameters, as an async generator closure that steps + * the value's iterator (or the generator the function returns) and yields + * each element. Node's pipeline iterates such a source with `for await`, + * through an async-from-sync iterator, and an async generator that + * yields the same elements resumes its consumer on the same ticks. Null + * when the source has no such lowering. */ +function lowerIterableSource( + lowerer: Lowerer, + node: ts.Expression, + fn: StageFunction | null, + loc: SrcLoc, +): { closure: IrExpr; out: SyncGenType } | null { + let value: IrExpr; + if (fn !== null) { + if (fn.parameters.nodes.length > 0) { + lowerer.noLowering( + "a synchronous generator function pipeline source with parameters", + fn.parameters.nodes[0]!, + "declare the source without parameters, or make it an async generator function", + ); + } + value = lowerer.lowerLambda(fn); + if (value.type.kind !== "func" || value.type.ret.kind !== "generator") return null; + } else { + value = lowerer.lowerExpr(node); + } + const srcT = value.type; + const elemT: IrType | null = + srcT.kind === "func" && srcT.ret.kind === "generator" + ? srcT.ret.yieldT + : srcT.kind === "array" + ? srcT.elem + : srcT.kind === "string" + ? STRING + : srcT.kind === "generator" && srcT.async !== true + ? srcT.yieldT + : null; + if (elemT === null) return null; + const out: SyncGenType = { + kind: "generator", + async: true, + yieldT: elemT, + retT: VOID, + nextT: UNDEFINED_T, + }; + const resultType = genResultRecord(elemT, VOID, lowerer.shapes, lowerer.unions); + if (!resultType) return null; + const key = `pipelineSource:${typeKey(srcT)}`; + let maker = lowerer.valueHelpers.get(key); + if (!maker) { + maker = `%stream.pipelineSource.${lowerer.valueHelpers.size}`; + const genName = `${maker}.gen`; + // The generator: g = the source's iterator; for (v of g) yield v. + const frame = new LiftedFrame(loc); + const srcId = frame.local("src", srcT, false); + const src = varRef(srcId, srcT, loc); + const syncT: SyncGenType = { + kind: "generator", + yieldT: elemT, + retT: VOID, + nextT: UNDEFINED_T, + }; + let iterator: IrExpr | null; + if (srcT.kind === "func") { + iterator = { kind: "callValue", callee: src, args: [], type: srcT.ret, loc }; + } else if (srcT.kind === "array") { + iterator = lowerArrayIteratorValue(lowerer, src, "values", syncT, loc); + } else if (srcT.kind === "string") { + iterator = lowerStringIteratorValue(lowerer, src, syncT, loc); + } else { + iterator = src; + } + if (iterator === null || iterator.type.kind !== "generator" || !stepDrivable(iterator.type)) + return null; + const iterT = iterator.type; + const gId = frame.local("g", iterT, false); + const body: IrStmt[] = [ + { kind: "varDecl", localId: gId, init: iterator, loc }, + ...driveGenerator( + lowerer, + frame, + gId, + iterT, + elemT, + [], + (v) => [{ kind: "exprStmt", expr: { kind: "yieldExpr", value: v, type: VOID, loc }, loc }], + loc, + ), + { kind: "return", value: null, loc }, + ]; + const srcLocal = frame.locals.find((l) => l.id === srcId)!; + srcLocal.boxed = true; + lowerer.valueHelpers.set(key, maker); + lowerer.liftedFns.push({ + name: genName, + params: [], + returnType: VOID, + async: true, + captures: [{ localId: srcId, name: "src", type: srcT }], + locals: frame.locals, + body, + generator: { yieldT: elemT, nextT: UNDEFINED_T, resultType }, + loc, + }); + // The maker: (src) => the generator function closed over src. + const makerSrc: IrLocal = { id: "src.0", name: "src", type: srcT, mutable: false, boxed: true }; + lowerer.liftedFns.push({ + name: maker, + params: [{ localId: makerSrc.id, name: makerSrc.name, type: srcT }], + returnType: funcOf([], out), + locals: [makerSrc], + body: [ + { + kind: "return", + value: { + kind: "closure", + fnName: genName, + captures: [makerSrc.id], + type: funcOf([], out), + loc, + }, + loc, + }, + ], + loc, + }); + } + return { + closure: { kind: "call", callee: maker, args: [value], type: funcOf([], out), loc }, + out, + }; +} + +/** The lowered function stages of a pipeline: the libcall head [n, k, + * positions, flags, mask, streams..., stages..., helpers..., box?, * (signal, abort)?], the destination's type (the last stream, or the * PassThrough a function destination answers), the destination kind * (SCR_PIPE_DEST_*), a promise destination's promise type, and a wrapper * that binds the pipeline's AbortController around the call when a - * stage takes `{ signal }`. */ + * stage takes `{ signal }`. positions has bit j set when the pipeline's + * j-th stage is a function; helpers holds (next, read, return) for each + * generator pumped into a stream. */ interface PipelineStagesLowering { args: IrExpr[]; last: IrType; @@ -2701,56 +2904,89 @@ interface PipelineStagesLowering { wrap: (call: IrExpr) => IrExpr; } -/** pipeline(...) with one run of function stages (pipeline.js). The run - * may start the pipeline (a source function, called with `{ signal }`) - * and may end it (a destination function: an async generator pumped into - * a PassThrough, or an async function whose promise's value reaches the - * callback or the promise). Each stage's `source` parameter is typed as - * what the pipeline passes it: makeAsyncIterable answers the previous - * stream itself (a Readable is async iterable) or the previous stage's +/** pipeline(...) with function stages (pipeline.js). A function may + * start the pipeline (a source function, called with `{ signal }`), may + * end it (an async function whose promise's value reaches the callback or + * the promise), and runs of async generator functions may sit between + * streams; the last generator of a run that a stream follows is pumped + * into that stream. Each stage's `source` parameter is typed as what the + * pipeline passes it: makeAsyncIterable answers the previous stream + * itself (a Readable is async iterable) or the previous stage's * generator. */ function lowerPipelineStages( lowerer: Lowerer, stageArgs: readonly ts.Expression[], loc: SrcLoc, ): PipelineStagesLowering { - const first = stageArgs.findIndex(isPipelineFunctionStage); - let end = first; - while (end < stageArgs.length && isPipelineFunctionStage(stageArgs[end]!)) end++; - if (stageArgs.slice(end).some(isPipelineFunctionStage)) { + if (stageArgs.length > 52) { lowerer.noLowering( - "pipeline with function stages separated by streams", - stageArgs[end]!, - "one run of function stages is supported", + "pipeline with function stages and more than 52 stages", + stageArgs[52]!, + "split the pipeline", ); } - const source = first === 0; - const destFn = end === stageArgs.length; - const before: IrExpr[] = []; - const after: IrExpr[] = []; - try { - for (const a of stageArgs.slice(0, first)) before.push(lowerStreamArg(lowerer, a, "pipeline")); - } catch (e) { - if (e instanceof StreamArgTypeThrow) - lowerer.noLowering("pipeline over this value", stageArgs[0]!); - throw e; - } - let srcT: IrType | null = source ? null : before[before.length - 1]!.type; + const streams: IrExpr[] = []; const stages: IrExpr[] = []; + const helperArgs: IrExpr[] = []; + let positions = 0; let mask = 0; let dest: 0 | 2 = 0; let destPromise: (IrType & { kind: "promise" }) | null = null; - for (let i = first; i < end; i++) { - const fn = stageArgs[i] as ts.FunctionExpression | ts.ArrowFunction; - const isLast = destFn && i === end - 1; + // What the next function stage receives: null before the first stage, + // else the previous stream's type or the previous stage's generator. + let srcT: IrType | null = null; + for (let j = 0; j < stageArgs.length; j++) { + const arg = stageArgs[j]!; + const fn = pipelineStageFunction(lowerer, arg); + const syncSourceFn = + j === 0 && + fn !== null && + !ts.isArrowFunction(fn) && + fn.asteriskToken !== undefined && + !(fn.modifiers?.nodes ?? []).some((m) => m.kind === ts.SyntaxKind.AsyncKeyword); + if (j === 0 && (syncSourceFn || (fn === null && iterableSourceType(lowerer, arg) !== null))) { + const source = lowerIterableSource(lowerer, arg, syncSourceFn ? fn : null, loc); + if (source === null) lowerer.noLowering("pipeline over this source", arg); + positions += 1; + stages.push(source!.closure); + srcT = source!.out; + continue; + } + if (fn === null) { + if (srcT?.kind === "generator") { + // the generator before this stream, pumped into it + if (!fromGenChunk(lowerer, srcT.yieldT)) { + lowerer.noLowering( + `a pipeline stage yielding '${lowerer.fmt(srcT.yieldT)}'`, + stageArgs[j - 1]!, + "stage values written to a stream are strings or Buffers", + ); + } + const helpers = fromGenHelpers(lowerer, srcT, loc); + if (!helpers) + lowerer.noLowering("a pipeline stage with this generator type", stageArgs[j - 1]!); + helperArgs.push(helpers![0]!, helpers![1]!, helpers![2]!); + } + let stream: IrExpr; + try { + stream = lowerStreamArg(lowerer, arg, "pipeline"); + } catch (e) { + if (e instanceof StreamArgTypeThrow) lowerer.noLowering("pipeline over this value", arg); + throw e; + } + streams.push(stream); + srcT = stream.type; + continue; + } + const isLast = j === stageArgs.length - 1; const isAsync = (fn.modifiers?.nodes ?? []).some((m) => m.kind === ts.SyntaxKind.AsyncKeyword); - const isGen = ts.isFunctionExpression(fn) && fn.asteriskToken !== undefined; + const isGen = !ts.isArrowFunction(fn) && fn.asteriskToken !== undefined; if (isLast && isGen) { // pipeline() pumps it into an object-mode PassThrough, whose // buffering decides when the pipeline finishes lowerer.noLowering( "a pipeline destination that is an async generator function", - fn, + arg, "end the pipeline with a stream or an async function (source) { for await (const chunk of source) ... }", ); } @@ -2761,7 +2997,7 @@ function lowerPipelineStages( : srcT === null ? "a pipeline source function that is not an async generator function" : "pipeline stages that are not async generator functions", - fn, + arg, "write the stage as async function* (source) { for await (const chunk of source) ... }", ); } @@ -2783,8 +3019,9 @@ function lowerPipelineStages( "type it as { signal: AbortSignal }", ); } - mask |= 1 << (i - first); + mask |= 1 << stages.length; } + positions += 2 ** j; stages.push(lowered.closure); if (lowered.out.kind === "promise") { dest = 2; @@ -2794,29 +3031,7 @@ function lowerPipelineStages( srcT = lowered.out; } } - try { - for (const a of stageArgs.slice(end)) after.push(lowerStreamArg(lowerer, a, "pipeline")); - } catch (e) { - if (e instanceof StreamArgTypeThrow) - lowerer.noLowering("pipeline over this value", stageArgs[end]!); - throw e; - } - const helperArgs: IrExpr[] = []; - if (dest !== 2) { - // the generator pumped into the next stream or the PassThrough - const lastGen = srcT as IrType & { kind: "generator" }; - if (!fromGenChunk(lowerer, lastGen.yieldT)) { - lowerer.noLowering( - `a pipeline stage yielding '${lowerer.fmt(lastGen.yieldT)}'`, - stageArgs[end - 1]!, - "stage values written to a stream are strings or Buffers", - ); - } - const helpers = fromGenHelpers(lowerer, lastGen, loc); - if (!helpers) - lowerer.noLowering("a pipeline stage with this generator type", stageArgs[end - 1]!); - helperArgs.push(helpers![0]!, helpers![1]!, helpers![2]!); - } else { + if (dest === 2) { const valueT = destPromise!.inner; if ( valueT.kind !== "void" && @@ -2828,28 +3043,25 @@ function lowerPipelineStages( ) { lowerer.noLowering( `a pipeline destination resolving to '${lowerer.fmt(valueT)}'`, - stageArgs[end - 1]!, + stageArgs[stageArgs.length - 1]!, ); } helperArgs.push(pipelineBoxHelper(lowerer, destPromise!, loc)); } - const streams = [...before, ...after]; - // SCR_PIPE_* flags: bit 0 a source function, bits 1-2 the destination, - // bit 3 the helpers, bit 4 the box, bit 5 the signal and abort. - const flags = (source ? 1 : 0) | (dest << 1) | (dest !== 2 ? 8 : 16) | (mask !== 0 ? 32 : 0); + // SCR_PIPE_* flags: bits 1-2 the destination, bit 5 the signal and abort. + const flags = (dest << 1) | (mask !== 0 ? 32 : 0); const head: IrExpr[] = [ numLit(streams.length, loc), - numLit(before.length, loc), numLit(stages.length, loc), + numLit(positions, loc), numLit(flags, loc), numLit(mask, loc), ...streams, ...stages, ...helperArgs, ]; - const last: IrType = destFn - ? { kind: "object", className: "%PassThrough" } - : streams[streams.length - 1]!.type; + const last: IrType = + dest === 2 ? { kind: "object", className: "%PassThrough" } : streams[streams.length - 1]!.type; if (mask === 0) return { args: head, last, dest, destPromise, wrap: (call) => call }; // const ac = new AbortController(): its signal goes to the stages, and // finishImpl's ac.abort() runs through the abort closure. @@ -2980,7 +3192,7 @@ function pipelineAbortHelper(lowerer: Lowerer, ac: IrExpr, loc: SrcLoc): IrExpr * generator, or a promise for a destination async function. */ function lowerStageFunction( lowerer: Lowerer, - fn: ts.FunctionExpression | ts.ArrowFunction, + fn: StageFunction, srcT: IrType | null, ): { closure: IrExpr; out: IrType & ({ kind: "generator" } | { kind: "promise" }) } { const param = srcT === null ? undefined : fn.parameters.nodes[0]; @@ -2995,6 +3207,8 @@ function lowerStageFunction( "name the source parameter", ); } + // The loop variables of the `for await` loops over the source. + const chunkSymbols: ts.Symbol[] = []; if (symbol && fn.body) { const visit = (node: ts.Node): void => { if ( @@ -3017,14 +3231,36 @@ function lowerStageFunction( "iterate the source with for await (const chunk of source)", ); } + const binding = ts.isVariableDeclarationList(parent.initializer) + ? parent.initializer.declarations.nodes[0]?.name + : undefined; + const chunk = + binding && ts.isIdentifier(binding) + ? lowerer.checker.getSymbolAtLocation(binding) + : undefined; + if (chunk) chunkSymbols.push(chunk); } ts.forEachChild(node, visit); }; visit(fn.body); } if (symbol) lowerer.stageSourceTypes.set(symbol, srcT!); + // In JavaScript the checker types the chunks of a source that is the + // previous stage's generator `any`; they read as the strings or Buffers + // the generator yields, so their members take the string and Buffer + // lowerings. + const previousImplicit = lowerer.implicitParamTypes; + const chunkType = + srcT?.kind === "generator" && isJsSourceFile(ts.getSourceFileOfNode(fn)) + ? stageChunkCheckerType(lowerer, srcT.yieldT, fn) + : null; + if (chunkType && chunkSymbols.length > 0) { + const implicit = new Map(previousImplicit ?? []); + for (const chunk of chunkSymbols) implicit.set(chunk, chunkType); + lowerer.implicitParamTypes = implicit; + } try { - const closure = lowerer.lowerExpr(fn); + const closure = lowerer.lowerLambda(fn); const out = closure.type.kind === "func" ? closure.type.ret : null; if (!(out?.kind === "generator" && out.async) && out?.kind !== "promise") { lowerer.noLowering("a pipeline stage that does not return an async generator", fn); @@ -3032,9 +3268,19 @@ function lowerStageFunction( return { closure, out: out as IrType & ({ kind: "generator" } | { kind: "promise" }) }; } finally { if (symbol) lowerer.stageSourceTypes.delete(symbol); + lowerer.implicitParamTypes = previousImplicit; } } +/** The checker type of a stage's string or Buffer chunks, or null for + * other chunk types. */ +function stageChunkCheckerType(lowerer: Lowerer, chunk: IrType, at: ts.Node): ts.Type | null { + if (chunk.kind === "string") return lowerer.checker.getStringType(); + if (chunk.kind !== "bytes") return null; + const buffer = lowerer.checker.resolveName("Buffer", ts.SymbolFlags.Type, at, false); + return buffer ? lowerer.checker.getDeclaredTypeOfSymbol(buffer) : null; +} + /** `stream.compose(...streams)` over stream instances: a Duplex writing * to the first stream and reading from the last (scr_stream_compose). The * classes fix which positions can be readable and writable; a stream in @@ -3806,9 +4052,10 @@ export function lowerStreamMethodCall( "the supported forms are (destination) and (destination, { end })", ); } - // A Hash or Hmac destination pipes into its Transform, and pipe() - // answers the Hash itself (the receiver evaluates first, as in JS). - if (isHashValueType(lowerer.mapTypeOf(lowerer.typeOf(args[0]!)))) { + // A Hash, Hmac, Cipheriv or Decipheriv destination pipes into its + // Transform, and pipe() answers the value itself (the receiver + // evaluates first, as in JS). + if (isValueStream(lowerer, args[0]!)) { const receiverValue = lowerer.lowerExpr(access.expression); const source = lowerer.declareHiddenLocal("%pipeSource", receiverValue.type); const hashValue = lowerer.lowerExpr(args[0]!); @@ -3826,7 +4073,10 @@ export function lowerStreamMethodCall( fn: "readable.pipe", args: [ { kind: "varRef", localId: source.id, type: receiverValue.type, loc }, - hashStreamOf({ kind: "varRef", localId: hash.id, type: hashValue.type, loc }, true), + valueStreamOf( + { kind: "varRef", localId: hash.id, type: hashValue.type, loc }, + true, + ), end, ], type: { kind: "object", className: "%Transform" }, diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts index 3f8a0a66e..f55498599 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -62,7 +62,7 @@ import { resolveRequireRuntime } from "../runtime-resolve.js"; import { lowerKeyObjectCall } from "./builtins/key-object.js"; import { isEcdhType, lowerEcdhCall } from "./builtins/ecdh.js"; import { fenceWebCryptoMember, lowerWebCryptoCall } from "./builtins/webcrypto.js"; -import { hashStreamOf } from "./builtins/hash-stream.js"; +import { valueStreamOf } from "./builtins/hash-stream.js"; import { lowerNetAddressCall, lowerNetAddressNew } from "./builtins/net-address.js"; import { dynUndefinedExpr, nodeThrowExpr, numLit, varRef } from "../../ir/build.js"; import { iteratorSlotAdapter } from "./iterator-adapters.js"; @@ -3030,10 +3030,10 @@ export class Lowerer { /** Inline Promise.then parameters whose contextual type is a builtin * module namespace anonymous object. The settled native token is the * ABI truth even when the checker type has no stable module symbol. */ - /** Receivers of a stream call on a Hash or Hmac (lowerHashStreamCall): - * for the duration of that call, the receiver lowers to the Transform of - * the value held in the named local. */ - readonly hashStreamReceivers = new Map(); + /** Receivers of a stream call on a Hash, Hmac, Cipheriv or Decipheriv + * (lowerHashStreamCall): for the duration of that call, the receiver + * lowers to the Transform of the value held in the named local. */ + readonly valueStreamReceivers = new Map(); /** fs call arguments evaluated ahead of a URL path's conversion * (builtins/fs-paths.ts): each lowers to the hidden local that holds its * value, which is null until the path's lowering has saved it. */ @@ -12486,8 +12486,9 @@ export class Lowerer { /* ── expressions ──────────────────────────────────────────────────── */ lowerExpr(expr: ts.Expression): IrExpr { - const hash = this.hashStreamReceivers.get(expr); - if (hash) return hashStreamOf(varRef(hash.localId, hash.type, locOf(expr))); + const streamValue = this.valueStreamReceivers.get(expr); + if (streamValue) + return valueStreamOf(varRef(streamValue.localId, streamValue.type, locOf(expr))); return this.stagedArgument(expr) ?? lowerExpr(this, expr); } diff --git a/packages/compiler/src/ir/builtin-effects.ts b/packages/compiler/src/ir/builtin-effects.ts index ca8c52118..89aa5b001 100644 --- a/packages/compiler/src/ir/builtin-effects.ts +++ b/packages/compiler/src/ir/builtin-effects.ts @@ -80,6 +80,7 @@ export const MAY_THROW_LIB_FNS: ReadonlySet = new Set([ "procStream.write", "child.stdioStream", "stream.unboxDyn", + "stream.handleStream", "stream.pipeDyn", "stream.unpipeDyn", "weakMap.new", diff --git a/packages/compiler/src/ir/builtin-signatures.ts b/packages/compiler/src/ir/builtin-signatures.ts index fa7876579..9490ed78c 100644 --- a/packages/compiler/src/ir/builtin-signatures.ts +++ b/packages/compiler/src/ir/builtin-signatures.ts @@ -2712,6 +2712,12 @@ export const LIB_FN_SIGS = defineLibFnSignatures({ argTypes: [DYN, STRING], result: { kind: "object", className: "%Duplex" }, }, + /** The Transform a Cipheriv or Decipheriv reads and writes as a stream + * (+1, created on first use and owned by the cipher). */ + "stream.handleStream": { + argTypes: [DYN], + result: { kind: "object", className: "%Transform" }, + }, /** Checked-dynamic stream slots (dyn-streams.ts): the native stream a * checked-dynamic value boxes (+1) — a runtime stream with the readable * (1) or writable (2) side — or null for any other value. Never throws; @@ -3936,14 +3942,15 @@ export const LIB_FN_SIGS = defineLibFnSignatures({ "stream.finishedOpts": { argTypes: [null, F64, F64, BOOL, null], result: VOID }, "stream.finishedOptsSignal": { argTypes: [null, F64, F64, BOOL, DYN, null], result: VOID }, "sp.pipeline": { argTypes: [F64], result: { kind: "promise", inner: VOID } }, - /** pipeline with a run of function stages: [n, at, k, flags, mask, - * s1..sn, stage1..stagek, (next, read, return)?, box?, (signal, - * abort)?] (+ the callback for the stream.* forms): the user's stage - * functions, the frontend's helpers over the pumped generator or a - * promise destination's box, and the pipeline's AbortSignal with its - * abort closure; flags names which groups are present - * (scr_stream_pipeline_stages). A promise destination's promise type is - * sp.pipelineStages' result. */ + /** pipeline with function stages: [n, k, positions, flags, mask, + * s1..sn, stage1..stagek, helpers..., box?, (signal, abort)?] (+ the + * callback for the stream.* forms): the user's stage functions at the + * positions the bitmask names, the frontend's (next, read, return) + * helpers for each pumped generator (pipelinePumpedRuns) and a promise + * destination's box, and the pipeline's AbortSignal with its abort + * closure; flags bits 1-2 give the destination kind and bit 5 the + * signal group (scr_stream_pipeline_stages). A promise destination's + * promise type is sp.pipelineStages' result. */ "sp.pipelineStages": { argTypes: [F64, F64, F64, F64, F64], result: { kind: "promise", inner: VOID }, @@ -4734,3 +4741,15 @@ export const LIB_FN_SIGS = defineLibFnSignatures({ /** A builtin name exists exactly when its runtime signature exists. */ export type IrLibFn = keyof typeof LIB_FN_SIGS; + +/** The function-stage runs of a pipeline of `total` stages that a stream + * follows (positions bit j: stage j is a function): each pumps its last + * generator into that stream through one (next, read, return) triple. */ +export function pipelinePumpedRuns(total: number, positions: number): number { + let runs = 0; + for (let j = 0; j + 1 < total; j++) { + if (Math.floor(positions / 2 ** j) % 2 === 1 && Math.floor(positions / 2 ** (j + 1)) % 2 === 0) + runs++; + } + return runs; +} diff --git a/packages/compiler/src/ir/runtime-features.ts b/packages/compiler/src/ir/runtime-features.ts index 4142b6efe..7d8626e4b 100644 --- a/packages/compiler/src/ir/runtime-features.ts +++ b/packages/compiler/src/ir/runtime-features.ts @@ -237,6 +237,7 @@ const STREAM_LIB_FNS: ReadonlySet = new Set([ "stream.prop", "stream.stdioWritable", "stream.unboxDyn", + "stream.handleStream", "stream.unpipeDyn", "stream.workerStdio", ]); diff --git a/packages/compiler/src/ir/validate.ts b/packages/compiler/src/ir/validate.ts index 88ccbbc33..9de1b5b62 100644 --- a/packages/compiler/src/ir/validate.ts +++ b/packages/compiler/src/ir/validate.ts @@ -60,7 +60,7 @@ import { DYN_CLASS_PROPERTIES, callSiteReturnType, classValueConstructor } from import { unionWideningTags } from "./analysis.js"; import { alwaysReturns } from "./control-flow.js"; import { dynamicOperationOf, functionTier } from "./tiers.js"; -import { LIB_FN_SIGS } from "./builtin-signatures.js"; +import { LIB_FN_SIGS, pipelinePumpedRuns } from "./builtin-signatures.js"; /** The promisified crypto calls' value kinds besides checked-dynamic. */ const CRYPTO_PROMISE_VALUES: Readonly> = { @@ -5614,23 +5614,34 @@ function validateFunction( e.fn === "stream.pipelineStagesDyn" || e.fn === "sp.pipelineStages" ) { - // (n, at, k, flags, mask, s1..sn, stage1..stagek, (next, read, - // return)?, box?, (signal, abort)?[, cb]): flags bit 0 a source - // function, bits 1-2 the destination, bits 3/4/5 the groups. - const [n, at, k, flags] = e.args + // (n, k, positions, flags, mask, s1..sn, stage1..stagek, + // helpers..., box?, (signal, abort)?[, cb]): positions bit j marks + // stage j a function, flags bits 1-2 the destination, bit 5 the + // signal group; helpers are three per function run a stream + // follows. + const [n, k, positions, flags] = e.args .slice(0, 4) .map((a) => (a?.kind === "numLit" ? a.value : -1)); - const source = (flags! & 1) !== 0; + const total = n! + k!; const destKind = (flags! >> 1) & 3; - const groups = (flags! & 8 ? 3 : 0) + (flags! & 16 ? 1 : 0) + (flags! & 32 ? 2 : 0); + let functions = 0; + for (let j = 0; j < total && j < 53; j++) { + if (Math.floor(positions! / 2 ** j) % 2 === 1) functions++; + } + const lastIsFunction = Math.floor(positions! / 2 ** (total - 1)) % 2 === 1; + const helperCount = 3 * pipelinePumpedRuns(total, positions!); + const groups = helperCount + (destKind === 2 ? 1 : 0) + (flags! & 32 ? 2 : 0); const cbArgs = e.fn === "sp.pipelineStages" ? 0 : 1; if ( flags! < 0 || n! < 0 || k! < 1 || - (source ? at !== 0 : at! < 1) || - (destKind === 0 ? at! + 0 >= n! : at! !== n!) || - n! + k! < 2 || + positions! < 1 || + total > 52 || + positions! >= 2 ** total || + functions !== k || + (destKind === 2) !== lastIsFunction || + total < 2 || e.args.length !== 5 + n! + k! + groups + cbArgs ) { err(`libCall ${e.fn} count/arity mismatch`, e.loc); @@ -5647,7 +5658,7 @@ function validateFunction( err(`libCall ${e.fn} stage function ${i} must be a func`, e.loc); } at2 += k!; - const helpers = (flags! & 8 ? 3 : 0) + (flags! & 16 ? 1 : 0); + const helpers = helperCount + (destKind === 2 ? 1 : 0); for (let i = at2; i < at2 + helpers; i++) { if (e.args[i]?.type.kind !== "func") err(`libCall ${e.fn} helper ${i} must be a func`, e.loc); diff --git a/packages/compiler/test/native-codegen-integration.test.ts b/packages/compiler/test/native-codegen-integration.test.ts index d8f158ebc..c05e7f994 100644 --- a/packages/compiler/test/native-codegen-integration.test.ts +++ b/packages/compiler/test/native-codegen-integration.test.ts @@ -378,7 +378,7 @@ done: expect(await symbols(helperObject, ["-u"])).toEqual(await symbols(clangObject, ["-u"])); expect(await symbols(helperObject, ["-gU"])).toEqual(await symbols(clangObject, ["-gU"])); expect(await symbols(helperObject, ["-gU"])).toEqual(["0000000000000000 T _main"]); - expect(await symbols(helperObject, ["-u"])).toContain("_scr_runtime_abi_v24"); + expect(await symbols(helperObject, ["-u"])).toContain("_scr_runtime_abi_v25"); const clangExe = join(dir, "clang-program"); const linkDriver = join(dir, "clang-driver.c"); @@ -712,7 +712,7 @@ done: .split("\n"); expect(undefinedSymbols).toContain("_sf_scale"); expect(undefinedSymbols).toContain("_sf_callback_mix"); - expect(undefinedSymbols).toContain("_scr_runtime_abi_v24"); + expect(undefinedSymbols).toContain("_scr_runtime_abi_v25"); }); test("helper and clang object paths retain the same outbound FFI C ABI", async () => { diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7055-cipher-streams.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7055-cipher-streams.ts.json new file mode 100644 index 000000000..989c7f452 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7055-cipher-streams.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7055-cipher-streams.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7056-cipher-stream-errors.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7056-cipher-stream-errors.ts.json new file mode 100644 index 000000000..16bd2586c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7056-cipher-stream-errors.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7056-cipher-stream-errors.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7057-cipher-streams.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7057-cipher-streams.mjs.json new file mode 100644 index 000000000..1304933ae --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7057-cipher-streams.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7057-cipher-streams.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7058-pipeline-function-stages.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7058-pipeline-function-stages.mjs.json new file mode 100644 index 000000000..3b9fd5a0f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7058-pipeline-function-stages.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7058-pipeline-function-stages.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7059-transform-backpressure.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7059-transform-backpressure.ts.json new file mode 100644 index 000000000..311882a39 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7059-transform-backpressure.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7059-transform-backpressure.ts" + ], + "diags": [] +} diff --git a/packages/runtime-darwin-arm64/scripts/build.mjs b/packages/runtime-darwin-arm64/scripts/build.mjs index 85c5ffb00..c18a1d080 100644 --- a/packages/runtime-darwin-arm64/scripts/build.mjs +++ b/packages/runtime-darwin-arm64/scripts/build.mjs @@ -337,7 +337,7 @@ async function build() { package: packageManifest.name, version: packageManifest.version, target: RUNTIME_PACK_MATRIX.target, - runtime_abi: { version: 24, marker: "scr_runtime_abi_v24" }, + runtime_abi: { version: 25, marker: "scr_runtime_abi_v25" }, compiler: { command: compiler, identity: compilerVersion, diff --git a/packages/runtime-pack-common/scripts/build.mjs b/packages/runtime-pack-common/scripts/build.mjs index b242b78aa..f0eab2cb5 100644 --- a/packages/runtime-pack-common/scripts/build.mjs +++ b/packages/runtime-pack-common/scripts/build.mjs @@ -434,7 +434,7 @@ async function build() { package: packageManifest.name, version: packageManifest.version, target: matrix.target, - runtime_abi: { version: 24, marker: "scr_runtime_abi_v24" }, + runtime_abi: { version: 25, marker: "scr_runtime_abi_v25" }, compiler: { command: compiler, identity: compilerVersion, diff --git a/packages/runtime/src/scr_cipher.c b/packages/runtime/src/scr_cipher.c index df62a79a3..c8a10a731 100644 --- a/packages/runtime/src/scr_cipher.c +++ b/packages/runtime/src/scr_cipher.c @@ -9,7 +9,9 @@ * the runtime StringDecoder, which carries partial characters and base64 * groups between calls as Node's does. chacha20-poly1305 follows OpenSSL's * construction, which also accepts AAD after data. Authentication tags are - * compared in constant time. All arguments are borrowed. */ + * compared in constant time. A cipher used as a stream reads and writes + * through its own native Transform, which the stream unit builds on first + * use, as Node's LazyTransform is. All arguments are borrowed. */ #include "scr_runtime.h" #include @@ -103,6 +105,12 @@ typedef struct ScCipher { bool aad_open; /* AAD was added since the last data or padding */ ScrStr *decoder; /* the StringDecoder encoding once string output starts */ double pending; /* the decoder's carried bytes */ + /* The Transform of a cipher used as a stream (+1) and its release + * (scr_stream.c). Its steps hold the cipher, so the cipher is a + * collector-headered object behind a traced handle, and the pair is + * reclaimed as a cycle. */ + void *stream; + void (*stream_release)(void *); } ScCipher; static void *sc_retain(void *h) { @@ -110,16 +118,38 @@ static void *sc_retain(void *h) { return h; } -static void sc_release(void *h) { +static void sc_trace(void *h, ScrTraceVisit visit, void *ctx) { + ScCipher *c = h; + if (c->stream) visit(c->stream, ctx); +} + +/* The collector frees the stream itself; the rest is released here. */ +static void sc_gcfree(void *h) { ScCipher *c = h; - if (--c->rc) return; mbedtls_aes_free(&c->aes); mbedtls_gcm_free(&c->gcm); mbedtls_chacha20_free(&c->chacha); mbedtls_poly1305_free(&c->poly); scr_str_release(c->decoder); mbedtls_platform_zeroize(c, sizeof *c); - free(c); + scr_obj_free_note(); + scr_cyc_free(c); +} + +static void sc_destroy(void *h) { + ScCipher *c = h; + void *stream = c->stream; + c->stream = NULL; + if (stream) c->stream_release(stream); + sc_gcfree(c); +} + +static void sc_release(void *h) { + ScCipher *c = h; + if (--c->rc == 0) { + scr_cyc_dead(c); + scr_rc_destroy(c, sc_destroy); + } else scr_cyc_released(c); } /* ── errors ───────────────────────────────────────────────────────────── */ @@ -532,9 +562,10 @@ static ScrDyn *sc_cipher_new(bool decrypt, ScrDyn *cipher, ScrDyn *key, ScrDyn * sc_throw(SCR_ERR_RANGE, "ERR_CRYPTO_INVALID_KEYLEN", "Invalid key length"); goto done; } - ScCipher *c = calloc(1, sizeof *c); - if (!c) scr_trap("scriptc: out of memory\n"); + static ScrCycType cyc_type = {&sc_trace, &sc_gcfree, SCR_CYC_KIND_NONE, 0}; + ScCipher *c = scr_cyc_alloc(sizeof *c, &cyc_type); c->rc = 1; + scr_obj_alloc_note(); c->mode = spec->mode; c->decrypt = decrypt; c->active = true; @@ -883,7 +914,8 @@ static bool sc_aead(const ScCipher *c) { return c->mode == SC_GCM || c->mode == SC_CHACHA; } -static ScrDyn *sc_final(ScCipher *c, ScrDyn *output_encoding) { +/* final()'s output bytes (+1 Buffer), or NULL with the error thrown. */ +static ScrBytes *sc_final_bytes(ScCipher *c) { if (!c->active) { sc_throw(SCR_ERR_ERROR, "ERR_CRYPTO_INVALID_STATE", "Invalid state"); return NULL; @@ -953,7 +985,12 @@ static ScrDyn *sc_final(ScCipher *c, ScrDyn *output_encoding) { sc_throw(SCR_ERR_ERROR, NULL, "Unsupported state or unable to authenticate data"); return NULL; } - return sc_output(c, out, output_encoding, true); + return out; +} + +static ScrDyn *sc_final(ScCipher *c, ScrDyn *output_encoding) { + ScrBytes *out = sc_final_bytes(c); + return out ? sc_output(c, out, output_encoding, true) : NULL; } static ScrDyn *sc_set_aad(ScCipher *c, ScrDyn *self, ScrDyn *buffer, ScrDyn *options) { @@ -1055,6 +1092,49 @@ static ScrDyn *sc_set_auth_tag(ScCipher *c, ScrDyn *self, ScrDyn *buffer, ScrDyn return scr_dyn_retain(self); } +/* ── Cipheriv and Decipheriv as streams ─────────────────────────────── + * The stream unit builds a cipher's Transform from these operations + * (ScrDynHandleTransform): each chunk goes through the handle's update(), + * and the end pushes final() or reports its error, as Node's cipher.js + * _transform and _flush do. */ + +static void *sc_stream_get(void *h) { + return ((ScCipher *)h)->stream; +} + +static void sc_stream_set(void *h, void *stream, void (*release)(void *)) { + ScCipher *c = h; + c->stream = stream; + c->stream_release = release; +} + +/* The handle's update(): it throws out of the write, as in Node, once + * the cipher has finished. */ +static ScrBytes *sc_stream_update(void *h, ScrBytes *chunk) { + ScCipher *c = h; + if (!c->active) { + sc_throw(SCR_ERR_ERROR, NULL, "Trying to add data in unsupported state"); + return NULL; + } + SCR_BYTES_SNAPSHOT(chunk); + return sc_transform(c, chunk->data, chunk->len * scr_bytes_elem_size(chunk->elem)); +} + +static ScrBytes *sc_stream_final(void *h) { + return sc_final_bytes(h); +} + +static const ScrDynHandleTransform sc_transform_ops = { + sc_stream_get, sc_stream_set, sc_stream_update, sc_stream_final, sc_trace, +}; + +static ScrDynHandleOps sc_ops_cipher; +static ScrDynHandleOps sc_ops_decipher; + +static const ScrDynHandleOps *sc_ops_of(const ScCipher *c) { + return c->decrypt ? &sc_ops_decipher : &sc_ops_cipher; +} + static bool sc_name_is(const char *method, const char *name) { return strcmp(method, name) == 0; } @@ -1076,8 +1156,12 @@ static bool sc_stream_member(const char *name) { static void sc_stream_fence(void) { static const char message[] = - "Cipheriv and Decipheriv stream members have no lowering; call update() and final()"; - scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020"); + "This Cipheriv and Decipheriv stream member has no lowering when called through an untyped value"; + static const char streamless[] = + "Cipheriv and Decipheriv stream members called through an untyped value have no lowering in a " + "program that uses no streams"; + if (scr_handle_stream_hooks) scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020"); + else scr_throw_error_msg_code(SCR_ERR_ERROR, streamless, sizeof streamless - 1, "SC2020"); } static ScrDyn *sc_dispatch(ScCipher *c, ScrDyn *self, const char *method, ScrDyn *const *args, size_t argc, @@ -1091,6 +1175,12 @@ static ScrDyn *sc_dispatch(ScCipher *c, ScrDyn *self, const char *method, ScrDyn if (c->decrypt && sc_name_is(method, "setAuthTag")) return sc_set_auth_tag(c, self, sc_arg(args, argc, 0), sc_arg(args, argc, 1)); if (sc_stream_member(method)) { + /* The members a native stream answers to checked-dynamic calls run + * on the cipher's Transform; the others have no lowering. */ + ScrDyn *result = NULL; + if (scr_handle_stream_hooks && + scr_handle_stream_hooks->call(sc_ops_of(c), c, self, method, args, argc, &result)) + return result; sc_stream_fence(); return NULL; } @@ -1117,11 +1207,19 @@ done: } static ScrDyn *sc_get(void *h, const char *key, size_t key_len) { - (void)h; (void)key; (void)key_len; + /* The stream properties read the cipher's Transform. */ + if (scr_handle_stream_hooks) { + ScrDyn *value = scr_handle_stream_hooks->get(sc_ops_of(h), h, key, key_len); + if (value || scr_exc_pending()) return value; + } static const char message[] = - "Cipheriv and Decipheriv property reads have no lowering; call update(), final(), setAAD(), " - "setAutoPadding(), getAuthTag() or setAuthTag()"; - scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020"); + "Cipheriv and Decipheriv property reads have no lowering other than the stream properties; call " + "update(), final(), setAAD(), setAutoPadding(), getAuthTag() or setAuthTag()"; + static const char streamless[] = + "Cipheriv and Decipheriv property reads through an untyped value have no lowering in a program " + "that uses no streams"; + if (scr_handle_stream_hooks) scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020"); + else scr_throw_error_msg_code(SCR_ERR_ERROR, streamless, sizeof streamless - 1, "SC2020"); return NULL; } @@ -1132,5 +1230,7 @@ static bool sc_set(void *h, const char *key, size_t key_len, const ScrDyn *value return true; } -static ScrDynHandleOps sc_ops_cipher = {"Cipheriv", sc_retain, sc_release, sc_invoke, sc_get, sc_set, NULL, NULL, NULL}; -static ScrDynHandleOps sc_ops_decipher = {"Decipheriv", sc_retain, sc_release, sc_invoke, sc_get, sc_set, NULL, NULL, NULL}; +static ScrDynHandleOps sc_ops_cipher = {"Cipheriv", sc_retain, sc_release, sc_invoke, sc_get, sc_set, NULL, NULL, NULL, + .transform = &sc_transform_ops}; +static ScrDynHandleOps sc_ops_decipher = {"Decipheriv", sc_retain, sc_release, sc_invoke, sc_get, sc_set, NULL, NULL, NULL, + .transform = &sc_transform_ops}; diff --git a/packages/runtime/src/scr_console.c b/packages/runtime/src/scr_console.c index c29126a4a..c8fa40b38 100644 --- a/packages/runtime/src/scr_console.c +++ b/packages/runtime/src/scr_console.c @@ -148,7 +148,7 @@ static void scr_enable_utf8_console_output(void) { } #endif -void scr_runtime_abi_v24(void) {} +void scr_runtime_abi_v25(void) {} void scr_init(void) { #ifdef SCR_WORKERS diff --git a/packages/runtime/src/scr_core.h b/packages/runtime/src/scr_core.h index 94936a8aa..5e5278588 100644 --- a/packages/runtime/src/scr_core.h +++ b/packages/runtime/src/scr_core.h @@ -81,7 +81,7 @@ void scr_init(void); /* Program objects emitted by the bundled LLVM helper reference this symbol. * Its versioned spelling makes a mismatched manual runtime link fail before * the program can start. */ -void scr_runtime_abi_v24(void); +void scr_runtime_abi_v25(void); void scr_runtime_workers_v8(void); /* ── the trap funnel (scr_console.c; scr_library.c under -DSCR_LIB) ────── diff --git a/packages/runtime/src/scr_dyn.h b/packages/runtime/src/scr_dyn.h index 02c4d828f..cafc8d07e 100644 --- a/packages/runtime/src/scr_dyn.h +++ b/packages/runtime/src/scr_dyn.h @@ -1388,8 +1388,37 @@ typedef struct ScrDynHandleOps { /* Cross-thread structured clone (postMessage, workerData); NULL = * DataCloneError. See ScrDynHandleTransfer. */ const struct ScrDynHandleTransfer *transfer; + /* A handle that is also a Node Transform (Cipheriv, Decipheriv): the + * stream unit builds the handle's Transform from these operations on its + * first stream use. NULL = the class is not a stream. */ + const struct ScrDynHandleTransform *transform; } ScrDynHandleOps; +/* The operations a Transform handle gives the stream unit (scr_stream.c): + * the slot where the handle keeps its stream (+1) with the stream's + * release, update() and final() over bytes (+1 Buffer, or NULL with the + * exception pending), and the handle's collector trace, since the + * stream's steps hold the handle. */ +typedef struct ScrDynHandleTransform { + void *(*stream)(void *h); + void (*set_stream)(void *h, void *stream, void (*release)(void *)); + struct ScrBytes *(*update)(void *h, struct ScrBytes *chunk); + struct ScrBytes *(*final)(void *h); + ScrTraceFn trace; +} ScrDynHandleTransform; + +/* Checked-dynamic member calls and property reads on a Transform handle, + * installed by the stream unit (scr_stream_install); NULL in a program + * without it. call answers true with *result set (+1, or NULL with the + * exception pending) for the members a native stream answers, and get + * answers a stream property (+1), or NULL for other keys. */ +typedef struct ScrHandleStreamHooks { + bool (*call)(const ScrDynHandleOps *ops, void *h, ScrDyn *self, const char *method, + ScrDyn *const *args, size_t argc, ScrDyn **result); + ScrDyn *(*get)(const ScrDynHandleOps *ops, void *h, const char *key, size_t key_len); +} ScrHandleStreamHooks; +extern SCR_TL const ScrHandleStreamHooks *scr_handle_stream_hooks; + /* How a handle crosses threads, supplied by the handle's owning unit so the * message encoder (scr_message.c) needs no reference to gated units and no * per-tag registry. share runs on the sending thread: it answers a payload diff --git a/packages/runtime/src/scr_json.c b/packages/runtime/src/scr_json.c index b8f16630b..194ade887 100644 --- a/packages/runtime/src/scr_json.c +++ b/packages/runtime/src/scr_json.c @@ -37,6 +37,8 @@ static SCR_TL ScrDyn *scr_builtin_object_prototype; +SCR_TL const ScrHandleStreamHooks *scr_handle_stream_hooks; + /* Constructor capsules expose identity and name/length, but do not model * per-class static property tables yet. Never report a fabricated empty view. */ static bool scr_dyn_class_reflection_fence(const ScrDyn *value) { @@ -4309,6 +4311,7 @@ ScrDyn *scr_dyn_new_handle(void *h, ScrDynHandleTag tag) { d->v.handle.tag = tag; d->v.handle.traced = tag == SCR_DYNH_WEAK_MAP || tag == SCR_DYNH_WEAK_SET || tag == SCR_DYNH_WORKER || tag == SCR_DYNH_MESSAGE_PORT || tag == SCR_DYNH_DISPOSABLE_STACK || + tag == SCR_DYNH_CIPHER || tag == SCR_DYNH_DECIPHER || ((tag == SCR_DYNH_SET || tag == SCR_DYNH_MAP) && ((ScrMap *)h)->traced != 0); return d; diff --git a/packages/runtime/src/scr_stream.c b/packages/runtime/src/scr_stream.c index f7330b615..271937f2e 100644 --- a/packages/runtime/src/scr_stream.c +++ b/packages/runtime/src/scr_stream.c @@ -175,6 +175,11 @@ struct ScrStreamState { ScrStreamPlainInv flush_inv; bool flush_called; bool flush_pending; /* _flush called, its callback not yet run */ + /* Transform._write's backpressure: the readable length when the + * transform started, and whether its completed write waits for the + * readable side to read (Node's kCallback). */ + size_t xf_length; + bool xf_held; /* A _final that completes at once (zlib's ZlibBase): 'prefinish' starts * the flush and 'finish' does not wait for it. */ bool flush_on_prefinish; @@ -412,6 +417,7 @@ typedef enum { SCR_ST_ERROR_BUFFER, /* errorBuffer: buffered write and end() callbacks */ SCR_ST_CONSTRUCT, /* constructNT: run the construct hook */ SCR_ST_CONSTRUCTED, /* onConstruct: resume reads/writes/destroy */ + SCR_ST_XF_DONE, /* a transform's write callback after push(null) */ } ScrStreamTickOp; typedef struct ScrStreamTick { @@ -688,8 +694,13 @@ static void scr_stream_call_read(ScrStream *s) { } if (st->r.read_cb == NULL) { /* transform reads are push-driven; the attempt still clears the - * initial sync flag (Node's Transform._read ran) */ + * initial sync flag (Node's Transform._read ran) and runs a held + * write callback */ st->r.in_read_sync = false; + if (st->xf_held) { + st->xf_held = false; + scr_stream_write_done(s, NULL); + } return; } st->r.reading = true; @@ -1706,17 +1717,20 @@ static void scr_stream_wq_push(ScrStreamState *st, ScrBytes *chunk /*moves*/, Sc st->w.n++; } +static void scr_stream_transform_callback(ScrStream *s); + static void scr_stream_do_write(ScrStream *s, ScrBytes *chunk /*moves*/, ScrClosure *cb /*moves*/) { ScrStreamState *st = s->st; st->w.writing = true; st->w.wsync = true; st->w.inflight_len = chunk->len; st->w.inflight_cb = cb; + if (st->is_transform || st->passthrough) st->xf_length = st->r.length; if (st->passthrough && st->transform_cb == NULL) { /* identity: push through, complete synchronously */ scr_stream_add_chunk(s, chunk, false); scr_bytes_release(chunk); - if (!scr_exc_pending()) scr_stream_write_done(s, NULL); + if (!scr_exc_pending()) scr_stream_transform_callback(s); st->w.wsync = false; return; } @@ -3294,13 +3308,13 @@ ScrDyn *scr_stream_from_done(void) { } /* ── pipeline function stages (pipeline.js: makeAsyncIterable, pumpToNode) ── - * A run of async generator functions between two node streams. Each - * stage is called while the pipeline is set up, in pipeline order: - * makeAsyncIterable hands the first one the previous stream itself (a - * Readable is async iterable) and each later one the previous stage's - * generator. The last generator is pumped into the stream after the run - * with pumpToNode. The stages and helpers use the closure ABI (the - * closure first; the callee owns its parameters). */ + * Runs of async generator functions between node streams. Each stage is + * called while the pipeline is set up, in pipeline order: + * makeAsyncIterable hands a stage that follows a stream the stream itself + * (a Readable is async iterable) and any other stage the previous stage's + * generator. The last generator of a run that a stream follows is pumped + * into that stream with pumpToNode. The stages and helpers use the closure + * ABI (the closure first; the callee owns its parameters). */ typedef ScrPromise *(*ScrPipeNextFn)(ScrClosure *, ScrGen *); typedef ScrDyn *(*ScrPipeReadFn)(ScrClosure *, void *); @@ -3309,20 +3323,25 @@ typedef ScrDyn *(*ScrPipeBoxFn)(ScrClosure *, ScrPromise *); enum { SCR_PIPE_DEST_STREAM, SCR_PIPE_DEST_PROMISE = 2 }; typedef struct { - size_t at; /* streams[0..at-1] come before the stages */ size_t count; /* the function stages */ + uint64_t positions; /* bit j: the pipeline's j-th stage is a function */ /* stage(source[, { signal }]) answers an async generator, or a promise * for a promise destination; the source is absent for a source - * function, else the previous stream or async generator */ + * function (position 0), else the previous stream or async generator */ ScrClosure **stages; - bool source; /* stages[0] is the source (at == 0) */ int dest; /* the last stage: SCR_PIPE_DEST_* */ unsigned opts_mask; /* bit i: stages[i] takes the { signal } argument */ ScrDyn *signal; /* the pipeline's AbortSignal when opts_mask != 0 */ - ScrClosure *next, *read, *ret; /* the pumped generator's helpers, or NULL */ + /* (next, read, return) for each generator pumped into a stream, in + * pipeline order, or NULL */ + ScrClosure **helpers; ScrClosure *box; /* SCR_PIPE_DEST_PROMISE: boxes its promise as a dyn promise */ } ScrPipeStages; +static bool scr_pipe_is_stage(const ScrPipeStages *fs, size_t j) { + return fs && j < 64 && ((fs->positions >> j) & 1u); +} + /* stages[i](source[, { signal }]): the callee owns its parameters. */ static void *scr_pipe_call_stage(const ScrPipeStages *fs, size_t i, void *src /*moves*/) { ScrClosure *st = fs->stages[i]; @@ -3331,7 +3350,7 @@ static void *scr_pipe_call_stage(const ScrPipeStages *fs, size_t i, void *src /* opts = scr_dyn_new_obj(); scr_dyn_obj_set(opts, "signal", 6, scr_dyn_retain(fs->signal)); } - if (i == 0 && fs->source) { + if (i == 0 && (fs->positions & 1u)) { return opts ? ((void *(*)(ScrClosure *, ScrDyn *))st->fn)(st, opts) : ((void *(*)(ScrClosure *))st->fn)(st); } @@ -3580,17 +3599,17 @@ static void scr_pump_after_wait(ScrPump *pm, int stage, bool rejected) { } /* pumpToNode(gen, w, finish, { end }): starts at once, as the async - * function does. The helpers are borrowed. */ -static void scr_pump_start(ScrStreamPipeCtx *ctx, ScrGen *gen /*moves*/, const ScrPipeStages *fs, + * function does. The helpers (next, read, return) are borrowed. */ +static void scr_pump_start(ScrStreamPipeCtx *ctx, ScrGen *gen /*moves*/, ScrClosure *const *helpers, ScrStream *w, bool end) { ScrPump *pm = calloc(1, sizeof *pm); if (!pm) scr_stream_oom(); pm->rc = 1; pm->ctx = scr_stream_pipectx_retain_v(ctx); pm->gen = gen; - pm->next = scr_closure_retain(fs->next); - pm->read = scr_closure_retain(fs->read); - pm->ret = scr_closure_retain(fs->ret); + pm->next = scr_closure_retain(helpers[0]); + pm->read = scr_closure_retain(helpers[1]); + pm->ret = scr_closure_retain(helpers[2]); pm->w = scr_stream_retain(w); pm->end = end; pm->drain_l = scr_pump_closure((void *)&scr_pump_drain_l, pm); @@ -3721,27 +3740,27 @@ static ScrStream *scr_stream_pipeline_ex(size_t n, ScrStream **streams, ScrClosu ctx->dispose = add(signal, listener); scr_dyn_release(listener); } - /* pipelineImpl's loop over the stages: the n streams, with fs->count - * function stages before streams[fs->at] */ + /* pipelineImpl's loop over the stages: the n streams and fs->count + * function stages, at the positions fs->positions names */ size_t stages = n + (fs ? fs->count : 0); - size_t fn_first = fs ? fs->at : stages, fn_end = fs ? fs->at + fs->count : stages; ScrStream *ret = NULL; ScrGen *ret_gen = NULL; /* +1: ret when the previous stage was a function */ size_t i = 0; /* the next stream */ + size_t k = 0; /* the next function stage */ + size_t h = 0; /* the next pumped generator's helpers */ for (size_t j = 0; j < stages; j++) { bool reading = j + 1 < stages; bool end = reading || end_opt; bool last = j + 1 == stages; - if (j >= fn_first && j < fn_end) { + if (scr_pipe_is_stage(fs, j)) { /* ret = stage({ signal }) for the source, else * stage(makeAsyncIterable(ret), { signal }) */ - size_t k = j - fn_first; bool dest = last && fs->dest != SCR_PIPE_DEST_STREAM; - void *src = k == 0 && fs->source ? NULL - : ret_gen ? (void *)ret_gen - : (void *)scr_stream_retain(ret); + void *src = j == 0 ? NULL + : ret_gen ? (void *)ret_gen + : (void *)scr_stream_retain(ret); ret_gen = NULL; - void *out = scr_pipe_call_stage(fs, k, src); + void *out = scr_pipe_call_stage(fs, k++, src); if (scr_exc_pending()) { if (out && dest) scr_promise_release(out); else if (out) scr_gen_release(out); @@ -3776,7 +3795,7 @@ static ScrStream *scr_stream_pipeline_ex(size_t n, ScrStream **streams, ScrClosu } ScrStream *s = streams[i]; bool writing = j > 0; - if (reading && !(j + 1 >= fn_first && j + 1 < fn_end) && + if (reading && !scr_pipe_is_stage(fs, j + 1) && (streams[i + 1]->st->close_emitted || streams[i + 1]->st->destroyed)) { scr_pipe_throw("ERR_STREAM_UNABLE_TO_PIPE", "Cannot pipe to a closed or destroyed stream", SCR_ERR_ERROR); @@ -3803,7 +3822,7 @@ static ScrStream *scr_stream_pipeline_ex(size_t n, ScrStream **streams, ScrClosu ctx->finish_count++; ScrGen *g = ret_gen; ret_gen = NULL; - scr_pump_start(ctx, g, fs, s, end); + scr_pump_start(ctx, g, fs->helpers + 3 * h++, s, end); } else if (j > 0) { if (!ret->st->has_r) { static const char msg[] = @@ -3841,12 +3860,12 @@ static ScrStream *scr_stream_pipeline_ex(size_t n, ScrStream **streams, ScrClosu return scr_stream_retain(ret); } -static ScrPipeStages scr_pipe_stages_of(double at, double count, ScrClosure **stages, double flags, - double mask, ScrClosure *next, ScrClosure *read, - ScrClosure *ret, ScrClosure *box, ScrDyn *signal) { +static ScrPipeStages scr_pipe_stages_of(double count, ScrClosure **stages, double positions, + double flags, double mask, ScrClosure **helpers, + ScrClosure *box, ScrDyn *signal) { int bits = (int)flags; - ScrPipeStages fs = {(size_t)at, (size_t)count, stages, (bits & 1) != 0, (bits >> 1) & 3, - (unsigned)mask, signal, next, read, ret, box}; + ScrPipeStages fs = {(size_t)count, (uint64_t)positions, stages, (bits >> 1) & 3, (unsigned)mask, + signal, helpers, box}; return fs; } @@ -3864,25 +3883,25 @@ static void scr_pipe_dyn_value_inv(ScrClosure *cb, ScrError *err, ScrDyn *value, if (r != NULL) scr_dyn_release(r); } -/* pipeline(...) with a run of function stages (see ScrPipeStages): flags - * bit 0 marks a source function and bits 1-2 the destination kind; mask - * names the stages taking { signal }. The helpers, box, signal and abort - * are borrowed (each NULL when unused); cb moves. */ -ScrStream *scr_stream_pipeline_stages(double n, ScrStream **streams, double at, double count, - ScrClosure **stages, double flags, double mask, - ScrClosure *next, ScrClosure *read, ScrClosure *ret, - ScrClosure *box, ScrDyn *signal, ScrClosure *abort, - ScrClosure *cb, ScrStreamErrInv inv) { - ScrPipeStages fs = scr_pipe_stages_of(at, count, stages, flags, mask, next, read, ret, box, signal); +/* pipeline(...) with function stages (see ScrPipeStages): positions + * marks the function stages among the n + count stages, flags bits 1-2 + * give the destination kind, and mask names the stages taking + * { signal }. The helpers, box, signal and abort are borrowed (each NULL + * when unused); cb moves. */ +ScrStream *scr_stream_pipeline_stages(double n, ScrStream **streams, double count, + ScrClosure **stages, double positions, double flags, + double mask, ScrClosure **helpers, ScrClosure *box, + ScrDyn *signal, ScrClosure *abort, ScrClosure *cb, + ScrStreamErrInv inv) { + ScrPipeStages fs = scr_pipe_stages_of(count, stages, positions, flags, mask, helpers, box, signal); return scr_stream_pipeline_ex((size_t)n, streams, cb, inv, true, NULL, NULL, &fs, abort, NULL); } -ScrStream *scr_stream_pipeline_stages_dyn(double n, ScrStream **streams, double at, double count, - ScrClosure **stages, double flags, double mask, - ScrClosure *next, ScrClosure *read, ScrClosure *ret, - ScrClosure *box, ScrDyn *signal, ScrClosure *abort, - ScrDyn *cb) { - ScrPipeStages fs = scr_pipe_stages_of(at, count, stages, flags, mask, next, read, ret, box, signal); +ScrStream *scr_stream_pipeline_stages_dyn(double n, ScrStream **streams, double count, + ScrClosure **stages, double positions, double flags, + double mask, ScrClosure **helpers, ScrClosure *box, + ScrDyn *signal, ScrClosure *abort, ScrDyn *cb) { + ScrPipeStages fs = scr_pipe_stages_of(count, stages, positions, flags, mask, helpers, box, signal); ScrClosure *c = scr_stream_dynopt_clo(cb, (void *)&scr_stream_finished_dyn_inv); /* a function destination's value reaches the callback */ ScrPipeValInv vi = fs.dest != SCR_PIPE_DEST_STREAM ? &scr_pipe_dyn_value_inv : NULL; @@ -4263,12 +4282,12 @@ static void scr_sp_value_inv(ScrClosure *cb, ScrError *err, ScrDyn *value, ScrPr scr_promise_release(p); } -ScrPromise *scr_sp_pipeline_stages(double n, ScrStream **streams, double at, double count, - ScrClosure **stages, double flags, double mask, - ScrClosure *next, ScrClosure *read, ScrClosure *ret, - ScrClosure *box, ScrDyn *signal, ScrClosure *abort) { +ScrPromise *scr_sp_pipeline_stages(double n, ScrStream **streams, double count, + ScrClosure **stages, double positions, double flags, + double mask, ScrClosure **helpers, ScrClosure *box, + ScrDyn *signal, ScrClosure *abort) { ScrPromise *p = scr_promise_new(); - ScrPipeStages fs = scr_pipe_stages_of(at, count, stages, flags, mask, next, read, ret, box, signal); + ScrPipeStages fs = scr_pipe_stages_of(count, stages, positions, flags, mask, helpers, box, signal); ScrPipeValInv vi = fs.dest != SCR_PIPE_DEST_STREAM ? &scr_sp_value_inv : NULL; ScrStream *dst = scr_stream_pipeline_ex((size_t)n, streams, scr_sp_watcher(p), &scr_sp_settle_inv, true, NULL, NULL, &fs, abort, vi); @@ -5800,6 +5819,19 @@ void scr_stream_destroy_done(ScrStream *s, ScrError *err /*moves*/) { } } +/* Transform._write's callback after the transform pushed its output: + * on a tick once the readable side has ended, at once when the writable + * side has ended, the transform pushed nothing, or the readable buffer is + * below its high-water mark, and otherwise when the readable side next + * reads (Transform._read). */ +static void scr_stream_transform_callback(ScrStream *s) { + ScrStreamState *st = s->st; + if (st->r.ended) scr_st_tick(s, SCR_ST_XF_DONE, NULL, NULL); + else if (st->w.ending || st->xf_length == st->r.length || st->r.length < st->r.hwm) + scr_stream_write_done(s, NULL); + else st->xf_held = true; +} + void scr_stream_transform_done(ScrStream *s, ScrError *err /*moves*/, ScrBytes *data /*moves*/, ScrStr *data_str /*moves*/) { if (!err) { @@ -5820,7 +5852,8 @@ void scr_stream_transform_done(ScrStream *s, ScrError *err /*moves*/, ScrBytes * if (err) scr_error_release(err); return; } - scr_stream_write_done(s, err); + if (err) scr_stream_write_done(s, err); + else scr_stream_transform_callback(s); } void scr_stream_flush_done(ScrStream *s, ScrError *err /*moves*/, ScrBytes *data /*moves*/, @@ -6171,6 +6204,9 @@ static void scr_stream_run_tick(ScrStreamTick *t) { } break; } + case SCR_ST_XF_DONE: + if (st->w.writing) scr_stream_write_done(s, NULL); + break; case SCR_ST_AFTER_WRITE: { st->w.after_scheduled = false; ScrClosure *cb = t->cb; @@ -6369,8 +6405,11 @@ static void scr_stream_dispatch(void) { } } +static const ScrHandleStreamHooks scr_handle_stream_hooks_impl; + void scr_stream_install(void) { scr_emitter_on_hook = &scr_stream_on_listener; + scr_handle_stream_hooks = &scr_handle_stream_hooks_impl; scr_loop_set_stream(&scr_stream_ticks_pending, &scr_stream_dispatch); } @@ -6409,23 +6448,138 @@ void scr_stream_worker_stdio(void) { #endif } -static ScrStream *scr_stream_view_receiver(const ScrDyn *value) { - if (value->kind == SCR_DYN_TYPED_REF && value->v.typed_ref.type_key_len > 7 && - !memcmp(value->v.typed_ref.type_key, "object:", 7)) { - ScrStream *stream = scr_dyn_typed_ref_unbox(value); - const ScrVt *vt = scr_stream_vt_of(stream); - if (vt && ((vt->pre >= scr_readable_vt.pre && vt->pre <= scr_readable_vt.post) || - (vt->pre >= scr_writable_vt.pre && vt->pre <= scr_writable_vt.post))) return stream; - value->v.typed_ref.release(stream); +/* ── handles that are Transforms (Cipheriv, Decipheriv) ────────────────── + * A Transform handle (ScrDynHandleOps.transform) used as a stream gets one + * native Transform, built here on first use and kept in the handle's + * slot. Its steps share the handle (held, and traced: the handle and its + * stream form a cycle the collector reclaims) and the handle's static + * ops: each chunk goes through the handle's update(), and the flush pushes + * final() or reports its error. */ + +static void *scr_handle_ops_retain(void *p) { return p; } +static void scr_handle_ops_release(void *p) { (void)p; } + +static const ScrDynHandleOps *scr_handle_step_handle_ops(ScrClosure *cb) { + return scr_box_get_ref(cb->caps[1]); +} + +/* The step's handle, borrowed: scr_box_get_ref answers +1, and the box + * keeps the handle alive. */ +static void *scr_handle_step_handle(ScrClosure *cb) { + void *h = scr_box_get_ref(cb->caps[0]); + scr_handle_step_handle_ops(cb)->release(h); + return h; +} + +static const ScrDynHandleTransform *scr_handle_step_ops(ScrClosure *cb) { + return scr_handle_step_handle_ops(cb)->transform; +} + +/* The pending exception as a stream error (+1). */ +static ScrError *scr_handle_step_caught(void) { + ScrCaught *caught = scr_exc_take(); + ScrDyn *value = scr_caught_to_dyn(caught); + scr_caught_release(caught); + ScrError *err = value ? scr_errdyn_err_of(value) : NULL; + if (value) scr_dyn_release(value); + return err ? err : scr_stream_mkerr("ERR_INTERNAL_ASSERTION", "a Transform handle threw a value that is not an Error"); +} + +static void scr_handle_step_transform(ScrClosure *cb, ScrStream *s, ScrBytes *chunk) { + /* A throwing update() leaves the exception pending: it throws out of + * the write, as Node's _transform does. */ + ScrBytes *out = scr_handle_step_ops(cb)->update(scr_handle_step_handle(cb), chunk); + if (out) scr_stream_transform_done(s, NULL, out, NULL); +} + +static void scr_handle_step_flush(ScrClosure *cb, ScrStream *s) { + ScrBytes *out = scr_handle_step_ops(cb)->final(scr_handle_step_handle(cb)); + scr_stream_flush_done(s, out ? NULL : scr_handle_step_caught(), out, NULL); +} + +static void scr_handle_step_destroy(ScrClosure *cb, ScrStream *s, ScrError *err) { + (void)cb; + scr_stream_destroy_done(s, err ? scr_error_retain(err) : NULL); +} + +static ScrClosure *scr_handle_step(const ScrDynHandleOps *ops, void *h) { + ScrClosure *step = scr_closure_new(NULL, 2); + step->caps[0] = scr_box_new_obj(ops->retain, ops->release, ops->transform->trace); + scr_box_set_ref(step->caps[0], ops->retain(h)); + step->caps[1] = scr_box_new_obj(scr_handle_ops_retain, scr_handle_ops_release, NULL); + scr_box_set_ref(step->caps[1], (void *)ops); + return step; +} + +/* The Transform of handle h (+1), built on first use. */ +static ScrStream *scr_handle_transform(const ScrDynHandleOps *ops, void *h) { + const ScrDynHandleTransform *t = ops->transform; + ScrStream *s = t->stream(h); + if (!s) { + s = scr_stream_new_transform(-1, -1, true, true, true, true, true, + scr_handle_step(ops, h), scr_handle_step_transform, + scr_handle_step(ops, h), scr_handle_step_flush, + scr_handle_step(ops, h), scr_handle_step_destroy); + s->cls = ops->cls; + t->set_stream(h, s, scr_stream_release_v); } + return scr_stream_retain(s); +} + +/* The native stream of a checked-dynamic Transform handle (+1), or NULL + * when the value is not one. */ +ScrStream *scr_stream_of_handle(const ScrDyn *value) { + if (value->kind != SCR_DYN_HANDLE) return NULL; + const ScrDynHandleOps *ops = scr_dyn_handle_ops_of(value); + return ops->transform ? scr_handle_transform(ops, value->v.handle.ptr) : NULL; +} + +/* A boxed native stream (+1), or NULL for any other value. */ +static ScrStream *scr_stream_boxed(const ScrDyn *value) { + if (value->kind != SCR_DYN_TYPED_REF || value->v.typed_ref.type_key_len <= 7 || + memcmp(value->v.typed_ref.type_key, "object:", 7) != 0) + return NULL; + ScrStream *stream = scr_dyn_typed_ref_unbox(value); + const ScrVt *vt = scr_stream_vt_of(stream); + if (vt && ((vt->pre >= scr_readable_vt.pre && vt->pre <= scr_readable_vt.post) || + (vt->pre >= scr_writable_vt.pre && vt->pre <= scr_writable_vt.post))) + return stream; + value->v.typed_ref.release(stream); + return NULL; +} + +/* stream.handleStream: the stream of a value typed as a stream handle + * class (a Cipheriv or Decipheriv), +1. A value of that type can also be + * the stream itself, boxed (the stream addAbortSignal answers). */ +ScrStream *scr_stream_handle(const ScrDyn *value) { + ScrStream *stream = scr_stream_of_handle(value); + if (!stream) stream = scr_stream_boxed(value); + if (stream) return stream; + static const char message[] = "Stream use of a value that is not a native stream has no lowering"; + scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020"); + return NULL; +} + +static ScrStream *scr_stream_view_receiver(const ScrDyn *value) { + ScrStream *stream = scr_stream_of_handle(value); + if (!stream) stream = scr_stream_boxed(value); + if (stream) return stream; scr_dyn_arg_type_fail("destination", "an instance of Stream", value); return NULL; } -static ScrDyn *scr_stream_view_call(ScrClosure *cb, ScrDyn *const *args, size_t argc) { - ScrStream *stream = scr_box_get_ref(cb->caps[0]); - ScrStr *name = scr_box_get_ref(cb->caps[1]); - const char *method = name->data; +/* The members a native stream answers to checked-dynamic calls. */ +static const char *const scr_stream_dyn_methods[] = { + "on", "once", "addListener", "prependListener", "prependOnceListener", + "off", "removeListener", "pipe", "unpipe", "read", "pause", "resume", "isPaused", + "setEncoding", "write", "end", "destroy", "cork", "uncork", +}; + +/* A checked-dynamic call of one of a native stream's members (borrowed + * stream): the result, +1, with `this` results answering `self`, or the + * current `this` when self is NULL. */ +static ScrDyn *scr_stream_dyn_call(ScrStream *stream, ScrDyn *self, const char *method, + ScrDyn *const *args, size_t argc) { ScrDyn *result = NULL; ScrDyn *first = argc ? args[0] : scr_dyn_undefined(); if (!strcmp(method, "on") || !strcmp(method, "once") || !strcmp(method, "addListener") || @@ -6501,21 +6655,72 @@ static ScrDyn *scr_stream_view_call(ScrClosure *cb, ScrDyn *const *args, size_t scr_error_release(error); } else if (!strcmp(method, "cork")) scr_stream_cork(stream); else if (!strcmp(method, "uncork")) scr_stream_uncork(stream); - if (!result && !scr_exc_pending()) result = scr_dyn_this_get(); + if (!result && !scr_exc_pending()) result = self ? scr_dyn_retain(self) : scr_dyn_this_get(); + return result; +} + +static ScrDyn *scr_stream_view_call(ScrClosure *cb, ScrDyn *const *args, size_t argc) { + ScrStream *stream = scr_box_get_ref(cb->caps[0]); + ScrStr *name = scr_box_get_ref(cb->caps[1]); + ScrDyn *result = scr_stream_dyn_call(stream, NULL, name->data, args, argc); scr_str_release(name); scr_stream_release(stream); return result; } +/* ScrHandleStreamHooks.call: a member a native stream answers to + * checked-dynamic calls, on the handle's Transform. Members that answer + * the stream answer `self`. */ +static bool scr_handle_stream_call(const ScrDynHandleOps *ops, void *h, ScrDyn *self, + const char *method, ScrDyn *const *args, size_t argc, + ScrDyn **result) { + for (size_t i = 0; i < sizeof scr_stream_dyn_methods / sizeof *scr_stream_dyn_methods; i++) { + if (strcmp(method, scr_stream_dyn_methods[i]) != 0) continue; + ScrStream *stream = scr_handle_transform(ops, h); + *result = scr_stream_dyn_call(stream, self, method, args, argc); + scr_stream_release(stream); + return true; + } + return false; +} + +/* The stream properties a checked-dynamic read answers. */ +static const char *const scr_stream_dyn_properties[] = { + "readable", "readableEnded", "readableLength", "readableHighWaterMark", + "writable", "writableEnded", "writableFinished", "writableLength", "writableHighWaterMark", + "writableNeedDrain", "destroyed", "closed", +}; + +static ScrDyn *scr_stream_dyn_property(ScrStream *stream, const char *name) { + double value = scr_stream_prop(stream, name); + bool number = strstr(name, "Length") || strstr(name, "HighWaterMark"); + return number ? scr_dyn_new_num(value) : scr_dyn_new_bool(value != 0); +} + +/* ScrHandleStreamHooks.get: a stream property of the handle's Transform. */ +static ScrDyn *scr_handle_stream_get(const ScrDynHandleOps *ops, void *h, const char *key, + size_t key_len) { + for (size_t i = 0; i < sizeof scr_stream_dyn_properties / sizeof *scr_stream_dyn_properties; i++) { + const char *name = scr_stream_dyn_properties[i]; + if (strlen(name) != key_len || memcmp(name, key, key_len) != 0) continue; + ScrStream *stream = scr_handle_transform(ops, h); + ScrDyn *value = scr_stream_dyn_property(stream, name); + scr_stream_release(stream); + return value; + } + return NULL; +} + +static const ScrHandleStreamHooks scr_handle_stream_hooks_impl = { + scr_handle_stream_call, + scr_handle_stream_get, +}; + ScrDyn *scr_stream_dyn_view(ScrStream *stream) { ScrDyn *view = scr_dyn_new_obj(); ScrDyn *prototype = scr_dyn_new_obj(); - static const char *const methods[] = { - "on", "once", "addListener", "prependListener", "prependOnceListener", - "off", "removeListener", "pipe", "unpipe", "read", "pause", "resume", "isPaused", - "setEncoding", "write", "end", "destroy", "cork", "uncork", - }; - for (size_t i = 0; i < sizeof methods / sizeof *methods; i++) { + const char *const *methods = scr_stream_dyn_methods; + for (size_t i = 0; i < sizeof scr_stream_dyn_methods / sizeof *scr_stream_dyn_methods; i++) { ScrClosure *cb = scr_closure_new((void *)scr_stream_view_call, 2); cb->caps[0] = scr_box_new_obj(scr_stream_retain_v, scr_stream_release_v, scr_stream_trace); cb->caps[1] = scr_box_new(SCR_BOX_STR); @@ -6524,16 +6729,9 @@ ScrDyn *scr_stream_dyn_view(ScrStream *stream) { scr_dyn_obj_set(prototype, methods[i], strlen(methods[i]), scr_dyn_new_func(cb, scr_stream_view_call, 0, "native stream method", methods[i])); } - static const char *const properties[] = { - "readable", "readableEnded", "readableLength", "readableHighWaterMark", - "writable", "writableEnded", "writableFinished", "writableLength", "writableHighWaterMark", - "writableNeedDrain", "destroyed", "closed", - }; - for (size_t i = 0; i < sizeof properties / sizeof *properties; i++) { - double value = scr_stream_prop(stream, properties[i]); - bool number = strstr(properties[i], "Length") || strstr(properties[i], "HighWaterMark"); - scr_dyn_obj_set(view, properties[i], strlen(properties[i]), - number ? scr_dyn_new_num(value) : scr_dyn_new_bool(value != 0)); + for (size_t i = 0; i < sizeof scr_stream_dyn_properties / sizeof *scr_stream_dyn_properties; i++) { + const char *name = scr_stream_dyn_properties[i]; + scr_dyn_obj_set(view, name, strlen(name), scr_stream_dyn_property(stream, name)); } if (stream->st->native && stream->st->native_ops && stream->st->native_ops->view) { ScrClosure *cb = scr_closure_new((void *)scr_stream_view_call, 2); @@ -6712,17 +6910,13 @@ ScrStream *scr_stream_pipe_general(ScrStream *src, ScrStream *dst, bool end) { /* A pipeline() stage that arrives as a checked-dynamic value (the * stream.unboxDyn libCall): a boxed native stream unwraps by identity - * (+1); any other value throws the compiled program's not-supported - * message (Node also takes iterables and functions there). */ + * (+1), a stream handle (a Cipheriv or Decipheriv) answers its stream, and + * any other value throws the compiled program's not-supported message + * (Node also takes iterables and functions there). */ ScrStream *scr_stream_unbox_dyn(const ScrDyn *value, const ScrStr *message) { - if (value->kind == SCR_DYN_TYPED_REF && value->v.typed_ref.type_key_len > 7 && - !memcmp(value->v.typed_ref.type_key, "object:", 7)) { - ScrStream *stream = scr_dyn_typed_ref_unbox(value); - const ScrVt *vt = scr_stream_vt_of(stream); - if (vt && ((vt->pre >= scr_readable_vt.pre && vt->pre <= scr_readable_vt.post) || - (vt->pre >= scr_writable_vt.pre && vt->pre <= scr_writable_vt.post))) return stream; - value->v.typed_ref.release(stream); - } + ScrStream *stream = scr_stream_of_handle(value); + if (!stream) stream = scr_stream_boxed(value); + if (stream) return stream; scr_throw_error_msg_code(SCR_ERR_ERROR, message->data, message->len, "SC2020"); return NULL; } diff --git a/packages/runtime/src/scr_stream.h b/packages/runtime/src/scr_stream.h index 99f58331c..1e5b789e7 100644 --- a/packages/runtime/src/scr_stream.h +++ b/packages/runtime/src/scr_stream.h @@ -143,6 +143,13 @@ ScrStream *scr_stream_pipe_general(ScrStream *src, ScrStream *dst, bool end); /* A boxed native stream out of a checked-dynamic pipeline stage (+1), or * NULL with `message` thrown as the not-supported Error. */ ScrStream *scr_stream_unbox_dyn(const struct ScrDyn *value, const ScrStr *message); +/* Handles that are Transforms (ScrDynHandleOps.transform: Cipheriv and + * Decipheriv). scr_stream_of_handle: the handle's Transform (+1), built on + * first use, or NULL when the value is not such a handle. + * stream.handleStream: the same, throwing the coded SC2020 error for any + * other value. */ +ScrStream *scr_stream_of_handle(const struct ScrDyn *value); +ScrStream *scr_stream_handle(const struct ScrDyn *value); /* Checked-dynamic stream slots (scr_stream_dyn.c): the native stream a * value boxes with the requested side (1 readable, 2 writable; +1, or * NULL), and readable.pipe()/unpipe() for a destination that is not a @@ -197,35 +204,34 @@ ScrStream *scr_stream_pipeline(double n, ScrStream **streams, ScrClosure *cb, Sc * mustCall wrappers; borrowed). */ ScrClosure *scr_stream_finished_dyn(ScrStream *s, struct ScrDyn *cb); ScrStream *scr_stream_pipeline_dyn(double n, ScrStream **streams, struct ScrDyn *cb); -/* pipeline(...[, cb]) with one run of function stages (pipeline.js): the - * run starts at streams[at] (count functions). flags bit 0: the first - * stage is a source function, called with only its options; bits 1-2: - * the last stage is a function destination (2: an async function whose - * promise, boxed through box, carries the value to the callback), and - * pipeline() answers a PassThrough. Other - * stages get the previous stream itself or the previous stage's async - * generator. mask bit i: stage i takes { signal } (the pipeline's own - * AbortSignal, aborted through abort when the pipeline finishes). The - * last generator before a stream or a PassThrough is pumped - * (pumpToNode) through its helpers: next/ret answer the resume's - * promise, read maps its IteratorResult to the value or - * scr_stream_from_done. Streams and closures borrowed (helpers, box, - * signal and abort NULL when unused); cb moves. */ -ScrStream *scr_stream_pipeline_stages(double n, ScrStream **streams, double at, double count, - ScrClosure **stages, double flags, double mask, - ScrClosure *next, ScrClosure *read, ScrClosure *ret, - ScrClosure *box, struct ScrDyn *signal, ScrClosure *abort, - ScrClosure *cb, ScrStreamErrInv inv); -ScrStream *scr_stream_pipeline_stages_dyn(double n, ScrStream **streams, double at, double count, - ScrClosure **stages, double flags, double mask, - ScrClosure *next, ScrClosure *read, ScrClosure *ret, - ScrClosure *box, struct ScrDyn *signal, - ScrClosure *abort, struct ScrDyn *cb); -struct ScrPromise *scr_sp_pipeline_stages(double n, ScrStream **streams, double at, double count, - ScrClosure **stages, double flags, double mask, - ScrClosure *next, ScrClosure *read, ScrClosure *ret, - ScrClosure *box, struct ScrDyn *signal, - ScrClosure *abort); +/* pipeline(...[, cb]) with function stages (pipeline.js): positions bit j + * marks the j-th of the n + count stages a function. A function at + * position 0 is a source function, called with only its options. flags + * bits 1-2: the last stage is a function destination (2: an async + * function whose promise, boxed through box, carries the value to the + * callback), and pipeline() answers a PassThrough. Other stages get the + * previous stream itself or the previous stage's async generator. mask + * bit i: function i takes { signal } (the pipeline's own AbortSignal, + * aborted through abort when the pipeline finishes). The last generator + * of each run that a stream follows is pumped (pumpToNode) through its + * three helpers in `helpers`: next/ret answer the resume's promise, read + * maps its IteratorResult to the value or scr_stream_from_done. Streams + * and closures borrowed (helpers, box, signal and abort NULL when + * unused); cb moves. */ +ScrStream *scr_stream_pipeline_stages(double n, ScrStream **streams, double count, + ScrClosure **stages, double positions, double flags, + double mask, ScrClosure **helpers, ScrClosure *box, + struct ScrDyn *signal, ScrClosure *abort, ScrClosure *cb, + ScrStreamErrInv inv); +ScrStream *scr_stream_pipeline_stages_dyn(double n, ScrStream **streams, double count, + ScrClosure **stages, double positions, double flags, + double mask, ScrClosure **helpers, ScrClosure *box, + struct ScrDyn *signal, ScrClosure *abort, + struct ScrDyn *cb); +struct ScrPromise *scr_sp_pipeline_stages(double n, ScrStream **streams, double count, + ScrClosure **stages, double positions, double flags, + double mask, ScrClosure **helpers, ScrClosure *box, + struct ScrDyn *signal, ScrClosure *abort); /* stream.compose(s1..sn): a pipeline over the streams and a Duplex that * writes to the first and reads from the last (compose.js). One stream * answers itself (Duplex.from of a duplex). +1, or NULL with diff --git a/packages/runtime/src/scr_stream_dyn.c b/packages/runtime/src/scr_stream_dyn.c index 11dcf6ee2..5cef9d536 100644 --- a/packages/runtime/src/scr_stream_dyn.c +++ b/packages/runtime/src/scr_stream_dyn.c @@ -17,8 +17,11 @@ static bool scr_stream_dyn_within(const ScrVt *vt, const ScrVt *cls) { /* The native stream a checked-dynamic value boxes (+1), when it has the * requested side (1 readable, 2 writable; Duplex, Transform and PassThrough - * have both), or NULL for any other value. Never throws. */ + * have both), or the stream of a stream handle, or NULL for any other + * value. Never throws. */ ScrStream *scr_stream_dyn_native(const ScrDyn *value, double side) { + /* A Cipheriv or Decipheriv is a Transform. */ + if (value->kind == SCR_DYN_HANDLE) return scr_stream_of_handle(value); if (value->kind != SCR_DYN_TYPED_REF || value->v.typed_ref.type_key_len <= 7 || memcmp(value->v.typed_ref.type_key, "object:", 7) != 0) return NULL; diff --git a/packages/runtime/src/scr_zlib_stream.c b/packages/runtime/src/scr_zlib_stream.c index 4ed717d53..54ffacf02 100644 --- a/packages/runtime/src/scr_zlib_stream.c +++ b/packages/runtime/src/scr_zlib_stream.c @@ -104,7 +104,8 @@ static void scr_zs_finish(ScrZlibStream *zs, ScrStream *s) { zs->flushing = false; scr_stream_flush_done(s, NULL, NULL, NULL); } else { - scr_stream_transform_done(s, NULL, NULL, NULL); + /* scr_zs_complete has applied Transform._write's callback rule. */ + scr_stream_write_done(s, NULL); } } diff --git a/tests/corpus/7055-cipher-streams.ts b/tests/corpus/7055-cipher-streams.ts new file mode 100644 index 000000000..8befd2339 --- /dev/null +++ b/tests/corpus/7055-cipher-streams.ts @@ -0,0 +1,182 @@ +// Cipheriv and Decipheriv as Transforms: pipeline() and stream/promises +// pipeline stages, pipe() chains, for await, write()/end() with 'data' +// events, setEncoding(), finished(), compose(), addAbortSignal(), +// stream/consumers, the stream properties, and the cipher's state after +// its stream flushed. A Hash reads through stream/consumers and for await +// the same way. +import * as crypto from "node:crypto"; +import { + PassThrough, + Readable, + Writable, + addAbortSignal, + compose, + finished, + pipeline, +} from "node:stream"; +import { text } from "node:stream/consumers"; +import { pipeline as pipelinePromise } from "node:stream/promises"; + +const key = Buffer.alloc(32, 7); +const iv = Buffer.alloc(16, 3); + +function collector(into: Buffer[]): Writable { + return new Writable({ + write(chunk: Buffer, _enc: string, cb: () => void) { + into.push(chunk); + cb(); + }, + }); +} + +async function viaCallbackPipeline(): Promise { + const out: Buffer[] = []; + await new Promise((resolve) => { + pipeline( + Readable.from(["hello ", "cipher ", "streams"]), + crypto.createCipheriv("aes-256-cbc", key, iv), + crypto.createDecipheriv("aes-256-cbc", key, iv), + collector(out), + (err: Error | null) => { + console.log("callback pipeline:", err ?? null, Buffer.concat(out).toString()); + resolve(); + }, + ); + }); +} + +async function viaPromisePipeline(): Promise { + const hash = crypto.createHash("sha256"); + await pipelinePromise( + Readable.from([Buffer.from("abc"), Buffer.from("def")]), + crypto.createCipheriv("aes-256-ctr", key, iv), + new PassThrough(), + hash, + ); + console.log("promise pipeline digest:", hash.digest("hex")); +} + +async function viaPipeAndForAwait(): Promise { + const cipher = crypto.createCipheriv("aes-256-cbc", key, iv); + const decipher = crypto.createDecipheriv("aes-256-cbc", key, iv); + const chain = Readable.from(["piped ", "through ", "two ciphers"]).pipe(cipher).pipe(decipher); + let text = ""; + for await (const chunk of chain) text += chunk; + console.log("pipe + for await:", text); +} + +async function viaEvents(): Promise { + const cipher = crypto.createCipheriv("aes-128-cbc", Buffer.alloc(16, 1), Buffer.alloc(16, 2)); + cipher.setEncoding("hex"); + let hex = ""; + cipher.on("data", (chunk: string) => { + hex += chunk; + }); + await new Promise((resolve) => { + cipher.on("end", () => { + console.log("events:", typeof hex, hex); + resolve(); + }); + console.log("write returns:", cipher.write("first block of text")); + cipher.end("and the rest"); + }); + // The stream's flush ran final(): the cipher is finished. + try { + cipher.update("more"); + } catch (e) { + console.log("update after the stream:", (e as Error).message); + } + try { + cipher.final(); + } catch (e) { + console.log("final after the stream:", (e as NodeJS.ErrnoException).code, (e as Error).message); + } +} + +async function gcm(): Promise { + const gcmKey = Buffer.alloc(32, 9); + const nonce = Buffer.alloc(12, 4); + const enc = crypto.createCipheriv("aes-256-gcm", gcmKey, nonce); + const parts: Buffer[] = []; + enc.on("data", (chunk: Buffer) => parts.push(chunk)); + await new Promise((resolve) => { + enc.on("end", () => resolve()); + enc.end("authenticated message"); + }); + const tag = enc.getAuthTag(); + console.log("gcm tag length:", tag.length); + const dec = crypto.createDecipheriv("aes-256-gcm", gcmKey, nonce); + dec.setAuthTag(tag); + let plain = ""; + for await (const chunk of Readable.from([Buffer.concat(parts)]).pipe(dec)) plain += chunk; + console.log("gcm round trip:", plain); +} + +async function viaFinishedAndProperties(): Promise { + const c = crypto.createDecipheriv("aes-256-ctr", key, iv); + console.log("before:", c.readable, c.writable, c.writableEnded, c.destroyed, c.writableLength); + const done = new Promise((resolve) => { + finished(c, (err?: NodeJS.ErrnoException | null) => { + console.log("finished:", err ?? null, c.readableEnded, c.writableFinished); + resolve(); + }); + }); + const parts: string[] = []; + const reading = (async () => { + for await (const chunk of c) parts.push(chunk.toString("hex")); + })(); + c.write(Buffer.from("00112233", "hex")); + c.end(Buffer.from("44556677", "hex")); + console.log("ended:", c.writableEnded, c.writable); + await reading; + await done; + console.log("for await over the cipher:", parts.join("")); + await new Promise((resolve) => setImmediate(resolve)); + console.log("after close:", c.destroyed, c.closed); +} + +async function viaCompositions(): Promise { + const both = compose( + crypto.createCipheriv("aes-256-cbc", key, iv), + crypto.createDecipheriv("aes-256-cbc", key, iv), + ); + let composed = ""; + both.on("data", (chunk: Buffer) => { + composed += chunk.toString(); + }); + await new Promise((resolve) => { + both.on("end", () => resolve()); + both.end("composed"); + }); + console.log("compose:", composed); + + const ac = new AbortController(); + const aborted = addAbortSignal(ac.signal, crypto.createCipheriv("aes-256-ctr", key, iv)); + aborted.on("error", (e: Error) => console.log("addAbortSignal:", e.name)); + const closed = new Promise((resolve) => aborted.on("close", () => resolve())); + ac.abort(); + await closed; + console.log("aborted cipher destroyed:", aborted.destroyed); + + const sealed = crypto.createCipheriv("aes-256-ctr", key, iv).update("through consumers"); + const plain = await text(Readable.from([sealed]).pipe(crypto.createDecipheriv("aes-256-ctr", key, iv))); + console.log("consumers text:", plain); + + const hash = crypto.createHash("sha1"); + hash.setEncoding("hex"); + console.log("hash text:", await text(Readable.from(["abc"]).pipe(hash))); + const md5 = crypto.createHash("md5"); + md5.end("xyz"); + for await (const digest of md5) console.log("hash for await:", (digest as Buffer).toString("hex")); +} + +async function main(): Promise { + await viaFinishedAndProperties(); + await viaCompositions(); + await viaCallbackPipeline(); + await viaPromisePipeline(); + await viaPipeAndForAwait(); + await viaEvents(); + await gcm(); +} +main(); diff --git a/tests/corpus/7056-cipher-stream-errors.ts b/tests/corpus/7056-cipher-stream-errors.ts new file mode 100644 index 000000000..e3e653091 --- /dev/null +++ b/tests/corpus/7056-cipher-stream-errors.ts @@ -0,0 +1,111 @@ +// Cipher stream errors, close ordering and backpressure: a bad decrypt +// through pipeline() destroys every stage with the same error, a failed +// GCM authentication reaches 'error' after the data, destroy() closes the +// cipher's stream, and write() reports the high-water mark with 'drain'. +import * as crypto from "node:crypto"; +import { Readable, Writable, pipeline } from "node:stream"; + +const key = Buffer.alloc(32, 5); +const iv = Buffer.alloc(16, 6); + +function sealed(text: string): Buffer { + const c = crypto.createCipheriv("aes-256-cbc", key, iv); + return Buffer.concat([c.update(text), c.final()]); +} + +async function badDecrypt(): Promise { + const log: string[] = []; + const source = Readable.from([sealed("secret message")]); + const decipher = crypto.createDecipheriv("aes-256-cbc", Buffer.alloc(32, 8), iv); + const sink = new Writable({ + write(_chunk: Buffer, _enc: string, cb: () => void) { + cb(); + }, + }); + source.on("close", () => log.push("source close")); + decipher.on("error", (e: NodeJS.ErrnoException) => log.push(`decipher error ${e.code}`)); + decipher.on("close", () => log.push("decipher close")); + sink.on("error", (e: NodeJS.ErrnoException) => log.push(`sink error ${e.code}`)); + sink.on("close", () => log.push("sink close")); + await new Promise((resolve) => { + pipeline(source, decipher, sink, (err: NodeJS.ErrnoException | null) => { + log.push(`callback ${err?.code} ${err?.message}`); + setImmediate(() => { + console.log(log.join("\n")); + console.log("destroyed:", source.destroyed, decipher.destroyed, sink.destroyed); + resolve(); + }); + }); + }); +} + +async function gcmWithoutTag(): Promise { + const d = crypto.createDecipheriv("aes-256-gcm", key, Buffer.alloc(12)); + await new Promise((resolve) => { + d.on("data", (chunk: Buffer) => console.log("gcm data", chunk.length)); + d.on("error", (e: Error) => console.log("gcm error:", e.message)); + d.on("close", () => { + console.log("gcm close"); + resolve(); + }); + d.end(Buffer.alloc(5)); + }); +} + +async function destroyMidway(): Promise { + const c = crypto.createCipheriv("aes-256-ctr", key, iv); + await new Promise((resolve) => { + c.on("data", (chunk: Buffer) => { + console.log("ctr data", chunk.length); + c.destroy(new Error("stop")); + }); + c.on("error", (e: Error) => console.log("ctr error:", e.message)); + c.on("close", () => { + console.log("ctr close, destroyed:", c.destroyed); + resolve(); + }); + c.write("0123456789"); + c.write("abcdef"); + }); +} + +async function backpressure(): Promise { + const c = crypto.createCipheriv("aes-256-ctr", key, iv); + let received = 0; + const slow = new Writable({ + highWaterMark: 1024, + write(chunk: Buffer, _enc: string, cb: () => void) { + received += chunk.length; + setImmediate(cb); + }, + }); + c.pipe(slow); + const block = Buffer.alloc(4096, 1); + let writes = 0; + let fullAt = -1; + while (writes < 64) { + writes++; + if (!c.write(block)) { + fullAt = writes; + break; + } + } + console.log("write returned false at", fullAt); + await new Promise((resolve) => c.once("drain", () => resolve())); + console.log("drained"); + await new Promise((resolve) => { + slow.on("finish", () => { + console.log("received", received); + resolve(); + }); + c.end(); + }); +} + +async function main(): Promise { + await badDecrypt(); + await gcmWithoutTag(); + await destroyMidway(); + await backpressure(); +} +main(); diff --git a/tests/corpus/7057-cipher-streams.mjs b/tests/corpus/7057-cipher-streams.mjs new file mode 100644 index 000000000..2173d29aa --- /dev/null +++ b/tests/corpus/7057-cipher-streams.mjs @@ -0,0 +1,85 @@ +// Cipheriv and Decipheriv streams from JavaScript: pipeline() and pipe() +// with cipher stages, a cipher passed through untyped helpers that call +// its stream members dynamically, and cipher stages that reach pipeline() +// through an untyped parameter. +import crypto from "node:crypto"; +import { pipeline, Readable, Writable } from "node:stream"; + +const key = Buffer.alloc(24, 1); +const iv = Buffer.alloc(16, 2); + +function attach(stream, label, log) { + stream.on("data", (chunk) => log.push(`${label} data ${chunk.length}`)); + stream.on("end", () => log.push(`${label} end`)); + stream.on("close", () => log.push(`${label} close`)); + return stream; +} + +function feed(stream, parts) { + for (const part of parts) stream.write(part); + stream.end(); +} + +function state(stream) { + return [stream.readable, stream.writable, stream.writableEnded, stream.destroyed, stream.readableLength].join(","); +} + +const log = []; +const cipher = attach(crypto.createCipheriv("aes-192-cbc", key, iv), "cipher", log); +const collected = []; +cipher.on("data", (chunk) => collected.push(chunk)); +cipher.on("end", () => { + console.log("state at end:", state(cipher)); + const sealed = Buffer.concat(collected); + const out = []; + pipeline( + Readable.from([sealed.subarray(0, 7), sealed.subarray(7)]), + crypto.createDecipheriv("aes-192-cbc", key, iv), + new Writable({ + write(chunk, enc, cb) { + out.push(chunk); + cb(); + }, + }), + (err) => { + console.log(log.join("\n")); + console.log("pipeline:", err ?? null, Buffer.concat(out).toString()); + const piped = Readable.from([sealed]).pipe(crypto.createDecipheriv("aes-192-cbc", key, iv)); + piped.setEncoding("utf8"); + let text = ""; + piped.on("data", (s) => (text += s)); + piped.on("end", () => { + console.log("pipe:", text); + throughHelper(sealed); + }); + }, + ); +}); + +// The stages arrive as untyped values. +function run(stages, done) { + const out = []; + pipeline( + stages[0], + stages[1], + new Writable({ + write(chunk, enc, cb) { + out.push(chunk); + cb(); + }, + }), + (err) => done(err, Buffer.concat(out)), + ); +} + +function throughHelper(sealed) { + run([Readable.from([sealed]), crypto.createDecipheriv("aes-192-cbc", key, iv)], (err, plain) => { + console.log("untyped stage:", err ?? null, plain.toString()); + run([Readable.from([sealed]), crypto.createDecipheriv("aes-192-cbc", Buffer.alloc(24, 9), iv)], (err2) => { + console.log("untyped stage, wrong key:", err2.code, err2.message); + }); + }); +} +console.log("state before:", state(cipher)); +feed(cipher, ["one ", "two ", "three"]); +console.log("state after end():", state(cipher)); diff --git a/tests/corpus/7058-pipeline-function-stages.mjs b/tests/corpus/7058-pipeline-function-stages.mjs new file mode 100644 index 000000000..f0a61e7c2 --- /dev/null +++ b/tests/corpus/7058-pipeline-function-stages.mjs @@ -0,0 +1,180 @@ +// pipeline() function stages from JavaScript: runs of async generator +// stages between streams, stages named by a function declaration and a +// const, sources that are arrays, strings, synchronous generators and +// generator functions (with the ticks Node's async-from-sync iteration +// takes), the string and Buffer methods of generator-fed chunks, and an +// error thrown in a stage after two streams. +import { pipeline, PassThrough, Transform, Writable } from "node:stream"; +import { pipeline as pipelinePromise } from "node:stream/promises"; +import zlib from "node:zlib"; + +function sink(into) { + return new Writable({ + write(chunk, enc, cb) { + into.push(chunk.toString()); + cb(); + }, + }); +} + +async function* upper(source) { + for await (const chunk of source) yield chunk.toString().toUpperCase(); +} + +const bracket = async function* (source) { + for await (const chunk of source) yield `[${chunk.trim().replaceAll("\n", "|")}]`; +}; + +function* letters() { + yield "a"; + yield "b"; + yield "c"; +} + +// Stages on both sides of two zlib streams, and a named stage. +{ + const out = []; + await pipelinePromise( + async function* () { + for (let i = 0; i < 3; i++) yield `line ${i}\n`; + }, + zlib.createGzip(), + zlib.createGunzip(), + upper, + bracket, + sink(out), + ); + console.log("split runs:", out.join("")); +} + +// Iterable sources, and the destination value that reaches the callback. +await new Promise((resolve) => { + pipeline( + ["x", "y", "z"], + zlib.createDeflate(), + zlib.createInflate(), + async function (source) { + let text = ""; + for await (const chunk of source) text += chunk; + return text; + }, + (err, value) => { + console.log("array source:", err ?? null, value); + resolve(); + }, + ); +}); +{ + const out = []; + await pipelinePromise("str", upper, sink(out)); + console.log("string source:", out.join(",")); + out.length = 0; + await pipelinePromise(letters, upper, sink(out)); + console.log("generator function source:", out.join(",")); + out.length = 0; + await pipelinePromise(letters(), new PassThrough(), sink(out)); + console.log("generator source:", out.join(",")); +} + +// Generator-fed chunks keep their string and Buffer methods. +{ + const out = []; + await pipelinePromise( + async function* () { + yield Buffer.from("buf"); + yield Buffer.from("fers"); + }, + async function* (source) { + for await (const chunk of source) yield chunk.toString("hex"); + }, + async function* (source) { + for await (const chunk of source) yield chunk.padStart(10, "-"); + }, + sink(out), + ); + console.log("chunk methods:", out.join(" ")); +} + +// The ticks of iterable sources match Node's for-await over them. +function ticker(log) { + let on = true; + (async () => { + for (let i = 0; on && i < 12; i++) { + log.push(`t${i}`); + await null; + } + })(); + return () => { + on = false; + }; +} +{ + const log = []; + const stop = ticker(log); + await new Promise((resolve) => + pipeline(["a", "b"], new PassThrough(), sink(log), () => { + stop(); + resolve(); + }), + ); + console.log("array ticks:", log.join(" ")); +} +{ + const log = []; + const stop = ticker(log); + await new Promise((resolve) => + pipeline( + letters, + async function* (source) { + for await (const chunk of source) { + log.push(`stage ${chunk}`); + yield chunk; + } + }, + sink(log), + () => { + stop(); + resolve(); + }, + ), + ); + console.log("generator function ticks:", log.join(" ")); +} + +// An error thrown in a stage after two streams destroys both with it. +{ + const log = []; + const first = new PassThrough(); + const second = new Transform({ + transform(chunk, enc, cb) { + cb(null, chunk.toString().toUpperCase()); + }, + }); + first.on("close", () => log.push("first close")); + second.on("close", () => log.push("second close")); + second.on("error", (e) => log.push(`second error ${e.name}`)); + await new Promise((resolve) => { + pipeline( + async function* () { + yield "one\n"; + yield "two\n"; + }, + first, + second, + async function* (source) { + for await (const chunk of source) { + log.push(`stage got ${JSON.stringify(chunk)}`); + if (chunk.length > 100) yield chunk; + throw new Error("stage failed"); + } + }, + sink([]), + (err) => { + log.push(`callback ${err.message}`); + setImmediate(resolve); + }, + ); + }); + console.log(log.join("\n")); + console.log("destroyed:", first.destroyed, second.destroyed); +} diff --git a/tests/corpus/7059-transform-backpressure.ts b/tests/corpus/7059-transform-backpressure.ts new file mode 100644 index 000000000..d19a41eb8 --- /dev/null +++ b/tests/corpus/7059-transform-backpressure.ts @@ -0,0 +1,90 @@ +// Transform write backpressure and typed pipeline stages. A Transform +// holds a write's callback while its readable side is at the high-water +// mark, so write() returns false once both buffers fill and 'drain' comes +// after the reader catches up. Typed stages: named async generator +// functions on both sides of zlib streams, an array source, and an async +// function destination whose value resolves the promise pipeline. +import { PassThrough, Transform, Writable } from "node:stream"; +import { pipeline } from "node:stream/promises"; +import * as zlib from "node:zlib"; + +class Copy extends Transform { + override _transform(chunk: Buffer, _enc: BufferEncoding, cb: (err?: Error | null) => void): void { + this.push(chunk); + cb(); + } +} + +async function measure(label: string, t: Transform): Promise { + let received = 0; + const slow = new Writable({ + highWaterMark: 1024, + write(chunk: Buffer, _enc: string, cb: () => void) { + received += chunk.length; + setImmediate(cb); + }, + }); + t.pipe(slow); + const block = Buffer.alloc(4096, 120); + let falseAt = -1; + for (let i = 1; i <= 64; i++) { + if (!t.write(block)) { + falseAt = i; + break; + } + } + console.log(label, "write() false at", falseAt, t.writableLength, t.readableLength); + await new Promise((resolve) => t.once("drain", () => resolve())); + console.log(label, "drained", t.writableLength); + await new Promise((resolve) => { + slow.on("finish", () => resolve()); + t.end(); + }); + console.log(label, "received", received); +} + +async function* numbered(): AsyncGenerator { + for (let i = 0; i < 4; i++) yield `row ${i}\n`; +} + +async function* shout(source: AsyncIterable): AsyncGenerator { + for await (const chunk of source) yield chunk.toString().toUpperCase(); +} + +async function count(source: AsyncIterable): Promise { + let n = 0; + for await (const chunk of source) n += chunk.split("\n").length - 1; + return n; +} + +async function main(): Promise { + await measure("passthrough", new PassThrough()); + await measure("subclass", new Copy()); + await measure( + "options", + new Transform({ + transform(chunk: Buffer, _enc: string, cb: (err?: Error | null, data?: Buffer) => void) { + cb(null, chunk); + }, + }), + ); + + const out: string[] = []; + await pipeline( + numbered, + zlib.createGzip(), + zlib.createGunzip(), + shout, + new Writable({ + write(chunk: Buffer, _enc: string, cb: () => void) { + out.push(chunk.toString()); + cb(); + }, + }), + ); + console.log("named stages:", JSON.stringify(out.join(""))); + + const rows = await pipeline(["a\n", "b\n", "c\n"], zlib.createGzip(), zlib.createGunzip(), shout, count); + console.log("array source, rows:", rows); +} +main(); diff --git a/tests/harness/corpus-costs/7055-cipher-streams.ts.json b/tests/harness/corpus-costs/7055-cipher-streams.ts.json new file mode 100644 index 000000000..7dda3fe10 --- /dev/null +++ b/tests/harness/corpus-costs/7055-cipher-streams.ts.json @@ -0,0 +1 @@ +{ "plain": 4395, "san": 6600 } diff --git a/tests/harness/corpus-costs/7056-cipher-stream-errors.ts.json b/tests/harness/corpus-costs/7056-cipher-stream-errors.ts.json new file mode 100644 index 000000000..b3e89de2a --- /dev/null +++ b/tests/harness/corpus-costs/7056-cipher-stream-errors.ts.json @@ -0,0 +1 @@ +{ "plain": 2558, "san": 4456 } diff --git a/tests/harness/corpus-costs/7057-cipher-streams.mjs.json b/tests/harness/corpus-costs/7057-cipher-streams.mjs.json new file mode 100644 index 000000000..1edb6e866 --- /dev/null +++ b/tests/harness/corpus-costs/7057-cipher-streams.mjs.json @@ -0,0 +1 @@ +{ "plain": 2780, "san": 5329 } diff --git a/tests/harness/corpus-costs/7058-pipeline-function-stages.mjs.json b/tests/harness/corpus-costs/7058-pipeline-function-stages.mjs.json new file mode 100644 index 000000000..d4709c5d6 --- /dev/null +++ b/tests/harness/corpus-costs/7058-pipeline-function-stages.mjs.json @@ -0,0 +1 @@ +{ "plain": 3703, "san": 7279 } diff --git a/tests/harness/corpus-costs/7059-transform-backpressure.ts.json b/tests/harness/corpus-costs/7059-transform-backpressure.ts.json new file mode 100644 index 000000000..cc34bea0e --- /dev/null +++ b/tests/harness/corpus-costs/7059-transform-backpressure.ts.json @@ -0,0 +1 @@ +{ "plain": 2394, "san": 5656 } diff --git a/tests/harness/self-hosting-native-toolchain.test.ts b/tests/harness/self-hosting-native-toolchain.test.ts index 7da7626b7..c01b52595 100644 --- a/tests/harness/self-hosting-native-toolchain.test.ts +++ b/tests/harness/self-hosting-native-toolchain.test.ts @@ -105,7 +105,7 @@ for (const backend of ["llvm"] as const) { object_format: target.objectFormat, minimum_os: target.minimumOs, }, - runtime_abi: { version: 24, marker: "scr_runtime_abi_v24" }, + runtime_abi: { version: 25, marker: "scr_runtime_abi_v25" }, compiler: { command: "fixture", identity: "fixture", target: target.llvmTriple }, macros: { executable: [], excluded: [], sanitizer: "external-toolchain-required" }, flavors: { From e7e943a1d3ffd4a8e44fc40ffcd19b217ba8ad4c Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 02:00:06 -0500 Subject: [PATCH 029/102] Accept only nested scans that highestCount walks pass by pass The first pass of guardedLoopCounterFacts accepted a nested while loop anywhere outside an opaque region, and highestCount then left counters unbounded where it does not walk such a loop. The first pass now accepts the same loops highestCount walks: statements of the body, its blocks and its branches. A loop in a labeled block or among an expression's statements is an ordinary loop region, whose counter writes are refused. --- packages/compiler/src/ir/integer-loop-facts.ts | 18 +++++++++++++++--- 1 file changed, 15 insertions(+), 3 deletions(-) diff --git a/packages/compiler/src/ir/integer-loop-facts.ts b/packages/compiler/src/ir/integer-loop-facts.ts index 31edc2f48..8807212dc 100644 --- a/packages/compiler/src/ir/integer-loop-facts.ts +++ b/packages/compiler/src/ir/integer-loop-facts.ts @@ -276,16 +276,26 @@ export function guardedLoopCounterFacts( else budget.set(id, (budget.get(id) ?? 0) + delta); }; // Nested while loops outside opaque regions, checked against their own - // conditions once the stable bounds are known. + // conditions once the stable bounds are known. Only loops that highestCount + // walks pass by pass qualify: statements of the body, its blocks and its + // branches. One in a labeled block or among an expression's statements + // (`indirect`) is an ordinary loop region. const nested: (IrStmt & { kind: "while" })[] = []; + let indirect = 0; const expr = (e: IrExpr): boolean => { if (e.kind === "assignExpr") write(e.localId, increment(e.localId, e.value)); if (e.kind === "incDec") write(e.localId, e.op === "+" ? 1 : null); - return everyExprChild(e, expr, stmt); + return everyExprChild(e, expr, (x) => { + indirect++; + const completed = stmt(x); + indirect--; + return completed; + }); }; const condition = new Set(); const stmt = (s: IrStmt): boolean => { - const bounded = s.kind === "while" && opaque === 0 && !s.labels?.length; + const bounded = s.kind === "while" && opaque === 0 && indirect === 0 && !s.labels?.length; + const labeled = s.kind === "block" && !!s.labels?.length; const region = !bounded && (s.kind === "for" || @@ -299,10 +309,12 @@ export function guardedLoopCounterFacts( conditionWrites(s.cond); } if (region) opaque++; + if (labeled) indirect++; if (s.kind === "assign") write(s.localId, increment(s.localId, s.value)); if (s.kind === "varDecl" || s.kind === "forOf") write(s.localId, null); if (s.kind === "tryCatch" && s.catchLocalId) write(s.catchLocalId, null); const completed = everyStmtChild(s, expr, stmt); + if (labeled) indirect--; if (region) opaque--; return completed; }; From 2fbfc1b270d2a48485464ceeb50ac75b28d514c5 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 02:00:30 -0500 Subject: [PATCH 030/102] Keep each build's translation unit private until the build ends The kept LLVM text and IR are named after the entry (`.ll`, `.ir.json`) in the output directory, so two programs whose entries share a name and are built into one directory share those files. The executable cache published the translation unit by copying the shared `.ll` after the native build, so when the other program wrote it in between, the stamp recorded the other program's text, and a later cache hit relinked the wrong program without any error. A build now writes, compiles and caches private copies beside the shared names and renames them into place when it ends. A cache hit that relinks compiles a private copy of the cached translation unit, and leaves a shared file that already holds those bytes as it is. The native build reads the private copy and keeps the shared name as the spelling clang sees, so native cache keys and debug names do not change. --- .../compiler/src/backend/native/contracts.ts | 4 + .../compiler/src/backend/native/executable.ts | 15 +- .../src/executable/executable-cache.test.ts | 11 +- .../src/executable/executable-cache.ts | 48 ++++- packages/compiler/src/index.ts | 176 ++++++++++++------ .../executable-cache-shared-output.test.ts | 102 ++++++++++ 6 files changed, 289 insertions(+), 67 deletions(-) create mode 100644 tests/harness/executable-cache-shared-output.test.ts diff --git a/packages/compiler/src/backend/native/contracts.ts b/packages/compiler/src/backend/native/contracts.ts index 06a41c9b2..36f804fb2 100644 --- a/packages/compiler/src/backend/native/contracts.ts +++ b/packages/compiler/src/backend/native/contracts.ts @@ -6,6 +6,10 @@ export interface CcOptions { * LLVM backend's .ll — clang compiles IR text natively on the same * command line, so both ride this one seat. */ cPath: string; + /** Where the program TU's bytes are read from, when that is not `cPath`: an invocation-private + * copy that a concurrent build of another program cannot replace. `cPath` stays the spelling + * clang sees (`__FILE__`, debug file names) and the one cache keys name. */ + cSourcePath?: string; /** Path of the native executable to produce. */ outPath: string; /** Additional identity for a translation unit whose complete non-system diff --git a/packages/compiler/src/backend/native/executable.ts b/packages/compiler/src/backend/native/executable.ts index a551ad600..9dab1c783 100644 --- a/packages/compiler/src/backend/native/executable.ts +++ b/packages/compiler/src/backend/native/executable.ts @@ -481,7 +481,7 @@ export async function compileCInternal( const [compiler, runtimeHash, programBytes] = await Promise.all([ resolvedTool(driver.argv[0] ?? "clang"), runtimeFingerprint(rtDir), - readFile(opts.cPath), + readFile(opts.cSourcePath ?? opts.cPath), ]); if (compiler !== null) { const effectiveCompiler = @@ -861,7 +861,12 @@ export async function compileCInternal( ); try { await materializeVendorPrerequisites(undefined, privateVendorRoot); - await buildExecutable((p) => p); + await buildExecutable( + (p) => p, + opts.cSourcePath === undefined + ? {} + : { programPath: opts.cSourcePath, compilerVisibleSource: opts.cPath }, + ); } finally { await rm(privateVendorRoot, { recursive: true, force: true }).catch(() => undefined); } @@ -896,7 +901,9 @@ export async function compileCInternal( localArtifact === null ? runtimeFingerprint(rtDir) : Promise.resolve(localArtifact.runtimeHash), - localArtifact === null ? readFile(opts.cPath) : Promise.resolve(localArtifact.programBytes), + localArtifact === null + ? readFile(opts.cSourcePath ?? opts.cPath) + : Promise.resolve(localArtifact.programBytes), ]); compileMetadataStamp = compileMetadataKey === null @@ -965,7 +972,7 @@ export async function compileCInternal( Promise.all([ ccVersion(driver.argv, toolchainEnv, true), runtimeFingerprint(rtDir), - readFile(opts.cPath), + readFile(opts.cSourcePath ?? opts.cPath), ])); } catch (error) { // A version/fingerprint probe is an optimization boundary. If the compiler diff --git a/packages/compiler/src/executable/executable-cache.test.ts b/packages/compiler/src/executable/executable-cache.test.ts index 94b136c90..e7c57d1b0 100644 --- a/packages/compiler/src/executable/executable-cache.test.ts +++ b/packages/compiler/src/executable/executable-cache.test.ts @@ -133,8 +133,15 @@ test("early executable cache restores the emitted TU, IR, and native feature gat const hit = await readEarlyExecutableCache(f.root, f.options); expect(hit?.native).toEqual(native); expect(hit?.executableRestored).toBe(false); - expect(await readFile(f.llvmPath, "utf8")).toBe("; generated llvm\n"); - expect(await readFile(f.irPath, "utf8")).toContain("irVersion"); + // The build compiles private copies beside the shared names and installs + // them there when it is done. + expect(hit?.llvmPath).toBe(f.llvmPath); + expect(hit?.irPath).toBe(f.irPath); + expect(hit?.llvmSourcePath).toMatch(/[/\\]\.scriptc-llvm-/); + expect(hit?.irSourcePath).toMatch(/[/\\]\.scriptc-ir-/); + expect(await readFile(hit!.llvmSourcePath!, "utf8")).toBe("; generated llvm\n"); + expect(await readFile(hit!.irSourcePath!, "utf8")).toContain("irVersion"); + await expect(stat(f.llvmPath)).rejects.toThrow(); expect(await readFile(alternateC, "utf8")).toBe("/* user-owned native source */\n"); }); diff --git a/packages/compiler/src/executable/executable-cache.ts b/packages/compiler/src/executable/executable-cache.ts index 2312f5e85..941a7acdc 100644 --- a/packages/compiler/src/executable/executable-cache.ts +++ b/packages/compiler/src/executable/executable-cache.ts @@ -18,6 +18,7 @@ import { compilerReleaseVersion } from "../library/sidecar.js"; import { nativeArtifactDependenciesStillMatch } from "../backend/native/artifact-stamps.js"; import { type NativeArtifactDependency } from "../backend/native/contracts.js"; import { optimizationKeyParts } from "../backend/optimization.js"; +import { privateSiblingPath } from "../backend/build-cache.js"; import type { CompilerImplementationDependency } from "../library/compiler-self-identity.js"; import { installDarwinDebugSymbols, @@ -179,6 +180,15 @@ interface EarlyExecutableImplementationProof { export interface EarlyExecutableCacheHit { llvmPath: string; irPath?: string; + /** When the executable was not restored: private copies of the cached LLVM text and IR beside + * llvmPath and irPath, which the build compiles from and installs at those names when it is done + * (index.ts BuildSources). A restored executable needs no compile, and its files are installed at + * llvmPath and irPath. */ + llvmSourcePath?: string; + irSourcePath?: string; + /** llvmPath (irPath) already holds the cached bytes: the build leaves it as it is. */ + llvmPathCurrent?: true; + irPathCurrent?: true; /** True when the final executable was restored after native dependencies * validated. False restores only frontend artifacts and must call compileC. */ executableRestored: boolean; @@ -575,15 +585,6 @@ async function readExecutableCache( (await nativeArtifactDependenciesStillMatch(stamp.nativeDependencies)); if (validateRoute !== undefined && !executableRestored) return null; const paths = outputPaths(options, stamp.native.backend); - if (!(await fileMatches(paths.llvmPath, stamp.files.translationUnit.digest))) { - await installBytes(translationUnit, paths.llvmPath); - } - if ( - ir !== null && - stamp.files.ir !== null && - !(await fileMatches(paths.irPath, stamp.files.ir.digest)) - ) - await installBytes(ir, paths.irPath); if (executableRestored) { try { if (debugSymbols !== null) await installDarwinDebugSymbols(debugSymbols, options.outPath); @@ -598,6 +599,31 @@ async function readExecutableCache( executableRestored = false; } } + // A build that compiles from the cached translation unit compiles its own copy: a concurrent + // build of another program with the same entry name may replace the shared names meanwhile. + let llvmSourcePath: string | undefined; + let irSourcePath: string | undefined; + let llvmPathCurrent = false; + let irPathCurrent = false; + if (executableRestored) { + if (!(await fileMatches(paths.llvmPath, stamp.files.translationUnit.digest))) + await installBytes(translationUnit, paths.llvmPath); + if ( + ir !== null && + stamp.files.ir !== null && + !(await fileMatches(paths.irPath, stamp.files.ir.digest)) + ) + await installBytes(ir, paths.irPath); + } else { + llvmSourcePath = privateSiblingPath(paths.llvmPath, "llvm"); + await installBytes(translationUnit, llvmSourcePath); + llvmPathCurrent = await fileMatches(paths.llvmPath, stamp.files.translationUnit.digest); + if (ir !== null && stamp.files.ir !== null) { + irSourcePath = privateSiblingPath(paths.irPath, "ir"); + await installBytes(ir, irSourcePath); + irPathCurrent = await fileMatches(paths.irPath, stamp.files.ir.digest); + } + } const now = new Date(); await Promise.all( [ @@ -619,6 +645,10 @@ async function readExecutableCache( ? { performance: stamp.performance } : {}), ...(ir === null ? {} : { irPath: paths.irPath }), + ...(llvmSourcePath === undefined ? {} : { llvmSourcePath }), + ...(irSourcePath === undefined ? {} : { irSourcePath }), + ...(llvmPathCurrent ? { llvmPathCurrent: true as const } : {}), + ...(irPathCurrent ? { irPathCurrent: true as const } : {}), }; } catch { return null; diff --git a/packages/compiler/src/index.ts b/packages/compiler/src/index.ts index 2b216c77d..db1b0b3e3 100644 --- a/packages/compiler/src/index.ts +++ b/packages/compiler/src/index.ts @@ -524,6 +524,9 @@ async function compileExecutableNative( onArtifactReady?: NonNullable[0]["onArtifactReady"]>, programPartitions: readonly string[] = [], profileGenerate = false, + /** The kept LLVM text's shared name, when `llvmPath` is the build's private copy of it + * (BuildSources): the spelling clang sees and native cache keys name. */ + llvmVisiblePath?: string, ): Promise { const programIsObject = /\.(?:o|obj)$/.test(llvmPath); const runtimePackTarget = programIsObject && !sanitize ? nativeCodegenTarget() : null; @@ -563,7 +566,9 @@ async function compileExecutableNative( if (programIsObject) throw new InternalCompilerError("program objects must link against a precompiled runtime pack"); await compileExternalC({ - cPath: llvmPath, + ...(llvmVisiblePath === undefined || llvmVisiblePath === llvmPath + ? { cPath: llvmPath } + : { cPath: llvmVisiblePath, cSourcePath: llvmPath }), outPath, cacheIdentity: "scriptc-generated-v1", ...optimizationField(features.optimization), @@ -729,8 +734,12 @@ function runtimePackDiagnostic(error: RuntimePackError, entryPath: string): ScrD interface PreparedExecutable { llvmSource: LlvmInput; + /** The kept LLVM text beside the executable, installed when the build ends. */ llvmPath: string; + /** This build's private copy of the LLVM text (BuildSources). */ + llvmSourcePath: string; irPath: string | undefined; + irSourcePath: string | undefined; nativeFeatures: EarlyExecutableNativeFeatures; programSplit: ReturnType; sourceTexts: Map; @@ -841,6 +850,7 @@ async function prepareExecutableInput( await mkdir(opts.outDir, { recursive: true }); const llvmPath = defaultSourcePaths.llvm; + const llvmSourcePath = privateSiblingPath(llvmPath, "llvm"); const backend = "llvm" as const; const useRuntimePack = opts.nativeProgramObject === true || usesPrecompiledRuntimePack(opts, backend); @@ -863,12 +873,14 @@ async function prepareExecutableInput( return { ok: false, diagnostics: [llvmRefusalDiag(err, entryPath)], sourceTexts }; } timing("llvm-emit"); - await writeLlvmSource(llvmPath, llvmSource); + await writeLlvmSource(llvmSourcePath, llvmSource); timing("llvm-write"); let irPath: string | undefined; + let irSourcePath: string | undefined; if (opts.emitIr) { irPath = defaultSourcePaths.ir; - await writeTextParts(irPath, serializeModuleParts(mod)); + irSourcePath = privateSiblingPath(irPath, "ir"); + await writeTextParts(irSourcePath, serializeModuleParts(mod)); } const nativeFeatures = executableNativeFeatures(mod, backend, opts.optimization ?? "release"); @@ -882,7 +894,51 @@ async function prepareExecutableInput( ? splitLlvmProgram(llvmSource) : null; timing("llvm-split"); - return { llvmSource, llvmPath, irPath, nativeFeatures, programSplit, sourceTexts }; + return { + llvmSource, + llvmPath, + llvmSourcePath, + irPath, + irSourcePath, + nativeFeatures, + programSplit, + sourceTexts, + }; +} + +/** + * The kept LLVM text (`.ll`) and IR (`.ir.json`) sit beside the executable, + * so programs whose entries share a name and are built into one output directory share them. Each + * build therefore writes, compiles and caches private copies (privateSiblingPath) and moves them to + * the shared names only when it is done (rename replaces a file in one step): a concurrent build of + * another program cannot replace the text a build compiles or the translation unit it caches. + */ +interface BuildSources { + llvmPath: string; + llvmSourcePath: string; + irPath?: string | undefined; + irSourcePath?: string | undefined; + /** The shared name already holds the private copy's bytes (a cache hit's restored files): it is + * left as it is, with its time stamps. */ + llvmPathCurrent?: boolean | undefined; + irPathCurrent?: boolean | undefined; +} + +/** Moves a build's private copies to the shared names, or drops them when that fails. */ +async function installBuildSources(sources: BuildSources): Promise { + const install = async ( + source: string | undefined, + destination: string | undefined, + current: boolean | undefined, + ) => { + if (source === undefined || destination === undefined || source === destination) return; + if (current === true) await rm(source, { force: true }); + else await rename(source, destination).catch(() => rm(source, { force: true })); + }; + await Promise.all([ + install(sources.llvmSourcePath, sources.llvmPath, sources.llvmPathCurrent), + install(sources.irSourcePath, sources.irPath, sources.irPathCurrent), + ]); } /** @@ -976,10 +1032,11 @@ type FrontendProcessResult = | { kind: "prepared"; llvmPath: string; - /** A private copy of the LLVM text, which the native helper reads (`nativeInputPath`). */ + /** The build's private copy of the LLVM text (BuildSources), which the native helper reads. */ nativeInputPath: string; llvmBytes: number; irPath: string | undefined; + irSourcePath: string | undefined; nativeFeatures: EarlyExecutableNativeFeatures; sourceTexts: [string, string][]; warnings: ScrDiagnostic[]; @@ -1047,7 +1104,9 @@ async function prepareExecutableInputInChild( return { llvmSource: { file: result.nativeInputPath, bytes: result.llvmBytes }, llvmPath: result.llvmPath, + llvmSourcePath: result.nativeInputPath, irPath: result.irPath, + irSourcePath: result.irSourcePath, nativeFeatures: result.nativeFeatures, programSplit: null, sourceTexts, @@ -1085,18 +1144,15 @@ export async function runFrontendProcess(requestPath: string, resultPath: string ); const frontend = frontendInputs.snapshot(); if (!("ok" in prepared)) { - // The public .ll file may be rewritten by a concurrent build of another entry with the - // same output stem before the native helper reads it (see emitNativeArtifact). if (isLlvmFile(prepared.llvmSource)) throw new InternalCompilerError("in-process preparation returned LLVM text as a file"); - const nativeInputPath = privateSiblingPath(prepared.llvmPath, "frontend-llvm"); - await writeLlvmSource(nativeInputPath, prepared.llvmSource, 0o600); result = { kind: "prepared", llvmPath: prepared.llvmPath, - nativeInputPath, + nativeInputPath: prepared.llvmSourcePath, llvmBytes: llvmInputBytes(prepared.llvmSource), irPath: prepared.irPath, + irSourcePath: prepared.irSourcePath, nativeFeatures: prepared.nativeFeatures, sourceTexts: [...prepared.sourceTexts], warnings: warnings.warnings, @@ -1450,37 +1506,46 @@ async function compileTracked( ...(earlyHit.irPath === undefined ? {} : { irPath: earlyHit.irPath }), }; } - let nativeInputPath = earlyHit.llvmPath; + // The build's private copies of the cached LLVM text and IR (BuildSources). + const hitSources: BuildSources = { + llvmPath: earlyHit.llvmPath, + llvmSourcePath: earlyHit.llvmSourcePath ?? earlyHit.llvmPath, + irPath: earlyHit.irPath, + irSourcePath: earlyHit.irSourcePath, + llvmPathCurrent: earlyHit.llvmPathCurrent, + irPathCurrent: earlyHit.irPathCurrent, + }; + let nativeInputPath = hitSources.llvmSourcePath; let nativeProgramObject: NativeProgramObject | null = null; const useRuntimePack = opts.nativeProgramObject === true || usesPrecompiledRuntimePack(opts, earlyHit.native.backend); - if (useRuntimePack) { - if (earlyHit.native.backend !== "llvm") { - throw new InternalCompilerError( - "native program-object cache hit restored a non-LLVM translation unit", - ); - } - try { - nativeProgramObject = await emitNativeProgramObject( - entryPath, - opts, - // A large program's LLVM exceeds the engine's string limit as one - // string; the emitter takes it in parts, as on a cold build. - await readTextParts(earlyHit.llvmPath), - profile, - ); - nativeInputPath = nativeProgramObject.linkPath; - } catch (err) { - if (!(err instanceof NativeCodegenError)) throw err; - return { - ok: false, - diagnostics: [nativeCodegenDiag(err.diagnosticCode, err.message, entryPath)], - sourceTexts: new Map(), - }; - } - } try { + if (useRuntimePack) { + if (earlyHit.native.backend !== "llvm") { + throw new InternalCompilerError( + "native program-object cache hit restored a non-LLVM translation unit", + ); + } + try { + nativeProgramObject = await emitNativeProgramObject( + entryPath, + opts, + // A large program's LLVM exceeds the engine's string limit as one + // string; the emitter takes it in parts, as on a cold build. + await readTextParts(hitSources.llvmSourcePath), + profile, + ); + nativeInputPath = nativeProgramObject.linkPath; + } catch (err) { + if (!(err instanceof NativeCodegenError)) throw err; + return { + ok: false, + diagnostics: [nativeCodegenDiag(err.diagnosticCode, err.message, entryPath)], + sourceTexts: new Map(), + }; + } + } await compileExecutableNative( earlyHit.native, nativeInputPath, @@ -1496,6 +1561,10 @@ async function compileTracked( : async ({ dependencies }) => { await publishEarlyExecutableCache(cacheRoot, executableCacheOptions, { ...earlyHit, + llvmPath: hitSources.llvmSourcePath, + ...(hitSources.irSourcePath === undefined + ? {} + : { irPath: hitSources.irSourcePath }), executableRestored: true, nativeDependencies: dependencies, frontend: earlyHit.frontend, @@ -1503,6 +1572,7 @@ async function compileTracked( }, nativeProgramObject?.partitionPaths, profile?.generate !== undefined, + hitSources.llvmPath, ); if (nativeProgramObject !== null && opts.nativeProgramObject === true) { await rename(nativeProgramObject.linkPath, nativeProgramObject.artifactPath); @@ -1532,6 +1602,7 @@ async function compileTracked( nativeProgramObject.partitionPaths, ); } + await installBuildSources(hitSources); } await pruneBuildCache(cacheRoot); return { @@ -1564,7 +1635,8 @@ async function compileTracked( ) : await prepareExecutableInput(entryPath, opts, ffi, buildPlatform, timing, warningSink); if ("ok" in prepared) return prepared; - const { llvmSource, llvmPath, irPath, nativeFeatures, programSplit, sourceTexts } = prepared; + const { llvmSource, llvmPath, llvmSourcePath, irPath, irSourcePath } = prepared; + const { nativeFeatures, programSplit, sourceTexts } = prepared; const backend = "llvm" as const; await mkdir(dirname(opts.outPath), { recursive: true }); if (earlyCacheOptions === null) { @@ -1599,7 +1671,7 @@ async function compileTracked( } await compileExecutableNative( nativeFeatures, - nativeProgramObject?.linkPath ?? llvmPath, + nativeProgramObject?.linkPath ?? llvmSourcePath, opts.outPath, opts.sanitize ?? false, ffi, @@ -1611,23 +1683,34 @@ async function compileTracked( ? undefined : async ({ dependencies }) => { await publishEarlyExecutableCache(cacheRoot, executableCacheOptions, { - llvmPath, + llvmPath: llvmSourcePath, native: nativeFeatures, executableRestored: true, nativeDependencies: dependencies, frontend: frontendInputs.snapshot(), - ...(irPath === undefined ? {} : { irPath }), + ...(irSourcePath === undefined ? {} : { irPath: irSourcePath }), ...performanceWarnings(warningSink), }); publishedExecutable = true; }, nativeProgramObject?.partitionPaths, profile?.generate !== undefined, + llvmPath, ); timing("native-link"); if (nativeProgramObject !== null && opts.nativeProgramObject === true) { await rename(nativeProgramObject.linkPath, nativeProgramObject.artifactPath); } + if (!publishedExecutable) { + await publishEarlyExecutableCache(cacheRoot, executableCacheOptions, { + llvmPath: llvmSourcePath, + native: nativeFeatures, + executableRestored: false, + frontend: frontendInputs.snapshot(), + ...(irSourcePath === undefined ? {} : { irPath: irSourcePath }), + ...performanceWarnings(warningSink), + }).catch(() => undefined); + } } catch (err) { if (err instanceof RuntimePackError) { return { ok: false, diagnostics: [runtimePackDiagnostic(err, entryPath)], sourceTexts }; @@ -1649,18 +1732,7 @@ async function compileTracked( nativeProgramObject.partitionPaths, ); } - // The frontend process's private copy of the LLVM text. - if (isLlvmFile(llvmSource)) await rm(llvmSource.file, { force: true }); - } - if (!publishedExecutable) { - await publishEarlyExecutableCache(cacheRoot, executableCacheOptions, { - llvmPath, - native: nativeFeatures, - executableRestored: false, - frontend: frontendInputs.snapshot(), - ...(irPath === undefined ? {} : { irPath }), - ...performanceWarnings(warningSink), - }).catch(() => undefined); + await installBuildSources({ llvmPath, llvmSourcePath, irPath, irSourcePath }); } await pruneBuildCache(cacheRoot); timing("complete"); diff --git a/tests/harness/executable-cache-shared-output.test.ts b/tests/harness/executable-cache-shared-output.test.ts new file mode 100644 index 000000000..bf9e7353c --- /dev/null +++ b/tests/harness/executable-cache-shared-output.test.ts @@ -0,0 +1,102 @@ +/* Two programs whose entries share a name (main.ts) built into one output + * directory share the kept `main.ll` beside their executables. Each build + * must still compile, link and cache its own translation unit: a later + * build that restores either program from the executable cache, or relinks + * it from the cached translation unit, gets that program back. + * + * The overlap is made deterministic with a linker wrapper that rewrites the + * kept `main.ll` with the other program's text while the first build links, + * which is what a concurrent build of the other program does when it writes + * its kept LLVM in that window. A caller-selected linker never publishes the + * final executable, so every cache hit relinks from the cached translation + * unit. Both builds also run concurrently. */ +import { execFile, execFileSync } from "node:child_process"; +import { chmodSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { promisify } from "node:util"; +import { afterAll, beforeAll, describe, expect, test } from "vitest"; + +const execFileAsync = promisify(execFile); +const repoRoot = join(import.meta.dirname, "../.."); +const cli = join(repoRoot, "packages/cli/dist/main.js"); +const windows = process.platform === "win32"; + +let directory = ""; + +beforeAll(() => { + directory = mkdtempSync(join(windows ? tmpdir() : "/tmp", "scriptc-shared-output-")); + for (const name of ["first", "second"]) { + mkdirSync(join(directory, name)); + writeFileSync(join(directory, name, "main.ts"), `console.log("${name} program");\n`); + } + mkdirSync(join(directory, "out")); +}); + +afterAll(() => { + if (directory !== "") rmSync(directory, { recursive: true, force: true }); +}); + +function outPath(name: string): string { + return join(directory, "out", name + (windows ? ".exe" : "")); +} + +async function build(name: string, env: NodeJS.ProcessEnv = {}): Promise { + await execFileAsync( + process.execPath, + [cli, "build", join(directory, name, "main.ts"), "-o", outPath(name)], + { + cwd: repoRoot, + env: { ...process.env, SCRIPTC_CACHE_DIR: join(directory, "cache"), ...env }, + maxBuffer: 1 << 24, + }, + ); +} + +function run(name: string): string { + return execFileSync(outPath(name), { encoding: "utf8" }); +} + +describe.skipIf(windows)("executables built into one output directory", () => { + test( + "keep their own translation units when their builds overlap", + { timeout: 600_000 }, + async () => { + const keptLlvm = join(directory, "out", "main.ll"); + // The second program's kept LLVM, for the wrapper to write while the + // first program links. + await build("second"); + const secondLlvm = join(directory, "second.ll"); + writeFileSync(secondLlvm, readFileSync(keptLlvm)); + const linker = join(directory, "linker.sh"); + writeFileSync( + linker, + [ + "#!/bin/sh", + `if [ -n "$SCRIPTC_TEST_OVERLAP" ]; then cp "${secondLlvm}" "${keptLlvm}"; fi`, + 'exec clang "$@"', + "", + ].join("\n"), + ); + chmodSync(linker, 0o755); + + await build("first", { SCRIPTC_LINKER: linker, SCRIPTC_TEST_OVERLAP: "1" }); + expect(run("first")).toBe("first program\n"); + expect(readFileSync(keptLlvm, "utf8")).toContain("first program"); + // A cache hit relinks from the translation unit the build cached. + rmSync(outPath("first")); + await build("first", { SCRIPTC_LINKER: linker }); + expect(run("first")).toBe("first program\n"); + expect(readFileSync(keptLlvm, "utf8")).toContain("first program"); + + // Both programs at once, cold and then from the cache. + for (const round of [0, 1]) { + if (round === 1) for (const name of ["first", "second"]) rmSync(outPath(name)); + const env = { SCRIPTC_CACHE_DIR: join(directory, "cache-both"), SCRIPTC_LINKER: linker }; + await Promise.all([build("first", env), build("second", env)]); + expect(run("first")).toBe("first program\n"); + expect(run("second")).toBe("second program\n"); + } + }, + ); +}); From 491480e1ad3990c5d6f834e6afbd910420a34ee3 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 02:09:43 -0500 Subject: [PATCH 031/102] Convert clamped stores inline and test thread-owned views once in typed-array loops A Uint8ClampedArray store called scr_bytes_to_u8_clamp for every element, which kept loops of clamped stores scalar. The store now computes ToUint8Clamp in line: NaN and values at most 0 store 0, values at least 255 store 255, and values between round through (v + 2^52) - 2^52, which rounds a value in (0, 255) to the nearest integer, ties to even, as the runtime function does. In worker-enabled programs, every typed-array element access tests the view's shared storage and branches between a relaxed atomic access and the ordinary one, so loops over thread-owned views kept one branch per access. A view's shared storage is fixed at construction, like its length, so the typed-array loop version guard now tests it once for each invariant receiver, and the fast copy reads and writes those views directly. In worker programs a loop is versioned for this even when no bound needs a guard. When any receiver is shared, the checked copy runs unchanged. Programs without workers emit the same code as before. Adds a Uint8ClampedArray brighten kernel to the typed-array-kernels workload. --- benchmarks/runtime/README.md | 2 +- .../runtime/workloads/typed-array-kernels.ts | 12 +++ .../backend/llvm/bytes-loop-versions.test.ts | 31 ++++++++ .../src/backend/llvm/bytes-loop-versions.ts | 46 ++++++++++- .../src/backend/llvm/emit-function.ts | 1 + .../src/backend/llvm/emit-statements.ts | 5 ++ packages/compiler/src/backend/llvm/emitter.ts | 11 ++- .../compiler/src/backend/llvm/expr-bytes.ts | 52 ++++++++++--- .../test/bytes-element-emission.test.ts | 42 ++++++++++ .../6994-uint8-clamped-store-rounding.ts.json | 6 ++ ...5-worker-typed-array-loop-versions.ts.json | 6 ++ .../6994-uint8-clamped-store-rounding.ts | 77 +++++++++++++++++++ .../6995-worker-typed-array-loop-versions.ts | 74 ++++++++++++++++++ .../6994-uint8-clamped-store-rounding.ts.json | 1 + ...5-worker-typed-array-loop-versions.ts.json | 1 + 15 files changed, 348 insertions(+), 19 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6994-uint8-clamped-store-rounding.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6995-worker-typed-array-loop-versions.ts.json create mode 100644 tests/corpus/6994-uint8-clamped-store-rounding.ts create mode 100644 tests/corpus/6995-worker-typed-array-loop-versions.ts create mode 100644 tests/harness/corpus-costs/6994-uint8-clamped-store-rounding.ts.json create mode 100644 tests/harness/corpus-costs/6995-worker-typed-array-loop-versions.ts.json diff --git a/benchmarks/runtime/README.md b/benchmarks/runtime/README.md index 1acdc9ce7..cbf47675a 100644 --- a/benchmarks/runtime/README.md +++ b/benchmarks/runtime/README.md @@ -26,7 +26,7 @@ Application-shaped workloads for measuring the speed of compiled executables. Ea | `region-builds` | cpu | a watch-mode build loop over `LifetimeRegion`: each build binds a program in a new region and releases the previous one, which a cache keeps referenced for two builds | | `template-render` | cpu | template literals, escaping, `map`/`join` | | `thread-slots`, `thread-slots-cache` | cpu | worker threads reading one published type graph from an `InternTable` and keeping per-thread state for each type they visit: a `ThreadSlots` family, or a direct-mapped cache by id in front of a `Map` by id (the `-cache` entry); under Node.js both are per thread | -| `typed-array-kernels` | cpu | element-wise loops that run to one typed array's length and index others at the same position: `Float64Array` axpy, `Float32Array` blend, `Uint8Array` mask, wrapping `Int32Array` add, RGBA to gray | +| `typed-array-kernels` | cpu | element-wise loops that run to one typed array's length and index others at the same position: `Float64Array` axpy, `Float32Array` blend, `Uint8Array` mask, wrapping `Int32Array` add, `Uint8ClampedArray` brighten, RGBA to gray | | `typed-array-scan`, `typed-array-scan-workers` | cpu | element-by-element scan loops over `Uint8Array`, `Uint16Array`, `Int32Array` and `Float64Array`; the second entry is a worker-enabled executable (it can start a worker), so each access also checks for shared storage | | `unicode-lexer` | cpu | a hand-written lexer over a 2.7M-unit bundled module whose comments and strings are in several languages: `charCodeAt` scans, line starts | | `validate-errors` | cpu | throw/catch on a fraction of inputs, small call chains | diff --git a/benchmarks/runtime/workloads/typed-array-kernels.ts b/benchmarks/runtime/workloads/typed-array-kernels.ts index 87c227bbc..ba68f7241 100644 --- a/benchmarks/runtime/workloads/typed-array-kernels.ts +++ b/benchmarks/runtime/workloads/typed-array-kernels.ts @@ -17,6 +17,10 @@ function addWrap(a: Int32Array, b: Int32Array, out: Int32Array): void { for (let i = 0; i < out.length; i++) out[i] = (a[i]! + b[i]!) | 0; } +function brighten(src: Uint8ClampedArray, gain: number, out: Uint8ClampedArray): void { + for (let i = 0; i < out.length; i++) out[i] = src[i]! * gain + 8; +} + function gray(rgba: Uint8Array, out: Uint8Array): void { for (let i = 0; i < out.length; i++) { const j = i * 4; @@ -38,6 +42,8 @@ const masked = new Uint8Array(n); const ia = new Int32Array(n); const ib = new Int32Array(n); const io = new Int32Array(n); +const pixels = new Uint8ClampedArray(n); +const bright = new Uint8ClampedArray(n); const rgba = new Uint8Array(n * 4); const luma = new Uint8Array(n); let state = 2463534242; @@ -56,6 +62,7 @@ for (let i = 0; i < n; i++) { key[i] = next() & 255; ia[i] = next() | 0; ib[i] = next() | 0; + pixels[i] = next() & 255; } for (let i = 0; i < rgba.length; i++) rgba[i] = next() & 255; @@ -64,6 +71,7 @@ let f64Sum = 0; let f32Sum = 0; let byteSum = 0; let intSum = 0; +let brightSum = 0; let lumaSum = 0; for (let r = 0; r < rounds; r++) { // Change one input element per round so no round repeats the last. @@ -72,21 +80,25 @@ for (let r = 0; r < rounds; r++) { fa[at] = r; data[at] = r & 255; ia[at] = r * 65537; + pixels[at] = r & 255; rgba[at * 4] = r & 255; axpy(1.5, x, y, d); blend((r & 15) / 16, fa, fb, fo); mask(data, key, masked); addWrap(ia, ib, io); + brighten(pixels, 0.75 + (r & 7) / 8, bright); gray(rgba, luma); const probe = (r * 104729) & (n - 1); f64Sum += d[probe]!; f32Sum += fo[probe]!; byteSum += masked[probe]!; intSum = (intSum + io[probe]!) | 0; + brightSum += bright[probe]!; lumaSum += luma[probe]!; } console.log(`float64 ${f64Sum.toFixed(3)}`); console.log(`float32 ${f32Sum.toFixed(3)}`); console.log(`uint8 ${byteSum}`); console.log(`int32 ${intSum}`); +console.log(`clamped ${brightSum}`); console.log(`gray ${lumaSum}`); diff --git a/packages/compiler/src/backend/llvm/bytes-loop-versions.test.ts b/packages/compiler/src/backend/llvm/bytes-loop-versions.test.ts index ea568bc3f..3fbc01cc5 100644 --- a/packages/compiler/src/backend/llvm/bytes-loop-versions.test.ts +++ b/packages/compiler/src/backend/llvm/bytes-loop-versions.test.ts @@ -109,6 +109,8 @@ function match( ranges, initialized: findInitializedByteLoopBindings(f).get(loop) ?? new Set(), proven: new Set(), + workers: false, + owned: new Set(), }); } @@ -250,6 +252,35 @@ test("loops to a typed array's length version the other typed arrays they index" expect(rebound).toContain("bytes.index.invalid"); }); +test("worker programs test each receiver's shared storage once in the guard", () => { + // for (let i = 0; i < n; i++) out[i] = src[i] * 2, where either view may + // be shared. + const loop = counted([ + set(ref("out", f64s), ref("i"), bin("*", get(ref("src", f64s), ref("i")), num(2))), + ]); + const kernel = fn([loop]); + const mod: IrModule = { + irVersion: 17, + sourceFile: loc.file, + entry: "__main", + workers: true, + 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.match(/icmp eq ptr %\S+, null/g)).toHaveLength(2); + const fast = /^bytes\.version\.fast\d+:$[^]*?^bytes\.version\.done\d+:$/m.exec(body)![0]; + expect(fast).not.toContain("bytes.shared"); + expect(fast).not.toMatch(/(load|store) atomic double/); + // The checked copy keeps the shared-memory path for each access. + const slow = body.slice(body.search(/^bytes\.version\.slow\d+:$/m), body.indexOf(fast)); + expect(slow).toContain("load atomic double"); + expect(slow).toContain("store atomic double"); +}); + test("Float16Array accesses version in elements and share the element tag", () => { const f16s: IrType = { kind: "bytes", elem: "f16" }; const withHalves = (body: IrStmt[]): IrFunction => { diff --git a/packages/compiler/src/backend/llvm/bytes-loop-versions.ts b/packages/compiler/src/backend/llvm/bytes-loop-versions.ts index df8977426..dcb735e61 100644 --- a/packages/compiler/src/backend/llvm/bytes-loop-versions.ts +++ b/packages/compiler/src/backend/llvm/bytes-loop-versions.ts @@ -6,7 +6,7 @@ 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 { emitBytesHeaderLength } from "./expr-bytes.js"; +import { emitBytesHeaderLength, emitBytesSharedStorage } from "./expr-bytes.js"; type Node = IrExpr | IrStmt; type VarRef = IrExpr & { kind: "varRef" }; @@ -41,8 +41,13 @@ interface AffineCheck { export interface BytesLoopVersion { /** Typed-array accesses that are in bounds whenever the guard holds. */ bounds: ReadonlySet; + /** Worker programs: typed-array accesses whose views the guard proves + * thread-owned (no shared storage). */ + owned: ReadonlySet; /** Root receiver bindings, read once before the loop. */ receivers: { ref: VarRef; global: boolean }[]; + /** Receivers the guard requires to have no shared storage. */ + ownedReceivers: number[]; fixed: FixedCheck[]; affine: AffineCheck[]; /** The counted loop whose iteration space the affine checks cover. */ @@ -66,6 +71,11 @@ export interface BytesLoopFacts { initialized: ReadonlySet; /** Accesses already proved in bounds without a guard. */ proven: ReadonlySet; + /** Worker programs: an access of a view that may be shared tests the + * view's shared storage first. */ + workers: boolean; + /** Accesses already proved thread-owned by an enclosing version. */ + owned: ReadonlySet; } const MAX_COST = 400; @@ -87,6 +97,11 @@ const INVARIANT_OPS = new Set(["+", "-", "*", "&", "|", "^", "<<", ">>", ">>>"]) * and last values in bounds, such as `out[base + i]` for `i < n` or * `view.getUint32(i * 4)`. * + * In worker programs, every access of a view that may be shared tests its + * shared storage. A view's storage is also fixed at construction, so the + * same guard tests each invariant receiver once, and the fast copy reads + * and writes thread-owned views directly. + * * Only small synchronous loops are versioned (nested loops included), and * the emitter bounds how deeply versions nest. The checked loop runs * whenever the guard fails, and keeps every out-of-bounds read, ignored @@ -314,10 +329,19 @@ export function matchBytesLoopVersion( } return index; }; + // Worker programs: accesses through invariant receivers, proven or not, + // become thread-owned when the guard finds no shared storage. + const owned = new Map(); const access = (node: Node, array: IrExpr, index: IrExpr, width: number): void => { - if (facts.proven.has(node)) return; const ref = root(array); if (!ref) return; + if (facts.workers && !facts.owned.has(node)) { + const receiver = receiverOf(ref); + const nodes = owned.get(receiver); + if (nodes) nodes.push(node); + else owned.set(receiver, [node]); + } + if (facts.proven.has(node)) return; const shape = counter !== null ? affine(index) : null; if (shape && shape.counter !== 0) { const operands = new Set(); @@ -383,9 +407,15 @@ export function matchBytesLoopVersion( }); const fixedKept = [...fixed.values()].slice(0, MAX_CHECKS); const affineKept = affineGroups.slice(0, MAX_CHECKS - fixedKept.length); - if (fixedKept.length === 0 && affineKept.length === 0) return null; + const ownedKept = [...owned.entries()].slice(0, MAX_CHECKS); + if (fixedKept.length === 0 && affineKept.length === 0 && ownedKept.length === 0) return null; const bounds = new Set(); + const ownedNodes = new Set(); const used = new Set(); + for (const [receiver, nodes] of ownedKept) { + used.add(receiver); + for (const node of nodes) ownedNodes.add(node); + } const ranges = new Map(); const counterLow = Math.max(counted?.range.min ?? 0, -bound), counterHigh = Math.min(counted?.range.max ?? 0, bound); @@ -420,7 +450,9 @@ export function matchBytesLoopVersion( (counted.range.min < -bound || counted.range.max > bound); return { bounds, + owned: ownedNodes, receivers: order.map((index) => receivers[index]!), + ownedReceivers: ownedKept.map(([receiver]) => renumber.get(receiver)!), fixed: fixedKept.map((g) => ({ receiver: renumber.get(g.check.receiver)!, end: g.check.end, @@ -439,7 +471,8 @@ export function matchBytesLoopVersion( } /** Branches to `fast` when every access the version proves is in bounds for - * every iteration, and to `slow` otherwise (including a counted loop whose + * every iteration and every view it proves thread-owned has no shared + * storage, and to `slow` otherwise (including a counted loop whose * integer form is not established, or a module receiver not yet set). */ export function emitBytesLoopVersionGuard( host: LlvmEmitterContext, @@ -473,6 +506,11 @@ export function emitBytesLoopVersionGuard( return wide; }); const conditions: string[] = []; + for (const index of version.ownedReceivers) { + const owned = B.tmp(); + B.line(`${owned} = icmp eq ptr ${emitBytesSharedStorage(host, receivers[index]!)}, null`); + conditions.push(owned); + } for (const check of version.fixed) { const ok = B.tmp(); B.line(`${ok} = icmp ugt i64 ${lengths[check.receiver]}, ${check.end}`); diff --git a/packages/compiler/src/backend/llvm/emit-function.ts b/packages/compiler/src/backend/llvm/emit-function.ts index d83b9ff64..5053c1b54 100644 --- a/packages/compiler/src/backend/llvm/emit-function.ts +++ b/packages/compiler/src/backend/llvm/emit-function.ts @@ -228,6 +228,7 @@ export function emitFunction(emitter: LlEmitter, fn: IrFunction): string { emitter.integerLoopRanges = rangeFacts.loopRanges; emitter.int32Elements = slotFacts.elements ?? null; emitter.bytesBounds = findBytesBounds(numericFn, emitter.integerRanges); + emitter.bytesOwned = new Set(); // Debug builds keep every number local a double for the debugger's // variable view. Lazily boxed captured parameters keep their double, // which the box is created from, and so do plain copies of a capture or diff --git a/packages/compiler/src/backend/llvm/emit-statements.ts b/packages/compiler/src/backend/llvm/emit-statements.ts index 433029651..d2e96994b 100644 --- a/packages/compiler/src/backend/llvm/emit-statements.ts +++ b/packages/compiler/src/backend/llvm/emit-statements.ts @@ -517,6 +517,7 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { s.index, s.value, emitter.bytesBounds.has(s), + emitter.bytesOwned.has(s), ); break; } @@ -970,6 +971,7 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { done = B.newLabel("bytes.version.done"); emitBytesLoopVersionGuard(emitter, version, fast, slow); const originalBounds = emitter.bytesBounds, + originalOwned = emitter.bytesOwned, originalRanges = emitter.integerRanges; emitter.bytesLoopVersioning.add(s); try { @@ -978,6 +980,8 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { B.br(done); B.startBlock(fast); emitter.bytesBounds = new Set([...originalBounds, ...version.bounds]); + 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) emitter.provenCountedGuards.add(s); @@ -985,6 +989,7 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { B.br(done); } finally { emitter.bytesBounds = originalBounds; + emitter.bytesOwned = originalOwned; emitter.integerRanges = originalRanges; emitter.provenCountedGuards.delete(s); emitter.bytesLoopVersioning.delete(s); diff --git a/packages/compiler/src/backend/llvm/emitter.ts b/packages/compiler/src/backend/llvm/emitter.ts index 1f2be4439..c254d0907 100644 --- a/packages/compiler/src/backend/llvm/emitter.ts +++ b/packages/compiler/src/backend/llvm/emitter.ts @@ -1125,6 +1125,9 @@ export class LlEmitter { * guard already passed. */ readonly provenCountedGuards = new Set(); bytesBounds: ReadonlySet = new Set(); + /** Worker programs: typed-array accesses whose views an enclosing version + * guard proved thread-owned. */ + bytesOwned: ReadonlySet = new Set(); integerViews = new Map(); /** Module globals the current function owns outright (initializer * bindings): their function-local slot, which stands in for the global. */ @@ -3836,6 +3839,8 @@ export class LlEmitter { ranges: this.integerRanges, initialized, proven: this.bytesBounds, + workers: this.mod.workers === true, + owned: this.bytesOwned, }); } @@ -6196,8 +6201,9 @@ export class LlEmitter { expr?: IrExpr, inBounds = false, invalidNaN = false, + owned = false, ): LlValue { - return emitBytesGet(this, elem, receiver, index, expr, inBounds, invalidNaN); + return emitBytesGet(this, elem, receiver, index, expr, inBounds, invalidNaN, owned); } emitToUint32(value: string, expr?: IrExpr, uint32?: string): string { @@ -6260,8 +6266,9 @@ export class LlEmitter { indexExpr?: IrExpr, expr?: IrExpr, inBounds = false, + owned = false, ): void { - return emitBytesSet(this, elem, receiver, index, value, indexExpr, expr, inBounds); + return emitBytesSet(this, elem, receiver, index, value, indexExpr, expr, inBounds, owned); } emitBytesIntrinsic(e: IrExpr & { kind: "bytesIntrinsic" }): LlValue { diff --git a/packages/compiler/src/backend/llvm/expr-bytes.ts b/packages/compiler/src/backend/llvm/expr-bytes.ts index d36001bf6..062bfdfbe 100644 --- a/packages/compiler/src/backend/llvm/expr-bytes.ts +++ b/packages/compiler/src/backend/llvm/expr-bytes.ts @@ -176,6 +176,17 @@ export function emitBytesLength( return { name: out, type: F64 }; } +/** A view's shared backing (null for a buffer this thread owns). It is + * set at construction, before script code can see the view. */ +export function emitBytesSharedStorage(host: LlvmEmitterContext, receiver: string): string { + const B = host.B; + const slot = B.tmp(), + storage = B.tmp(); + B.line(`${slot} = getelementptr inbounds %ScrBytes, ptr ${receiver}, i64 0, i32 9`); + B.line(`${storage} = load ptr, ptr ${slot}${bytesHeaderAlias(host)}`); + return storage; +} + /** Worker programs: an element of a view of a SharedArrayBuffer (`shared` is * fixed before script code can see the view) is read and written with one * relaxed atomic access of its width, as the runtime's shared accessors do; @@ -186,12 +197,9 @@ export function emitBytesLength( function emitSharedBytesSplit(host: LlvmEmitterContext, receiver: string): string { const B = host.B; host.declare(`declare i1 @llvm.expect.i1(i1, i1)`); - const slot = B.tmp(), - storage = B.tmp(), + const storage = emitBytesSharedStorage(host, receiver), isShared = B.tmp(), expected = B.tmp(); - B.line(`${slot} = getelementptr inbounds %ScrBytes, ptr ${receiver}, i64 0, i32 9`); - B.line(`${storage} = load ptr, ptr ${slot}${bytesHeaderAlias(host)}`); B.line(`${isShared} = icmp ne ptr ${storage}, null`); B.line(`${expected} = call i1 @llvm.expect.i1(i1 ${isShared}, i1 false)`); const shared = B.newLabel("bytes.shared"), @@ -209,15 +217,17 @@ export function emitBytesGet( expr?: IrExpr, inBounds = false, invalidNaN = false, + owned = false, ): LlValue { const B = host.B; // Any invalid index traps (the array runtime's discipline). - if (!invalidNaN) return emitBytesLoad(host, elem, receiver, index, expr, inBounds, undefined); + if (!invalidNaN) + return emitBytesLoad(host, elem, receiver, index, expr, inBounds, undefined, owned); // The numeric view of an ordinary read: an invalid index never touches // storage and reads as NaN — ToNumber of Node's undefined. const invalid = B.newLabel("bytes.read.invalid"); const done = B.newLabel("bytes.read.done"); - const loaded = emitBytesLoad(host, elem, receiver, index, expr, inBounds, invalid); + const loaded = emitBytesLoad(host, elem, receiver, index, expr, inBounds, invalid, owned); const ok = B.newLabel("bytes.read.ok"); B.br(ok); B.startBlock(ok); @@ -260,8 +270,10 @@ function emitBytesLoad( expr: IrExpr | undefined, inBounds: boolean, invalid: string | undefined, + owned: boolean, ): LlValue { - if (host.mod.workers) { + // `owned`: an enclosing version guard proved the view thread-owned. + if (host.mod.workers && !owned) { const idx = emitBytesIndex(host, receiver, index, expr, invalid, inBounds); return emitSharedOrLocalLoad(host, elem, receiver, idx); } @@ -515,13 +527,14 @@ export function emitBytesSet( indexExpr?: IrExpr, expr?: IrExpr, inBounds = false, + owned = false, ): void { const B = host.B; // Invalid integer-indexed writes are ignored after evaluating the RHS. const done = B.newLabel("bytes.store.done"); const data = host.emitBytesData(receiver); const idx = emitBytesIndex(host, receiver, index, indexExpr, done, inBounds); - if (host.mod.workers && elem === "f16") { + if (host.mod.workers && !owned && elem === "f16") { host.declare(`declare void @scr_bytes_shared_set(ptr, ${host.sizeType}, double)`); const local = emitSharedBytesSplit(host, receiver); B.line( @@ -532,10 +545,24 @@ export function emitBytesSet( } let stored: string | null; if (elem === "u8c") { - host.declare(`declare double @scr_bytes_to_u8_clamp(double)`); - const clamped = B.tmp(); + // ToUint8Clamp, as scr_bytes_to_u8_clamp computes it: NaN and values + // at most 0 store 0, values at least 255 store 255, and values between + // round to the nearest integer, ties to even. Adding and subtracting + // 2^52 rounds a value in (0, 255) that way in the default rounding mode, + // with no call or branch, so loops of clamped stores can vectorize. + const positive = B.tmp(), + high = B.tmp(), + shifted = B.tmp(), + rounded = B.tmp(), + upper = B.tmp(), + clamped = B.tmp(); stored = B.tmp(); - B.line(`${clamped} = call double @scr_bytes_to_u8_clamp(double ${value.name})`); + B.line(`${positive} = fcmp ogt double ${value.name}, 0.0`); + B.line(`${high} = fcmp oge double ${value.name}, 255.0`); + B.line(`${shifted} = fadd double ${value.name}, 0x4330000000000000`); + B.line(`${rounded} = fsub double ${shifted}, 0x4330000000000000`); + B.line(`${upper} = select i1 ${high}, double 255.0, double ${rounded}`); + B.line(`${clamped} = select i1 ${positive}, double ${upper}, double 0.0`); B.line(`${stored} = fptoui double ${clamped} to i32`); } else stored = @@ -572,7 +599,7 @@ export function emitBytesSet( ty = "i32"; operand = stored!; } - if (host.mod.workers) { + if (host.mod.workers && !owned) { // A shared view's element takes a relaxed atomic store of its width. const local = emitSharedBytesSplit(host, receiver); const p = B.tmp(); @@ -721,6 +748,7 @@ export function emitBytesIntrinsic( e.args[0], host.bytesBounds.has(e), e.invalidNaN === true, + host.bytesOwned.has(e), ); case "slice": return call( diff --git a/packages/compiler/test/bytes-element-emission.test.ts b/packages/compiler/test/bytes-element-emission.test.ts index 505b51963..c0a78a898 100644 --- a/packages/compiler/test/bytes-element-emission.test.ts +++ b/packages/compiler/test/bytes-element-emission.test.ts @@ -406,3 +406,45 @@ test("large record clones stay outlined while small clones remain inlineable", ( expect(large).toContain("define internal ptr @sc_rclone_large(ptr %src) #2"); expect(large).toContain("attributes #2 = { noinline sanitize_address }"); }); + +test("Uint8ClampedArray stores clamp and round without a runtime call", () => { + const type = bytesOf("u8c"); + const mod: IrModule = { + irVersion: 17, + sourceFile: loc.file, + entry: "__main", + functions: [ + { name: "__main", params: [], returnType: VOID, locals: [], body: [], loc }, + { + name: "store", + params: [ + { localId: "px", name: "px", type }, + { localId: "v", name: "v", type: F64 }, + ], + returnType: VOID, + locals: [ + { id: "px", name: "px", type, mutable: false }, + { id: "v", name: "v", type: F64, mutable: false }, + ], + body: [ + { + kind: "bytesSet", + arr: { kind: "varRef", localId: "px", type, loc }, + index: { kind: "numLit", value: 0, type: F64, loc }, + value: { kind: "varRef", localId: "v", type: F64, loc }, + loc, + }, + ], + loc, + }, + ], + }; + expect(validateModule(mod)).toEqual([]); + const body = /^define internal [^\n]*@sc_bf_store[^]*?^}/m.exec(emitLlvmModule(mod))![0]; + expect(body).not.toContain("scr_bytes_to_u8_clamp"); + expect(body).toMatch(/fcmp ogt double %\S+, 0\.0/); + expect(body).toMatch(/fcmp oge double %\S+, 255\.0/); + expect(body).toMatch(/fadd double %\S+, 0x4330000000000000/); + expect(body).toMatch(/fsub double %\S+, 0x4330000000000000/); + expect(body).toMatch(/store i8 [^\n]*, align 1/); +}); diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6994-uint8-clamped-store-rounding.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6994-uint8-clamped-store-rounding.ts.json new file mode 100644 index 000000000..f5a6b8742 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6994-uint8-clamped-store-rounding.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6994-uint8-clamped-store-rounding.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6995-worker-typed-array-loop-versions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6995-worker-typed-array-loop-versions.ts.json new file mode 100644 index 000000000..8078248f5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6995-worker-typed-array-loop-versions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6995-worker-typed-array-loop-versions.ts" + ], + "diags": [] +} diff --git a/tests/corpus/6994-uint8-clamped-store-rounding.ts b/tests/corpus/6994-uint8-clamped-store-rounding.ts new file mode 100644 index 000000000..5fc3295da --- /dev/null +++ b/tests/corpus/6994-uint8-clamped-store-rounding.ts @@ -0,0 +1,77 @@ +// Uint8ClampedArray stores: NaN and values at most 0 store 0, values at +// least 255 store 255, and values between round to the nearest integer, +// ties to even. Covers single stores and loops, every tie between 0 and +// 255 with the doubles on either side of it, and values far outside. + +/** The largest power of two at most `x` (x > 0). */ +function floorPower(x: number): number { + let p = 1; + while (p * 2 <= x) p *= 2; + while (p > x) p /= 2; + return p; +} + +/** The doubles just above and below `x` (x >= 0). */ +function nextUp(x: number): number { + return x === 0 ? 5e-324 : x + floorPower(x) * 2 ** -52; +} + +function nextDown(x: number): number { + if (x === 0) return -5e-324; + const p = floorPower(x); + return x - (p === x ? p * 2 ** -53 : p * 2 ** -52); +} + +function storeAll(values: Float64Array, out: Uint8ClampedArray): void { + const n = out.length; + for (let i = 0; i < n; i++) out[i] = values[i]!; +} + +function scale(px: Uint8ClampedArray, k: number): void { + const n = px.length; + for (let i = 0; i < n; i++) px[i] = px[i]! * k; +} + +const special = [ + NaN, -NaN, Infinity, -Infinity, 0, -0, 5e-324, -5e-324, 2.2250738585072014e-308, 0.49999999999999994, + 0.5, 0.5000000000000001, 1, 1.5, 2.5, 3.5, 127.5, 128.5, 253.5, 254.49999999999997, 254.5, + 254.50000000000003, 254.99999999999997, 255, 255.00000000000003, 255.5, 256, -1, -0.5, -0.4, + 1e300, -1e300, 2 ** 31, 2 ** 32 + 0.5, 2 ** 52, 2 ** 52 + 1, 2 ** 53, -(2 ** 52), +]; +const one = new Uint8ClampedArray(1); +const singles: number[] = []; +for (const v of special) { + one[0] = v; + singles.push(one[0]!); +} +console.log("single", singles.join(",")); + +const ties: number[] = []; +for (let k = 0; k <= 255; k++) { + ties.push(k + 0.5, nextDown(k + 0.5), nextUp(k + 0.5), k, nextDown(k), nextUp(k)); +} +const values = new Float64Array(ties.length + special.length); +values.set(ties); +values.set(special, ties.length); +const stored = new Uint8ClampedArray(values.length); +storeAll(values, stored); +const expected = new Uint8ClampedArray(values.length); +for (let i = 0; i < values.length; i++) expected[i] = values[i]!; +let mismatches = 0; +for (let i = 0; i < values.length; i++) if (stored[i] !== expected[i]) mismatches++; +console.log("loop", values.length, "mismatches", mismatches); +let digest = 0; +for (let i = 0; i < stored.length; i++) digest = (Math.imul(digest, 31) + stored[i]!) | 0; +console.log("digest", digest, stored.subarray(0, 24).join(",")); +console.log("tail", stored.subarray(ties.length).join(",")); + +const px = new Uint8ClampedArray(64); +for (let i = 0; i < px.length; i++) px[i] = i * 4.25; +scale(px, 1.37); +console.log("scaled", px.join(",")); +scale(px, -1); +console.log("negated", px.join(",")); +const fromInts = new Uint8ClampedArray(8); +const ints = new Int32Array([-300, -1, 0, 1, 254, 255, 256, 2147483647]); +for (let i = 0; i < fromInts.length; i++) fromInts[i] = ints[i]!; +console.log("ints", fromInts.join(",")); diff --git a/tests/corpus/6995-worker-typed-array-loop-versions.ts b/tests/corpus/6995-worker-typed-array-loop-versions.ts new file mode 100644 index 000000000..5b85271b9 --- /dev/null +++ b/tests/corpus/6995-worker-typed-array-loop-versions.ts @@ -0,0 +1,74 @@ +import { Worker, isMainThread, parentPort, workerData } from "node:worker_threads"; + +// Typed-array loops in a worker-enabled program, over views of a thread's +// own ArrayBuffer, views of a SharedArrayBuffer, and both in one loop. Each +// loop gives the same results whichever kind of buffer its views use, and +// writes through shared views are visible to the other thread. + +function scale(src: Float64Array, dst: Float32Array, k: number): void { + for (let i = 0; i < dst.length; i++) dst[i] = src[i]! * k; +} + +function countAbove(view: Int16Array, limit: number): number { + let n = 0; + for (let i = 0; i < view.length; i++) if (view[i]! > limit) n++; + return n; +} + +function mix(a: Uint8Array, b: Uint8Array, out: Uint8ClampedArray): void { + const n = out.length; + for (let i = 0; i < n; i++) out[i] = a[i]! * 2 - b[i]!; +} + +function bump(view: Int32Array, by: number): void { + for (let i = 0; i < view.length; i++) view[i] = (view[i]! + by) | 0; +} + +function report(label: string, src: Float64Array, dst: Float32Array, ints: Int16Array, a: Uint8Array, b: Uint8Array, out: Uint8ClampedArray): string { + for (let i = 0; i < src.length; i++) src[i] = i * 1.5 - 4; + for (let i = 0; i < ints.length; i++) ints[i] = (i * 7919) % 2001 - 1000; + for (let i = 0; i < a.length; i++) { + a[i] = i * 37; + b[i] = 255 - i * 11; + } + scale(src, dst, 0.1); + mix(a, b, out); + return `${label}: ${dst.join(",")} | ${countAbove(ints, 250)} ${countAbove(ints.subarray(3), -1)} | ${out.join(",")}`; +} + +function views(buffer: ArrayBuffer | SharedArrayBuffer, other: ArrayBuffer | SharedArrayBuffer): string { + const src = new Float64Array(buffer, 0, 12); + const dst = new Float32Array(other, 0, 10); + const ints = new Int16Array(buffer, 96, 40); + const a = new Uint8Array(other, 40, 16); + const b = new Uint8Array(buffer, 176, 16); + const out = new Uint8ClampedArray(other, 56, 16); + return report("pair", src, dst, ints, a, b, out); +} + +if (isMainThread) { + // Bytes 224-255 of the shared buffer hold counters the views never use. + const shared = new SharedArrayBuffer(256); + console.log(views(new ArrayBuffer(256), new ArrayBuffer(256))); + console.log(views(shared, new ArrayBuffer(256))); + console.log(views(new ArrayBuffer(256), shared)); + console.log(views(shared, new SharedArrayBuffer(256))); + const own = new Int32Array(8); + bump(own, 5); + bump(new Int32Array(shared, 224, 8), 1); + const worker = new Worker(new URL(import.meta.url), { workerData: shared }); + worker.on("message", (line: string) => console.log(line)); + worker.on("exit", (code: number) => { + const seen = new Int32Array(shared, 224, 8); + bump(seen, 1000); + console.log(`exit ${code}: ${seen.join(",")} own ${own.join(",")}`); + console.log(`dst after worker: ${new Float32Array(shared, 0, 10).join(",")}`); + }); +} else { + const shared = workerData as SharedArrayBuffer; + const counters = new Int32Array(shared, 224, 8); + bump(counters, 10); + bump(counters.subarray(2, 5), -3); + parentPort!.postMessage(`worker: ${counters.join(",")}`); + parentPort!.postMessage(views(new ArrayBuffer(256), shared)); +} diff --git a/tests/harness/corpus-costs/6994-uint8-clamped-store-rounding.ts.json b/tests/harness/corpus-costs/6994-uint8-clamped-store-rounding.ts.json new file mode 100644 index 000000000..a52f2c454 --- /dev/null +++ b/tests/harness/corpus-costs/6994-uint8-clamped-store-rounding.ts.json @@ -0,0 +1 @@ +{ "plain": 2400, "san": 3300 } diff --git a/tests/harness/corpus-costs/6995-worker-typed-array-loop-versions.ts.json b/tests/harness/corpus-costs/6995-worker-typed-array-loop-versions.ts.json new file mode 100644 index 000000000..c0aef3bb7 --- /dev/null +++ b/tests/harness/corpus-costs/6995-worker-typed-array-loop-versions.ts.json @@ -0,0 +1 @@ +{ "plain": 2700, "san": 3900 } From 16cf12c20d66aa23a18308446871e7d55dc18d01 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 02:11:54 -0500 Subject: [PATCH 032/102] Run two-counter for loops on integer counters `for (let lo = a, hi = b; lo < hi; lo++, hi--)` kept both counters as doubles: the counted-loop match takes a single counter, so every `a[lo]`/`a[hi]` converted and tested its index. A loop whose two counters close in on each other by positive literal steps, are not written by the body and index something now stores both as i64: on every body entry both lie between the first start and the second. A start without a proven integer range is tested at run time on a versioned loop, as a counted loop's is. --- .../src/backend/llvm/counted-loops.ts | 81 ++++++++----- .../src/backend/llvm/emit-statements.ts | 58 ++++++++- .../compiler/src/ir/integer-loops.test.ts | 73 ++++++++++- packages/compiler/src/ir/integer-loops.ts | 114 ++++++++++++++++++ .../corpus/7140-paired-loop-counters.ts.json | 6 + tests/corpus/7140-paired-loop-counters.ts | 81 +++++++++++++ .../7140-paired-loop-counters.ts.json | 1 + 7 files changed, 377 insertions(+), 37 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7140-paired-loop-counters.ts.json create mode 100644 tests/corpus/7140-paired-loop-counters.ts create mode 100644 tests/harness/corpus-costs/7140-paired-loop-counters.ts.json diff --git a/packages/compiler/src/backend/llvm/counted-loops.ts b/packages/compiler/src/backend/llvm/counted-loops.ts index 36fc63e1f..02943b852 100644 --- a/packages/compiler/src/backend/llvm/counted-loops.ts +++ b/packages/compiler/src/backend/llvm/counted-loops.ts @@ -1,4 +1,5 @@ -import type { IntegerCountedForLoop } from "../../ir/integer-loops.js"; +import type { IntegerCountedForLoop, IntegerPairedForLoop } from "../../ir/integer-loops.js"; +import type { IrExpr } from "../../ir/ir.js"; import type { LlvmEmitterContext } from "./expr-context.js"; import { f64Lit } from "./common.js"; @@ -59,37 +60,51 @@ export function emitCountedLoopSafety( `${safe} = fcmp ${loop.step > 0 ? "ole" : "oge"} double ${bound.name}, ${f64Lit(loop.guardLimit)}`, ); } - if (loop.startGuarded) { - // An exact integer of at most 2^53 - 1 in magnitude, and not -0 - // (the bit patterns of the value and its round trip agree). - // NaN and infinities fail the ordered range tests. - const start = host.emitExpr(loop.start); - const low = B.tmp(), - high = B.tmp(), - raw = B.tmp(), - wide = B.tmp(), - back = B.tmp(), - bits = B.tmp(), - backBits = B.tmp(), - exact = B.tmp(), - inRange = B.tmp(), - ok = B.tmp(); - B.line(`${low} = fcmp oge double ${start.name}, ${f64Lit(-Number.MAX_SAFE_INTEGER)}`); - B.line(`${high} = fcmp ole double ${start.name}, ${f64Lit(Number.MAX_SAFE_INTEGER)}`); - B.line(`${inRange} = and i1 ${low}, ${high}`); - B.line(`${raw} = fptosi double ${start.name} to i64`); - B.line(`${wide} = freeze i64 ${raw}`); - B.line(`${back} = sitofp i64 ${wide} to double`); - B.line(`${bits} = bitcast double ${start.name} 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}`); - if (safe === "true") safe = ok; - else { - const both = B.tmp(); - B.line(`${both} = and i1 ${safe}, ${ok}`); - safe = both; - } - } + if (loop.startGuarded) safe = andSafe(host, safe, emitExactStart(host, loop.start)); return safe; } + +/** The run-time test of a guarded paired loop: each unproven start is an + * exact safe integer. */ +export function emitPairedLoopSafety(host: LlvmEmitterContext, loop: IntegerPairedForLoop): string { + let safe = "true"; + for (const counter of [loop.low, loop.high]) + if (counter.startGuarded) safe = andSafe(host, safe, emitExactStart(host, counter.start)); + return safe; +} + +function andSafe(host: LlvmEmitterContext, safe: string, ok: string): string { + if (safe === "true") return ok; + const both = host.B.tmp(); + host.B.line(`${both} = and i1 ${safe}, ${ok}`); + return both; +} + +/** An exact integer of at most 2^53 - 1 in magnitude, and not -0 (the bit + * patterns of the value and its round trip agree). NaN and infinities fail + * the ordered range tests. */ +function emitExactStart(host: LlvmEmitterContext, expr: IrExpr): string { + const B = host.B; + const start = host.emitExpr(expr); + const low = B.tmp(), + high = B.tmp(), + raw = B.tmp(), + wide = B.tmp(), + back = B.tmp(), + bits = B.tmp(), + backBits = B.tmp(), + exact = B.tmp(), + inRange = B.tmp(), + ok = B.tmp(); + B.line(`${low} = fcmp oge double ${start.name}, ${f64Lit(-Number.MAX_SAFE_INTEGER)}`); + B.line(`${high} = fcmp ole double ${start.name}, ${f64Lit(Number.MAX_SAFE_INTEGER)}`); + B.line(`${inRange} = and i1 ${low}, ${high}`); + B.line(`${raw} = fptosi double ${start.name} to i64`); + B.line(`${wide} = freeze i64 ${raw}`); + B.line(`${back} = sitofp i64 ${wide} to double`); + B.line(`${bits} = bitcast double ${start.name} 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; +} diff --git a/packages/compiler/src/backend/llvm/emit-statements.ts b/packages/compiler/src/backend/llvm/emit-statements.ts index 433029651..cf83fc945 100644 --- a/packages/compiler/src/backend/llvm/emit-statements.ts +++ b/packages/compiler/src/backend/llvm/emit-statements.ts @@ -42,10 +42,15 @@ import { matchIntegerArrayForLoop, matchIntegerBytesForLoop, matchIntegerCountedForLoop, + matchIntegerPairedForLoop, } from "../../ir/integer-loops.js"; import { emitByteWindowGuard, matchByteWindow } from "./byte-windows.js"; import { countedDenseShape, emitDenseLoopGuard, matchDenseArrayLoop } from "./dense-array-loops.js"; -import { emitCountedLoopLimit, emitCountedLoopSafety } from "./counted-loops.js"; +import { + emitCountedLoopLimit, + emitCountedLoopSafety, + emitPairedLoopSafety, +} from "./counted-loops.js"; import { emitBytesLoopVersionGuard } from "./bytes-loop-versions.js"; import { mangleLocal } from "../mangle.js"; import { LlvmUnsupportedError } from "./unsupported.js"; @@ -865,6 +870,12 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { emitter.unaliasedArrays, ) : null; + // Two counters closing in on each other (`lo++, hi--`) take the same + // integer storage as a counted loop's one. + const pairedLoop = + !integerLoop && !countedLoop && emitter.countedLoopsEnabled + ? matchIntegerPairedForLoop(s, emitter.numericLocals, emitter.integerRanges) + : null; const window = countedLoop && emitter.byteWindowsEnabled ? matchByteWindow( @@ -993,8 +1004,10 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { break; } let countedJoin: string | null = null; - if (countedLoop?.guarded && !emitter.provenCountedGuards.has(s)) { - const safe = emitCountedLoopSafety(emitter, countedLoop); + if ((countedLoop?.guarded && !emitter.provenCountedGuards.has(s)) || pairedLoop?.guarded) { + const safe = countedLoop + ? emitCountedLoopSafety(emitter, countedLoop) + : emitPairedLoopSafety(emitter, pairedLoop!); const fast = B.newLabel("counted.fast"); const slow = B.newLabel("counted.slow"); countedJoin = B.newLabel("counted.done"); @@ -1009,6 +1022,7 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { emitter.scopes.push([]); let integerSlot: string | null = null; let countedLimit: string | null = null; + const pairedSlots: string[] = []; if (integerLoop) { integerSlot = B.slot(); B.entryAllocas.push( @@ -1053,6 +1067,24 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { : countedLoop.range, }); countedLimit = emitCountedLoopLimit(emitter, countedLoop); + } else if (pairedLoop) { + for (const counter of [pairedLoop.low, pairedLoop.high]) { + const slot = B.slot(); + B.entryAllocas.push( + `${slot} = alloca i64 ; integer induction ${emitter.currentLocals.get(counter.localId)!.name}`, + ); + const value = emitter.emitExpr(counter.start); + const start = B.tmp(); + B.line(`${start} = fptosi double ${value.name} to i64`); + B.line(`store i64 ${start}, ptr ${slot}`); + pairedSlots.push(slot); + emitter.integerLoopBindings.set(counter.localId, { + slot, + type: "i64", + signed: true, + range: pairedLoop.range, + }); + } } else if (s.init) { // A multi-declarator head shares the loop's scope. Emitting its // IR block as an ordinary block would release captured/ref locals @@ -1134,6 +1166,14 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { `${inBounds} = icmp ${countedLoop.step > 0 ? "slt" : "sgt"} i64 ${index}, ${countedLimit}`, ); B.condBr(inBounds, lb, exit); + } else if (pairedLoop) { + const low = B.tmp(), + high = B.tmp(), + open = B.tmp(); + B.line(`${low} = load i64, ptr ${pairedSlots[0]}`); + B.line(`${high} = load i64, ptr ${pairedSlots[1]}`); + B.line(`${open} = icmp ${pairedLoop.inclusive ? "sle" : "slt"} i64 ${low}, ${high}`); + B.condBr(open, lb, exit); } else if (s.cond) B.condBr(emitter.emitCondition(s.cond), lb, exit); else B.br(lb); B.startBlock(lb); @@ -1165,6 +1205,14 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { B.line(`${old} = load i64, ptr ${integerSlot}`); B.line(`${next} = add nsw i64 ${old}, ${countedLoop.step}`); B.line(`store i64 ${next}, ptr ${integerSlot}`); + } else if (pairedLoop) { + [pairedLoop.low, pairedLoop.high].forEach((counter, i) => { + const old = B.tmp(); + const next = B.tmp(); + B.line(`${old} = load i64, ptr ${pairedSlots[i]}`); + B.line(`${next} = add nsw i64 ${old}, ${counter.step}`); + B.line(`store i64 ${next}, ptr ${pairedSlots[i]}`); + }); } else if (s.update) emitter.emitStmt(s.update); B.br(lc); } @@ -1173,6 +1221,10 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { emitter.releaseScope(emitter.scopes.pop()!); if (integerLoop) emitter.integerLoopBindings.delete(integerLoop.localId); if (countedLoop) emitter.integerLoopBindings.delete(countedLoop.localId); + if (pairedLoop) { + emitter.integerLoopBindings.delete(pairedLoop.low.localId); + emitter.integerLoopBindings.delete(pairedLoop.high.localId); + } if (integerArrayLoop) emitter.integerArrayBindings.delete(integerArrayLoop.localId); if (countedJoin) { B.br(countedJoin); diff --git a/packages/compiler/src/ir/integer-loops.test.ts b/packages/compiler/src/ir/integer-loops.test.ts index aada3b053..24bbf5be0 100644 --- a/packages/compiler/src/ir/integer-loops.test.ts +++ b/packages/compiler/src/ir/integer-loops.test.ts @@ -1,6 +1,10 @@ import { expect, test } from "vitest"; import { BOOL, F64, STRING, arrayOf, type IrExpr, type IrLocal, type IrStmt } from "./ir.js"; -import { matchIntegerArrayForLoop, matchIntegerCountedForLoop } from "./integer-loops.js"; +import { + matchIntegerArrayForLoop, + matchIntegerCountedForLoop, + matchIntegerPairedForLoop, +} from "./integer-loops.js"; const loc = { file: "integer-array-loop.ts", start: 0, end: 0 }; const number = (value: number): IrExpr => ({ kind: "numLit", value, type: F64, loc }); @@ -355,3 +359,70 @@ test("a descending loop from an array's last index takes an integer counter for range: { min: 0, max: 4294967294 }, }); }); + +test("paired counters closing in on each other run as integers", () => { + const vars = new Map(locals); + for (const id of ["lo", "hi", "head"]) vars.set(id, { id, name: id, type: F64, mutable: true }); + const step = (id: string, op: "+" | "-", value = 1): IrStmt => ({ + kind: "assign", + localId: id, + value: { kind: "bin", op, left: ref(id), right: number(value), type: F64, loc }, + loc, + }); + const element = (index: IrExpr): IrExpr => ({ + kind: "arrayGet", + arr: { kind: "varRef", localId: "a", type: arrayOf(F64), loc }, + index, + type: F64, + loc, + }); + const paired = ( + lowStart: IrExpr, + highStart: IrExpr, + update = [step("lo", "+"), step("hi", "-")], + ) => + ({ + kind: "for", + loc, + init: { + kind: "block", + body: [ + { kind: "varDecl", localId: "lo", init: lowStart, loc }, + { kind: "varDecl", localId: "hi", init: highStart, loc }, + ], + loc, + }, + cond: { kind: "bin", op: "<", left: ref("lo"), right: ref("hi"), type: BOOL, loc }, + update: { kind: "block", body: update, loc }, + body: [{ kind: "exprStmt", expr: element(ref("hi")), loc }], + }) as IrStmt & { kind: "for" }; + expect(matchIntegerPairedForLoop(paired(number(0), number(9)), vars)).toMatchObject({ + low: { localId: "lo", step: 1, startGuarded: false }, + high: { localId: "hi", step: -1, startGuarded: false }, + guarded: false, + range: { min: 0, max: 9 }, + }); + // A start without a known range is tested at run time. + expect(matchIntegerPairedForLoop(paired(number(0), ref("head")), vars)).toMatchObject({ + high: { startGuarded: true }, + guarded: true, + }); + // Counters moving the same way, written by the body, captured, started + // from each other, or never used as an index are refused. + expect( + matchIntegerPairedForLoop( + paired(number(0), number(9), [step("lo", "+"), step("hi", "+")]), + vars, + ), + ).toBeNull(); + const writing = paired(number(0), number(9)); + writing.body.push(step("hi", "-", 2)); + expect(matchIntegerPairedForLoop(writing, vars)).toBeNull(); + const boxed = new Map(vars); + boxed.set("hi", { ...vars.get("hi")!, boxed: true }); + expect(matchIntegerPairedForLoop(paired(number(0), number(9)), boxed)).toBeNull(); + expect(matchIntegerPairedForLoop(paired(number(0), ref("lo")), vars)).toBeNull(); + const unused = paired(number(0), number(9)); + unused.body = []; + expect(matchIntegerPairedForLoop(unused, vars)).toBeNull(); +}); diff --git a/packages/compiler/src/ir/integer-loops.ts b/packages/compiler/src/ir/integer-loops.ts index 9b4675685..e80680d6e 100644 --- a/packages/compiler/src/ir/integer-loops.ts +++ b/packages/compiler/src/ir/integer-loops.ts @@ -281,6 +281,120 @@ export function matchIntegerCountedForLoop( }; } +/** A for loop whose two counters close in on each other: + * + * for (let lo = a, hi = b; lo < hi; lo++, hi--) { ... } + * + * The first counter only grows and the second only shrinks, by positive + * literal steps, the body writes neither, and the loop runs while the first + * is below (or at most) the second. Every body entry therefore holds both + * between the first start and the second start: exact integers when the + * starts are. A start without a proven integer range is tested at run time + * on a versioned loop, as a counted loop's is. */ +export interface IntegerPairedCounter { + localId: string; + start: IrExpr; + /** The signed step of each update. */ + step: number; + startGuarded: boolean; +} +export interface IntegerPairedForLoop { + low: IntegerPairedCounter; + high: IntegerPairedCounter; + inclusive: boolean; + guarded: boolean; + /** Both counters' values on every body entry. */ + range: IntegerRange; +} + +export function matchIntegerPairedForLoop( + stmt: IrStmt & { kind: "for" }, + locals: ReadonlyMap, + ranges: IntegerRanges = new Map(), +): IntegerPairedForLoop | null { + const init = stmt.init, + update = stmt.update, + cond = stmt.cond; + if (init?.kind !== "block" || init.body.length !== 2) return null; + if (update?.kind !== "block" || update.body.length !== 2) return null; + if (cond?.kind !== "bin" || (cond.op !== "<" && cond.op !== "<=")) return null; + if (cond.left.kind !== "varRef" || cond.right.kind !== "varRef") return null; + const lowId = cond.left.localId, + highId = cond.right.localId; + if (lowId === highId) return null; + const counter = (id: string): IntegerPairedCounter | null => { + const decl = init.body.find((d) => d.kind === "varDecl" && d.localId === id); + if (decl?.kind !== "varDecl" || !decl.init) return null; + const local = locals.get(id); + if (local?.type.kind !== "f64" || !local.mutable || local.boxed || local.tdz) return null; + const start = decl.init; + // Each start is evaluated once in the head and again on a fallback path. + if ( + !stableLoopValue(start, locals, stmt.body, false, lowId) || + !stableLoopValue(start, locals, stmt.body, false, highId) + ) + return null; + const steps = update.body.map((u) => constantStep(u, id)).filter((v) => v !== null); + if (steps.length !== 1 || writesLocal(stmt.body, id)) return null; + const known = + start.kind === "numLit" && Number.isSafeInteger(start.value) && !Object.is(start.value, -0) + ? { min: start.value, max: start.value } + : ranges.get(start); + const startGuarded = !known && start.kind !== "numLit" && start.type.kind === "f64"; + if (!known && !startGuarded) return null; + if (known && (known.min < -Number.MAX_SAFE_INTEGER || known.max > Number.MAX_SAFE_INTEGER)) + return null; + return { localId: id, start, step: steps[0]!, startGuarded }; + }; + const low = counter(lowId), + high = counter(highId); + if (!low || !high || low.step <= 0 || high.step >= 0) return null; + const startRange = (c: IntegerPairedCounter): IntegerRange => + c.startGuarded + ? { min: -Number.MAX_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER } + : c.start.kind === "numLit" + ? { min: c.start.value, max: c.start.value } + : ranges.get(c.start)!; + const guarded = low.startGuarded || high.startGuarded; + // Only a loop whose counters index something gains from integer storage. + let useful = false, + cost = 0; + const isCounter = (e: IrExpr): boolean => + (e.kind === "varRef" && (e.localId === lowId || e.localId === highId)) || + (e.kind === "bin" && + (e.op === "+" || e.op === "-") && + (isCounter(e.left) || isCounter(e.right))); + const expr = (e: IrExpr): boolean => { + if (e.kind === "arrayGet" && isCounter(e.index)) useful = true; + if (e.kind === "strIntrinsic" && e.method === "charCodeAt" && e.args[0] && isCounter(e.args[0])) + useful = true; + if (e.kind === "bytesIntrinsic" && e.method === "get" && e.args[0] && isCounter(e.args[0])) + useful = true; + return (!guarded || ++cost <= 80) && everyExprChild(e, expr, bodyStmt); + }; + const bodyStmt = (s: IrStmt): boolean => { + if ((s.kind === "arraySet" || s.kind === "bytesSet") && isCounter(s.index)) useful = true; + if ( + guarded && + (s.kind === "for" || s.kind === "forOf" || s.kind === "while" || s.kind === "doWhile") + ) + return false; + return (!guarded || ++cost <= 80) && everyStmtChild(s, expr, bodyStmt); + }; + if (!stmt.body.every(bodyStmt) || !useful) return null; + return { + low, + high, + inclusive: cond.op === "<=", + guarded, + // A loop whose starts already fail the condition never enters the body. + range: { + min: startRange(low).min, + max: Math.max(startRange(low).min, startRange(high).max), + }, + }; +} + /** True when a lowered subtree writes `localId`. Local ids are unique per * function, so typed traversal includes writes * nested in expressions, branches, nested loops, and try/finally bodies. */ diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7140-paired-loop-counters.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7140-paired-loop-counters.ts.json new file mode 100644 index 000000000..122d64bb6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7140-paired-loop-counters.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7140-paired-loop-counters.ts" + ], + "diags": [] +} diff --git a/tests/corpus/7140-paired-loop-counters.ts b/tests/corpus/7140-paired-loop-counters.ts new file mode 100644 index 000000000..ec1610d1a --- /dev/null +++ b/tests/corpus/7140-paired-loop-counters.ts @@ -0,0 +1,81 @@ +// For loops with two counters closing in on each other (`lo++, hi--`): +// in-place reversals, inclusive bounds, larger steps, early exits, starts +// that are fractions, negative zero, NaN, huge or already crossed, nested +// reversals, and counters a closure captures or the body writes. +function reverse(a: number[], from: number, to: number): number[] { + for (let lo = from, hi = to; lo < hi; lo++, hi--) { + const t = a[lo]!; + a[lo] = a[hi]!; + a[hi] = t; + } + return a; +} +const base = (): number[] => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; +console.log(reverse(base(), 0, 9).join(",")); +console.log(reverse(base(), 2, 6).join(",")); +console.log(reverse(base(), 6, 2).join(",")); +console.log(reverse(base(), 3, 3).join(",")); +// Unproven starts: fractions, negative zero, NaN and huge values keep JS +// semantics (charCodeAt truncates its index; out-of-range reads are NaN). +function codes(s: string, from: number, to: number): string { + const out: number[] = []; + for (let lo = from, hi = to; lo < hi; lo++, hi--) out.push(s.charCodeAt(lo), s.charCodeAt(hi), lo, hi); + return out.join(","); +} +const word = "abcdefgh"; +console.log(codes(word, 0.5, 4.5)); +console.log(codes(word, -0, 3), Object.is(-0 + 0, 0)); +console.log(codes(word, NaN, 4), "|", codes(word, 0, NaN)); +console.log(codes(word, 2 ** 53 - 3, 2 ** 53)); +console.log(codes(word, -3, 2)); + +function pairs(n: number): string { + const out: string[] = []; + for (let i = 0, j = n; i <= j; i += 2, j -= 3) out.push(`${i}:${j}`); + return out.join(" "); +} +console.log(pairs(20), "|", pairs(0), "|", pairs(-1)); + +function firstGap(a: number[]): number { + let found = -1; + for (let lo = 0, hi = a.length - 1; lo < hi; lo++, hi--) { + if (a[lo] === a[hi]) continue; + found = lo; + break; + } + return found; +} +console.log(firstGap([1, 2, 3, 2, 1]), firstGap([1, 2, 3, 4, 2, 1]), firstGap([])); + +// The flip loop of a permutation puzzle: the next index comes from the array. +function flips(perm: number[]): number { + const work = perm.slice(); + let count = 0; + let head = work[0]!; + while (head !== 0) { + for (let lo = 0, hi = head; lo < hi; lo++, hi--) { + const t = work[lo]!; + work[lo] = work[hi]!; + work[hi] = t; + } + count++; + head = work[0]!; + } + return count; +} +console.log(flips([3, 1, 0, 2]), flips([4, 3, 2, 1, 0]), flips([0, 1, 2])); + +// Counters a closure reads, or the body writes, stay ordinary bindings. +const readers: (() => number)[] = []; +for (let lo = 0, hi = 4; lo < hi; lo++, hi--) readers.push(() => lo * 10 + hi); +console.log(readers.map((f) => f()).join(",")); +const seen: number[] = []; +for (let lo = 0, hi = 10; lo < hi; lo++, hi--) { + seen.push(lo, hi); + if (lo === 2) hi -= 3; +} +console.log(seen.join(",")); +const text = "abcdefgh"; +let mirrored = ""; +for (let lo = 0, hi = text.length - 1; lo <= hi; lo++, hi--) mirrored += text.charAt(hi) + text.charCodeAt(lo); +console.log(mirrored); diff --git a/tests/harness/corpus-costs/7140-paired-loop-counters.ts.json b/tests/harness/corpus-costs/7140-paired-loop-counters.ts.json new file mode 100644 index 000000000..549fd6a4a --- /dev/null +++ b/tests/harness/corpus-costs/7140-paired-loop-counters.ts.json @@ -0,0 +1 @@ +{ "plain": 3880, "san": 6000 } From d1ff061833279865ddff6cba84b4f2d5dd362ebc Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 02:48:13 -0500 Subject: [PATCH 033/102] Revert "Run two-counter for loops on integer counters" This reverts #1768 (8fec4484d), which made main CI fail. --- .../src/backend/llvm/counted-loops.ts | 81 +++++-------- .../src/backend/llvm/emit-statements.ts | 58 +-------- .../compiler/src/ir/integer-loops.test.ts | 73 +---------- packages/compiler/src/ir/integer-loops.ts | 114 ------------------ .../corpus/7140-paired-loop-counters.ts.json | 6 - tests/corpus/7140-paired-loop-counters.ts | 81 ------------- .../7140-paired-loop-counters.ts.json | 1 - 7 files changed, 37 insertions(+), 377 deletions(-) delete mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7140-paired-loop-counters.ts.json delete mode 100644 tests/corpus/7140-paired-loop-counters.ts delete mode 100644 tests/harness/corpus-costs/7140-paired-loop-counters.ts.json diff --git a/packages/compiler/src/backend/llvm/counted-loops.ts b/packages/compiler/src/backend/llvm/counted-loops.ts index 02943b852..36fc63e1f 100644 --- a/packages/compiler/src/backend/llvm/counted-loops.ts +++ b/packages/compiler/src/backend/llvm/counted-loops.ts @@ -1,5 +1,4 @@ -import type { IntegerCountedForLoop, IntegerPairedForLoop } from "../../ir/integer-loops.js"; -import type { IrExpr } from "../../ir/ir.js"; +import type { IntegerCountedForLoop } from "../../ir/integer-loops.js"; import type { LlvmEmitterContext } from "./expr-context.js"; import { f64Lit } from "./common.js"; @@ -60,51 +59,37 @@ export function emitCountedLoopSafety( `${safe} = fcmp ${loop.step > 0 ? "ole" : "oge"} double ${bound.name}, ${f64Lit(loop.guardLimit)}`, ); } - if (loop.startGuarded) safe = andSafe(host, safe, emitExactStart(host, loop.start)); + if (loop.startGuarded) { + // An exact integer of at most 2^53 - 1 in magnitude, and not -0 + // (the bit patterns of the value and its round trip agree). + // NaN and infinities fail the ordered range tests. + const start = host.emitExpr(loop.start); + const low = B.tmp(), + high = B.tmp(), + raw = B.tmp(), + wide = B.tmp(), + back = B.tmp(), + bits = B.tmp(), + backBits = B.tmp(), + exact = B.tmp(), + inRange = B.tmp(), + ok = B.tmp(); + B.line(`${low} = fcmp oge double ${start.name}, ${f64Lit(-Number.MAX_SAFE_INTEGER)}`); + B.line(`${high} = fcmp ole double ${start.name}, ${f64Lit(Number.MAX_SAFE_INTEGER)}`); + B.line(`${inRange} = and i1 ${low}, ${high}`); + B.line(`${raw} = fptosi double ${start.name} to i64`); + B.line(`${wide} = freeze i64 ${raw}`); + B.line(`${back} = sitofp i64 ${wide} to double`); + B.line(`${bits} = bitcast double ${start.name} 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}`); + if (safe === "true") safe = ok; + else { + const both = B.tmp(); + B.line(`${both} = and i1 ${safe}, ${ok}`); + safe = both; + } + } return safe; } - -/** The run-time test of a guarded paired loop: each unproven start is an - * exact safe integer. */ -export function emitPairedLoopSafety(host: LlvmEmitterContext, loop: IntegerPairedForLoop): string { - let safe = "true"; - for (const counter of [loop.low, loop.high]) - if (counter.startGuarded) safe = andSafe(host, safe, emitExactStart(host, counter.start)); - return safe; -} - -function andSafe(host: LlvmEmitterContext, safe: string, ok: string): string { - if (safe === "true") return ok; - const both = host.B.tmp(); - host.B.line(`${both} = and i1 ${safe}, ${ok}`); - return both; -} - -/** An exact integer of at most 2^53 - 1 in magnitude, and not -0 (the bit - * patterns of the value and its round trip agree). NaN and infinities fail - * the ordered range tests. */ -function emitExactStart(host: LlvmEmitterContext, expr: IrExpr): string { - const B = host.B; - const start = host.emitExpr(expr); - const low = B.tmp(), - high = B.tmp(), - raw = B.tmp(), - wide = B.tmp(), - back = B.tmp(), - bits = B.tmp(), - backBits = B.tmp(), - exact = B.tmp(), - inRange = B.tmp(), - ok = B.tmp(); - B.line(`${low} = fcmp oge double ${start.name}, ${f64Lit(-Number.MAX_SAFE_INTEGER)}`); - B.line(`${high} = fcmp ole double ${start.name}, ${f64Lit(Number.MAX_SAFE_INTEGER)}`); - B.line(`${inRange} = and i1 ${low}, ${high}`); - B.line(`${raw} = fptosi double ${start.name} to i64`); - B.line(`${wide} = freeze i64 ${raw}`); - B.line(`${back} = sitofp i64 ${wide} to double`); - B.line(`${bits} = bitcast double ${start.name} 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; -} diff --git a/packages/compiler/src/backend/llvm/emit-statements.ts b/packages/compiler/src/backend/llvm/emit-statements.ts index e15de353a..d2e96994b 100644 --- a/packages/compiler/src/backend/llvm/emit-statements.ts +++ b/packages/compiler/src/backend/llvm/emit-statements.ts @@ -42,15 +42,10 @@ import { matchIntegerArrayForLoop, matchIntegerBytesForLoop, matchIntegerCountedForLoop, - matchIntegerPairedForLoop, } from "../../ir/integer-loops.js"; import { emitByteWindowGuard, matchByteWindow } from "./byte-windows.js"; import { countedDenseShape, emitDenseLoopGuard, matchDenseArrayLoop } from "./dense-array-loops.js"; -import { - emitCountedLoopLimit, - emitCountedLoopSafety, - emitPairedLoopSafety, -} from "./counted-loops.js"; +import { emitCountedLoopLimit, emitCountedLoopSafety } from "./counted-loops.js"; import { emitBytesLoopVersionGuard } from "./bytes-loop-versions.js"; import { mangleLocal } from "../mangle.js"; import { LlvmUnsupportedError } from "./unsupported.js"; @@ -871,12 +866,6 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { emitter.unaliasedArrays, ) : null; - // Two counters closing in on each other (`lo++, hi--`) take the same - // integer storage as a counted loop's one. - const pairedLoop = - !integerLoop && !countedLoop && emitter.countedLoopsEnabled - ? matchIntegerPairedForLoop(s, emitter.numericLocals, emitter.integerRanges) - : null; const window = countedLoop && emitter.byteWindowsEnabled ? matchByteWindow( @@ -1009,10 +998,8 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { break; } let countedJoin: string | null = null; - if ((countedLoop?.guarded && !emitter.provenCountedGuards.has(s)) || pairedLoop?.guarded) { - const safe = countedLoop - ? emitCountedLoopSafety(emitter, countedLoop) - : emitPairedLoopSafety(emitter, pairedLoop!); + if (countedLoop?.guarded && !emitter.provenCountedGuards.has(s)) { + const safe = emitCountedLoopSafety(emitter, countedLoop); const fast = B.newLabel("counted.fast"); const slow = B.newLabel("counted.slow"); countedJoin = B.newLabel("counted.done"); @@ -1027,7 +1014,6 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { emitter.scopes.push([]); let integerSlot: string | null = null; let countedLimit: string | null = null; - const pairedSlots: string[] = []; if (integerLoop) { integerSlot = B.slot(); B.entryAllocas.push( @@ -1072,24 +1058,6 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { : countedLoop.range, }); countedLimit = emitCountedLoopLimit(emitter, countedLoop); - } else if (pairedLoop) { - for (const counter of [pairedLoop.low, pairedLoop.high]) { - const slot = B.slot(); - B.entryAllocas.push( - `${slot} = alloca i64 ; integer induction ${emitter.currentLocals.get(counter.localId)!.name}`, - ); - const value = emitter.emitExpr(counter.start); - const start = B.tmp(); - B.line(`${start} = fptosi double ${value.name} to i64`); - B.line(`store i64 ${start}, ptr ${slot}`); - pairedSlots.push(slot); - emitter.integerLoopBindings.set(counter.localId, { - slot, - type: "i64", - signed: true, - range: pairedLoop.range, - }); - } } else if (s.init) { // A multi-declarator head shares the loop's scope. Emitting its // IR block as an ordinary block would release captured/ref locals @@ -1171,14 +1139,6 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { `${inBounds} = icmp ${countedLoop.step > 0 ? "slt" : "sgt"} i64 ${index}, ${countedLimit}`, ); B.condBr(inBounds, lb, exit); - } else if (pairedLoop) { - const low = B.tmp(), - high = B.tmp(), - open = B.tmp(); - B.line(`${low} = load i64, ptr ${pairedSlots[0]}`); - B.line(`${high} = load i64, ptr ${pairedSlots[1]}`); - B.line(`${open} = icmp ${pairedLoop.inclusive ? "sle" : "slt"} i64 ${low}, ${high}`); - B.condBr(open, lb, exit); } else if (s.cond) B.condBr(emitter.emitCondition(s.cond), lb, exit); else B.br(lb); B.startBlock(lb); @@ -1210,14 +1170,6 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { B.line(`${old} = load i64, ptr ${integerSlot}`); B.line(`${next} = add nsw i64 ${old}, ${countedLoop.step}`); B.line(`store i64 ${next}, ptr ${integerSlot}`); - } else if (pairedLoop) { - [pairedLoop.low, pairedLoop.high].forEach((counter, i) => { - const old = B.tmp(); - const next = B.tmp(); - B.line(`${old} = load i64, ptr ${pairedSlots[i]}`); - B.line(`${next} = add nsw i64 ${old}, ${counter.step}`); - B.line(`store i64 ${next}, ptr ${pairedSlots[i]}`); - }); } else if (s.update) emitter.emitStmt(s.update); B.br(lc); } @@ -1226,10 +1178,6 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { emitter.releaseScope(emitter.scopes.pop()!); if (integerLoop) emitter.integerLoopBindings.delete(integerLoop.localId); if (countedLoop) emitter.integerLoopBindings.delete(countedLoop.localId); - if (pairedLoop) { - emitter.integerLoopBindings.delete(pairedLoop.low.localId); - emitter.integerLoopBindings.delete(pairedLoop.high.localId); - } if (integerArrayLoop) emitter.integerArrayBindings.delete(integerArrayLoop.localId); if (countedJoin) { B.br(countedJoin); diff --git a/packages/compiler/src/ir/integer-loops.test.ts b/packages/compiler/src/ir/integer-loops.test.ts index 24bbf5be0..aada3b053 100644 --- a/packages/compiler/src/ir/integer-loops.test.ts +++ b/packages/compiler/src/ir/integer-loops.test.ts @@ -1,10 +1,6 @@ import { expect, test } from "vitest"; import { BOOL, F64, STRING, arrayOf, type IrExpr, type IrLocal, type IrStmt } from "./ir.js"; -import { - matchIntegerArrayForLoop, - matchIntegerCountedForLoop, - matchIntegerPairedForLoop, -} from "./integer-loops.js"; +import { matchIntegerArrayForLoop, matchIntegerCountedForLoop } from "./integer-loops.js"; const loc = { file: "integer-array-loop.ts", start: 0, end: 0 }; const number = (value: number): IrExpr => ({ kind: "numLit", value, type: F64, loc }); @@ -359,70 +355,3 @@ test("a descending loop from an array's last index takes an integer counter for range: { min: 0, max: 4294967294 }, }); }); - -test("paired counters closing in on each other run as integers", () => { - const vars = new Map(locals); - for (const id of ["lo", "hi", "head"]) vars.set(id, { id, name: id, type: F64, mutable: true }); - const step = (id: string, op: "+" | "-", value = 1): IrStmt => ({ - kind: "assign", - localId: id, - value: { kind: "bin", op, left: ref(id), right: number(value), type: F64, loc }, - loc, - }); - const element = (index: IrExpr): IrExpr => ({ - kind: "arrayGet", - arr: { kind: "varRef", localId: "a", type: arrayOf(F64), loc }, - index, - type: F64, - loc, - }); - const paired = ( - lowStart: IrExpr, - highStart: IrExpr, - update = [step("lo", "+"), step("hi", "-")], - ) => - ({ - kind: "for", - loc, - init: { - kind: "block", - body: [ - { kind: "varDecl", localId: "lo", init: lowStart, loc }, - { kind: "varDecl", localId: "hi", init: highStart, loc }, - ], - loc, - }, - cond: { kind: "bin", op: "<", left: ref("lo"), right: ref("hi"), type: BOOL, loc }, - update: { kind: "block", body: update, loc }, - body: [{ kind: "exprStmt", expr: element(ref("hi")), loc }], - }) as IrStmt & { kind: "for" }; - expect(matchIntegerPairedForLoop(paired(number(0), number(9)), vars)).toMatchObject({ - low: { localId: "lo", step: 1, startGuarded: false }, - high: { localId: "hi", step: -1, startGuarded: false }, - guarded: false, - range: { min: 0, max: 9 }, - }); - // A start without a known range is tested at run time. - expect(matchIntegerPairedForLoop(paired(number(0), ref("head")), vars)).toMatchObject({ - high: { startGuarded: true }, - guarded: true, - }); - // Counters moving the same way, written by the body, captured, started - // from each other, or never used as an index are refused. - expect( - matchIntegerPairedForLoop( - paired(number(0), number(9), [step("lo", "+"), step("hi", "+")]), - vars, - ), - ).toBeNull(); - const writing = paired(number(0), number(9)); - writing.body.push(step("hi", "-", 2)); - expect(matchIntegerPairedForLoop(writing, vars)).toBeNull(); - const boxed = new Map(vars); - boxed.set("hi", { ...vars.get("hi")!, boxed: true }); - expect(matchIntegerPairedForLoop(paired(number(0), number(9)), boxed)).toBeNull(); - expect(matchIntegerPairedForLoop(paired(number(0), ref("lo")), vars)).toBeNull(); - const unused = paired(number(0), number(9)); - unused.body = []; - expect(matchIntegerPairedForLoop(unused, vars)).toBeNull(); -}); diff --git a/packages/compiler/src/ir/integer-loops.ts b/packages/compiler/src/ir/integer-loops.ts index e80680d6e..9b4675685 100644 --- a/packages/compiler/src/ir/integer-loops.ts +++ b/packages/compiler/src/ir/integer-loops.ts @@ -281,120 +281,6 @@ export function matchIntegerCountedForLoop( }; } -/** A for loop whose two counters close in on each other: - * - * for (let lo = a, hi = b; lo < hi; lo++, hi--) { ... } - * - * The first counter only grows and the second only shrinks, by positive - * literal steps, the body writes neither, and the loop runs while the first - * is below (or at most) the second. Every body entry therefore holds both - * between the first start and the second start: exact integers when the - * starts are. A start without a proven integer range is tested at run time - * on a versioned loop, as a counted loop's is. */ -export interface IntegerPairedCounter { - localId: string; - start: IrExpr; - /** The signed step of each update. */ - step: number; - startGuarded: boolean; -} -export interface IntegerPairedForLoop { - low: IntegerPairedCounter; - high: IntegerPairedCounter; - inclusive: boolean; - guarded: boolean; - /** Both counters' values on every body entry. */ - range: IntegerRange; -} - -export function matchIntegerPairedForLoop( - stmt: IrStmt & { kind: "for" }, - locals: ReadonlyMap, - ranges: IntegerRanges = new Map(), -): IntegerPairedForLoop | null { - const init = stmt.init, - update = stmt.update, - cond = stmt.cond; - if (init?.kind !== "block" || init.body.length !== 2) return null; - if (update?.kind !== "block" || update.body.length !== 2) return null; - if (cond?.kind !== "bin" || (cond.op !== "<" && cond.op !== "<=")) return null; - if (cond.left.kind !== "varRef" || cond.right.kind !== "varRef") return null; - const lowId = cond.left.localId, - highId = cond.right.localId; - if (lowId === highId) return null; - const counter = (id: string): IntegerPairedCounter | null => { - const decl = init.body.find((d) => d.kind === "varDecl" && d.localId === id); - if (decl?.kind !== "varDecl" || !decl.init) return null; - const local = locals.get(id); - if (local?.type.kind !== "f64" || !local.mutable || local.boxed || local.tdz) return null; - const start = decl.init; - // Each start is evaluated once in the head and again on a fallback path. - if ( - !stableLoopValue(start, locals, stmt.body, false, lowId) || - !stableLoopValue(start, locals, stmt.body, false, highId) - ) - return null; - const steps = update.body.map((u) => constantStep(u, id)).filter((v) => v !== null); - if (steps.length !== 1 || writesLocal(stmt.body, id)) return null; - const known = - start.kind === "numLit" && Number.isSafeInteger(start.value) && !Object.is(start.value, -0) - ? { min: start.value, max: start.value } - : ranges.get(start); - const startGuarded = !known && start.kind !== "numLit" && start.type.kind === "f64"; - if (!known && !startGuarded) return null; - if (known && (known.min < -Number.MAX_SAFE_INTEGER || known.max > Number.MAX_SAFE_INTEGER)) - return null; - return { localId: id, start, step: steps[0]!, startGuarded }; - }; - const low = counter(lowId), - high = counter(highId); - if (!low || !high || low.step <= 0 || high.step >= 0) return null; - const startRange = (c: IntegerPairedCounter): IntegerRange => - c.startGuarded - ? { min: -Number.MAX_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER } - : c.start.kind === "numLit" - ? { min: c.start.value, max: c.start.value } - : ranges.get(c.start)!; - const guarded = low.startGuarded || high.startGuarded; - // Only a loop whose counters index something gains from integer storage. - let useful = false, - cost = 0; - const isCounter = (e: IrExpr): boolean => - (e.kind === "varRef" && (e.localId === lowId || e.localId === highId)) || - (e.kind === "bin" && - (e.op === "+" || e.op === "-") && - (isCounter(e.left) || isCounter(e.right))); - const expr = (e: IrExpr): boolean => { - if (e.kind === "arrayGet" && isCounter(e.index)) useful = true; - if (e.kind === "strIntrinsic" && e.method === "charCodeAt" && e.args[0] && isCounter(e.args[0])) - useful = true; - if (e.kind === "bytesIntrinsic" && e.method === "get" && e.args[0] && isCounter(e.args[0])) - useful = true; - return (!guarded || ++cost <= 80) && everyExprChild(e, expr, bodyStmt); - }; - const bodyStmt = (s: IrStmt): boolean => { - if ((s.kind === "arraySet" || s.kind === "bytesSet") && isCounter(s.index)) useful = true; - if ( - guarded && - (s.kind === "for" || s.kind === "forOf" || s.kind === "while" || s.kind === "doWhile") - ) - return false; - return (!guarded || ++cost <= 80) && everyStmtChild(s, expr, bodyStmt); - }; - if (!stmt.body.every(bodyStmt) || !useful) return null; - return { - low, - high, - inclusive: cond.op === "<=", - guarded, - // A loop whose starts already fail the condition never enters the body. - range: { - min: startRange(low).min, - max: Math.max(startRange(low).min, startRange(high).max), - }, - }; -} - /** True when a lowered subtree writes `localId`. Local ids are unique per * function, so typed traversal includes writes * nested in expressions, branches, nested loops, and try/finally bodies. */ diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7140-paired-loop-counters.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7140-paired-loop-counters.ts.json deleted file mode 100644 index 122d64bb6..000000000 --- a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7140-paired-loop-counters.ts.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "order": [ - "/tests/corpus/7140-paired-loop-counters.ts" - ], - "diags": [] -} diff --git a/tests/corpus/7140-paired-loop-counters.ts b/tests/corpus/7140-paired-loop-counters.ts deleted file mode 100644 index ec1610d1a..000000000 --- a/tests/corpus/7140-paired-loop-counters.ts +++ /dev/null @@ -1,81 +0,0 @@ -// For loops with two counters closing in on each other (`lo++, hi--`): -// in-place reversals, inclusive bounds, larger steps, early exits, starts -// that are fractions, negative zero, NaN, huge or already crossed, nested -// reversals, and counters a closure captures or the body writes. -function reverse(a: number[], from: number, to: number): number[] { - for (let lo = from, hi = to; lo < hi; lo++, hi--) { - const t = a[lo]!; - a[lo] = a[hi]!; - a[hi] = t; - } - return a; -} -const base = (): number[] => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; -console.log(reverse(base(), 0, 9).join(",")); -console.log(reverse(base(), 2, 6).join(",")); -console.log(reverse(base(), 6, 2).join(",")); -console.log(reverse(base(), 3, 3).join(",")); -// Unproven starts: fractions, negative zero, NaN and huge values keep JS -// semantics (charCodeAt truncates its index; out-of-range reads are NaN). -function codes(s: string, from: number, to: number): string { - const out: number[] = []; - for (let lo = from, hi = to; lo < hi; lo++, hi--) out.push(s.charCodeAt(lo), s.charCodeAt(hi), lo, hi); - return out.join(","); -} -const word = "abcdefgh"; -console.log(codes(word, 0.5, 4.5)); -console.log(codes(word, -0, 3), Object.is(-0 + 0, 0)); -console.log(codes(word, NaN, 4), "|", codes(word, 0, NaN)); -console.log(codes(word, 2 ** 53 - 3, 2 ** 53)); -console.log(codes(word, -3, 2)); - -function pairs(n: number): string { - const out: string[] = []; - for (let i = 0, j = n; i <= j; i += 2, j -= 3) out.push(`${i}:${j}`); - return out.join(" "); -} -console.log(pairs(20), "|", pairs(0), "|", pairs(-1)); - -function firstGap(a: number[]): number { - let found = -1; - for (let lo = 0, hi = a.length - 1; lo < hi; lo++, hi--) { - if (a[lo] === a[hi]) continue; - found = lo; - break; - } - return found; -} -console.log(firstGap([1, 2, 3, 2, 1]), firstGap([1, 2, 3, 4, 2, 1]), firstGap([])); - -// The flip loop of a permutation puzzle: the next index comes from the array. -function flips(perm: number[]): number { - const work = perm.slice(); - let count = 0; - let head = work[0]!; - while (head !== 0) { - for (let lo = 0, hi = head; lo < hi; lo++, hi--) { - const t = work[lo]!; - work[lo] = work[hi]!; - work[hi] = t; - } - count++; - head = work[0]!; - } - return count; -} -console.log(flips([3, 1, 0, 2]), flips([4, 3, 2, 1, 0]), flips([0, 1, 2])); - -// Counters a closure reads, or the body writes, stay ordinary bindings. -const readers: (() => number)[] = []; -for (let lo = 0, hi = 4; lo < hi; lo++, hi--) readers.push(() => lo * 10 + hi); -console.log(readers.map((f) => f()).join(",")); -const seen: number[] = []; -for (let lo = 0, hi = 10; lo < hi; lo++, hi--) { - seen.push(lo, hi); - if (lo === 2) hi -= 3; -} -console.log(seen.join(",")); -const text = "abcdefgh"; -let mirrored = ""; -for (let lo = 0, hi = text.length - 1; lo <= hi; lo++, hi--) mirrored += text.charAt(hi) + text.charCodeAt(lo); -console.log(mirrored); diff --git a/tests/harness/corpus-costs/7140-paired-loop-counters.ts.json b/tests/harness/corpus-costs/7140-paired-loop-counters.ts.json deleted file mode 100644 index 549fd6a4a..000000000 --- a/tests/harness/corpus-costs/7140-paired-loop-counters.ts.json +++ /dev/null @@ -1 +0,0 @@ -{ "plain": 3880, "san": 6000 } From 1a240fbf107766e102c7c027b02ea5f78b62d6d7 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 02:49:33 -0500 Subject: [PATCH 034/102] Support asymmetric keys, signatures and Ed25519 in node:crypto and WebCrypto Co-authored-by: saboursepideh <25549001+saboursepideh@users.noreply.github.com> --- .../limitations/builtin-apis/crypto.mdx | 16 +- .../src/generated/node-v24-compatibility.json | 108 +- .../generated/node-v24-internal.json | 226 +- internal/compatibility/static-support.json | 3 +- .../ambient/scriptc-node-fallback.d.ts | 249 +- .../src/backend/executable-features.ts | 2 + packages/compiler/src/backend/library-pack.ts | 2 + .../compiler/src/backend/llvm/lib-shared.ts | 12 + .../src/backend/native-link-info-core.ts | 6 + .../compiler/src/backend/native/contracts.ts | 6 + .../compiler/src/backend/native/executable.ts | 8 +- .../src/backend/runtime-pack-targets.test.ts | 2 + .../compiler/src/backend/runtime-pack.test.ts | 2 + .../src/backend/target-diagnostics.ts | 21 +- packages/compiler/src/backend/warm-cache.ts | 2 + .../src/executable/executable-cache.test.ts | 2 + .../src/executable/executable-cache.ts | 4 + .../src/frontend/lowering/builtins/crypto.ts | 54 + .../frontend/lowering/builtins/key-object.ts | 31 +- .../frontend/lowering/builtins/webcrypto.ts | 31 +- .../src/frontend/lowering/surfaces.ts | 35 +- packages/compiler/src/frontend/type-mapper.ts | 102 +- packages/compiler/src/index.ts | 2 + packages/compiler/src/ir/builtin-effects.ts | 8 + .../compiler/src/ir/builtin-signatures.ts | 15 + packages/compiler/src/ir/runtime-features.ts | 65 + packages/compiler/src/library/ir-policy.ts | 8 + packages/compiler/src/native/cli.ts | 2 + packages/compiler/src/native/prepare.ts | 2 + .../compiler/src/native/sanitizer.test.ts | 2 + packages/compiler/surface-manifest.json | 50 +- .../tests/corpus/7080-crypto-ed25519.mjs.json | 6 + .../corpus/7081-webcrypto-ed25519.mjs.json | 6 + .../corpus/7082-crypto-key-objects.ts.json | 6 + .../corpus/7083-crypto-sign-verify.ts.json | 6 + .../corpus/7084-crypto-key-pairs.cjs.json | 6 + .../corpus/7085-webcrypto-ecdsa-rsa.ts.json | 6 + .../7086-webcrypto-ecdsa-rsa-errors.mjs.json | 6 + .../tests/fixtures/node-types/keys.ts.json | 6 + .../node-types/webcrypto-ecdsa.ts.json | 6 + .../runtime-pack-matrix.mjs | 2 +- .../runtime-darwin-arm64/scripts/build.mjs | 3 +- .../runtime-pack-matrix.mjs | 5 +- .../runtime-pack-common/scripts/build.mjs | 3 +- .../runtime-wasm32-wasi/scripts/build.mjs | 3 + packages/runtime/src/scr_crypto.h | 18 + packages/runtime/src/scr_dyn.h | 5 + packages/runtime/src/scr_ed25519.c | 76 + packages/runtime/src/scr_lib.c | 12 +- packages/runtime/src/scr_pki.c | 2118 ++++++++++++ packages/runtime/src/scr_pki.h | 75 + packages/runtime/src/scr_webcrypto.c | 164 +- packages/runtime/src/scr_webcrypto.h | 58 + packages/runtime/src/scr_webcrypto_pki.c | 845 +++++ packages/runtime/vendor/README.md | 12 + packages/runtime/vendor/libsodium/LICENSE | 18 + packages/runtime/vendor/libsodium/README.md | 7 + packages/runtime/vendor/libsodium/common.h | 285 ++ .../vendor/libsodium/crypto_hash_sha512.h | 60 + .../libsodium/crypto_scalarmult_curve25519.h | 42 + .../vendor/libsodium/crypto_sign_ed25519.h | 124 + .../vendor/libsodium/crypto_verify_16.h | 23 + .../vendor/libsodium/crypto_verify_32.h | 23 + .../vendor/libsodium/crypto_verify_64.h | 23 + .../runtime/vendor/libsodium/ed25519_ref10.c | 2858 +++++++++++++++++ .../runtime/vendor/libsodium/ed25519_ref10.h | 142 + .../vendor/libsodium/ed25519_ref10_fe_25_5.h | 1030 ++++++ packages/runtime/vendor/libsodium/export.h | 57 + .../runtime/vendor/libsodium/fe_25_5/base.h | 1344 ++++++++ .../runtime/vendor/libsodium/fe_25_5/base2.h | 40 + .../vendor/libsodium/fe_25_5/constants.h | 40 + .../runtime/vendor/libsodium/fe_25_5/fe.h | 220 ++ .../runtime/vendor/libsodium/hash_sha512_cp.c | 284 ++ packages/runtime/vendor/libsodium/keypair.c | 84 + packages/runtime/vendor/libsodium/open.c | 98 + .../runtime/vendor/libsodium/randombytes.h | 72 + packages/runtime/vendor/libsodium/sign.c | 128 + .../vendor/libsodium/sign_ed25519_ref10.h | 18 + packages/runtime/vendor/libsodium/utils.h | 179 ++ packages/runtime/vendor/libsodium/verify.c | 95 + tests/corpus/7080-crypto-ed25519.mjs | 34 + tests/corpus/7081-webcrypto-ed25519.mjs | 39 + tests/corpus/7082-crypto-key-objects.ts | 132 + tests/corpus/7083-crypto-sign-verify.ts | 85 + tests/corpus/7084-crypto-key-pairs.cjs | 64 + tests/corpus/7085-webcrypto-ecdsa-rsa.ts | 66 + .../7086-webcrypto-ecdsa-rsa-errors.mjs | 58 + tests/diagnostics/webcrypto-refusals.ts | 16 +- tests/fixtures/node-types/fenced.ts | 16 +- tests/fixtures/node-types/keys.ts | 43 + tests/fixtures/node-types/webcrypto-ecdsa.ts | 34 + .../__snapshots__/node-types-fenced.txt | 16 +- .../__snapshots__/webcrypto-refusals.ts.txt | 33 +- .../corpus-costs/7080-crypto-ed25519.mjs.json | 1 + .../7081-webcrypto-ed25519.mjs.json | 1 + .../7082-crypto-key-objects.ts.json | 1 + .../7083-crypto-sign-verify.ts.json | 1 + .../7084-crypto-key-pairs.cjs.json | 1 + .../7085-webcrypto-ecdsa-rsa.ts.json | 1 + .../7086-webcrypto-ecdsa-rsa-errors.mjs.json | 1 + tests/harness/errors.test.ts | 71 +- tests/harness/library-asyncfree.test.ts | 9 + tests/harness/project-config.test.ts | 32 + .../self-hosting-native-toolchain.test.ts | 2 + .../harness/self-hosting-runtime-pack.test.ts | 2 + 105 files changed, 12304 insertions(+), 280 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7080-crypto-ed25519.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7081-webcrypto-ed25519.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7082-crypto-key-objects.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7083-crypto-sign-verify.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7084-crypto-key-pairs.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7085-webcrypto-ecdsa-rsa.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7086-webcrypto-ecdsa-rsa-errors.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/keys.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/webcrypto-ecdsa.ts.json create mode 100644 packages/runtime/src/scr_ed25519.c create mode 100644 packages/runtime/src/scr_pki.c create mode 100644 packages/runtime/src/scr_pki.h create mode 100644 packages/runtime/src/scr_webcrypto.h create mode 100644 packages/runtime/src/scr_webcrypto_pki.c create mode 100644 packages/runtime/vendor/libsodium/LICENSE create mode 100644 packages/runtime/vendor/libsodium/README.md create mode 100644 packages/runtime/vendor/libsodium/common.h create mode 100644 packages/runtime/vendor/libsodium/crypto_hash_sha512.h create mode 100644 packages/runtime/vendor/libsodium/crypto_scalarmult_curve25519.h create mode 100644 packages/runtime/vendor/libsodium/crypto_sign_ed25519.h create mode 100644 packages/runtime/vendor/libsodium/crypto_verify_16.h create mode 100644 packages/runtime/vendor/libsodium/crypto_verify_32.h create mode 100644 packages/runtime/vendor/libsodium/crypto_verify_64.h create mode 100644 packages/runtime/vendor/libsodium/ed25519_ref10.c create mode 100644 packages/runtime/vendor/libsodium/ed25519_ref10.h create mode 100644 packages/runtime/vendor/libsodium/ed25519_ref10_fe_25_5.h create mode 100644 packages/runtime/vendor/libsodium/export.h create mode 100644 packages/runtime/vendor/libsodium/fe_25_5/base.h create mode 100644 packages/runtime/vendor/libsodium/fe_25_5/base2.h create mode 100644 packages/runtime/vendor/libsodium/fe_25_5/constants.h create mode 100644 packages/runtime/vendor/libsodium/fe_25_5/fe.h create mode 100644 packages/runtime/vendor/libsodium/hash_sha512_cp.c create mode 100644 packages/runtime/vendor/libsodium/keypair.c create mode 100644 packages/runtime/vendor/libsodium/open.c create mode 100644 packages/runtime/vendor/libsodium/randombytes.h create mode 100644 packages/runtime/vendor/libsodium/sign.c create mode 100644 packages/runtime/vendor/libsodium/sign_ed25519_ref10.h create mode 100644 packages/runtime/vendor/libsodium/utils.h create mode 100644 packages/runtime/vendor/libsodium/verify.c create mode 100644 tests/corpus/7080-crypto-ed25519.mjs create mode 100644 tests/corpus/7081-webcrypto-ed25519.mjs create mode 100644 tests/corpus/7082-crypto-key-objects.ts create mode 100644 tests/corpus/7083-crypto-sign-verify.ts create mode 100644 tests/corpus/7084-crypto-key-pairs.cjs create mode 100644 tests/corpus/7085-webcrypto-ecdsa-rsa.ts create mode 100644 tests/corpus/7086-webcrypto-ecdsa-rsa-errors.mjs create mode 100644 tests/fixtures/node-types/keys.ts create mode 100644 tests/fixtures/node-types/webcrypto-ecdsa.ts create mode 100644 tests/harness/corpus-costs/7080-crypto-ed25519.mjs.json create mode 100644 tests/harness/corpus-costs/7081-webcrypto-ed25519.mjs.json create mode 100644 tests/harness/corpus-costs/7082-crypto-key-objects.ts.json create mode 100644 tests/harness/corpus-costs/7083-crypto-sign-verify.ts.json create mode 100644 tests/harness/corpus-costs/7084-crypto-key-pairs.cjs.json create mode 100644 tests/harness/corpus-costs/7085-webcrypto-ecdsa-rsa.ts.json create mode 100644 tests/harness/corpus-costs/7086-webcrypto-ecdsa-rsa-errors.mjs.json diff --git a/docs/content/limitations/builtin-apis/crypto.mdx b/docs/content/limitations/builtin-apis/crypto.mdx index 3c830c63d..855968219 100644 --- a/docs/content/limitations/builtin-apis/crypto.mdx +++ b/docs/content/limitations/builtin-apis/crypto.mdx @@ -4,7 +4,7 @@ `copy()` of a Hash whose stream flushed, and stream use of a value after its stream closed, throw a coded SC2020 error. Through `unknown` and `any` slots and untyped JavaScript, Hash and Hmac values keep their identity and support `update()`, `digest()`, and Hash's `copy()`, called or read as values; their stream and event members there throw a coded SC2020 error. `timingSafeEqual` compares any view or ArrayBuffer. - Secret KeyObjects (`createSecretKey`, `generateKey` and `generateKeySync` for `hmac` and `aes`) support `type`, `symmetricKeySize`, `export()`, `equals()`, and `instanceof KeyObject`, and createHmac, hkdf, createCipheriv, and createDecipheriv accept them; asymmetric keys, `KeyObject.from()`, and `toCryptoKey()` are not available. + Secret KeyObjects (`createSecretKey`, `generateKey` and `generateKeySync` for `hmac` and `aes`) support `type`, `symmetricKeySize`, `export()`, `equals()`, and `instanceof KeyObject`, and createHmac, hkdf, createCipheriv, and createDecipheriv accept them; `KeyObject.from()` and `toCryptoKey()` are not available. `randomFill`, `randomFillSync` (every view kind and ArrayBuffer), `randomInt`, `randomUUID`, and `randomUUIDv7` follow Node 24.22, including callback timing; a `randomInt` callback whose error parameter is typed `Error | null` receives `null` where Node passes `undefined`. Scrypt supports its default parameters, numeric options, aliases, and memory limit. Both KDFs accept strings, Buffers, numeric typed arrays, DataViews, and fixed-length ArrayBuffers. @@ -15,5 +15,17 @@ `createECDH` and `ECDH.convertKey` support prime192v1, secp224r1, prime256v1, secp384r1, secp521r1, secp192k1, secp224k1, secp256k1, brainpoolP256r1, brainpoolP384r1, and brainpoolP512r1, on native targets, through `generateKeys()`, `computeSecret()`, `getPublicKey()`, `getPrivateKey()`, `setPrivateKey()`, and `setPublicKey()`, in compressed, uncompressed, and hybrid forms; the other curves `crypto.getCurves()` lists and wasm32-wasi builds are refused. A call on an ECDH value whose arguments no @types/node overload accepts (`getPublicKey("HEX")`) is refused at compile time, as is `computeSecret(view, encoding)`: Node reads that encoding as the input encoding and answers a Buffer where @types/node declares a string. ECDH property reads and writes throw a coded SC2020 error. - Other public-key operations remain unsupported. + RSA, EC, and Ed25519 private and public KeyObjects come from `generateKeyPairSync`, `generateKeyPair`, `createPrivateKey`, and `createPublicKey`, on native targets. + 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. + 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. + Comparing keys of different types with `equals()` answers false; Node also leaves an OpenSSL error queued, which a later key operation can report. + Diffie-Hellman and `publicEncrypt`/`privateDecrypt` remain unsupported. + WebCrypto's `crypto.subtle` supports HMAC keys imported from `raw` with `sign` and `verify`, SHA-1 and SHA-2 `digest`, and `generateKey`, `importKey`, `exportKey`, `sign`, and `verify` for ECDSA (P-256, P-384, and P-521), Ed25519, RSASSA-PKCS1-v1_5, and RSA-PSS, with the `spki`, `pkcs8`, and `jwk` formats and `raw` for ECDSA and Ed25519 public keys. + The methods are called on `crypto.subtle` directly; other methods, algorithms, and SHA-3 digests throw a coded SC2020 error, and ECDSA, Ed25519, and RSA are refused in wasm32-wasi builds. + ECDSA, Ed25519, and RSA link when a string literal in the program names the algorithm; a name built only at run time throws a coded SC2020 error. Native derivations finish before their deferred callbacks, so computation blocks the caller. diff --git a/docs/src/generated/node-v24-compatibility.json b/docs/src/generated/node-v24-compatibility.json index 66b0ba3dd..4898fe218 100644 --- a/docs/src/generated/node-v24-compatibility.json +++ b/docs/src/generated/node-v24-compatibility.json @@ -11338,9 +11338,9 @@ "inherited": true }, "static": { - "status": "refused", - "detail": "Explicitly rejected by a named compiler diagnostic.", - "verification": "explicit-refusal" + "status": "partial", + "detail": "Implemented by a dedicated static compiler/runtime path.", + "verification": "test-backed" } }, { @@ -11361,9 +11361,9 @@ "inherited": true }, "static": { - "status": "refused", - "detail": "Explicitly rejected by a named compiler diagnostic.", - "verification": "explicit-refusal" + "status": "partial", + "detail": "Implemented by a dedicated static compiler/runtime path.", + "verification": "test-backed" } }, { @@ -11407,9 +11407,9 @@ "inherited": true }, "static": { - "status": "refused", - "detail": "Explicitly rejected by a named compiler diagnostic.", - "verification": "explicit-refusal" + "status": "partial", + "detail": "Implemented by a dedicated static compiler/runtime path.", + "verification": "test-backed" } }, { @@ -11430,9 +11430,9 @@ "inherited": true }, "static": { - "status": "refused", - "detail": "Explicitly rejected by a named compiler diagnostic.", - "verification": "explicit-refusal" + "status": "partial", + "detail": "Implemented by a dedicated static compiler/runtime path.", + "verification": "test-backed" } }, { @@ -11545,9 +11545,9 @@ "inherited": true }, "static": { - "status": "refused", - "detail": "Explicitly rejected by a named compiler diagnostic.", - "verification": "explicit-refusal" + "status": "partial", + "detail": "Implemented by a dedicated static compiler/runtime path.", + "verification": "test-backed" } }, { @@ -11568,9 +11568,9 @@ "inherited": true }, "static": { - "status": "refused", - "detail": "Explicitly rejected by a named compiler diagnostic.", - "verification": "explicit-refusal" + "status": "partial", + "detail": "Implemented by a dedicated static compiler/runtime path.", + "verification": "test-backed" } }, { @@ -12327,9 +12327,9 @@ "inherited": true }, "static": { - "status": "refused", - "detail": "Explicitly rejected by a named compiler diagnostic.", - "verification": "explicit-refusal" + "status": "partial", + "detail": "Implemented by a dedicated static compiler/runtime path.", + "verification": "test-backed" } }, { @@ -12373,9 +12373,9 @@ "inherited": true }, "static": { - "status": "refused", - "detail": "Explicitly rejected by a named compiler diagnostic.", - "verification": "explicit-refusal" + "status": "partial", + "detail": "Implemented by a dedicated static compiler/runtime path.", + "verification": "test-backed" } }, { @@ -13523,9 +13523,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 by a dedicated static compiler/runtime path.", + "verification": "test-backed" } }, { @@ -13546,9 +13546,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 by a dedicated static compiler/runtime path.", + "verification": "test-backed" } }, { @@ -13684,9 +13684,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 by a dedicated static compiler/runtime path.", + "verification": "test-backed" } }, { @@ -13707,9 +13707,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 by a dedicated static compiler/runtime path.", + "verification": "test-backed" } }, { @@ -13730,9 +13730,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 by a dedicated static compiler/runtime path.", + "verification": "test-backed" } }, { @@ -13753,9 +13753,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 by a dedicated static compiler/runtime path.", + "verification": "test-backed" } }, { @@ -13776,9 +13776,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 by a dedicated static compiler/runtime path.", + "verification": "test-backed" } }, { @@ -13799,9 +13799,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 by a dedicated static compiler/runtime path.", + "verification": "test-backed" } }, { @@ -80162,9 +80162,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" } }, { @@ -80208,9 +80208,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" } }, { diff --git a/internal/compatibility/generated/node-v24-internal.json b/internal/compatibility/generated/node-v24-internal.json index c6a7a102c..c886cccf9 100644 --- a/internal/compatibility/generated/node-v24-internal.json +++ b/internal/compatibility/generated/node-v24-internal.json @@ -19313,12 +19313,17 @@ "tests/corpus/6703-ecdh-private-keys.ts", "tests/corpus/6704-ecdh-set-public-key.cjs", "tests/corpus/6705-ecdh-handles.ts", + "tests/corpus/7080-crypto-ed25519.mjs", + "tests/corpus/7082-crypto-key-objects.ts", + "tests/corpus/7083-crypto-sign-verify.ts", + "tests/corpus/7084-crypto-key-pairs.cjs", "tests/corpus/node24-crypto-kdf-errors.ts", "tests/corpus/node24-crypto-kdf-options.ts", "tests/corpus/node24-crypto-kdf.ts", "tests/corpus/node24-crypto-sha2.ts", "tests/fixtures/node-types/cipher.ts", "tests/fixtures/node-types/ecdh.ts", + "tests/fixtures/node-types/keys.ts", "tests/harness/npm-static.test.ts" ] }, @@ -19961,8 +19966,15 @@ "inherited": true }, "static": { - "status": "refused", - "evidence": "surface-manifest:unsupported:node-builtin.crypto.createPrivateKey" + "status": "partial", + "evidence": "compiler-dedicated:crypto.createPrivateKey", + "tests": [ + "tests/corpus/7080-crypto-ed25519.mjs", + "tests/corpus/7082-crypto-key-objects.ts", + "tests/corpus/7083-crypto-sign-verify.ts", + "tests/corpus/7084-crypto-key-pairs.cjs", + "tests/fixtures/node-types/keys.ts" + ] }, "anchorSource": "exact" }, @@ -20007,8 +20019,15 @@ "inherited": true }, "static": { - "status": "refused", - "evidence": "surface-manifest:unsupported:node-builtin.crypto.createPublicKey" + "status": "partial", + "evidence": "compiler-dedicated:crypto.createPublicKey", + "tests": [ + "tests/corpus/7080-crypto-ed25519.mjs", + "tests/corpus/7082-crypto-key-objects.ts", + "tests/corpus/7083-crypto-sign-verify.ts", + "tests/corpus/7084-crypto-key-pairs.cjs", + "tests/fixtures/node-types/keys.ts" + ] }, "anchorSource": "exact" }, @@ -20057,8 +20076,15 @@ "inherited": true }, "static": { - "status": "refused", - "evidence": "surface-manifest:unsupported:node-builtin.crypto.createSign" + "status": "partial", + "evidence": "compiler-dedicated:crypto.createSign", + "tests": [ + "tests/corpus/7080-crypto-ed25519.mjs", + "tests/corpus/7082-crypto-key-objects.ts", + "tests/corpus/7083-crypto-sign-verify.ts", + "tests/corpus/7084-crypto-key-pairs.cjs", + "tests/fixtures/node-types/keys.ts" + ] }, "anchorSource": "exact" }, @@ -20080,8 +20106,15 @@ "inherited": true }, "static": { - "status": "refused", - "evidence": "surface-manifest:unsupported:node-builtin.crypto.createVerify" + "status": "partial", + "evidence": "compiler-dedicated:crypto.createVerify", + "tests": [ + "tests/corpus/7080-crypto-ed25519.mjs", + "tests/corpus/7082-crypto-key-objects.ts", + "tests/corpus/7083-crypto-sign-verify.ts", + "tests/corpus/7084-crypto-key-pairs.cjs", + "tests/fixtures/node-types/keys.ts" + ] }, "anchorSource": "exact" }, @@ -20199,8 +20232,15 @@ "inherited": true }, "static": { - "status": "refused", - "evidence": "surface-manifest:unsupported:node-builtin.crypto.generateKeyPair" + "status": "partial", + "evidence": "compiler-dedicated:crypto.generateKeyPair", + "tests": [ + "tests/corpus/7080-crypto-ed25519.mjs", + "tests/corpus/7082-crypto-key-objects.ts", + "tests/corpus/7083-crypto-sign-verify.ts", + "tests/corpus/7084-crypto-key-pairs.cjs", + "tests/fixtures/node-types/keys.ts" + ] }, "anchorSource": "exact" }, @@ -20222,8 +20262,15 @@ "inherited": true }, "static": { - "status": "refused", - "evidence": "surface-manifest:unsupported:node-builtin.crypto.generateKeyPairSync" + "status": "partial", + "evidence": "compiler-dedicated:crypto.generateKeyPairSync", + "tests": [ + "tests/corpus/7080-crypto-ed25519.mjs", + "tests/corpus/7082-crypto-key-objects.ts", + "tests/corpus/7083-crypto-sign-verify.ts", + "tests/corpus/7084-crypto-key-pairs.cjs", + "tests/fixtures/node-types/keys.ts" + ] }, "anchorSource": "exact" }, @@ -21096,8 +21143,15 @@ "inherited": true }, "static": { - "status": "refused", - "evidence": "surface-manifest:unsupported:node-builtin.crypto.sign" + "status": "partial", + "evidence": "compiler-dedicated:crypto.sign", + "tests": [ + "tests/corpus/7080-crypto-ed25519.mjs", + "tests/corpus/7082-crypto-key-objects.ts", + "tests/corpus/7083-crypto-sign-verify.ts", + "tests/corpus/7084-crypto-key-pairs.cjs", + "tests/fixtures/node-types/keys.ts" + ] }, "anchorSource": "exact" }, @@ -21146,8 +21200,15 @@ "inherited": true }, "static": { - "status": "refused", - "evidence": "surface-manifest:unsupported:node-builtin.crypto.verify" + "status": "partial", + "evidence": "compiler-dedicated:crypto.verify", + "tests": [ + "tests/corpus/7080-crypto-ed25519.mjs", + "tests/corpus/7082-crypto-key-objects.ts", + "tests/corpus/7083-crypto-sign-verify.ts", + "tests/corpus/7084-crypto-key-pairs.cjs", + "tests/fixtures/node-types/keys.ts" + ] }, "anchorSource": "exact" }, @@ -23007,8 +23068,15 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:crypto" + "status": "partial", + "evidence": "compiler-dedicated:asymmetricKeyDetails", + "tests": [ + "tests/corpus/7080-crypto-ed25519.mjs", + "tests/corpus/7082-crypto-key-objects.ts", + "tests/corpus/7083-crypto-sign-verify.ts", + "tests/corpus/7084-crypto-key-pairs.cjs", + "tests/fixtures/node-types/keys.ts" + ] }, "anchorSource": "ancestor" }, @@ -23030,8 +23098,15 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:crypto" + "status": "partial", + "evidence": "compiler-dedicated:asymmetricKeyType", + "tests": [ + "tests/corpus/7080-crypto-ed25519.mjs", + "tests/corpus/7082-crypto-key-objects.ts", + "tests/corpus/7083-crypto-sign-verify.ts", + "tests/corpus/7084-crypto-key-pairs.cjs", + "tests/fixtures/node-types/keys.ts" + ] }, "anchorSource": "ancestor" }, @@ -23168,8 +23243,15 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:crypto" + "status": "partial", + "evidence": "compiler-dedicated:Sign", + "tests": [ + "tests/corpus/7080-crypto-ed25519.mjs", + "tests/corpus/7082-crypto-key-objects.ts", + "tests/corpus/7083-crypto-sign-verify.ts", + "tests/corpus/7084-crypto-key-pairs.cjs", + "tests/fixtures/node-types/keys.ts" + ] }, "anchorSource": "exact" }, @@ -23191,8 +23273,15 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:crypto" + "status": "partial", + "evidence": "compiler-dedicated:sign.sign", + "tests": [ + "tests/corpus/7080-crypto-ed25519.mjs", + "tests/corpus/7082-crypto-key-objects.ts", + "tests/corpus/7083-crypto-sign-verify.ts", + "tests/corpus/7084-crypto-key-pairs.cjs", + "tests/fixtures/node-types/keys.ts" + ] }, "anchorSource": "exact" }, @@ -23214,8 +23303,15 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:crypto" + "status": "partial", + "evidence": "compiler-dedicated:sign.update", + "tests": [ + "tests/corpus/7080-crypto-ed25519.mjs", + "tests/corpus/7082-crypto-key-objects.ts", + "tests/corpus/7083-crypto-sign-verify.ts", + "tests/corpus/7084-crypto-key-pairs.cjs", + "tests/fixtures/node-types/keys.ts" + ] }, "anchorSource": "exact" }, @@ -23237,8 +23333,15 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:crypto" + "status": "partial", + "evidence": "compiler-dedicated:Verify", + "tests": [ + "tests/corpus/7080-crypto-ed25519.mjs", + "tests/corpus/7082-crypto-key-objects.ts", + "tests/corpus/7083-crypto-sign-verify.ts", + "tests/corpus/7084-crypto-key-pairs.cjs", + "tests/fixtures/node-types/keys.ts" + ] }, "anchorSource": "exact" }, @@ -23260,8 +23363,15 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:crypto" + "status": "partial", + "evidence": "compiler-dedicated:verify.update", + "tests": [ + "tests/corpus/7080-crypto-ed25519.mjs", + "tests/corpus/7082-crypto-key-objects.ts", + "tests/corpus/7083-crypto-sign-verify.ts", + "tests/corpus/7084-crypto-key-pairs.cjs", + "tests/fixtures/node-types/keys.ts" + ] }, "anchorSource": "exact" }, @@ -23283,8 +23393,15 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:crypto" + "status": "partial", + "evidence": "compiler-dedicated:verify.verify", + "tests": [ + "tests/corpus/7080-crypto-ed25519.mjs", + "tests/corpus/7082-crypto-key-objects.ts", + "tests/corpus/7083-crypto-sign-verify.ts", + "tests/corpus/7084-crypto-key-pairs.cjs", + "tests/fixtures/node-types/keys.ts" + ] }, "anchorSource": "exact" }, @@ -106616,6 +106733,9 @@ "tests/corpus/6293-webcrypto-digest.ts", "tests/corpus/6294-webcrypto-js-values.mjs", "tests/corpus/6295-jose-hs256/main.mjs", + "tests/corpus/7081-webcrypto-ed25519.mjs", + "tests/corpus/7085-webcrypto-ecdsa-rsa.ts", + "tests/corpus/7086-webcrypto-ecdsa-rsa-errors.mjs", "tests/corpus/node24-crypto-kdf-errors.ts", "tests/corpus/node24-crypto-kdf-options.ts", "tests/corpus/node24-crypto-kdf.ts", @@ -110543,6 +110663,9 @@ "status": "partial", "evidence": "compiler-feature:webcrypto.subtle.digest", "tests": [ + "tests/corpus/7081-webcrypto-ed25519.mjs", + "tests/corpus/7085-webcrypto-ecdsa-rsa.ts", + "tests/corpus/7086-webcrypto-ecdsa-rsa-errors.mjs", "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6292-webcrypto-hmac-errors.ts", "tests/corpus/6293-webcrypto-digest.ts", @@ -110640,8 +110763,19 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:webcrypto" + "status": "partial", + "evidence": "compiler-feature:webcrypto.subtle.exportKey", + "tests": [ + "tests/corpus/7081-webcrypto-ed25519.mjs", + "tests/corpus/7085-webcrypto-ecdsa-rsa.ts", + "tests/corpus/7086-webcrypto-ecdsa-rsa-errors.mjs", + "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", + "tests/corpus/6292-webcrypto-hmac-errors.ts", + "tests/corpus/6293-webcrypto-digest.ts", + "tests/corpus/6294-webcrypto-js-values.mjs", + "tests/corpus/6295-jose-hs256/main.mjs", + "tests/fixtures/node-types/webcrypto-hmac.ts" + ] }, "anchorSource": "exact" }, @@ -110686,8 +110820,19 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:webcrypto" + "status": "partial", + "evidence": "compiler-feature:webcrypto.subtle.generateKey", + "tests": [ + "tests/corpus/7081-webcrypto-ed25519.mjs", + "tests/corpus/7085-webcrypto-ecdsa-rsa.ts", + "tests/corpus/7086-webcrypto-ecdsa-rsa-errors.mjs", + "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", + "tests/corpus/6292-webcrypto-hmac-errors.ts", + "tests/corpus/6293-webcrypto-digest.ts", + "tests/corpus/6294-webcrypto-js-values.mjs", + "tests/corpus/6295-jose-hs256/main.mjs", + "tests/fixtures/node-types/webcrypto-hmac.ts" + ] }, "anchorSource": "exact" }, @@ -110712,6 +110857,9 @@ "status": "partial", "evidence": "compiler-feature:webcrypto.subtle.importKey", "tests": [ + "tests/corpus/7081-webcrypto-ed25519.mjs", + "tests/corpus/7085-webcrypto-ecdsa-rsa.ts", + "tests/corpus/7086-webcrypto-ecdsa-rsa-errors.mjs", "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6292-webcrypto-hmac-errors.ts", "tests/corpus/6293-webcrypto-digest.ts", @@ -110743,6 +110891,9 @@ "status": "partial", "evidence": "compiler-feature:webcrypto.subtle.sign", "tests": [ + "tests/corpus/7081-webcrypto-ed25519.mjs", + "tests/corpus/7085-webcrypto-ecdsa-rsa.ts", + "tests/corpus/7086-webcrypto-ecdsa-rsa-errors.mjs", "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6292-webcrypto-hmac-errors.ts", "tests/corpus/6293-webcrypto-digest.ts", @@ -110797,6 +110948,9 @@ "status": "partial", "evidence": "compiler-feature:webcrypto.subtle.verify", "tests": [ + "tests/corpus/7081-webcrypto-ed25519.mjs", + "tests/corpus/7085-webcrypto-ecdsa-rsa.ts", + "tests/corpus/7086-webcrypto-ecdsa-rsa-errors.mjs", "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6292-webcrypto-hmac-errors.ts", "tests/corpus/6293-webcrypto-digest.ts", diff --git a/internal/compatibility/static-support.json b/internal/compatibility/static-support.json index 23c7a159b..d799d4887 100644 --- a/internal/compatibility/static-support.json +++ b/internal/compatibility/static-support.json @@ -194,7 +194,7 @@ "stdlib.abort": ["tests/harness/fetch-conformance.test.ts"] }, "features": [ - { "chapter": "webcrypto", "symbols": ["subtle.importKey", "subtle.sign", "subtle.verify", "subtle.digest"], "status": "partial", "evidence": ["tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6292-webcrypto-hmac-errors.ts", "tests/corpus/6293-webcrypto-digest.ts", "tests/corpus/6294-webcrypto-js-values.mjs", "tests/corpus/6295-jose-hs256/main.mjs", "tests/fixtures/node-types/webcrypto-hmac.ts"] }, + { "chapter": "webcrypto", "symbols": ["subtle.generateKey", "subtle.importKey", "subtle.exportKey", "subtle.sign", "subtle.verify", "subtle.digest"], "status": "partial", "evidence": ["tests/corpus/7081-webcrypto-ed25519.mjs", "tests/corpus/7085-webcrypto-ecdsa-rsa.ts", "tests/corpus/7086-webcrypto-ecdsa-rsa-errors.mjs", "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6292-webcrypto-hmac-errors.ts", "tests/corpus/6293-webcrypto-digest.ts", "tests/corpus/6294-webcrypto-js-values.mjs", "tests/corpus/6295-jose-hs256/main.mjs", "tests/fixtures/node-types/webcrypto-hmac.ts"] }, { "chapter": "webcrypto", "signatures": ["Class: `SubtleCrypto`", "`subtle` Type: {SubtleCrypto}"], "status": "partial", "evidence": ["tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6292-webcrypto-hmac-errors.ts", "tests/corpus/6293-webcrypto-digest.ts", "tests/corpus/6294-webcrypto-js-values.mjs", "tests/corpus/6295-jose-hs256/main.mjs"] }, { "chapter": "webcrypto", "signatures": ["Class: `CryptoKey`", "`cryptoKey.algorithm`", "`extractable` Type: {boolean}", "`type` Type: {string} One of `'secret'`, `'private'`, or `'public'`.", "`usages` Type: {string\\[]}"], "status": "partial", "evidence": ["tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6294-webcrypto-js-values.mjs", "tests/corpus/6295-jose-hs256/main.mjs"] }, { "chapter": "globals", "signatures": ["`navigator`"], "status": "partial", "evidence": ["tests/fixtures/node-types/navigator.ts", "tests/harness/project-config.test.ts", "tests/corpus/6331-jose-root-entry/main.ts"] }, @@ -418,6 +418,7 @@ { "symbols": ["crypto.createHash", "Hash", "hash.update", "hash.digest", "hash.copy", "crypto.createHmac", "Hmac", "hmac.update", "hmac.digest", "crypto.hash", "crypto.pbkdf2", "crypto.pbkdf2Sync"], "status": "partial", "evidence": ["tests/corpus/5760-crypto-hash-stream.ts", "tests/corpus/5768-crypto-hash-unknown.ts", "tests/corpus/5769-crypto-hash-unknown.cjs", "tests/corpus/5761-crypto-hash-stream-states.ts", "tests/corpus/5762-crypto-hash-stream.cjs", "tests/corpus/2890-crypto-static-utility.ts", "tests/corpus/node24-crypto-sha2.ts", "tests/corpus/5435-crypto-hash-algorithms.ts", "tests/corpus/5436-crypto-hash-names.js", "tests/corpus/5437-crypto-hmac-algorithms.ts", "tests/corpus/5438-crypto-kdf-digests.ts", "tests/corpus/5440-crypto-hash-encodings.js", "tests/corpus/5441-crypto-hash-output-length.ts", "tests/harness/npm-static.test.ts"] }, { "symbols": ["crypto.randomFill", "crypto.randomFillSync", "crypto.randomUUID", "crypto.randomUUIDv7"], "status": "supported", "evidence": ["tests/corpus/5442-crypto-random-values.ts", "tests/corpus/5443-crypto-random-arguments.js", "tests/corpus/1358-crypto-random.ts"] }, { "symbols": ["crypto.createSecretKey", "crypto.generateKey", "crypto.generateKeySync", "KeyObject", "keyObject.export", "keyObject.equals", "keyObject.symmetricKeySize", "keyObject.type"], "status": "partial", "evidence": ["tests/corpus/5445-crypto-secret-key-objects.ts", "tests/corpus/5446-crypto-secret-key-errors.js"] }, + { "symbols": ["crypto.createPrivateKey", "crypto.createPublicKey", "crypto.generateKeyPair", "crypto.generateKeyPairSync", "crypto.sign", "crypto.verify", "crypto.createSign", "crypto.createVerify", "Sign", "sign.update", "sign.sign", "Verify", "verify.update", "verify.verify", "asymmetricKeyType", "asymmetricKeyDetails"], "status": "partial", "evidence": ["tests/corpus/7080-crypto-ed25519.mjs", "tests/corpus/7082-crypto-key-objects.ts", "tests/corpus/7083-crypto-sign-verify.ts", "tests/corpus/7084-crypto-key-pairs.cjs", "tests/fixtures/node-types/keys.ts"] }, { "symbols": ["crypto.getRandomValues"], "status": "supported", "evidence": ["tests/corpus/6204-crypto-get-random-values.ts", "tests/corpus/6205-crypto-get-random-values.js"] }, { "symbols": ["crypto.timingSafeEqual"], "status": "supported", "evidence": ["tests/corpus/5444-crypto-timing-safe-equal.js", "tests/corpus/2890-crypto-static-utility.ts"] }, { "symbols": ["crypto.randomInt"], "status": "partial", "evidence": ["tests/corpus/5442-crypto-random-values.ts", "tests/corpus/2890-crypto-static-utility.ts"] }, diff --git a/packages/compiler/ambient/scriptc-node-fallback.d.ts b/packages/compiler/ambient/scriptc-node-fallback.d.ts index dbb3cd8fd..ca1913cd7 100644 --- a/packages/compiler/ambient/scriptc-node-fallback.d.ts +++ b/packages/compiler/ambient/scriptc-node-fallback.d.ts @@ -544,11 +544,12 @@ declare var DOMException: { readonly prototype: DOMException; }; -/* WebCrypto's HMAC slice (scr_webcrypto.c): crypto.subtle's importKey for - * raw HMAC keys, HMAC sign/verify and the SHA-1/SHA-2 digests, typed as - * exactly that surface (the declarations mirror @types/node's webcrypto - * shapes). Every other SubtleCrypto method and crypto member is absent, - * so a use is an honest type error. CryptoKey values are native handles +/* WebCrypto (scr_webcrypto.c): crypto.subtle's importKey for raw HMAC + * keys, HMAC sign/verify, generateKey, importKey, exportKey, sign and + * verify for ECDSA, RSASSA-PKCS1-v1_5 and RSA-PSS, and the SHA-1/SHA-2 + * digests, typed as exactly that surface (the declarations mirror + * @types/node's webcrypto shapes). Every other SubtleCrypto method and + * crypto member is absent, so a use is an honest type error. CryptoKey values are native handles * whose four members read through the handle. */ declare var crypto: Crypto; /* The Crypto and SubtleCrypto constructors (feature probes only) stay @@ -623,27 +624,70 @@ interface JsonWebKey { x?: string; y?: string; } -/* The 'jwk' form type-checks like @types/node's; the compiler refuses it - * (the JsonWebKey import is not implemented). */ +interface EcKeyGenParams extends Algorithm { + namedCurve: string; +} +interface EcKeyImportParams extends Algorithm { + namedCurve: string; +} +interface EcdsaParams extends Algorithm { + hash: HashAlgorithmIdentifier; +} +interface RsaHashedKeyGenParams extends Algorithm { + modulusLength: number; + publicExponent: Uint8Array; + hash: HashAlgorithmIdentifier; +} +interface RsaHashedImportParams extends Algorithm { + hash: HashAlgorithmIdentifier; +} +interface RsaPssParams extends Algorithm { + saltLength: number; +} +interface EcKeyAlgorithm extends KeyAlgorithm { + namedCurve: string; +} +interface RsaHashedKeyAlgorithm extends KeyAlgorithm { + modulusLength: number; + publicExponent: Uint8Array; + hash: KeyAlgorithm; +} +interface CryptoKeyPair { + privateKey: CryptoKey; + publicKey: CryptoKey; +} +/* HMAC keys import from 'raw'; ECDSA and RSA keys generate, import and + * export as 'spki', 'pkcs8' and 'jwk', and ECDSA public keys as 'raw'. */ interface SubtleCrypto { digest(algorithm: AlgorithmIdentifier, data: BufferSource): Promise; + generateKey( + algorithm: EcKeyGenParams | RsaHashedKeyGenParams | "Ed25519" | { name: "Ed25519" }, + extractable: boolean, + keyUsages: readonly KeyUsage[], + ): Promise; importKey( format: "jwk", keyData: JsonWebKey, - algorithm: AlgorithmIdentifier | HmacImportParams, + algorithm: AlgorithmIdentifier | HmacImportParams | EcKeyImportParams | RsaHashedImportParams, extractable: boolean, keyUsages: readonly KeyUsage[], ): Promise; importKey( format: Exclude, keyData: BufferSource, - algorithm: AlgorithmIdentifier | HmacImportParams, + algorithm: AlgorithmIdentifier | HmacImportParams | EcKeyImportParams | RsaHashedImportParams, extractable: boolean, keyUsages: readonly KeyUsage[], ): Promise; - sign(algorithm: AlgorithmIdentifier, key: CryptoKey, data: BufferSource): Promise; + exportKey(format: "jwk", key: CryptoKey): Promise; + exportKey(format: Exclude, key: CryptoKey): Promise; + sign( + algorithm: AlgorithmIdentifier | EcdsaParams | RsaPssParams, + key: CryptoKey, + data: BufferSource, + ): Promise; verify( - algorithm: AlgorithmIdentifier, + algorithm: AlgorithmIdentifier | EcdsaParams | RsaPssParams, key: CryptoKey, signature: BufferSource, data: BufferSource, @@ -2693,8 +2737,20 @@ declare module "crypto" { import { Transform } from "stream"; export type KeyObjectType = "secret" | "public" | "private"; export interface JsonWebKey { - kty?: string; + crv?: string; + d?: string; + dp?: string; + dq?: string; + e?: string; k?: string; + kty?: string; + n?: string; + p?: string; + q?: string; + qi?: string; + x?: string; + y?: string; + [key: string]: unknown; } export interface JwkKeyExportOptions { format: "jwk"; @@ -2702,16 +2758,183 @@ declare module "crypto" { export interface KeyExportOptions { format?: "buffer" | undefined; } - /** Secret keys only; the asymmetric key types are not available. */ + export type KeyFormat = "pem" | "der" | "jwk"; + export interface AsymmetricKeyExportOptions { + type: "pkcs1" | "spki" | "pkcs8" | "sec1"; + format: T; + } + export interface AsymmetricKeyDetails { + modulusLength?: number; + publicExponent?: bigint; + namedCurve?: string; + } + /* Secret keys, and RSA and EC private and public keys. */ export class KeyObject { private constructor(); type: KeyObjectType; symmetricKeySize?: number; asymmetricKeyType?: string; + asymmetricKeyDetails?: AsymmetricKeyDetails; + export(options: AsymmetricKeyExportOptions<"pem">): string | Buffer; + export(options: AsymmetricKeyExportOptions<"der">): Buffer; export(options?: KeyExportOptions): Buffer; export(options: JwkKeyExportOptions): JsonWebKey; equals(otherKeyObject: KeyObject): boolean; } + export interface PrivateKeyInput { + key: string | Buffer; + format?: "pem" | "der" | undefined; + type?: "pkcs1" | "pkcs8" | "sec1" | undefined; + encoding?: string | undefined; + } + export interface PublicKeyInput { + key: string | Buffer; + format?: "pem" | "der" | undefined; + type?: "pkcs1" | "spki" | undefined; + encoding?: string | undefined; + } + export interface JsonWebKeyInput { + key: JsonWebKey; + format: "jwk"; + } + export function createPrivateKey( + key: PrivateKeyInput | string | Buffer | JsonWebKeyInput, + ): KeyObject; + export function createPublicKey( + key: PublicKeyInput | string | Buffer | KeyObject | JsonWebKeyInput, + ): KeyObject; + export interface KeyPairKeyObjectResult { + publicKey: KeyObject; + privateKey: KeyObject; + } + export interface KeyPairSyncResult { + publicKey: T1; + privateKey: T2; + } + export interface RSAKeyPairKeyObjectOptions { + modulusLength: number; + publicExponent?: number | undefined; + } + export interface ECKeyPairKeyObjectOptions { + namedCurve: string; + } + export interface RSAKeyPairOptions { + modulusLength: number; + publicExponent?: number | undefined; + publicKeyEncoding: { type: "pkcs1" | "spki"; format: PubF }; + privateKeyEncoding: { type: "pkcs1" | "pkcs8"; format: PrivF }; + } + export interface ECKeyPairOptions { + namedCurve: string; + publicKeyEncoding: { type: "pkcs1" | "spki"; format: PubF }; + privateKeyEncoding: { type: "sec1" | "pkcs8"; format: PrivF }; + } + export function generateKeyPairSync( + type: "rsa", + options: RSAKeyPairOptions<"pem", "pem">, + ): KeyPairSyncResult; + export function generateKeyPairSync( + type: "rsa", + options: RSAKeyPairOptions<"der", "der">, + ): KeyPairSyncResult; + export function generateKeyPairSync( + type: "rsa", + options: RSAKeyPairKeyObjectOptions, + ): KeyPairKeyObjectResult; + export function generateKeyPairSync( + type: "ec", + options: ECKeyPairOptions<"pem", "pem">, + ): KeyPairSyncResult; + export function generateKeyPairSync( + type: "ec", + options: ECKeyPairOptions<"der", "der">, + ): KeyPairSyncResult; + export function generateKeyPairSync( + type: "ec", + options: ECKeyPairKeyObjectOptions, + ): KeyPairKeyObjectResult; + export interface ED25519KeyPairOptions { + publicKeyEncoding: { type: "spki"; format: PubF }; + privateKeyEncoding: { type: "pkcs8"; format: PrivF }; + } + export function generateKeyPairSync( + type: "ed25519", + options: ED25519KeyPairOptions<"pem", "pem">, + ): KeyPairSyncResult; + export function generateKeyPairSync( + type: "ed25519", + options: ED25519KeyPairOptions<"der", "der">, + ): KeyPairSyncResult; + export function generateKeyPairSync(type: "ed25519", options?: {}): KeyPairKeyObjectResult; + export function generateKeyPair( + type: "ed25519", + options: {} | undefined, + callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void, + ): void; + export function generateKeyPair( + type: "rsa", + options: RSAKeyPairKeyObjectOptions, + callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void, + ): void; + export function generateKeyPair( + type: "ec", + options: ECKeyPairKeyObjectOptions, + callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void, + ): void; + export interface SigningOptions { + padding?: number | undefined; + saltLength?: number | undefined; + dsaEncoding?: "der" | "ieee-p1363" | undefined; + } + export interface SignPrivateKeyInput extends PrivateKeyInput, SigningOptions {} + export interface SignKeyObjectInput extends SigningOptions { + key: KeyObject; + } + export interface VerifyPublicKeyInput extends PublicKeyInput, SigningOptions {} + export interface VerifyKeyObjectInput extends SigningOptions { + key: KeyObject; + } + export function sign( + algorithm: string | null | undefined, + data: ArrayBufferView, + key: KeyObject | string | Buffer | SignKeyObjectInput | SignPrivateKeyInput, + ): Buffer; + export function verify( + algorithm: string | null | undefined, + data: ArrayBufferView, + key: KeyObject | string | Buffer | VerifyKeyObjectInput | VerifyPublicKeyInput, + signature: ArrayBufferView, + ): boolean; + /* Sign and Verify accumulate update() data; they are not usable as + * writable streams. */ + export class Sign { + private constructor(); + update(data: string | ArrayBufferView): this; + update(data: string, inputEncoding: Encoding): this; + sign( + privateKey: KeyObject | string | Buffer | SignKeyObjectInput | SignPrivateKeyInput, + ): Buffer; + sign( + privateKey: KeyObject | string | Buffer | SignKeyObjectInput | SignPrivateKeyInput, + outputFormat: BinaryToTextEncoding, + ): string; + } + export class Verify { + private constructor(); + update(data: string | ArrayBufferView): this; + update(data: string, inputEncoding: Encoding): this; + verify( + object: KeyObject | string | Buffer | VerifyKeyObjectInput | VerifyPublicKeyInput, + signature: ArrayBufferView, + ): boolean; + verify( + object: KeyObject | string | Buffer | VerifyKeyObjectInput | VerifyPublicKeyInput, + signature: string, + signatureEncoding?: BinaryToTextEncoding, + ): boolean; + } + export function createSign(algorithm: string): Sign; + export function createVerify(algorithm: string): Verify; export function createSecretKey(key: ArrayBufferView | ArrayBufferLike): KeyObject; export function createSecretKey(key: string, encoding: BufferEncoding): KeyObject; export function generateKeySync(type: "hmac" | "aes", options: { length: number }): KeyObject; diff --git a/packages/compiler/src/backend/executable-features.ts b/packages/compiler/src/backend/executable-features.ts index f7cae8508..f22607384 100644 --- a/packages/compiler/src/backend/executable-features.ts +++ b/packages/compiler/src/backend/executable-features.ts @@ -56,6 +56,8 @@ export function executableLinkFeatures(mod: IrModule): NativeLinkFeatures { tlsCa: features.tlsCa, cipher: features.cipher, ecdh: features.ecdh, + pki: features.pki, + ed25519: features.ed25519, webcrypto: features.webcrypto, perfLoop: features.perfLoop, }; diff --git a/packages/compiler/src/backend/library-pack.ts b/packages/compiler/src/backend/library-pack.ts index 805198df1..3867d255a 100644 --- a/packages/compiler/src/backend/library-pack.ts +++ b/packages/compiler/src/backend/library-pack.ts @@ -60,6 +60,8 @@ export async function compilePackedLibrary( tls: false, cipher: false, ecdh: false, + pki: false, + ed25519: false, webcrypto: false, perfLoop: false, tlsCa: false, diff --git a/packages/compiler/src/backend/llvm/lib-shared.ts b/packages/compiler/src/backend/llvm/lib-shared.ts index 8bb8bc3aa..c1a8a33b1 100644 --- a/packages/compiler/src/backend/llvm/lib-shared.ts +++ b/packages/compiler/src/backend/llvm/lib-shared.ts @@ -614,7 +614,9 @@ export const LIB_FN_SYMS: Record = { "crypto.generateKeySync": "scr_crypto_generate_key_sync", "crypto.keyObjectInput": "scr_crypto_key_object_input", "crypto.isKeyObject": "scr_crypto_is_key_object", + "webcrypto.generateKey": "scr_webcrypto_generate_key", "webcrypto.importKey": "scr_webcrypto_import_key", + "webcrypto.exportKey": "scr_webcrypto_export_key", "webcrypto.sign": "scr_webcrypto_sign", "webcrypto.verify": "scr_webcrypto_verify", "webcrypto.digest": "scr_webcrypto_digest", @@ -1027,6 +1029,14 @@ export const LIB_FN_SYMS: Record = { "crypto.x509ValidFromStr": "scr_crypto_x509_valid_from_str", "crypto.x509ValidTo": "scr_crypto_x509_valid_to", "crypto.x509ValidToStr": "scr_crypto_x509_valid_to_str", + "crypto.createPrivateKey": "scr_crypto_create_private_key", + "crypto.createPublicKey": "scr_crypto_create_public_key", + "crypto.generateKeyPairSync": "scr_crypto_generate_key_pair_sync", + "crypto.generateKeyPairCb": "scr_crypto_generate_key_pair_async", + "crypto.signOneshot": "scr_crypto_sign_oneshot", + "crypto.verifyOneshot": "scr_crypto_verify_oneshot", + "crypto.createSign": "scr_crypto_create_sign", + "crypto.createVerify": "scr_crypto_create_verify", "fs.writeFileModeSync": "scr_fs_write_file_mode", "fs.chownSync": "scr_fs_chown", "fs.lchownSync": "scr_fs_lchown", @@ -1565,6 +1575,7 @@ export function mockTimerSym( } export const USES_TIMERS_LIB_FNS = new Set([ + "crypto.generateKeyPairCb", "process.emitWarning", // Constructor-function streams defer their events on the stream ticks. "dyn.builtinStreamClass", @@ -1573,6 +1584,7 @@ export const USES_TIMERS_LIB_FNS = new Set([ // ecdh.setPublicKey reports DEP0031 on the next tick. "crypto.ecdhNew", // WebCrypto results settle through the deferred crypto queue. + "webcrypto.generateKey", "webcrypto.sign", "webcrypto.verify", "webcrypto.digest", diff --git a/packages/compiler/src/backend/native-link-info-core.ts b/packages/compiler/src/backend/native-link-info-core.ts index a476e1f7f..484ce03cd 100644 --- a/packages/compiler/src/backend/native-link-info-core.ts +++ b/packages/compiler/src/backend/native-link-info-core.ts @@ -90,6 +90,12 @@ export interface NativeLinkFeatures { /** crypto.createECDH and ECDH.convertKey: scr_ecdh.c plus the mbedTLS * archive. */ ecdh: boolean; + /** Asymmetric KeyObjects, crypto.sign/verify and Sign/Verify: scr_pki.c + * plus the mbedTLS archive. */ + pki: boolean; + /** Ed25519 keys and signatures with pki: scr_ed25519.c (the vendored + * libsodium Ed25519). */ + ed25519: boolean; /** perf_hooks event-loop metrics: scr_perf_loop.c. */ perfLoop: boolean; tlsCa: boolean; diff --git a/packages/compiler/src/backend/native/contracts.ts b/packages/compiler/src/backend/native/contracts.ts index 06a41c9b2..a4d5dc3dd 100644 --- a/packages/compiler/src/backend/native/contracts.ts +++ b/packages/compiler/src/backend/native/contracts.ts @@ -249,6 +249,12 @@ export interface CcOptions { /** crypto.createECDH and ECDH.convertKey: compiles scr_ecdh.c and links * the mbedTLS archive (shared with tls). */ ecdh?: boolean; + /** Asymmetric KeyObjects and signatures: compiles scr_pki.c and links + * the mbedTLS archive. */ + pki?: boolean; + /** Ed25519 with pki: compiles scr_ed25519.c (the vendored libsodium + * Ed25519). */ + ed25519?: boolean; /** crypto.subtle importKey/sign/verify/digest: compiles scr_webcrypto.c. */ webcrypto?: boolean; /** perf_hooks event-loop metrics: compiles scr_perf_loop.c. */ diff --git a/packages/compiler/src/backend/native/executable.ts b/packages/compiler/src/backend/native/executable.ts index a551ad600..cae6d9499 100644 --- a/packages/compiler/src/backend/native/executable.ts +++ b/packages/compiler/src/backend/native/executable.ts @@ -114,6 +114,7 @@ interface RuntimeUnitContext { tlsCa: boolean; cipher: boolean; ecdh: boolean; + pki: boolean; lreObjects: readonly string[]; zlibObjects: readonly string[]; tlsArchive: string | null; @@ -297,6 +298,8 @@ const RUNTIME_UNITS: readonly RuntimeUnit[] = [ unit((u) => u.opts.foreignFfi, "scr_ffi_queue.c"), unit((u) => u.opts.nodeTest, "scr_test.c"), unit((u) => u.opts.webcrypto, "scr_webcrypto.c"), + unit((u) => u.opts.webcrypto === true && u.opts.pki === true, "scr_webcrypto_pki.c"), + unit((u) => u.opts.pki === true && u.opts.ed25519 === true, "scr_ed25519.c"), // The CA-store unit rides its own gate OR the tls one: scr_tls.c // references its default-set override unconditionally. unit((u) => u.tlsCa, "scr_tls_ca.c"), @@ -308,6 +311,7 @@ const RUNTIME_UNITS: readonly RuntimeUnit[] = [ ...(u.tls ? [u.rt(join(u.rtDir, "scr_tls.c"))] : []), ...(u.cipher ? [u.rt(join(u.rtDir, "scr_cipher.c"))] : []), ...(u.ecdh ? [u.rt(join(u.rtDir, "scr_ecdh.c"))] : []), + ...(u.pki ? [u.rt(join(u.rtDir, "scr_pki.c"))] : []), u.tlsArchive, // mbedTLS's win32 entropy poll is BCryptGenRandom (bcrypt.h). // The unconditional win32 libs above do not carry it. @@ -375,7 +379,8 @@ export async function compileCInternal( // Symmetric ciphers and ECDH link the same mbedTLS archive as TLS. const cipher = opts.cipher ?? false; const ecdh = opts.ecdh ?? false; - const mbedtls = tls || cipher || ecdh; + const pki = opts.pki ?? false; + const mbedtls = tls || cipher || ecdh || pki; const driver = resolveCc(); const darwinDebugSymbols = needsDarwinDebugSymbols( targetPlatform(driver), @@ -733,6 +738,7 @@ export async function compileCInternal( tlsCa, cipher, ecdh, + pki, lreObjects, zlibObjects, tlsArchive, diff --git a/packages/compiler/src/backend/runtime-pack-targets.test.ts b/packages/compiler/src/backend/runtime-pack-targets.test.ts index fc7ed9efa..0a6868aa0 100644 --- a/packages/compiler/src/backend/runtime-pack-targets.test.ts +++ b/packages/compiler/src/backend/runtime-pack-targets.test.ts @@ -125,6 +125,8 @@ const features = { tlsCa: false, cipher: false, ecdh: false, + pki: false, + ed25519: false, webcrypto: false, perfLoop: false, }; diff --git a/packages/compiler/src/backend/runtime-pack.test.ts b/packages/compiler/src/backend/runtime-pack.test.ts index 5ffb4797d..d0515a8ef 100644 --- a/packages/compiler/src/backend/runtime-pack.test.ts +++ b/packages/compiler/src/backend/runtime-pack.test.ts @@ -61,6 +61,8 @@ const BASE: NativeLinkFeatures = { tlsCa: false, cipher: false, ecdh: false, + pki: false, + ed25519: false, webcrypto: false, perfLoop: false, }; diff --git a/packages/compiler/src/backend/target-diagnostics.ts b/packages/compiler/src/backend/target-diagnostics.ts index b7049f6fe..c9aecc170 100644 --- a/packages/compiler/src/backend/target-diagnostics.ts +++ b/packages/compiler/src/backend/target-diagnostics.ts @@ -2,7 +2,11 @@ import { everyModuleNode, everyStmtList, transformStmtList } from "../ir/travers import type { LlvmUnsupportedError } from "./llvm/emitter.js"; import type { ScrDiagnostic } from "../diagnostics/diagnostic.js"; import { type IrModule, type SrcLoc } from "../ir/ir.js"; -import { moduleUsesFetch } from "../ir/runtime-features.js"; +import { + PKI_LIB_FNS, + moduleUsesFetch, + moduleUsesWebCryptoAsymmetric, +} from "../ir/runtime-features.js"; /** Reflection tables expose methods that the program never calls. On WASI, * keep their host-only implementations as explicit runtime refusals. Typed @@ -215,6 +219,14 @@ export function moduleWasiUnavailableSurface( }; return false; } + if (PKI_LIB_FNS.has(node.fn)) { + found = { + surface: + "asymmetric keys and signatures (the wasm32-wasi runtime does not include the mbedTLS library)", + loc, + }; + return false; + } if (node.fn === "os.networkInterfaces") { found = { surface: "network-interface enumeration (WASI Preview 1 has no interface API)", @@ -241,5 +253,12 @@ export function moduleWasiUnavailableSurface( if (moduleUsesFetch(mod)) { return { surface: "network-backed fetch (WASI Preview 1 has no socket API)", loc: entryLoc }; } + if (moduleUsesWebCryptoAsymmetric(mod)) { + return { + surface: + "WebCrypto ECDSA and RSA (the wasm32-wasi runtime does not include the mbedTLS library)", + loc: entryLoc, + }; + } return null; } diff --git a/packages/compiler/src/backend/warm-cache.ts b/packages/compiler/src/backend/warm-cache.ts index 2d8ae6641..2f98fd920 100644 --- a/packages/compiler/src/backend/warm-cache.ts +++ b/packages/compiler/src/backend/warm-cache.ts @@ -67,6 +67,8 @@ export async function warmNativeCaches( tls: false, cipher: false, ecdh: false, + pki: false, + ed25519: false, webcrypto: false, perfLoop: false, tlsCa: false, diff --git a/packages/compiler/src/executable/executable-cache.test.ts b/packages/compiler/src/executable/executable-cache.test.ts index 94b136c90..0d786e208 100644 --- a/packages/compiler/src/executable/executable-cache.test.ts +++ b/packages/compiler/src/executable/executable-cache.test.ts @@ -65,6 +65,8 @@ const native: EarlyExecutableNativeFeatures = { tlsCa: false, cipher: false, ecdh: false, + pki: false, + ed25519: false, webcrypto: false, perfLoop: false, }; diff --git a/packages/compiler/src/executable/executable-cache.ts b/packages/compiler/src/executable/executable-cache.ts index 2312f5e85..975f67cf8 100644 --- a/packages/compiler/src/executable/executable-cache.ts +++ b/packages/compiler/src/executable/executable-cache.ts @@ -96,6 +96,8 @@ export interface EarlyExecutableNativeFeatures { tls: boolean; cipher: boolean; ecdh: boolean; + pki: boolean; + ed25519: boolean; perfLoop: boolean; tlsCa: boolean; webcrypto: boolean; @@ -228,6 +230,8 @@ const BOOLEAN_NATIVE_KEYS = [ "tlsCa", "cipher", "ecdh", + "pki", + "ed25519", "webcrypto", "perfLoop", ] as const satisfies readonly (keyof EarlyExecutableNativeFeatures)[]; diff --git a/packages/compiler/src/frontend/lowering/builtins/crypto.ts b/packages/compiler/src/frontend/lowering/builtins/crypto.ts index f4270dbe8..8b42a218d 100644 --- a/packages/compiler/src/frontend/lowering/builtins/crypto.ts +++ b/packages/compiler/src/frontend/lowering/builtins/crypto.ts @@ -695,6 +695,8 @@ export function lowerCryptoModuleCall( loc, }; } + const pki = lowerPkiCall(lowerer, expr, bi.member, args, loc); + if (pki) return pki; if (bi.member === "createSecretKey") { if (args.length < 1 || args.length > 2 || args.some(ts.isSpreadElement)) lowerer.noLowering( @@ -1335,3 +1337,55 @@ export function isWebCryptoReceiver(lowerer: Lowerer, receiver: ts.Expression): } return false; } + +/** The asymmetric-key and signature members (scr_pki.c): checked-dynamic + * arguments, and the result converted to the call site's type + * (KeyObject, Sign and Verify are checked-dynamic handles; key pairs, + * signatures and verdicts convert to their records, Buffers and + * booleans). Null for other members. */ +function lowerPkiCall( + lowerer: Lowerer, + expr: ts.CallExpression, + member: string, + args: readonly ts.Expression[], + loc: SrcLoc, +): IrExpr | null { + const forms: Readonly> = { + createPrivateKey: ["crypto.createPrivateKey", 1, 1, "createPrivateKey(key)"], + createPublicKey: ["crypto.createPublicKey", 1, 1, "createPublicKey(key)"], + generateKeyPairSync: ["crypto.generateKeyPairSync", 1, 2, "generateKeyPairSync(type, options)"], + generateKeyPair: [ + "crypto.generateKeyPairCb", + 2, + 3, + "generateKeyPair(type, [options,] callback)", + ], + sign: ["crypto.signOneshot", 3, 3, "sign(algorithm, data, key)"], + verify: ["crypto.verifyOneshot", 4, 4, "verify(algorithm, data, key, signature)"], + createSign: ["crypto.createSign", 1, 1, "createSign(algorithm)"], + createVerify: ["crypto.createVerify", 1, 1, "createVerify(algorithm)"], + }; + const form = forms[member]; + if (!form) return null; + const [fn, min, max, supported] = form; + if (args.length < min || args.length > max) + lowerer.noLowering( + `crypto.${member} with ${args.length} arguments`, + expr, + `${supported} is supported`, + ); + // generateKeyPair(type, callback): Node reads a function in the options + // position as the callback. + const shifted = fn === "crypto.generateKeyPairCb" && args.length === 2; + const values: IrExpr[] = []; + for (let i = 0; i < max; i++) { + const node = shifted ? (i === 1 ? undefined : i === 2 ? args[1] : args[i]) : args[i]; + values.push(dynArg(lowerer, node, loc)); + } + if (fn === "crypto.generateKeyPairCb") + 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; + return lowerer.coerceInto(expr, call, result); +} diff --git a/packages/compiler/src/frontend/lowering/builtins/key-object.ts b/packages/compiler/src/frontend/lowering/builtins/key-object.ts index 7e680fa20..ecb4f275a 100644 --- a/packages/compiler/src/frontend/lowering/builtins/key-object.ts +++ b/packages/compiler/src/frontend/lowering/builtins/key-object.ts @@ -4,10 +4,11 @@ import { locOf } from "../../program.js"; import { BOOL, DYN, type IrExpr } from "../../../ir/ir.js"; import { builtinImportOf } from "./module-bindings.js"; -/* node:crypto's secret KeyObject is a native checked-dynamic handle - * (scr_lib.c): the KeyObject type maps to dyn, its getters and methods - * dispatch through the handle, and these helpers lower the class's uses - * that a dyn value cannot answer by itself. */ +/* node:crypto's KeyObject is a native checked-dynamic handle (secret keys + * in scr_lib.c, private and public keys in scr_pki.c), as are Sign and + * Verify: the types map to dyn, their getters and methods dispatch through + * the handle, and these helpers lower the uses that a dyn value cannot + * answer by itself. */ /** Whether `node` names node:crypto's KeyObject class. */ export function isKeyObjectClass(lowerer: Lowerer, node: ts.Expression): boolean { @@ -37,15 +38,31 @@ export function lowerKeyObjectInstanceof( } const KEY_OBJECT_METHODS = new Set(["export", "equals", "toCryptoKey"]); +const SIGNER_METHODS = new Set(["update", "sign", "verify"]); -/** `key.export(...)`, `key.equals(...)` and `key.toCryptoKey(...)`: the +/** Whether a value's checker type is node:crypto's Sign or Verify. */ +function isSignerValue(lowerer: Lowerer, node: ts.Expression): boolean { + const type = lowerer.typeOf(node); + const sym = type.getAliasSymbol() ?? type.getSymbol(); + return ( + !!sym && + (ts.symbolName(sym) === "Sign" || ts.symbolName(sym) === "Verify") && + lowerer.isStdlibSymbol(sym) + ); +} + +/** `key.export(...)`, `key.equals(...)` and `key.toCryptoKey(...)`, and + * the update/sign/verify methods of Sign and Verify (scr_pki.c): the * handle answers them as methods, so they dispatch through dynInvoke * rather than as a member read and a call. */ export function lowerKeyObjectCall(lowerer: Lowerer, call: ts.CallExpression): IrExpr | null { if (call.questionDotToken || !ts.isPropertyAccessExpression(call.expression)) return null; const access = call.expression; - if (access.questionDotToken || !KEY_OBJECT_METHODS.has(access.name.text)) return null; - if (!isKeyObjectValue(lowerer, access.expression)) return null; + if (access.questionDotToken) return null; + const method = access.name.text; + const keyMethod = KEY_OBJECT_METHODS.has(method) && isKeyObjectValue(lowerer, access.expression); + if (!keyMethod && !(SIGNER_METHODS.has(method) && isSignerValue(lowerer, access.expression))) + return null; if (call.arguments.nodes.some(ts.isSpreadElement)) return null; return { kind: "dynInvoke", diff --git a/packages/compiler/src/frontend/lowering/builtins/webcrypto.ts b/packages/compiler/src/frontend/lowering/builtins/webcrypto.ts index 93cba84c5..ef04e8761 100644 --- a/packages/compiler/src/frontend/lowering/builtins/webcrypto.ts +++ b/packages/compiler/src/frontend/lowering/builtins/webcrypto.ts @@ -6,23 +6,27 @@ import { lowerDynObjectLiteral } from "../expressions/object-literals.js"; import { stdlibGlobalNameOf } from "../surfaces.js"; import { WEBCRYPTO_DYN_TYPES } from "../../type-mapper.js"; -/* WebCrypto's HMAC slice (scr_webcrypto.c): `crypto.subtle.importKey`, - * `sign`, `verify` and `digest` called on the crypto global (also through - * globalThis) lower to runtime entry points that take the argument vector - * as one dyn array and answer a promise, so Web IDL conversion, algorithm - * normalization and every error stay Node-shaped at run time. CryptoKey - * values are native handles; their type maps to dyn and their members - * are handle reads. Other SubtleCrypto methods are refused by name. */ +/* WebCrypto (scr_webcrypto.c, and scr_webcrypto_pki.c for ECDSA, Ed25519, + * RSASSA-PKCS1-v1_5 and RSA-PSS): `crypto.subtle.generateKey`, + * `importKey`, `exportKey`, `sign`, `verify` and `digest` called on the + * crypto global (also through globalThis) lower to runtime entry points + * that take the argument vector as one dyn array and answer a promise, so + * Web IDL conversion, algorithm normalization and every error stay + * Node-shaped at run time. CryptoKey values are native handles; their type + * maps to dyn and their members are handle reads. Other SubtleCrypto + * methods are refused by name. */ const SUBTLE_LOWERED: ReadonlyMap = new Map([ + ["generateKey", "webcrypto.generateKey"], ["importKey", "webcrypto.importKey"], + ["exportKey", "webcrypto.exportKey"], ["sign", "webcrypto.sign"], ["verify", "webcrypto.verify"], ["digest", "webcrypto.digest"], ]); const SUBTLE_HINT = - "the native WebCrypto surface is crypto.subtle.importKey('raw', ...) for HMAC keys, sign and verify with HMAC, and digest with SHA-1, SHA-256, SHA-384 or SHA-512, each called directly on crypto.subtle"; + "the native WebCrypto surface is crypto.subtle.importKey('raw', ...) for HMAC keys, sign and verify with HMAC, generateKey, importKey, exportKey, sign and verify for ECDSA, Ed25519, RSASSA-PKCS1-v1_5 and RSA-PSS, and digest with SHA-1, SHA-256, SHA-384 or SHA-512, each called directly on crypto.subtle"; /** Whether `node` is `crypto.subtle` on the WebCrypto global. */ function isSubtleReceiver(lowerer: Lowerer, node: ts.Expression): boolean { @@ -51,17 +55,6 @@ export function lowerWebCryptoCall(lowerer: Lowerer, call: ts.CallExpression): I if (call.arguments.nodes.some(ts.isSpreadElement)) { lowerer.noLowering(`crypto.subtle.${member} with spread arguments`, call, SUBTLE_HINT); } - // JsonWebKey imports are not implemented: a literal 'jwk' format is - // refused here (the runtime refuses a computed one). - const format = call.arguments.nodes[0]; - if ( - member === "importKey" && - format !== undefined && - ts.isStringLiteralLike(format) && - format.text === "jwk" - ) { - lowerer.noLowering("crypto.subtle.importKey with the 'jwk' key format", format, SUBTLE_HINT); - } const loc = locOf(call); const args = call.arguments.nodes.map((arg) => ts.isObjectLiteralExpression(arg) diff --git a/packages/compiler/src/frontend/lowering/surfaces.ts b/packages/compiler/src/frontend/lowering/surfaces.ts index c77938337..bc5834533 100644 --- a/packages/compiler/src/frontend/lowering/surfaces.ts +++ b/packages/compiler/src/frontend/lowering/surfaces.ts @@ -1553,6 +1553,16 @@ export const BUILTIN_MODULE_FNS: Record< createSecretKey: { fn: "crypto.createSecretKey", params: [DYN, DYN], result: DYN }, generateKeySync: { fn: "crypto.generateKeySync", params: [DYN, DYN], result: DYN }, generateKey: { fn: "crypto.generateKeyCb", params: [], result: VOID }, + // Asymmetric keys and signatures (lowerPkiCall): checked-dynamic + // arguments, results converted to the call site's type. + createPrivateKey: { fn: "crypto.createPrivateKey", params: [DYN], result: DYN }, + createPublicKey: { fn: "crypto.createPublicKey", params: [DYN], result: DYN }, + createSign: { fn: "crypto.createSign", params: [DYN], result: DYN }, + createVerify: { fn: "crypto.createVerify", params: [DYN], result: DYN }, + generateKeyPairSync: { fn: "crypto.generateKeyPairSync", params: [], result: DYN }, + generateKeyPair: { fn: "crypto.generateKeyPairCb", params: [], result: VOID }, + sign: { fn: "crypto.signOneshot", params: [], result: DYN }, + verify: { fn: "crypto.verifyOneshot", params: [], result: DYN }, pbkdf2Sync: { fn: "crypto.pbkdf2", params: [BYTES_U8, BYTES_U8, F64, F64, STRING], @@ -2210,8 +2220,15 @@ export const AMBIENT_SURFACE_FNS: readonly AmbientSurfaceRow[] = [ id: "stdlib.webcrypto.subtle", kind: "stdlib", name: "globalThis.crypto.subtle", - fns: ["webcrypto.importKey", "webcrypto.sign", "webcrypto.verify", "webcrypto.digest"], - note: "importKey('raw') for HMAC keys, HMAC sign and verify, and SHA-1/SHA-2 digest; other methods, algorithms and key formats are refused", + fns: [ + "webcrypto.generateKey", + "webcrypto.importKey", + "webcrypto.exportKey", + "webcrypto.sign", + "webcrypto.verify", + "webcrypto.digest", + ], + note: "importKey('raw') for HMAC keys, HMAC sign and verify, generateKey, importKey, exportKey, sign and verify for ECDSA, Ed25519, RSASSA-PKCS1-v1_5 and RSA-PSS, and SHA-1/SHA-2 digest; other methods, algorithms and key formats are refused", }, { id: "stdlib.webcrypto.CryptoKey", @@ -3055,14 +3072,6 @@ export const BUILTIN_MODULE_FENCE_HINTS: Record< crypto: { ...Object.fromEntries( [ - "generateKeyPair", - "generateKeyPairSync", - "createPrivateKey", - "createPublicKey", - "createSign", - "createVerify", - "sign", - "verify", "createDiffieHellman", "createDiffieHellmanGroup", "getDiffieHellman", @@ -3073,9 +3082,9 @@ export const BUILTIN_MODULE_FENCE_HINTS: Record< "privateDecrypt", ].map((m) => [ m, - "asymmetric-key operations need a public-key stack (bignum, RSA/EC/EdDSA math) and " + - "public and private KeyObjects — neither exists in the static runtime, so no faithful lowering " + - "can be small; the lowered crypto surface is hashing, randomness, secret KeyObjects, and the introspection statics", + "Diffie-Hellman and RSA encryption have no lowering — the asymmetric crypto surface is " + + "RSA and EC KeyObjects (generateKeyPair, createPrivateKey, createPublicKey), sign, verify, " + + "createSign, createVerify, and createECDH", ]), ), ...Object.fromEntries( diff --git a/packages/compiler/src/frontend/type-mapper.ts b/packages/compiler/src/frontend/type-mapper.ts index a233f0186..50b809007 100644 --- a/packages/compiler/src/frontend/type-mapper.ts +++ b/packages/compiler/src/frontend/type-mapper.ts @@ -146,6 +146,37 @@ export const WEBCRYPTO_DYN_TYPES: ReadonlySet = new Set([ "KeyAlgorithm", "HmacImportParams", "HmacKeyAlgorithm", + "CryptoKeyPair", + "EcKeyAlgorithm", + "RsaHashedKeyAlgorithm", + "EcKeyGenParams", + "EcKeyImportParams", + "EcdsaParams", + "RsaHashedKeyGenParams", + "RsaHashedImportParams", + "RsaPssParams", +]); + +/** node:crypto's key and signature option interfaces: the key functions, + * KeyObject.export and sign/verify take them as checked-dynamic arguments + * (scr_lib.c, scr_pki.c). */ +export const CRYPTO_KEY_OPTION_DYN_TYPES: ReadonlySet = new Set([ + "AsymmetricKeyExportOptions", + "ECKeyPairKeyObjectOptions", + "ECKeyPairOptions", + "ED25519KeyPairOptions", + "JsonWebKeyInput", + "JwkKeyExportOptions", + "KeyExportOptions", + "PrivateKeyInput", + "PublicKeyInput", + "RSAKeyPairKeyObjectOptions", + "RSAKeyPairOptions", + "SignKeyObjectInput", + "SignPrivateKeyInput", + "SigningOptions", + "VerifyKeyObjectInput", + "VerifyPublicKeyInput", ]); export const FETCH_AMBIENT_TYPES = [ @@ -2903,9 +2934,10 @@ function mapTypeInner(type: ts.Type, ctx: TypeMapperCtx): IrType | null { ) { return DYN; } - // node:crypto's KeyObject: secret keys are native handles (scr_lib.c) - // whose getters and methods dispatch through the handle. The JsonWebKey - // that export() returns is a plain checked-dynamic object. + // node:crypto's KeyObject: secret keys (scr_lib.c) and private and + // public keys (scr_pki.c) are native handles whose getters and methods + // dispatch through the handle. The JsonWebKey that export() returns is a + // plain checked-dynamic object. if ( ((psym !== undefined && ts.symbolName(psym) === "KeyObject") || (psym !== undefined && ts.symbolName(psym) === "JsonWebKey")) && @@ -2917,6 +2949,35 @@ function mapTypeInner(type: ts.Type, ctx: TypeMapperCtx): IrType | null { ) { return DYN; } + // node:crypto's key and signature options are plain checked-dynamic + // objects, so a value asserted to one (`opts as + // crypto.AsymmetricKeyExportOptions<"pem">`) reaches the call unchanged. + if ( + psym !== undefined && + CRYPTO_KEY_OPTION_DYN_TYPES.has(ts.symbolName(psym)) && + psym.declarations.some( + (d) => + ts.isInterfaceDeclaration(d) && + ctx.isStdlibFile(ts.getSourceFileOfNode(d)) && + isDeclaredInAmbientModule(d, "crypto"), + ) + ) { + return DYN; + } + // node:crypto's Sign and Verify (createSign/createVerify): native + // handles over the digest state (scr_pki.c). + if ( + psym !== undefined && + (ts.symbolName(psym) === "Sign" || ts.symbolName(psym) === "Verify") && + psym.declarations.some( + (d) => + ts.isClassDeclaration(d) && + ctx.isStdlibFile(ts.getSourceFileOfNode(d)) && + isDeclaredInAmbientModule(d, "crypto"), + ) + ) { + return DYN; + } if ( psym && (FETCH_AMBIENT_TYPES as readonly string[]).includes(ts.symbolName(psym)) && @@ -4183,6 +4244,41 @@ function mapTypeInner(type: ts.Type, ctx: TypeMapperCtx): IrType | null { }; } } + // crypto.generateKeyPairSync's results: KeyPairKeyObjectResult and + // KeyPairSyncResult as { publicKey, privateKey } records over the + // mapped property types (KeyObjects, PEM strings or DER Buffers), in + // Node's key order. + if ( + psym !== undefined && + (ts.symbolName(psym) === "KeyPairKeyObjectResult" || + ts.symbolName(psym) === "KeyPairSyncResult") && + psym.declarations.some( + (d) => + ts.isInterfaceDeclaration(d) && + ctx.isStdlibFile(ts.getSourceFileOfNode(d)) && + isDeclaredInAmbientModule(d, "crypto"), + ) + ) { + const field = (name: string): IrType | null => { + const prop = ctx.checker.getPropertyOfType(type, name); + return prop ? mapType(ctx.checker.getTypeOfSymbol(prop), ctx) : null; + }; + const publicKey = field("publicKey"); + const privateKey = field("privateKey"); + if (!publicKey || !privateKey) return null; + return { + kind: "record", + shapeId: ctx.shapes.intern( + [ + { name: "privateKey", type: privateKey }, + { name: "publicKey", type: publicKey }, + ], + false, + undefined, + ["publicKey", "privateKey"], + ), + }; + } // crypto.X509Certificate — the Dirent-style data record: THREE visible // fields (fingerprint and the validFrom/validTo validity window, all // computed at construction by the new-expression lowering). Module- diff --git a/packages/compiler/src/index.ts b/packages/compiler/src/index.ts index 2b216c77d..458930616 100644 --- a/packages/compiler/src/index.ts +++ b/packages/compiler/src/index.ts @@ -624,6 +624,8 @@ async function compileExecutableNative( tlsCa: features.tlsCa, cipher: features.cipher, ecdh: features.ecdh, + pki: features.pki, + ed25519: features.ed25519, webcrypto: features.webcrypto, perfLoop: features.perfLoop, ...(onArtifactReady === undefined ? {} : { onArtifactReady }), diff --git a/packages/compiler/src/ir/builtin-effects.ts b/packages/compiler/src/ir/builtin-effects.ts index ca8c52118..3d9fb3f50 100644 --- a/packages/compiler/src/ir/builtin-effects.ts +++ b/packages/compiler/src/ir/builtin-effects.ts @@ -976,4 +976,12 @@ export const MAY_THROW_LIB_FNS: ReadonlySet = new Set([ "crypto.x509ValidFromStr", "crypto.x509ValidTo", "crypto.x509ValidToStr", + "crypto.createPrivateKey", + "crypto.createPublicKey", + "crypto.generateKeyPairSync", + "crypto.generateKeyPairCb", + "crypto.signOneshot", + "crypto.verifyOneshot", + "crypto.createSign", + "crypto.createVerify", ]); diff --git a/packages/compiler/src/ir/builtin-signatures.ts b/packages/compiler/src/ir/builtin-signatures.ts index fa7876579..95de752ec 100644 --- a/packages/compiler/src/ir/builtin-signatures.ts +++ b/packages/compiler/src/ir/builtin-signatures.ts @@ -2845,7 +2845,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({ /** WebCrypto (scr_webcrypto.c): each method takes its argument vector as * one dyn array and answers a promise that argument and validation * failures reject. CryptoKey values are native handles. */ + "webcrypto.generateKey": { argTypes: [DYN], result: { kind: "promise", inner: DYN } }, "webcrypto.importKey": { argTypes: [DYN], result: { kind: "promise", inner: DYN } }, + "webcrypto.exportKey": { argTypes: [DYN], result: { kind: "promise", inner: DYN } }, "webcrypto.sign": { argTypes: [DYN], result: { kind: "promise", inner: DYN } }, "webcrypto.verify": { argTypes: [DYN], result: { kind: "promise", inner: BOOL } }, "webcrypto.digest": { argTypes: [DYN], result: { kind: "promise", inner: DYN } }, @@ -4638,6 +4640,19 @@ export const LIB_FN_SIGS = defineLibFnSignatures({ * body passes its undefined result on into a Buffer slot. Owned (+1); * never throws. */ "bytes.absent": { argTypes: [], result: BYTES_U8 }, + /** node:crypto asymmetric keys and signatures (scr_pki.c): checked- + * dynamic arguments, borrowed; KeyObject, Sign and Verify handles, + * Buffers and booleans as checked-dynamic results (+1). Node's argument + * and decoder errors throw (may-throw); generateKeyPairCb's callback + * receives (null, publicKey, privateKey) in a later macrotask. */ + "crypto.createPrivateKey": { argTypes: [DYN], result: DYN }, + "crypto.createPublicKey": { argTypes: [DYN], result: DYN }, + "crypto.generateKeyPairSync": { argTypes: [DYN, DYN], result: DYN }, + "crypto.generateKeyPairCb": { argTypes: [DYN, DYN, DYN], result: VOID }, + "crypto.signOneshot": { argTypes: [DYN, DYN, DYN], result: DYN }, + "crypto.verifyOneshot": { argTypes: [DYN, DYN, DYN, DYN], result: DYN }, + "crypto.createSign": { argTypes: [DYN], result: DYN }, + "crypto.createVerify": { argTypes: [DYN], result: DYN }, /** The Buffer brand of a Uint8Array source onto a fresh Uint8Array * result (map and filter of a Buffer return a Buffer). */ "bytes.copyBrand": { argTypes: [BYTES_U8, BYTES_U8], result: VOID }, diff --git a/packages/compiler/src/ir/runtime-features.ts b/packages/compiler/src/ir/runtime-features.ts index 4142b6efe..2e828c027 100644 --- a/packages/compiler/src/ir/runtime-features.ts +++ b/packages/compiler/src/ir/runtime-features.ts @@ -621,6 +621,63 @@ const rule = (r: RuntimeFeatureRule): RuntimeFeatureRule => r; /* The HTTP, HTTPS, HTTP/2 and TLS surfaces, which link the net unit. */ const NET_PREFIXES: readonly string[] = ["net.", "http.", "tls.", "https.", "http2."]; +/** The scr_pki.c entry points (the pki unit). */ +export const PKI_LIB_FNS: ReadonlySet = new Set([ + "crypto.createPrivateKey", + "crypto.createPublicKey", + "crypto.createSign", + "crypto.createVerify", + "crypto.generateKeyPairCb", + "crypto.generateKeyPairSync", + "crypto.signOneshot", + "crypto.verifyOneshot", +]); + +/** The WebCrypto algorithms scr_webcrypto_pki.c implements over the pki + * unit (lowercased). */ +const WEBCRYPTO_ASYMMETRIC_NAMES: ReadonlySet = new Set([ + "ecdsa", + "ed25519", + "rsa-pss", + "rsassa-pkcs1-v1_5", +]); + +/** Whether a string literal in the module names Ed25519, without regard + * to case ("ed25519" for node:crypto, "Ed25519" for WebCrypto): the + * Ed25519 unit links then, alongside the pki unit. */ +export function moduleNamesEd25519(mod: IrModule): boolean { + let named = false; + everyModuleNode(mod, { + expr: (node) => { + if (node.kind === "strLit" && node.value.toLowerCase() === "ed25519") named = true; + return !named; + }, + stmt: () => !named, + type: () => true, + }); + return named; +} + +/** Whether the module calls WebCrypto and a string literal in it names one + * of the asymmetric algorithms (matched without regard to case, as + * normalizeAlgorithm matches names): scr_webcrypto_pki.c and the pki unit + * link then. */ +export function moduleUsesWebCryptoAsymmetric(mod: IrModule): boolean { + let webcrypto = false; + let named = false; + everyModuleNode(mod, { + expr: (node) => { + if (node.kind === "libCall" && node.fn.startsWith("webcrypto.")) webcrypto = true; + if (node.kind === "strLit" && WEBCRYPTO_ASYMMETRIC_NAMES.has(node.value.toLowerCase())) + named = true; + return !(webcrypto && named); + }, + stmt: () => !(webcrypto && named), + type: () => true, + }); + return webcrypto && named; +} + /** One rule per runtime feature, sorted by name. A new feature is an * entry here and its line in noRuntimeFeatures; RuntimeFeatures, the scan * and its early exit derive from this table. The lists above keep one @@ -819,6 +876,12 @@ const RUNTIME_FEATURE_RULES = { /** perf_hooks event-loop metrics (eventLoopUtilization, * monitorEventLoopDelay): scr_perf_loop.c. */ perfLoop: rule({ fns: ["perf.idleTime"], prefixes: ["perf.loop", "perf.eld"] }), + /** scr_pki.c over the mbedTLS archive: asymmetric KeyObjects and + * signatures. */ + pki: rule({ initial: moduleUsesWebCryptoAsymmetric, fns: [...PKI_LIB_FNS] }), + /** scr_ed25519.c (the vendored libsodium Ed25519), linked with pki: a + * string literal in the module names Ed25519. */ + ed25519: rule({ initial: moduleNamesEd25519 }), processEvents: rule({ fns: [...PROCESS_EVENT_LIB_FNS, "util.styleText"], types: ["procStream"] }), /** scr_url_legacy.c parses and stringifies queries. */ qs: rule({ fns: [...QS_LIB_FNS, ...LEGACY_URL_LIB_FNS] }), @@ -926,6 +989,8 @@ function noRuntimeFeatures(): RuntimeFeatures { nodeTest: false, parseArgs: false, perfLoop: false, + pki: false, + ed25519: false, processEvents: false, qs: false, regex: false, diff --git a/packages/compiler/src/library/ir-policy.ts b/packages/compiler/src/library/ir-policy.ts index 51aeb6146..f16ae3d0c 100644 --- a/packages/compiler/src/library/ir-policy.ts +++ b/packages/compiler/src/library/ir-policy.ts @@ -52,6 +52,13 @@ const LIB_MODE_REFUSED_PREFIXES: readonly [string, string][] = [ ["tls.", "the node:tls surface"], ["crypto.cipherNew", "crypto.createCipheriv and createDecipheriv"], ["crypto.ecdh", "crypto.createECDH and ECDH.convertKey"], + ["crypto.createPrivateKey", "asymmetric KeyObjects, generateKeyPair, sign and verify"], + ["crypto.createPublicKey", "asymmetric KeyObjects, generateKeyPair, sign and verify"], + ["crypto.createSign", "asymmetric KeyObjects, generateKeyPair, sign and verify"], + ["crypto.createVerify", "asymmetric KeyObjects, generateKeyPair, sign and verify"], + ["crypto.generateKeyPair", "asymmetric KeyObjects, generateKeyPair, sign and verify"], + ["crypto.signOneshot", "asymmetric KeyObjects, generateKeyPair, sign and verify"], + ["crypto.verifyOneshot", "asymmetric KeyObjects, generateKeyPair, sign and verify"], ["webcrypto.", "WebCrypto (crypto.subtle)"], ["fs.watch", "fs.watch"], ["watcher.", "fs.watch"], @@ -159,6 +166,7 @@ export function moduleLibAsyncSurface(mod: IrModule): { surface: string; loc: Sr [features.fsWatch, "fs.watch"], [features.stream, "the node:stream surface"], [features.tls, "the node:tls surface"], + [features.pki, "asymmetric KeyObjects, generateKeyPair, sign and verify"], [features.fetch, "fetch"], [features.eventTarget, "the EventTarget surface"], [features.nodeTest, "the node:test surface"], diff --git a/packages/compiler/src/native/cli.ts b/packages/compiler/src/native/cli.ts index ed8d52293..7679338bb 100644 --- a/packages/compiler/src/native/cli.ts +++ b/packages/compiler/src/native/cli.ts @@ -110,6 +110,8 @@ async function main(): Promise { tls: false, cipher: false, ecdh: false, + pki: false, + ed25519: false, webcrypto: false, perfLoop: false, tlsCa: false, diff --git a/packages/compiler/src/native/prepare.ts b/packages/compiler/src/native/prepare.ts index 6b0a2fea5..f470b614e 100644 --- a/packages/compiler/src/native/prepare.ts +++ b/packages/compiler/src/native/prepare.ts @@ -161,6 +161,8 @@ function validFeatures(value: unknown): value is NativeLinkFeatures { "tlsCa", "cipher", "ecdh", + "pki", + "ed25519", "webcrypto", "perfLoop", ].every((name) => typeof features[name] === "boolean"); diff --git a/packages/compiler/src/native/sanitizer.test.ts b/packages/compiler/src/native/sanitizer.test.ts index e6beb24cc..a626cd78c 100644 --- a/packages/compiler/src/native/sanitizer.test.ts +++ b/packages/compiler/src/native/sanitizer.test.ts @@ -120,6 +120,8 @@ test.skipIf(process.platform !== "linux" && process.platform !== "darwin")( tlsCa: false, cipher: false, ecdh: false, + pki: false, + ed25519: false, webcrypto: false, perfLoop: false, nativeFetch: false, diff --git a/packages/compiler/surface-manifest.json b/packages/compiler/surface-manifest.json index c05e994a8..a1f252814 100644 --- a/packages/compiler/surface-manifest.json +++ b/packages/compiler/surface-manifest.json @@ -498,7 +498,7 @@ "name": "crypto.createDiffieHellman", "status": "unsupported", "code": "SC2020", - "note": "asymmetric-key operations need a public-key stack (bignum, RSA/EC/EdDSA math) and public and private KeyObjects — neither exists in the static runtime, so no faithful lowering can be small; the lowered crypto surface is hashing, randomness, secret KeyObjects, and the introspection statics" + "note": "Diffie-Hellman and RSA encryption have no lowering — the asymmetric crypto surface is RSA and EC KeyObjects (generateKeyPair, createPrivateKey, createPublicKey), sign, verify, createSign, createVerify, and createECDH" }, { "id": "node-builtin.crypto.createDiffieHellmanGroup", @@ -506,7 +506,7 @@ "name": "crypto.createDiffieHellmanGroup", "status": "unsupported", "code": "SC2020", - "note": "asymmetric-key operations need a public-key stack (bignum, RSA/EC/EdDSA math) and public and private KeyObjects — neither exists in the static runtime, so no faithful lowering can be small; the lowered crypto surface is hashing, randomness, secret KeyObjects, and the introspection statics" + "note": "Diffie-Hellman and RSA encryption have no lowering — the asymmetric crypto surface is RSA and EC KeyObjects (generateKeyPair, createPrivateKey, createPublicKey), sign, verify, createSign, createVerify, and createECDH" }, { "id": "node-builtin.crypto.createECDH", @@ -530,17 +530,13 @@ "id": "node-builtin.crypto.createPrivateKey", "kind": "node-builtin", "name": "crypto.createPrivateKey", - "status": "unsupported", - "code": "SC2020", - "note": "asymmetric-key operations need a public-key stack (bignum, RSA/EC/EdDSA math) and public and private KeyObjects — neither exists in the static runtime, so no faithful lowering can be small; the lowered crypto surface is hashing, randomness, secret KeyObjects, and the introspection statics" + "status": "static" }, { "id": "node-builtin.crypto.createPublicKey", "kind": "node-builtin", "name": "crypto.createPublicKey", - "status": "unsupported", - "code": "SC2020", - "note": "asymmetric-key operations need a public-key stack (bignum, RSA/EC/EdDSA math) and public and private KeyObjects — neither exists in the static runtime, so no faithful lowering can be small; the lowered crypto surface is hashing, randomness, secret KeyObjects, and the introspection statics" + "status": "static" }, { "id": "node-builtin.crypto.createSecretKey", @@ -552,17 +548,13 @@ "id": "node-builtin.crypto.createSign", "kind": "node-builtin", "name": "crypto.createSign", - "status": "unsupported", - "code": "SC2020", - "note": "asymmetric-key operations need a public-key stack (bignum, RSA/EC/EdDSA math) and public and private KeyObjects — neither exists in the static runtime, so no faithful lowering can be small; the lowered crypto surface is hashing, randomness, secret KeyObjects, and the introspection statics" + "status": "static" }, { "id": "node-builtin.crypto.createVerify", "kind": "node-builtin", "name": "crypto.createVerify", - "status": "unsupported", - "code": "SC2020", - "note": "asymmetric-key operations need a public-key stack (bignum, RSA/EC/EdDSA math) and public and private KeyObjects — neither exists in the static runtime, so no faithful lowering can be small; the lowered crypto surface is hashing, randomness, secret KeyObjects, and the introspection statics" + "status": "static" }, { "id": "node-builtin.crypto.diffieHellman", @@ -570,7 +562,7 @@ "name": "crypto.diffieHellman", "status": "unsupported", "code": "SC2020", - "note": "asymmetric-key operations need a public-key stack (bignum, RSA/EC/EdDSA math) and public and private KeyObjects — neither exists in the static runtime, so no faithful lowering can be small; the lowered crypto surface is hashing, randomness, secret KeyObjects, and the introspection statics" + "note": "Diffie-Hellman and RSA encryption have no lowering — the asymmetric crypto surface is RSA and EC KeyObjects (generateKeyPair, createPrivateKey, createPublicKey), sign, verify, createSign, createVerify, and createECDH" }, { "id": "node-builtin.crypto.generateKey", @@ -582,17 +574,13 @@ "id": "node-builtin.crypto.generateKeyPair", "kind": "node-builtin", "name": "crypto.generateKeyPair", - "status": "unsupported", - "code": "SC2020", - "note": "asymmetric-key operations need a public-key stack (bignum, RSA/EC/EdDSA math) and public and private KeyObjects — neither exists in the static runtime, so no faithful lowering can be small; the lowered crypto surface is hashing, randomness, secret KeyObjects, and the introspection statics" + "status": "static" }, { "id": "node-builtin.crypto.generateKeyPairSync", "kind": "node-builtin", "name": "crypto.generateKeyPairSync", - "status": "unsupported", - "code": "SC2020", - "note": "asymmetric-key operations need a public-key stack (bignum, RSA/EC/EdDSA math) and public and private KeyObjects — neither exists in the static runtime, so no faithful lowering can be small; the lowered crypto surface is hashing, randomness, secret KeyObjects, and the introspection statics" + "status": "static" }, { "id": "node-builtin.crypto.generateKeySync", @@ -614,7 +602,7 @@ "name": "crypto.getDiffieHellman", "status": "unsupported", "code": "SC2020", - "note": "asymmetric-key operations need a public-key stack (bignum, RSA/EC/EdDSA math) and public and private KeyObjects — neither exists in the static runtime, so no faithful lowering can be small; the lowered crypto surface is hashing, randomness, secret KeyObjects, and the introspection statics" + "note": "Diffie-Hellman and RSA encryption have no lowering — the asymmetric crypto surface is RSA and EC KeyObjects (generateKeyPair, createPrivateKey, createPublicKey), sign, verify, createSign, createVerify, and createECDH" }, { "id": "node-builtin.crypto.getRandomValues", @@ -658,7 +646,7 @@ "name": "crypto.privateDecrypt", "status": "unsupported", "code": "SC2020", - "note": "asymmetric-key operations need a public-key stack (bignum, RSA/EC/EdDSA math) and public and private KeyObjects — neither exists in the static runtime, so no faithful lowering can be small; the lowered crypto surface is hashing, randomness, secret KeyObjects, and the introspection statics" + "note": "Diffie-Hellman and RSA encryption have no lowering — the asymmetric crypto surface is RSA and EC KeyObjects (generateKeyPair, createPrivateKey, createPublicKey), sign, verify, createSign, createVerify, and createECDH" }, { "id": "node-builtin.crypto.privateEncrypt", @@ -666,7 +654,7 @@ "name": "crypto.privateEncrypt", "status": "unsupported", "code": "SC2020", - "note": "asymmetric-key operations need a public-key stack (bignum, RSA/EC/EdDSA math) and public and private KeyObjects — neither exists in the static runtime, so no faithful lowering can be small; the lowered crypto surface is hashing, randomness, secret KeyObjects, and the introspection statics" + "note": "Diffie-Hellman and RSA encryption have no lowering — the asymmetric crypto surface is RSA and EC KeyObjects (generateKeyPair, createPrivateKey, createPublicKey), sign, verify, createSign, createVerify, and createECDH" }, { "id": "node-builtin.crypto.publicDecrypt", @@ -674,7 +662,7 @@ "name": "crypto.publicDecrypt", "status": "unsupported", "code": "SC2020", - "note": "asymmetric-key operations need a public-key stack (bignum, RSA/EC/EdDSA math) and public and private KeyObjects — neither exists in the static runtime, so no faithful lowering can be small; the lowered crypto surface is hashing, randomness, secret KeyObjects, and the introspection statics" + "note": "Diffie-Hellman and RSA encryption have no lowering — the asymmetric crypto surface is RSA and EC KeyObjects (generateKeyPair, createPrivateKey, createPublicKey), sign, verify, createSign, createVerify, and createECDH" }, { "id": "node-builtin.crypto.publicEncrypt", @@ -682,7 +670,7 @@ "name": "crypto.publicEncrypt", "status": "unsupported", "code": "SC2020", - "note": "asymmetric-key operations need a public-key stack (bignum, RSA/EC/EdDSA math) and public and private KeyObjects — neither exists in the static runtime, so no faithful lowering can be small; the lowered crypto surface is hashing, randomness, secret KeyObjects, and the introspection statics" + "note": "Diffie-Hellman and RSA encryption have no lowering — the asymmetric crypto surface is RSA and EC KeyObjects (generateKeyPair, createPrivateKey, createPublicKey), sign, verify, createSign, createVerify, and createECDH" }, { "id": "node-builtin.crypto.randomBytes", @@ -744,9 +732,7 @@ "id": "node-builtin.crypto.sign", "kind": "node-builtin", "name": "crypto.sign", - "status": "unsupported", - "code": "SC2020", - "note": "asymmetric-key operations need a public-key stack (bignum, RSA/EC/EdDSA math) and public and private KeyObjects — neither exists in the static runtime, so no faithful lowering can be small; the lowered crypto surface is hashing, randomness, secret KeyObjects, and the introspection statics" + "status": "static" }, { "id": "node-builtin.crypto.timingSafeEqual", @@ -758,9 +744,7 @@ "id": "node-builtin.crypto.verify", "kind": "node-builtin", "name": "crypto.verify", - "status": "unsupported", - "code": "SC2020", - "note": "asymmetric-key operations need a public-key stack (bignum, RSA/EC/EdDSA math) and public and private KeyObjects — neither exists in the static runtime, so no faithful lowering can be small; the lowered crypto surface is hashing, randomness, secret KeyObjects, and the introspection statics" + "status": "static" }, { "id": "node-builtin.crypto.webcrypto", @@ -5726,7 +5710,7 @@ "kind": "stdlib", "name": "globalThis.crypto.subtle", "status": "static", - "note": "importKey('raw') for HMAC keys, HMAC sign and verify, and SHA-1/SHA-2 digest; other methods, algorithms and key formats are refused" + "note": "importKey('raw') for HMAC keys, HMAC sign and verify, generateKey, importKey, exportKey, sign and verify for ECDSA, Ed25519, RSASSA-PKCS1-v1_5 and RSA-PSS, and SHA-1/SHA-2 digest; other methods, algorithms and key formats are refused" }, { "id": "syntax.async-generators", diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7080-crypto-ed25519.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7080-crypto-ed25519.mjs.json new file mode 100644 index 000000000..035d9d765 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7080-crypto-ed25519.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7080-crypto-ed25519.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7081-webcrypto-ed25519.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7081-webcrypto-ed25519.mjs.json new file mode 100644 index 000000000..bbd2d1ebc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7081-webcrypto-ed25519.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7081-webcrypto-ed25519.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7082-crypto-key-objects.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7082-crypto-key-objects.ts.json new file mode 100644 index 000000000..c2e50cc97 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7082-crypto-key-objects.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7082-crypto-key-objects.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7083-crypto-sign-verify.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7083-crypto-sign-verify.ts.json new file mode 100644 index 000000000..385c9347c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7083-crypto-sign-verify.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7083-crypto-sign-verify.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7084-crypto-key-pairs.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7084-crypto-key-pairs.cjs.json new file mode 100644 index 000000000..e1ac90536 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7084-crypto-key-pairs.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7084-crypto-key-pairs.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7085-webcrypto-ecdsa-rsa.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7085-webcrypto-ecdsa-rsa.ts.json new file mode 100644 index 000000000..3fc5406e8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7085-webcrypto-ecdsa-rsa.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7085-webcrypto-ecdsa-rsa.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7086-webcrypto-ecdsa-rsa-errors.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7086-webcrypto-ecdsa-rsa-errors.mjs.json new file mode 100644 index 000000000..ef44f9180 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7086-webcrypto-ecdsa-rsa-errors.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7086-webcrypto-ecdsa-rsa-errors.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/keys.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/keys.ts.json new file mode 100644 index 000000000..b0b79568d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/keys.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/node-types/keys.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/webcrypto-ecdsa.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/webcrypto-ecdsa.ts.json new file mode 100644 index 000000000..2c4a3b15b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/webcrypto-ecdsa.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/node-types/webcrypto-ecdsa.ts" + ], + "diags": [] +} diff --git a/packages/runtime-darwin-arm64/runtime-pack-matrix.mjs b/packages/runtime-darwin-arm64/runtime-pack-matrix.mjs index db72284f6..5549b0db9 100644 --- a/packages/runtime-darwin-arm64/runtime-pack-matrix.mjs +++ b/packages/runtime-darwin-arm64/runtime-pack-matrix.mjs @@ -43,7 +43,7 @@ export const RUNTIME_PACK_MATRIX = withLibraryRuntimeFlavors( { id: "quickjs", predicate: false }, { id: "libregexp", predicate: "regex" }, { id: "zlib", predicate: "zlibEffective" }, - { id: "mbedtls", predicate: any("tlsEffective", "cipher", "ecdh") }, + { id: "mbedtls", predicate: any("tlsEffective", "cipher", "ecdh", "pki") }, ], system_libraries: [{ name: "System", predicate: true }], }), diff --git a/packages/runtime-darwin-arm64/scripts/build.mjs b/packages/runtime-darwin-arm64/scripts/build.mjs index 85c5ffb00..9e74b48c6 100644 --- a/packages/runtime-darwin-arm64/scripts/build.mjs +++ b/packages/runtime-darwin-arm64/scripts/build.mjs @@ -172,7 +172,8 @@ async function build() { ...(unit.source === "scr_regex.c" ? ["-I", quickjs] : []), ...(unit.source === "scr_tls.c" || unit.source === "scr_cipher.c" || - unit.source === "scr_ecdh.c" + unit.source === "scr_ecdh.c" || + unit.source === "scr_pki.c" ? ["-I", join(mbedtls, "include")] : []), ...(unit.source === "scr_zlib.c" || unit.source === "scr_fetch.c" diff --git a/packages/runtime-pack-common/runtime-pack-matrix.mjs b/packages/runtime-pack-common/runtime-pack-matrix.mjs index 0f40218a1..0039662bf 100644 --- a/packages/runtime-pack-common/runtime-pack-matrix.mjs +++ b/packages/runtime-pack-common/runtime-pack-matrix.mjs @@ -149,8 +149,11 @@ export const OPTIONAL_RUNTIME_SOURCES = [ ["scr_tls.c", "tlsEffective"], ["scr_cipher.c", "cipher"], ["scr_ecdh.c", "ecdh"], + ["scr_pki.c", "pki"], ["scr_wasm.c", "wasm"], ["scr_webcrypto.c", "webcrypto"], + ["scr_webcrypto_pki.c", all("webcrypto", "pki")], + ["scr_ed25519.c", all("pki", "ed25519")], ["scr_fetch.c", "nativeFetch"], ]; @@ -212,7 +215,7 @@ export function createRuntimePackMatrix({ { id: "quickjs", predicate: false }, { id: "libregexp", predicate: "regex" }, { id: "zlib", predicate: "zlibEffective" }, - { id: "mbedtls", predicate: any("tlsEffective", "cipher", "ecdh") }, + { id: "mbedtls", predicate: any("tlsEffective", "cipher", "ecdh", "pki") }, ]; const matrix = withLibraryRuntimeFlavors( withWorkerRuntimeVariants({ diff --git a/packages/runtime-pack-common/scripts/build.mjs b/packages/runtime-pack-common/scripts/build.mjs index b242b78aa..3b43f3b83 100644 --- a/packages/runtime-pack-common/scripts/build.mjs +++ b/packages/runtime-pack-common/scripts/build.mjs @@ -223,7 +223,8 @@ async function build() { ...(unit.source === "scr_regex.c" ? ["-I", quickjs] : []), ...(unit.source === "scr_tls.c" || unit.source === "scr_cipher.c" || - unit.source === "scr_ecdh.c" + unit.source === "scr_ecdh.c" || + unit.source === "scr_pki.c" ? ["-I", join(mbedtls, "include")] : []), ...(unit.source === "scr_zlib.c" || unit.source === "scr_fetch.c" diff --git a/packages/runtime-wasm32-wasi/scripts/build.mjs b/packages/runtime-wasm32-wasi/scripts/build.mjs index 2dd983973..7c8bc4652 100644 --- a/packages/runtime-wasm32-wasi/scripts/build.mjs +++ b/packages/runtime-wasm32-wasi/scripts/build.mjs @@ -22,6 +22,9 @@ process.env.SCRIPTC_RUNTIME_PACK_CONFIG = JSON.stringify({ "scr_tls.c", "scr_cipher.c", "scr_ecdh.c", + "scr_pki.c", + "scr_webcrypto_pki.c", + "scr_ed25519.c", "scr_wasm.c", "scr_fetch.c", ], diff --git a/packages/runtime/src/scr_crypto.h b/packages/runtime/src/scr_crypto.h index d12858abf..29695e5cc 100644 --- a/packages/runtime/src/scr_crypto.h +++ b/packages/runtime/src/scr_crypto.h @@ -82,6 +82,10 @@ ScrDyn *scr_crypto_create_secret_key(ScrDyn *key, ScrDyn *encoding); ScrDyn *scr_crypto_generate_key_sync(ScrDyn *type, ScrDyn *options); ScrBytes *scr_crypto_key_object_input(ScrDyn *key); bool scr_crypto_is_key_object(const ScrDyn *value); +/* Throws Node's ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE for a private or public + * KeyObject used as a secret key. scr_pki.c, which makes those keys, + * installs it with them, so its messages stay out of other programs. */ +extern void (*scr_crypto_reject_asymmetric_secret)(const ScrDyn *key); const unsigned char *scr_key_object_bytes(const ScrDyn *value, size_t *len); /* crypto.createCipheriv (decrypt false) and crypto.createDecipheriv * (decrypt true) over checked-dynamic arguments (scr_cipher.c, linked @@ -212,6 +216,8 @@ size_t scr_crypto_hmac_raw(const char *alg, const unsigned char *key, size_t key * verify with a boolean on a later loop turn. scr_webcrypto_is_crypto_key * answers `value instanceof CryptoKey`. */ ScrPromise *scr_webcrypto_import_key(ScrDyn *args); +ScrPromise *scr_webcrypto_generate_key(ScrDyn *args); +ScrPromise *scr_webcrypto_export_key(ScrDyn *args); ScrPromise *scr_webcrypto_sign(ScrDyn *args); ScrPromise *scr_webcrypto_verify(ScrDyn *args); ScrPromise *scr_webcrypto_digest(ScrDyn *args); @@ -229,5 +235,17 @@ ScrStr *scr_crypto_x509_valid_from(ScrBytes *data); ScrStr *scr_crypto_x509_valid_from_str(ScrStr *pem); ScrStr *scr_crypto_x509_valid_to(ScrBytes *data); ScrStr *scr_crypto_x509_valid_to_str(ScrStr *pem); +/* Asymmetric keys and signatures (scr_pki.c, the pki unit). Arguments + * borrowed; results +1, or NULL with the error pending. */ +ScrDyn *scr_crypto_create_private_key(ScrDyn *key); +ScrDyn *scr_crypto_create_public_key(ScrDyn *key); +ScrDyn *scr_crypto_generate_key_pair_sync(ScrDyn *type, ScrDyn *options); +void scr_crypto_generate_key_pair_async(ScrDyn *type, ScrDyn *options, ScrDyn *callback); +ScrDyn *scr_crypto_sign_oneshot(ScrDyn *algorithm, ScrDyn *data, ScrDyn *key); +ScrDyn *scr_crypto_verify_oneshot(ScrDyn *algorithm, ScrDyn *data, ScrDyn *key, ScrDyn *signature); +ScrDyn *scr_crypto_create_sign(ScrDyn *algorithm); +ScrDyn *scr_crypto_create_verify(ScrDyn *algorithm); +bool scr_crypto_is_asymmetric_key(const ScrDyn *value); +const char *scr_crypto_asymmetric_key_type(const ScrDyn *value); #endif /* SCR_CRYPTO_H */ diff --git a/packages/runtime/src/scr_dyn.h b/packages/runtime/src/scr_dyn.h index 02c4d828f..b2615b57e 100644 --- a/packages/runtime/src/scr_dyn.h +++ b/packages/runtime/src/scr_dyn.h @@ -158,6 +158,11 @@ typedef enum { X(DIR, 44) /* fs.Dir (scr_lib.c) */ \ X(DISPOSABLE_STACK, 49) /* DisposableStack (scr_symbol.c) */ \ X(ECDH, 64) /* node:crypto ECDH (scr_ecdh.c) */ \ + X(PRIVATE_KEY, 65) /* node:crypto PrivateKeyObject (scr_pki.c) */ \ + X(PUBLIC_KEY, 66) /* node:crypto PublicKeyObject (scr_pki.c) */ \ + X(SIGN, 67) /* node:crypto Sign (scr_pki.c) */ \ + X(VERIFY, 68) /* node:crypto Verify (scr_pki.c) */ \ + X(ASYMMETRIC_CRYPTO_KEY, 69) /* WebCrypto ECDSA and RSA CryptoKey (scr_webcrypto_pki.c) */ \ X(EVENT, 14) /* ScrEvent — new Event() and AbortSignal's abort events */ \ X(EVENT_TARGET, 39) /* ScrEventTarget — new EventTarget() */ \ X(FETCH_HEADERS, 13) /* native static-fetch response Headers */ \ diff --git a/packages/runtime/src/scr_ed25519.c b/packages/runtime/src/scr_ed25519.c new file mode 100644 index 000000000..c6d6ce370 --- /dev/null +++ b/packages/runtime/src/scr_ed25519.c @@ -0,0 +1,76 @@ +/* Ed25519 for scr_pki.c: libsodium's ref10 implementation (vendored, see + * ../vendor/README.md), textually included so it builds as this one unit. + * It links only into programs that name Ed25519 (the ed25519 runtime + * feature) and installs itself into scr_pki.c at startup; without it, + * Ed25519 signing, verification and public-key derivation throw a coded + * SC2020 error. + * + * Signing runs in constant time. Verification rejects a non-canonical S + * and the small-order R and public-key encodings, then checks the + * cofactorless equation, which is what Node 24 answers. */ +#include "scr_runtime.h" + +#include +#include +#include +#include + +#include "scr_pki.h" + +#define CONFIGURED 1 +#include "../vendor/libsodium/ed25519_ref10.c" +#include "../vendor/libsodium/hash_sha512_cp.c" +#include "../vendor/libsodium/verify.c" +#include "../vendor/libsodium/sign.c" +#include "../vendor/libsodium/open.c" +#include "../vendor/libsodium/keypair.c" +#undef CONFIGURED + +/* The libsodium utilities those units call. */ +void sodium_memzero(void *const pnt, const size_t len) { + volatile unsigned char *p = (volatile unsigned char *)pnt; + for (size_t i = 0; i < len; i++) p[i] = 0U; +} + +int sodium_memcmp(const void *const b1_, const void *const b2_, size_t len) { + const volatile unsigned char *b1 = (const volatile unsigned char *)b1_; + const volatile unsigned char *b2 = (const volatile unsigned char *)b2_; + volatile unsigned char d = 0U; + for (size_t i = 0; i < len; i++) d |= b1[i] ^ b2[i]; + return (1 & ((d - 1) >> 8)) - 1; +} + +int sodium_is_zero(const unsigned char *n, const size_t nlen) { + volatile unsigned char d = 0U; + for (size_t i = 0; i < nlen; i++) d |= n[i]; + return 1 & ((d - 1) >> 8); +} + +void randombytes_buf(void *const buf, const size_t size) { arc4random_buf(buf, size); } + +static void se_public_key(uint8_t pub[32], const uint8_t seed[32]) { + uint8_t sk[64]; + crypto_sign_ed25519_seed_keypair(pub, sk, seed); + sodium_memzero(sk, sizeof sk); +} + +static void se_sign(uint8_t sig[64], const uint8_t seed[32], const uint8_t pub[32], const uint8_t *m, + size_t n) { + uint8_t sk[64]; + memcpy(sk, seed, 32); + memcpy(sk + 32, pub, 32); + crypto_sign_ed25519_detached(sig, NULL, m, n, sk); + sodium_memzero(sk, sizeof sk); +} + +static bool se_verify(const uint8_t pub[32], const uint8_t *m, size_t n, const uint8_t sig[64]) { + return crypto_sign_ed25519_verify_detached(sig, m, n, pub) == 0; +} + +static const ScrPkiEd25519 se_table = { + .public_key = se_public_key, + .sign = se_sign, + .verify = se_verify, +}; + +__attribute__((constructor)) static void se_install(void) { scr_pki_ed25519 = &se_table; } diff --git a/packages/runtime/src/scr_lib.c b/packages/runtime/src/scr_lib.c index ee4c34592..094ec36af 100644 --- a/packages/runtime/src/scr_lib.c +++ b/packages/runtime/src/scr_lib.c @@ -9225,6 +9225,10 @@ ScrCryptoHash *scr_crypto_hmac_new_dyn(ScrStr *alg, ScrDyn *key, ScrDyn *options if (key_object) { bytes = scr_bytes_new(SCR_BYTES_U8, (double)key_object_len); if (key_object_len) memcpy(bytes->data, key_object, key_object_len); + } else if (scr_crypto_is_key_object(key)) { + /* A private or public KeyObject: scr_pki.c reports Node's error. */ + scr_crypto_reject_asymmetric_secret(key); + return NULL; } else if (key->kind == SCR_DYN_STR) { ScrStr *utf8 = encoding ? NULL : scr_str_new("utf8", 4); bytes = scr_bytes_from_str_checked(key->v.str, encoding ? encoding : utf8); @@ -9856,9 +9860,15 @@ const unsigned char *scr_key_object_bytes(const ScrDyn *value, size_t *len) { return key->data; } -/* `value instanceof KeyObject`. */ +void (*scr_crypto_reject_asymmetric_secret)(const ScrDyn *key) = NULL; + +/* `value instanceof KeyObject`: a secret key, or a private or public key + * (scr_pki.c, matched by its handle tags so this unit does not link it). */ bool scr_crypto_is_key_object(const ScrDyn *value) { size_t len; + if (value->kind == SCR_DYN_HANDLE && + (value->v.handle.tag == SCR_DYNH_PRIVATE_KEY || value->v.handle.tag == SCR_DYNH_PUBLIC_KEY)) + return true; return scr_key_object_bytes(value, &len) != NULL; } diff --git a/packages/runtime/src/scr_pki.c b/packages/runtime/src/scr_pki.c new file mode 100644 index 000000000..1b102fd22 --- /dev/null +++ b/packages/runtime/src/scr_pki.c @@ -0,0 +1,2118 @@ +/* node:crypto asymmetric keys and signatures over the vendored mbedTLS + * public-key layer: createPrivateKey, createPublicKey, generateKeyPairSync + * and generateKeyPair for "rsa", "ec" and "ed25519" keys, the + * PrivateKeyObject and PublicKeyObject handles (type, asymmetricKeyType, + * asymmetricKeyDetails, export(), equals()), crypto.sign and crypto.verify, + * and the Sign and Verify objects of createSign and createVerify. Keys read + * and write PEM and DER as PKCS#1, SEC1, PKCS#8 and SubjectPublicKeyInfo, + * and JWK; the EC curves are prime256v1, secp384r1, secp521r1 and + * secp256k1, and the Ed25519 arithmetic is scr_ed25519.c. Argument checks + * and errors follow Node 24's lib/internal/crypto/keys.js, keygen.js and + * sig.js. Encrypted keys and other key types throw a coded SC2020 error. + * All arguments are borrowed. */ +#include "scr_runtime.h" + +#include +#include +#include + +#include "mbedtls/asn1.h" +#include "mbedtls/asn1write.h" +#include "mbedtls/base64.h" +#include "mbedtls/bignum.h" +#include "mbedtls/ecdsa.h" +#include "mbedtls/ecp.h" +#include "mbedtls/md.h" +#include "mbedtls/oid.h" +#include "mbedtls/pk.h" +#include "mbedtls/platform_util.h" +#include "mbedtls/rsa.h" +#include "mbedtls/x509_crt.h" + +#include "scr_pki.h" + +/* ── errors ───────────────────────────────────────────────────────────── */ + +static void sp_throw(int kind, const char *code, const char *message) { + scr_throw_error_msg_code(kind, message, strlen(message), code); +} + +/* ERR_INVALID_ARG_VALUE for an option ("The property 'options.type' is + * invalid. Received 'spki'"). */ +static void sp_property_invalid(const char *name, const ScrDyn *got) { + char lite[96]; + char message[256]; + int n = snprintf(message, sizeof message, "The property '%s' is invalid. Received %s", name, + scr_dyn_inspect_lite(got, lite, sizeof lite)); + scr_throw_error_msg_code(SCR_ERR_TYPE, message, (size_t)n, "ERR_INVALID_ARG_VALUE"); +} + +static void sp_unsupported_input(void) { + sp_throw(SCR_ERR_ERROR, "ERR_OSSL_UNSUPPORTED", "error:1E08010C:DECODER routines::unsupported"); +} + +/* The coded refusal for a form this runtime does not implement. */ +static void sp_not_supported(const char *what) { + char message[256]; + int n = snprintf(message, sizeof message, + "'%s' is part of the standard library types but has no scriptc lowering yet", what); + scr_throw_error_msg_code(SCR_ERR_ERROR, message, (size_t)n, "SC2020"); +} + +static int sp_random(void *state, unsigned char *out, size_t len) { + (void)state; + arc4random_buf(out, len); + return 0; +} + +/* ── Ed25519 ────────────────────────────────────────────────────────── + * The arithmetic is scr_ed25519.c, which links only into programs that + * name Ed25519 and installs itself here at startup. Keys are the 32-byte + * seed and the 32-byte encoded public point. */ +const ScrPkiEd25519 *scr_pki_ed25519 = NULL; + +/* The Ed25519 arithmetic, or NULL with a coded SC2020 error pending. */ +static const ScrPkiEd25519 *sp_ed(void) { + if (!scr_pki_ed25519) + sp_throw(SCR_ERR_ERROR, "SC2020", + "Ed25519 keys are supported when a string literal in the program names 'ed25519'"); + return scr_pki_ed25519; +} + +bool scr_pki_ed25519_ready(void) { return sp_ed() != NULL; } + +static bool sp_ed_verify(const ScrPkiEd25519 *ed, const uint8_t pub[32], const uint8_t *m, size_t n, + const uint8_t *sig, size_t sig_len) { + return sig_len == 64 && ed->verify(pub, m, n, sig); +} + +/* ── option bags ──────────────────────────────────────────────────────── */ + +static bool sp_is_object(const ScrDyn *v) { return v != NULL && v->kind == SCR_DYN_OBJ; } + +/* A statically typed object argument (a record or class instance) as a + * plain object: +1, or NULL with the error pending. Other values are + * retained as they are. */ +static ScrDyn *sp_plain(const ScrDyn *v) { + if (v != NULL && v->kind == SCR_DYN_TYPED_REF) return scr_dyn_typed_ref_materialize(v); + return scr_dyn_retain((ScrDyn *)(v ? v : scr_dyn_undefined())); +} + +/* A borrowed option, or the undefined singleton. */ +static const ScrDyn *sp_opt(const ScrDyn *obj, const char *key) { + const ScrDyn *v = sp_is_object(obj) ? scr_dyn_obj_get(obj, key, strlen(key)) : NULL; + return v ? v : scr_dyn_undefined(); +} + +static bool sp_is_str(const ScrDyn *v, const char *text) { + size_t n = strlen(text); + return v->kind == SCR_DYN_STR && v->v.str->len == n && memcmp(v->v.str->data, text, n) == 0; +} + +static bool sp_absent(const ScrDyn *v) { return v->kind == SCR_DYN_UNDEF; } + +/* ── keys ─────────────────────────────────────────────────────────────── */ + +typedef struct SpKey { + size_t rc; + mbedtls_pk_context pk; /* RSA and EC keys */ + bool private_key; + bool ed25519; /* an Ed25519 key: ed_seed (private keys) and ed_pub */ + uint8_t ed_seed[32]; + uint8_t ed_pub[32]; +} SpKey; + +static void *sp_key_retain(void *h) { + SpKey *k = h; + if (k->rc != SIZE_MAX) k->rc++; + return h; +} + +static void sp_key_release(void *h) { + SpKey *k = h; + if (!k || k->rc == SIZE_MAX || --k->rc != 0) return; + mbedtls_pk_free(&k->pk); + mbedtls_platform_zeroize(k, sizeof *k); + free(k); +} + +static SpKey *sp_key_alloc(bool private_key) { + SpKey *k = calloc(1, sizeof *k); + if (!k) scr_trap("scriptc: out of memory\n"); + k->rc = 1; + k->private_key = private_key; + mbedtls_pk_init(&k->pk); + return k; +} + +static void sp_key_install(void); + +/* Boxes the key (consuming the caller's reference). */ +static ScrDyn *sp_key_box(SpKey *k) { + sp_key_install(); + ScrDyn *box = scr_dyn_new_handle(k, k->private_key ? SCR_DYNH_PRIVATE_KEY : SCR_DYNH_PUBLIC_KEY); + sp_key_release(k); + return box; +} + +static SpKey *sp_key_of(const ScrDyn *v) { + if (v == NULL || v->kind != SCR_DYN_HANDLE) return NULL; + if (v->v.handle.tag != SCR_DYNH_PRIVATE_KEY && v->v.handle.tag != SCR_DYNH_PUBLIC_KEY) return NULL; + return v->v.handle.ptr; +} + +bool scr_crypto_is_asymmetric_key(const ScrDyn *value) { return sp_key_of(value) != NULL; } + +/* The type getter of a KeyObject value: "private", "public", or NULL for + * anything else. */ +const char *scr_crypto_asymmetric_key_type(const ScrDyn *value) { + SpKey *k = sp_key_of(value); + return k ? (k->private_key ? "private" : "public") : NULL; +} + +static bool sp_is_rsa(const SpKey *k) { return mbedtls_pk_get_type(&k->pk) == MBEDTLS_PK_RSA; } + +static bool sp_is_ec(const SpKey *k) { return mbedtls_pk_get_type(&k->pk) == MBEDTLS_PK_ECKEY; } + +static bool sp_is_ed(const SpKey *k) { return k->ed25519; } + +typedef struct { + const char *name; /* OpenSSL short name (namedCurve) */ + const char *nist; /* EC_curve_nist2nid alias, or NULL */ + const char *jwk; /* JWK crv */ + mbedtls_ecp_group_id id; +} SpCurve; + +static const SpCurve sp_curves[] = { + {"prime256v1", "P-256", "P-256", MBEDTLS_ECP_DP_SECP256R1}, + {"secp384r1", "P-384", "P-384", MBEDTLS_ECP_DP_SECP384R1}, + {"secp521r1", "P-521", "P-521", MBEDTLS_ECP_DP_SECP521R1}, + {"secp256k1", NULL, "secp256k1", MBEDTLS_ECP_DP_SECP256K1}, +}; + +static const SpCurve *sp_curve_by_id(mbedtls_ecp_group_id id) { + for (size_t i = 0; i < sizeof sp_curves / sizeof sp_curves[0]; i++) + if (sp_curves[i].id == id) return &sp_curves[i]; + return NULL; +} + +static const SpCurve *sp_curve_of(const SpKey *k) { + return sp_is_ec(k) ? sp_curve_by_id(mbedtls_pk_ec(k->pk)->MBEDTLS_PRIVATE(grp).id) : NULL; +} + +/* A parsed key is usable when it is RSA or EC on a curve above. */ +static bool sp_key_supported(const SpKey *k) { + return sp_is_ed(k) || sp_is_rsa(k) || (sp_is_ec(k) && sp_curve_of(k) != NULL); +} + +/* ── DER writing ──────────────────────────────────────────────────────── */ + +/* mbedtls writes DER backwards into the end of a buffer; these helpers + * answer the written length or a negative error. */ +#define SP_DER_MAX 8192 + +static int sp_write_private_der(SpKey *k, unsigned char *buf, size_t size) { + return mbedtls_pk_write_key_der(&k->pk, buf, size); +} + +/* Ed25519's PKCS#8 and SubjectPublicKeyInfo prefixes (RFC 8410): the + * 32-byte seed or public key follows. */ +static const uint8_t sp_ed_pkcs8_prefix[16] = {0x30, 0x2e, 0x02, 0x01, 0x00, 0x30, 0x05, 0x06, + 0x03, 0x2b, 0x65, 0x70, 0x04, 0x22, 0x04, 0x20}; +static const uint8_t sp_ed_spki_prefix[12] = {0x30, 0x2a, 0x30, 0x05, 0x06, 0x03, + 0x2b, 0x65, 0x70, 0x03, 0x21, 0x00}; + +/* Writes prefix || 32 bytes at the end of buf, as the mbedtls writers do. */ +static int sp_write_ed_der(const uint8_t *prefix, size_t prefix_len, const uint8_t key[32], + unsigned char *buf, size_t size) { + size_t n = prefix_len + 32; + if (size < n) return MBEDTLS_ERR_ASN1_BUF_TOO_SMALL; + memcpy(buf + size - n, prefix, prefix_len); + memcpy(buf + size - 32, key, 32); + return (int)n; +} + +static int sp_write_spki_der(SpKey *k, unsigned char *buf, size_t size) { + if (sp_is_ed(k)) return sp_write_ed_der(sp_ed_spki_prefix, sizeof sp_ed_spki_prefix, k->ed_pub, buf, size); + return mbedtls_pk_write_pubkey_der(&k->pk, buf, size); +} + +/* RSAPublicKey (PKCS#1) DER. */ +static int sp_write_pkcs1_public_der(SpKey *k, unsigned char *buf, size_t size) { + unsigned char *p = buf + size; + return mbedtls_pk_write_pubkey(&p, buf, &k->pk); +} + +/* PKCS#8 PrivateKeyInfo around the PKCS#1 or SEC1 key, as OpenSSL writes + * it: version 0, the AlgorithmIdentifier (rsaEncryption with NULL + * parameters, or id-ecPublicKey with the curve OID), and the inner key, + * which for EC omits the parameters field. */ +static int sp_write_pkcs8_der(SpKey *k, unsigned char *buf, size_t size) { + if (sp_is_ed(k)) + return sp_write_ed_der(sp_ed_pkcs8_prefix, sizeof sp_ed_pkcs8_prefix, k->ed_seed, buf, size); + unsigned char inner[SP_DER_MAX]; + size_t inner_len; + if (sp_is_rsa(k)) { + int n = sp_write_private_der(k, inner, sizeof inner); + if (n < 0) return n; + inner_len = (size_t)n; + memmove(inner, inner + sizeof inner - inner_len, inner_len); + } else { + /* ECPrivateKey ::= SEQUENCE { version 1, privateKey OCTET STRING, + * [1] publicKey BIT STRING } */ + const mbedtls_ecp_keypair *ec = mbedtls_pk_ec(k->pk); + unsigned char *c = inner + sizeof inner; + size_t len = 0; + int r; + unsigned char point[160]; + size_t point_len; + if ((r = mbedtls_ecp_point_write_binary(&ec->MBEDTLS_PRIVATE(grp), &ec->MBEDTLS_PRIVATE(Q), + MBEDTLS_ECP_PF_UNCOMPRESSED, &point_len, point, + sizeof point)) != 0) + return r; + size_t pub_len = 0; + if ((r = mbedtls_asn1_write_bitstring(&c, inner, point, point_len * 8)) < 0) return r; + pub_len += (size_t)r; + if ((r = mbedtls_asn1_write_len(&c, inner, pub_len)) < 0) return r; + pub_len += (size_t)r; + if ((r = mbedtls_asn1_write_tag(&c, inner, MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 1)) < 0) + return r; + pub_len += (size_t)r; + len += pub_len; + size_t d_len = (ec->MBEDTLS_PRIVATE(grp).nbits + 7) / 8; + unsigned char d[72]; + if ((r = mbedtls_mpi_write_binary(&ec->MBEDTLS_PRIVATE(d), d, d_len)) != 0) return r; + if ((r = mbedtls_asn1_write_octet_string(&c, inner, d, d_len)) < 0) return r; + len += (size_t)r; + mbedtls_platform_zeroize(d, sizeof d); + if ((r = mbedtls_asn1_write_int(&c, inner, 1)) < 0) return r; + len += (size_t)r; + if ((r = mbedtls_asn1_write_len(&c, inner, len)) < 0) return r; + len += (size_t)r; + if ((r = mbedtls_asn1_write_tag(&c, inner, MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE)) < 0) + return r; + len += (size_t)r; + inner_len = len; + memmove(inner, c, inner_len); + } + unsigned char *c = buf + size; + size_t len = 0; + int r; + if ((r = mbedtls_asn1_write_octet_string(&c, buf, inner, inner_len)) < 0) goto done; + len += (size_t)r; + { + const char *oid; + size_t oid_len; + size_t alg_len = 0; + if (sp_is_rsa(k)) { + if ((r = mbedtls_asn1_write_null(&c, buf)) < 0) goto done; + alg_len += (size_t)r; + oid = MBEDTLS_OID_PKCS1_RSA; + oid_len = MBEDTLS_OID_SIZE(MBEDTLS_OID_PKCS1_RSA); + } else { + const char *curve_oid; + size_t curve_oid_len; + if ((r = mbedtls_oid_get_oid_by_ec_grp(mbedtls_pk_ec(k->pk)->MBEDTLS_PRIVATE(grp).id, &curve_oid, + &curve_oid_len)) != 0) + goto done; + if ((r = mbedtls_asn1_write_oid(&c, buf, curve_oid, curve_oid_len)) < 0) goto done; + alg_len += (size_t)r; + oid = MBEDTLS_OID_EC_ALG_UNRESTRICTED; + oid_len = MBEDTLS_OID_SIZE(MBEDTLS_OID_EC_ALG_UNRESTRICTED); + } + if ((r = mbedtls_asn1_write_oid(&c, buf, oid, oid_len)) < 0) goto done; + alg_len += (size_t)r; + if ((r = mbedtls_asn1_write_len(&c, buf, alg_len)) < 0) goto done; + alg_len += (size_t)r; + if ((r = mbedtls_asn1_write_tag(&c, buf, MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE)) < 0) + goto done; + alg_len += (size_t)r; + len += alg_len; + } + if ((r = mbedtls_asn1_write_int(&c, buf, 0)) < 0) goto done; + len += (size_t)r; + if ((r = mbedtls_asn1_write_len(&c, buf, len)) < 0) goto done; + len += (size_t)r; + if ((r = mbedtls_asn1_write_tag(&c, buf, MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE)) < 0) + goto done; + len += (size_t)r; + r = (int)len; +done: + mbedtls_platform_zeroize(inner, sizeof inner); + return r; +} + +/* PEM armor with 64-character base64 lines and a final newline. */ +static ScrStr *sp_pem(const char *label, const unsigned char *der, size_t len) { + size_t b64_len = 0; + mbedtls_base64_encode(NULL, 0, &b64_len, der, len); + unsigned char *b64 = malloc(b64_len + 1); + char *out = malloc(b64_len + b64_len / 64 + 2 * strlen(label) + 64); + if (!b64 || !out) scr_trap("scriptc: out of memory\n"); + mbedtls_base64_encode(b64, b64_len + 1, &b64_len, der, len); + size_t o = (size_t)sprintf(out, "-----BEGIN %s-----\n", label); + for (size_t i = 0; i < b64_len; i += 64) { + size_t n = b64_len - i < 64 ? b64_len - i : 64; + memcpy(out + o, b64 + i, n); + o += n; + out[o++] = '\n'; + } + o += (size_t)sprintf(out + o, "-----END %s-----\n", label); + ScrStr *s = scr_str_new(out, o); + mbedtls_platform_zeroize(b64, b64_len); + mbedtls_platform_zeroize(out, o); + free(b64); + free(out); + return s; +} + +static ScrDyn *sp_dyn_buffer(const unsigned char *data, size_t len) { + ScrBytes *bytes = scr_bytes_new(SCR_BYTES_U8, (double)len); + bytes->is_buffer = true; + if (len) memcpy(bytes->data, data, len); + ScrDyn *d = scr_dyn_new_buffer(bytes); + scr_bytes_release(bytes); + return d; +} + +static ScrDyn *sp_dyn_str(ScrStr *s) { + ScrDyn *d = scr_dyn_new_str(s); + scr_str_release(s); + return d; +} + +/* ── JWK ──────────────────────────────────────────────────────────────── */ + +/* base64url without padding of the big-endian integer `x` in `len` bytes + * (0 = its minimal length). */ +static ScrDyn *sp_jwk_int(const mbedtls_mpi *x, size_t len) { + if (len == 0) len = mbedtls_mpi_size(x); + if (len == 0) len = 1; + unsigned char *raw = malloc(len); + size_t b64_len = 0; + if (!raw) scr_trap("scriptc: out of memory\n"); + mbedtls_mpi_write_binary(x, raw, len); + mbedtls_base64_encode(NULL, 0, &b64_len, raw, len); + unsigned char *b64 = malloc(b64_len + 1); + if (!b64) scr_trap("scriptc: out of memory\n"); + mbedtls_base64_encode(b64, b64_len + 1, &b64_len, raw, len); + size_t o = 0; + for (size_t i = 0; i < b64_len; i++) { + unsigned char c = b64[i]; + if (c == '=') break; + b64[o++] = c == '+' ? '-' : c == '/' ? '_' : c; + } + ScrDyn *d = sp_dyn_str(scr_str_new((const char *)b64, o)); + mbedtls_platform_zeroize(raw, len); + free(raw); + free(b64); + return d; +} + +static void sp_set(ScrDyn *obj, const char *key, ScrDyn *value) { + scr_dyn_obj_set(obj, key, strlen(key), value); +} + +/* base64url without padding of raw bytes. */ +static ScrDyn *sp_b64url(const uint8_t *raw, size_t len) { + size_t b64_len = 0; + mbedtls_base64_encode(NULL, 0, &b64_len, raw, len); + unsigned char *b64 = malloc(b64_len + 1); + if (!b64) scr_trap("scriptc: out of memory\n"); + mbedtls_base64_encode(b64, b64_len + 1, &b64_len, raw, len); + size_t o = 0; + for (size_t i = 0; i < b64_len; i++) { + unsigned char c = b64[i]; + if (c == '=') break; + b64[o++] = c == '+' ? '-' : c == '/' ? '_' : c; + } + ScrDyn *d = sp_dyn_str(scr_str_new((const char *)b64, o)); + mbedtls_platform_zeroize(b64, b64_len); + free(b64); + return d; +} + +static ScrDyn *sp_export_jwk(SpKey *k) { + ScrDyn *jwk = scr_dyn_new_obj(); + if (sp_is_ed(k)) { + sp_set(jwk, "kty", sp_dyn_str(scr_str_new("OKP", 3))); + sp_set(jwk, "crv", sp_dyn_str(scr_str_new("Ed25519", 7))); + sp_set(jwk, "x", sp_b64url(k->ed_pub, 32)); + if (k->private_key) sp_set(jwk, "d", sp_b64url(k->ed_seed, 32)); + return jwk; + } + if (sp_is_rsa(k)) { + mbedtls_rsa_context *rsa = mbedtls_pk_rsa(k->pk); + mbedtls_mpi n, e, d, p, q, dp, dq, qi; + mbedtls_mpi *all[] = {&n, &e, &d, &p, &q, &dp, &dq, &qi}; + for (size_t i = 0; i < 8; i++) mbedtls_mpi_init(all[i]); + mbedtls_rsa_export(rsa, &n, k->private_key ? &p : NULL, k->private_key ? &q : NULL, + k->private_key ? &d : NULL, &e); + sp_set(jwk, "kty", sp_dyn_str(scr_str_new("RSA", 3))); + sp_set(jwk, "n", sp_jwk_int(&n, 0)); + sp_set(jwk, "e", sp_jwk_int(&e, 0)); + if (k->private_key) { + mbedtls_rsa_export_crt(rsa, &dp, &dq, &qi); + sp_set(jwk, "d", sp_jwk_int(&d, 0)); + sp_set(jwk, "p", sp_jwk_int(&p, 0)); + sp_set(jwk, "q", sp_jwk_int(&q, 0)); + sp_set(jwk, "dp", sp_jwk_int(&dp, 0)); + sp_set(jwk, "dq", sp_jwk_int(&dq, 0)); + sp_set(jwk, "qi", sp_jwk_int(&qi, 0)); + } + for (size_t i = 0; i < 8; i++) mbedtls_mpi_free(all[i]); + } else { + const mbedtls_ecp_keypair *ec = mbedtls_pk_ec(k->pk); + const SpCurve *curve = sp_curve_of(k); + size_t size = (ec->MBEDTLS_PRIVATE(grp).nbits + 7) / 8; + sp_set(jwk, "kty", sp_dyn_str(scr_str_new("EC", 2))); + sp_set(jwk, "x", sp_jwk_int(&ec->MBEDTLS_PRIVATE(Q).MBEDTLS_PRIVATE(X), size)); + sp_set(jwk, "y", sp_jwk_int(&ec->MBEDTLS_PRIVATE(Q).MBEDTLS_PRIVATE(Y), size)); + sp_set(jwk, "crv", sp_dyn_str(scr_str_new(curve->jwk, strlen(curve->jwk)))); + if (k->private_key) sp_set(jwk, "d", sp_jwk_int(&ec->MBEDTLS_PRIVATE(d), size)); + } + return jwk; +} + +/* Decodes a JWK base64url member into `x`; false when it is missing or + * not a string. */ +static bool sp_jwk_read(const ScrDyn *jwk, const char *key, mbedtls_mpi *x) { + const ScrDyn *v = sp_opt(jwk, key); + if (v->kind != SCR_DYN_STR) return false; + size_t n = v->v.str->len; + unsigned char *b64 = malloc(n + 4); + unsigned char *raw = malloc(n + 4); + if (!b64 || !raw) scr_trap("scriptc: out of memory\n"); + for (size_t i = 0; i < n; i++) { + char c = v->v.str->data[i]; + b64[i] = (unsigned char)(c == '-' ? '+' : c == '_' ? '/' : c); + } + while (n % 4) b64[n++] = '='; + size_t raw_len = 0; + bool ok = mbedtls_base64_decode(raw, n, &raw_len, b64, n) == 0 && + mbedtls_mpi_read_binary(x, raw, raw_len) == 0; + mbedtls_platform_zeroize(raw, n); + free(b64); + free(raw); + return ok; +} + +/* Decodes a 32-byte JWK base64url member; false when it is missing, not a + * string, or another length. */ +static bool sp_jwk_bytes(const ScrDyn *jwk, const char *key, uint8_t out[32]) { + const ScrDyn *v = sp_opt(jwk, key); + if (v->kind != SCR_DYN_STR || v->v.str->len != 43) return false; + unsigned char b64[44]; + for (size_t i = 0; i < 43; i++) { + char c = v->v.str->data[i]; + b64[i] = (unsigned char)(c == '-' ? '+' : c == '_' ? '/' : c); + } + b64[43] = '='; + size_t n = 0; + return mbedtls_base64_decode(out, 32, &n, b64, 44) == 0 && n == 32; +} + +static void sp_invalid_jwk(void) { + sp_throw(SCR_ERR_TYPE, "ERR_CRYPTO_INVALID_JWK", "Invalid JWK data"); +} + +/* A key from a JWK object: RSA (n, e, and d, p, q for a private key) or EC + * (crv, x, y, and d). NULL with the error pending. */ +static SpKey *sp_key_from_jwk_plain(const ScrDyn *jwk, bool want_private); + +static SpKey *sp_key_from_jwk(const ScrDyn *jwk, bool want_private) { + ScrDyn *plain = sp_plain(jwk); + if (!plain) return NULL; + SpKey *k = sp_key_from_jwk_plain(plain, want_private); + scr_dyn_release(plain); + return k; +} + +static SpKey *sp_key_from_jwk_plain(const ScrDyn *jwk, bool want_private) { + if (!sp_is_object(jwk)) { + scr_dyn_prop_type_fail("key.key", "of type object", jwk); + return NULL; + } + const ScrDyn *kty = sp_opt(jwk, "kty"); + if (kty->kind != SCR_DYN_STR) { + scr_dyn_prop_type_fail("key.kty", "of type string", kty); + return NULL; + } + bool has_d = !sp_absent(sp_opt(jwk, "d")); + if (want_private && !has_d) { + sp_invalid_jwk(); + return NULL; + } + bool private_key = want_private; + SpKey *k = sp_key_alloc(private_key); + bool ok = false; + if (sp_is_str(kty, "OKP")) { + const ScrDyn *crv = sp_opt(jwk, "crv"); + if (!sp_is_str(crv, "Ed25519")) { + sp_key_release(k); + if (crv->kind != SCR_DYN_STR) { + scr_dyn_prop_type_fail("key.crv", "of type string", crv); + return NULL; + } + sp_not_supported("JWK keys of this crv"); + return NULL; + } + k->ed25519 = true; + if (private_key) { + ok = sp_jwk_bytes(jwk, "d", k->ed_seed); + if (ok) { + const ScrPkiEd25519 *ed = sp_ed(); + if (!ed) { + sp_key_release(k); + return NULL; + } + ed->public_key(k->ed_pub, k->ed_seed); + } + } else { + ok = sp_jwk_bytes(jwk, "x", k->ed_pub); + } + } else if (sp_is_str(kty, "RSA")) { + mbedtls_mpi n, e, d, p, q; + mbedtls_mpi_init(&n); + mbedtls_mpi_init(&e); + mbedtls_mpi_init(&d); + mbedtls_mpi_init(&p); + mbedtls_mpi_init(&q); + if (sp_jwk_read(jwk, "n", &n) && sp_jwk_read(jwk, "e", &e) && + mbedtls_pk_setup(&k->pk, mbedtls_pk_info_from_type(MBEDTLS_PK_RSA)) == 0) { + mbedtls_rsa_context *rsa = mbedtls_pk_rsa(k->pk); + if (private_key) { + ok = sp_jwk_read(jwk, "d", &d) && sp_jwk_read(jwk, "p", &p) && sp_jwk_read(jwk, "q", &q) && + mbedtls_rsa_import(rsa, &n, &p, &q, &d, &e) == 0 && mbedtls_rsa_complete(rsa) == 0 && + mbedtls_rsa_check_privkey(rsa) == 0; + } else { + ok = mbedtls_rsa_import(rsa, &n, NULL, NULL, NULL, &e) == 0 && + mbedtls_rsa_complete(rsa) == 0 && mbedtls_rsa_check_pubkey(rsa) == 0; + } + } + mbedtls_mpi_free(&n); + mbedtls_mpi_free(&e); + mbedtls_mpi_free(&d); + mbedtls_mpi_free(&p); + mbedtls_mpi_free(&q); + } else if (sp_is_str(kty, "EC")) { + const ScrDyn *crv = sp_opt(jwk, "crv"); + if (crv->kind != SCR_DYN_STR) { + sp_key_release(k); + scr_dyn_prop_type_fail("key.crv", "of type string", crv); + return NULL; + } + const SpCurve *curve = NULL; + for (size_t i = 0; i < sizeof sp_curves / sizeof sp_curves[0]; i++) + if (sp_is_str(crv, sp_curves[i].jwk)) curve = &sp_curves[i]; + if (!curve) { + sp_key_release(k); + sp_throw(SCR_ERR_TYPE, "ERR_CRYPTO_INVALID_CURVE", "Invalid EC curve name"); + return NULL; + } + if (mbedtls_pk_setup(&k->pk, mbedtls_pk_info_from_type(MBEDTLS_PK_ECKEY)) == 0) { + mbedtls_ecp_keypair *ec = mbedtls_pk_ec(k->pk); + mbedtls_ecp_point *Q = &ec->MBEDTLS_PRIVATE(Q); + ok = mbedtls_ecp_group_load(&ec->MBEDTLS_PRIVATE(grp), curve->id) == 0 && + sp_jwk_read(jwk, "x", &Q->MBEDTLS_PRIVATE(X)) && + sp_jwk_read(jwk, "y", &Q->MBEDTLS_PRIVATE(Y)) && + mbedtls_mpi_lset(&Q->MBEDTLS_PRIVATE(Z), 1) == 0 && + mbedtls_ecp_check_pubkey(&ec->MBEDTLS_PRIVATE(grp), Q) == 0; + if (ok && private_key) + ok = sp_jwk_read(jwk, "d", &ec->MBEDTLS_PRIVATE(d)) && + mbedtls_ecp_check_privkey(&ec->MBEDTLS_PRIVATE(grp), &ec->MBEDTLS_PRIVATE(d)) == 0; + } + } else { + sp_key_release(k); + sp_not_supported("JWK keys of this kty"); + return NULL; + } + if (!ok) { + sp_key_release(k); + sp_invalid_jwk(); + return NULL; + } + return k; +} + +/* ── parsing ──────────────────────────────────────────────────────────── */ + +/* The private key of a public SpKey derived from `k`. */ +static SpKey *sp_public_of(SpKey *k) { + if (sp_is_ed(k)) { + SpKey *pub = sp_key_alloc(false); + pub->ed25519 = true; + memcpy(pub->ed_pub, k->ed_pub, 32); + return pub; + } + unsigned char der[SP_DER_MAX]; + int n = sp_write_spki_der(k, der, sizeof der); + SpKey *pub = sp_key_alloc(false); + if (n < 0 || mbedtls_pk_parse_public_key(&pub->pk, der + sizeof der - n, (size_t)n) != 0) { + sp_key_release(pub); + return NULL; + } + return pub; +} + +/* Parses key material (PEM or DER bytes). `private_key` selects + * createPrivateKey's parse (PKCS#1, SEC1, PKCS#8) or createPublicKey's + * (SubjectPublicKeyInfo, PKCS#1 RSAPublicKey, then a private key or an + * X.509 certificate, whose public key it takes). NULL with Node's + * decoder error pending. */ +/* The DER of the first PEM block in data (+1 malloc'd in *out), or the + * data itself when it has no PEM armor (*out NULL). */ +static bool sp_der_of(const unsigned char *data, size_t len, unsigned char **out, const unsigned char **der, + size_t *der_len) { + *out = NULL; + const unsigned char *begin = NULL; + for (size_t i = 0; i + 11 <= len; i++) { + if (memcmp(data + i, "-----BEGIN ", 11) == 0) { + begin = data + i; + break; + } + } + if (!begin) { + *der = data; + *der_len = len; + return true; + } + const unsigned char *end = data + len; + const unsigned char *body = memchr(begin, '\n', (size_t)(end - begin)); + if (!body) return false; + body++; + unsigned char *b64 = malloc((size_t)(end - body) + 1); + unsigned char *raw = malloc((size_t)(end - body) + 1); + if (!b64 || !raw) scr_trap("scriptc: out of memory\n"); + size_t n = 0; + for (const unsigned char *p = body; p < end && *p != '-'; p++) + if (*p != '\n' && *p != '\r' && *p != ' ' && *p != '\t') b64[n++] = *p; + size_t raw_len = 0; + bool ok = mbedtls_base64_decode(raw, (size_t)(end - body) + 1, &raw_len, b64, n) == 0; + free(b64); + if (!ok) { + free(raw); + return false; + } + *out = raw; + *der = raw; + *der_len = raw_len; + return true; +} + +/* The SubjectPublicKeyInfo element of an X.509 certificate's DER. */ +static bool sp_cert_spki(const unsigned char *der, size_t len, const unsigned char **spki, size_t *spki_len) { + unsigned char *p = (unsigned char *)der; + const unsigned char *end = der + len; + size_t n; + if (mbedtls_asn1_get_tag(&p, end, &n, MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE) != 0) return false; + if (mbedtls_asn1_get_tag(&p, end, &n, MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE) != 0) return false; + const unsigned char *tbs_end = p + n; + /* [0] version, serialNumber, signature, issuer, validity, subject */ + if (mbedtls_asn1_get_tag(&p, tbs_end, &n, MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 0) == 0) + p += n; + int tags[] = {MBEDTLS_ASN1_INTEGER, MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE, + MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE, MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE, + MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE}; + for (size_t i = 0; i < 5; i++) { + if (mbedtls_asn1_get_tag(&p, tbs_end, &n, tags[i]) != 0) return false; + p += n; + } + const unsigned char *start = p; + if (mbedtls_asn1_get_tag(&p, tbs_end, &n, MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE) != 0) return false; + *spki = start; + *spki_len = (size_t)(p + n - start); + return true; +} + +/* An Ed25519 key from PKCS#8 or SubjectPublicKeyInfo DER, or (for a public + * key) the key of an X.509 certificate; NULL when the DER is none of + * these, or with *failed set and an error pending. A private key wanted + * as public answers its public key. */ +static SpKey *sp_ed_from_der(const unsigned char *der, size_t len, bool private_key, bool *failed) { + *failed = false; + if (len == 48 && memcmp(der, sp_ed_pkcs8_prefix, 16) == 0) { + const ScrPkiEd25519 *ed = sp_ed(); + if (!ed) { + *failed = true; + return NULL; + } + SpKey *k = sp_key_alloc(private_key); + k->ed25519 = true; + ed->public_key(k->ed_pub, der + 16); + if (private_key) memcpy(k->ed_seed, der + 16, 32); + return k; + } + if (private_key) return NULL; + const unsigned char *spki = der; + size_t spki_len = len; + if (!(len == 44 && memcmp(der, sp_ed_spki_prefix, 12) == 0) && !sp_cert_spki(der, len, &spki, &spki_len)) + return NULL; + if (spki_len != 44 || memcmp(spki, sp_ed_spki_prefix, 12) != 0) return NULL; + SpKey *k = sp_key_alloc(false); + k->ed25519 = true; + memcpy(k->ed_pub, spki + 12, 32); + return k; +} + +static SpKey *sp_parse(const unsigned char *data, size_t len, bool private_key) { + { + unsigned char *decoded; + const unsigned char *der; + size_t der_len; + if (sp_der_of(data, len, &decoded, &der, &der_len)) { + bool failed; + SpKey *ed = sp_ed_from_der(der, der_len, private_key, &failed); + if (decoded) { + mbedtls_platform_zeroize(decoded, der_len); + free(decoded); + } + if (ed || failed) return ed; + } + } + /* mbedtls reads PEM from a NUL-terminated buffer whose length counts the + * NUL. */ + bool pem = false; + for (size_t i = 0; i + 11 <= len; i++) { + if (memcmp(data + i, "-----BEGIN ", 11) == 0) { + pem = true; + break; + } + } + unsigned char *buf = malloc(len + 1); + if (!buf) scr_trap("scriptc: out of memory\n"); + memcpy(buf, data, len); + buf[len] = 0; + size_t n = pem ? len + 1 : len; + SpKey *k = sp_key_alloc(private_key); + bool ok; + if (private_key) { + ok = mbedtls_pk_parse_key(&k->pk, buf, n, NULL, 0, sp_random, NULL) == 0; + } else { + ok = mbedtls_pk_parse_public_key(&k->pk, buf, n) == 0; + if (!ok) { + SpKey *priv = sp_key_alloc(true); + mbedtls_pk_free(&k->pk); + mbedtls_pk_init(&k->pk); + if (mbedtls_pk_parse_key(&priv->pk, buf, n, NULL, 0, sp_random, NULL) == 0) { + sp_key_release(k); + k = sp_public_of(priv); + ok = k != NULL; + if (!k) k = sp_key_alloc(false); + } else { + mbedtls_x509_crt crt; + mbedtls_x509_crt_init(&crt); + if (mbedtls_x509_crt_parse(&crt, buf, n) == 0) { + unsigned char der[SP_DER_MAX]; + int w = mbedtls_pk_write_pubkey_der(&crt.pk, der, sizeof der); + ok = w > 0 && mbedtls_pk_parse_public_key(&k->pk, der + sizeof der - w, (size_t)w) == 0; + } + mbedtls_x509_crt_free(&crt); + } + sp_key_release(priv); + } + } + mbedtls_platform_zeroize(buf, len); + free(buf); + if (!ok) { + sp_key_release(k); + sp_unsupported_input(); + return NULL; + } + if (!sp_key_supported(k)) { + sp_key_release(k); + sp_not_supported("crypto keys of this type"); + return NULL; + } + return k; +} + +/* The bytes of a string or buffer source, +1; NULL when `v` is neither. */ +static ScrBytes *sp_source_bytes(const ScrDyn *v, const ScrDyn *encoding) { + if (v->kind == SCR_DYN_STR) { + bool named = encoding != NULL && encoding->kind == SCR_DYN_STR; + ScrStr *utf8 = named ? NULL : scr_str_new("utf8", 4); + ScrBytes *b = scr_bytes_from_str_checked(v->v.str, named ? encoding->v.str : utf8); + if (utf8) scr_str_release(utf8); + return b; + } + if (v->kind == SCR_DYN_BYTES || scr_buffer_storage_is(v)) return scr_bytes_buffer_source(v); + return NULL; +} + +static const char sp_key_input_types[] = + "of type string or an instance of ArrayBuffer, Buffer, TypedArray, DataView, or URL"; + +/* createPrivateKey / createPublicKey: a PEM string or buffer, or + * { key, format, type, encoding, passphrase }; createPublicKey also takes + * a private KeyObject. */ +static ScrDyn *sp_create_key(ScrDyn *input, bool private_key) { + if (input->kind == SCR_DYN_TYPED_REF) { + ScrDyn *value = scr_dyn_typed_ref_materialize(input); + if (!value) return NULL; + ScrDyn *result = sp_create_key(value, private_key); + scr_dyn_release(value); + return result; + } + SpKey *object = sp_key_of(input); + if (object) { + if (private_key) { + scr_dyn_arg_type_fail("key", sp_key_input_types, input); + return NULL; + } + if (!object->private_key) { + sp_throw(SCR_ERR_TYPE, "ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE", + "Invalid key object type public, expected private."); + return NULL; + } + SpKey *pub = sp_public_of(object); + if (!pub) { + sp_unsupported_input(); + return NULL; + } + return sp_key_box(pub); + } + const ScrDyn *data = input; + const ScrDyn *format = scr_dyn_undefined(); + const ScrDyn *type = scr_dyn_undefined(); + const ScrDyn *encoding = NULL; + if (sp_is_object(input) && !scr_buffer_storage_is(input)) { + data = sp_opt(input, "key"); + format = sp_opt(input, "format"); + type = sp_opt(input, "type"); + encoding = sp_opt(input, "encoding"); + if (!sp_absent(sp_opt(input, "passphrase"))) { + sp_not_supported("encrypted private keys"); + return NULL; + } + SpKey *inner = sp_key_of(data); + if (inner) return sp_create_key((ScrDyn *)data, private_key); + if (sp_is_str(format, "jwk")) { + SpKey *k = sp_key_from_jwk(data, private_key); + return k ? sp_key_box(k) : NULL; + } + if (!sp_absent(format) && !sp_is_str(format, "pem") && !sp_is_str(format, "der")) { + sp_property_invalid("key.format", format); + return NULL; + } + if (sp_is_str(format, "der")) { + bool valid = private_key ? sp_is_str(type, "pkcs1") || sp_is_str(type, "pkcs8") || + sp_is_str(type, "sec1") + : sp_is_str(type, "pkcs1") || sp_is_str(type, "spki"); + if (!valid) { + sp_property_invalid("key.type", type); + return NULL; + } + } + } + ScrBytes *bytes = sp_source_bytes(data, encoding); + if (!bytes) { + if (data->kind == SCR_DYN_STR || data->kind == SCR_DYN_BYTES || scr_buffer_storage_is(data)) + return NULL; /* the decoder threw */ + scr_dyn_arg_type_fail(data == input ? "key" : "key.key", sp_key_input_types, data); + return NULL; + } + SpKey *k = sp_parse(bytes->data, (size_t)scr_bytes_byte_len(bytes), private_key); + scr_bytes_release(bytes); + return k ? sp_key_box(k) : NULL; +} + +ScrDyn *scr_crypto_create_private_key(ScrDyn *key) { return sp_create_key(key, true); } + +ScrDyn *scr_crypto_create_public_key(ScrDyn *key) { return sp_create_key(key, false); } + +/* ── export ───────────────────────────────────────────────────────────── */ + +/* export({ format, type }) per Node's parseKeyEncoding: format "pem", + * "der" or "jwk"; type pkcs1/pkcs8/sec1 for private keys and pkcs1/spki + * for public keys, where pkcs1 needs an RSA key and sec1 an EC key. */ +static ScrDyn *sp_export_plain(SpKey *k, const ScrDyn *options); + +static ScrDyn *sp_export(SpKey *k, const ScrDyn *options) { + ScrDyn *plain = sp_plain(options); + if (!plain) return NULL; + ScrDyn *result = sp_export_plain(k, plain); + scr_dyn_release(plain); + return result; +} + +static ScrDyn *sp_export_plain(SpKey *k, const ScrDyn *options) { + if (options == NULL || !sp_is_object(options)) { + scr_dyn_arg_type_fail("options", "of type object", options ? options : scr_dyn_undefined()); + return NULL; + } + const ScrDyn *format = sp_opt(options, "format"); + if (sp_is_str(format, "jwk")) return sp_export_jwk(k); + bool pem = sp_is_str(format, "pem"); + if (!pem && !sp_is_str(format, "der")) { + sp_property_invalid("options.format", format); + return NULL; + } + const ScrDyn *type = sp_opt(options, "type"); + bool pkcs1 = sp_is_str(type, "pkcs1"); + bool pkcs8 = k->private_key && sp_is_str(type, "pkcs8"); + bool sec1 = k->private_key && sp_is_str(type, "sec1"); + bool spki = !k->private_key && sp_is_str(type, "spki"); + if (!pkcs1 && !pkcs8 && !sec1 && !spki) { + sp_property_invalid("options.type", type); + return NULL; + } + if (!sp_absent(sp_opt(options, "cipher")) || !sp_absent(sp_opt(options, "passphrase"))) { + sp_not_supported("encrypted private key export"); + return NULL; + } + if (pkcs1 && !sp_is_rsa(k)) { + sp_throw(SCR_ERR_ERROR, "ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS", + "The selected key encoding pkcs1 can only be used for RSA keys."); + return NULL; + } + if (sec1 && !sp_is_ec(k)) { + sp_throw(SCR_ERR_ERROR, "ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS", + "The selected key encoding sec1 can only be used for EC keys."); + return NULL; + } + unsigned char *der = malloc(SP_DER_MAX); + if (!der) scr_trap("scriptc: out of memory\n"); + int n; + const char *label; + if (pkcs8) { + n = sp_write_pkcs8_der(k, der, SP_DER_MAX); + label = "PRIVATE KEY"; + } else if (spki) { + n = sp_write_spki_der(k, der, SP_DER_MAX); + label = "PUBLIC KEY"; + } else if (k->private_key) { + n = sp_write_private_der(k, der, SP_DER_MAX); + label = pkcs1 ? "RSA PRIVATE KEY" : "EC PRIVATE KEY"; + } else { + n = sp_write_pkcs1_public_der(k, der, SP_DER_MAX); + label = "RSA PUBLIC KEY"; + } + ScrDyn *result = NULL; + if (n < 0) { + sp_unsupported_input(); + } else { + const unsigned char *start = der + SP_DER_MAX - n; + result = pem ? sp_dyn_str(sp_pem(label, start, (size_t)n)) : sp_dyn_buffer(start, (size_t)n); + } + mbedtls_platform_zeroize(der, SP_DER_MAX); + free(der); + return result; +} + +/* ── the KeyObject handles ────────────────────────────────────────────── */ + +static ScrDyn *sp_key_details(SpKey *k) { + ScrDyn *details = scr_dyn_new_obj(); + if (sp_is_ed(k)) return details; + if (sp_is_rsa(k)) { + mbedtls_rsa_context *rsa = mbedtls_pk_rsa(k->pk); + mbedtls_mpi e; + mbedtls_mpi_init(&e); + mbedtls_rsa_export(rsa, NULL, NULL, NULL, NULL, &e); + uint64_t exponent = 0; + size_t bytes = mbedtls_mpi_size(&e); + unsigned char raw[8] = {0}; + if (bytes <= 8) mbedtls_mpi_write_binary(&e, raw, 8); + for (size_t i = 0; i < 8; i++) exponent = (exponent << 8) | raw[i]; + mbedtls_mpi_free(&e); + sp_set(details, "modulusLength", scr_dyn_new_num((double)mbedtls_pk_get_bitlen(&k->pk))); + ScrBigInt *big = scr_bigint_from_u64(exponent); + sp_set(details, "publicExponent", scr_dyn_new_bigint(big)); + scr_bigint_release(big); + } else { + const SpCurve *curve = sp_curve_of(k); + sp_set(details, "namedCurve", sp_dyn_str(scr_str_new(curve->name, strlen(curve->name)))); + } + return details; +} + +/* The DER that identifies a key for equals(): its private encoding for a + * private key, its SubjectPublicKeyInfo otherwise. */ +static int sp_identity_der(SpKey *k, unsigned char *buf, size_t size) { + if (sp_is_ed(k)) return k->private_key ? sp_write_pkcs8_der(k, buf, size) : sp_write_spki_der(k, buf, size); + return k->private_key ? sp_write_private_der(k, buf, size) : sp_write_spki_der(k, buf, size); +} + +static ScrDyn *sp_key_invoke(void *h, ScrDyn *self, const char *method, ScrDyn *const *args, + size_t argc, const char *what) { + (void)self; + SpKey *k = h; + if (strcmp(method, "export") == 0) return sp_export(k, argc ? args[0] : NULL); + if (strcmp(method, "equals") == 0) { + const ScrDyn *other_value = argc ? args[0] : scr_dyn_undefined(); + SpKey *other = sp_key_of(other_value); + if (!other) { + size_t len; + if (scr_key_object_bytes(other_value, &len)) return scr_dyn_new_bool(false); + scr_dyn_arg_type_fail("otherKeyObject", "an instance of KeyObject", other_value); + return NULL; + } + if (other->private_key != k->private_key || + mbedtls_pk_get_type(&other->pk) != mbedtls_pk_get_type(&k->pk)) + return scr_dyn_new_bool(false); + unsigned char *a = malloc(SP_DER_MAX), *b = malloc(SP_DER_MAX); + if (!a || !b) scr_trap("scriptc: out of memory\n"); + int na = sp_identity_der(k, a, SP_DER_MAX); + int nb = sp_identity_der(other, b, SP_DER_MAX); + bool same = na > 0 && na == nb && memcmp(a + SP_DER_MAX - na, b + SP_DER_MAX - nb, (size_t)na) == 0; + mbedtls_platform_zeroize(a, SP_DER_MAX); + mbedtls_platform_zeroize(b, SP_DER_MAX); + free(a); + free(b); + return scr_dyn_new_bool(same); + } + if (strcmp(method, "toCryptoKey") == 0) { + sp_not_supported("KeyObject.toCryptoKey"); + return NULL; + } + char message[160]; + int n = snprintf(message, sizeof message, "%s is not a function", what); + scr_throw_error_msg(SCR_ERR_TYPE, message, (size_t)n); + return NULL; +} + +static ScrDyn *sp_key_get(void *h, const char *name, size_t len) { + SpKey *k = h; + if (len == 4 && memcmp(name, "type", 4) == 0) + return k->private_key ? sp_dyn_str(scr_str_new("private", 7)) : sp_dyn_str(scr_str_new("public", 6)); + if (len == 17 && memcmp(name, "asymmetricKeyType", 17) == 0) + return sp_is_ed(k) ? sp_dyn_str(scr_str_new("ed25519", 7)) + : sp_is_rsa(k) ? sp_dyn_str(scr_str_new("rsa", 3)) + : sp_dyn_str(scr_str_new("ec", 2)); + if (len == 20 && memcmp(name, "asymmetricKeyDetails", 20) == 0) return sp_key_details(k); + return NULL; +} + +static bool sp_key_set(void *h, const char *name, size_t len, const ScrDyn *value) { + (void)h; + (void)value; + const char *holder = len == 4 && memcmp(name, "type", 4) == 0 ? "KeyObject" + : (len == 17 && memcmp(name, "asymmetricKeyType", 17) == 0) || + (len == 20 && memcmp(name, "asymmetricKeyDetails", 20) == 0) + ? "AsymmetricKeyObject" + : NULL; + if (!holder) return false; + char message[160]; + int n = snprintf(message, sizeof message, "Cannot set property %.*s of #<%s> which has only a getter", + (int)len, name, holder); + scr_throw_error_msg(SCR_ERR_TYPE, message, (size_t)n); + return true; +} + +static ScrDyn *sp_key_inspect_view(void *h) { + (void)h; + return scr_dyn_new_obj(); +} + +static const ScrDynHandleOps sp_private_ops = { + .cls = "PrivateKeyObject", + .retain = sp_key_retain, + .release = sp_key_release, + .invoke = sp_key_invoke, + .get = sp_key_get, + .set = sp_key_set, + .inspect_view = sp_key_inspect_view, + .json_empty_object = true, + .to_string_tag = "KeyObject", + .inspect_view_empty = true, +}; + +static const ScrDynHandleOps sp_public_ops = { + .cls = "PublicKeyObject", + .retain = sp_key_retain, + .release = sp_key_release, + .invoke = sp_key_invoke, + .get = sp_key_get, + .set = sp_key_set, + .inspect_view = sp_key_inspect_view, + .json_empty_object = true, + .to_string_tag = "KeyObject", + .inspect_view_empty = true, +}; + +/* createHmac with a private or public key (scr_crypto_reject_asymmetric_secret). */ +static void sp_reject_as_secret(const ScrDyn *key) { + bool private_key = key->v.handle.tag == SCR_DYNH_PRIVATE_KEY; + scr_throw_error_msg_code(SCR_ERR_TYPE, + private_key ? "Invalid key object type private, expected secret." + : "Invalid key object type public, expected secret.", + private_key ? 49 : 48, "ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE"); +} + +static void sp_key_install(void) { + static SCR_TL bool installed; + if (installed) return; + installed = true; + scr_dyn_handle_install(SCR_DYNH_PRIVATE_KEY, &sp_private_ops); + scr_dyn_handle_install(SCR_DYNH_PUBLIC_KEY, &sp_public_ops); + scr_crypto_reject_asymmetric_secret = sp_reject_as_secret; +} + +/* ── generateKeyPairSync ──────────────────────────────────────────────── */ + +/* A key in the encoding an options.publicKeyEncoding/privateKeyEncoding + * object asks for, or the KeyObject when it is undefined. Consumes `k`. */ +static ScrDyn *sp_encoded(SpKey *k, const ScrDyn *encoding) { + if (sp_absent(encoding)) return sp_key_box(k); + ScrDyn *result = sp_export(k, encoding); + sp_key_release(k); + return result; +} + +static bool sp_check_encoding_plain(const ScrDyn *encoding, const char *name, bool private_key); + +static bool sp_check_encoding(const ScrDyn *options, const char *name, bool private_key) { + ScrDyn *encoding = sp_plain(sp_opt(options, name)); + if (!encoding) return false; + bool ok = sp_check_encoding_plain(encoding, name, private_key); + scr_dyn_release(encoding); + return ok; +} + +static bool sp_check_encoding_plain(const ScrDyn *encoding, const char *name, bool private_key) { + if (sp_absent(encoding)) return true; + char full[64]; + snprintf(full, sizeof full, "options.%s", name); + if (!sp_is_object(encoding)) { + sp_property_invalid(full, encoding); + return false; + } + const ScrDyn *format = sp_opt(encoding, "format"); + if (!sp_is_str(format, "pem") && !sp_is_str(format, "der") && !sp_is_str(format, "jwk")) { + snprintf(full, sizeof full, "options.%s.format", name); + sp_property_invalid(full, format); + return false; + } + if (sp_is_str(format, "jwk")) return true; + const ScrDyn *type = sp_opt(encoding, "type"); + bool valid = private_key ? sp_is_str(type, "pkcs1") || sp_is_str(type, "pkcs8") || sp_is_str(type, "sec1") + : sp_is_str(type, "pkcs1") || sp_is_str(type, "spki"); + if (!valid) { + snprintf(full, sizeof full, "options.%s.type", name); + sp_property_invalid(full, type); + return false; + } + return true; +} + +/* Generates the private key for (type, options), validated in Node's + * order; NULL with the error pending. */ +static SpKey *sp_generate(const ScrDyn *type, const ScrDyn *options) { + if (type->kind != SCR_DYN_STR) { + scr_dyn_arg_type_fail("type", "of type string", type); + return NULL; + } + bool rsa = sp_is_str(type, "rsa"); + bool ec = sp_is_str(type, "ec"); + bool ed = sp_is_str(type, "ed25519"); + static const char *const known[] = {"rsa-pss", "dsa", "ed448", "x25519", "x448", "dh"}; + bool other = false; + for (size_t i = 0; i < sizeof known / sizeof known[0]; i++) other = other || sp_is_str(type, known[i]); + if (!rsa && !ec && !ed && !other) { + char lite[96]; + char message[200]; + int n = snprintf(message, sizeof message, + "The argument 'type' must be a supported key type. Received %s", + scr_dyn_inspect_lite(type, lite, sizeof lite)); + scr_throw_error_msg_code(SCR_ERR_TYPE, message, (size_t)n, "ERR_INVALID_ARG_VALUE"); + return NULL; + } + /* The ed25519 options are optional. */ + if (!sp_is_object(options) && !(ed && sp_absent(options))) { + scr_dyn_arg_type_fail("options", "of type object", options); + return NULL; + } + if (other) { + sp_not_supported("generateKeyPairSync for this key type"); + return NULL; + } + SpKey *k = sp_key_alloc(true); + if (ed) { + if (!sp_check_encoding(options, "publicKeyEncoding", false) || + !sp_check_encoding(options, "privateKeyEncoding", true)) { + sp_key_release(k); + return NULL; + } + const ScrPkiEd25519 *ed = sp_ed(); + if (!ed) { + sp_key_release(k); + return NULL; + } + k->ed25519 = true; + sp_random(NULL, k->ed_seed, 32); + ed->public_key(k->ed_pub, k->ed_seed); + return k; + } + if (rsa) { + const ScrDyn *bits = sp_opt(options, "modulusLength"); + if (bits->kind != SCR_DYN_NUM) { + sp_key_release(k); + scr_dyn_prop_type_fail("options.modulusLength", "of type number", bits); + return NULL; + } + double b = bits->v.num; + if (b != b || b < 0 || b > 4294967295.0 || b != (double)(uint64_t)b) { + sp_key_release(k); + char message[160]; + char lite[64]; + int n = snprintf(message, sizeof message, + "The value of \"options.modulusLength\" is out of range. It must be >= 0 && <= 4294967295. Received %s", + scr_dyn_inspect_lite(bits, lite, sizeof lite)); + scr_throw_error_msg_code(SCR_ERR_RANGE, message, (size_t)n, "ERR_OUT_OF_RANGE"); + return NULL; + } + const ScrDyn *exp = sp_opt(options, "publicExponent"); + double e = 65537; + if (!sp_absent(exp)) { + if (exp->kind != SCR_DYN_NUM) { + sp_key_release(k); + scr_dyn_prop_type_fail("options.publicExponent", "of type number", exp); + return NULL; + } + e = exp->v.num; + } + if (!sp_check_encoding(options, "publicKeyEncoding", false) || + !sp_check_encoding(options, "privateKeyEncoding", true)) { + sp_key_release(k); + return NULL; + } + if (b < 512 || b > 16384 || e < 3 || e > 2147483647.0 || e != (double)(int64_t)e || ((int64_t)e & 1) == 0 || + mbedtls_pk_setup(&k->pk, mbedtls_pk_info_from_type(MBEDTLS_PK_RSA)) != 0 || + mbedtls_rsa_gen_key(mbedtls_pk_rsa(k->pk), sp_random, NULL, (unsigned)b, (int)e) != 0) { + sp_key_release(k); + sp_not_supported("generateKeyPairSync with this RSA modulus length or exponent"); + return NULL; + } + return k; + } + const ScrDyn *curve_name = sp_opt(options, "namedCurve"); + if (curve_name->kind != SCR_DYN_STR) { + sp_key_release(k); + scr_dyn_prop_type_fail("options.namedCurve", "of type string", curve_name); + return NULL; + } + if (!sp_check_encoding(options, "publicKeyEncoding", false) || + !sp_check_encoding(options, "privateKeyEncoding", true)) { + sp_key_release(k); + return NULL; + } + const SpCurve *curve = NULL; + for (size_t i = 0; i < sizeof sp_curves / sizeof sp_curves[0]; i++) + if (sp_is_str(curve_name, sp_curves[i].name) || + (sp_curves[i].nist && sp_is_str(curve_name, sp_curves[i].nist))) + curve = &sp_curves[i]; + if (!curve) { + sp_key_release(k); + sp_throw(SCR_ERR_TYPE, "ERR_CRYPTO_INVALID_CURVE", "Invalid EC curve name"); + return NULL; + } + if (mbedtls_pk_setup(&k->pk, mbedtls_pk_info_from_type(MBEDTLS_PK_ECKEY)) != 0 || + mbedtls_ecp_gen_key(curve->id, mbedtls_pk_ec(k->pk), sp_random, NULL) != 0) { + sp_key_release(k); + sp_unsupported_input(); + return NULL; + } + return k; +} + +/* generateKeyPairSync(type, options): { publicKey, privateKey }, each a + * KeyObject or the encoding the options ask for. */ +ScrDyn *scr_crypto_generate_key_pair_sync(ScrDyn *type, ScrDyn *options) { + if (options->kind == SCR_DYN_TYPED_REF) { + ScrDyn *value = scr_dyn_typed_ref_materialize(options); + if (!value) return NULL; + ScrDyn *result = scr_crypto_generate_key_pair_sync(type, value); + scr_dyn_release(value); + return result; + } + SpKey *k = sp_generate(type, options); + if (!k) return NULL; + SpKey *pub = sp_public_of(k); + if (!pub) { + sp_key_release(k); + sp_unsupported_input(); + return NULL; + } + ScrDyn *public_value = sp_encoded(pub, sp_opt(options, "publicKeyEncoding")); + if (!public_value) { + sp_key_release(k); + return NULL; + } + ScrDyn *private_value = sp_encoded(k, sp_opt(options, "privateKeyEncoding")); + if (!private_value) { + scr_dyn_release(public_value); + return NULL; + } + ScrDyn *pair = scr_dyn_new_obj(); + sp_set(pair, "publicKey", public_value); + sp_set(pair, "privateKey", private_value); + return pair; +} + +/* ── sign and verify ──────────────────────────────────────────────────── */ + +typedef struct { + const char *name; + mbedtls_md_type_t md; +} SpDigest; + +/* Digest names as OpenSSL's EVP_get_digestbyname takes them for + * signatures, matched without regard to case. */ +static const SpDigest sp_digests[] = { + {"sha1", MBEDTLS_MD_SHA1}, {"rsa-sha1", MBEDTLS_MD_SHA1}, + {"sha1withrsaencryption", MBEDTLS_MD_SHA1}, {"ecdsa-with-sha1", MBEDTLS_MD_SHA1}, + {"sha224", MBEDTLS_MD_SHA224}, {"rsa-sha224", MBEDTLS_MD_SHA224}, + {"sha224withrsaencryption", MBEDTLS_MD_SHA224}, + {"sha256", MBEDTLS_MD_SHA256}, {"rsa-sha256", MBEDTLS_MD_SHA256}, + {"sha256withrsaencryption", MBEDTLS_MD_SHA256}, + {"sha384", MBEDTLS_MD_SHA384}, {"rsa-sha384", MBEDTLS_MD_SHA384}, + {"sha384withrsaencryption", MBEDTLS_MD_SHA384}, + {"sha512", MBEDTLS_MD_SHA512}, {"rsa-sha512", MBEDTLS_MD_SHA512}, + {"sha512withrsaencryption", MBEDTLS_MD_SHA512}, + {"sha2-256", MBEDTLS_MD_SHA256}, {"sha2-384", MBEDTLS_MD_SHA384}, + {"sha2-512", MBEDTLS_MD_SHA512}, {"sha2-224", MBEDTLS_MD_SHA224}, +}; + +static bool sp_digest_of(const ScrStr *name, mbedtls_md_type_t *md) { + for (size_t i = 0; i < sizeof sp_digests / sizeof sp_digests[0]; i++) { + size_t n = strlen(sp_digests[i].name); + if (name->len != n) continue; + bool same = true; + for (size_t j = 0; j < n && same; j++) { + char c = name->data[j]; + if (c >= 'A' && c <= 'Z') c = (char)(c - 'A' + 'a'); + same = c == sp_digests[i].name[j]; + } + if (same) { + *md = sp_digests[i].md; + return true; + } + } + return false; +} + +/* The algorithm argument of crypto.sign/verify: a digest name, or + * null/undefined for the key type's default (SHA-256). */ +static bool sp_algorithm(const ScrDyn *alg, mbedtls_md_type_t *md) { + if (alg->kind == SCR_DYN_UNDEF || alg->kind == SCR_DYN_NULL) { + *md = MBEDTLS_MD_SHA256; + return true; + } + if (alg->kind != SCR_DYN_STR) { + scr_dyn_arg_type_fail("algorithm", "of type string", alg); + return false; + } + if (!sp_digest_of(alg->v.str, md)) { + char message[160]; + int n = snprintf(message, sizeof message, "Invalid digest: %.*s", (int)alg->v.str->len, + alg->v.str->data); + scr_throw_error_msg_code(SCR_ERR_TYPE, message, (size_t)n, "ERR_CRYPTO_INVALID_DIGEST"); + return false; + } + return true; +} + +typedef struct { + SpKey *key; /* +1 */ + int padding; /* RSA_PKCS1_PADDING (1) or RSA_PKCS1_PSS_PADDING (6) */ + int salt; /* -1 digest length, -2 maximum (sign) or auto (verify) */ + bool p1363; /* dsaEncoding: "ieee-p1363" */ +} SpSigKey; + +/* The key argument of a signing operation: a KeyObject, key material, or + * { key, dsaEncoding, padding, saltLength, ...createKey options }. */ +static bool sp_sig_key_plain(const ScrDyn *value, bool sign, SpSigKey *out); + +static bool sp_sig_key(const ScrDyn *value, bool sign, SpSigKey *out) { + out->key = NULL; + ScrDyn *plain = sp_plain(value); + if (!plain) return false; + bool ok = sp_sig_key_plain(plain, sign, out); + scr_dyn_release(plain); + return ok; +} + +static bool sp_sig_key_plain(const ScrDyn *value, bool sign, SpSigKey *out) { + out->key = NULL; + out->padding = 1; + out->salt = sign ? -2 : -2; + out->p1363 = false; + const ScrDyn *options = NULL; + if (sp_is_object(value) && !sp_key_of(value) && !scr_buffer_storage_is(value)) { + options = value; + const ScrDyn *dsa = sp_opt(value, "dsaEncoding"); + if (sp_is_str(dsa, "ieee-p1363")) out->p1363 = true; + else if (!sp_absent(dsa) && !sp_is_str(dsa, "der")) { + sp_property_invalid("options.dsaEncoding", dsa); + return false; + } + const ScrDyn *padding = sp_opt(value, "padding"); + if (!sp_absent(padding)) { + if (padding->kind != SCR_DYN_NUM || (padding->v.num != 1 && padding->v.num != 6)) { + sp_not_supported("signatures with this padding"); + return false; + } + out->padding = (int)padding->v.num; + } + const ScrDyn *salt = sp_opt(value, "saltLength"); + if (!sp_absent(salt)) { + if (salt->kind != SCR_DYN_NUM || salt->v.num != (double)(int)salt->v.num || salt->v.num < -2) { + sp_not_supported("signatures with this saltLength"); + return false; + } + out->salt = (int)salt->v.num; + } + } + SpKey *direct = sp_key_of(options ? sp_opt(options, "key") : value); + if (direct) { + if (sign && !direct->private_key) { + sp_throw(SCR_ERR_TYPE, "ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE", + "Invalid key object type public, expected private."); + return false; + } + sp_key_retain(direct); + out->key = direct; + return true; + } + ScrDyn *created = sp_create_key((ScrDyn *)value, sign); + if (!created) return false; + out->key = sp_key_retain(sp_key_of(created)); + scr_dyn_release(created); + return true; +} + +/* DER ECDSA-Sig-Value ⇄ IEEE P1363 r || s. */ +static bool sp_der_to_p1363(const unsigned char *der, size_t len, size_t size, unsigned char *out) { + unsigned char *p = (unsigned char *)der; + const unsigned char *end = der + len; + size_t seq; + mbedtls_mpi r, s; + mbedtls_mpi_init(&r); + mbedtls_mpi_init(&s); + bool ok = mbedtls_asn1_get_tag(&p, end, &seq, MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE) == 0 && + mbedtls_asn1_get_mpi(&p, end, &r) == 0 && mbedtls_asn1_get_mpi(&p, end, &s) == 0 && + mbedtls_mpi_write_binary(&r, out, size) == 0 && + mbedtls_mpi_write_binary(&s, out + size, size) == 0; + mbedtls_mpi_free(&r); + mbedtls_mpi_free(&s); + return ok; +} + +static int sp_p1363_to_der(const unsigned char *sig, size_t len, unsigned char *buf, size_t size) { + mbedtls_mpi r, s; + mbedtls_mpi_init(&r); + mbedtls_mpi_init(&s); + int out = -1; + if (len % 2 == 0 && mbedtls_mpi_read_binary(&r, sig, len / 2) == 0 && + mbedtls_mpi_read_binary(&s, sig + len / 2, len / 2) == 0) { + unsigned char *c = buf + size; + size_t n = 0; + int w; + if ((w = mbedtls_asn1_write_mpi(&c, buf, &s)) >= 0) { + n += (size_t)w; + if ((w = mbedtls_asn1_write_mpi(&c, buf, &r)) >= 0) { + n += (size_t)w; + if ((w = mbedtls_asn1_write_len(&c, buf, n)) >= 0) { + n += (size_t)w; + if ((w = mbedtls_asn1_write_tag(&c, buf, MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE)) >= 0) + out = (int)(n + (size_t)w); + } + } + } + } + mbedtls_mpi_free(&r); + mbedtls_mpi_free(&s); + return out; +} + +static size_t sp_ec_size(SpKey *k) { return (mbedtls_pk_ec(k->pk)->MBEDTLS_PRIVATE(grp).nbits + 7) / 8; } + +/* Applies the RSA padding of a signature operation. */ +static bool sp_rsa_padding(SpSigKey *key, mbedtls_md_type_t md) { + if (!sp_is_rsa(key->key)) return true; + mbedtls_rsa_context *rsa = mbedtls_pk_rsa(key->key->pk); + if (key->padding == 6) return mbedtls_rsa_set_padding(rsa, MBEDTLS_RSA_PKCS_V21, md) == 0; + return mbedtls_rsa_set_padding(rsa, MBEDTLS_RSA_PKCS_V15, MBEDTLS_MD_NONE) == 0; +} + +/* Signs a digest: +1 Buffer or NULL with the error pending. */ +static ScrDyn *sp_sign_hash(SpSigKey *key, mbedtls_md_type_t md, const unsigned char *hash, size_t hash_len) { + unsigned char sig[MBEDTLS_PK_SIGNATURE_MAX_SIZE]; + size_t sig_len = 0; + int r; + if (!sp_rsa_padding(key, md)) { + sp_unsupported_input(); + return NULL; + } + if (sp_is_rsa(key->key) && key->padding == 6) { + mbedtls_rsa_context *rsa = mbedtls_pk_rsa(key->key->pk); + int salt = key->salt; + size_t bytes = mbedtls_rsa_get_len(rsa); + size_t bits = mbedtls_pk_get_bitlen(&key->key->pk); + size_t max = bytes - hash_len - 2 - ((bits - 1) % 8 == 0 ? 1 : 0); + if (salt == -1) salt = (int)hash_len; + else if (salt == -2) salt = (int)max; + if (salt < 0 || (size_t)salt > max) { + sp_throw(SCR_ERR_ERROR, "ERR_OSSL_RSA_DATA_TOO_LARGE_FOR_KEY_SIZE", + "error:1C8000A5:Provider routines::data too large for key size"); + return NULL; + } + r = mbedtls_rsa_rsassa_pss_sign_ext(rsa, sp_random, NULL, md, (unsigned)hash_len, hash, salt, sig); + sig_len = bytes; + } else { + r = mbedtls_pk_sign(&key->key->pk, md, hash, hash_len, sig, sizeof sig, &sig_len, sp_random, NULL); + } + if (r != 0) { + sp_unsupported_input(); + return NULL; + } + if (sp_is_ec(key->key) && key->p1363) { + size_t size = sp_ec_size(key->key); + unsigned char raw[2 * 66]; + if (!sp_der_to_p1363(sig, sig_len, size, raw)) { + sp_unsupported_input(); + return NULL; + } + return sp_dyn_buffer(raw, 2 * size); + } + return sp_dyn_buffer(sig, sig_len); +} + +/* Verifies a digest against a signature; false for a signature that does + * not verify or does not parse. */ +static bool sp_verify_hash(SpSigKey *key, mbedtls_md_type_t md, const unsigned char *hash, size_t hash_len, + const unsigned char *sig, size_t sig_len) { + if (!sp_rsa_padding(key, md)) return false; + if (sp_is_rsa(key->key) && key->padding == 6) { + mbedtls_rsa_context *rsa = mbedtls_pk_rsa(key->key->pk); + if (sig_len != mbedtls_rsa_get_len(rsa)) return false; + int salt = key->salt; + if (salt == -1) salt = (int)hash_len; + else if (salt == -2) salt = MBEDTLS_RSA_SALT_LEN_ANY; + return mbedtls_rsa_rsassa_pss_verify_ext(rsa, md, (unsigned)hash_len, hash, md, salt, sig) == 0; + } + if (sp_is_ec(key->key) && key->p1363) { + unsigned char der[2 * 66 + 16]; + if (sig_len != 2 * sp_ec_size(key->key)) return false; + int n = sp_p1363_to_der(sig, sig_len, der, sizeof der); + if (n < 0) return false; + return mbedtls_pk_verify(&key->key->pk, md, hash, hash_len, der + sizeof der - n, (size_t)n) == 0; + } + return mbedtls_pk_verify(&key->key->pk, md, hash, hash_len, sig, sig_len) == 0; +} + +static const char sp_data_types[] = "an instance of Buffer, TypedArray, or DataView"; + +/* Ed25519 signs the message itself: an algorithm other than null or + * undefined is OpenSSL's invalid digest (false, error pending). */ +static bool sp_ed_digest_given(const ScrDyn *algorithm) { + if (algorithm->kind == SCR_DYN_UNDEF || algorithm->kind == SCR_DYN_NULL) return true; + sp_throw(SCR_ERR_ERROR, "ERR_OSSL_INVALID_DIGEST", "error:1C80007A:Provider routines::invalid digest"); + return false; +} + +/* crypto.sign(algorithm, data, key): the signature Buffer. */ +ScrDyn *scr_crypto_sign_oneshot(ScrDyn *algorithm, ScrDyn *data, ScrDyn *key) { + mbedtls_md_type_t md; + if (!sp_algorithm(algorithm, &md)) return NULL; + if (data->kind != SCR_DYN_BYTES) { + scr_dyn_arg_type_fail("data", sp_data_types, data); + return NULL; + } + SpSigKey k; + if (!sp_sig_key(key, true, &k)) return NULL; + ScrBytes *bytes = scr_bytes_buffer_source(data); + if (sp_is_ed(k.key)) { + ScrDyn *result = NULL; + const ScrPkiEd25519 *ed = sp_ed_digest_given(algorithm) ? sp_ed() : NULL; + if (ed) { + uint8_t sig[64]; + ed->sign(sig, k.key->ed_seed, k.key->ed_pub, bytes->data, (size_t)scr_bytes_byte_len(bytes)); + result = sp_dyn_buffer(sig, 64); + } + scr_bytes_release(bytes); + sp_key_release(k.key); + return result; + } + unsigned char hash[MBEDTLS_MD_MAX_SIZE]; + const mbedtls_md_info_t *info = mbedtls_md_info_from_type(md); + mbedtls_md(info, bytes->data, (size_t)scr_bytes_byte_len(bytes), hash); + scr_bytes_release(bytes); + ScrDyn *result = sp_sign_hash(&k, md, hash, mbedtls_md_get_size(info)); + sp_key_release(k.key); + return result; +} + +/* crypto.verify(algorithm, data, key, signature): a boolean. */ +ScrDyn *scr_crypto_verify_oneshot(ScrDyn *algorithm, ScrDyn *data, ScrDyn *key, ScrDyn *signature) { + mbedtls_md_type_t md; + if (!sp_algorithm(algorithm, &md)) return NULL; + if (data->kind != SCR_DYN_BYTES) { + scr_dyn_arg_type_fail("data", sp_data_types, data); + return NULL; + } + SpSigKey k; + if (!sp_sig_key(key, false, &k)) return NULL; + if (signature->kind != SCR_DYN_BYTES) { + sp_key_release(k.key); + scr_dyn_arg_type_fail("signature", sp_data_types, signature); + return NULL; + } + ScrBytes *bytes = scr_bytes_buffer_source(data); + ScrBytes *sig = scr_bytes_buffer_source(signature); + if (sp_is_ed(k.key)) { + ScrDyn *result = NULL; + const ScrPkiEd25519 *ed = sp_ed_digest_given(algorithm) ? sp_ed() : NULL; + if (ed) + result = scr_dyn_new_bool(sp_ed_verify(ed, k.key->ed_pub, bytes->data, + (size_t)scr_bytes_byte_len(bytes), sig->data, + (size_t)scr_bytes_byte_len(sig))); + scr_bytes_release(bytes); + scr_bytes_release(sig); + sp_key_release(k.key); + return result; + } + unsigned char hash[MBEDTLS_MD_MAX_SIZE]; + const mbedtls_md_info_t *info = mbedtls_md_info_from_type(md); + mbedtls_md(info, bytes->data, (size_t)scr_bytes_byte_len(bytes), hash); + bool ok = sp_verify_hash(&k, md, hash, mbedtls_md_get_size(info), sig->data, (size_t)scr_bytes_byte_len(sig)); + scr_bytes_release(bytes); + scr_bytes_release(sig); + sp_key_release(k.key); + return scr_dyn_new_bool(ok); +} + +/* ── Sign and Verify objects ──────────────────────────────────────────── */ + +typedef struct SpSigner { + size_t rc; + mbedtls_md_context_t md; + mbedtls_md_type_t type; + bool done; /* sign()/verify() ran: Node's "Not initialised" afterwards */ +} SpSigner; + +static void *sp_signer_retain(void *h) { + ((SpSigner *)h)->rc++; + return h; +} + +static void sp_signer_release(void *h) { + SpSigner *s = h; + if (--s->rc) return; + mbedtls_md_free(&s->md); + free(s); +} + +static void sp_not_initialised(void) { + sp_throw(SCR_ERR_ERROR, "ERR_CRYPTO_INVALID_STATE", "Not initialised"); +} + +/* update(data[, inputEncoding]): strings encode with the encoding (UTF-8 + * by default). */ +static bool sp_signer_update(SpSigner *s, ScrDyn *const *args, size_t argc) { + if (s->done) { + sp_not_initialised(); + return false; + } + const ScrDyn *data = argc ? args[0] : scr_dyn_undefined(); + if (data->kind != SCR_DYN_STR && data->kind != SCR_DYN_BYTES) { + scr_dyn_arg_type_fail("data", "of type string or an instance of Buffer, TypedArray, or DataView", data); + return false; + } + ScrBytes *bytes = sp_source_bytes(data, argc > 1 ? args[1] : NULL); + if (!bytes) return false; + mbedtls_md_update(&s->md, bytes->data, (size_t)scr_bytes_byte_len(bytes)); + scr_bytes_release(bytes); + return true; +} + +/* An output or signature encoding argument: a string encoding, or the + * Buffer form for undefined, null and "buffer". */ +static const ScrStr *sp_encoding_arg(const ScrDyn *v) { + if (v == NULL || v->kind != SCR_DYN_STR || sp_is_str(v, "buffer")) return NULL; + return v->v.str; +} + +static ScrDyn *sp_signer_invoke(void *h, ScrDyn *self, const char *method, ScrDyn *const *args, size_t argc, + const char *what, bool verifier) { + SpSigner *s = h; + if (strcmp(method, "update") == 0) return sp_signer_update(s, args, argc) ? scr_dyn_retain(self) : NULL; + if (!verifier && strcmp(method, "sign") == 0) { + if (s->done) { + sp_not_initialised(); + return NULL; + } + SpSigKey k; + if (!sp_sig_key(argc ? args[0] : scr_dyn_undefined(), true, &k)) return NULL; + if (sp_is_ed(k.key)) { + sp_key_release(k.key); + sp_throw(SCR_ERR_ERROR, "ERR_CRYPTO_UNSUPPORTED_OPERATION", "Unsupported crypto operation"); + return NULL; + } + unsigned char hash[MBEDTLS_MD_MAX_SIZE]; + mbedtls_md_finish(&s->md, hash); + s->done = true; + ScrDyn *sig = sp_sign_hash(&k, s->type, hash, mbedtls_md_get_size(mbedtls_md_info_from_type(s->type))); + sp_key_release(k.key); + const ScrStr *encoding = sp_encoding_arg(argc > 1 ? args[1] : NULL); + if (!sig || !encoding) return sig; + ScrBytes *bytes = scr_bytes_buffer_source(sig); + ScrStr *text = scr_bytes_to_str_checked(bytes, encoding); + scr_bytes_release(bytes); + scr_dyn_release(sig); + return text ? sp_dyn_str(text) : NULL; + } + if (verifier && strcmp(method, "verify") == 0) { + if (s->done) { + sp_not_initialised(); + return NULL; + } + SpSigKey k; + if (!sp_sig_key(argc ? args[0] : scr_dyn_undefined(), false, &k)) return NULL; + if (sp_is_ed(k.key)) { + sp_key_release(k.key); + sp_throw(SCR_ERR_ERROR, "ERR_CRYPTO_UNSUPPORTED_OPERATION", "Unsupported crypto operation"); + return NULL; + } + const ScrDyn *signature = argc > 1 ? args[1] : scr_dyn_undefined(); + if (signature->kind != SCR_DYN_STR && signature->kind != SCR_DYN_BYTES) { + sp_key_release(k.key); + scr_dyn_arg_type_fail("signature", "of type string or an instance of Buffer, TypedArray, or DataView", + signature); + return NULL; + } + const ScrStr *encoding = sp_encoding_arg(argc > 2 ? args[2] : NULL); + ScrDyn *encoding_value = encoding ? scr_dyn_new_str((ScrStr *)encoding) : NULL; + ScrBytes *sig = sp_source_bytes(signature, encoding_value); + if (encoding_value) scr_dyn_release(encoding_value); + if (!sig) { + sp_key_release(k.key); + return NULL; + } + unsigned char hash[MBEDTLS_MD_MAX_SIZE]; + mbedtls_md_finish(&s->md, hash); + s->done = true; + bool ok = sp_verify_hash(&k, s->type, hash, mbedtls_md_get_size(mbedtls_md_info_from_type(s->type)), + sig->data, (size_t)scr_bytes_byte_len(sig)); + scr_bytes_release(sig); + sp_key_release(k.key); + return scr_dyn_new_bool(ok); + } + char message[160]; + int n = snprintf(message, sizeof message, "%s is not a function", what); + scr_throw_error_msg(SCR_ERR_TYPE, message, (size_t)n); + return NULL; +} + +static ScrDyn *sp_sign_invoke(void *h, ScrDyn *self, const char *method, ScrDyn *const *args, size_t argc, + const char *what) { + return sp_signer_invoke(h, self, method, args, argc, what, false); +} + +static ScrDyn *sp_verify_invoke(void *h, ScrDyn *self, const char *method, ScrDyn *const *args, size_t argc, + const char *what) { + return sp_signer_invoke(h, self, method, args, argc, what, true); +} + +/* Sign and Verify have no modeled properties. */ +static ScrDyn *sp_signer_get(void *h, const char *name, size_t len) { + (void)h; + (void)name; + (void)len; + return NULL; +} + +static bool sp_signer_set(void *h, const char *name, size_t len, const ScrDyn *value) { + (void)h; + (void)name; + (void)len; + (void)value; + return false; +} + +static ScrDyn *sp_signer_inspect_view(void *h) { + (void)h; + return scr_dyn_new_obj(); +} + +static const ScrDynHandleOps sp_sign_ops = { + .cls = "Sign", + .retain = sp_signer_retain, + .release = sp_signer_release, + .invoke = sp_sign_invoke, + .get = sp_signer_get, + .set = sp_signer_set, + .inspect_view = sp_signer_inspect_view, +}; + +static const ScrDynHandleOps sp_verify_ops = { + .cls = "Verify", + .retain = sp_signer_retain, + .release = sp_signer_release, + .invoke = sp_verify_invoke, + .get = sp_signer_get, + .set = sp_signer_set, + .inspect_view = sp_signer_inspect_view, +}; + +/* createSign(algorithm) / createVerify(algorithm). */ +static ScrDyn *sp_signer_new(ScrDyn *algorithm, bool verifier) { + if (algorithm->kind != SCR_DYN_STR) { + scr_dyn_arg_type_fail("algorithm", "of type string", algorithm); + return NULL; + } + mbedtls_md_type_t md; + if (!sp_digest_of(algorithm->v.str, &md)) { + sp_throw(SCR_ERR_TYPE, "ERR_CRYPTO_INVALID_DIGEST", "Invalid digest"); + return NULL; + } + static SCR_TL bool installed; + if (!installed) { + installed = true; + scr_dyn_handle_install(SCR_DYNH_SIGN, &sp_sign_ops); + scr_dyn_handle_install(SCR_DYNH_VERIFY, &sp_verify_ops); + } + SpSigner *s = calloc(1, sizeof *s); + if (!s) scr_trap("scriptc: out of memory\n"); + s->rc = 1; + s->type = md; + mbedtls_md_init(&s->md); + mbedtls_md_setup(&s->md, mbedtls_md_info_from_type(md), 0); + mbedtls_md_starts(&s->md); + ScrDyn *box = scr_dyn_new_handle(s, verifier ? SCR_DYNH_VERIFY : SCR_DYNH_SIGN); + sp_signer_release(s); + return box; +} + +ScrDyn *scr_crypto_create_sign(ScrDyn *algorithm) { return sp_signer_new(algorithm, false); } + +ScrDyn *scr_crypto_create_verify(ScrDyn *algorithm) { return sp_signer_new(algorithm, true); } + +/* ── generateKeyPair ──────────────────────────────────────────────────── */ + +static ScrDyn *sp_cap(ScrClosure *c, size_t i) { return scr_box_get_ref(c->caps[i]); } + +static void sp_key_pair_deliver(ScrClosure *self) { + ScrDyn *callback = sp_cap(self, 0); + ScrDyn *pair = sp_cap(self, 1); + ScrDyn *args[3] = {scr_dyn_new_null(), scr_dyn_retain(scr_dyn_obj_get(pair, "publicKey", 9)), + scr_dyn_retain(scr_dyn_obj_get(pair, "privateKey", 10))}; + ScrDyn *result = scr_dyn_call(callback, args, 3, "callback"); + if (result) scr_dyn_release(result); + for (size_t i = 0; i < 3; i++) scr_dyn_release(args[i]); + scr_dyn_release(pair); + scr_dyn_release(callback); +} + +/* generateKeyPair(type, options, callback): argument errors throw, and the + * callback receives (null, publicKey, privateKey) in a later macrotask. */ +void scr_crypto_generate_key_pair_async(ScrDyn *type, ScrDyn *options, ScrDyn *callback) { + ScrDyn *pair = scr_crypto_generate_key_pair_sync(type, options); + if (!pair) return; + ScrClosure *c = scr_closure_new((void *)sp_key_pair_deliver, 2); + c->caps[0] = scr_box_new_obj(scr_dyn_retain_v, scr_dyn_release_v, NULL); + scr_box_set_ref(c->caps[0], scr_dyn_retain(callback)); + c->caps[1] = scr_box_new_obj(scr_dyn_retain_v, scr_dyn_release_v, NULL); + scr_box_set_ref(c->caps[1], pair); + scr_loop_defer(c); +} + +/* ── the core for the WebCrypto layer (scr_pki.h) ─────────────────────── */ + +ScrPkiKey *scr_pki_key_retain(ScrPkiKey *key) { return sp_key_retain(key); } + +void scr_pki_key_release(ScrPkiKey *key) { sp_key_release(key); } + +bool scr_pki_key_is_private(const ScrPkiKey *key) { return key->private_key; } + +bool scr_pki_key_is_rsa(const ScrPkiKey *key) { return sp_is_rsa(key); } + +bool scr_pki_key_is_ed25519(const ScrPkiKey *key) { return sp_is_ed(key); } + +const char *scr_pki_key_curve(const ScrPkiKey *key) { + const SpCurve *curve = sp_curve_of(key); + return curve ? curve->jwk : NULL; +} + +size_t scr_pki_key_bits(const ScrPkiKey *key) { return mbedtls_pk_get_bitlen(&key->pk); } + +ScrBytes *scr_pki_key_exponent(const ScrPkiKey *key) { + mbedtls_mpi e; + mbedtls_mpi_init(&e); + mbedtls_rsa_export(mbedtls_pk_rsa(key->pk), NULL, NULL, NULL, NULL, &e); + size_t n = mbedtls_mpi_size(&e); + ScrBytes *out = scr_bytes_new(SCR_BYTES_U8, (double)n); + if (n) mbedtls_mpi_write_binary(&e, out->data, n); + mbedtls_mpi_free(&e); + return out; +} + +ScrPkiKey *scr_pki_key_parse_der(const uint8_t *der, size_t len, bool private_key) { + if ((private_key && len == 48 && memcmp(der, sp_ed_pkcs8_prefix, 16) == 0) || + (!private_key && len == 44 && memcmp(der, sp_ed_spki_prefix, 12) == 0)) + { + bool failed; + return sp_ed_from_der(der, len, private_key, &failed); + } + SpKey *k = sp_key_alloc(private_key); + int r = private_key ? mbedtls_pk_parse_key(&k->pk, der, len, NULL, 0, sp_random, NULL) + : mbedtls_pk_parse_public_key(&k->pk, der, len); + if (r != 0 || !sp_key_supported(k)) { + sp_key_release(k); + return NULL; + } + return k; +} + +ScrPkiKey *scr_pki_key_from_jwk(const ScrDyn *jwk, bool private_key) { + SpKey *k = sp_key_from_jwk(jwk, private_key); + if (!k) scr_exc_clear(); + return k; +} + +ScrPkiKey *scr_pki_key_from_point(const char *curve_name, const uint8_t *point, size_t len) { + const SpCurve *curve = NULL; + for (size_t i = 0; i < sizeof sp_curves / sizeof sp_curves[0]; i++) + if (strcmp(sp_curves[i].jwk, curve_name) == 0) curve = &sp_curves[i]; + if (!curve) return NULL; + SpKey *k = sp_key_alloc(false); + bool ok = false; + if (mbedtls_pk_setup(&k->pk, mbedtls_pk_info_from_type(MBEDTLS_PK_ECKEY)) == 0) { + mbedtls_ecp_keypair *ec = mbedtls_pk_ec(k->pk); + ok = mbedtls_ecp_group_load(&ec->MBEDTLS_PRIVATE(grp), curve->id) == 0 && + mbedtls_ecp_point_read_binary(&ec->MBEDTLS_PRIVATE(grp), &ec->MBEDTLS_PRIVATE(Q), point, len) == 0 && + mbedtls_ecp_check_pubkey(&ec->MBEDTLS_PRIVATE(grp), &ec->MBEDTLS_PRIVATE(Q)) == 0; + } + if (!ok) { + sp_key_release(k); + return NULL; + } + return k; +} + +ScrPkiKey *scr_pki_key_public_of(ScrPkiKey *key) { return sp_public_of(key); } + +ScrPkiKey *scr_pki_generate_rsa(unsigned bits, uint64_t exponent) { + SpKey *k = sp_key_alloc(true); + if (exponent > 2147483647 || mbedtls_pk_setup(&k->pk, mbedtls_pk_info_from_type(MBEDTLS_PK_RSA)) != 0 || + mbedtls_rsa_gen_key(mbedtls_pk_rsa(k->pk), sp_random, NULL, bits, (int)exponent) != 0) { + sp_key_release(k); + return NULL; + } + return k; +} + +ScrPkiKey *scr_pki_generate_ec(const char *curve_name) { + const SpCurve *curve = NULL; + for (size_t i = 0; i < sizeof sp_curves / sizeof sp_curves[0]; i++) + if (strcmp(sp_curves[i].jwk, curve_name) == 0) curve = &sp_curves[i]; + SpKey *k = sp_key_alloc(true); + if (!curve || mbedtls_pk_setup(&k->pk, mbedtls_pk_info_from_type(MBEDTLS_PK_ECKEY)) != 0 || + mbedtls_ecp_gen_key(curve->id, mbedtls_pk_ec(k->pk), sp_random, NULL) != 0) { + sp_key_release(k); + return NULL; + } + return k; +} + +ScrPkiKey *scr_pki_generate_ed25519(void) { + const ScrPkiEd25519 *ed = sp_ed(); + if (!ed) return NULL; + SpKey *k = sp_key_alloc(true); + k->ed25519 = true; + sp_random(NULL, k->ed_seed, 32); + ed->public_key(k->ed_pub, k->ed_seed); + return k; +} + +ScrPkiKey *scr_pki_key_from_ed25519_raw(const uint8_t *raw, size_t len) { + if (len != 32) return NULL; + SpKey *k = sp_key_alloc(false); + k->ed25519 = true; + memcpy(k->ed_pub, raw, 32); + return k; +} + +ScrBytes *scr_pki_export_ed25519_raw(ScrPkiKey *key) { + ScrBytes *out = scr_bytes_new(SCR_BYTES_U8, 32); + memcpy(out->data, key->ed_pub, 32); + return out; +} + +ScrBytes *scr_pki_export_der(ScrPkiKey *key) { + unsigned char *der = malloc(SP_DER_MAX); + if (!der) scr_trap("scriptc: out of memory\n"); + int n = key->private_key ? sp_write_pkcs8_der(key, der, SP_DER_MAX) : sp_write_spki_der(key, der, SP_DER_MAX); + ScrBytes *out = NULL; + if (n > 0) { + out = scr_bytes_new(SCR_BYTES_U8, (double)n); + memcpy(out->data, der + SP_DER_MAX - n, (size_t)n); + } + mbedtls_platform_zeroize(der, SP_DER_MAX); + free(der); + return out; +} + +ScrBytes *scr_pki_export_point(ScrPkiKey *key) { + const mbedtls_ecp_keypair *ec = mbedtls_pk_ec(key->pk); + unsigned char point[160]; + size_t n; + if (mbedtls_ecp_point_write_binary(&ec->MBEDTLS_PRIVATE(grp), &ec->MBEDTLS_PRIVATE(Q), + MBEDTLS_ECP_PF_UNCOMPRESSED, &n, point, sizeof point) != 0) + return NULL; + ScrBytes *out = scr_bytes_new(SCR_BYTES_U8, (double)n); + memcpy(out->data, point, n); + return out; +} + +ScrDyn *scr_pki_export_jwk(ScrPkiKey *key) { return sp_export_jwk(key); } + +static bool sp_webcrypto_md(const char *hash, mbedtls_md_type_t *md) { + if (strcmp(hash, "SHA-1") == 0) *md = MBEDTLS_MD_SHA1; + else if (strcmp(hash, "SHA-256") == 0) *md = MBEDTLS_MD_SHA256; + else if (strcmp(hash, "SHA-384") == 0) *md = MBEDTLS_MD_SHA384; + else if (strcmp(hash, "SHA-512") == 0) *md = MBEDTLS_MD_SHA512; + else return false; + return true; +} + +ScrBytes *scr_pki_sign(ScrPkiKey *key, const char *hash, bool pss, int salt, const uint8_t *data, + size_t len) { + if (sp_is_ed(key)) { + const ScrPkiEd25519 *ed = sp_ed(); + if (!ed) return NULL; + ScrBytes *out = scr_bytes_new(SCR_BYTES_U8, 64); + ed->sign(out->data, key->ed_seed, key->ed_pub, data, len); + return out; + } + mbedtls_md_type_t md; + if (!sp_webcrypto_md(hash, &md)) return NULL; + const mbedtls_md_info_t *info = mbedtls_md_info_from_type(md); + unsigned char digest[MBEDTLS_MD_MAX_SIZE]; + mbedtls_md(info, data, len, digest); + SpSigKey k = {.key = key, .padding = pss ? 6 : 1, .salt = salt, .p1363 = true}; + ScrDyn *sig = sp_sign_hash(&k, md, digest, mbedtls_md_get_size(info)); + if (!sig) { + scr_exc_clear(); + return NULL; + } + ScrBytes *out = scr_bytes_buffer_source(sig); + scr_dyn_release(sig); + return out; +} + +bool scr_pki_verify(ScrPkiKey *key, const char *hash, bool pss, int salt, const uint8_t *data, + size_t len, const uint8_t *signature, size_t signature_len) { + if (sp_is_ed(key)) { + const ScrPkiEd25519 *ed = sp_ed(); + return ed && sp_ed_verify(ed, key->ed_pub, data, len, signature, signature_len); + } + mbedtls_md_type_t md; + if (!sp_webcrypto_md(hash, &md)) return false; + const mbedtls_md_info_t *info = mbedtls_md_info_from_type(md); + unsigned char digest[MBEDTLS_MD_MAX_SIZE]; + mbedtls_md(info, data, len, digest); + SpSigKey k = {.key = key, .padding = pss ? 6 : 1, .salt = salt, .p1363 = true}; + return sp_verify_hash(&k, md, digest, mbedtls_md_get_size(info), signature, signature_len); +} diff --git a/packages/runtime/src/scr_pki.h b/packages/runtime/src/scr_pki.h new file mode 100644 index 000000000..e299806f7 --- /dev/null +++ b/packages/runtime/src/scr_pki.h @@ -0,0 +1,75 @@ +/* The key and signature core of scr_pki.c, for the WebCrypto layer + * (scr_webcrypto_pki.c) and the Ed25519 unit (scr_ed25519.c). Keys are + * reference-counted RSA keys, EC keys on P-256, P-384, P-521 or secp256k1, + * or Ed25519 keys. Functions answering NULL or false set no error unless + * they say so; byte results are +1. */ +#ifndef SCR_PKI_H +#define SCR_PKI_H + +#include +#include +#include + +typedef struct SpKey ScrPkiKey; + +/* The Ed25519 arithmetic (scr_ed25519.c), installed at startup in + * programs that name Ed25519; NULL otherwise. Keys are the 32-byte seed + * and the 32-byte encoded public point. */ +typedef struct { + void (*public_key)(uint8_t pub[32], const uint8_t seed[32]); + void (*sign)(uint8_t sig[64], const uint8_t seed[32], const uint8_t pub[32], const uint8_t *m, size_t n); + bool (*verify)(const uint8_t pub[32], const uint8_t *m, size_t n, const uint8_t sig[64]); +} ScrPkiEd25519; +extern const ScrPkiEd25519 *scr_pki_ed25519; + +/* Whether the Ed25519 arithmetic is linked; false with a coded SC2020 + * error pending otherwise. */ +bool scr_pki_ed25519_ready(void); + +ScrPkiKey *scr_pki_key_retain(ScrPkiKey *key); +void scr_pki_key_release(ScrPkiKey *key); +bool scr_pki_key_is_private(const ScrPkiKey *key); +bool scr_pki_key_is_rsa(const ScrPkiKey *key); +bool scr_pki_key_is_ed25519(const ScrPkiKey *key); +/* The EC key's JWK curve name ("P-256", ...), or NULL for RSA keys. */ +const char *scr_pki_key_curve(const ScrPkiKey *key); +/* The RSA modulus length in bits. */ +size_t scr_pki_key_bits(const ScrPkiKey *key); +/* The RSA public exponent's big-endian bytes, without leading zeros. */ +ScrBytes *scr_pki_key_exponent(const ScrPkiKey *key); + +/* A key from SubjectPublicKeyInfo (public) or PKCS#8 (private) DER. */ +ScrPkiKey *scr_pki_key_parse_der(const uint8_t *der, size_t len, bool private_key); +/* A key from a JWK object (borrowed; a plain object). */ +ScrPkiKey *scr_pki_key_from_jwk(const ScrDyn *jwk, bool private_key); +/* A public EC key from an uncompressed or compressed point. */ +ScrPkiKey *scr_pki_key_from_point(const char *curve, const uint8_t *point, size_t len); +ScrPkiKey *scr_pki_key_public_of(ScrPkiKey *key); +ScrPkiKey *scr_pki_generate_rsa(unsigned bits, uint64_t exponent); +ScrPkiKey *scr_pki_generate_ec(const char *curve); +/* NULL with a coded SC2020 error pending when the program does not link + * the Ed25519 unit. */ +ScrPkiKey *scr_pki_generate_ed25519(void); +/* A public Ed25519 key from its 32-byte encoding. */ +ScrPkiKey *scr_pki_key_from_ed25519_raw(const uint8_t *raw, size_t len); +/* The Ed25519 public key's 32-byte encoding. */ +ScrBytes *scr_pki_export_ed25519_raw(ScrPkiKey *key); + +/* SubjectPublicKeyInfo (public keys) or PKCS#8 (private keys) DER. */ +ScrBytes *scr_pki_export_der(ScrPkiKey *key); +/* The EC public key's uncompressed point. */ +ScrBytes *scr_pki_export_point(ScrPkiKey *key); +/* The JWK members in Node's order (kty, n, e, ... or kty, x, y, crv, d), + * +1. */ +ScrDyn *scr_pki_export_jwk(ScrPkiKey *key); + +/* Signs `data` with the digest named by its WebCrypto name ("SHA-256"): + * RSA PKCS#1 v1.5 (pss false), RSA-PSS with `salt` bytes, or ECDSA as + * IEEE P1363 r || s. Ed25519 keys sign the message itself (hash + * ignored). */ +ScrBytes *scr_pki_sign(ScrPkiKey *key, const char *hash, bool pss, int salt, const uint8_t *data, + size_t len); +bool scr_pki_verify(ScrPkiKey *key, const char *hash, bool pss, int salt, const uint8_t *data, + size_t len, const uint8_t *signature, size_t signature_len); + +#endif diff --git a/packages/runtime/src/scr_webcrypto.c b/packages/runtime/src/scr_webcrypto.c index 546b24151..a11b22fe4 100644 --- a/packages/runtime/src/scr_webcrypto.c +++ b/packages/runtime/src/scr_webcrypto.c @@ -18,6 +18,7 @@ * SC2020 Error instead of silently diverging. The compiler links the unit * only into programs that call these methods (the webcrypto feature). */ #include "scr_runtime.h" +#include "scr_webcrypto.h" #include #include @@ -43,13 +44,12 @@ static const char *const scr_wc_sign_names[] = { "ECDSA", "Ed25519", "Ed448", "HMAC", "KMAC128", "KMAC256", "ML-DSA-44", "ML-DSA-65", "ML-DSA-87", "RSA-PSS", "RSASSA-PKCS1-v1_5", }; -static const char *const scr_wc_digest_names[] = { +const char *const scr_wc_digest_names[] = { "SHA-1", "SHA-256", "SHA-384", "SHA-512", "SHA3-256", "SHA3-384", "SHA3-512", "cSHAKE128", "cSHAKE256", "KT128", "KT256", "TurboSHAKE128", "TurboSHAKE256", }; -#define SCR_WC_COUNT(names) (sizeof(names) / sizeof((names)[0])) /* The implemented hashes: WebCrypto name and node:crypto digest name. */ static const struct { @@ -75,7 +75,7 @@ static bool scr_wc_ascii_ieq(const ScrStr *s, const char *name) { } /* The canonical registered spelling of `name`, or NULL. */ -static const char *scr_wc_lookup(const char *const *names, size_t count, const ScrStr *name) { +const char *scr_wc_lookup(const char *const *names, size_t count, const ScrStr *name) { for (size_t i = 0; i < count; i++) if (scr_wc_ascii_ieq(name, names[i])) return names[i]; return NULL; @@ -89,11 +89,9 @@ static const char *scr_wc_native_hash(const char *name) { /* ── errors ────────────────────────────────────────────────────────── */ -static const char *const scr_wc_ordinals[] = {"1st", "2nd", "3rd", "4th", "5th"}; +const char *const scr_wc_ordinals[] = {"1st", "2nd", "3rd", "4th", "5th"}; -static void scr_wc_type_error(const char *code, const char *fmt, ...) - __attribute__((format(printf, 2, 3))); -static void scr_wc_type_error(const char *code, const char *fmt, ...) { +void scr_wc_type_error(const char *code, const char *fmt, ...) { char message[512]; va_list ap; va_start(ap, fmt); @@ -105,7 +103,7 @@ static void scr_wc_type_error(const char *code, const char *fmt, ...) { } /* An operation or algorithm Node supports that this slice does not. */ -static void scr_wc_unsupported(const char *method, const char *what) { +void scr_wc_unsupported(const char *method, const char *what) { char message[256]; int n = snprintf(message, sizeof message, "crypto.subtle.%s with %s is not supported yet", method, what); @@ -113,7 +111,7 @@ static void scr_wc_unsupported(const char *method, const char *what) { scr_throw_error_msg_code(SCR_ERR_ERROR, message, (size_t)n, "SC2020"); } -static void scr_wc_unsupported_algorithm(const char *method, const char *name) { +void scr_wc_unsupported_algorithm(const char *method, const char *name) { char what[96]; snprintf(what, sizeof what, "the %s algorithm", name); scr_wc_unsupported(method, what); @@ -123,7 +121,7 @@ static void scr_wc_unsupported_algorithm(const char *method, const char *name) { * Each answers NULL/false with the TypeError pending. `prefix` is * "Failed to execute '' on 'SubtleCrypto'". */ -static bool scr_wc_is_object(const ScrDyn *v) { +bool scr_wc_is_object(const ScrDyn *v) { switch (v->kind) { case SCR_DYN_UNDEF: case SCR_DYN_NULL: @@ -139,14 +137,14 @@ static bool scr_wc_is_object(const ScrDyn *v) { } /* A typed reference capsule as its plain view; other values retained. */ -static ScrDyn *scr_wc_plain(ScrDyn *v) { +ScrDyn *scr_wc_plain(ScrDyn *v) { if (v->kind == SCR_DYN_TYPED_REF) return scr_dyn_typed_ref_materialize(v); return scr_dyn_retain(v); } /* BufferSource: the bytes of a TypedArray, DataView, Buffer or * ArrayBuffer as a u8 view (+1). */ -static ScrBytes *scr_wc_buffer_source(const char *prefix, size_t index, ScrDyn *value) { +ScrBytes *scr_wc_buffer_source(const char *prefix, size_t index, ScrDyn *value) { ScrDyn *plain = scr_wc_plain(value); if (!plain) return NULL; ScrBytes *view = NULL; @@ -163,14 +161,14 @@ static ScrBytes *scr_wc_buffer_source(const char *prefix, size_t index, ScrDyn * } /* DOMString conversion (+1). */ -static ScrStr *scr_wc_dom_string(const ScrDyn *value) { return scr_dyn_string_coerce_js(value); } +ScrStr *scr_wc_dom_string(const ScrDyn *value) { return scr_dyn_string_coerce_js(value); } static const char *const scr_wc_key_formats[] = { "raw", "raw-public", "raw-seed", "raw-secret", "raw-private", "pkcs8", "spki", "jwk", }; /* KeyFormat: the canonical enum spelling, or NULL. */ -static const char *scr_wc_key_format(const char *prefix, ScrDyn *value) { +const char *scr_wc_key_format(const char *prefix, ScrDyn *value) { ScrStr *s = scr_wc_dom_string(value); if (!s) return NULL; for (size_t i = 0; i < SCR_WC_COUNT(scr_wc_key_formats); i++) { @@ -188,15 +186,14 @@ static const char *scr_wc_key_format(const char *prefix, ScrDyn *value) { } /* Node's canonical usage order; the bit is the index. */ -static const char *const scr_wc_usages[] = { +const char *const scr_wc_usages[] = { "encrypt", "decrypt", "sign", "verify", "deriveKey", "deriveBits", "wrapKey", "unwrapKey", "encapsulateKey", "encapsulateBits", "decapsulateKey", "decapsulateBits", }; -enum { SCR_WC_USAGE_SIGN = 1u << 2, SCR_WC_USAGE_VERIFY = 1u << 3 }; /* sequence over an array: the usage mask (-1 on failure). */ -static long scr_wc_key_usages(const char *prefix, size_t index, ScrDyn *value) { +long scr_wc_key_usages(const char *prefix, size_t index, ScrDyn *value) { ScrDyn *plain = scr_wc_plain(value); if (!plain) return -1; if (plain->kind != SCR_DYN_ARR) { @@ -245,9 +242,9 @@ typedef struct { double length; } ScrWcAlgorithm; -static const char scr_wc_normalize_prefix[] = "Failed to normalize algorithm"; +const char scr_wc_normalize_prefix[] = "Failed to normalize algorithm"; -static void scr_wc_missing_member(const char *dict, const char *member) { +void scr_wc_missing_member(const char *dict, const char *member) { scr_wc_type_error("ERR_MISSING_OPTION", "%s: passed algorithm cannot be converted to '%s' because '%s' is required in " "'%s'.", @@ -255,7 +252,7 @@ static void scr_wc_missing_member(const char *dict, const char *member) { } /* Reads `key` off an algorithm dictionary (+1; undefined when absent). */ -static ScrDyn *scr_wc_member(const ScrDyn *dict, const char *key) { +ScrDyn *scr_wc_member(const ScrDyn *dict, const char *key) { if (dict->kind != SCR_DYN_OBJ) return scr_dyn_retain(scr_dyn_undefined()); ScrDyn *v = scr_dyn_obj_read(dict, key, strlen(key)); return v ? v : scr_dyn_retain(scr_dyn_undefined()); @@ -264,7 +261,7 @@ static ScrDyn *scr_wc_member(const ScrDyn *dict, const char *key) { /* The name an AlgorithmIdentifier carries (+1), with the Algorithm * dictionary's missing-name TypeError. `dict` names the dictionary the * value converts to. */ -static ScrStr *scr_wc_algorithm_name(ScrDyn *identifier, const char *dict) { +ScrStr *scr_wc_algorithm_name(ScrDyn *identifier, const char *dict) { if (!scr_wc_is_object(identifier)) return scr_wc_dom_string(identifier); ScrDyn *plain = scr_wc_plain(identifier); if (!plain) return NULL; @@ -279,7 +276,7 @@ static ScrStr *scr_wc_algorithm_name(ScrDyn *identifier, const char *dict) { /* The digest a HashAlgorithmIdentifier names: canonical name, or NULL * with NotSupportedError / the SC2020 refusal pending. */ -static const char *scr_wc_digest_algorithm(ScrDyn *identifier, const char *method) { +const char *scr_wc_digest_algorithm(ScrDyn *identifier, const char *method) { ScrStr *name = scr_wc_algorithm_name(identifier, "Algorithm"); if (!name) return NULL; const char *canonical = scr_wc_lookup(scr_wc_digest_names, SCR_WC_COUNT(scr_wc_digest_names), name); @@ -436,10 +433,10 @@ static ScrCryptoKey *scr_crypto_key_of(const ScrDyn *value) { bool scr_webcrypto_is_crypto_key(const ScrDyn *value) { if (value->kind == SCR_DYN_TYPED_REF) return false; - return scr_crypto_key_of(value) != NULL; + return scr_crypto_key_of(value) != NULL || (scr_wc_asymmetric && scr_wc_asymmetric->is_key(value)); } -static ScrDyn *scr_wc_cstr(const char *s) { +ScrDyn *scr_wc_cstr(const char *s) { ScrStr *str = scr_str_new(s, strlen(s)); ScrDyn *out = scr_dyn_new_str(str); scr_str_release(str); @@ -567,7 +564,43 @@ static ScrDyn *scr_crypto_key_new(const unsigned char *data, size_t len, const c * Each takes its argument vector as one dyn array (borrowed) and answers * a +1 promise. */ -static ScrPromise *scr_wc_rejected(void) { +const ScrWcAsymmetric *scr_wc_asymmetric = NULL; + +static const char *const scr_wc_asymmetric_names[] = {"ECDSA", "Ed25519", "RSA-PSS", "RSASSA-PKCS1-v1_5"}; + +/* Whether the AlgorithmIdentifier at args[index] names ECDSA, + * RSASSA-PKCS1-v1_5, RSA-PSS or Ed25519, read without side effects or errors: a + * string, or the name member of an object (a statically typed one through + * its plain view). A value that does not read cleanly takes the HMAC path, + * which reports its errors. */ +static const char *scr_wc_asymmetric_name(const ScrDyn *args, size_t index) { + if ((size_t)scr_dyn_arr_len(args) <= index) return NULL; + ScrDyn *identifier = scr_dyn_arr_at(args, (double)index); + ScrDyn *plain = scr_wc_plain(identifier); + if (!plain) scr_exc_clear(); + const char *found = NULL; + if (plain) { + const ScrDyn *name = plain; + if (plain->kind == SCR_DYN_OBJ) name = scr_dyn_obj_get(plain, "name", 4); + if (name && name->kind == SCR_DYN_STR) + found = scr_wc_lookup(scr_wc_asymmetric_names, SCR_WC_COUNT(scr_wc_asymmetric_names), + name->v.str); + scr_dyn_release(plain); + } + scr_dyn_release(identifier); + return found; +} + +/* The asymmetric algorithms run in scr_webcrypto_pki.c, which the compiler + * links when a string literal in the program names one of them. */ +static ScrPromise *scr_wc_asymmetric_missing(const char *method, const char *name) { + char what[160]; + snprintf(what, sizeof what, "the %s algorithm named only by a computed string", name); + scr_wc_unsupported(method, what); + return scr_wc_rejected(); +} + +ScrPromise *scr_wc_rejected(void) { ScrPromise *p = scr_promise_new(); scr_promise_reject_pending(p); return p; @@ -575,7 +608,7 @@ static ScrPromise *scr_wc_rejected(void) { /* The argument count check every method starts with (after the receiver * check the compiler's call shape already guarantees). */ -static bool scr_wc_required(const char *prefix, const ScrDyn *args, size_t required) { +bool scr_wc_required(const char *prefix, const ScrDyn *args, size_t required) { size_t argc = (size_t)scr_dyn_arr_len(args); if (argc >= required) return true; scr_wc_type_error("ERR_MISSING_ARGS", "%s: %zu arguments required, but only %zu present.", prefix, @@ -583,15 +616,12 @@ static bool scr_wc_required(const char *prefix, const ScrDyn *args, size_t requi return false; } -typedef struct { - ScrDyn *v[5]; -} ScrWcArgs; -static void scr_wc_args_take(ScrWcArgs *a, const ScrDyn *args, size_t n) { +void scr_wc_args_take(ScrWcArgs *a, const ScrDyn *args, size_t n) { for (size_t i = 0; i < n; i++) a->v[i] = scr_dyn_arr_at(args, (double)i); } -static void scr_wc_args_drop(ScrWcArgs *a, size_t n) { +void scr_wc_args_drop(ScrWcArgs *a, size_t n) { for (size_t i = 0; i < n; i++) scr_dyn_release(a->v[i]); } @@ -681,6 +711,11 @@ done: } ScrPromise *scr_webcrypto_import_key(ScrDyn *args) { + const char *asymmetric = scr_wc_asymmetric_name(args, 2); + if (asymmetric) { + return scr_wc_asymmetric ? scr_wc_asymmetric->import_key(args) + : scr_wc_asymmetric_missing("importKey", asymmetric); + } ScrDyn *key = scr_wc_import(args); if (!key) return scr_wc_rejected(); return scr_promise_settled_ref(key, &scr_dyn_retain_v, &scr_dyn_release_v, NULL); @@ -706,7 +741,8 @@ static bool scr_wc_sign_verify(const ScrDyn *args, bool verify, unsigned char ma scr_str_release(s); } ScrCryptoKey *key = scr_crypto_key_of(a.v[1]); - if (!key) { + bool asymmetric_key = !key && scr_wc_asymmetric && scr_wc_asymmetric->is_key(a.v[1]); + if (!key && !asymmetric_key) { scr_wc_type_error("ERR_INVALID_ARG_TYPE", "%s: 2nd argument is not of type CryptoKey.", prefix); goto done; } @@ -724,6 +760,10 @@ static bool scr_wc_sign_verify(const ScrDyn *args, bool verify, unsigned char ma scr_wc_unsupported_algorithm(method, algorithm.name); goto done; } + if (asymmetric_key) { + scr_throw_domex("InvalidAccessError", "Key algorithm mismatch"); + goto done; + } if (!(key->usages & (verify ? SCR_WC_USAGE_VERIFY : SCR_WC_USAGE_SIGN))) { char message[64]; snprintf(message, sizeof message, "Unable to use this key to %s", method); @@ -744,6 +784,11 @@ done: } ScrPromise *scr_webcrypto_sign(ScrDyn *args) { + const char *asymmetric = scr_wc_asymmetric_name(args, 0); + if (asymmetric) { + return scr_wc_asymmetric ? scr_wc_asymmetric->sign(args) + : scr_wc_asymmetric_missing("sign", asymmetric); + } unsigned char mac[64]; size_t mac_len = 0; if (!scr_wc_sign_verify(args, false, mac, &mac_len, NULL)) return scr_wc_rejected(); @@ -766,6 +811,11 @@ static void scr_wc_settle_verified(ScrClosure *cb, ScrError *error, ScrBytes *va } ScrPromise *scr_webcrypto_verify(ScrDyn *args) { + const char *asymmetric = scr_wc_asymmetric_name(args, 0); + if (asymmetric) { + return scr_wc_asymmetric ? scr_wc_asymmetric->verify(args) + : scr_wc_asymmetric_missing("verify", asymmetric); + } unsigned char mac[64]; size_t mac_len = 0; ScrBytes *signature = NULL; @@ -827,3 +877,53 @@ done: scr_crypto_promise_settle_array_buffer); return p; } + +/* generateKey(algorithm, extractable, keyUsages): ECDSA, + * RSASSA-PKCS1-v1_5 and RSA-PSS key pairs (scr_webcrypto_pki.c); other + * recognized algorithms are refused after Node's argument conversions. */ +ScrPromise *scr_webcrypto_generate_key(ScrDyn *args) { + const char *asymmetric = scr_wc_asymmetric_name(args, 0); + if (asymmetric) { + return scr_wc_asymmetric ? scr_wc_asymmetric->generate_key(args) + : scr_wc_asymmetric_missing("generateKey", asymmetric); + } + static const char prefix[] = "Failed to execute 'generateKey' on 'SubtleCrypto'"; + if (!scr_wc_required(prefix, args, 3)) return scr_wc_rejected(); + ScrWcArgs a; + scr_wc_args_take(&a, args, 3); + bool converted = true; + if (!scr_wc_is_object(a.v[0])) { + ScrStr *str = scr_wc_dom_string(a.v[0]); + if (str) scr_str_release(str); + else converted = false; + } + if (converted && scr_wc_key_usages(prefix, 2, a.v[2]) >= 0) { + ScrStr *name = scr_wc_algorithm_name(a.v[0], "Algorithm"); + if (name) { + const char *known = scr_wc_lookup(scr_wc_import_names, SCR_WC_COUNT(scr_wc_import_names), name); + scr_str_release(name); + if (!known) scr_throw_domex("NotSupportedError", "Unrecognized algorithm name"); + else scr_wc_unsupported_algorithm("generateKey", known); + } + } + scr_wc_args_drop(&a, 3); + return scr_wc_rejected(); +} + +/* exportKey(format, key): ECDSA and RSA keys (scr_webcrypto_pki.c); HMAC + * keys are refused after Node's argument conversions. */ +ScrPromise *scr_webcrypto_export_key(ScrDyn *args) { + static const char prefix[] = "Failed to execute 'exportKey' on 'SubtleCrypto'"; + if (!scr_wc_required(prefix, args, 2)) return scr_wc_rejected(); + ScrWcArgs a; + scr_wc_args_take(&a, args, 2); + ScrPromise *result = NULL; + if (scr_wc_key_format(prefix, a.v[0])) { + if (scr_wc_asymmetric && scr_wc_asymmetric->is_key(a.v[1])) result = scr_wc_asymmetric->export_key(args); + else if (scr_crypto_key_of(a.v[1])) scr_wc_unsupported("exportKey", "HMAC keys"); + else + scr_wc_type_error("ERR_INVALID_ARG_TYPE", "%s: 2nd argument is not of type CryptoKey.", prefix); + } + scr_wc_args_drop(&a, 2); + return result ? result : scr_wc_rejected(); +} diff --git a/packages/runtime/src/scr_webcrypto.h b/packages/runtime/src/scr_webcrypto.h new file mode 100644 index 000000000..c8d7d83bc --- /dev/null +++ b/packages/runtime/src/scr_webcrypto.h @@ -0,0 +1,58 @@ +/* The Web IDL and error helpers of scr_webcrypto.c that the asymmetric + * algorithms (scr_webcrypto_pki.c) share, and the table through which + * scr_webcrypto.c reaches them when that unit is linked. */ +#ifndef SCR_WEBCRYPTO_H +#define SCR_WEBCRYPTO_H + +#include +#include + +#define SCR_WC_COUNT(names) (sizeof(names) / sizeof((names)[0])) + +enum { SCR_WC_USAGE_SIGN = 1u << 2, SCR_WC_USAGE_VERIFY = 1u << 3 }; + +/* Node's canonical usage order; the bit is the index. */ +extern const char *const scr_wc_usages[12]; +extern const char *const scr_wc_ordinals[5]; +extern const char scr_wc_normalize_prefix[]; +extern const char *const scr_wc_digest_names[13]; + +typedef struct { + ScrDyn *v[5]; +} ScrWcArgs; + +void scr_wc_type_error(const char *code, const char *fmt, ...) __attribute__((format(printf, 2, 3))); +void scr_wc_unsupported(const char *method, const char *what); +void scr_wc_unsupported_algorithm(const char *method, const char *name); +bool scr_wc_is_object(const ScrDyn *v); +ScrDyn *scr_wc_plain(ScrDyn *v); +ScrBytes *scr_wc_buffer_source(const char *prefix, size_t index, ScrDyn *value); +ScrStr *scr_wc_dom_string(const ScrDyn *value); +const char *scr_wc_key_format(const char *prefix, ScrDyn *value); +long scr_wc_key_usages(const char *prefix, size_t index, ScrDyn *value); +void scr_wc_missing_member(const char *dict, const char *member); +ScrDyn *scr_wc_member(const ScrDyn *dict, const char *key); +ScrStr *scr_wc_algorithm_name(ScrDyn *identifier, const char *dict); +const char *scr_wc_digest_algorithm(ScrDyn *identifier, const char *method); +const char *scr_wc_lookup(const char *const *names, size_t count, const ScrStr *name); +ScrDyn *scr_wc_cstr(const char *s); +ScrPromise *scr_wc_rejected(void); +bool scr_wc_required(const char *prefix, const ScrDyn *args, size_t required); +void scr_wc_args_take(ScrWcArgs *a, const ScrDyn *args, size_t n); +void scr_wc_args_drop(ScrWcArgs *a, size_t n); + +/* ECDSA, RSASSA-PKCS1-v1_5 and RSA-PSS (scr_webcrypto_pki.c, linked with + * the pki unit): each takes the method's argument vector (borrowed) and + * answers a +1 promise. NULL until that unit installs it. */ +typedef struct { + ScrPromise *(*generate_key)(const ScrDyn *args); + ScrPromise *(*import_key)(const ScrDyn *args); + ScrPromise *(*export_key)(const ScrDyn *args); + ScrPromise *(*sign)(const ScrDyn *args); + ScrPromise *(*verify)(const ScrDyn *args); + bool (*is_key)(const ScrDyn *value); +} ScrWcAsymmetric; + +extern const ScrWcAsymmetric *scr_wc_asymmetric; + +#endif diff --git a/packages/runtime/src/scr_webcrypto_pki.c b/packages/runtime/src/scr_webcrypto_pki.c new file mode 100644 index 000000000..e913b1dc6 --- /dev/null +++ b/packages/runtime/src/scr_webcrypto_pki.c @@ -0,0 +1,845 @@ +/* WebCrypto's ECDSA, RSASSA-PKCS1-v1_5, RSA-PSS and Ed25519 algorithms: + * crypto.subtle.generateKey, importKey (spki, pkcs8, jwk, and raw for ECDSA + * and Ed25519 public keys), exportKey, sign and verify, and the CryptoKey + * values of these keys. ECDSA keys are on P-256, P-384 and P-521; ECDSA + * signatures are IEEE P1363 r || s. + * + * Argument conversion, algorithm normalization and the DOMException + * shapes follow Node 24's lib/internal/crypto/webcrypto.js, ec.js and + * rsa.js, through the Web IDL helpers of scr_webcrypto.c. The keys and + * signatures come from the pki unit (scr_pki.c). This unit installs + * itself into scr_webcrypto.c's dispatch table at startup; the compiler + * links it when a program uses WebCrypto and names one of these + * algorithms. All arguments are borrowed. */ +#include "scr_runtime.h" + +#include +#include +#include +#include + +#include "scr_pki.h" +#include "scr_webcrypto.h" + +typedef enum { SW_ECDSA, SW_RSASSA, SW_PSS, SW_ED25519 } SwKind; + +static const char *const sw_names[] = {"ECDSA", "RSASSA-PKCS1-v1_5", "RSA-PSS", "Ed25519"}; + +static const char *const sw_curves[] = {"P-256", "P-384", "P-521"}; + +/* ── CryptoKey ────────────────────────────────────────────────────────── */ + +typedef struct SwKey { + size_t rc; + ScrPkiKey *key; + SwKind kind; + const char *hash; /* RSA keys: the WebCrypto hash name */ + unsigned usages; + bool extractable; + ScrDyn *algorithm; /* cached getter results, or NULL */ + ScrDyn *usage_list; +} SwKey; + +static void *sw_key_retain(void *p) { + ((SwKey *)p)->rc++; + return p; +} + +static void sw_key_release(void *p) { + SwKey *k = p; + if (!k || --k->rc != 0) return; + scr_pki_key_release(k->key); + if (k->algorithm) scr_dyn_release(k->algorithm); + if (k->usage_list) scr_dyn_release(k->usage_list); + free(k); +} + +static SwKey *sw_key_of(const ScrDyn *value) { + if (value->kind != SCR_DYN_HANDLE || value->v.handle.tag != SCR_DYNH_ASYMMETRIC_CRYPTO_KEY) return NULL; + return value->v.handle.ptr; +} + +static bool sw_is_key(const ScrDyn *value) { return sw_key_of(value) != NULL; } + +static ScrDyn *sw_key_algorithm(SwKey *k) { + if (!k->algorithm) { + ScrDyn *algorithm = scr_dyn_new_obj(); + scr_dyn_obj_set(algorithm, "name", 4, scr_wc_cstr(sw_names[k->kind])); + if (k->kind == SW_ED25519) { + /* { name } only */ + } else if (k->kind == SW_ECDSA) { + scr_dyn_obj_set(algorithm, "namedCurve", 10, scr_wc_cstr(scr_pki_key_curve(k->key))); + } else { + scr_dyn_obj_set(algorithm, "modulusLength", 13, scr_dyn_new_num((double)scr_pki_key_bits(k->key))); + ScrBytes *exponent = scr_pki_key_exponent(k->key); + scr_dyn_obj_set(algorithm, "publicExponent", 14, scr_dyn_new_bytes(exponent)); + scr_bytes_release(exponent); + ScrDyn *hash = scr_dyn_new_obj(); + scr_dyn_obj_set(hash, "name", 4, scr_wc_cstr(k->hash)); + scr_dyn_obj_set(algorithm, "hash", 4, hash); + } + k->algorithm = algorithm; + } + return scr_dyn_retain(k->algorithm); +} + +static ScrDyn *sw_usage_array(unsigned usages) { + ScrDyn *list = scr_dyn_new_arr(); + for (size_t i = 0; i < SCR_WC_COUNT(scr_wc_usages); i++) + if (usages & (1u << i)) scr_dyn_arr_push(list, scr_wc_cstr(scr_wc_usages[i])); + return list; +} + +static ScrDyn *sw_key_usages(SwKey *k) { + if (!k->usage_list) k->usage_list = sw_usage_array(k->usages); + return scr_dyn_retain(k->usage_list); +} + +static bool sw_name_is(const char *name, size_t len, const char *literal) { + return len == strlen(literal) && memcmp(name, literal, len) == 0; +} + +static ScrDyn *sw_key_get(void *h, const char *name, size_t len) { + SwKey *k = h; + if (sw_name_is(name, len, "type")) + return scr_wc_cstr(scr_pki_key_is_private(k->key) ? "private" : "public"); + if (sw_name_is(name, len, "extractable")) return scr_dyn_new_bool(k->extractable); + if (sw_name_is(name, len, "algorithm")) return sw_key_algorithm(k); + if (sw_name_is(name, len, "usages")) return sw_key_usages(k); + return NULL; +} + +static bool sw_key_set(void *h, const char *name, size_t len, const ScrDyn *value) { + (void)h; + (void)value; + if (!sw_name_is(name, len, "type") && !sw_name_is(name, len, "extractable") && + !sw_name_is(name, len, "algorithm") && !sw_name_is(name, len, "usages")) + return false; + char message[128]; + int n = snprintf(message, sizeof message, "Cannot set property %.*s of # which has only a getter", + (int)len, name); + scr_throw_error_msg(SCR_ERR_TYPE, message, (size_t)n); + return true; +} + +static ScrDyn *sw_key_invoke(void *h, ScrDyn *self, const char *method, ScrDyn *const *args, size_t argc, + const char *what) { + (void)h; + (void)self; + (void)args; + (void)argc; + if (strcmp(method, "toString") == 0) return scr_wc_cstr("[object CryptoKey]"); + char message[160]; + int n = snprintf(message, sizeof message, "%s is not a function", what); + scr_throw_error_msg(SCR_ERR_TYPE, message, (size_t)n); + return NULL; +} + +static ScrDyn *sw_key_symbol_get(void *h, const ScrDyn *key) { + (void)h; + if (key->kind != SCR_DYN_SYMBOL || !key->v.symbol.description) return NULL; + ScrStr *description = key->v.symbol.description(key->v.symbol.value); + bool tag = description && description->len == 18 && memcmp(description->data, "Symbol.toStringTag", 18) == 0; + if (description) scr_str_release(description); + return tag ? scr_wc_cstr("CryptoKey") : NULL; +} + +/* As for HMAC CryptoKeys, util.inspect refuses these keys rather than + * printing a different shape than Node's custom inspector. */ +static const ScrDynHandleOps sw_key_ops = { + .cls = "CryptoKey", + .retain = sw_key_retain, + .release = sw_key_release, + .invoke = sw_key_invoke, + .get = sw_key_get, + .set = sw_key_set, + .json_empty_object = true, + .to_string_tag = "CryptoKey", + .symbol_get = sw_key_symbol_get, +}; + +/* Boxes a CryptoKey over `key` (consumed). */ +static ScrDyn *sw_key_new(ScrPkiKey *key, SwKind kind, const char *hash, unsigned usages, bool extractable) { + static SCR_TL bool installed; + if (!installed) { + installed = true; + scr_dyn_handle_install(SCR_DYNH_ASYMMETRIC_CRYPTO_KEY, &sw_key_ops); + } + SwKey *k = calloc(1, sizeof *k); + if (!k) scr_trap("scriptc: out of memory\n"); + k->rc = 1; + k->key = key; + k->kind = kind; + k->hash = hash; + k->usages = usages; + k->extractable = extractable; + ScrDyn *box = scr_dyn_new_handle(k, SCR_DYNH_ASYMMETRIC_CRYPTO_KEY); + sw_key_release(k); + return box; +} + +/* ── algorithm parameters ─────────────────────────────────────────────── */ + +static SwKind sw_kind_of(const char *name) { + if (strcmp(name, "ECDSA") == 0) return SW_ECDSA; + if (strcmp(name, "Ed25519") == 0) return SW_ED25519; + return strcmp(name, "RSA-PSS") == 0 ? SW_PSS : SW_RSASSA; +} + +static bool sw_is_rsa_kind(SwKind kind) { return kind == SW_RSASSA || kind == SW_PSS; } + +/* The canonical algorithm name of an AlgorithmIdentifier the dispatcher + * already recognized as one of this unit's algorithms, or NULL with the + * error pending. */ +static const char *sw_algorithm_name(ScrDyn *identifier) { + ScrStr *name = scr_wc_algorithm_name(identifier, "Algorithm"); + if (!name) return NULL; + const char *found = scr_wc_lookup(sw_names, SCR_WC_COUNT(sw_names), name); + scr_str_release(name); + if (!found) scr_throw_domex("NotSupportedError", "Unrecognized algorithm name"); + return found; +} + +/* A required dictionary member (+1), or NULL with ERR_MISSING_OPTION. */ +static ScrDyn *sw_required(ScrDyn *plain, const char *dict, const char *member) { + ScrDyn *v = scr_wc_member(plain, member); + if (v->kind == SCR_DYN_UNDEF) { + scr_dyn_release(v); + scr_wc_missing_member(dict, member); + return NULL; + } + return v; +} + +/* namedCurve (DOMString, required): one of the implemented curves, or + * NULL with the error pending. */ +static const char *sw_named_curve(ScrDyn *plain, const char *dict) { + ScrDyn *value = sw_required(plain, dict, "namedCurve"); + if (!value) return NULL; + ScrStr *s = scr_wc_dom_string(value); + scr_dyn_release(value); + if (!s) return NULL; + const char *curve = NULL; + for (size_t i = 0; i < SCR_WC_COUNT(sw_curves); i++) + if (s->len == strlen(sw_curves[i]) && memcmp(s->data, sw_curves[i], s->len) == 0) curve = sw_curves[i]; + scr_str_release(s); + if (!curve) scr_throw_domex("NotSupportedError", "Unrecognized namedCurve"); + return curve; +} + +/* hash (HashAlgorithmIdentifier, required): with `sha_only`, Node's + * ensureSHA check first ("Only SHA hashes are supported in "). */ +static const char *sw_hash(ScrDyn *plain, const char *dict, bool sha_only, const char *method) { + ScrDyn *hash = sw_required(plain, dict, "hash"); + if (!hash) return NULL; + if (sha_only) { + ScrStr *name = NULL; + if (scr_wc_is_object(hash)) { + ScrDyn *hp = scr_wc_plain(hash); + ScrDyn *member = hp ? scr_wc_member(hp, "name") : NULL; + if (hp) scr_dyn_release(hp); + if (member && member->kind == SCR_DYN_STR) name = scr_str_retain(member->v.str); + if (member) scr_dyn_release(member); + } else { + name = scr_wc_dom_string(hash); + if (!name) { + scr_dyn_release(hash); + return NULL; + } + } + bool sha = name && name->len >= 3 && (name->data[0] | 32) == 's' && (name->data[1] | 32) == 'h' && + (name->data[2] | 32) == 'a'; + if (name) scr_str_release(name); + if (!sha) { + char message[96]; + snprintf(message, sizeof message, "Only SHA hashes are supported in %s", dict); + scr_throw_domex("NotSupportedError", message); + scr_dyn_release(hash); + return NULL; + } + } + const char *canonical = scr_wc_digest_algorithm(hash, method); + scr_dyn_release(hash); + return canonical; +} + +/* An [EnforceRange] unsigned long member; false with the TypeError + * pending. */ +static bool sw_unsigned_long(ScrDyn *value, const char *member, double *out) { + double x; + if (!scr_dyn_number_coerce_js(value, &x)) return false; + if (x != x || x == 1.0 / 0.0 || x == -1.0 / 0.0) { + scr_wc_type_error("ERR_INVALID_ARG_TYPE", "%s: %s in passed algorithm is not a finite number.", + scr_wc_normalize_prefix, member); + return false; + } + x = trunc(x); + if (x < 0 || x > 4294967295.0) { + scr_wc_type_error("ERR_OUT_OF_RANGE", + "%s: %s in passed algorithm is outside the expected range of 0 to 4294967295.", + scr_wc_normalize_prefix, member); + return false; + } + *out = x == 0 ? 0 : x; + return true; +} + +static void sw_unsupported_usage(SwKind kind) { + char message[96]; + snprintf(message, sizeof message, "Unsupported key usage for %s key", sw_names[kind]); + scr_throw_domex("SyntaxError", message); +} + +/* ── generateKey ──────────────────────────────────────────────────────── */ + +static ScrPromise *sw_generate_key(const ScrDyn *args) { + static const char prefix[] = "Failed to execute 'generateKey' on 'SubtleCrypto'"; + if (!scr_wc_required(prefix, args, 3)) return scr_wc_rejected(); + ScrWcArgs a; + scr_wc_args_take(&a, args, 3); + ScrDyn *pair = NULL; + ScrDyn *plain = NULL; + if (!scr_wc_is_object(a.v[0])) { + ScrStr *s = scr_wc_dom_string(a.v[0]); + if (!s) goto done; + scr_str_release(s); + } + bool extractable = scr_dyn_truthy(a.v[1]); + long usages = scr_wc_key_usages(prefix, 2, a.v[2]); + if (usages < 0) goto done; + const char *name = sw_algorithm_name(a.v[0]); + if (!name) goto done; + SwKind kind = sw_kind_of(name); + plain = scr_wc_plain(a.v[0]); + if (!plain) goto done; + const char *curve = NULL; + const char *hash = NULL; + double bits = 0; + ScrBytes *exponent = NULL; + if (kind == SW_ED25519) { + /* no parameters */ + } else if (kind == SW_ECDSA) { + if (!scr_wc_is_object(plain)) { + scr_wc_missing_member("EcKeyGenParams", "namedCurve"); + goto done; + } + curve = sw_named_curve(plain, "EcKeyGenParams"); + if (!curve) goto done; + } else { + static const char dict[] = "RsaHashedKeyGenParams"; + if (!scr_wc_is_object(plain)) { + scr_wc_missing_member(dict, "hash"); + goto done; + } + /* Dictionary members convert in name order: hash, modulusLength, + * publicExponent. */ + hash = sw_hash(plain, dict, true, "generateKey"); + if (!hash) goto done; + ScrDyn *length = sw_required(plain, dict, "modulusLength"); + if (!length) goto done; + bool ok = sw_unsigned_long(length, "modulusLength", &bits); + scr_dyn_release(length); + if (!ok) goto done; + ScrDyn *e = sw_required(plain, dict, "publicExponent"); + if (!e) goto done; + if (e->kind != SCR_DYN_BYTES || e->v.bytes->elem != SCR_BYTES_U8) { + scr_wc_type_error("ERR_INVALID_ARG_TYPE", "%s: publicExponent in passed algorithm is not instance of Uint8Array.", + scr_wc_normalize_prefix); + scr_dyn_release(e); + goto done; + } + exponent = scr_bytes_buffer_source(e); + scr_dyn_release(e); + } + if (usages & ~(long)(SCR_WC_USAGE_SIGN | SCR_WC_USAGE_VERIFY)) { + sw_unsupported_usage(kind); + if (exponent) scr_bytes_release(exponent); + goto done; + } + ScrPkiKey *key; + if (kind == SW_ED25519) { + key = scr_pki_generate_ed25519(); + if (!key) goto done; + } else if (kind == SW_ECDSA) { + key = scr_pki_generate_ec(curve); + } else { + /* publicExponent: big-endian, at most a 32-bit value. */ + size_t n = (size_t)scr_bytes_byte_len(exponent); + uint64_t value = 0; + bool fits = true; + for (size_t i = 0; i < n; i++) { + if (value > 0xffffffu && fits) fits = false; + value = (value << 8) | exponent->data[i]; + } + scr_bytes_release(exponent); + if (!fits || value > 0xffffffffu) { + scr_throw_domex("OperationError", "The publicExponent must be equivalent to an unsigned 32-bit value"); + goto done; + } + if (bits < 512) { + scr_throw_domex("OperationError", "algorithm.modulusLength must be at least 512"); + goto done; + } + if ((value & 1) == 0) { + scr_throw_domex("OperationError", "algorithm.publicExponent must be odd"); + goto done; + } + if (bits > 16384 || value < 3) { + scr_wc_unsupported("generateKey", "this RSA modulus length or public exponent"); + goto done; + } + key = scr_pki_generate_rsa((unsigned)bits, value); + } + if (!key) { + scr_throw_domex("OperationError", "Key generation failed"); + goto done; + } + unsigned private_usages = (unsigned)usages & SCR_WC_USAGE_SIGN; + unsigned public_usages = (unsigned)usages & SCR_WC_USAGE_VERIFY; + if (private_usages == 0) { + scr_pki_key_release(key); + scr_throw_domex("SyntaxError", "Usages cannot be empty when creating a key."); + goto done; + } + ScrPkiKey *public_key = scr_pki_key_public_of(key); + if (!public_key) { + scr_pki_key_release(key); + scr_throw_domex("OperationError", "Key generation failed"); + goto done; + } + pair = scr_dyn_new_obj(); + scr_dyn_obj_set(pair, "publicKey", 9, sw_key_new(public_key, kind, hash, public_usages, true)); + scr_dyn_obj_set(pair, "privateKey", 10, sw_key_new(key, kind, hash, private_usages, extractable)); +done: + if (plain) scr_dyn_release(plain); + scr_wc_args_drop(&a, 3); + if (!pair) return scr_wc_rejected(); + ScrPromise *p = scr_promise_new(); + scr_crypto_defer_dyn(pair, NULL, scr_crypto_promise_callback(p), scr_crypto_promise_settle_dyn); + return p; +} + +/* ── importKey ────────────────────────────────────────────────────────── */ + +/* A JWK string member, or NULL. */ +static const ScrDyn *sw_jwk_member(const ScrDyn *jwk, const char *key) { + const ScrDyn *v = scr_dyn_obj_get(jwk, key, strlen(key)); + return v && v->kind != SCR_DYN_UNDEF ? v : NULL; +} + +static bool sw_jwk_is(const ScrDyn *v, const char *text) { + return v && v->kind == SCR_DYN_STR && v->v.str->len == strlen(text) && + memcmp(v->v.str->data, text, v->v.str->len) == 0; +} + +/* The JWK checks Node runs before reading the key: use, key_ops and ext. */ +static bool sw_jwk_checks(const ScrDyn *jwk, unsigned usages, bool extractable) { + const ScrDyn *use = sw_jwk_member(jwk, "use"); + if (use && !sw_jwk_is(use, "sig")) { + scr_throw_domex("DataError", "Invalid JWK \"use\" Parameter"); + return false; + } + const ScrDyn *ops = sw_jwk_member(jwk, "key_ops"); + if (ops) { + if (ops->kind != SCR_DYN_ARR) { + scr_throw_domex("DataError", "Key operations and usage mismatch"); + return false; + } + for (size_t u = 0; u < SCR_WC_COUNT(scr_wc_usages); u++) { + if (!(usages & (1u << u))) continue; + bool listed = false; + double n = scr_dyn_arr_len(ops); + for (double i = 0; i < n && !listed; i++) { + ScrDyn *item = scr_dyn_arr_at(ops, i); + listed = sw_jwk_is(item, scr_wc_usages[u]); + scr_dyn_release(item); + } + if (!listed) { + scr_throw_domex("DataError", "Key operations and usage mismatch"); + return false; + } + } + } + const ScrDyn *ext = sw_jwk_member(jwk, "ext"); + if (ext && ext->kind == SCR_DYN_BOOL && !ext->v.b && extractable) { + scr_throw_domex("DataError", "JWK \"ext\" Parameter and extractable mismatch"); + return false; + } + return true; +} + +/* The JWK "alg" an RSA key with this hash carries ("RS256", "PS384"). */ +static void sw_rsa_jwk_alg(SwKind kind, const char *hash, char out[8]) { + const char *bits = strcmp(hash, "SHA-1") == 0 ? "1" : hash + 4; + snprintf(out, 8, "%s%s", kind == SW_PSS ? "PS" : "RS", bits); +} + +static ScrDyn *sw_import(const ScrDyn *args) { + static const char prefix[] = "Failed to execute 'importKey' on 'SubtleCrypto'"; + if (!scr_wc_required(prefix, args, 5)) return NULL; + ScrWcArgs a; + scr_wc_args_take(&a, args, 5); + ScrDyn *result = NULL; + ScrBytes *data = NULL; + ScrDyn *jwk = NULL; + ScrDyn *plain = NULL; + const char *format = scr_wc_key_format(prefix, a.v[0]); + if (!format) goto done; + bool is_jwk = strcmp(format, "jwk") == 0; + if (is_jwk) { + if (!scr_wc_is_object(a.v[1])) { + scr_wc_type_error("ERR_INVALID_ARG_TYPE", "%s: 2nd argument is not of type JsonWebKey.", prefix); + goto done; + } + jwk = scr_wc_plain(a.v[1]); + if (!jwk) goto done; + } else { + data = scr_wc_buffer_source(prefix, 1, a.v[1]); + if (!data) goto done; + } + if (!scr_wc_is_object(a.v[2])) { + ScrStr *s = scr_wc_dom_string(a.v[2]); + if (!s) goto done; + scr_str_release(s); + } + bool extractable = scr_dyn_truthy(a.v[3]); + long usages = scr_wc_key_usages(prefix, 4, a.v[4]); + if (usages < 0) goto done; + const char *name = sw_algorithm_name(a.v[2]); + if (!name) goto done; + SwKind kind = sw_kind_of(name); + plain = scr_wc_plain(a.v[2]); + if (!plain) goto done; + const char *curve = NULL; + const char *hash = NULL; + if (kind == SW_ED25519) { + /* no parameters */ + } else if (kind == SW_ECDSA) { + if (!scr_wc_is_object(plain)) { + scr_wc_missing_member("EcKeyImportParams", "namedCurve"); + goto done; + } + curve = sw_named_curve(plain, "EcKeyImportParams"); + if (!curve) goto done; + } else { + if (!scr_wc_is_object(plain)) { + scr_wc_missing_member("RsaHashedImportParams", "hash"); + goto done; + } + hash = sw_hash(plain, "RsaHashedImportParams", true, "importKey"); + if (!hash) goto done; + } + bool private_key; + if (is_jwk) { + private_key = sw_jwk_member(jwk, "d") != NULL; + } else if (strcmp(format, "pkcs8") == 0) { + private_key = true; + } else if (strcmp(format, "spki") == 0 || + ((kind == SW_ECDSA || kind == SW_ED25519) && strcmp(format, "raw") == 0)) { + private_key = false; + } else { + char message[96]; + snprintf(message, sizeof message, "Unable to import %s using %s format", sw_names[kind], format); + scr_throw_domex("NotSupportedError", message); + goto done; + } + unsigned allowed = private_key ? SCR_WC_USAGE_SIGN : SCR_WC_USAGE_VERIFY; + ScrPkiKey *key = NULL; + /* An Ed25519 private key derives its public key in the Ed25519 unit. */ + if (kind == SW_ED25519 && private_key && !scr_pki_ed25519_ready()) goto done; + if (is_jwk) { + const ScrDyn *kty = sw_jwk_member(jwk, "kty"); + if (!kty) { + scr_throw_domex("DataError", "Invalid keyData"); + goto done; + } + if (!sw_jwk_is(kty, kind == SW_ECDSA ? "EC" : kind == SW_ED25519 ? "OKP" : "RSA")) { + scr_throw_domex("DataError", "Invalid JWK \"kty\" Parameter"); + goto done; + } + if (kind == SW_ECDSA && !sw_jwk_is(sw_jwk_member(jwk, "crv"), curve)) { + scr_throw_domex("DataError", "JWK \"crv\" does not match the requested algorithm"); + goto done; + } + if (kind == SW_ED25519 && !sw_jwk_is(sw_jwk_member(jwk, "crv"), "Ed25519")) { + scr_throw_domex("DataError", "JWK \"crv\" Parameter and algorithm name mismatch"); + goto done; + } + if ((unsigned)usages & ~allowed) { + sw_unsupported_usage(kind); + goto done; + } + if (!sw_jwk_checks(jwk, (unsigned)usages, extractable)) goto done; + const ScrDyn *alg = sw_jwk_member(jwk, "alg"); + if (kind == SW_ED25519 && alg && !sw_jwk_is(alg, "Ed25519") && !sw_jwk_is(alg, "EdDSA")) { + scr_throw_domex("DataError", "JWK \"alg\" does not match the requested algorithm"); + goto done; + } + if (sw_is_rsa_kind(kind) && alg) { + char expected[8]; + sw_rsa_jwk_alg(kind, hash, expected); + if (!sw_jwk_is(alg, expected)) { + scr_throw_domex("DataError", "JWK \"alg\" does not match the requested algorithm"); + goto done; + } + } + key = scr_pki_key_from_jwk(jwk, private_key); + } else { + if ((unsigned)usages & ~allowed) { + sw_unsupported_usage(kind); + goto done; + } + ScrBytes *view = data; + SCR_BYTES_SNAPSHOT(view); + size_t len = (size_t)scr_bytes_byte_len(view); + if (strcmp(format, "raw") == 0) + key = kind == SW_ED25519 ? scr_pki_key_from_ed25519_raw(view->data, len) + : scr_pki_key_from_point(curve, view->data, len); + else key = scr_pki_key_parse_der(view->data, len, private_key); + } + if (!key) { + scr_throw_domex("DataError", "Invalid keyData"); + goto done; + } + bool key_matches = kind == SW_ED25519 ? scr_pki_key_is_ed25519(key) + : kind == SW_ECDSA ? !scr_pki_key_is_rsa(key) && !scr_pki_key_is_ed25519(key) + : scr_pki_key_is_rsa(key); + if (!key_matches) { + scr_pki_key_release(key); + scr_throw_domex("DataError", "Invalid key type"); + goto done; + } + if (kind == SW_ECDSA && strcmp(scr_pki_key_curve(key), curve) != 0) { + scr_pki_key_release(key); + scr_throw_domex("DataError", "Named curve mismatch"); + goto done; + } + if (private_key && usages == 0) { + scr_pki_key_release(key); + scr_throw_domex("SyntaxError", "Usages cannot be empty when importing a private key."); + goto done; + } + result = sw_key_new(key, kind, hash, (unsigned)usages, extractable); +done: + if (data) scr_bytes_release(data); + if (jwk) scr_dyn_release(jwk); + if (plain) scr_dyn_release(plain); + scr_wc_args_drop(&a, 5); + return result; +} + +static ScrPromise *sw_import_key(const ScrDyn *args) { + ScrDyn *key = sw_import(args); + if (!key) return scr_wc_rejected(); + return scr_promise_settled_ref(key, &scr_dyn_retain_v, &scr_dyn_release_v, NULL); +} + +/* ── exportKey ────────────────────────────────────────────────────────── */ + +static ScrDyn *sw_array_buffer(ScrBytes *bytes) { + ScrDyn *out = scr_array_buffer_from_bytes(bytes); + scr_bytes_release(bytes); + return out; +} + +static ScrDyn *sw_export(const ScrDyn *args) { + ScrWcArgs a; + scr_wc_args_take(&a, args, 2); + ScrDyn *result = NULL; + const char *format = scr_wc_key_format("Failed to execute 'exportKey' on 'SubtleCrypto'", a.v[0]); + SwKey *k = sw_key_of(a.v[1]); + bool private_key = scr_pki_key_is_private(k->key); + if (!format) goto done; + if (!k->extractable) { + scr_throw_domex("InvalidAccessError", "key is not extractable"); + goto done; + } + if (strcmp(format, "spki") == 0 || strcmp(format, "pkcs8") == 0) { + bool want_private = strcmp(format, "pkcs8") == 0; + if (want_private != private_key) { + scr_throw_domex("InvalidAccessError", want_private ? "Key must be a private key" : "Key must be a public key"); + goto done; + } + ScrBytes *der = scr_pki_export_der(k->key); + if (!der) { + scr_throw_domex("OperationError", "Failed to export key"); + goto done; + } + result = sw_array_buffer(der); + } else if (strcmp(format, "raw") == 0 && (k->kind == SW_ECDSA || k->kind == SW_ED25519) && + !private_key) { + ScrBytes *point = k->kind == SW_ED25519 ? scr_pki_export_ed25519_raw(k->key) : scr_pki_export_point(k->key); + if (!point) { + scr_throw_domex("OperationError", "Failed to export key"); + goto done; + } + result = sw_array_buffer(point); + } else if (strcmp(format, "jwk") == 0) { + ScrDyn *members = scr_pki_export_jwk(k->key); + ScrDyn *jwk = scr_dyn_new_obj(); + scr_dyn_obj_set(jwk, "key_ops", 7, sw_usage_array(k->usages)); + scr_dyn_obj_set(jwk, "ext", 3, scr_dyn_new_bool(k->extractable)); + if (sw_is_rsa_kind(k->kind)) { + char alg[8]; + sw_rsa_jwk_alg(k->kind, k->hash, alg); + scr_dyn_obj_set(jwk, "alg", 3, scr_wc_cstr(alg)); + } else if (k->kind == SW_ED25519) { + scr_dyn_obj_set(jwk, "alg", 3, scr_wc_cstr("Ed25519")); + } + /* The key members in Node's order for each key type. */ + static const char *const rsa_names[] = {"kty", "n", "e", "d", "p", "q", "dp", "dq", "qi"}; + static const char *const ec_names[] = {"kty", "x", "y", "crv", "d"}; + static const char *const okp_names[] = {"kty", "crv", "x", "d"}; + const char *const *names = sw_is_rsa_kind(k->kind) ? rsa_names : k->kind == SW_ED25519 ? okp_names : ec_names; + size_t count = sw_is_rsa_kind(k->kind) ? SCR_WC_COUNT(rsa_names) + : k->kind == SW_ED25519 ? SCR_WC_COUNT(okp_names) + : SCR_WC_COUNT(ec_names); + for (size_t i = 0; i < count; i++) { + const ScrDyn *v = scr_dyn_obj_get(members, names[i], strlen(names[i])); + if (v) scr_dyn_obj_set(jwk, names[i], strlen(names[i]), scr_dyn_retain((ScrDyn *)v)); + } + scr_dyn_release(members); + result = jwk; + } else { + char message[128]; + snprintf(message, sizeof message, "Unable to export %s %s key using %s format", sw_names[k->kind], + private_key ? "private" : "public", format); + scr_throw_domex("NotSupportedError", message); + } +done: + scr_wc_args_drop(&a, 2); + return result; +} + +static ScrPromise *sw_export_key(const ScrDyn *args) { + ScrDyn *value = sw_export(args); + if (!value) return scr_wc_rejected(); + return scr_promise_settled_ref(value, &scr_dyn_retain_v, &scr_dyn_release_v, NULL); +} + +/* ── sign and verify ──────────────────────────────────────────────────── */ + +/* The deferred verify result: a dyn boolean. */ +static void sw_settle_verified(ScrClosure *cb, ScrError *error, ScrBytes *value) { + (void)error; + ScrPromise *p; + memcpy(&p, &cb->caps[0]->slot, sizeof p); + ScrDyn *verified = (ScrDyn *)value; + scr_promise_fulfill_bool(p, scr_dyn_truthy(verified)); + scr_dyn_release(verified); +} + +static ScrPromise *sw_sign_verify(const ScrDyn *args, bool verify) { + const char *prefix = verify ? "Failed to execute 'verify' on 'SubtleCrypto'" + : "Failed to execute 'sign' on 'SubtleCrypto'"; + const char *method = verify ? "verify" : "sign"; + size_t n = verify ? 4 : 3; + if (!scr_wc_required(prefix, args, n)) return scr_wc_rejected(); + ScrWcArgs a; + scr_wc_args_take(&a, args, n); + ScrPromise *result = NULL; + ScrBytes *data = NULL; + ScrBytes *signature = NULL; + ScrDyn *plain = NULL; + if (!scr_wc_is_object(a.v[0])) { + ScrStr *s = scr_wc_dom_string(a.v[0]); + if (!s) goto done; + scr_str_release(s); + } + SwKey *k = sw_key_of(a.v[1]); + if (!k && !scr_webcrypto_is_crypto_key(a.v[1])) { + scr_wc_type_error("ERR_INVALID_ARG_TYPE", "%s: 2nd argument is not of type CryptoKey.", prefix); + goto done; + } + if (verify) { + signature = scr_wc_buffer_source(prefix, 2, a.v[2]); + if (!signature) goto done; + } + data = scr_wc_buffer_source(prefix, verify ? 3 : 2, a.v[verify ? 3 : 2]); + if (!data) goto done; + const char *name = sw_algorithm_name(a.v[0]); + if (!name) goto done; + SwKind kind = sw_kind_of(name); + plain = scr_wc_plain(a.v[0]); + if (!plain) goto done; + const char *hash = NULL; + int salt = 0; + if (kind == SW_ED25519) { + /* no parameters */ + } else if (kind == SW_ECDSA) { + if (!scr_wc_is_object(plain)) { + scr_wc_missing_member("EcdsaParams", "hash"); + goto done; + } + hash = sw_hash(plain, "EcdsaParams", false, method); + if (!hash) goto done; + } else if (kind == SW_PSS) { + if (!scr_wc_is_object(plain)) { + scr_wc_missing_member("RsaPssParams", "saltLength"); + goto done; + } + ScrDyn *value = sw_required(plain, "RsaPssParams", "saltLength"); + if (!value) goto done; + double x; + bool ok = sw_unsigned_long(value, "saltLength", &x); + scr_dyn_release(value); + if (!ok) goto done; + salt = x > 65536 ? 65536 : (int)x; + } + if (!k || k->kind != kind) { + scr_throw_domex("InvalidAccessError", "Key algorithm mismatch"); + goto done; + } + if (!(k->usages & (verify ? SCR_WC_USAGE_VERIFY : SCR_WC_USAGE_SIGN))) { + char message[64]; + snprintf(message, sizeof message, "Unable to use this key to %s", method); + scr_throw_domex("InvalidAccessError", message); + goto done; + } + if (sw_is_rsa_kind(kind)) hash = k->hash; + if (kind == SW_ED25519 && !scr_pki_ed25519_ready()) goto done; + { + ScrBytes *view = data; + SCR_BYTES_SNAPSHOT(view); + size_t len = (size_t)scr_bytes_byte_len(view); + if (verify) { + ScrBytes *sig = signature; + SCR_BYTES_SNAPSHOT(sig); + bool ok = scr_pki_verify(k->key, hash, kind == SW_PSS, salt, view->data, len, sig->data, + (size_t)scr_bytes_byte_len(sig)); + result = scr_promise_new(); + scr_crypto_defer_dyn(scr_dyn_new_bool(ok), NULL, scr_crypto_promise_callback(result), sw_settle_verified); + } else { + ScrBytes *out = scr_pki_sign(k->key, hash, kind == SW_PSS, salt, view->data, len); + if (!out) { + scr_throw_domex("OperationError", "Failed to sign"); + goto done; + } + result = scr_promise_new(); + scr_crypto_defer_bytes(out, NULL, scr_crypto_promise_callback(result), scr_crypto_promise_settle_array_buffer); + } + } +done: + if (data) scr_bytes_release(data); + if (signature) scr_bytes_release(signature); + if (plain) scr_dyn_release(plain); + scr_wc_args_drop(&a, n); + return result ? result : scr_wc_rejected(); +} + +static ScrPromise *sw_sign(const ScrDyn *args) { return sw_sign_verify(args, false); } + +static ScrPromise *sw_verify(const ScrDyn *args) { return sw_sign_verify(args, true); } + +static const ScrWcAsymmetric sw_table = { + .generate_key = sw_generate_key, + .import_key = sw_import_key, + .export_key = sw_export_key, + .sign = sw_sign, + .verify = sw_verify, + .is_key = sw_is_key, +}; + +/* Installed before main: scr_webcrypto.c dispatches these algorithms + * here. */ +__attribute__((constructor)) static void sw_install(void) { scr_wc_asymmetric = &sw_table; } diff --git a/packages/runtime/vendor/README.md b/packages/runtime/vendor/README.md index 977179609..7ab8cf6b0 100644 --- a/packages/runtime/vendor/README.md +++ b/packages/runtime/vendor/README.md @@ -48,3 +48,15 @@ The objects build lazily on the first zlib-using cross compile into the per-user The TLS provider behind node:tls/node:https (see the design note atop packages/runtime/src/scr_tls.c for why mbedTLS over SecureTransport/BoringSSL/libtls). Only `include/` and `library/` are vendored (LICENSE beside them) — tests, docs, programs, scripts, and CMake machinery are not. No vendored file is modified and no custom config is applied (the stock `mbedtls_config.h` builds every `library/*.c` standalone with clang); to update, re-fetch the release tarball, copy the same two directories, and bump `MBEDTLS_VERSION` in packages/compiler/src/backend/vendor-archives.ts. The archive (libmbedtls.a) is prebuilt best-effort during npm installation (or explicitly by `scriptc cache warm`) and otherwise built lazily on the first TLS-using compile. It lives under the per-user build cache's `vendor/mbedtls----/` directory — one flavor per lane (plain, asan), native platform/architecture or explicit cross target, and compiler environment/identity, the libqjs.a pattern. TLS-free binaries never compile or link any of this. + +## libsodium/ + +- Project: https://github.com/jedisct1/libsodium +- Version: 1.0.20 (release tarball libsodium-1.0.20.tar.gz, sha256 ebb65ef6ca439333c2bb41a0c1990587288da07f6c7fd07cb3a18cc18d30ce19) +- License: ISC (see libsodium/LICENSE) + +The Ed25519 arithmetic behind node:crypto and WebCrypto Ed25519 keys (see packages/runtime/src/scr_ed25519.c). Its verification matches Node 24: it rejects a non-canonical S and the small-order R and public-key encodings, then checks the cofactorless equation. Only the ref10 Ed25519 subset is vendored, flat in one directory: `crypto_core/ed25519/ref10/ed25519_ref10.c` with its `fe_25_5/` headers, `crypto_sign/ed25519/ref10/{sign,open,keypair}.c` and `sign_ed25519_ref10.h`, `crypto_hash/sha512/cp/hash_sha512_cp.c`, `crypto_verify/verify.c`, and the public and private headers they include. The 64-bit `fe_51` field code (used only with `HAVE_TI_MODE`) and the rest of the library are not vendored. + +The only modification to upstream files: `#include "private/x.h"` flattened to `#include "x.h"` in ed25519_ref10.c, sign.c, open.c, keypair.c, hash_sha512_cp.c and ed25519_ref10_fe_25_5.h, so the directory is self-contained. scr_ed25519.c textually includes the .c files and supplies `sodium_memzero`, `sodium_memcmp`, `sodium_is_zero` and `randombytes_buf` (from `arc4random_buf`) in place of libsodium's utils.c and randombytes.c. To update, re-fetch the release tarball, copy the same files, and re-apply that include flattening. + +The unit compiles only into programs that use asymmetric keys and name Ed25519 in a string literal (the `ed25519` runtime feature); other binaries never compile or link any of this. diff --git a/packages/runtime/vendor/libsodium/LICENSE b/packages/runtime/vendor/libsodium/LICENSE new file mode 100644 index 000000000..6bce7f058 --- /dev/null +++ b/packages/runtime/vendor/libsodium/LICENSE @@ -0,0 +1,18 @@ +/* + * ISC License + * + * Copyright (c) 2013-2024 + * Frank Denis + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ diff --git a/packages/runtime/vendor/libsodium/README.md b/packages/runtime/vendor/libsodium/README.md new file mode 100644 index 000000000..5207d8ad6 --- /dev/null +++ b/packages/runtime/vendor/libsodium/README.md @@ -0,0 +1,7 @@ +# libsodium 1.0.20 (Ed25519 subset) + +- Source: https://download.libsodium.org/libsodium/releases/libsodium-1.0.20.tar.gz (the same tarball as the GitHub release 1.0.20-RELEASE) +- sha256: ebb65ef6ca439333c2bb41a0c1990587288da07f6c7fd07cb3a18cc18d30ce19 +- License: ISC, see LICENSE + +See ../README.md for the files vendored, the one modification, and how to update. diff --git a/packages/runtime/vendor/libsodium/common.h b/packages/runtime/vendor/libsodium/common.h new file mode 100644 index 000000000..63f0d2b2d --- /dev/null +++ b/packages/runtime/vendor/libsodium/common.h @@ -0,0 +1,285 @@ +#ifndef common_H +#define common_H 1 + +#if !defined(_MSC_VER) && !defined(DEV_MODE) && 0 +# warning *** This is unstable, untested, development code. +# warning It might not compile. It might not work as expected. +# warning It might be totally insecure. +# warning Do not use this except if you are planning to contribute code. +# warning Use releases available at https://download.libsodium.org/libsodium/releases/ instead. +# warning Alternatively, use the "stable" branch in the git repository. +#endif + +#if !defined(_MSC_VER) && (!defined(CONFIGURED) || CONFIGURED != 1) +# warning *** The library is being compiled using an undocumented method. +# warning This is not supported. It has not been tested, it might not +# warning work as expected, and performance is likely to be suboptimal. +#endif + +#include +#include +#include + +#define COMPILER_ASSERT(X) (void) sizeof(char[(X) ? 1 : -1]) + +#ifdef HAVE_TI_MODE +# if defined(__SIZEOF_INT128__) +typedef unsigned __int128 uint128_t; +# else +typedef unsigned uint128_t __attribute__((mode(TI))); +# endif +#endif + +#define ROTL32(X, B) rotl32((X), (B)) +static inline uint32_t +rotl32(const uint32_t x, const int b) +{ + return (x << b) | (x >> (32 - b)); +} + +#define ROTL64(X, B) rotl64((X), (B)) +static inline uint64_t +rotl64(const uint64_t x, const int b) +{ + return (x << b) | (x >> (64 - b)); +} + +#define ROTR32(X, B) rotr32((X), (B)) +static inline uint32_t +rotr32(const uint32_t x, const int b) +{ + return (x >> b) | (x << (32 - b)); +} + +#define ROTR64(X, B) rotr64((X), (B)) +static inline uint64_t +rotr64(const uint64_t x, const int b) +{ + return (x >> b) | (x << (64 - b)); +} + +#define LOAD64_LE(SRC) load64_le(SRC) +static inline uint64_t +load64_le(const uint8_t src[8]) +{ +#ifdef NATIVE_LITTLE_ENDIAN + uint64_t w; + memcpy(&w, src, sizeof w); + return w; +#else + uint64_t w = (uint64_t) src[0]; + w |= (uint64_t) src[1] << 8; + w |= (uint64_t) src[2] << 16; + w |= (uint64_t) src[3] << 24; + w |= (uint64_t) src[4] << 32; + w |= (uint64_t) src[5] << 40; + w |= (uint64_t) src[6] << 48; + w |= (uint64_t) src[7] << 56; + return w; +#endif +} + +#define STORE64_LE(DST, W) store64_le((DST), (W)) +static inline void +store64_le(uint8_t dst[8], uint64_t w) +{ +#ifdef NATIVE_LITTLE_ENDIAN + memcpy(dst, &w, sizeof w); +#else + dst[0] = (uint8_t) w; w >>= 8; + dst[1] = (uint8_t) w; w >>= 8; + dst[2] = (uint8_t) w; w >>= 8; + dst[3] = (uint8_t) w; w >>= 8; + dst[4] = (uint8_t) w; w >>= 8; + dst[5] = (uint8_t) w; w >>= 8; + dst[6] = (uint8_t) w; w >>= 8; + dst[7] = (uint8_t) w; +#endif +} + +#define LOAD32_LE(SRC) load32_le(SRC) +static inline uint32_t +load32_le(const uint8_t src[4]) +{ +#ifdef NATIVE_LITTLE_ENDIAN + uint32_t w; + memcpy(&w, src, sizeof w); + return w; +#else + uint32_t w = (uint32_t) src[0]; + w |= (uint32_t) src[1] << 8; + w |= (uint32_t) src[2] << 16; + w |= (uint32_t) src[3] << 24; + return w; +#endif +} + +#define STORE32_LE(DST, W) store32_le((DST), (W)) +static inline void +store32_le(uint8_t dst[4], uint32_t w) +{ +#ifdef NATIVE_LITTLE_ENDIAN + memcpy(dst, &w, sizeof w); +#else + dst[0] = (uint8_t) w; w >>= 8; + dst[1] = (uint8_t) w; w >>= 8; + dst[2] = (uint8_t) w; w >>= 8; + dst[3] = (uint8_t) w; +#endif +} + +/* ----- */ + +#define LOAD64_BE(SRC) load64_be(SRC) +static inline uint64_t +load64_be(const uint8_t src[8]) +{ +#ifdef NATIVE_BIG_ENDIAN + uint64_t w; + memcpy(&w, src, sizeof w); + return w; +#else + uint64_t w = (uint64_t) src[7]; + w |= (uint64_t) src[6] << 8; + w |= (uint64_t) src[5] << 16; + w |= (uint64_t) src[4] << 24; + w |= (uint64_t) src[3] << 32; + w |= (uint64_t) src[2] << 40; + w |= (uint64_t) src[1] << 48; + w |= (uint64_t) src[0] << 56; + return w; +#endif +} + +#define STORE64_BE(DST, W) store64_be((DST), (W)) +static inline void +store64_be(uint8_t dst[8], uint64_t w) +{ +#ifdef NATIVE_BIG_ENDIAN + memcpy(dst, &w, sizeof w); +#else + dst[7] = (uint8_t) w; w >>= 8; + dst[6] = (uint8_t) w; w >>= 8; + dst[5] = (uint8_t) w; w >>= 8; + dst[4] = (uint8_t) w; w >>= 8; + dst[3] = (uint8_t) w; w >>= 8; + dst[2] = (uint8_t) w; w >>= 8; + dst[1] = (uint8_t) w; w >>= 8; + dst[0] = (uint8_t) w; +#endif +} + +#define LOAD32_BE(SRC) load32_be(SRC) +static inline uint32_t +load32_be(const uint8_t src[4]) +{ +#ifdef NATIVE_BIG_ENDIAN + uint32_t w; + memcpy(&w, src, sizeof w); + return w; +#else + uint32_t w = (uint32_t) src[3]; + w |= (uint32_t) src[2] << 8; + w |= (uint32_t) src[1] << 16; + w |= (uint32_t) src[0] << 24; + return w; +#endif +} + +#define STORE32_BE(DST, W) store32_be((DST), (W)) +static inline void +store32_be(uint8_t dst[4], uint32_t w) +{ +#ifdef NATIVE_BIG_ENDIAN + memcpy(dst, &w, sizeof w); +#else + dst[3] = (uint8_t) w; w >>= 8; + dst[2] = (uint8_t) w; w >>= 8; + dst[1] = (uint8_t) w; w >>= 8; + dst[0] = (uint8_t) w; +#endif +} + +#define XOR_BUF(OUT, IN, N) xor_buf((OUT), (IN), (N)) +static inline void +xor_buf(unsigned char *out, const unsigned char *in, size_t n) +{ + size_t i; + + for (i = 0; i < n; i++) { + out[i] ^= in[i]; + } +} + +#if !defined(__clang__) && !defined(__GNUC__) +# ifdef __attribute__ +# undef __attribute__ +# endif +# define __attribute__(a) +#endif + +#ifndef CRYPTO_ALIGN +# if defined(__INTEL_COMPILER) || defined(_MSC_VER) +# define CRYPTO_ALIGN(x) __declspec(align(x)) +# else +# define CRYPTO_ALIGN(x) __attribute__ ((aligned(x))) +# endif +#endif + +#ifdef _MSC_VER + +# if defined(_M_X64) || defined(_M_IX86) +# include + +# define HAVE_INTRIN_H 1 +# define HAVE_MMINTRIN_H 1 +# define HAVE_EMMINTRIN_H 1 +# define HAVE_PMMINTRIN_H 1 +# define HAVE_TMMINTRIN_H 1 +# define HAVE_SMMINTRIN_H 1 +# define HAVE_AVXINTRIN_H 1 +# if _MSC_VER >= 1600 +# define HAVE_WMMINTRIN_H 1 +# endif +# if _MSC_VER >= 1700 && defined(_M_X64) +# define HAVE_AVX2INTRIN_H 1 +# endif +# if _MSC_VER >= 1910 && defined(_M_X64) +# define HAVE_AVX512FINTRIN_H 1 +# endif + +# elif defined(_M_ARM64) + +# ifndef __ARM_ARCH +# define __ARM_ARCH 1 +# endif +# ifndef __ARM_NEON +# define __ARM_NEON 1 +# endif +# define HAVE_ARMCRYPTO 1 + +# endif /* _MSC_VER */ + +#elif defined(HAVE_INTRIN_H) +# include +#endif + +#ifdef HAVE_LIBCTGRIND +extern void ct_poison (const void *, size_t); +extern void ct_unpoison(const void *, size_t); +# define POISON(X, L) ct_poison((X), (L)) +# define UNPOISON(X, L) ct_unpoison((X), (L)) +#else +# define POISON(X, L) (void) 0 +# define UNPOISON(X, L) (void) 0 +#endif + +#ifdef HAVE_GCC_MEMORY_FENCES +# define ACQUIRE_FENCE __atomic_thread_fence(__ATOMIC_ACQUIRE) +#elif defined(HAVE_C11_MEMORY_FENCES) +# define ACQUIRE_FENCE atomic_thread_fence(memory_order_acquire) +#else +# define ACQUIRE_FENCE (void) 0 +#endif + +#endif diff --git a/packages/runtime/vendor/libsodium/crypto_hash_sha512.h b/packages/runtime/vendor/libsodium/crypto_hash_sha512.h new file mode 100644 index 000000000..5b690fb25 --- /dev/null +++ b/packages/runtime/vendor/libsodium/crypto_hash_sha512.h @@ -0,0 +1,60 @@ +#ifndef crypto_hash_sha512_H +#define crypto_hash_sha512_H + +/* + * WARNING: Unless you absolutely need to use SHA512 for interoperability, + * purposes, you might want to consider crypto_generichash() instead. + * Unlike SHA512, crypto_generichash() is not vulnerable to length + * extension attacks. + */ + +#include +#include +#include + +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +typedef struct crypto_hash_sha512_state { + uint64_t state[8]; + uint64_t count[2]; + uint8_t buf[128]; +} crypto_hash_sha512_state; + +SODIUM_EXPORT +size_t crypto_hash_sha512_statebytes(void); + +#define crypto_hash_sha512_BYTES 64U +SODIUM_EXPORT +size_t crypto_hash_sha512_bytes(void); + +SODIUM_EXPORT +int crypto_hash_sha512(unsigned char *out, const unsigned char *in, + unsigned long long inlen) __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +int crypto_hash_sha512_init(crypto_hash_sha512_state *state) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_hash_sha512_update(crypto_hash_sha512_state *state, + const unsigned char *in, + unsigned long long inlen) + __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +int crypto_hash_sha512_final(crypto_hash_sha512_state *state, + unsigned char *out) + __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/packages/runtime/vendor/libsodium/crypto_scalarmult_curve25519.h b/packages/runtime/vendor/libsodium/crypto_scalarmult_curve25519.h new file mode 100644 index 000000000..60e9d0c5a --- /dev/null +++ b/packages/runtime/vendor/libsodium/crypto_scalarmult_curve25519.h @@ -0,0 +1,42 @@ +#ifndef crypto_scalarmult_curve25519_H +#define crypto_scalarmult_curve25519_H + +#include + +#include "export.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define crypto_scalarmult_curve25519_BYTES 32U +SODIUM_EXPORT +size_t crypto_scalarmult_curve25519_bytes(void); + +#define crypto_scalarmult_curve25519_SCALARBYTES 32U +SODIUM_EXPORT +size_t crypto_scalarmult_curve25519_scalarbytes(void); + +/* + * NOTE: Do not use the result of this function directly for key exchange. + * + * Hash the result with the public keys in order to compute a shared + * secret key: H(q || client_pk || server_pk) + * + * Or unless this is not an option, use the crypto_kx() API instead. + */ +SODIUM_EXPORT +int crypto_scalarmult_curve25519(unsigned char *q, const unsigned char *n, + const unsigned char *p) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_scalarmult_curve25519_base(unsigned char *q, + const unsigned char *n) + __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/packages/runtime/vendor/libsodium/crypto_sign_ed25519.h b/packages/runtime/vendor/libsodium/crypto_sign_ed25519.h new file mode 100644 index 000000000..0fdac42d3 --- /dev/null +++ b/packages/runtime/vendor/libsodium/crypto_sign_ed25519.h @@ -0,0 +1,124 @@ +#ifndef crypto_sign_ed25519_H +#define crypto_sign_ed25519_H + +#include +#include "crypto_hash_sha512.h" +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +typedef struct crypto_sign_ed25519ph_state { + crypto_hash_sha512_state hs; +} crypto_sign_ed25519ph_state; + +SODIUM_EXPORT +size_t crypto_sign_ed25519ph_statebytes(void); + +#define crypto_sign_ed25519_BYTES 64U +SODIUM_EXPORT +size_t crypto_sign_ed25519_bytes(void); + +#define crypto_sign_ed25519_SEEDBYTES 32U +SODIUM_EXPORT +size_t crypto_sign_ed25519_seedbytes(void); + +#define crypto_sign_ed25519_PUBLICKEYBYTES 32U +SODIUM_EXPORT +size_t crypto_sign_ed25519_publickeybytes(void); + +#define crypto_sign_ed25519_SECRETKEYBYTES (32U + 32U) +SODIUM_EXPORT +size_t crypto_sign_ed25519_secretkeybytes(void); + +#define crypto_sign_ed25519_MESSAGEBYTES_MAX (SODIUM_SIZE_MAX - crypto_sign_ed25519_BYTES) +SODIUM_EXPORT +size_t crypto_sign_ed25519_messagebytes_max(void); + +SODIUM_EXPORT +int crypto_sign_ed25519(unsigned char *sm, unsigned long long *smlen_p, + const unsigned char *m, unsigned long long mlen, + const unsigned char *sk) + __attribute__ ((nonnull(1, 5))); + +SODIUM_EXPORT +int crypto_sign_ed25519_open(unsigned char *m, unsigned long long *mlen_p, + const unsigned char *sm, unsigned long long smlen, + const unsigned char *pk) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(3, 5))); + +SODIUM_EXPORT +int crypto_sign_ed25519_detached(unsigned char *sig, + unsigned long long *siglen_p, + const unsigned char *m, + unsigned long long mlen, + const unsigned char *sk) + __attribute__ ((nonnull(1, 5))); + +SODIUM_EXPORT +int crypto_sign_ed25519_verify_detached(const unsigned char *sig, + const unsigned char *m, + unsigned long long mlen, + const unsigned char *pk) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(1, 4))); + +SODIUM_EXPORT +int crypto_sign_ed25519_keypair(unsigned char *pk, unsigned char *sk) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_sign_ed25519_seed_keypair(unsigned char *pk, unsigned char *sk, + const unsigned char *seed) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_sign_ed25519_pk_to_curve25519(unsigned char *curve25519_pk, + const unsigned char *ed25519_pk) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_sign_ed25519_sk_to_curve25519(unsigned char *curve25519_sk, + const unsigned char *ed25519_sk) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_sign_ed25519_sk_to_seed(unsigned char *seed, + const unsigned char *sk) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_sign_ed25519_sk_to_pk(unsigned char *pk, const unsigned char *sk) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_sign_ed25519ph_init(crypto_sign_ed25519ph_state *state) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_sign_ed25519ph_update(crypto_sign_ed25519ph_state *state, + const unsigned char *m, + unsigned long long mlen) + __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +int crypto_sign_ed25519ph_final_create(crypto_sign_ed25519ph_state *state, + unsigned char *sig, + unsigned long long *siglen_p, + const unsigned char *sk) + __attribute__ ((nonnull(1, 2, 4))); + +SODIUM_EXPORT +int crypto_sign_ed25519ph_final_verify(crypto_sign_ed25519ph_state *state, + const unsigned char *sig, + const unsigned char *pk) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/packages/runtime/vendor/libsodium/crypto_verify_16.h b/packages/runtime/vendor/libsodium/crypto_verify_16.h new file mode 100644 index 000000000..7b9c8077a --- /dev/null +++ b/packages/runtime/vendor/libsodium/crypto_verify_16.h @@ -0,0 +1,23 @@ +#ifndef crypto_verify_16_H +#define crypto_verify_16_H + +#include +#include "export.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define crypto_verify_16_BYTES 16U +SODIUM_EXPORT +size_t crypto_verify_16_bytes(void); + +SODIUM_EXPORT +int crypto_verify_16(const unsigned char *x, const unsigned char *y) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/packages/runtime/vendor/libsodium/crypto_verify_32.h b/packages/runtime/vendor/libsodium/crypto_verify_32.h new file mode 100644 index 000000000..9b0f4529f --- /dev/null +++ b/packages/runtime/vendor/libsodium/crypto_verify_32.h @@ -0,0 +1,23 @@ +#ifndef crypto_verify_32_H +#define crypto_verify_32_H + +#include +#include "export.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define crypto_verify_32_BYTES 32U +SODIUM_EXPORT +size_t crypto_verify_32_bytes(void); + +SODIUM_EXPORT +int crypto_verify_32(const unsigned char *x, const unsigned char *y) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/packages/runtime/vendor/libsodium/crypto_verify_64.h b/packages/runtime/vendor/libsodium/crypto_verify_64.h new file mode 100644 index 000000000..c83b73025 --- /dev/null +++ b/packages/runtime/vendor/libsodium/crypto_verify_64.h @@ -0,0 +1,23 @@ +#ifndef crypto_verify_64_H +#define crypto_verify_64_H + +#include +#include "export.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define crypto_verify_64_BYTES 64U +SODIUM_EXPORT +size_t crypto_verify_64_bytes(void); + +SODIUM_EXPORT +int crypto_verify_64(const unsigned char *x, const unsigned char *y) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/packages/runtime/vendor/libsodium/ed25519_ref10.c b/packages/runtime/vendor/libsodium/ed25519_ref10.c new file mode 100644 index 000000000..ac7a41492 --- /dev/null +++ b/packages/runtime/vendor/libsodium/ed25519_ref10.c @@ -0,0 +1,2858 @@ +#include +#include +#include +#include + +#include "crypto_verify_32.h" +#include "common.h" +#include "ed25519_ref10.h" +#include "utils.h" + +static inline uint64_t +load_3(const unsigned char *in) +{ + uint64_t result; + + result = (uint64_t) in[0]; + result |= ((uint64_t) in[1]) << 8; + result |= ((uint64_t) in[2]) << 16; + + return result; +} + +static inline uint64_t +load_4(const unsigned char *in) +{ + uint64_t result; + + result = (uint64_t) in[0]; + result |= ((uint64_t) in[1]) << 8; + result |= ((uint64_t) in[2]) << 16; + result |= ((uint64_t) in[3]) << 24; + + return result; +} + +/* + * Field arithmetic: + * Use 5*51 bit limbs on 64-bit systems with support for 128 bit arithmetic, + * and 10*25.5 bit limbs elsewhere. + * + * Functions used elsewhere that are candidates for inlining are defined + * via "private/curve25519_ref10.h". + */ + +#ifdef HAVE_TI_MODE +# include "fe_51/constants.h" +# include "fe_51/fe.h" +#else +# include "fe_25_5/constants.h" +# include "fe_25_5/fe.h" +#endif + +void +fe25519_invert(fe25519 out, const fe25519 z) +{ + fe25519 t0; + fe25519 t1; + fe25519 t2; + fe25519 t3; + int i; + + fe25519_sq(t0, z); + fe25519_sq(t1, t0); + fe25519_sq(t1, t1); + fe25519_mul(t1, z, t1); + fe25519_mul(t0, t0, t1); + fe25519_sq(t2, t0); + fe25519_mul(t1, t1, t2); + fe25519_sq(t2, t1); + for (i = 1; i < 5; ++i) { + fe25519_sq(t2, t2); + } + fe25519_mul(t1, t2, t1); + fe25519_sq(t2, t1); + for (i = 1; i < 10; ++i) { + fe25519_sq(t2, t2); + } + fe25519_mul(t2, t2, t1); + fe25519_sq(t3, t2); + for (i = 1; i < 20; ++i) { + fe25519_sq(t3, t3); + } + fe25519_mul(t2, t3, t2); + for (i = 1; i < 11; ++i) { + fe25519_sq(t2, t2); + } + fe25519_mul(t1, t2, t1); + fe25519_sq(t2, t1); + for (i = 1; i < 50; ++i) { + fe25519_sq(t2, t2); + } + fe25519_mul(t2, t2, t1); + fe25519_sq(t3, t2); + for (i = 1; i < 100; ++i) { + fe25519_sq(t3, t3); + } + fe25519_mul(t2, t3, t2); + for (i = 1; i < 51; ++i) { + fe25519_sq(t2, t2); + } + fe25519_mul(t1, t2, t1); + for (i = 1; i < 6; ++i) { + fe25519_sq(t1, t1); + } + fe25519_mul(out, t1, t0); +} + +static void +fe25519_pow22523(fe25519 out, const fe25519 z) +{ + fe25519 t0; + fe25519 t1; + fe25519 t2; + int i; + + fe25519_sq(t0, z); + fe25519_sq(t1, t0); + fe25519_sq(t1, t1); + fe25519_mul(t1, z, t1); + fe25519_mul(t0, t0, t1); + fe25519_sq(t0, t0); + fe25519_mul(t0, t1, t0); + fe25519_sq(t1, t0); + for (i = 1; i < 5; ++i) { + fe25519_sq(t1, t1); + } + fe25519_mul(t0, t1, t0); + fe25519_sq(t1, t0); + for (i = 1; i < 10; ++i) { + fe25519_sq(t1, t1); + } + fe25519_mul(t1, t1, t0); + fe25519_sq(t2, t1); + for (i = 1; i < 20; ++i) { + fe25519_sq(t2, t2); + } + fe25519_mul(t1, t2, t1); + for (i = 1; i < 11; ++i) { + fe25519_sq(t1, t1); + } + fe25519_mul(t0, t1, t0); + fe25519_sq(t1, t0); + for (i = 1; i < 50; ++i) { + fe25519_sq(t1, t1); + } + fe25519_mul(t1, t1, t0); + fe25519_sq(t2, t1); + for (i = 1; i < 100; ++i) { + fe25519_sq(t2, t2); + } + fe25519_mul(t1, t2, t1); + for (i = 1; i < 51; ++i) { + fe25519_sq(t1, t1); + } + fe25519_mul(t0, t1, t0); + fe25519_sq(t0, t0); + fe25519_sq(t0, t0); + fe25519_mul(out, t0, z); +} + +static inline void +fe25519_cneg(fe25519 h, const fe25519 f, unsigned int b) +{ + fe25519 negf; + + fe25519_neg(negf, f); + fe25519_copy(h, f); + fe25519_cmov(h, negf, b); +} + +static inline void +fe25519_abs(fe25519 h, const fe25519 f) +{ + fe25519_cneg(h, f, fe25519_isnegative(f)); +} + +static inline void +fe25519_sqmul(fe25519 s, const int n, const fe25519 a) +{ + int i; + + for (i = 0; i < n; i++) { + fe25519_sq(s, s); + } + fe25519_mul(s, s, a); +} + +static unsigned int +fe25519_notsquare(const fe25519 x) +{ + fe25519 _10, _11, _1100, _1111, _11110000, _11111111; + fe25519 t, u, v; + unsigned char s[32]; + + /* Jacobi symbol - x^((p-1)/2) */ + fe25519_mul(_10, x, x); + fe25519_mul(_11, x, _10); + fe25519_sq(_1100, _11); + fe25519_sq(_1100, _1100); + fe25519_mul(_1111, _11, _1100); + fe25519_sq(_11110000, _1111); + fe25519_sq(_11110000, _11110000); + fe25519_sq(_11110000, _11110000); + fe25519_sq(_11110000, _11110000); + fe25519_mul(_11111111, _1111, _11110000); + fe25519_copy(t, _11111111); + fe25519_sqmul(t, 2, _11); + fe25519_copy(u, t); + fe25519_sqmul(t, 10, u); + fe25519_sqmul(t, 10, u); + fe25519_copy(v, t); + fe25519_sqmul(t, 30, v); + fe25519_copy(v, t); + fe25519_sqmul(t, 60, v); + fe25519_copy(v, t); + fe25519_sqmul(t, 120, v); + fe25519_sqmul(t, 10, u); + fe25519_sqmul(t, 3, _11); + fe25519_sq(t, t); + + fe25519_tobytes(s, t); + + return s[1] & 1; +} + +/* + r = p + q + */ + +void +ge25519_add(ge25519_p1p1 *r, const ge25519_p3 *p, const ge25519_cached *q) +{ + fe25519 t0; + + fe25519_add(r->X, p->Y, p->X); + fe25519_sub(r->Y, p->Y, p->X); + fe25519_mul(r->Z, r->X, q->YplusX); + fe25519_mul(r->Y, r->Y, q->YminusX); + fe25519_mul(r->T, q->T2d, p->T); + fe25519_mul(r->X, p->Z, q->Z); + fe25519_add(t0, r->X, r->X); + fe25519_sub(r->X, r->Z, r->Y); + fe25519_add(r->Y, r->Z, r->Y); + fe25519_add(r->Z, t0, r->T); + fe25519_sub(r->T, t0, r->T); +} + +static void +slide_vartime(signed char *r, const unsigned char *a) +{ + int i; + int b; + int k; + int ribs; + int cmp; + + for (i = 0; i < 256; ++i) { + r[i] = 1 & (a[i >> 3] >> (i & 7)); + } + for (i = 0; i < 256; ++i) { + if (! r[i]) { + continue; + } + for (b = 1; b <= 6 && i + b < 256; ++b) { + if (! r[i + b]) { + continue; + } + ribs = r[i + b] << b; + cmp = r[i] + ribs; + if (cmp <= 15) { + r[i] = cmp; + r[i + b] = 0; + } else { + cmp = r[i] - ribs; + if (cmp < -15) { + break; + } + r[i] = cmp; + for (k = i + b; k < 256; ++k) { + if (! r[k]) { + r[k] = 1; + break; + } + r[k] = 0; + } + } + } + } +} + +int +ge25519_frombytes(ge25519_p3 *h, const unsigned char *s) +{ + fe25519 u; + fe25519 v; + fe25519 vxx; + fe25519 m_root_check, p_root_check; + fe25519 negx; + fe25519 x_sqrtm1; + int has_m_root, has_p_root; + + fe25519_frombytes(h->Y, s); + fe25519_1(h->Z); + fe25519_sq(u, h->Y); + fe25519_mul(v, u, d); + fe25519_sub(u, u, h->Z); /* u = y^2-1 */ + fe25519_add(v, v, h->Z); /* v = dy^2+1 */ + + fe25519_mul(h->X, u, v); + fe25519_pow22523(h->X, h->X); + fe25519_mul(h->X, u, h->X); /* u((uv)^((q-5)/8)) */ + + fe25519_sq(vxx, h->X); + fe25519_mul(vxx, vxx, v); + fe25519_sub(m_root_check, vxx, u); /* vx^2-u */ + fe25519_add(p_root_check, vxx, u); /* vx^2+u */ + has_m_root = fe25519_iszero(m_root_check); + has_p_root = fe25519_iszero(p_root_check); + fe25519_mul(x_sqrtm1, h->X, sqrtm1); /* x*sqrt(-1) */ + fe25519_cmov(h->X, x_sqrtm1, 1 - has_m_root); + + fe25519_neg(negx, h->X); + fe25519_cmov(h->X, negx, fe25519_isnegative(h->X) ^ (s[31] >> 7)); + fe25519_mul(h->T, h->X, h->Y); + + return (has_m_root | has_p_root) - 1; +} + +int +ge25519_frombytes_negate_vartime(ge25519_p3 *h, const unsigned char *s) +{ + fe25519 u; + fe25519 v; + fe25519 v3; + fe25519 vxx; + fe25519 m_root_check, p_root_check; + + fe25519_frombytes(h->Y, s); + fe25519_1(h->Z); + fe25519_sq(u, h->Y); + fe25519_mul(v, u, d); + fe25519_sub(u, u, h->Z); /* u = y^2-1 */ + fe25519_add(v, v, h->Z); /* v = dy^2+1 */ + + fe25519_sq(v3, v); + fe25519_mul(v3, v3, v); /* v3 = v^3 */ + fe25519_sq(h->X, v3); + fe25519_mul(h->X, h->X, v); + fe25519_mul(h->X, h->X, u); /* x = uv^7 */ + + fe25519_pow22523(h->X, h->X); /* x = (uv^7)^((q-5)/8) */ + fe25519_mul(h->X, h->X, v3); + fe25519_mul(h->X, h->X, u); /* x = uv^3(uv^7)^((q-5)/8) */ + + fe25519_sq(vxx, h->X); + fe25519_mul(vxx, vxx, v); + fe25519_sub(m_root_check, vxx, u); /* vx^2-u */ + if (fe25519_iszero(m_root_check) == 0) { + fe25519_add(p_root_check, vxx, u); /* vx^2+u */ + if (fe25519_iszero(p_root_check) == 0) { + return -1; + } + fe25519_mul(h->X, h->X, sqrtm1); + } + + if (fe25519_isnegative(h->X) == (s[31] >> 7)) { + fe25519_neg(h->X, h->X); + } + fe25519_mul(h->T, h->X, h->Y); + + return 0; +} + +/* + r = p + q + */ + +static void +ge25519_madd(ge25519_p1p1 *r, const ge25519_p3 *p, const ge25519_precomp *q) +{ + fe25519 t0; + + fe25519_add(r->X, p->Y, p->X); + fe25519_sub(r->Y, p->Y, p->X); + fe25519_mul(r->Z, r->X, q->yplusx); + fe25519_mul(r->Y, r->Y, q->yminusx); + fe25519_mul(r->T, q->xy2d, p->T); + fe25519_add(t0, p->Z, p->Z); + fe25519_sub(r->X, r->Z, r->Y); + fe25519_add(r->Y, r->Z, r->Y); + fe25519_add(r->Z, t0, r->T); + fe25519_sub(r->T, t0, r->T); +} + +/* + r = p - q + */ + +static void +ge25519_msub(ge25519_p1p1 *r, const ge25519_p3 *p, const ge25519_precomp *q) +{ + fe25519 t0; + + fe25519_add(r->X, p->Y, p->X); + fe25519_sub(r->Y, p->Y, p->X); + fe25519_mul(r->Z, r->X, q->yminusx); + fe25519_mul(r->Y, r->Y, q->yplusx); + fe25519_mul(r->T, q->xy2d, p->T); + fe25519_add(t0, p->Z, p->Z); + fe25519_sub(r->X, r->Z, r->Y); + fe25519_add(r->Y, r->Z, r->Y); + fe25519_sub(r->Z, t0, r->T); + fe25519_add(r->T, t0, r->T); +} + +/* + r = p + */ + +void +ge25519_p1p1_to_p2(ge25519_p2 *r, const ge25519_p1p1 *p) +{ + fe25519_mul(r->X, p->X, p->T); + fe25519_mul(r->Y, p->Y, p->Z); + fe25519_mul(r->Z, p->Z, p->T); +} + +/* + r = p + */ + +void +ge25519_p1p1_to_p3(ge25519_p3 *r, const ge25519_p1p1 *p) +{ + fe25519_mul(r->X, p->X, p->T); + fe25519_mul(r->Y, p->Y, p->Z); + fe25519_mul(r->Z, p->Z, p->T); + fe25519_mul(r->T, p->X, p->Y); +} + +static void +ge25519_p2_0(ge25519_p2 *h) +{ + fe25519_0(h->X); + fe25519_1(h->Y); + fe25519_1(h->Z); +} + +/* + r = 2 * p + */ + +static void +ge25519_p2_dbl(ge25519_p1p1 *r, const ge25519_p2 *p) +{ + fe25519 t0; + + fe25519_sq(r->X, p->X); + fe25519_sq(r->Z, p->Y); + fe25519_sq2(r->T, p->Z); + fe25519_add(r->Y, p->X, p->Y); + fe25519_sq(t0, r->Y); + fe25519_add(r->Y, r->Z, r->X); + fe25519_sub(r->Z, r->Z, r->X); + fe25519_sub(r->X, t0, r->Y); + fe25519_sub(r->T, r->T, r->Z); +} + +static void +ge25519_p3_0(ge25519_p3 *h) +{ + fe25519_0(h->X); + fe25519_1(h->Y); + fe25519_1(h->Z); + fe25519_0(h->T); +} + +static void +ge25519_cached_0(ge25519_cached *h) +{ + fe25519_1(h->YplusX); + fe25519_1(h->YminusX); + fe25519_1(h->Z); + fe25519_0(h->T2d); +} + +/* + r = p + */ + +void +ge25519_p3_to_cached(ge25519_cached *r, const ge25519_p3 *p) +{ + fe25519_add(r->YplusX, p->Y, p->X); + fe25519_sub(r->YminusX, p->Y, p->X); + fe25519_copy(r->Z, p->Z); + fe25519_mul(r->T2d, p->T, d2); +} + +static void +ge25519_p3_to_precomp(ge25519_precomp *pi, const ge25519_p3 *p) +{ + fe25519 recip; + fe25519 x; + fe25519 y; + fe25519 xy; + + fe25519_invert(recip, p->Z); + fe25519_mul(x, p->X, recip); + fe25519_mul(y, p->Y, recip); + fe25519_add(pi->yplusx, y, x); + fe25519_sub(pi->yminusx, y, x); + fe25519_mul(xy, x, y); + fe25519_mul(pi->xy2d, xy, d2); +} + +/* + r = p + */ + +static void +ge25519_p3_to_p2(ge25519_p2 *r, const ge25519_p3 *p) +{ + fe25519_copy(r->X, p->X); + fe25519_copy(r->Y, p->Y); + fe25519_copy(r->Z, p->Z); +} + +void +ge25519_p3_tobytes(unsigned char *s, const ge25519_p3 *h) +{ + fe25519 recip; + fe25519 x; + fe25519 y; + + fe25519_invert(recip, h->Z); + fe25519_mul(x, h->X, recip); + fe25519_mul(y, h->Y, recip); + fe25519_tobytes(s, y); + s[31] ^= fe25519_isnegative(x) << 7; +} + +/* + r = 2 * p + */ + +static void +ge25519_p3_dbl(ge25519_p1p1 *r, const ge25519_p3 *p) +{ + ge25519_p2 q; + ge25519_p3_to_p2(&q, p); + ge25519_p2_dbl(r, &q); +} + +static void +ge25519_precomp_0(ge25519_precomp *h) +{ + fe25519_1(h->yplusx); + fe25519_1(h->yminusx); + fe25519_0(h->xy2d); +} + +static unsigned char +equal(signed char b, signed char c) +{ + unsigned char ub = b; + unsigned char uc = c; + unsigned char x = ub ^ uc; /* 0: yes; 1..255: no */ + uint32_t y = (uint32_t) x; /* 0: yes; 1..255: no */ + + y -= 1; /* 4294967295: yes; 0..254: no */ + y >>= 31; /* 1: yes; 0: no */ + + return y; +} + +static unsigned char +negative(signed char b) +{ + /* 18446744073709551361..18446744073709551615: yes; 0..255: no */ + uint64_t x = b; + + x >>= 63; /* 1: yes; 0: no */ + + return x; +} + +static void +ge25519_cmov(ge25519_precomp *t, const ge25519_precomp *u, unsigned char b) +{ + fe25519_cmov(t->yplusx, u->yplusx, b); + fe25519_cmov(t->yminusx, u->yminusx, b); + fe25519_cmov(t->xy2d, u->xy2d, b); +} + +static void +ge25519_cmov_cached(ge25519_cached *t, const ge25519_cached *u, unsigned char b) +{ + fe25519_cmov(t->YplusX, u->YplusX, b); + fe25519_cmov(t->YminusX, u->YminusX, b); + fe25519_cmov(t->Z, u->Z, b); + fe25519_cmov(t->T2d, u->T2d, b); +} + +static void +ge25519_cmov8(ge25519_precomp *t, const ge25519_precomp precomp[8], const signed char b) +{ + ge25519_precomp minust; + const unsigned char bnegative = negative(b); + const unsigned char babs = b - (((-bnegative) & b) * ((signed char) 1 << 1)); + + ge25519_precomp_0(t); + ge25519_cmov(t, &precomp[0], equal(babs, 1)); + ge25519_cmov(t, &precomp[1], equal(babs, 2)); + ge25519_cmov(t, &precomp[2], equal(babs, 3)); + ge25519_cmov(t, &precomp[3], equal(babs, 4)); + ge25519_cmov(t, &precomp[4], equal(babs, 5)); + ge25519_cmov(t, &precomp[5], equal(babs, 6)); + ge25519_cmov(t, &precomp[6], equal(babs, 7)); + ge25519_cmov(t, &precomp[7], equal(babs, 8)); + fe25519_copy(minust.yplusx, t->yminusx); + fe25519_copy(minust.yminusx, t->yplusx); + fe25519_neg(minust.xy2d, t->xy2d); + ge25519_cmov(t, &minust, bnegative); +} + +static void +ge25519_cmov8_base(ge25519_precomp *t, const int pos, const signed char b) +{ + static const ge25519_precomp base[32][8] = { /* base[i][j] = (j+1)*256^i*B */ +#ifdef HAVE_TI_MODE +# include "fe_51/base.h" +#else +# include "fe_25_5/base.h" +#endif + }; + ge25519_cmov8(t, base[pos], b); +} + +static void +ge25519_cmov8_cached(ge25519_cached *t, const ge25519_cached cached[8], const signed char b) +{ + ge25519_cached minust; + const unsigned char bnegative = negative(b); + const unsigned char babs = b - (((-bnegative) & b) * ((signed char) 1 << 1)); + + ge25519_cached_0(t); + ge25519_cmov_cached(t, &cached[0], equal(babs, 1)); + ge25519_cmov_cached(t, &cached[1], equal(babs, 2)); + ge25519_cmov_cached(t, &cached[2], equal(babs, 3)); + ge25519_cmov_cached(t, &cached[3], equal(babs, 4)); + ge25519_cmov_cached(t, &cached[4], equal(babs, 5)); + ge25519_cmov_cached(t, &cached[5], equal(babs, 6)); + ge25519_cmov_cached(t, &cached[6], equal(babs, 7)); + ge25519_cmov_cached(t, &cached[7], equal(babs, 8)); + fe25519_copy(minust.YplusX, t->YminusX); + fe25519_copy(minust.YminusX, t->YplusX); + fe25519_copy(minust.Z, t->Z); + fe25519_neg(minust.T2d, t->T2d); + ge25519_cmov_cached(t, &minust, bnegative); +} + +/* + r = p - q + */ + +void +ge25519_sub(ge25519_p1p1 *r, const ge25519_p3 *p, const ge25519_cached *q) +{ + fe25519 t0; + + fe25519_add(r->X, p->Y, p->X); + fe25519_sub(r->Y, p->Y, p->X); + fe25519_mul(r->Z, r->X, q->YminusX); + fe25519_mul(r->Y, r->Y, q->YplusX); + fe25519_mul(r->T, q->T2d, p->T); + fe25519_mul(r->X, p->Z, q->Z); + fe25519_add(t0, r->X, r->X); + fe25519_sub(r->X, r->Z, r->Y); + fe25519_add(r->Y, r->Z, r->Y); + fe25519_sub(r->Z, t0, r->T); + fe25519_add(r->T, t0, r->T); +} + +void +ge25519_tobytes(unsigned char *s, const ge25519_p2 *h) +{ + fe25519 recip; + fe25519 x; + fe25519 y; + + fe25519_invert(recip, h->Z); + fe25519_mul(x, h->X, recip); + fe25519_mul(y, h->Y, recip); + fe25519_tobytes(s, y); + s[31] ^= fe25519_isnegative(x) << 7; +} + +/* + r = a * A + b * B + where a = a[0]+256*a[1]+...+256^31 a[31]. + and b = b[0]+256*b[1]+...+256^31 b[31]. + B is the Ed25519 base point (x,4/5) with x positive. + + Only used for signatures verification. + */ + +void +ge25519_double_scalarmult_vartime(ge25519_p2 *r, const unsigned char *a, + const ge25519_p3 *A, const unsigned char *b) +{ + static const ge25519_precomp Bi[8] = { +#ifdef HAVE_TI_MODE +# include "fe_51/base2.h" +#else +# include "fe_25_5/base2.h" +#endif + }; + signed char aslide[256]; + signed char bslide[256]; + ge25519_cached Ai[8]; /* A,3A,5A,7A,9A,11A,13A,15A */ + ge25519_p1p1 t; + ge25519_p3 u; + ge25519_p3 A2; + int i; + + slide_vartime(aslide, a); + slide_vartime(bslide, b); + + ge25519_p3_to_cached(&Ai[0], A); + + ge25519_p3_dbl(&t, A); + ge25519_p1p1_to_p3(&A2, &t); + + ge25519_add(&t, &A2, &Ai[0]); + ge25519_p1p1_to_p3(&u, &t); + ge25519_p3_to_cached(&Ai[1], &u); + + ge25519_add(&t, &A2, &Ai[1]); + ge25519_p1p1_to_p3(&u, &t); + ge25519_p3_to_cached(&Ai[2], &u); + + ge25519_add(&t, &A2, &Ai[2]); + ge25519_p1p1_to_p3(&u, &t); + ge25519_p3_to_cached(&Ai[3], &u); + + ge25519_add(&t, &A2, &Ai[3]); + ge25519_p1p1_to_p3(&u, &t); + ge25519_p3_to_cached(&Ai[4], &u); + + ge25519_add(&t, &A2, &Ai[4]); + ge25519_p1p1_to_p3(&u, &t); + ge25519_p3_to_cached(&Ai[5], &u); + + ge25519_add(&t, &A2, &Ai[5]); + ge25519_p1p1_to_p3(&u, &t); + ge25519_p3_to_cached(&Ai[6], &u); + + ge25519_add(&t, &A2, &Ai[6]); + ge25519_p1p1_to_p3(&u, &t); + ge25519_p3_to_cached(&Ai[7], &u); + + ge25519_p2_0(r); + + for (i = 255; i >= 0; --i) { + if (aslide[i] || bslide[i]) { + break; + } + } + + for (; i >= 0; --i) { + ge25519_p2_dbl(&t, r); + + if (aslide[i] > 0) { + ge25519_p1p1_to_p3(&u, &t); + ge25519_add(&t, &u, &Ai[aslide[i] / 2]); + } else if (aslide[i] < 0) { + ge25519_p1p1_to_p3(&u, &t); + ge25519_sub(&t, &u, &Ai[(-aslide[i]) / 2]); + } + + if (bslide[i] > 0) { + ge25519_p1p1_to_p3(&u, &t); + ge25519_madd(&t, &u, &Bi[bslide[i] / 2]); + } else if (bslide[i] < 0) { + ge25519_p1p1_to_p3(&u, &t); + ge25519_msub(&t, &u, &Bi[(-bslide[i]) / 2]); + } + + ge25519_p1p1_to_p2(r, &t); + } +} + +/* + h = a * p + where a = a[0]+256*a[1]+...+256^31 a[31] + + Preconditions: + a[31] <= 127 + + p is public + */ + +void +ge25519_scalarmult(ge25519_p3 *h, const unsigned char *a, const ge25519_p3 *p) +{ + signed char e[64]; + signed char carry; + ge25519_p1p1 r; + ge25519_p2 s; + ge25519_p1p1 t2, t3, t4, t5, t6, t7, t8; + ge25519_p3 p2, p3, p4, p5, p6, p7, p8; + ge25519_cached pi[8]; + ge25519_cached t; + int i; + + ge25519_p3_to_cached(&pi[1 - 1], p); /* p */ + + ge25519_p3_dbl(&t2, p); + ge25519_p1p1_to_p3(&p2, &t2); + ge25519_p3_to_cached(&pi[2 - 1], &p2); /* 2p = 2*p */ + + ge25519_add(&t3, p, &pi[2 - 1]); + ge25519_p1p1_to_p3(&p3, &t3); + ge25519_p3_to_cached(&pi[3 - 1], &p3); /* 3p = 2p+p */ + + ge25519_p3_dbl(&t4, &p2); + ge25519_p1p1_to_p3(&p4, &t4); + ge25519_p3_to_cached(&pi[4 - 1], &p4); /* 4p = 2*2p */ + + ge25519_add(&t5, p, &pi[4 - 1]); + ge25519_p1p1_to_p3(&p5, &t5); + ge25519_p3_to_cached(&pi[5 - 1], &p5); /* 5p = 4p+p */ + + ge25519_p3_dbl(&t6, &p3); + ge25519_p1p1_to_p3(&p6, &t6); + ge25519_p3_to_cached(&pi[6 - 1], &p6); /* 6p = 2*3p */ + + ge25519_add(&t7, p, &pi[6 - 1]); + ge25519_p1p1_to_p3(&p7, &t7); + ge25519_p3_to_cached(&pi[7 - 1], &p7); /* 7p = 6p+p */ + + ge25519_p3_dbl(&t8, &p4); + ge25519_p1p1_to_p3(&p8, &t8); + ge25519_p3_to_cached(&pi[8 - 1], &p8); /* 8p = 2*4p */ + + for (i = 0; i < 32; ++i) { + e[2 * i + 0] = (a[i] >> 0) & 15; + e[2 * i + 1] = (a[i] >> 4) & 15; + } + /* each e[i] is between 0 and 15 */ + /* e[63] is between 0 and 7 */ + + carry = 0; + for (i = 0; i < 63; ++i) { + e[i] += carry; + carry = e[i] + 8; + carry >>= 4; + e[i] -= carry * ((signed char) 1 << 4); + } + e[63] += carry; + /* each e[i] is between -8 and 8 */ + + ge25519_p3_0(h); + + for (i = 63; i != 0; i--) { + ge25519_cmov8_cached(&t, pi, e[i]); + ge25519_add(&r, h, &t); + + ge25519_p1p1_to_p2(&s, &r); + ge25519_p2_dbl(&r, &s); + ge25519_p1p1_to_p2(&s, &r); + ge25519_p2_dbl(&r, &s); + ge25519_p1p1_to_p2(&s, &r); + ge25519_p2_dbl(&r, &s); + ge25519_p1p1_to_p2(&s, &r); + ge25519_p2_dbl(&r, &s); + + ge25519_p1p1_to_p3(h, &r); /* *16 */ + } + ge25519_cmov8_cached(&t, pi, e[i]); + ge25519_add(&r, h, &t); + + ge25519_p1p1_to_p3(h, &r); +} + +/* + h = a * B (with precomputation) + where a = a[0]+256*a[1]+...+256^31 a[31] + B is the Ed25519 base point (x,4/5) with x positive + (as bytes: 0x5866666666666666666666666666666666666666666666666666666666666666) + + Preconditions: + a[31] <= 127 + */ + +void +ge25519_scalarmult_base(ge25519_p3 *h, const unsigned char *a) +{ + signed char e[64]; + signed char carry; + ge25519_p1p1 r; + ge25519_p2 s; + ge25519_precomp t; + int i; + + for (i = 0; i < 32; ++i) { + e[2 * i + 0] = (a[i] >> 0) & 15; + e[2 * i + 1] = (a[i] >> 4) & 15; + } + /* each e[i] is between 0 and 15 */ + /* e[63] is between 0 and 7 */ + + carry = 0; + for (i = 0; i < 63; ++i) { + e[i] += carry; + carry = e[i] + 8; + carry >>= 4; + e[i] -= carry * ((signed char) 1 << 4); + } + e[63] += carry; + /* each e[i] is between -8 and 8 */ + + ge25519_p3_0(h); + + for (i = 1; i < 64; i += 2) { + ge25519_cmov8_base(&t, i / 2, e[i]); + ge25519_madd(&r, h, &t); + ge25519_p1p1_to_p3(h, &r); + } + + ge25519_p3_dbl(&r, h); + ge25519_p1p1_to_p2(&s, &r); + ge25519_p2_dbl(&r, &s); + ge25519_p1p1_to_p2(&s, &r); + ge25519_p2_dbl(&r, &s); + ge25519_p1p1_to_p2(&s, &r); + ge25519_p2_dbl(&r, &s); + ge25519_p1p1_to_p3(h, &r); + + for (i = 0; i < 64; i += 2) { + ge25519_cmov8_base(&t, i / 2, e[i]); + ge25519_madd(&r, h, &t); + ge25519_p1p1_to_p3(h, &r); + } +} + +/* multiply by the order of the main subgroup l = 2^252+27742317777372353535851937790883648493 */ +static void +ge25519_mul_l(ge25519_p3 *r, const ge25519_p3 *A) +{ + static const signed char aslide[253] = { + 13, 0, 0, 0, 0, -1, 0, 0, 0, 0, -11, 0, 0, 0, 0, 0, 0, -5, 0, 0, 0, 0, 0, 0, -3, 0, 0, 0, 0, -13, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, -13, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, -13, 0, 0, 0, 0, 0, 0, -3, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 3, 0, 0, 0, 0, -11, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 7, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 + }; + ge25519_cached Ai[8]; + ge25519_p1p1 t; + ge25519_p3 u; + ge25519_p3 A2; + int i; + + ge25519_p3_to_cached(&Ai[0], A); + ge25519_p3_dbl(&t, A); + ge25519_p1p1_to_p3(&A2, &t); + ge25519_add(&t, &A2, &Ai[0]); + ge25519_p1p1_to_p3(&u, &t); + ge25519_p3_to_cached(&Ai[1], &u); + ge25519_add(&t, &A2, &Ai[1]); + ge25519_p1p1_to_p3(&u, &t); + ge25519_p3_to_cached(&Ai[2], &u); + ge25519_add(&t, &A2, &Ai[2]); + ge25519_p1p1_to_p3(&u, &t); + ge25519_p3_to_cached(&Ai[3], &u); + ge25519_add(&t, &A2, &Ai[3]); + ge25519_p1p1_to_p3(&u, &t); + ge25519_p3_to_cached(&Ai[4], &u); + ge25519_add(&t, &A2, &Ai[4]); + ge25519_p1p1_to_p3(&u, &t); + ge25519_p3_to_cached(&Ai[5], &u); + ge25519_add(&t, &A2, &Ai[5]); + ge25519_p1p1_to_p3(&u, &t); + ge25519_p3_to_cached(&Ai[6], &u); + ge25519_add(&t, &A2, &Ai[6]); + ge25519_p1p1_to_p3(&u, &t); + ge25519_p3_to_cached(&Ai[7], &u); + + ge25519_p3_0(r); + + for (i = 252; i >= 0; --i) { + ge25519_p3_dbl(&t, r); + + if (aslide[i] > 0) { + ge25519_p1p1_to_p3(&u, &t); + ge25519_add(&t, &u, &Ai[aslide[i] / 2]); + } else if (aslide[i] < 0) { + ge25519_p1p1_to_p3(&u, &t); + ge25519_sub(&t, &u, &Ai[(-aslide[i]) / 2]); + } + + ge25519_p1p1_to_p3(r, &t); + } +} + +int +ge25519_is_on_curve(const ge25519_p3 *p) +{ + fe25519 x2; + fe25519 y2; + fe25519 z2; + fe25519 z4; + fe25519 t0; + fe25519 t1; + + fe25519_sq(x2, p->X); + fe25519_sq(y2, p->Y); + fe25519_sq(z2, p->Z); + fe25519_sub(t0, y2, x2); + fe25519_mul(t0, t0, z2); + + fe25519_mul(t1, x2, y2); + fe25519_mul(t1, t1, d); + fe25519_sq(z4, z2); + fe25519_add(t1, t1, z4); + fe25519_sub(t0, t0, t1); + + return fe25519_iszero(t0); +} + +int +ge25519_is_on_main_subgroup(const ge25519_p3 *p) +{ + ge25519_p3 pl; + + ge25519_mul_l(&pl, p); + + return fe25519_iszero(pl.X); +} + +int +ge25519_is_canonical(const unsigned char *s) +{ + unsigned char c; + unsigned char d; + unsigned int i; + + c = (s[31] & 0x7f) ^ 0x7f; + for (i = 30; i > 0; i--) { + c |= s[i] ^ 0xff; + } + c = (((unsigned int) c) - 1U) >> 8; + d = (0xed - 1U - (unsigned int) s[0]) >> 8; + + return 1 - (c & d & 1); +} + +int +ge25519_has_small_order(const unsigned char s[32]) +{ + CRYPTO_ALIGN(16) + static const unsigned char blacklist[][32] = { + /* 0 (order 4) */ + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, + /* 1 (order 1) */ + { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, + /* 2707385501144840649318225287225658788936804267575313519463743609750303402022 + (order 8) */ + { 0x26, 0xe8, 0x95, 0x8f, 0xc2, 0xb2, 0x27, 0xb0, 0x45, 0xc3, 0xf4, + 0x89, 0xf2, 0xef, 0x98, 0xf0, 0xd5, 0xdf, 0xac, 0x05, 0xd3, 0xc6, + 0x33, 0x39, 0xb1, 0x38, 0x02, 0x88, 0x6d, 0x53, 0xfc, 0x05 }, + /* 55188659117513257062467267217118295137698188065244968500265048394206261417927 + (order 8) */ + { 0xc7, 0x17, 0x6a, 0x70, 0x3d, 0x4d, 0xd8, 0x4f, 0xba, 0x3c, 0x0b, + 0x76, 0x0d, 0x10, 0x67, 0x0f, 0x2a, 0x20, 0x53, 0xfa, 0x2c, 0x39, + 0xcc, 0xc6, 0x4e, 0xc7, 0xfd, 0x77, 0x92, 0xac, 0x03, 0x7a }, + /* p-1 (order 2) */ + { 0xec, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f }, + /* p (=0, order 4) */ + { 0xed, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f }, + /* p+1 (=1, order 1) */ + { 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f } + }; + unsigned char c[7] = { 0 }; + unsigned int k; + size_t i, j; + + COMPILER_ASSERT(7 == sizeof blacklist / sizeof blacklist[0]); + for (j = 0; j < 31; j++) { + for (i = 0; i < sizeof blacklist / sizeof blacklist[0]; i++) { + c[i] |= s[j] ^ blacklist[i][j]; + } + } + for (i = 0; i < sizeof blacklist / sizeof blacklist[0]; i++) { + c[i] |= (s[j] & 0x7f) ^ blacklist[i][j]; + } + k = 0; + for (i = 0; i < sizeof blacklist / sizeof blacklist[0]; i++) { + k |= (c[i] - 1); + } + return (int) ((k >> 8) & 1); +} + +/* + Input: + a[0]+256*a[1]+...+256^31*a[31] = a + b[0]+256*b[1]+...+256^31*b[31] = b + * + Output: + s[0]+256*s[1]+...+256^31*s[31] = (ab) mod l + where l = 2^252 + 27742317777372353535851937790883648493. + */ + +void +sc25519_mul(unsigned char s[32], const unsigned char a[32], const unsigned char b[32]) +{ + int64_t a0 = 2097151 & load_3(a); + int64_t a1 = 2097151 & (load_4(a + 2) >> 5); + int64_t a2 = 2097151 & (load_3(a + 5) >> 2); + int64_t a3 = 2097151 & (load_4(a + 7) >> 7); + int64_t a4 = 2097151 & (load_4(a + 10) >> 4); + int64_t a5 = 2097151 & (load_3(a + 13) >> 1); + int64_t a6 = 2097151 & (load_4(a + 15) >> 6); + int64_t a7 = 2097151 & (load_3(a + 18) >> 3); + int64_t a8 = 2097151 & load_3(a + 21); + int64_t a9 = 2097151 & (load_4(a + 23) >> 5); + int64_t a10 = 2097151 & (load_3(a + 26) >> 2); + int64_t a11 = (load_4(a + 28) >> 7); + + int64_t b0 = 2097151 & load_3(b); + int64_t b1 = 2097151 & (load_4(b + 2) >> 5); + int64_t b2 = 2097151 & (load_3(b + 5) >> 2); + int64_t b3 = 2097151 & (load_4(b + 7) >> 7); + int64_t b4 = 2097151 & (load_4(b + 10) >> 4); + int64_t b5 = 2097151 & (load_3(b + 13) >> 1); + int64_t b6 = 2097151 & (load_4(b + 15) >> 6); + int64_t b7 = 2097151 & (load_3(b + 18) >> 3); + int64_t b8 = 2097151 & load_3(b + 21); + int64_t b9 = 2097151 & (load_4(b + 23) >> 5); + int64_t b10 = 2097151 & (load_3(b + 26) >> 2); + int64_t b11 = (load_4(b + 28) >> 7); + + int64_t s0; + int64_t s1; + int64_t s2; + int64_t s3; + int64_t s4; + int64_t s5; + int64_t s6; + int64_t s7; + int64_t s8; + int64_t s9; + int64_t s10; + int64_t s11; + int64_t s12; + int64_t s13; + int64_t s14; + int64_t s15; + int64_t s16; + int64_t s17; + int64_t s18; + int64_t s19; + int64_t s20; + int64_t s21; + int64_t s22; + int64_t s23; + + int64_t carry0; + int64_t carry1; + int64_t carry2; + int64_t carry3; + int64_t carry4; + int64_t carry5; + int64_t carry6; + int64_t carry7; + int64_t carry8; + int64_t carry9; + int64_t carry10; + int64_t carry11; + int64_t carry12; + int64_t carry13; + int64_t carry14; + int64_t carry15; + int64_t carry16; + int64_t carry17; + int64_t carry18; + int64_t carry19; + int64_t carry20; + int64_t carry21; + int64_t carry22; + + s0 = a0 * b0; + s1 = a0 * b1 + a1 * b0; + s2 = a0 * b2 + a1 * b1 + a2 * b0; + s3 = a0 * b3 + a1 * b2 + a2 * b1 + a3 * b0; + s4 = a0 * b4 + a1 * b3 + a2 * b2 + a3 * b1 + a4 * b0; + s5 = a0 * b5 + a1 * b4 + a2 * b3 + a3 * b2 + a4 * b1 + a5 * b0; + s6 = a0 * b6 + a1 * b5 + a2 * b4 + a3 * b3 + a4 * b2 + a5 * b1 + a6 * b0; + s7 = a0 * b7 + a1 * b6 + a2 * b5 + a3 * b4 + a4 * b3 + a5 * b2 + + a6 * b1 + a7 * b0; + s8 = a0 * b8 + a1 * b7 + a2 * b6 + a3 * b5 + a4 * b4 + a5 * b3 + + a6 * b2 + a7 * b1 + a8 * b0; + s9 = a0 * b9 + a1 * b8 + a2 * b7 + a3 * b6 + a4 * b5 + a5 * b4 + + a6 * b3 + a7 * b2 + a8 * b1 + a9 * b0; + s10 = a0 * b10 + a1 * b9 + a2 * b8 + a3 * b7 + a4 * b6 + a5 * b5 + + a6 * b4 + a7 * b3 + a8 * b2 + a9 * b1 + a10 * b0; + s11 = a0 * b11 + a1 * b10 + a2 * b9 + a3 * b8 + a4 * b7 + a5 * b6 + + a6 * b5 + a7 * b4 + a8 * b3 + a9 * b2 + a10 * b1 + a11 * b0; + s12 = a1 * b11 + a2 * b10 + a3 * b9 + a4 * b8 + a5 * b7 + a6 * b6 + + a7 * b5 + a8 * b4 + a9 * b3 + a10 * b2 + a11 * b1; + s13 = a2 * b11 + a3 * b10 + a4 * b9 + a5 * b8 + a6 * b7 + a7 * b6 + + a8 * b5 + a9 * b4 + a10 * b3 + a11 * b2; + s14 = a3 * b11 + a4 * b10 + a5 * b9 + a6 * b8 + a7 * b7 + a8 * b6 + + a9 * b5 + a10 * b4 + a11 * b3; + s15 = a4 * b11 + a5 * b10 + a6 * b9 + a7 * b8 + a8 * b7 + a9 * b6 + + a10 * b5 + a11 * b4; + s16 = + a5 * b11 + a6 * b10 + a7 * b9 + a8 * b8 + a9 * b7 + a10 * b6 + a11 * b5; + s17 = a6 * b11 + a7 * b10 + a8 * b9 + a9 * b8 + a10 * b7 + a11 * b6; + s18 = a7 * b11 + a8 * b10 + a9 * b9 + a10 * b8 + a11 * b7; + s19 = a8 * b11 + a9 * b10 + a10 * b9 + a11 * b8; + s20 = a9 * b11 + a10 * b10 + a11 * b9; + s21 = a10 * b11 + a11 * b10; + s22 = a11 * b11; + s23 = 0; + + carry0 = (s0 + (int64_t) (1L << 20)) >> 21; + s1 += carry0; + s0 -= carry0 * ((uint64_t) 1L << 21); + carry2 = (s2 + (int64_t) (1L << 20)) >> 21; + s3 += carry2; + s2 -= carry2 * ((uint64_t) 1L << 21); + carry4 = (s4 + (int64_t) (1L << 20)) >> 21; + s5 += carry4; + s4 -= carry4 * ((uint64_t) 1L << 21); + carry6 = (s6 + (int64_t) (1L << 20)) >> 21; + s7 += carry6; + s6 -= carry6 * ((uint64_t) 1L << 21); + carry8 = (s8 + (int64_t) (1L << 20)) >> 21; + s9 += carry8; + s8 -= carry8 * ((uint64_t) 1L << 21); + carry10 = (s10 + (int64_t) (1L << 20)) >> 21; + s11 += carry10; + s10 -= carry10 * ((uint64_t) 1L << 21); + carry12 = (s12 + (int64_t) (1L << 20)) >> 21; + s13 += carry12; + s12 -= carry12 * ((uint64_t) 1L << 21); + carry14 = (s14 + (int64_t) (1L << 20)) >> 21; + s15 += carry14; + s14 -= carry14 * ((uint64_t) 1L << 21); + carry16 = (s16 + (int64_t) (1L << 20)) >> 21; + s17 += carry16; + s16 -= carry16 * ((uint64_t) 1L << 21); + carry18 = (s18 + (int64_t) (1L << 20)) >> 21; + s19 += carry18; + s18 -= carry18 * ((uint64_t) 1L << 21); + carry20 = (s20 + (int64_t) (1L << 20)) >> 21; + s21 += carry20; + s20 -= carry20 * ((uint64_t) 1L << 21); + carry22 = (s22 + (int64_t) (1L << 20)) >> 21; + s23 += carry22; + s22 -= carry22 * ((uint64_t) 1L << 21); + + carry1 = (s1 + (int64_t) (1L << 20)) >> 21; + s2 += carry1; + s1 -= carry1 * ((uint64_t) 1L << 21); + carry3 = (s3 + (int64_t) (1L << 20)) >> 21; + s4 += carry3; + s3 -= carry3 * ((uint64_t) 1L << 21); + carry5 = (s5 + (int64_t) (1L << 20)) >> 21; + s6 += carry5; + s5 -= carry5 * ((uint64_t) 1L << 21); + carry7 = (s7 + (int64_t) (1L << 20)) >> 21; + s8 += carry7; + s7 -= carry7 * ((uint64_t) 1L << 21); + carry9 = (s9 + (int64_t) (1L << 20)) >> 21; + s10 += carry9; + s9 -= carry9 * ((uint64_t) 1L << 21); + carry11 = (s11 + (int64_t) (1L << 20)) >> 21; + s12 += carry11; + s11 -= carry11 * ((uint64_t) 1L << 21); + carry13 = (s13 + (int64_t) (1L << 20)) >> 21; + s14 += carry13; + s13 -= carry13 * ((uint64_t) 1L << 21); + carry15 = (s15 + (int64_t) (1L << 20)) >> 21; + s16 += carry15; + s15 -= carry15 * ((uint64_t) 1L << 21); + carry17 = (s17 + (int64_t) (1L << 20)) >> 21; + s18 += carry17; + s17 -= carry17 * ((uint64_t) 1L << 21); + carry19 = (s19 + (int64_t) (1L << 20)) >> 21; + s20 += carry19; + s19 -= carry19 * ((uint64_t) 1L << 21); + carry21 = (s21 + (int64_t) (1L << 20)) >> 21; + s22 += carry21; + s21 -= carry21 * ((uint64_t) 1L << 21); + + s11 += s23 * 666643; + s12 += s23 * 470296; + s13 += s23 * 654183; + s14 -= s23 * 997805; + s15 += s23 * 136657; + s16 -= s23 * 683901; + + s10 += s22 * 666643; + s11 += s22 * 470296; + s12 += s22 * 654183; + s13 -= s22 * 997805; + s14 += s22 * 136657; + s15 -= s22 * 683901; + + s9 += s21 * 666643; + s10 += s21 * 470296; + s11 += s21 * 654183; + s12 -= s21 * 997805; + s13 += s21 * 136657; + s14 -= s21 * 683901; + + s8 += s20 * 666643; + s9 += s20 * 470296; + s10 += s20 * 654183; + s11 -= s20 * 997805; + s12 += s20 * 136657; + s13 -= s20 * 683901; + + s7 += s19 * 666643; + s8 += s19 * 470296; + s9 += s19 * 654183; + s10 -= s19 * 997805; + s11 += s19 * 136657; + s12 -= s19 * 683901; + + s6 += s18 * 666643; + s7 += s18 * 470296; + s8 += s18 * 654183; + s9 -= s18 * 997805; + s10 += s18 * 136657; + s11 -= s18 * 683901; + + carry6 = (s6 + (int64_t) (1L << 20)) >> 21; + s7 += carry6; + s6 -= carry6 * ((uint64_t) 1L << 21); + carry8 = (s8 + (int64_t) (1L << 20)) >> 21; + s9 += carry8; + s8 -= carry8 * ((uint64_t) 1L << 21); + carry10 = (s10 + (int64_t) (1L << 20)) >> 21; + s11 += carry10; + s10 -= carry10 * ((uint64_t) 1L << 21); + carry12 = (s12 + (int64_t) (1L << 20)) >> 21; + s13 += carry12; + s12 -= carry12 * ((uint64_t) 1L << 21); + carry14 = (s14 + (int64_t) (1L << 20)) >> 21; + s15 += carry14; + s14 -= carry14 * ((uint64_t) 1L << 21); + carry16 = (s16 + (int64_t) (1L << 20)) >> 21; + s17 += carry16; + s16 -= carry16 * ((uint64_t) 1L << 21); + + carry7 = (s7 + (int64_t) (1L << 20)) >> 21; + s8 += carry7; + s7 -= carry7 * ((uint64_t) 1L << 21); + carry9 = (s9 + (int64_t) (1L << 20)) >> 21; + s10 += carry9; + s9 -= carry9 * ((uint64_t) 1L << 21); + carry11 = (s11 + (int64_t) (1L << 20)) >> 21; + s12 += carry11; + s11 -= carry11 * ((uint64_t) 1L << 21); + carry13 = (s13 + (int64_t) (1L << 20)) >> 21; + s14 += carry13; + s13 -= carry13 * ((uint64_t) 1L << 21); + carry15 = (s15 + (int64_t) (1L << 20)) >> 21; + s16 += carry15; + s15 -= carry15 * ((uint64_t) 1L << 21); + + s5 += s17 * 666643; + s6 += s17 * 470296; + s7 += s17 * 654183; + s8 -= s17 * 997805; + s9 += s17 * 136657; + s10 -= s17 * 683901; + + s4 += s16 * 666643; + s5 += s16 * 470296; + s6 += s16 * 654183; + s7 -= s16 * 997805; + s8 += s16 * 136657; + s9 -= s16 * 683901; + + s3 += s15 * 666643; + s4 += s15 * 470296; + s5 += s15 * 654183; + s6 -= s15 * 997805; + s7 += s15 * 136657; + s8 -= s15 * 683901; + + s2 += s14 * 666643; + s3 += s14 * 470296; + s4 += s14 * 654183; + s5 -= s14 * 997805; + s6 += s14 * 136657; + s7 -= s14 * 683901; + + s1 += s13 * 666643; + s2 += s13 * 470296; + s3 += s13 * 654183; + s4 -= s13 * 997805; + s5 += s13 * 136657; + s6 -= s13 * 683901; + + s0 += s12 * 666643; + s1 += s12 * 470296; + s2 += s12 * 654183; + s3 -= s12 * 997805; + s4 += s12 * 136657; + s5 -= s12 * 683901; + s12 = 0; + + carry0 = (s0 + (int64_t) (1L << 20)) >> 21; + s1 += carry0; + s0 -= carry0 * ((uint64_t) 1L << 21); + carry2 = (s2 + (int64_t) (1L << 20)) >> 21; + s3 += carry2; + s2 -= carry2 * ((uint64_t) 1L << 21); + carry4 = (s4 + (int64_t) (1L << 20)) >> 21; + s5 += carry4; + s4 -= carry4 * ((uint64_t) 1L << 21); + carry6 = (s6 + (int64_t) (1L << 20)) >> 21; + s7 += carry6; + s6 -= carry6 * ((uint64_t) 1L << 21); + carry8 = (s8 + (int64_t) (1L << 20)) >> 21; + s9 += carry8; + s8 -= carry8 * ((uint64_t) 1L << 21); + carry10 = (s10 + (int64_t) (1L << 20)) >> 21; + s11 += carry10; + s10 -= carry10 * ((uint64_t) 1L << 21); + + carry1 = (s1 + (int64_t) (1L << 20)) >> 21; + s2 += carry1; + s1 -= carry1 * ((uint64_t) 1L << 21); + carry3 = (s3 + (int64_t) (1L << 20)) >> 21; + s4 += carry3; + s3 -= carry3 * ((uint64_t) 1L << 21); + carry5 = (s5 + (int64_t) (1L << 20)) >> 21; + s6 += carry5; + s5 -= carry5 * ((uint64_t) 1L << 21); + carry7 = (s7 + (int64_t) (1L << 20)) >> 21; + s8 += carry7; + s7 -= carry7 * ((uint64_t) 1L << 21); + carry9 = (s9 + (int64_t) (1L << 20)) >> 21; + s10 += carry9; + s9 -= carry9 * ((uint64_t) 1L << 21); + carry11 = (s11 + (int64_t) (1L << 20)) >> 21; + s12 += carry11; + s11 -= carry11 * ((uint64_t) 1L << 21); + + s0 += s12 * 666643; + s1 += s12 * 470296; + s2 += s12 * 654183; + s3 -= s12 * 997805; + s4 += s12 * 136657; + s5 -= s12 * 683901; + s12 = 0; + + carry0 = s0 >> 21; + s1 += carry0; + s0 -= carry0 * ((uint64_t) 1L << 21); + carry1 = s1 >> 21; + s2 += carry1; + s1 -= carry1 * ((uint64_t) 1L << 21); + carry2 = s2 >> 21; + s3 += carry2; + s2 -= carry2 * ((uint64_t) 1L << 21); + carry3 = s3 >> 21; + s4 += carry3; + s3 -= carry3 * ((uint64_t) 1L << 21); + carry4 = s4 >> 21; + s5 += carry4; + s4 -= carry4 * ((uint64_t) 1L << 21); + carry5 = s5 >> 21; + s6 += carry5; + s5 -= carry5 * ((uint64_t) 1L << 21); + carry6 = s6 >> 21; + s7 += carry6; + s6 -= carry6 * ((uint64_t) 1L << 21); + carry7 = s7 >> 21; + s8 += carry7; + s7 -= carry7 * ((uint64_t) 1L << 21); + carry8 = s8 >> 21; + s9 += carry8; + s8 -= carry8 * ((uint64_t) 1L << 21); + carry9 = s9 >> 21; + s10 += carry9; + s9 -= carry9 * ((uint64_t) 1L << 21); + carry10 = s10 >> 21; + s11 += carry10; + s10 -= carry10 * ((uint64_t) 1L << 21); + carry11 = s11 >> 21; + s12 += carry11; + s11 -= carry11 * ((uint64_t) 1L << 21); + + s0 += s12 * 666643; + s1 += s12 * 470296; + s2 += s12 * 654183; + s3 -= s12 * 997805; + s4 += s12 * 136657; + s5 -= s12 * 683901; + + carry0 = s0 >> 21; + s1 += carry0; + s0 -= carry0 * ((uint64_t) 1L << 21); + carry1 = s1 >> 21; + s2 += carry1; + s1 -= carry1 * ((uint64_t) 1L << 21); + carry2 = s2 >> 21; + s3 += carry2; + s2 -= carry2 * ((uint64_t) 1L << 21); + carry3 = s3 >> 21; + s4 += carry3; + s3 -= carry3 * ((uint64_t) 1L << 21); + carry4 = s4 >> 21; + s5 += carry4; + s4 -= carry4 * ((uint64_t) 1L << 21); + carry5 = s5 >> 21; + s6 += carry5; + s5 -= carry5 * ((uint64_t) 1L << 21); + carry6 = s6 >> 21; + s7 += carry6; + s6 -= carry6 * ((uint64_t) 1L << 21); + carry7 = s7 >> 21; + s8 += carry7; + s7 -= carry7 * ((uint64_t) 1L << 21); + carry8 = s8 >> 21; + s9 += carry8; + s8 -= carry8 * ((uint64_t) 1L << 21); + carry9 = s9 >> 21; + s10 += carry9; + s9 -= carry9 * ((uint64_t) 1L << 21); + carry10 = s10 >> 21; + s11 += carry10; + s10 -= carry10 * ((uint64_t) 1L << 21); + + s[0] = s0 >> 0; + s[1] = s0 >> 8; + s[2] = (s0 >> 16) | (s1 * ((uint64_t) 1 << 5)); + s[3] = s1 >> 3; + s[4] = s1 >> 11; + s[5] = (s1 >> 19) | (s2 * ((uint64_t) 1 << 2)); + s[6] = s2 >> 6; + s[7] = (s2 >> 14) | (s3 * ((uint64_t) 1 << 7)); + s[8] = s3 >> 1; + s[9] = s3 >> 9; + s[10] = (s3 >> 17) | (s4 * ((uint64_t) 1 << 4)); + s[11] = s4 >> 4; + s[12] = s4 >> 12; + s[13] = (s4 >> 20) | (s5 * ((uint64_t) 1 << 1)); + s[14] = s5 >> 7; + s[15] = (s5 >> 15) | (s6 * ((uint64_t) 1 << 6)); + s[16] = s6 >> 2; + s[17] = s6 >> 10; + s[18] = (s6 >> 18) | (s7 * ((uint64_t) 1 << 3)); + s[19] = s7 >> 5; + s[20] = s7 >> 13; + s[21] = s8 >> 0; + s[22] = s8 >> 8; + s[23] = (s8 >> 16) | (s9 * ((uint64_t) 1 << 5)); + s[24] = s9 >> 3; + s[25] = s9 >> 11; + s[26] = (s9 >> 19) | (s10 * ((uint64_t) 1 << 2)); + s[27] = s10 >> 6; + s[28] = (s10 >> 14) | (s11 * ((uint64_t) 1 << 7)); + s[29] = s11 >> 1; + s[30] = s11 >> 9; + s[31] = s11 >> 17; +} + +/* + Input: + a[0]+256*a[1]+...+256^31*a[31] = a + b[0]+256*b[1]+...+256^31*b[31] = b + c[0]+256*c[1]+...+256^31*c[31] = c + * + Output: + s[0]+256*s[1]+...+256^31*s[31] = (ab+c) mod l + where l = 2^252 + 27742317777372353535851937790883648493. + */ + +void +sc25519_muladd(unsigned char s[32], const unsigned char a[32], + const unsigned char b[32], const unsigned char c[32]) +{ + int64_t a0 = 2097151 & load_3(a); + int64_t a1 = 2097151 & (load_4(a + 2) >> 5); + int64_t a2 = 2097151 & (load_3(a + 5) >> 2); + int64_t a3 = 2097151 & (load_4(a + 7) >> 7); + int64_t a4 = 2097151 & (load_4(a + 10) >> 4); + int64_t a5 = 2097151 & (load_3(a + 13) >> 1); + int64_t a6 = 2097151 & (load_4(a + 15) >> 6); + int64_t a7 = 2097151 & (load_3(a + 18) >> 3); + int64_t a8 = 2097151 & load_3(a + 21); + int64_t a9 = 2097151 & (load_4(a + 23) >> 5); + int64_t a10 = 2097151 & (load_3(a + 26) >> 2); + int64_t a11 = (load_4(a + 28) >> 7); + + int64_t b0 = 2097151 & load_3(b); + int64_t b1 = 2097151 & (load_4(b + 2) >> 5); + int64_t b2 = 2097151 & (load_3(b + 5) >> 2); + int64_t b3 = 2097151 & (load_4(b + 7) >> 7); + int64_t b4 = 2097151 & (load_4(b + 10) >> 4); + int64_t b5 = 2097151 & (load_3(b + 13) >> 1); + int64_t b6 = 2097151 & (load_4(b + 15) >> 6); + int64_t b7 = 2097151 & (load_3(b + 18) >> 3); + int64_t b8 = 2097151 & load_3(b + 21); + int64_t b9 = 2097151 & (load_4(b + 23) >> 5); + int64_t b10 = 2097151 & (load_3(b + 26) >> 2); + int64_t b11 = (load_4(b + 28) >> 7); + + int64_t c0 = 2097151 & load_3(c); + int64_t c1 = 2097151 & (load_4(c + 2) >> 5); + int64_t c2 = 2097151 & (load_3(c + 5) >> 2); + int64_t c3 = 2097151 & (load_4(c + 7) >> 7); + int64_t c4 = 2097151 & (load_4(c + 10) >> 4); + int64_t c5 = 2097151 & (load_3(c + 13) >> 1); + int64_t c6 = 2097151 & (load_4(c + 15) >> 6); + int64_t c7 = 2097151 & (load_3(c + 18) >> 3); + int64_t c8 = 2097151 & load_3(c + 21); + int64_t c9 = 2097151 & (load_4(c + 23) >> 5); + int64_t c10 = 2097151 & (load_3(c + 26) >> 2); + int64_t c11 = (load_4(c + 28) >> 7); + + int64_t s0; + int64_t s1; + int64_t s2; + int64_t s3; + int64_t s4; + int64_t s5; + int64_t s6; + int64_t s7; + int64_t s8; + int64_t s9; + int64_t s10; + int64_t s11; + int64_t s12; + int64_t s13; + int64_t s14; + int64_t s15; + int64_t s16; + int64_t s17; + int64_t s18; + int64_t s19; + int64_t s20; + int64_t s21; + int64_t s22; + int64_t s23; + + int64_t carry0; + int64_t carry1; + int64_t carry2; + int64_t carry3; + int64_t carry4; + int64_t carry5; + int64_t carry6; + int64_t carry7; + int64_t carry8; + int64_t carry9; + int64_t carry10; + int64_t carry11; + int64_t carry12; + int64_t carry13; + int64_t carry14; + int64_t carry15; + int64_t carry16; + int64_t carry17; + int64_t carry18; + int64_t carry19; + int64_t carry20; + int64_t carry21; + int64_t carry22; + + s0 = c0 + a0 * b0; + s1 = c1 + a0 * b1 + a1 * b0; + s2 = c2 + a0 * b2 + a1 * b1 + a2 * b0; + s3 = c3 + a0 * b3 + a1 * b2 + a2 * b1 + a3 * b0; + s4 = c4 + a0 * b4 + a1 * b3 + a2 * b2 + a3 * b1 + a4 * b0; + s5 = c5 + a0 * b5 + a1 * b4 + a2 * b3 + a3 * b2 + a4 * b1 + a5 * b0; + s6 = c6 + a0 * b6 + a1 * b5 + a2 * b4 + a3 * b3 + a4 * b2 + a5 * b1 + + a6 * b0; + s7 = c7 + a0 * b7 + a1 * b6 + a2 * b5 + a3 * b4 + a4 * b3 + a5 * b2 + + a6 * b1 + a7 * b0; + s8 = c8 + a0 * b8 + a1 * b7 + a2 * b6 + a3 * b5 + a4 * b4 + a5 * b3 + + a6 * b2 + a7 * b1 + a8 * b0; + s9 = c9 + a0 * b9 + a1 * b8 + a2 * b7 + a3 * b6 + a4 * b5 + a5 * b4 + + a6 * b3 + a7 * b2 + a8 * b1 + a9 * b0; + s10 = c10 + a0 * b10 + a1 * b9 + a2 * b8 + a3 * b7 + a4 * b6 + a5 * b5 + + a6 * b4 + a7 * b3 + a8 * b2 + a9 * b1 + a10 * b0; + s11 = c11 + a0 * b11 + a1 * b10 + a2 * b9 + a3 * b8 + a4 * b7 + a5 * b6 + + a6 * b5 + a7 * b4 + a8 * b3 + a9 * b2 + a10 * b1 + a11 * b0; + s12 = a1 * b11 + a2 * b10 + a3 * b9 + a4 * b8 + a5 * b7 + a6 * b6 + + a7 * b5 + a8 * b4 + a9 * b3 + a10 * b2 + a11 * b1; + s13 = a2 * b11 + a3 * b10 + a4 * b9 + a5 * b8 + a6 * b7 + a7 * b6 + + a8 * b5 + a9 * b4 + a10 * b3 + a11 * b2; + s14 = a3 * b11 + a4 * b10 + a5 * b9 + a6 * b8 + a7 * b7 + a8 * b6 + + a9 * b5 + a10 * b4 + a11 * b3; + s15 = a4 * b11 + a5 * b10 + a6 * b9 + a7 * b8 + a8 * b7 + a9 * b6 + + a10 * b5 + a11 * b4; + s16 = + a5 * b11 + a6 * b10 + a7 * b9 + a8 * b8 + a9 * b7 + a10 * b6 + a11 * b5; + s17 = a6 * b11 + a7 * b10 + a8 * b9 + a9 * b8 + a10 * b7 + a11 * b6; + s18 = a7 * b11 + a8 * b10 + a9 * b9 + a10 * b8 + a11 * b7; + s19 = a8 * b11 + a9 * b10 + a10 * b9 + a11 * b8; + s20 = a9 * b11 + a10 * b10 + a11 * b9; + s21 = a10 * b11 + a11 * b10; + s22 = a11 * b11; + s23 = 0; + + carry0 = (s0 + (int64_t) (1L << 20)) >> 21; + s1 += carry0; + s0 -= carry0 * ((uint64_t) 1L << 21); + carry2 = (s2 + (int64_t) (1L << 20)) >> 21; + s3 += carry2; + s2 -= carry2 * ((uint64_t) 1L << 21); + carry4 = (s4 + (int64_t) (1L << 20)) >> 21; + s5 += carry4; + s4 -= carry4 * ((uint64_t) 1L << 21); + carry6 = (s6 + (int64_t) (1L << 20)) >> 21; + s7 += carry6; + s6 -= carry6 * ((uint64_t) 1L << 21); + carry8 = (s8 + (int64_t) (1L << 20)) >> 21; + s9 += carry8; + s8 -= carry8 * ((uint64_t) 1L << 21); + carry10 = (s10 + (int64_t) (1L << 20)) >> 21; + s11 += carry10; + s10 -= carry10 * ((uint64_t) 1L << 21); + carry12 = (s12 + (int64_t) (1L << 20)) >> 21; + s13 += carry12; + s12 -= carry12 * ((uint64_t) 1L << 21); + carry14 = (s14 + (int64_t) (1L << 20)) >> 21; + s15 += carry14; + s14 -= carry14 * ((uint64_t) 1L << 21); + carry16 = (s16 + (int64_t) (1L << 20)) >> 21; + s17 += carry16; + s16 -= carry16 * ((uint64_t) 1L << 21); + carry18 = (s18 + (int64_t) (1L << 20)) >> 21; + s19 += carry18; + s18 -= carry18 * ((uint64_t) 1L << 21); + carry20 = (s20 + (int64_t) (1L << 20)) >> 21; + s21 += carry20; + s20 -= carry20 * ((uint64_t) 1L << 21); + carry22 = (s22 + (int64_t) (1L << 20)) >> 21; + s23 += carry22; + s22 -= carry22 * ((uint64_t) 1L << 21); + + carry1 = (s1 + (int64_t) (1L << 20)) >> 21; + s2 += carry1; + s1 -= carry1 * ((uint64_t) 1L << 21); + carry3 = (s3 + (int64_t) (1L << 20)) >> 21; + s4 += carry3; + s3 -= carry3 * ((uint64_t) 1L << 21); + carry5 = (s5 + (int64_t) (1L << 20)) >> 21; + s6 += carry5; + s5 -= carry5 * ((uint64_t) 1L << 21); + carry7 = (s7 + (int64_t) (1L << 20)) >> 21; + s8 += carry7; + s7 -= carry7 * ((uint64_t) 1L << 21); + carry9 = (s9 + (int64_t) (1L << 20)) >> 21; + s10 += carry9; + s9 -= carry9 * ((uint64_t) 1L << 21); + carry11 = (s11 + (int64_t) (1L << 20)) >> 21; + s12 += carry11; + s11 -= carry11 * ((uint64_t) 1L << 21); + carry13 = (s13 + (int64_t) (1L << 20)) >> 21; + s14 += carry13; + s13 -= carry13 * ((uint64_t) 1L << 21); + carry15 = (s15 + (int64_t) (1L << 20)) >> 21; + s16 += carry15; + s15 -= carry15 * ((uint64_t) 1L << 21); + carry17 = (s17 + (int64_t) (1L << 20)) >> 21; + s18 += carry17; + s17 -= carry17 * ((uint64_t) 1L << 21); + carry19 = (s19 + (int64_t) (1L << 20)) >> 21; + s20 += carry19; + s19 -= carry19 * ((uint64_t) 1L << 21); + carry21 = (s21 + (int64_t) (1L << 20)) >> 21; + s22 += carry21; + s21 -= carry21 * ((uint64_t) 1L << 21); + + s11 += s23 * 666643; + s12 += s23 * 470296; + s13 += s23 * 654183; + s14 -= s23 * 997805; + s15 += s23 * 136657; + s16 -= s23 * 683901; + + s10 += s22 * 666643; + s11 += s22 * 470296; + s12 += s22 * 654183; + s13 -= s22 * 997805; + s14 += s22 * 136657; + s15 -= s22 * 683901; + + s9 += s21 * 666643; + s10 += s21 * 470296; + s11 += s21 * 654183; + s12 -= s21 * 997805; + s13 += s21 * 136657; + s14 -= s21 * 683901; + + s8 += s20 * 666643; + s9 += s20 * 470296; + s10 += s20 * 654183; + s11 -= s20 * 997805; + s12 += s20 * 136657; + s13 -= s20 * 683901; + + s7 += s19 * 666643; + s8 += s19 * 470296; + s9 += s19 * 654183; + s10 -= s19 * 997805; + s11 += s19 * 136657; + s12 -= s19 * 683901; + + s6 += s18 * 666643; + s7 += s18 * 470296; + s8 += s18 * 654183; + s9 -= s18 * 997805; + s10 += s18 * 136657; + s11 -= s18 * 683901; + + carry6 = (s6 + (int64_t) (1L << 20)) >> 21; + s7 += carry6; + s6 -= carry6 * ((uint64_t) 1L << 21); + carry8 = (s8 + (int64_t) (1L << 20)) >> 21; + s9 += carry8; + s8 -= carry8 * ((uint64_t) 1L << 21); + carry10 = (s10 + (int64_t) (1L << 20)) >> 21; + s11 += carry10; + s10 -= carry10 * ((uint64_t) 1L << 21); + carry12 = (s12 + (int64_t) (1L << 20)) >> 21; + s13 += carry12; + s12 -= carry12 * ((uint64_t) 1L << 21); + carry14 = (s14 + (int64_t) (1L << 20)) >> 21; + s15 += carry14; + s14 -= carry14 * ((uint64_t) 1L << 21); + carry16 = (s16 + (int64_t) (1L << 20)) >> 21; + s17 += carry16; + s16 -= carry16 * ((uint64_t) 1L << 21); + + carry7 = (s7 + (int64_t) (1L << 20)) >> 21; + s8 += carry7; + s7 -= carry7 * ((uint64_t) 1L << 21); + carry9 = (s9 + (int64_t) (1L << 20)) >> 21; + s10 += carry9; + s9 -= carry9 * ((uint64_t) 1L << 21); + carry11 = (s11 + (int64_t) (1L << 20)) >> 21; + s12 += carry11; + s11 -= carry11 * ((uint64_t) 1L << 21); + carry13 = (s13 + (int64_t) (1L << 20)) >> 21; + s14 += carry13; + s13 -= carry13 * ((uint64_t) 1L << 21); + carry15 = (s15 + (int64_t) (1L << 20)) >> 21; + s16 += carry15; + s15 -= carry15 * ((uint64_t) 1L << 21); + + s5 += s17 * 666643; + s6 += s17 * 470296; + s7 += s17 * 654183; + s8 -= s17 * 997805; + s9 += s17 * 136657; + s10 -= s17 * 683901; + + s4 += s16 * 666643; + s5 += s16 * 470296; + s6 += s16 * 654183; + s7 -= s16 * 997805; + s8 += s16 * 136657; + s9 -= s16 * 683901; + + s3 += s15 * 666643; + s4 += s15 * 470296; + s5 += s15 * 654183; + s6 -= s15 * 997805; + s7 += s15 * 136657; + s8 -= s15 * 683901; + + s2 += s14 * 666643; + s3 += s14 * 470296; + s4 += s14 * 654183; + s5 -= s14 * 997805; + s6 += s14 * 136657; + s7 -= s14 * 683901; + + s1 += s13 * 666643; + s2 += s13 * 470296; + s3 += s13 * 654183; + s4 -= s13 * 997805; + s5 += s13 * 136657; + s6 -= s13 * 683901; + + s0 += s12 * 666643; + s1 += s12 * 470296; + s2 += s12 * 654183; + s3 -= s12 * 997805; + s4 += s12 * 136657; + s5 -= s12 * 683901; + s12 = 0; + + carry0 = (s0 + (int64_t) (1L << 20)) >> 21; + s1 += carry0; + s0 -= carry0 * ((uint64_t) 1L << 21); + carry2 = (s2 + (int64_t) (1L << 20)) >> 21; + s3 += carry2; + s2 -= carry2 * ((uint64_t) 1L << 21); + carry4 = (s4 + (int64_t) (1L << 20)) >> 21; + s5 += carry4; + s4 -= carry4 * ((uint64_t) 1L << 21); + carry6 = (s6 + (int64_t) (1L << 20)) >> 21; + s7 += carry6; + s6 -= carry6 * ((uint64_t) 1L << 21); + carry8 = (s8 + (int64_t) (1L << 20)) >> 21; + s9 += carry8; + s8 -= carry8 * ((uint64_t) 1L << 21); + carry10 = (s10 + (int64_t) (1L << 20)) >> 21; + s11 += carry10; + s10 -= carry10 * ((uint64_t) 1L << 21); + + carry1 = (s1 + (int64_t) (1L << 20)) >> 21; + s2 += carry1; + s1 -= carry1 * ((uint64_t) 1L << 21); + carry3 = (s3 + (int64_t) (1L << 20)) >> 21; + s4 += carry3; + s3 -= carry3 * ((uint64_t) 1L << 21); + carry5 = (s5 + (int64_t) (1L << 20)) >> 21; + s6 += carry5; + s5 -= carry5 * ((uint64_t) 1L << 21); + carry7 = (s7 + (int64_t) (1L << 20)) >> 21; + s8 += carry7; + s7 -= carry7 * ((uint64_t) 1L << 21); + carry9 = (s9 + (int64_t) (1L << 20)) >> 21; + s10 += carry9; + s9 -= carry9 * ((uint64_t) 1L << 21); + carry11 = (s11 + (int64_t) (1L << 20)) >> 21; + s12 += carry11; + s11 -= carry11 * ((uint64_t) 1L << 21); + + s0 += s12 * 666643; + s1 += s12 * 470296; + s2 += s12 * 654183; + s3 -= s12 * 997805; + s4 += s12 * 136657; + s5 -= s12 * 683901; + s12 = 0; + + carry0 = s0 >> 21; + s1 += carry0; + s0 -= carry0 * ((uint64_t) 1L << 21); + carry1 = s1 >> 21; + s2 += carry1; + s1 -= carry1 * ((uint64_t) 1L << 21); + carry2 = s2 >> 21; + s3 += carry2; + s2 -= carry2 * ((uint64_t) 1L << 21); + carry3 = s3 >> 21; + s4 += carry3; + s3 -= carry3 * ((uint64_t) 1L << 21); + carry4 = s4 >> 21; + s5 += carry4; + s4 -= carry4 * ((uint64_t) 1L << 21); + carry5 = s5 >> 21; + s6 += carry5; + s5 -= carry5 * ((uint64_t) 1L << 21); + carry6 = s6 >> 21; + s7 += carry6; + s6 -= carry6 * ((uint64_t) 1L << 21); + carry7 = s7 >> 21; + s8 += carry7; + s7 -= carry7 * ((uint64_t) 1L << 21); + carry8 = s8 >> 21; + s9 += carry8; + s8 -= carry8 * ((uint64_t) 1L << 21); + carry9 = s9 >> 21; + s10 += carry9; + s9 -= carry9 * ((uint64_t) 1L << 21); + carry10 = s10 >> 21; + s11 += carry10; + s10 -= carry10 * ((uint64_t) 1L << 21); + carry11 = s11 >> 21; + s12 += carry11; + s11 -= carry11 * ((uint64_t) 1L << 21); + + s0 += s12 * 666643; + s1 += s12 * 470296; + s2 += s12 * 654183; + s3 -= s12 * 997805; + s4 += s12 * 136657; + s5 -= s12 * 683901; + + carry0 = s0 >> 21; + s1 += carry0; + s0 -= carry0 * ((uint64_t) 1L << 21); + carry1 = s1 >> 21; + s2 += carry1; + s1 -= carry1 * ((uint64_t) 1L << 21); + carry2 = s2 >> 21; + s3 += carry2; + s2 -= carry2 * ((uint64_t) 1L << 21); + carry3 = s3 >> 21; + s4 += carry3; + s3 -= carry3 * ((uint64_t) 1L << 21); + carry4 = s4 >> 21; + s5 += carry4; + s4 -= carry4 * ((uint64_t) 1L << 21); + carry5 = s5 >> 21; + s6 += carry5; + s5 -= carry5 * ((uint64_t) 1L << 21); + carry6 = s6 >> 21; + s7 += carry6; + s6 -= carry6 * ((uint64_t) 1L << 21); + carry7 = s7 >> 21; + s8 += carry7; + s7 -= carry7 * ((uint64_t) 1L << 21); + carry8 = s8 >> 21; + s9 += carry8; + s8 -= carry8 * ((uint64_t) 1L << 21); + carry9 = s9 >> 21; + s10 += carry9; + s9 -= carry9 * ((uint64_t) 1L << 21); + carry10 = s10 >> 21; + s11 += carry10; + s10 -= carry10 * ((uint64_t) 1L << 21); + + s[0] = s0 >> 0; + s[1] = s0 >> 8; + s[2] = (s0 >> 16) | (s1 * ((uint64_t) 1 << 5)); + s[3] = s1 >> 3; + s[4] = s1 >> 11; + s[5] = (s1 >> 19) | (s2 * ((uint64_t) 1 << 2)); + s[6] = s2 >> 6; + s[7] = (s2 >> 14) | (s3 * ((uint64_t) 1 << 7)); + s[8] = s3 >> 1; + s[9] = s3 >> 9; + s[10] = (s3 >> 17) | (s4 * ((uint64_t) 1 << 4)); + s[11] = s4 >> 4; + s[12] = s4 >> 12; + s[13] = (s4 >> 20) | (s5 * ((uint64_t) 1 << 1)); + s[14] = s5 >> 7; + s[15] = (s5 >> 15) | (s6 * ((uint64_t) 1 << 6)); + s[16] = s6 >> 2; + s[17] = s6 >> 10; + s[18] = (s6 >> 18) | (s7 * ((uint64_t) 1 << 3)); + s[19] = s7 >> 5; + s[20] = s7 >> 13; + s[21] = s8 >> 0; + s[22] = s8 >> 8; + s[23] = (s8 >> 16) | (s9 * ((uint64_t) 1 << 5)); + s[24] = s9 >> 3; + s[25] = s9 >> 11; + s[26] = (s9 >> 19) | (s10 * ((uint64_t) 1 << 2)); + s[27] = s10 >> 6; + s[28] = (s10 >> 14) | (s11 * ((uint64_t) 1 << 7)); + s[29] = s11 >> 1; + s[30] = s11 >> 9; + s[31] = s11 >> 17; +} + +/* + Input: + a[0]+256*a[1]+...+256^31*a[31] = a + * + Output: + s[0]+256*s[1]+...+256^31*s[31] = a^2 mod l + where l = 2^252 + 27742317777372353535851937790883648493. + */ + +static inline void +sc25519_sq(unsigned char *s, const unsigned char *a) +{ + sc25519_mul(s, a, a); +} + +/* + Input: + s[0]+256*a[1]+...+256^31*a[31] = a + n + * + Output: + s[0]+256*s[1]+...+256^31*s[31] = x * s^(s^n) mod l + where l = 2^252 + 27742317777372353535851937790883648493. + Overwrites s in place. + */ + +static inline void +sc25519_sqmul(unsigned char s[32], const int n, const unsigned char a[32]) +{ + int i; + + for (i = 0; i < n; i++) { + sc25519_sq(s, s); + } + sc25519_mul(s, s, a); +} + +void +sc25519_invert(unsigned char recip[32], const unsigned char s[32]) +{ + unsigned char _10[32], _100[32], _1000[32], _10000[32], _100000[32], + _1000000[32], _10010011[32], _10010111[32], _100110[32], _1010[32], + _1010000[32], _1010011[32], _1011[32], _10110[32], _10111101[32], + _11[32], _1100011[32], _1100111[32], _11010011[32], _1101011[32], + _11100111[32], _11101011[32], _11110101[32]; + + sc25519_sq(_10, s); + sc25519_mul(_11, s, _10); + sc25519_mul(_100, s, _11); + sc25519_sq(_1000, _100); + sc25519_mul(_1010, _10, _1000); + sc25519_mul(_1011, s, _1010); + sc25519_sq(_10000, _1000); + sc25519_sq(_10110, _1011); + sc25519_mul(_100000, _1010, _10110); + sc25519_mul(_100110, _10000, _10110); + sc25519_sq(_1000000, _100000); + sc25519_mul(_1010000, _10000, _1000000); + sc25519_mul(_1010011, _11, _1010000); + sc25519_mul(_1100011, _10000, _1010011); + sc25519_mul(_1100111, _100, _1100011); + sc25519_mul(_1101011, _100, _1100111); + sc25519_mul(_10010011, _1000000, _1010011); + sc25519_mul(_10010111, _100, _10010011); + sc25519_mul(_10111101, _100110, _10010111); + sc25519_mul(_11010011, _10110, _10111101); + sc25519_mul(_11100111, _1010000, _10010111); + sc25519_mul(_11101011, _100, _11100111); + sc25519_mul(_11110101, _1010, _11101011); + + sc25519_mul(recip, _1011, _11110101); + sc25519_sqmul(recip, 126, _1010011); + sc25519_sqmul(recip, 9, _10); + sc25519_mul(recip, recip, _11110101); + sc25519_sqmul(recip, 7, _1100111); + sc25519_sqmul(recip, 9, _11110101); + sc25519_sqmul(recip, 11, _10111101); + sc25519_sqmul(recip, 8, _11100111); + sc25519_sqmul(recip, 9, _1101011); + sc25519_sqmul(recip, 6, _1011); + sc25519_sqmul(recip, 14, _10010011); + sc25519_sqmul(recip, 10, _1100011); + sc25519_sqmul(recip, 9, _10010111); + sc25519_sqmul(recip, 10, _11110101); + sc25519_sqmul(recip, 8, _11010011); + sc25519_sqmul(recip, 8, _11101011); +} + +/* + Input: + s[0]+256*s[1]+...+256^63*s[63] = s + * + Output: + s[0]+256*s[1]+...+256^31*s[31] = s mod l + where l = 2^252 + 27742317777372353535851937790883648493. + Overwrites s in place. + */ + +void +sc25519_reduce(unsigned char s[64]) +{ + int64_t s0 = 2097151 & load_3(s); + int64_t s1 = 2097151 & (load_4(s + 2) >> 5); + int64_t s2 = 2097151 & (load_3(s + 5) >> 2); + int64_t s3 = 2097151 & (load_4(s + 7) >> 7); + int64_t s4 = 2097151 & (load_4(s + 10) >> 4); + int64_t s5 = 2097151 & (load_3(s + 13) >> 1); + int64_t s6 = 2097151 & (load_4(s + 15) >> 6); + int64_t s7 = 2097151 & (load_3(s + 18) >> 3); + int64_t s8 = 2097151 & load_3(s + 21); + int64_t s9 = 2097151 & (load_4(s + 23) >> 5); + int64_t s10 = 2097151 & (load_3(s + 26) >> 2); + int64_t s11 = 2097151 & (load_4(s + 28) >> 7); + int64_t s12 = 2097151 & (load_4(s + 31) >> 4); + int64_t s13 = 2097151 & (load_3(s + 34) >> 1); + int64_t s14 = 2097151 & (load_4(s + 36) >> 6); + int64_t s15 = 2097151 & (load_3(s + 39) >> 3); + int64_t s16 = 2097151 & load_3(s + 42); + int64_t s17 = 2097151 & (load_4(s + 44) >> 5); + int64_t s18 = 2097151 & (load_3(s + 47) >> 2); + int64_t s19 = 2097151 & (load_4(s + 49) >> 7); + int64_t s20 = 2097151 & (load_4(s + 52) >> 4); + int64_t s21 = 2097151 & (load_3(s + 55) >> 1); + int64_t s22 = 2097151 & (load_4(s + 57) >> 6); + int64_t s23 = (load_4(s + 60) >> 3); + + int64_t carry0; + int64_t carry1; + int64_t carry2; + int64_t carry3; + int64_t carry4; + int64_t carry5; + int64_t carry6; + int64_t carry7; + int64_t carry8; + int64_t carry9; + int64_t carry10; + int64_t carry11; + int64_t carry12; + int64_t carry13; + int64_t carry14; + int64_t carry15; + int64_t carry16; + + s11 += s23 * 666643; + s12 += s23 * 470296; + s13 += s23 * 654183; + s14 -= s23 * 997805; + s15 += s23 * 136657; + s16 -= s23 * 683901; + + s10 += s22 * 666643; + s11 += s22 * 470296; + s12 += s22 * 654183; + s13 -= s22 * 997805; + s14 += s22 * 136657; + s15 -= s22 * 683901; + + s9 += s21 * 666643; + s10 += s21 * 470296; + s11 += s21 * 654183; + s12 -= s21 * 997805; + s13 += s21 * 136657; + s14 -= s21 * 683901; + + s8 += s20 * 666643; + s9 += s20 * 470296; + s10 += s20 * 654183; + s11 -= s20 * 997805; + s12 += s20 * 136657; + s13 -= s20 * 683901; + + s7 += s19 * 666643; + s8 += s19 * 470296; + s9 += s19 * 654183; + s10 -= s19 * 997805; + s11 += s19 * 136657; + s12 -= s19 * 683901; + + s6 += s18 * 666643; + s7 += s18 * 470296; + s8 += s18 * 654183; + s9 -= s18 * 997805; + s10 += s18 * 136657; + s11 -= s18 * 683901; + + carry6 = (s6 + (int64_t) (1L << 20)) >> 21; + s7 += carry6; + s6 -= carry6 * ((uint64_t) 1L << 21); + carry8 = (s8 + (int64_t) (1L << 20)) >> 21; + s9 += carry8; + s8 -= carry8 * ((uint64_t) 1L << 21); + carry10 = (s10 + (int64_t) (1L << 20)) >> 21; + s11 += carry10; + s10 -= carry10 * ((uint64_t) 1L << 21); + carry12 = (s12 + (int64_t) (1L << 20)) >> 21; + s13 += carry12; + s12 -= carry12 * ((uint64_t) 1L << 21); + carry14 = (s14 + (int64_t) (1L << 20)) >> 21; + s15 += carry14; + s14 -= carry14 * ((uint64_t) 1L << 21); + carry16 = (s16 + (int64_t) (1L << 20)) >> 21; + s17 += carry16; + s16 -= carry16 * ((uint64_t) 1L << 21); + + carry7 = (s7 + (int64_t) (1L << 20)) >> 21; + s8 += carry7; + s7 -= carry7 * ((uint64_t) 1L << 21); + carry9 = (s9 + (int64_t) (1L << 20)) >> 21; + s10 += carry9; + s9 -= carry9 * ((uint64_t) 1L << 21); + carry11 = (s11 + (int64_t) (1L << 20)) >> 21; + s12 += carry11; + s11 -= carry11 * ((uint64_t) 1L << 21); + carry13 = (s13 + (int64_t) (1L << 20)) >> 21; + s14 += carry13; + s13 -= carry13 * ((uint64_t) 1L << 21); + carry15 = (s15 + (int64_t) (1L << 20)) >> 21; + s16 += carry15; + s15 -= carry15 * ((uint64_t) 1L << 21); + + s5 += s17 * 666643; + s6 += s17 * 470296; + s7 += s17 * 654183; + s8 -= s17 * 997805; + s9 += s17 * 136657; + s10 -= s17 * 683901; + + s4 += s16 * 666643; + s5 += s16 * 470296; + s6 += s16 * 654183; + s7 -= s16 * 997805; + s8 += s16 * 136657; + s9 -= s16 * 683901; + + s3 += s15 * 666643; + s4 += s15 * 470296; + s5 += s15 * 654183; + s6 -= s15 * 997805; + s7 += s15 * 136657; + s8 -= s15 * 683901; + + s2 += s14 * 666643; + s3 += s14 * 470296; + s4 += s14 * 654183; + s5 -= s14 * 997805; + s6 += s14 * 136657; + s7 -= s14 * 683901; + + s1 += s13 * 666643; + s2 += s13 * 470296; + s3 += s13 * 654183; + s4 -= s13 * 997805; + s5 += s13 * 136657; + s6 -= s13 * 683901; + + s0 += s12 * 666643; + s1 += s12 * 470296; + s2 += s12 * 654183; + s3 -= s12 * 997805; + s4 += s12 * 136657; + s5 -= s12 * 683901; + s12 = 0; + + carry0 = (s0 + (int64_t) (1L << 20)) >> 21; + s1 += carry0; + s0 -= carry0 * ((uint64_t) 1L << 21); + carry2 = (s2 + (int64_t) (1L << 20)) >> 21; + s3 += carry2; + s2 -= carry2 * ((uint64_t) 1L << 21); + carry4 = (s4 + (int64_t) (1L << 20)) >> 21; + s5 += carry4; + s4 -= carry4 * ((uint64_t) 1L << 21); + carry6 = (s6 + (int64_t) (1L << 20)) >> 21; + s7 += carry6; + s6 -= carry6 * ((uint64_t) 1L << 21); + carry8 = (s8 + (int64_t) (1L << 20)) >> 21; + s9 += carry8; + s8 -= carry8 * ((uint64_t) 1L << 21); + carry10 = (s10 + (int64_t) (1L << 20)) >> 21; + s11 += carry10; + s10 -= carry10 * ((uint64_t) 1L << 21); + + carry1 = (s1 + (int64_t) (1L << 20)) >> 21; + s2 += carry1; + s1 -= carry1 * ((uint64_t) 1L << 21); + carry3 = (s3 + (int64_t) (1L << 20)) >> 21; + s4 += carry3; + s3 -= carry3 * ((uint64_t) 1L << 21); + carry5 = (s5 + (int64_t) (1L << 20)) >> 21; + s6 += carry5; + s5 -= carry5 * ((uint64_t) 1L << 21); + carry7 = (s7 + (int64_t) (1L << 20)) >> 21; + s8 += carry7; + s7 -= carry7 * ((uint64_t) 1L << 21); + carry9 = (s9 + (int64_t) (1L << 20)) >> 21; + s10 += carry9; + s9 -= carry9 * ((uint64_t) 1L << 21); + carry11 = (s11 + (int64_t) (1L << 20)) >> 21; + s12 += carry11; + s11 -= carry11 * ((uint64_t) 1L << 21); + + s0 += s12 * 666643; + s1 += s12 * 470296; + s2 += s12 * 654183; + s3 -= s12 * 997805; + s4 += s12 * 136657; + s5 -= s12 * 683901; + s12 = 0; + + carry0 = s0 >> 21; + s1 += carry0; + s0 -= carry0 * ((uint64_t) 1L << 21); + carry1 = s1 >> 21; + s2 += carry1; + s1 -= carry1 * ((uint64_t) 1L << 21); + carry2 = s2 >> 21; + s3 += carry2; + s2 -= carry2 * ((uint64_t) 1L << 21); + carry3 = s3 >> 21; + s4 += carry3; + s3 -= carry3 * ((uint64_t) 1L << 21); + carry4 = s4 >> 21; + s5 += carry4; + s4 -= carry4 * ((uint64_t) 1L << 21); + carry5 = s5 >> 21; + s6 += carry5; + s5 -= carry5 * ((uint64_t) 1L << 21); + carry6 = s6 >> 21; + s7 += carry6; + s6 -= carry6 * ((uint64_t) 1L << 21); + carry7 = s7 >> 21; + s8 += carry7; + s7 -= carry7 * ((uint64_t) 1L << 21); + carry8 = s8 >> 21; + s9 += carry8; + s8 -= carry8 * ((uint64_t) 1L << 21); + carry9 = s9 >> 21; + s10 += carry9; + s9 -= carry9 * ((uint64_t) 1L << 21); + carry10 = s10 >> 21; + s11 += carry10; + s10 -= carry10 * ((uint64_t) 1L << 21); + carry11 = s11 >> 21; + s12 += carry11; + s11 -= carry11 * ((uint64_t) 1L << 21); + + s0 += s12 * 666643; + s1 += s12 * 470296; + s2 += s12 * 654183; + s3 -= s12 * 997805; + s4 += s12 * 136657; + s5 -= s12 * 683901; + + carry0 = s0 >> 21; + s1 += carry0; + s0 -= carry0 * ((uint64_t) 1L << 21); + carry1 = s1 >> 21; + s2 += carry1; + s1 -= carry1 * ((uint64_t) 1L << 21); + carry2 = s2 >> 21; + s3 += carry2; + s2 -= carry2 * ((uint64_t) 1L << 21); + carry3 = s3 >> 21; + s4 += carry3; + s3 -= carry3 * ((uint64_t) 1L << 21); + carry4 = s4 >> 21; + s5 += carry4; + s4 -= carry4 * ((uint64_t) 1L << 21); + carry5 = s5 >> 21; + s6 += carry5; + s5 -= carry5 * ((uint64_t) 1L << 21); + carry6 = s6 >> 21; + s7 += carry6; + s6 -= carry6 * ((uint64_t) 1L << 21); + carry7 = s7 >> 21; + s8 += carry7; + s7 -= carry7 * ((uint64_t) 1L << 21); + carry8 = s8 >> 21; + s9 += carry8; + s8 -= carry8 * ((uint64_t) 1L << 21); + carry9 = s9 >> 21; + s10 += carry9; + s9 -= carry9 * ((uint64_t) 1L << 21); + carry10 = s10 >> 21; + s11 += carry10; + s10 -= carry10 * ((uint64_t) 1L << 21); + + s[0] = s0 >> 0; + s[1] = s0 >> 8; + s[2] = (s0 >> 16) | (s1 * ((uint64_t) 1 << 5)); + s[3] = s1 >> 3; + s[4] = s1 >> 11; + s[5] = (s1 >> 19) | (s2 * ((uint64_t) 1 << 2)); + s[6] = s2 >> 6; + s[7] = (s2 >> 14) | (s3 * ((uint64_t) 1 << 7)); + s[8] = s3 >> 1; + s[9] = s3 >> 9; + s[10] = (s3 >> 17) | (s4 * ((uint64_t) 1 << 4)); + s[11] = s4 >> 4; + s[12] = s4 >> 12; + s[13] = (s4 >> 20) | (s5 * ((uint64_t) 1 << 1)); + s[14] = s5 >> 7; + s[15] = (s5 >> 15) | (s6 * ((uint64_t) 1 << 6)); + s[16] = s6 >> 2; + s[17] = s6 >> 10; + s[18] = (s6 >> 18) | (s7 * ((uint64_t) 1 << 3)); + s[19] = s7 >> 5; + s[20] = s7 >> 13; + s[21] = s8 >> 0; + s[22] = s8 >> 8; + s[23] = (s8 >> 16) | (s9 * ((uint64_t) 1 << 5)); + s[24] = s9 >> 3; + s[25] = s9 >> 11; + s[26] = (s9 >> 19) | (s10 * ((uint64_t) 1 << 2)); + s[27] = s10 >> 6; + s[28] = (s10 >> 14) | (s11 * ((uint64_t) 1 << 7)); + s[29] = s11 >> 1; + s[30] = s11 >> 9; + s[31] = s11 >> 17; +} + +int +sc25519_is_canonical(const unsigned char s[32]) +{ + /* 2^252+27742317777372353535851937790883648493 */ + static const unsigned char L[32] = { + 0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, + 0xa2, 0xde, 0xf9, 0xde, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10 + }; + unsigned char c = 0; + unsigned char n = 1; + unsigned int i = 32; + + do { + i--; + c |= ((s[i] - L[i]) >> 8) & n; + n &= ((s[i] ^ L[i]) - 1) >> 8; + } while (i != 0); + + return (c != 0); +} + +/* multiply by the cofactor */ +static void +ge25519_clear_cofactor(ge25519_p3 *p3) +{ + ge25519_p1p1 p1; + ge25519_p2 p2; + + ge25519_p3_dbl(&p1, p3); + ge25519_p1p1_to_p2(&p2, &p1); + ge25519_p2_dbl(&p1, &p2); + ge25519_p1p1_to_p2(&p2, &p1); + ge25519_p2_dbl(&p1, &p2); + ge25519_p1p1_to_p3(p3, &p1); +} + +static void +ge25519_elligator2(unsigned char s[32], const fe25519 r, const unsigned char x_sign) +{ + fe25519 gx; + fe25519 negx; + fe25519 rr2; + fe25519 x, x2, x3; + ge25519_p3 p3; + unsigned int notsquare; + + fe25519_sq2(rr2, r); + rr2[0]++; + fe25519_invert(rr2, rr2); + fe25519_mul32(x, rr2, curve25519_A[0]); + fe25519_neg(x, x); + + fe25519_sq(x2, x); + fe25519_mul(x3, x, x2); + fe25519_add(gx, x3, x); + fe25519_mul32(x2, x2, curve25519_A[0]); + fe25519_add(gx, x2, gx); + + notsquare = fe25519_notsquare(gx); + fe25519_neg(negx, x); + fe25519_cmov(x, negx, notsquare); + fe25519_0(x2); + fe25519_cmov(x2, curve25519_A, notsquare); + fe25519_sub(x, x, x2); + + /* yed = (x-1)/(x+1) */ + { + fe25519 one; + fe25519 x_plus_one; + fe25519 x_plus_one_inv; + fe25519 x_minus_one; + fe25519 yed; + + fe25519_1(one); + fe25519_add(x_plus_one, x, one); + fe25519_sub(x_minus_one, x, one); + fe25519_invert(x_plus_one_inv, x_plus_one); + fe25519_mul(yed, x_minus_one, x_plus_one_inv); + fe25519_tobytes(s, yed); + } + + /* recover x */ + s[31] |= x_sign; + if (ge25519_frombytes(&p3, s) != 0) { + abort(); /* LCOV_EXCL_LINE */ + } + + ge25519_clear_cofactor(&p3); + ge25519_p3_tobytes(s, &p3); +} + +void +ge25519_from_uniform(unsigned char s[32], const unsigned char r[32]) +{ + fe25519 r_fe; + unsigned char x_sign; + + memcpy(s, r, 32); + x_sign = s[31] & 0x80; + s[31] &= 0x7f; + fe25519_frombytes(r_fe, s); + ge25519_elligator2(s, r_fe, x_sign); +} + +void +ge25519_from_hash(unsigned char s[32], const unsigned char h[64]) +{ + unsigned char fl[32]; + unsigned char gl[32]; + fe25519 fe_f; + fe25519 fe_g; + size_t i; + unsigned char x_sign; + + x_sign = h[0] & 0x80; + for (i = 0; i < 32; i++) { + fl[i] = h[63 - i]; + gl[i] = h[31 - i]; + } + fl[31] &= 0x7f; + gl[31] &= 0x7f; + fe25519_frombytes(fe_f, fl); + fe25519_frombytes(fe_g, gl); + fe_f[0] += (h[32] >> 7) * 19; + for (i = 0; i < sizeof (fe25519) / sizeof fe_f[0]; i++) { + fe_f[i] += 38 * fe_g[i]; + } + fe25519_reduce(fe_f, fe_f); + ge25519_elligator2(s, fe_f, x_sign); +} + +/* Ristretto group */ + +static int +ristretto255_sqrt_ratio_m1(fe25519 x, const fe25519 u, const fe25519 v) +{ + fe25519 v3; + fe25519 vxx; + fe25519 m_root_check, p_root_check, f_root_check; + fe25519 x_sqrtm1; + int has_m_root, has_p_root, has_f_root; + + fe25519_sq(v3, v); + fe25519_mul(v3, v3, v); /* v3 = v^3 */ + fe25519_sq(x, v3); + fe25519_mul(x, x, v); + fe25519_mul(x, x, u); /* x = uv^7 */ + + fe25519_pow22523(x, x); /* x = (uv^7)^((q-5)/8) */ + fe25519_mul(x, x, v3); + fe25519_mul(x, x, u); /* x = uv^3(uv^7)^((q-5)/8) */ + + fe25519_sq(vxx, x); + fe25519_mul(vxx, vxx, v); /* vx^2 */ + fe25519_sub(m_root_check, vxx, u); /* vx^2-u */ + fe25519_add(p_root_check, vxx, u); /* vx^2+u */ + fe25519_mul(f_root_check, u, sqrtm1); /* u*sqrt(-1) */ + fe25519_add(f_root_check, vxx, f_root_check); /* vx^2+u*sqrt(-1) */ + has_m_root = fe25519_iszero(m_root_check); + has_p_root = fe25519_iszero(p_root_check); + has_f_root = fe25519_iszero(f_root_check); + fe25519_mul(x_sqrtm1, x, sqrtm1); /* x*sqrt(-1) */ + + fe25519_cmov(x, x_sqrtm1, has_p_root | has_f_root); + fe25519_abs(x, x); + + return has_m_root | has_p_root; +} + +static int +ristretto255_is_canonical(const unsigned char *s) +{ + unsigned char c; + unsigned char d; + unsigned char e; + unsigned int i; + + c = (s[31] & 0x7f) ^ 0x7f; + for (i = 30; i > 0; i--) { + c |= s[i] ^ 0xff; + } + c = (((unsigned int) c) - 1U) >> 8; + d = (0xed - 1U - (unsigned int) s[0]) >> 8; + e = s[31] >> 7; + + return 1 - (((c & d) | e | s[0]) & 1); +} + +int +ristretto255_frombytes(ge25519_p3 *h, const unsigned char *s) +{ + fe25519 inv_sqrt; + fe25519 one; + fe25519 s_; + fe25519 ss; + fe25519 u1, u2; + fe25519 u1u1, u2u2; + fe25519 v; + fe25519 v_u2u2; + int was_square; + + if (ristretto255_is_canonical(s) == 0) { + return -1; + } + fe25519_frombytes(s_, s); + fe25519_sq(ss, s_); /* ss = s^2 */ + + fe25519_1(u1); + fe25519_sub(u1, u1, ss); /* u1 = 1-ss */ + fe25519_sq(u1u1, u1); /* u1u1 = u1^2 */ + + fe25519_1(u2); + fe25519_add(u2, u2, ss); /* u2 = 1+ss */ + fe25519_sq(u2u2, u2); /* u2u2 = u2^2 */ + + fe25519_mul(v, d, u1u1); /* v = d*u1^2 */ + fe25519_neg(v, v); /* v = -d*u1^2 */ + fe25519_sub(v, v, u2u2); /* v = -(d*u1^2)-u2^2 */ + + fe25519_mul(v_u2u2, v, u2u2); /* v_u2u2 = v*u2^2 */ + + fe25519_1(one); + was_square = ristretto255_sqrt_ratio_m1(inv_sqrt, one, v_u2u2); + fe25519_mul(h->X, inv_sqrt, u2); + fe25519_mul(h->Y, inv_sqrt, h->X); + fe25519_mul(h->Y, h->Y, v); + + fe25519_mul(h->X, h->X, s_); + fe25519_add(h->X, h->X, h->X); + fe25519_abs(h->X, h->X); + fe25519_mul(h->Y, u1, h->Y); + fe25519_1(h->Z); + fe25519_mul(h->T, h->X, h->Y); + + return - ((1 - was_square) | + fe25519_isnegative(h->T) | fe25519_iszero(h->Y)); +} + +void +ristretto255_p3_tobytes(unsigned char *s, const ge25519_p3 *h) +{ + fe25519 den1, den2; + fe25519 den_inv; + fe25519 eden; + fe25519 inv_sqrt; + fe25519 ix, iy; + fe25519 one; + fe25519 s_; + fe25519 t_z_inv; + fe25519 u1, u2; + fe25519 u1_u2u2; + fe25519 x_, y_; + fe25519 x_z_inv; + fe25519 z_inv; + fe25519 zmy; + int rotate; + + fe25519_add(u1, h->Z, h->Y); /* u1 = Z+Y */ + fe25519_sub(zmy, h->Z, h->Y); /* zmy = Z-Y */ + fe25519_mul(u1, u1, zmy); /* u1 = (Z+Y)*(Z-Y) */ + fe25519_mul(u2, h->X, h->Y); /* u2 = X*Y */ + + fe25519_sq(u1_u2u2, u2); /* u1_u2u2 = u2^2 */ + fe25519_mul(u1_u2u2, u1, u1_u2u2); /* u1_u2u2 = u1*u2^2 */ + + fe25519_1(one); + (void) ristretto255_sqrt_ratio_m1(inv_sqrt, one, u1_u2u2); + fe25519_mul(den1, inv_sqrt, u1); /* den1 = inv_sqrt*u1 */ + fe25519_mul(den2, inv_sqrt, u2); /* den2 = inv_sqrt*u2 */ + fe25519_mul(z_inv, den1, den2); /* z_inv = den1*den2 */ + fe25519_mul(z_inv, z_inv, h->T); /* z_inv = den1*den2*T */ + + fe25519_mul(ix, h->X, sqrtm1); /* ix = X*sqrt(-1) */ + fe25519_mul(iy, h->Y, sqrtm1); /* iy = Y*sqrt(-1) */ + fe25519_mul(eden, den1, invsqrtamd); /* eden = den1/sqrt(a-d) */ + + fe25519_mul(t_z_inv, h->T, z_inv); /* t_z_inv = T*z_inv */ + rotate = fe25519_isnegative(t_z_inv); + + fe25519_copy(x_, h->X); + fe25519_copy(y_, h->Y); + fe25519_copy(den_inv, den2); + + fe25519_cmov(x_, iy, rotate); + fe25519_cmov(y_, ix, rotate); + fe25519_cmov(den_inv, eden, rotate); + + fe25519_mul(x_z_inv, x_, z_inv); + fe25519_cneg(y_, y_, fe25519_isnegative(x_z_inv)); + + fe25519_sub(s_, h->Z, y_); + fe25519_mul(s_, den_inv, s_); + fe25519_abs(s_, s_); + fe25519_tobytes(s, s_); +} + +static void +ristretto255_elligator(ge25519_p3 *p, const fe25519 t) +{ + fe25519 c; + fe25519 n; + fe25519 one; + fe25519 r; + fe25519 rpd; + fe25519 s, s_prime; + fe25519 ss; + fe25519 u, v; + fe25519 w0, w1, w2, w3; + int wasnt_square; + + fe25519_1(one); + fe25519_sq(r, t); /* r = t^2 */ + fe25519_mul(r, sqrtm1, r); /* r = sqrt(-1)*t^2 */ + fe25519_add(u, r, one); /* u = r+1 */ + fe25519_mul(u, u, onemsqd); /* u = (r+1)*(1-d^2) */ + fe25519_1(c); + fe25519_neg(c, c); /* c = -1 */ + fe25519_add(rpd, r, d); /* rpd = r+d */ + fe25519_mul(v, r, d); /* v = r*d */ + fe25519_sub(v, c, v); /* v = c-r*d */ + fe25519_mul(v, v, rpd); /* v = (c-r*d)*(r+d) */ + + wasnt_square = 1 - ristretto255_sqrt_ratio_m1(s, u, v); + fe25519_mul(s_prime, s, t); + fe25519_abs(s_prime, s_prime); + fe25519_neg(s_prime, s_prime); /* s_prime = -|s*t| */ + fe25519_cmov(s, s_prime, wasnt_square); + fe25519_cmov(c, r, wasnt_square); + + fe25519_sub(n, r, one); /* n = r-1 */ + fe25519_mul(n, n, c); /* n = c*(r-1) */ + fe25519_mul(n, n, sqdmone); /* n = c*(r-1)*(d-1)^2 */ + fe25519_sub(n, n, v); /* n = c*(r-1)*(d-1)^2-v */ + + fe25519_add(w0, s, s); /* w0 = 2s */ + fe25519_mul(w0, w0, v); /* w0 = 2s*v */ + fe25519_mul(w1, n, sqrtadm1); /* w1 = n*sqrt(ad-1) */ + fe25519_sq(ss, s); /* ss = s^2 */ + fe25519_sub(w2, one, ss); /* w2 = 1-s^2 */ + fe25519_add(w3, one, ss); /* w3 = 1+s^2 */ + + fe25519_mul(p->X, w0, w3); + fe25519_mul(p->Y, w2, w1); + fe25519_mul(p->Z, w1, w3); + fe25519_mul(p->T, w0, w2); +} + +void +ristretto255_from_hash(unsigned char s[32], const unsigned char h[64]) +{ + fe25519 r0, r1; + ge25519_cached p1_cached; + ge25519_p1p1 p_p1p1; + ge25519_p3 p0, p1; + ge25519_p3 p; + + fe25519_frombytes(r0, h); + fe25519_frombytes(r1, h + 32); + ristretto255_elligator(&p0, r0); + ristretto255_elligator(&p1, r1); + ge25519_p3_to_cached(&p1_cached, &p1); + ge25519_add(&p_p1p1, &p0, &p1_cached); + ge25519_p1p1_to_p3(&p, &p_p1p1); + ristretto255_p3_tobytes(s, &p); +} diff --git a/packages/runtime/vendor/libsodium/ed25519_ref10.h b/packages/runtime/vendor/libsodium/ed25519_ref10.h new file mode 100644 index 000000000..3f4c45caf --- /dev/null +++ b/packages/runtime/vendor/libsodium/ed25519_ref10.h @@ -0,0 +1,142 @@ +#ifndef ed25519_ref10_H +#define ed25519_ref10_H + +#include +#include + +/* + fe means field element. + Here the field is \Z/(2^255-19). + */ + +#ifdef HAVE_TI_MODE +typedef uint64_t fe25519[5]; +#else +typedef int32_t fe25519[10]; +#endif + +void fe25519_invert(fe25519 out, const fe25519 z); +void fe25519_frombytes(fe25519 h, const unsigned char *s); +void fe25519_tobytes(unsigned char *s, const fe25519 h); + +#ifdef HAVE_TI_MODE +# include "ed25519_ref10_fe_51.h" +#else +# include "ed25519_ref10_fe_25_5.h" +#endif + + +/* + ge means group element. + + Here the group is the set of pairs (x,y) of field elements + satisfying -x^2 + y^2 = 1 + d x^2y^2 + where d = -121665/121666. + + Representations: + ge25519_p2 (projective): (X:Y:Z) satisfying x=X/Z, y=Y/Z + ge25519_p3 (extended): (X:Y:Z:T) satisfying x=X/Z, y=Y/Z, XY=ZT + ge25519_p1p1 (completed): ((X:Z),(Y:T)) satisfying x=X/Z, y=Y/T + ge25519_precomp (Duif): (y+x,y-x,2dxy) + */ + +typedef struct { + fe25519 X; + fe25519 Y; + fe25519 Z; +} ge25519_p2; + +typedef struct { + fe25519 X; + fe25519 Y; + fe25519 Z; + fe25519 T; +} ge25519_p3; + +typedef struct { + fe25519 X; + fe25519 Y; + fe25519 Z; + fe25519 T; +} ge25519_p1p1; + +typedef struct { + fe25519 yplusx; + fe25519 yminusx; + fe25519 xy2d; +} ge25519_precomp; + +typedef struct { + fe25519 YplusX; + fe25519 YminusX; + fe25519 Z; + fe25519 T2d; +} ge25519_cached; + +void ge25519_tobytes(unsigned char *s, const ge25519_p2 *h); + +void ge25519_p3_tobytes(unsigned char *s, const ge25519_p3 *h); + +int ge25519_frombytes(ge25519_p3 *h, const unsigned char *s); + +int ge25519_frombytes_negate_vartime(ge25519_p3 *h, const unsigned char *s); + +void ge25519_p3_to_cached(ge25519_cached *r, const ge25519_p3 *p); + +void ge25519_p1p1_to_p2(ge25519_p2 *r, const ge25519_p1p1 *p); + +void ge25519_p1p1_to_p3(ge25519_p3 *r, const ge25519_p1p1 *p); + +void ge25519_add(ge25519_p1p1 *r, const ge25519_p3 *p, const ge25519_cached *q); + +void ge25519_sub(ge25519_p1p1 *r, const ge25519_p3 *p, const ge25519_cached *q); + +void ge25519_scalarmult_base(ge25519_p3 *h, const unsigned char *a); + +void ge25519_double_scalarmult_vartime(ge25519_p2 *r, const unsigned char *a, + const ge25519_p3 *A, + const unsigned char *b); + +void ge25519_scalarmult(ge25519_p3 *h, const unsigned char *a, + const ge25519_p3 *p); + +int ge25519_is_canonical(const unsigned char *s); + +int ge25519_is_on_curve(const ge25519_p3 *p); + +int ge25519_is_on_main_subgroup(const ge25519_p3 *p); + +int ge25519_has_small_order(const unsigned char s[32]); + +void ge25519_from_uniform(unsigned char s[32], const unsigned char r[32]); + +void ge25519_from_hash(unsigned char s[32], const unsigned char h[64]); + +/* + Ristretto group + */ + +int ristretto255_frombytes(ge25519_p3 *h, const unsigned char *s); + +void ristretto255_p3_tobytes(unsigned char *s, const ge25519_p3 *h); + +void ristretto255_from_hash(unsigned char s[32], const unsigned char h[64]); + +/* + The set of scalars is \Z/l + where l = 2^252 + 27742317777372353535851937790883648493. + */ + +void sc25519_invert(unsigned char recip[32], const unsigned char s[32]); + +void sc25519_reduce(unsigned char s[64]); + +void sc25519_mul(unsigned char s[32], const unsigned char a[32], + const unsigned char b[32]); + +void sc25519_muladd(unsigned char s[32], const unsigned char a[32], + const unsigned char b[32], const unsigned char c[32]); + +int sc25519_is_canonical(const unsigned char s[32]); + +#endif diff --git a/packages/runtime/vendor/libsodium/ed25519_ref10_fe_25_5.h b/packages/runtime/vendor/libsodium/ed25519_ref10_fe_25_5.h new file mode 100644 index 000000000..a0816b219 --- /dev/null +++ b/packages/runtime/vendor/libsodium/ed25519_ref10_fe_25_5.h @@ -0,0 +1,1030 @@ +#include + +#include "common.h" +#include "utils.h" + +/* + h = 0 + */ + +static inline void +fe25519_0(fe25519 h) +{ + memset(&h[0], 0, 10 * sizeof h[0]); +} + +/* + h = 1 + */ + +static inline void +fe25519_1(fe25519 h) +{ + h[0] = 1; + h[1] = 0; + memset(&h[2], 0, 8 * sizeof h[0]); +} + +/* + h = f + g + Can overlap h with f or g. + * + Preconditions: + |f| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc. + |g| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc. + * + Postconditions: + |h| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc. + */ + +static inline void +fe25519_add(fe25519 h, const fe25519 f, const fe25519 g) +{ + int32_t h0 = f[0] + g[0]; + int32_t h1 = f[1] + g[1]; + int32_t h2 = f[2] + g[2]; + int32_t h3 = f[3] + g[3]; + int32_t h4 = f[4] + g[4]; + int32_t h5 = f[5] + g[5]; + int32_t h6 = f[6] + g[6]; + int32_t h7 = f[7] + g[7]; + int32_t h8 = f[8] + g[8]; + int32_t h9 = f[9] + g[9]; + + h[0] = h0; + h[1] = h1; + h[2] = h2; + h[3] = h3; + h[4] = h4; + h[5] = h5; + h[6] = h6; + h[7] = h7; + h[8] = h8; + h[9] = h9; +} + +/* + h = f - g + Can overlap h with f or g. + * + Preconditions: + |f| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc. + |g| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc. + * + Postconditions: + |h| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc. + */ + +static void +fe25519_sub(fe25519 h, const fe25519 f, const fe25519 g) +{ + int32_t h0 = f[0] - g[0]; + int32_t h1 = f[1] - g[1]; + int32_t h2 = f[2] - g[2]; + int32_t h3 = f[3] - g[3]; + int32_t h4 = f[4] - g[4]; + int32_t h5 = f[5] - g[5]; + int32_t h6 = f[6] - g[6]; + int32_t h7 = f[7] - g[7]; + int32_t h8 = f[8] - g[8]; + int32_t h9 = f[9] - g[9]; + + h[0] = h0; + h[1] = h1; + h[2] = h2; + h[3] = h3; + h[4] = h4; + h[5] = h5; + h[6] = h6; + h[7] = h7; + h[8] = h8; + h[9] = h9; +} + +/* + h = -f + * + Preconditions: + |f| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc. + * + Postconditions: + |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc. + */ + +static inline void +fe25519_neg(fe25519 h, const fe25519 f) +{ + int32_t h0 = -f[0]; + int32_t h1 = -f[1]; + int32_t h2 = -f[2]; + int32_t h3 = -f[3]; + int32_t h4 = -f[4]; + int32_t h5 = -f[5]; + int32_t h6 = -f[6]; + int32_t h7 = -f[7]; + int32_t h8 = -f[8]; + int32_t h9 = -f[9]; + + h[0] = h0; + h[1] = h1; + h[2] = h2; + h[3] = h3; + h[4] = h4; + h[5] = h5; + h[6] = h6; + h[7] = h7; + h[8] = h8; + h[9] = h9; +} + +/* + Replace (f,g) with (g,g) if b == 1; + replace (f,g) with (f,g) if b == 0. + * + Preconditions: b in {0,1}. + */ + +static void +fe25519_cmov(fe25519 f, const fe25519 g, unsigned int b) +{ + const uint32_t mask = (uint32_t) (-(int32_t) b); + + int32_t f0 = f[0]; + int32_t f1 = f[1]; + int32_t f2 = f[2]; + int32_t f3 = f[3]; + int32_t f4 = f[4]; + int32_t f5 = f[5]; + int32_t f6 = f[6]; + int32_t f7 = f[7]; + int32_t f8 = f[8]; + int32_t f9 = f[9]; + + int32_t x0 = f0 ^ g[0]; + int32_t x1 = f1 ^ g[1]; + int32_t x2 = f2 ^ g[2]; + int32_t x3 = f3 ^ g[3]; + int32_t x4 = f4 ^ g[4]; + int32_t x5 = f5 ^ g[5]; + int32_t x6 = f6 ^ g[6]; + int32_t x7 = f7 ^ g[7]; + int32_t x8 = f8 ^ g[8]; + int32_t x9 = f9 ^ g[9]; + + x0 &= mask; + x1 &= mask; + x2 &= mask; + x3 &= mask; + x4 &= mask; + x5 &= mask; + x6 &= mask; + x7 &= mask; + x8 &= mask; + x9 &= mask; + + f[0] = f0 ^ x0; + f[1] = f1 ^ x1; + f[2] = f2 ^ x2; + f[3] = f3 ^ x3; + f[4] = f4 ^ x4; + f[5] = f5 ^ x5; + f[6] = f6 ^ x6; + f[7] = f7 ^ x7; + f[8] = f8 ^ x8; + f[9] = f9 ^ x9; +} + +static void +fe25519_cswap(fe25519 f, fe25519 g, unsigned int b) +{ + const uint32_t mask = (uint32_t) (-(int64_t) b); + + int32_t f0 = f[0]; + int32_t f1 = f[1]; + int32_t f2 = f[2]; + int32_t f3 = f[3]; + int32_t f4 = f[4]; + int32_t f5 = f[5]; + int32_t f6 = f[6]; + int32_t f7 = f[7]; + int32_t f8 = f[8]; + int32_t f9 = f[9]; + + int32_t g0 = g[0]; + int32_t g1 = g[1]; + int32_t g2 = g[2]; + int32_t g3 = g[3]; + int32_t g4 = g[4]; + int32_t g5 = g[5]; + int32_t g6 = g[6]; + int32_t g7 = g[7]; + int32_t g8 = g[8]; + int32_t g9 = g[9]; + + int32_t x0 = f0 ^ g0; + int32_t x1 = f1 ^ g1; + int32_t x2 = f2 ^ g2; + int32_t x3 = f3 ^ g3; + int32_t x4 = f4 ^ g4; + int32_t x5 = f5 ^ g5; + int32_t x6 = f6 ^ g6; + int32_t x7 = f7 ^ g7; + int32_t x8 = f8 ^ g8; + int32_t x9 = f9 ^ g9; + + x0 &= mask; + x1 &= mask; + x2 &= mask; + x3 &= mask; + x4 &= mask; + x5 &= mask; + x6 &= mask; + x7 &= mask; + x8 &= mask; + x9 &= mask; + + f[0] = f0 ^ x0; + f[1] = f1 ^ x1; + f[2] = f2 ^ x2; + f[3] = f3 ^ x3; + f[4] = f4 ^ x4; + f[5] = f5 ^ x5; + f[6] = f6 ^ x6; + f[7] = f7 ^ x7; + f[8] = f8 ^ x8; + f[9] = f9 ^ x9; + + g[0] = g0 ^ x0; + g[1] = g1 ^ x1; + g[2] = g2 ^ x2; + g[3] = g3 ^ x3; + g[4] = g4 ^ x4; + g[5] = g5 ^ x5; + g[6] = g6 ^ x6; + g[7] = g7 ^ x7; + g[8] = g8 ^ x8; + g[9] = g9 ^ x9; +} + +/* + h = f + */ + +static inline void +fe25519_copy(fe25519 h, const fe25519 f) +{ + memcpy(h, f, 10 * sizeof h[0]); +} + +/* + return 1 if f is in {1,3,5,...,q-2} + return 0 if f is in {0,2,4,...,q-1} + + Preconditions: + |f| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc. + */ + +static inline int +fe25519_isnegative(const fe25519 f) +{ + unsigned char s[32]; + + fe25519_tobytes(s, f); + + return s[0] & 1; +} + +/* + return 1 if f == 0 + return 0 if f != 0 + + Preconditions: + |f| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc. + */ + +static inline int +fe25519_iszero(const fe25519 f) +{ + unsigned char s[32]; + + fe25519_tobytes(s, f); + + return sodium_is_zero(s, 32); +} + +/* + h = f * g + Can overlap h with f or g. + * + Preconditions: + |f| bounded by 1.65*2^26,1.65*2^25,1.65*2^26,1.65*2^25,etc. + |g| bounded by 1.65*2^26,1.65*2^25,1.65*2^26,1.65*2^25,etc. + * + Postconditions: + |h| bounded by 1.01*2^25,1.01*2^24,1.01*2^25,1.01*2^24,etc. + */ + +/* + Notes on implementation strategy: + * + Using schoolbook multiplication. + Karatsuba would save a little in some cost models. + * + Most multiplications by 2 and 19 are 32-bit precomputations; + cheaper than 64-bit postcomputations. + * + There is one remaining multiplication by 19 in the carry chain; + one *19 precomputation can be merged into this, + but the resulting data flow is considerably less clean. + * + There are 12 carries below. + 10 of them are 2-way parallelizable and vectorizable. + Can get away with 11 carries, but then data flow is much deeper. + * + With tighter constraints on inputs can squeeze carries into int32. + */ + +static void +fe25519_mul(fe25519 h, const fe25519 f, const fe25519 g) +{ + int32_t f0 = f[0]; + int32_t f1 = f[1]; + int32_t f2 = f[2]; + int32_t f3 = f[3]; + int32_t f4 = f[4]; + int32_t f5 = f[5]; + int32_t f6 = f[6]; + int32_t f7 = f[7]; + int32_t f8 = f[8]; + int32_t f9 = f[9]; + + int32_t g0 = g[0]; + int32_t g1 = g[1]; + int32_t g2 = g[2]; + int32_t g3 = g[3]; + int32_t g4 = g[4]; + int32_t g5 = g[5]; + int32_t g6 = g[6]; + int32_t g7 = g[7]; + int32_t g8 = g[8]; + int32_t g9 = g[9]; + + int32_t g1_19 = 19 * g1; /* 1.959375*2^29 */ + int32_t g2_19 = 19 * g2; /* 1.959375*2^30; still ok */ + int32_t g3_19 = 19 * g3; + int32_t g4_19 = 19 * g4; + int32_t g5_19 = 19 * g5; + int32_t g6_19 = 19 * g6; + int32_t g7_19 = 19 * g7; + int32_t g8_19 = 19 * g8; + int32_t g9_19 = 19 * g9; + int32_t f1_2 = 2 * f1; + int32_t f3_2 = 2 * f3; + int32_t f5_2 = 2 * f5; + int32_t f7_2 = 2 * f7; + int32_t f9_2 = 2 * f9; + + int64_t f0g0 = f0 * (int64_t) g0; + int64_t f0g1 = f0 * (int64_t) g1; + int64_t f0g2 = f0 * (int64_t) g2; + int64_t f0g3 = f0 * (int64_t) g3; + int64_t f0g4 = f0 * (int64_t) g4; + int64_t f0g5 = f0 * (int64_t) g5; + int64_t f0g6 = f0 * (int64_t) g6; + int64_t f0g7 = f0 * (int64_t) g7; + int64_t f0g8 = f0 * (int64_t) g8; + int64_t f0g9 = f0 * (int64_t) g9; + int64_t f1g0 = f1 * (int64_t) g0; + int64_t f1g1_2 = f1_2 * (int64_t) g1; + int64_t f1g2 = f1 * (int64_t) g2; + int64_t f1g3_2 = f1_2 * (int64_t) g3; + int64_t f1g4 = f1 * (int64_t) g4; + int64_t f1g5_2 = f1_2 * (int64_t) g5; + int64_t f1g6 = f1 * (int64_t) g6; + int64_t f1g7_2 = f1_2 * (int64_t) g7; + int64_t f1g8 = f1 * (int64_t) g8; + int64_t f1g9_38 = f1_2 * (int64_t) g9_19; + int64_t f2g0 = f2 * (int64_t) g0; + int64_t f2g1 = f2 * (int64_t) g1; + int64_t f2g2 = f2 * (int64_t) g2; + int64_t f2g3 = f2 * (int64_t) g3; + int64_t f2g4 = f2 * (int64_t) g4; + int64_t f2g5 = f2 * (int64_t) g5; + int64_t f2g6 = f2 * (int64_t) g6; + int64_t f2g7 = f2 * (int64_t) g7; + int64_t f2g8_19 = f2 * (int64_t) g8_19; + int64_t f2g9_19 = f2 * (int64_t) g9_19; + int64_t f3g0 = f3 * (int64_t) g0; + int64_t f3g1_2 = f3_2 * (int64_t) g1; + int64_t f3g2 = f3 * (int64_t) g2; + int64_t f3g3_2 = f3_2 * (int64_t) g3; + int64_t f3g4 = f3 * (int64_t) g4; + int64_t f3g5_2 = f3_2 * (int64_t) g5; + int64_t f3g6 = f3 * (int64_t) g6; + int64_t f3g7_38 = f3_2 * (int64_t) g7_19; + int64_t f3g8_19 = f3 * (int64_t) g8_19; + int64_t f3g9_38 = f3_2 * (int64_t) g9_19; + int64_t f4g0 = f4 * (int64_t) g0; + int64_t f4g1 = f4 * (int64_t) g1; + int64_t f4g2 = f4 * (int64_t) g2; + int64_t f4g3 = f4 * (int64_t) g3; + int64_t f4g4 = f4 * (int64_t) g4; + int64_t f4g5 = f4 * (int64_t) g5; + int64_t f4g6_19 = f4 * (int64_t) g6_19; + int64_t f4g7_19 = f4 * (int64_t) g7_19; + int64_t f4g8_19 = f4 * (int64_t) g8_19; + int64_t f4g9_19 = f4 * (int64_t) g9_19; + int64_t f5g0 = f5 * (int64_t) g0; + int64_t f5g1_2 = f5_2 * (int64_t) g1; + int64_t f5g2 = f5 * (int64_t) g2; + int64_t f5g3_2 = f5_2 * (int64_t) g3; + int64_t f5g4 = f5 * (int64_t) g4; + int64_t f5g5_38 = f5_2 * (int64_t) g5_19; + int64_t f5g6_19 = f5 * (int64_t) g6_19; + int64_t f5g7_38 = f5_2 * (int64_t) g7_19; + int64_t f5g8_19 = f5 * (int64_t) g8_19; + int64_t f5g9_38 = f5_2 * (int64_t) g9_19; + int64_t f6g0 = f6 * (int64_t) g0; + int64_t f6g1 = f6 * (int64_t) g1; + int64_t f6g2 = f6 * (int64_t) g2; + int64_t f6g3 = f6 * (int64_t) g3; + int64_t f6g4_19 = f6 * (int64_t) g4_19; + int64_t f6g5_19 = f6 * (int64_t) g5_19; + int64_t f6g6_19 = f6 * (int64_t) g6_19; + int64_t f6g7_19 = f6 * (int64_t) g7_19; + int64_t f6g8_19 = f6 * (int64_t) g8_19; + int64_t f6g9_19 = f6 * (int64_t) g9_19; + int64_t f7g0 = f7 * (int64_t) g0; + int64_t f7g1_2 = f7_2 * (int64_t) g1; + int64_t f7g2 = f7 * (int64_t) g2; + int64_t f7g3_38 = f7_2 * (int64_t) g3_19; + int64_t f7g4_19 = f7 * (int64_t) g4_19; + int64_t f7g5_38 = f7_2 * (int64_t) g5_19; + int64_t f7g6_19 = f7 * (int64_t) g6_19; + int64_t f7g7_38 = f7_2 * (int64_t) g7_19; + int64_t f7g8_19 = f7 * (int64_t) g8_19; + int64_t f7g9_38 = f7_2 * (int64_t) g9_19; + int64_t f8g0 = f8 * (int64_t) g0; + int64_t f8g1 = f8 * (int64_t) g1; + int64_t f8g2_19 = f8 * (int64_t) g2_19; + int64_t f8g3_19 = f8 * (int64_t) g3_19; + int64_t f8g4_19 = f8 * (int64_t) g4_19; + int64_t f8g5_19 = f8 * (int64_t) g5_19; + int64_t f8g6_19 = f8 * (int64_t) g6_19; + int64_t f8g7_19 = f8 * (int64_t) g7_19; + int64_t f8g8_19 = f8 * (int64_t) g8_19; + int64_t f8g9_19 = f8 * (int64_t) g9_19; + int64_t f9g0 = f9 * (int64_t) g0; + int64_t f9g1_38 = f9_2 * (int64_t) g1_19; + int64_t f9g2_19 = f9 * (int64_t) g2_19; + int64_t f9g3_38 = f9_2 * (int64_t) g3_19; + int64_t f9g4_19 = f9 * (int64_t) g4_19; + int64_t f9g5_38 = f9_2 * (int64_t) g5_19; + int64_t f9g6_19 = f9 * (int64_t) g6_19; + int64_t f9g7_38 = f9_2 * (int64_t) g7_19; + int64_t f9g8_19 = f9 * (int64_t) g8_19; + int64_t f9g9_38 = f9_2 * (int64_t) g9_19; + + int64_t h0 = f0g0 + f1g9_38 + f2g8_19 + f3g7_38 + f4g6_19 + f5g5_38 + + f6g4_19 + f7g3_38 + f8g2_19 + f9g1_38; + int64_t h1 = f0g1 + f1g0 + f2g9_19 + f3g8_19 + f4g7_19 + f5g6_19 + f6g5_19 + + f7g4_19 + f8g3_19 + f9g2_19; + int64_t h2 = f0g2 + f1g1_2 + f2g0 + f3g9_38 + f4g8_19 + f5g7_38 + f6g6_19 + + f7g5_38 + f8g4_19 + f9g3_38; + int64_t h3 = f0g3 + f1g2 + f2g1 + f3g0 + f4g9_19 + f5g8_19 + f6g7_19 + + f7g6_19 + f8g5_19 + f9g4_19; + int64_t h4 = f0g4 + f1g3_2 + f2g2 + f3g1_2 + f4g0 + f5g9_38 + f6g8_19 + + f7g7_38 + f8g6_19 + f9g5_38; + int64_t h5 = f0g5 + f1g4 + f2g3 + f3g2 + f4g1 + f5g0 + f6g9_19 + f7g8_19 + + f8g7_19 + f9g6_19; + int64_t h6 = f0g6 + f1g5_2 + f2g4 + f3g3_2 + f4g2 + f5g1_2 + f6g0 + + f7g9_38 + f8g8_19 + f9g7_38; + int64_t h7 = f0g7 + f1g6 + f2g5 + f3g4 + f4g3 + f5g2 + f6g1 + f7g0 + + f8g9_19 + f9g8_19; + int64_t h8 = f0g8 + f1g7_2 + f2g6 + f3g5_2 + f4g4 + f5g3_2 + f6g2 + f7g1_2 + + f8g0 + f9g9_38; + int64_t h9 = + f0g9 + f1g8 + f2g7 + f3g6 + f4g5 + f5g4 + f6g3 + f7g2 + f8g1 + f9g0; + + int64_t carry0; + int64_t carry1; + int64_t carry2; + int64_t carry3; + int64_t carry4; + int64_t carry5; + int64_t carry6; + int64_t carry7; + int64_t carry8; + int64_t carry9; + + /* + |h0| <= (1.65*1.65*2^52*(1+19+19+19+19)+1.65*1.65*2^50*(38+38+38+38+38)) + i.e. |h0| <= 1.4*2^60; narrower ranges for h2, h4, h6, h8 + |h1| <= (1.65*1.65*2^51*(1+1+19+19+19+19+19+19+19+19)) + i.e. |h1| <= 1.7*2^59; narrower ranges for h3, h5, h7, h9 + */ + + carry0 = (h0 + (int64_t)(1L << 25)) >> 26; + h1 += carry0; + h0 -= carry0 * ((uint64_t) 1L << 26); + carry4 = (h4 + (int64_t)(1L << 25)) >> 26; + h5 += carry4; + h4 -= carry4 * ((uint64_t) 1L << 26); + /* |h0| <= 2^25 */ + /* |h4| <= 2^25 */ + /* |h1| <= 1.71*2^59 */ + /* |h5| <= 1.71*2^59 */ + + carry1 = (h1 + (int64_t)(1L << 24)) >> 25; + h2 += carry1; + h1 -= carry1 * ((uint64_t) 1L << 25); + carry5 = (h5 + (int64_t)(1L << 24)) >> 25; + h6 += carry5; + h5 -= carry5 * ((uint64_t) 1L << 25); + /* |h1| <= 2^24; from now on fits into int32 */ + /* |h5| <= 2^24; from now on fits into int32 */ + /* |h2| <= 1.41*2^60 */ + /* |h6| <= 1.41*2^60 */ + + carry2 = (h2 + (int64_t)(1L << 25)) >> 26; + h3 += carry2; + h2 -= carry2 * ((uint64_t) 1L << 26); + carry6 = (h6 + (int64_t)(1L << 25)) >> 26; + h7 += carry6; + h6 -= carry6 * ((uint64_t) 1L << 26); + /* |h2| <= 2^25; from now on fits into int32 unchanged */ + /* |h6| <= 2^25; from now on fits into int32 unchanged */ + /* |h3| <= 1.71*2^59 */ + /* |h7| <= 1.71*2^59 */ + + carry3 = (h3 + (int64_t)(1L << 24)) >> 25; + h4 += carry3; + h3 -= carry3 * ((uint64_t) 1L << 25); + carry7 = (h7 + (int64_t)(1L << 24)) >> 25; + h8 += carry7; + h7 -= carry7 * ((uint64_t) 1L << 25); + /* |h3| <= 2^24; from now on fits into int32 unchanged */ + /* |h7| <= 2^24; from now on fits into int32 unchanged */ + /* |h4| <= 1.72*2^34 */ + /* |h8| <= 1.41*2^60 */ + + carry4 = (h4 + (int64_t)(1L << 25)) >> 26; + h5 += carry4; + h4 -= carry4 * ((uint64_t) 1L << 26); + carry8 = (h8 + (int64_t)(1L << 25)) >> 26; + h9 += carry8; + h8 -= carry8 * ((uint64_t) 1L << 26); + /* |h4| <= 2^25; from now on fits into int32 unchanged */ + /* |h8| <= 2^25; from now on fits into int32 unchanged */ + /* |h5| <= 1.01*2^24 */ + /* |h9| <= 1.71*2^59 */ + + carry9 = (h9 + (int64_t)(1L << 24)) >> 25; + h0 += carry9 * 19; + h9 -= carry9 * ((uint64_t) 1L << 25); + /* |h9| <= 2^24; from now on fits into int32 unchanged */ + /* |h0| <= 1.1*2^39 */ + + carry0 = (h0 + (int64_t)(1L << 25)) >> 26; + h1 += carry0; + h0 -= carry0 * ((uint64_t) 1L << 26); + /* |h0| <= 2^25; from now on fits into int32 unchanged */ + /* |h1| <= 1.01*2^24 */ + + h[0] = (int32_t) h0; + h[1] = (int32_t) h1; + h[2] = (int32_t) h2; + h[3] = (int32_t) h3; + h[4] = (int32_t) h4; + h[5] = (int32_t) h5; + h[6] = (int32_t) h6; + h[7] = (int32_t) h7; + h[8] = (int32_t) h8; + h[9] = (int32_t) h9; +} + +/* + h = f * f + Can overlap h with f. + * + Preconditions: + |f| bounded by 1.65*2^26,1.65*2^25,1.65*2^26,1.65*2^25,etc. + * + Postconditions: + |h| bounded by 1.01*2^25,1.01*2^24,1.01*2^25,1.01*2^24,etc. + */ + +static void +fe25519_sq(fe25519 h, const fe25519 f) +{ + int32_t f0 = f[0]; + int32_t f1 = f[1]; + int32_t f2 = f[2]; + int32_t f3 = f[3]; + int32_t f4 = f[4]; + int32_t f5 = f[5]; + int32_t f6 = f[6]; + int32_t f7 = f[7]; + int32_t f8 = f[8]; + int32_t f9 = f[9]; + + int32_t f0_2 = 2 * f0; + int32_t f1_2 = 2 * f1; + int32_t f2_2 = 2 * f2; + int32_t f3_2 = 2 * f3; + int32_t f4_2 = 2 * f4; + int32_t f5_2 = 2 * f5; + int32_t f6_2 = 2 * f6; + int32_t f7_2 = 2 * f7; + int32_t f5_38 = 38 * f5; /* 1.959375*2^30 */ + int32_t f6_19 = 19 * f6; /* 1.959375*2^30 */ + int32_t f7_38 = 38 * f7; /* 1.959375*2^30 */ + int32_t f8_19 = 19 * f8; /* 1.959375*2^30 */ + int32_t f9_38 = 38 * f9; /* 1.959375*2^30 */ + + int64_t f0f0 = f0 * (int64_t) f0; + int64_t f0f1_2 = f0_2 * (int64_t) f1; + int64_t f0f2_2 = f0_2 * (int64_t) f2; + int64_t f0f3_2 = f0_2 * (int64_t) f3; + int64_t f0f4_2 = f0_2 * (int64_t) f4; + int64_t f0f5_2 = f0_2 * (int64_t) f5; + int64_t f0f6_2 = f0_2 * (int64_t) f6; + int64_t f0f7_2 = f0_2 * (int64_t) f7; + int64_t f0f8_2 = f0_2 * (int64_t) f8; + int64_t f0f9_2 = f0_2 * (int64_t) f9; + int64_t f1f1_2 = f1_2 * (int64_t) f1; + int64_t f1f2_2 = f1_2 * (int64_t) f2; + int64_t f1f3_4 = f1_2 * (int64_t) f3_2; + int64_t f1f4_2 = f1_2 * (int64_t) f4; + int64_t f1f5_4 = f1_2 * (int64_t) f5_2; + int64_t f1f6_2 = f1_2 * (int64_t) f6; + int64_t f1f7_4 = f1_2 * (int64_t) f7_2; + int64_t f1f8_2 = f1_2 * (int64_t) f8; + int64_t f1f9_76 = f1_2 * (int64_t) f9_38; + int64_t f2f2 = f2 * (int64_t) f2; + int64_t f2f3_2 = f2_2 * (int64_t) f3; + int64_t f2f4_2 = f2_2 * (int64_t) f4; + int64_t f2f5_2 = f2_2 * (int64_t) f5; + int64_t f2f6_2 = f2_2 * (int64_t) f6; + int64_t f2f7_2 = f2_2 * (int64_t) f7; + int64_t f2f8_38 = f2_2 * (int64_t) f8_19; + int64_t f2f9_38 = f2 * (int64_t) f9_38; + int64_t f3f3_2 = f3_2 * (int64_t) f3; + int64_t f3f4_2 = f3_2 * (int64_t) f4; + int64_t f3f5_4 = f3_2 * (int64_t) f5_2; + int64_t f3f6_2 = f3_2 * (int64_t) f6; + int64_t f3f7_76 = f3_2 * (int64_t) f7_38; + int64_t f3f8_38 = f3_2 * (int64_t) f8_19; + int64_t f3f9_76 = f3_2 * (int64_t) f9_38; + int64_t f4f4 = f4 * (int64_t) f4; + int64_t f4f5_2 = f4_2 * (int64_t) f5; + int64_t f4f6_38 = f4_2 * (int64_t) f6_19; + int64_t f4f7_38 = f4 * (int64_t) f7_38; + int64_t f4f8_38 = f4_2 * (int64_t) f8_19; + int64_t f4f9_38 = f4 * (int64_t) f9_38; + int64_t f5f5_38 = f5 * (int64_t) f5_38; + int64_t f5f6_38 = f5_2 * (int64_t) f6_19; + int64_t f5f7_76 = f5_2 * (int64_t) f7_38; + int64_t f5f8_38 = f5_2 * (int64_t) f8_19; + int64_t f5f9_76 = f5_2 * (int64_t) f9_38; + int64_t f6f6_19 = f6 * (int64_t) f6_19; + int64_t f6f7_38 = f6 * (int64_t) f7_38; + int64_t f6f8_38 = f6_2 * (int64_t) f8_19; + int64_t f6f9_38 = f6 * (int64_t) f9_38; + int64_t f7f7_38 = f7 * (int64_t) f7_38; + int64_t f7f8_38 = f7_2 * (int64_t) f8_19; + int64_t f7f9_76 = f7_2 * (int64_t) f9_38; + int64_t f8f8_19 = f8 * (int64_t) f8_19; + int64_t f8f9_38 = f8 * (int64_t) f9_38; + int64_t f9f9_38 = f9 * (int64_t) f9_38; + + int64_t h0 = f0f0 + f1f9_76 + f2f8_38 + f3f7_76 + f4f6_38 + f5f5_38; + int64_t h1 = f0f1_2 + f2f9_38 + f3f8_38 + f4f7_38 + f5f6_38; + int64_t h2 = f0f2_2 + f1f1_2 + f3f9_76 + f4f8_38 + f5f7_76 + f6f6_19; + int64_t h3 = f0f3_2 + f1f2_2 + f4f9_38 + f5f8_38 + f6f7_38; + int64_t h4 = f0f4_2 + f1f3_4 + f2f2 + f5f9_76 + f6f8_38 + f7f7_38; + int64_t h5 = f0f5_2 + f1f4_2 + f2f3_2 + f6f9_38 + f7f8_38; + int64_t h6 = f0f6_2 + f1f5_4 + f2f4_2 + f3f3_2 + f7f9_76 + f8f8_19; + int64_t h7 = f0f7_2 + f1f6_2 + f2f5_2 + f3f4_2 + f8f9_38; + int64_t h8 = f0f8_2 + f1f7_4 + f2f6_2 + f3f5_4 + f4f4 + f9f9_38; + int64_t h9 = f0f9_2 + f1f8_2 + f2f7_2 + f3f6_2 + f4f5_2; + + int64_t carry0; + int64_t carry1; + int64_t carry2; + int64_t carry3; + int64_t carry4; + int64_t carry5; + int64_t carry6; + int64_t carry7; + int64_t carry8; + int64_t carry9; + + carry0 = (h0 + (int64_t)(1L << 25)) >> 26; + h1 += carry0; + h0 -= carry0 * ((uint64_t) 1L << 26); + carry4 = (h4 + (int64_t)(1L << 25)) >> 26; + h5 += carry4; + h4 -= carry4 * ((uint64_t) 1L << 26); + + carry1 = (h1 + (int64_t)(1L << 24)) >> 25; + h2 += carry1; + h1 -= carry1 * ((uint64_t) 1L << 25); + carry5 = (h5 + (int64_t)(1L << 24)) >> 25; + h6 += carry5; + h5 -= carry5 * ((uint64_t) 1L << 25); + + carry2 = (h2 + (int64_t)(1L << 25)) >> 26; + h3 += carry2; + h2 -= carry2 * ((uint64_t) 1L << 26); + carry6 = (h6 + (int64_t)(1L << 25)) >> 26; + h7 += carry6; + h6 -= carry6 * ((uint64_t) 1L << 26); + + carry3 = (h3 + (int64_t)(1L << 24)) >> 25; + h4 += carry3; + h3 -= carry3 * ((uint64_t) 1L << 25); + carry7 = (h7 + (int64_t)(1L << 24)) >> 25; + h8 += carry7; + h7 -= carry7 * ((uint64_t) 1L << 25); + + carry4 = (h4 + (int64_t)(1L << 25)) >> 26; + h5 += carry4; + h4 -= carry4 * ((uint64_t) 1L << 26); + carry8 = (h8 + (int64_t)(1L << 25)) >> 26; + h9 += carry8; + h8 -= carry8 * ((uint64_t) 1L << 26); + + carry9 = (h9 + (int64_t)(1L << 24)) >> 25; + h0 += carry9 * 19; + h9 -= carry9 * ((uint64_t) 1L << 25); + + carry0 = (h0 + (int64_t)(1L << 25)) >> 26; + h1 += carry0; + h0 -= carry0 * ((uint64_t) 1L << 26); + + h[0] = (int32_t) h0; + h[1] = (int32_t) h1; + h[2] = (int32_t) h2; + h[3] = (int32_t) h3; + h[4] = (int32_t) h4; + h[5] = (int32_t) h5; + h[6] = (int32_t) h6; + h[7] = (int32_t) h7; + h[8] = (int32_t) h8; + h[9] = (int32_t) h9; +} + +/* + h = 2 * f * f + Can overlap h with f. + * + Preconditions: + |f| bounded by 1.65*2^26,1.65*2^25,1.65*2^26,1.65*2^25,etc. + * + Postconditions: + |h| bounded by 1.01*2^25,1.01*2^24,1.01*2^25,1.01*2^24,etc. + */ + +static void +fe25519_sq2(fe25519 h, const fe25519 f) +{ + int32_t f0 = f[0]; + int32_t f1 = f[1]; + int32_t f2 = f[2]; + int32_t f3 = f[3]; + int32_t f4 = f[4]; + int32_t f5 = f[5]; + int32_t f6 = f[6]; + int32_t f7 = f[7]; + int32_t f8 = f[8]; + int32_t f9 = f[9]; + + int32_t f0_2 = 2 * f0; + int32_t f1_2 = 2 * f1; + int32_t f2_2 = 2 * f2; + int32_t f3_2 = 2 * f3; + int32_t f4_2 = 2 * f4; + int32_t f5_2 = 2 * f5; + int32_t f6_2 = 2 * f6; + int32_t f7_2 = 2 * f7; + int32_t f5_38 = 38 * f5; /* 1.959375*2^30 */ + int32_t f6_19 = 19 * f6; /* 1.959375*2^30 */ + int32_t f7_38 = 38 * f7; /* 1.959375*2^30 */ + int32_t f8_19 = 19 * f8; /* 1.959375*2^30 */ + int32_t f9_38 = 38 * f9; /* 1.959375*2^30 */ + + int64_t f0f0 = f0 * (int64_t) f0; + int64_t f0f1_2 = f0_2 * (int64_t) f1; + int64_t f0f2_2 = f0_2 * (int64_t) f2; + int64_t f0f3_2 = f0_2 * (int64_t) f3; + int64_t f0f4_2 = f0_2 * (int64_t) f4; + int64_t f0f5_2 = f0_2 * (int64_t) f5; + int64_t f0f6_2 = f0_2 * (int64_t) f6; + int64_t f0f7_2 = f0_2 * (int64_t) f7; + int64_t f0f8_2 = f0_2 * (int64_t) f8; + int64_t f0f9_2 = f0_2 * (int64_t) f9; + int64_t f1f1_2 = f1_2 * (int64_t) f1; + int64_t f1f2_2 = f1_2 * (int64_t) f2; + int64_t f1f3_4 = f1_2 * (int64_t) f3_2; + int64_t f1f4_2 = f1_2 * (int64_t) f4; + int64_t f1f5_4 = f1_2 * (int64_t) f5_2; + int64_t f1f6_2 = f1_2 * (int64_t) f6; + int64_t f1f7_4 = f1_2 * (int64_t) f7_2; + int64_t f1f8_2 = f1_2 * (int64_t) f8; + int64_t f1f9_76 = f1_2 * (int64_t) f9_38; + int64_t f2f2 = f2 * (int64_t) f2; + int64_t f2f3_2 = f2_2 * (int64_t) f3; + int64_t f2f4_2 = f2_2 * (int64_t) f4; + int64_t f2f5_2 = f2_2 * (int64_t) f5; + int64_t f2f6_2 = f2_2 * (int64_t) f6; + int64_t f2f7_2 = f2_2 * (int64_t) f7; + int64_t f2f8_38 = f2_2 * (int64_t) f8_19; + int64_t f2f9_38 = f2 * (int64_t) f9_38; + int64_t f3f3_2 = f3_2 * (int64_t) f3; + int64_t f3f4_2 = f3_2 * (int64_t) f4; + int64_t f3f5_4 = f3_2 * (int64_t) f5_2; + int64_t f3f6_2 = f3_2 * (int64_t) f6; + int64_t f3f7_76 = f3_2 * (int64_t) f7_38; + int64_t f3f8_38 = f3_2 * (int64_t) f8_19; + int64_t f3f9_76 = f3_2 * (int64_t) f9_38; + int64_t f4f4 = f4 * (int64_t) f4; + int64_t f4f5_2 = f4_2 * (int64_t) f5; + int64_t f4f6_38 = f4_2 * (int64_t) f6_19; + int64_t f4f7_38 = f4 * (int64_t) f7_38; + int64_t f4f8_38 = f4_2 * (int64_t) f8_19; + int64_t f4f9_38 = f4 * (int64_t) f9_38; + int64_t f5f5_38 = f5 * (int64_t) f5_38; + int64_t f5f6_38 = f5_2 * (int64_t) f6_19; + int64_t f5f7_76 = f5_2 * (int64_t) f7_38; + int64_t f5f8_38 = f5_2 * (int64_t) f8_19; + int64_t f5f9_76 = f5_2 * (int64_t) f9_38; + int64_t f6f6_19 = f6 * (int64_t) f6_19; + int64_t f6f7_38 = f6 * (int64_t) f7_38; + int64_t f6f8_38 = f6_2 * (int64_t) f8_19; + int64_t f6f9_38 = f6 * (int64_t) f9_38; + int64_t f7f7_38 = f7 * (int64_t) f7_38; + int64_t f7f8_38 = f7_2 * (int64_t) f8_19; + int64_t f7f9_76 = f7_2 * (int64_t) f9_38; + int64_t f8f8_19 = f8 * (int64_t) f8_19; + int64_t f8f9_38 = f8 * (int64_t) f9_38; + int64_t f9f9_38 = f9 * (int64_t) f9_38; + + int64_t h0 = f0f0 + f1f9_76 + f2f8_38 + f3f7_76 + f4f6_38 + f5f5_38; + int64_t h1 = f0f1_2 + f2f9_38 + f3f8_38 + f4f7_38 + f5f6_38; + int64_t h2 = f0f2_2 + f1f1_2 + f3f9_76 + f4f8_38 + f5f7_76 + f6f6_19; + int64_t h3 = f0f3_2 + f1f2_2 + f4f9_38 + f5f8_38 + f6f7_38; + int64_t h4 = f0f4_2 + f1f3_4 + f2f2 + f5f9_76 + f6f8_38 + f7f7_38; + int64_t h5 = f0f5_2 + f1f4_2 + f2f3_2 + f6f9_38 + f7f8_38; + int64_t h6 = f0f6_2 + f1f5_4 + f2f4_2 + f3f3_2 + f7f9_76 + f8f8_19; + int64_t h7 = f0f7_2 + f1f6_2 + f2f5_2 + f3f4_2 + f8f9_38; + int64_t h8 = f0f8_2 + f1f7_4 + f2f6_2 + f3f5_4 + f4f4 + f9f9_38; + int64_t h9 = f0f9_2 + f1f8_2 + f2f7_2 + f3f6_2 + f4f5_2; + + int64_t carry0; + int64_t carry1; + int64_t carry2; + int64_t carry3; + int64_t carry4; + int64_t carry5; + int64_t carry6; + int64_t carry7; + int64_t carry8; + int64_t carry9; + + h0 += h0; + h1 += h1; + h2 += h2; + h3 += h3; + h4 += h4; + h5 += h5; + h6 += h6; + h7 += h7; + h8 += h8; + h9 += h9; + + carry0 = (h0 + (int64_t)(1L << 25)) >> 26; + h1 += carry0; + h0 -= carry0 * ((uint64_t) 1L << 26); + carry4 = (h4 + (int64_t)(1L << 25)) >> 26; + h5 += carry4; + h4 -= carry4 * ((uint64_t) 1L << 26); + + carry1 = (h1 + (int64_t)(1L << 24)) >> 25; + h2 += carry1; + h1 -= carry1 * ((uint64_t) 1L << 25); + carry5 = (h5 + (int64_t)(1L << 24)) >> 25; + h6 += carry5; + h5 -= carry5 * ((uint64_t) 1L << 25); + + carry2 = (h2 + (int64_t)(1L << 25)) >> 26; + h3 += carry2; + h2 -= carry2 * ((uint64_t) 1L << 26); + carry6 = (h6 + (int64_t)(1L << 25)) >> 26; + h7 += carry6; + h6 -= carry6 * ((uint64_t) 1L << 26); + + carry3 = (h3 + (int64_t)(1L << 24)) >> 25; + h4 += carry3; + h3 -= carry3 * ((uint64_t) 1L << 25); + carry7 = (h7 + (int64_t)(1L << 24)) >> 25; + h8 += carry7; + h7 -= carry7 * ((uint64_t) 1L << 25); + + carry4 = (h4 + (int64_t)(1L << 25)) >> 26; + h5 += carry4; + h4 -= carry4 * ((uint64_t) 1L << 26); + carry8 = (h8 + (int64_t)(1L << 25)) >> 26; + h9 += carry8; + h8 -= carry8 * ((uint64_t) 1L << 26); + + carry9 = (h9 + (int64_t)(1L << 24)) >> 25; + h0 += carry9 * 19; + h9 -= carry9 * ((uint64_t) 1L << 25); + + carry0 = (h0 + (int64_t)(1L << 25)) >> 26; + h1 += carry0; + h0 -= carry0 * ((uint64_t) 1L << 26); + + h[0] = (int32_t) h0; + h[1] = (int32_t) h1; + h[2] = (int32_t) h2; + h[3] = (int32_t) h3; + h[4] = (int32_t) h4; + h[5] = (int32_t) h5; + h[6] = (int32_t) h6; + h[7] = (int32_t) h7; + h[8] = (int32_t) h8; + h[9] = (int32_t) h9; +} + +static inline void +fe25519_mul32(fe25519 h, const fe25519 f, uint32_t n) +{ + int64_t sn = (int64_t) n; + int32_t f0 = f[0]; + int32_t f1 = f[1]; + int32_t f2 = f[2]; + int32_t f3 = f[3]; + int32_t f4 = f[4]; + int32_t f5 = f[5]; + int32_t f6 = f[6]; + int32_t f7 = f[7]; + int32_t f8 = f[8]; + int32_t f9 = f[9]; + int64_t h0 = f0 * sn; + int64_t h1 = f1 * sn; + int64_t h2 = f2 * sn; + int64_t h3 = f3 * sn; + int64_t h4 = f4 * sn; + int64_t h5 = f5 * sn; + int64_t h6 = f6 * sn; + int64_t h7 = f7 * sn; + int64_t h8 = f8 * sn; + int64_t h9 = f9 * sn; + int64_t carry0, carry1, carry2, carry3, carry4, carry5, carry6, carry7, + carry8, carry9; + + carry9 = (h9 + ((int64_t) 1 << 24)) >> 25; + h0 += carry9 * 19; + h9 -= carry9 * ((int64_t) 1 << 25); + carry1 = (h1 + ((int64_t) 1 << 24)) >> 25; + h2 += carry1; + h1 -= carry1 * ((int64_t) 1 << 25); + carry3 = (h3 + ((int64_t) 1 << 24)) >> 25; + h4 += carry3; + h3 -= carry3 * ((int64_t) 1 << 25); + carry5 = (h5 + ((int64_t) 1 << 24)) >> 25; + h6 += carry5; + h5 -= carry5 * ((int64_t) 1 << 25); + carry7 = (h7 + ((int64_t) 1 << 24)) >> 25; + h8 += carry7; + h7 -= carry7 * ((int64_t) 1 << 25); + + carry0 = (h0 + ((int64_t) 1 << 25)) >> 26; + h1 += carry0; + h0 -= carry0 * ((int64_t) 1 << 26); + carry2 = (h2 + ((int64_t) 1 << 25)) >> 26; + h3 += carry2; + h2 -= carry2 * ((int64_t) 1 << 26); + carry4 = (h4 + ((int64_t) 1 << 25)) >> 26; + h5 += carry4; + h4 -= carry4 * ((int64_t) 1 << 26); + carry6 = (h6 + ((int64_t) 1 << 25)) >> 26; + h7 += carry6; + h6 -= carry6 * ((int64_t) 1 << 26); + carry8 = (h8 + ((int64_t) 1 << 25)) >> 26; + h9 += carry8; + h8 -= carry8 * ((int64_t) 1 << 26); + + h[0] = (int32_t) h0; + h[1] = (int32_t) h1; + h[2] = (int32_t) h2; + h[3] = (int32_t) h3; + h[4] = (int32_t) h4; + h[5] = (int32_t) h5; + h[6] = (int32_t) h6; + h[7] = (int32_t) h7; + h[8] = (int32_t) h8; + h[9] = (int32_t) h9; +} diff --git a/packages/runtime/vendor/libsodium/export.h b/packages/runtime/vendor/libsodium/export.h new file mode 100644 index 000000000..a0074fc9c --- /dev/null +++ b/packages/runtime/vendor/libsodium/export.h @@ -0,0 +1,57 @@ + +#ifndef sodium_export_H +#define sodium_export_H + +#include +#include +#include + +#if !defined(__clang__) && !defined(__GNUC__) +# ifdef __attribute__ +# undef __attribute__ +# endif +# define __attribute__(a) +#endif + +#ifdef SODIUM_STATIC +# define SODIUM_EXPORT +# define SODIUM_EXPORT_WEAK +#else +# if defined(_MSC_VER) +# ifdef SODIUM_DLL_EXPORT +# define SODIUM_EXPORT __declspec(dllexport) +# else +# define SODIUM_EXPORT __declspec(dllimport) +# endif +# else +# if defined(__SUNPRO_C) +# ifndef __GNU_C__ +# define SODIUM_EXPORT __attribute__ (visibility(__global)) +# else +# define SODIUM_EXPORT __attribute__ __global +# endif +# elif defined(_MSG_VER) +# define SODIUM_EXPORT extern __declspec(dllexport) +# else +# define SODIUM_EXPORT __attribute__ ((visibility ("default"))) +# endif +# endif +# if defined(__ELF__) && !defined(SODIUM_DISABLE_WEAK_FUNCTIONS) +# define SODIUM_EXPORT_WEAK SODIUM_EXPORT __attribute__((weak)) +# else +# define SODIUM_EXPORT_WEAK SODIUM_EXPORT +# endif +#endif + +#ifndef CRYPTO_ALIGN +# if defined(__INTEL_COMPILER) || defined(_MSC_VER) +# define CRYPTO_ALIGN(x) __declspec(align(x)) +# else +# define CRYPTO_ALIGN(x) __attribute__ ((aligned(x))) +# endif +#endif + +#define SODIUM_MIN(A, B) ((A) < (B) ? (A) : (B)) +#define SODIUM_SIZE_MAX SODIUM_MIN(UINT64_MAX, SIZE_MAX) + +#endif diff --git a/packages/runtime/vendor/libsodium/fe_25_5/base.h b/packages/runtime/vendor/libsodium/fe_25_5/base.h new file mode 100644 index 000000000..e18530bbb --- /dev/null +++ b/packages/runtime/vendor/libsodium/fe_25_5/base.h @@ -0,0 +1,1344 @@ +{ /* 0/31 */ + { + { 25967493, -14356035, 29566456, 3660896, -12694345, 4014787, 27544626, -11754271, -6079156, 2047605 }, + { -12545711, 934262, -2722910, 3049990, -727428, 9406986, 12720692, 5043384, 19500929, -15469378 }, + { -8738181, 4489570, 9688441, -14785194, 10184609, -12363380, 29287919, 11864899, -24514362, -4438546 } + }, + { + { -12815894, -12976347, -21581243, 11784320, -25355658, -2750717, -11717903, -3814571, -358445, -10211303 }, + { -21703237, 6903825, 27185491, 6451973, -29577724, -9554005, -15616551, 11189268, -26829678, -5319081 }, + { 26966642, 11152617, 32442495, 15396054, 14353839, -12752335, -3128826, -9541118, -15472047, -4166697 } + }, + { + { 15636291, -9688557, 24204773, -7912398, 616977, -16685262, 27787600, -14772189, 28944400, -1550024 }, + { 16568933, 4717097, -11556148, -1102322, 15682896, -11807043, 16354577, -11775962, 7689662, 11199574 }, + { 30464156, -5976125, -11779434, -15670865, 23220365, 15915852, 7512774, 10017326, -17749093, -9920357 } + }, + { + { -17036878, 13921892, 10945806, -6033431, 27105052, -16084379, -28926210, 15006023, 3284568, -6276540 }, + { 23599295, -8306047, -11193664, -7687416, 13236774, 10506355, 7464579, 9656445, 13059162, 10374397 }, + { 7798556, 16710257, 3033922, 2874086, 28997861, 2835604, 32406664, -3839045, -641708, -101325 } + }, + { + { 10861363, 11473154, 27284546, 1981175, -30064349, 12577861, 32867885, 14515107, -15438304, 10819380 }, + { 4708026, 6336745, 20377586, 9066809, -11272109, 6594696, -25653668, 12483688, -12668491, 5581306 }, + { 19563160, 16186464, -29386857, 4097519, 10237984, -4348115, 28542350, 13850243, -23678021, -15815942 } + }, + { + { -15371964, -12862754, 32573250, 4720197, -26436522, 5875511, -19188627, -15224819, -9818940, -12085777 }, + { -8549212, 109983, 15149363, 2178705, 22900618, 4543417, 3044240, -15689887, 1762328, 14866737 }, + { -18199695, -15951423, -10473290, 1707278, -17185920, 3916101, -28236412, 3959421, 27914454, 4383652 } + }, + { + { 5153746, 9909285, 1723747, -2777874, 30523605, 5516873, 19480852, 5230134, -23952439, -15175766 }, + { -30269007, -3463509, 7665486, 10083793, 28475525, 1649722, 20654025, 16520125, 30598449, 7715701 }, + { 28881845, 14381568, 9657904, 3680757, -20181635, 7843316, -31400660, 1370708, 29794553, -1409300 } + }, + { + { 14499471, -2729599, -33191113, -4254652, 28494862, 14271267, 30290735, 10876454, -33154098, 2381726 }, + { -7195431, -2655363, -14730155, 462251, -27724326, 3941372, -6236617, 3696005, -32300832, 15351955 }, + { 27431194, 8222322, 16448760, -3907995, -18707002, 11938355, -32961401, -2970515, 29551813, 10109425 } + } +}, +{ /* 1/31 */ + { + { -13657040, -13155431, -31283750, 11777098, 21447386, 6519384, -2378284, -1627556, 10092783, -4764171 }, + { 27939166, 14210322, 4677035, 16277044, -22964462, -12398139, -32508754, 12005538, -17810127, 12803510 }, + { 17228999, -15661624, -1233527, 300140, -1224870, -11714777, 30364213, -9038194, 18016357, 4397660 } + }, + { + { -10958843, -7690207, 4776341, -14954238, 27850028, -15602212, -26619106, 14544525, -17477504, 982639 }, + { 29253598, 15796703, -2863982, -9908884, 10057023, 3163536, 7332899, -4120128, -21047696, 9934963 }, + { 5793303, 16271923, -24131614, -10116404, 29188560, 1206517, -14747930, 4559895, -30123922, -10897950 } + }, + { + { -27643952, -11493006, 16282657, -11036493, 28414021, -15012264, 24191034, 4541697, -13338309, 5500568 }, + { 12650548, -1497113, 9052871, 11355358, -17680037, -8400164, -17430592, 12264343, 10874051, 13524335 }, + { 25556948, -3045990, 714651, 2510400, 23394682, -10415330, 33119038, 5080568, -22528059, 5376628 } + }, + { + { -26088264, -4011052, -17013699, -3537628, -6726793, 1920897, -22321305, -9447443, 4535768, 1569007 }, + { -2255422, 14606630, -21692440, -8039818, 28430649, 8775819, -30494562, 3044290, 31848280, 12543772 }, + { -22028579, 2943893, -31857513, 6777306, 13784462, -4292203, -27377195, -2062731, 7718482, 14474653 } + }, + { + { 2385315, 2454213, -22631320, 46603, -4437935, -15680415, 656965, -7236665, 24316168, -5253567 }, + { 13741529, 10911568, -33233417, -8603737, -20177830, -1033297, 33040651, -13424532, -20729456, 8321686 }, + { 21060490, -2212744, 15712757, -4336099, 1639040, 10656336, 23845965, -11874838, -9984458, 608372 } + }, + { + { -13672732, -15087586, -10889693, -7557059, -6036909, 11305547, 1123968, -6780577, 27229399, 23887 }, + { -23244140, -294205, -11744728, 14712571, -29465699, -2029617, 12797024, -6440308, -1633405, 16678954 }, + { -29500620, 4770662, -16054387, 14001338, 7830047, 9564805, -1508144, -4795045, -17169265, 4904953 } + }, + { + { 24059557, 14617003, 19037157, -15039908, 19766093, -14906429, 5169211, 16191880, 2128236, -4326833 }, + { -16981152, 4124966, -8540610, -10653797, 30336522, -14105247, -29806336, 916033, -6882542, -2986532 }, + { -22630907, 12419372, -7134229, -7473371, -16478904, 16739175, 285431, 2763829, 15736322, 4143876 } + }, + { + { 2379352, 11839345, -4110402, -5988665, 11274298, 794957, 212801, -14594663, 23527084, -16458268 }, + { 33431127, -11130478, -17838966, -15626900, 8909499, 8376530, -32625340, 4087881, -15188911, -14416214 }, + { 1767683, 7197987, -13205226, -2022635, -13091350, 448826, 5799055, 4357868, -4774191, -16323038 } + } +}, +{ /* 2/31 */ + { + { 6721966, 13833823, -23523388, -1551314, 26354293, -11863321, 23365147, -3949732, 7390890, 2759800 }, + { 4409041, 2052381, 23373853, 10530217, 7676779, -12885954, 21302353, -4264057, 1244380, -12919645 }, + { -4421239, 7169619, 4982368, -2957590, 30256825, -2777540, 14086413, 9208236, 15886429, 16489664 } + }, + { + { 1996075, 10375649, 14346367, 13311202, -6874135, -16438411, -13693198, 398369, -30606455, -712933 }, + { -25307465, 9795880, -2777414, 14878809, -33531835, 14780363, 13348553, 12076947, -30836462, 5113182 }, + { -17770784, 11797796, 31950843, 13929123, -25888302, 12288344, -30341101, -7336386, 13847711, 5387222 } + }, + { + { -18582163, -3416217, 17824843, -2340966, 22744343, -10442611, 8763061, 3617786, -19600662, 10370991 }, + { 20246567, -14369378, 22358229, -543712, 18507283, -10413996, 14554437, -8746092, 32232924, 16763880 }, + { 9648505, 10094563, 26416693, 14745928, -30374318, -6472621, 11094161, 15689506, 3140038, -16510092 } + }, + { + { -16160072, 5472695, 31895588, 4744994, 8823515, 10365685, -27224800, 9448613, -28774454, 366295 }, + { 19153450, 11523972, -11096490, -6503142, -24647631, 5420647, 28344573, 8041113, 719605, 11671788 }, + { 8678025, 2694440, -6808014, 2517372, 4964326, 11152271, -15432916, -15266516, 27000813, -10195553 } + }, + { + { -15157904, 7134312, 8639287, -2814877, -7235688, 10421742, 564065, 5336097, 6750977, -14521026 }, + { 11836410, -3979488, 26297894, 16080799, 23455045, 15735944, 1695823, -8819122, 8169720, 16220347 }, + { -18115838, 8653647, 17578566, -6092619, -8025777, -16012763, -11144307, -2627664, -5990708, -14166033 } + }, + { + { -23308498, -10968312, 15213228, -10081214, -30853605, -11050004, 27884329, 2847284, 2655861, 1738395 }, + { -27537433, -14253021, -25336301, -8002780, -9370762, 8129821, 21651608, -3239336, -19087449, -11005278 }, + { 1533110, 3437855, 23735889, 459276, 29970501, 11335377, 26030092, 5821408, 10478196, 8544890 } + }, + { + { 32173121, -16129311, 24896207, 3921497, 22579056, -3410854, 19270449, 12217473, 17789017, -3395995 }, + { -30552961, -2228401, -15578829, -10147201, 13243889, 517024, 15479401, -3853233, 30460520, 1052596 }, + { -11614875, 13323618, 32618793, 8175907, -15230173, 12596687, 27491595, -4612359, 3179268, -9478891 } + }, + { + { 31947069, -14366651, -4640583, -15339921, -15125977, -6039709, -14756777, -16411740, 19072640, -9511060 }, + { 11685058, 11822410, 3158003, -13952594, 33402194, -4165066, 5977896, -5215017, 473099, 5040608 }, + { -20290863, 8198642, -27410132, 11602123, 1290375, -2799760, 28326862, 1721092, -19558642, -3131606 } + } +}, +{ /* 3/31 */ + { + { 7881532, 10687937, 7578723, 7738378, -18951012, -2553952, 21820786, 8076149, -27868496, 11538389 }, + { -19935666, 3899861, 18283497, -6801568, -15728660, -11249211, 8754525, 7446702, -5676054, 5797016 }, + { -11295600, -3793569, -15782110, -7964573, 12708869, -8456199, 2014099, -9050574, -2369172, -5877341 } + }, + { + { -22472376, -11568741, -27682020, 1146375, 18956691, 16640559, 1192730, -3714199, 15123619, 10811505 }, + { 14352098, -3419715, -18942044, 10822655, 32750596, 4699007, -70363, 15776356, -28886779, -11974553 }, + { -28241164, -8072475, -4978962, -5315317, 29416931, 1847569, -20654173, -16484855, 4714547, -9600655 } + }, + { + { 15200332, 8368572, 19679101, 15970074, -31872674, 1959451, 24611599, -4543832, -11745876, 12340220 }, + { 12876937, -10480056, 33134381, 6590940, -6307776, 14872440, 9613953, 8241152, 15370987, 9608631 }, + { -4143277, -12014408, 8446281, -391603, 4407738, 13629032, -7724868, 15866074, -28210621, -8814099 } + }, + { + { 26660628, -15677655, 8393734, 358047, -7401291, 992988, -23904233, 858697, 20571223, 8420556 }, + { 14620715, 13067227, -15447274, 8264467, 14106269, 15080814, 33531827, 12516406, -21574435, -12476749 }, + { 236881, 10476226, 57258, -14677024, 6472998, 2466984, 17258519, 7256740, 8791136, 15069930 } + }, + { + { 1276410, -9371918, 22949635, -16322807, -23493039, -5702186, 14711875, 4874229, -30663140, -2331391 }, + { 5855666, 4990204, -13711848, 7294284, -7804282, 1924647, -1423175, -7912378, -33069337, 9234253 }, + { 20590503, -9018988, 31529744, -7352666, -2706834, 10650548, 31559055, -11609587, 18979186, 13396066 } + }, + { + { 24474287, 4968103, 22267082, 4407354, 24063882, -8325180, -18816887, 13594782, 33514650, 7021958 }, + { -11566906, -6565505, -21365085, 15928892, -26158305, 4315421, -25948728, -3916677, -21480480, 12868082 }, + { -28635013, 13504661, 19988037, -2132761, 21078225, 6443208, -21446107, 2244500, -12455797, -8089383 } + }, + { + { -30595528, 13793479, -5852820, 319136, -25723172, -6263899, 33086546, 8957937, -15233648, 5540521 }, + { -11630176, -11503902, -8119500, -7643073, 2620056, 1022908, -23710744, -1568984, -16128528, -14962807 }, + { 23152971, 775386, 27395463, 14006635, -9701118, 4649512, 1689819, 892185, -11513277, -15205948 } + }, + { + { 9770129, 9586738, 26496094, 4324120, 1556511, -3550024, 27453819, 4763127, -19179614, 5867134 }, + { -32765025, 1927590, 31726409, -4753295, 23962434, -16019500, 27846559, 5931263, -29749703, -16108455 }, + { 27461885, -2977536, 22380810, 1815854, -23033753, -3031938, 7283490, -15148073, -19526700, 7734629 } + } +}, +{ /* 4/31 */ + { + { -8010264, -9590817, -11120403, 6196038, 29344158, -13430885, 7585295, -3176626, 18549497, 15302069 }, + { -32658337, -6171222, -7672793, -11051681, 6258878, 13504381, 10458790, -6418461, -8872242, 8424746 }, + { 24687205, 8613276, -30667046, -3233545, 1863892, -1830544, 19206234, 7134917, -11284482, -828919 } + }, + { + { 11334899, -9218022, 8025293, 12707519, 17523892, -10476071, 10243738, -14685461, -5066034, 16498837 }, + { 8911542, 6887158, -9584260, -6958590, 11145641, -9543680, 17303925, -14124238, 6536641, 10543906 }, + { -28946384, 15479763, -17466835, 568876, -1497683, 11223454, -2669190, -16625574, -27235709, 8876771 } + }, + { + { -25742899, -12566864, -15649966, -846607, -33026686, -796288, -33481822, 15824474, -604426, -9039817 }, + { 10330056, 70051, 7957388, -9002667, 9764902, 15609756, 27698697, -4890037, 1657394, 3084098 }, + { 10477963, -7470260, 12119566, -13250805, 29016247, -5365589, 31280319, 14396151, -30233575, 15272409 } + }, + { + { -12288309, 3169463, 28813183, 16658753, 25116432, -5630466, -25173957, -12636138, -25014757, 1950504 }, + { -26180358, 9489187, 11053416, -14746161, -31053720, 5825630, -8384306, -8767532, 15341279, 8373727 }, + { 28685821, 7759505, -14378516, -12002860, -31971820, 4079242, 298136, -10232602, -2878207, 15190420 } + }, + { + { -32932876, 13806336, -14337485, -15794431, -24004620, 10940928, 8669718, 2742393, -26033313, -6875003 }, + { -1580388, -11729417, -25979658, -11445023, -17411874, -10912854, 9291594, -16247779, -12154742, 6048605 }, + { -30305315, 14843444, 1539301, 11864366, 20201677, 1900163, 13934231, 5128323, 11213262, 9168384 } + }, + { + { -26280513, 11007847, 19408960, -940758, -18592965, -4328580, -5088060, -11105150, 20470157, -16398701 }, + { -23136053, 9282192, 14855179, -15390078, -7362815, -14408560, -22783952, 14461608, 14042978, 5230683 }, + { 29969567, -2741594, -16711867, -8552442, 9175486, -2468974, 21556951, 3506042, -5933891, -12449708 } + }, + { + { -3144746, 8744661, 19704003, 4581278, -20430686, 6830683, -21284170, 8971513, -28539189, 15326563 }, + { -19464629, 10110288, -17262528, -3503892, -23500387, 1355669, -15523050, 15300988, -20514118, 9168260 }, + { -5353335, 4488613, -23803248, 16314347, 7780487, -15638939, -28948358, 9601605, 33087103, -9011387 } + }, + { + { -19443170, -15512900, -20797467, -12445323, -29824447, 10229461, -27444329, -15000531, -5996870, 15664672 }, + { 23294591, -16632613, -22650781, -8470978, 27844204, 11461195, 13099750, -2460356, 18151676, 13417686 }, + { -24722913, -4176517, -31150679, 5988919, -26858785, 6685065, 1661597, -12551441, 15271676, -15452665 } + } +}, +{ /* 5/31 */ + { + { 11433042, -13228665, 8239631, -5279517, -1985436, -725718, -18698764, 2167544, -6921301, -13440182 }, + { -31436171, 15575146, 30436815, 12192228, -22463353, 9395379, -9917708, -8638997, 12215110, 12028277 }, + { 14098400, 6555944, 23007258, 5757252, -15427832, -12950502, 30123440, 4617780, -16900089, -655628 } + }, + { + { -4026201, -15240835, 11893168, 13718664, -14809462, 1847385, -15819999, 10154009, 23973261, -12684474 }, + { -26531820, -3695990, -1908898, 2534301, -31870557, -16550355, 18341390, -11419951, 32013174, -10103539 }, + { -25479301, 10876443, -11771086, -14625140, -12369567, 1838104, 21911214, 6354752, 4425632, -837822 } + }, + { + { -10433389, -14612966, 22229858, -3091047, -13191166, 776729, -17415375, -12020462, 4725005, 14044970 }, + { 19268650, -7304421, 1555349, 8692754, -21474059, -9910664, 6347390, -1411784, -19522291, -16109756 }, + { -24864089, 12986008, -10898878, -5558584, -11312371, -148526, 19541418, 8180106, 9282262, 10282508 } + }, + { + { -26205082, 4428547, -8661196, -13194263, 4098402, -14165257, 15522535, 8372215, 5542595, -10702683 }, + { -10562541, 14895633, 26814552, -16673850, -17480754, -2489360, -2781891, 6993761, -18093885, 10114655 }, + { -20107055, -929418, 31422704, 10427861, -7110749, 6150669, -29091755, -11529146, 25953725, -106158 } + }, + { + { -4234397, -8039292, -9119125, 3046000, 2101609, -12607294, 19390020, 6094296, -3315279, 12831125 }, + { -15998678, 7578152, 5310217, 14408357, -33548620, -224739, 31575954, 6326196, 7381791, -2421839 }, + { -20902779, 3296811, 24736065, -16328389, 18374254, 7318640, 6295303, 8082724, -15362489, 12339664 } + }, + { + { 27724736, 2291157, 6088201, -14184798, 1792727, 5857634, 13848414, 15768922, 25091167, 14856294 }, + { -18866652, 8331043, 24373479, 8541013, -701998, -9269457, 12927300, -12695493, -22182473, -9012899 }, + { -11423429, -5421590, 11632845, 3405020, 30536730, -11674039, -27260765, 13866390, 30146206, 9142070 } + }, + { + { 3924129, -15307516, -13817122, -10054960, 12291820, -668366, -27702774, 9326384, -8237858, 4171294 }, + { -15921940, 16037937, 6713787, 16606682, -21612135, 2790944, 26396185, 3731949, 345228, -5462949 }, + { -21327538, 13448259, 25284571, 1143661, 20614966, -8849387, 2031539, -12391231, -16253183, -13582083 } + }, + { + { 31016211, -16722429, 26371392, -14451233, -5027349, 14854137, 17477601, 3842657, 28012650, -16405420 }, + { -5075835, 9368966, -8562079, -4600902, -15249953, 6970560, -9189873, 16292057, -8867157, 3507940 }, + { 29439664, 3537914, 23333589, 6997794, -17555561, -11018068, -15209202, -15051267, -9164929, 6580396 } + } +}, +{ /* 6/31 */ + { + { -12185861, -7679788, 16438269, 10826160, -8696817, -6235611, 17860444, -9273846, -2095802, 9304567 }, + { 20714564, -4336911, 29088195, 7406487, 11426967, -5095705, 14792667, -14608617, 5289421, -477127 }, + { -16665533, -10650790, -6160345, -13305760, 9192020, -1802462, 17271490, 12349094, 26939669, -3752294 } + }, + { + { -12889898, 9373458, 31595848, 16374215, 21471720, 13221525, -27283495, -12348559, -3698806, 117887 }, + { 22263325, -6560050, 3984570, -11174646, -15114008, -566785, 28311253, 5358056, -23319780, 541964 }, + { 16259219, 3261970, 2309254, -15534474, -16885711, -4581916, 24134070, -16705829, -13337066, -13552195 } + }, + { + { 9378160, -13140186, -22845982, -12745264, 28198281, -7244098, -2399684, -717351, 690426, 14876244 }, + { 24977353, -314384, -8223969, -13465086, 28432343, -1176353, -13068804, -12297348, -22380984, 6618999 }, + { -1538174, 11685646, 12944378, 13682314, -24389511, -14413193, 8044829, -13817328, 32239829, -5652762 } + }, + { + { -18603066, 4762990, -926250, 8885304, -28412480, -3187315, 9781647, -10350059, 32779359, 5095274 }, + { -33008130, -5214506, -32264887, -3685216, 9460461, -9327423, -24601656, 14506724, 21639561, -2630236 }, + { -16400943, -13112215, 25239338, 15531969, 3987758, -4499318, -1289502, -6863535, 17874574, 558605 } + }, + { + { -13600129, 10240081, 9171883, 16131053, -20869254, 9599700, 33499487, 5080151, 2085892, 5119761 }, + { -22205145, -2519528, -16381601, 414691, -25019550, 2170430, 30634760, -8363614, -31999993, -5759884 }, + { -6845704, 15791202, 8550074, -1312654, 29928809, -12092256, 27534430, -7192145, -22351378, 12961482 } + }, + { + { -24492060, -9570771, 10368194, 11582341, -23397293, -2245287, 16533930, 8206996, -30194652, -5159638 }, + { -11121496, -3382234, 2307366, 6362031, -135455, 8868177, -16835630, 7031275, 7589640, 8945490 }, + { -32152748, 8917967, 6661220, -11677616, -1192060, -15793393, 7251489, -11182180, 24099109, -14456170 } + }, + { + { 5019558, -7907470, 4244127, -14714356, -26933272, 6453165, -19118182, -13289025, -6231896, -10280736 }, + { 10853594, 10721687, 26480089, 5861829, -22995819, 1972175, -1866647, -10557898, -3363451, -6441124 }, + { -17002408, 5906790, 221599, -6563147, 7828208, -13248918, 24362661, -2008168, -13866408, 7421392 } + }, + { + { 8139927, -6546497, 32257646, -5890546, 30375719, 1886181, -21175108, 15441252, 28826358, -4123029 }, + { 6267086, 9695052, 7709135, -16603597, -32869068, -1886135, 14795160, -7840124, 13746021, -1742048 }, + { 28584902, 7787108, -6732942, -15050729, 22846041, -7571236, -3181936, -363524, 4771362, -8419958 } + } +}, +{ /* 7/31 */ + { + { 24949256, 6376279, -27466481, -8174608, -18646154, -9930606, 33543569, -12141695, 3569627, 11342593 }, + { 26514989, 4740088, 27912651, 3697550, 19331575, -11472339, 6809886, 4608608, 7325975, -14801071 }, + { -11618399, -14554430, -24321212, 7655128, -1369274, 5214312, -27400540, 10258390, -17646694, -8186692 } + }, + { + { 11431204, 15823007, 26570245, 14329124, 18029990, 4796082, -31446179, 15580664, 9280358, -3973687 }, + { -160783, -10326257, -22855316, -4304997, -20861367, -13621002, -32810901, -11181622, -15545091, 4387441 }, + { -20799378, 12194512, 3937617, -5805892, -27154820, 9340370, -24513992, 8548137, 20617071, -7482001 } + }, + { + { -938825, -3930586, -8714311, 16124718, 24603125, -6225393, -13775352, -11875822, 24345683, 10325460 }, + { -19855277, -1568885, -22202708, 8714034, 14007766, 6928528, 16318175, -1010689, 4766743, 3552007 }, + { -21751364, -16730916, 1351763, -803421, -4009670, 3950935, 3217514, 14481909, 10988822, -3994762 } + }, + { + { 15564307, -14311570, 3101243, 5684148, 30446780, -8051356, 12677127, -6505343, -8295852, 13296005 }, + { -9442290, 6624296, -30298964, -11913677, -4670981, -2057379, 31521204, 9614054, -30000824, 12074674 }, + { 4771191, -135239, 14290749, -13089852, 27992298, 14998318, -1413936, -1556716, 29832613, -16391035 } + }, + { + { 7064884, -7541174, -19161962, -5067537, -18891269, -2912736, 25825242, 5293297, -27122660, 13101590 }, + { -2298563, 2439670, -7466610, 1719965, -27267541, -16328445, 32512469, -5317593, -30356070, -4190957 }, + { -30006540, 10162316, -33180176, 3981723, -16482138, -13070044, 14413974, 9515896, 19568978, 9628812 } + }, + { + { 33053803, 199357, 15894591, 1583059, 27380243, -4580435, -17838894, -6106839, -6291786, 3437740 }, + { -18978877, 3884493, 19469877, 12726490, 15913552, 13614290, -22961733, 70104, 7463304, 4176122 }, + { -27124001, 10659917, 11482427, -16070381, 12771467, -6635117, -32719404, -5322751, 24216882, 5944158 } + }, + { + { 8894125, 7450974, -2664149, -9765752, -28080517, -12389115, 19345746, 14680796, 11632993, 5847885 }, + { 26942781, -2315317, 9129564, -4906607, 26024105, 11769399, -11518837, 6367194, -9727230, 4782140 }, + { 19916461, -4828410, -22910704, -11414391, 25606324, -5972441, 33253853, 8220911, 6358847, -1873857 } + }, + { + { 801428, -2081702, 16569428, 11065167, 29875704, 96627, 7908388, -4480480, -13538503, 1387155 }, + { 19646058, 5720633, -11416706, 12814209, 11607948, 12749789, 14147075, 15156355, -21866831, 11835260 }, + { 19299512, 1155910, 28703737, 14890794, 2925026, 7269399, 26121523, 15467869, -26560550, 5052483 } + } +}, +{ /* 8/31 */ + { + { -3017432, 10058206, 1980837, 3964243, 22160966, 12322533, -6431123, -12618185, 12228557, -7003677 }, + { 32944382, 14922211, -22844894, 5188528, 21913450, -8719943, 4001465, 13238564, -6114803, 8653815 }, + { 22865569, -4652735, 27603668, -12545395, 14348958, 8234005, 24808405, 5719875, 28483275, 2841751 } + }, + { + { -16420968, -1113305, -327719, -12107856, 21886282, -15552774, -1887966, -315658, 19932058, -12739203 }, + { -11656086, 10087521, -8864888, -5536143, -19278573, -3055912, 3999228, 13239134, -4777469, -13910208 }, + { 1382174, -11694719, 17266790, 9194690, -13324356, 9720081, 20403944, 11284705, -14013818, 3093230 } + }, + { + { 16650921, -11037932, -1064178, 1570629, -8329746, 7352753, -302424, 16271225, -24049421, -6691850 }, + { -21911077, -5927941, -4611316, -5560156, -31744103, -10785293, 24123614, 15193618, -21652117, -16739389 }, + { -9935934, -4289447, -25279823, 4372842, 2087473, 10399484, 31870908, 14690798, 17361620, 11864968 } + }, + { + { -11307610, 6210372, 13206574, 5806320, -29017692, -13967200, -12331205, -7486601, -25578460, -16240689 }, + { 14668462, -12270235, 26039039, 15305210, 25515617, 4542480, 10453892, 6577524, 9145645, -6443880 }, + { 5974874, 3053895, -9433049, -10385191, -31865124, 3225009, -7972642, 3936128, -5652273, -3050304 } + }, + { + { 30625386, -4729400, -25555961, -12792866, -20484575, 7695099, 17097188, -16303496, -27999779, 1803632 }, + { -3553091, 9865099, -5228566, 4272701, -5673832, -16689700, 14911344, 12196514, -21405489, 7047412 }, + { 20093277, 9920966, -11138194, -5343857, 13161587, 12044805, -32856851, 4124601, -32343828, -10257566 } + }, + { + { -20788824, 14084654, -13531713, 7842147, 19119038, -13822605, 4752377, -8714640, -21679658, 2288038 }, + { -26819236, -3283715, 29965059, 3039786, -14473765, 2540457, 29457502, 14625692, -24819617, 12570232 }, + { -1063558, -11551823, 16920318, 12494842, 1278292, -5869109, -21159943, -3498680, -11974704, 4724943 } + }, + { + { 17960970, -11775534, -4140968, -9702530, -8876562, -1410617, -12907383, -8659932, -29576300, 1903856 }, + { 23134274, -14279132, -10681997, -1611936, 20684485, 15770816, -12989750, 3190296, 26955097, 14109738 }, + { 15308788, 5320727, -30113809, -14318877, 22902008, 7767164, 29425325, -11277562, 31960942, 11934971 } + }, + { + { -27395711, 8435796, 4109644, 12222639, -24627868, 14818669, 20638173, 4875028, 10491392, 1379718 }, + { -13159415, 9197841, 3875503, -8936108, -1383712, -5879801, 33518459, 16176658, 21432314, 12180697 }, + { -11787308, 11500838, 13787581, -13832590, -22430679, 10140205, 1465425, 12689540, -10301319, -13872883 } + } +}, +{ /* 9/31 */ + { + { 5414091, -15386041, -21007664, 9643570, 12834970, 1186149, -2622916, -1342231, 26128231, 6032912 }, + { -26337395, -13766162, 32496025, -13653919, 17847801, -12669156, 3604025, 8316894, -25875034, -10437358 }, + { 3296484, 6223048, 24680646, -12246460, -23052020, 5903205, -8862297, -4639164, 12376617, 3188849 } + }, + { + { 29190488, -14659046, 27549113, -1183516, 3520066, -10697301, 32049515, -7309113, -16109234, -9852307 }, + { -14744486, -9309156, 735818, -598978, -20407687, -5057904, 25246078, -15795669, 18640741, -960977 }, + { -6928835, -16430795, 10361374, 5642961, 4910474, 12345252, -31638386, -494430, 10530747, 1053335 } + }, + { + { -29265967, -14186805, -13538216, -12117373, -19457059, -10655384, -31462369, -2948985, 24018831, 15026644 }, + { -22592535, -3145277, -2289276, 5953843, -13440189, 9425631, 25310643, 13003497, -2314791, -15145616 }, + { -27419985, -603321, -8043984, -1669117, -26092265, 13987819, -27297622, 187899, -23166419, -2531735 } + }, + { + { -21744398, -13810475, 1844840, 5021428, -10434399, -15911473, 9716667, 16266922, -5070217, 726099 }, + { 29370922, -6053998, 7334071, -15342259, 9385287, 2247707, -13661962, -4839461, 30007388, -15823341 }, + { -936379, 16086691, 23751945, -543318, -1167538, -5189036, 9137109, 730663, 9835848, 4555336 } + }, + { + { -23376435, 1410446, -22253753, -12899614, 30867635, 15826977, 17693930, 544696, -11985298, 12422646 }, + { 31117226, -12215734, -13502838, 6561947, -9876867, -12757670, -5118685, -4096706, 29120153, 13924425 }, + { -17400879, -14233209, 19675799, -2734756, -11006962, -5858820, -9383939, -11317700, 7240931, -237388 } + }, + { + { -31361739, -11346780, -15007447, -5856218, -22453340, -12152771, 1222336, 4389483, 3293637, -15551743 }, + { -16684801, -14444245, 11038544, 11054958, -13801175, -3338533, -24319580, 7733547, 12796905, -6335822 }, + { -8759414, -10817836, -25418864, 10783769, -30615557, -9746811, -28253339, 3647836, 3222231, -11160462 } + }, + { + { 18606113, 1693100, -25448386, -15170272, 4112353, 10045021, 23603893, -2048234, -7550776, 2484985 }, + { 9255317, -3131197, -12156162, -1004256, 13098013, -9214866, 16377220, -2102812, -19802075, -3034702 }, + { -22729289, 7496160, -5742199, 11329249, 19991973, -3347502, -31718148, 9936966, -30097688, -10618797 } + }, + { + { 21878590, -5001297, 4338336, 13643897, -3036865, 13160960, 19708896, 5415497, -7360503, -4109293 }, + { 27736861, 10103576, 12500508, 8502413, -3413016, -9633558, 10436918, -1550276, -23659143, -8132100 }, + { 19492550, -12104365, -29681976, -852630, -3208171, 12403437, 30066266, 8367329, 13243957, 8709688 } + } +}, +{ /* 10/31 */ + { + { 12015105, 2801261, 28198131, 10151021, 24818120, -4743133, -11194191, -5645734, 5150968, 7274186 }, + { 2831366, -12492146, 1478975, 6122054, 23825128, -12733586, 31097299, 6083058, 31021603, -9793610 }, + { -2529932, -2229646, 445613, 10720828, -13849527, -11505937, -23507731, 16354465, 15067285, -14147707 } + }, + { + { 7840942, 14037873, -33364863, 15934016, -728213, -3642706, 21403988, 1057586, -19379462, -12403220 }, + { 915865, -16469274, 15608285, -8789130, -24357026, 6060030, -17371319, 8410997, -7220461, 16527025 }, + { 32922597, -556987, 20336074, -16184568, 10903705, -5384487, 16957574, 52992, 23834301, 6588044 } + }, + { + { 32752030, 11232950, 3381995, -8714866, 22652988, -10744103, 17159699, 16689107, -20314580, -1305992 }, + { -4689649, 9166776, -25710296, -10847306, 11576752, 12733943, 7924251, -2752281, 1976123, -7249027 }, + { 21251222, 16309901, -2983015, -6783122, 30810597, 12967303, 156041, -3371252, 12331345, -8237197 } + }, + { + { 8651614, -4477032, -16085636, -4996994, 13002507, 2950805, 29054427, -5106970, 10008136, -4667901 }, + { 31486080, 15114593, -14261250, 12951354, 14369431, -7387845, 16347321, -13662089, 8684155, -10532952 }, + { 19443825, 11385320, 24468943, -9659068, -23919258, 2187569, -26263207, -6086921, 31316348, 14219878 } + }, + { + { -28594490, 1193785, 32245219, 11392485, 31092169, 15722801, 27146014, 6992409, 29126555, 9207390 }, + { 32382935, 1110093, 18477781, 11028262, -27411763, -7548111, -4980517, 10843782, -7957600, -14435730 }, + { 2814918, 7836403, 27519878, -7868156, -20894015, -11553689, -21494559, 8550130, 28346258, 1994730 } + }, + { + { -19578299, 8085545, -14000519, -3948622, 2785838, -16231307, -19516951, 7174894, 22628102, 8115180 }, + { -30405132, 955511, -11133838, -15078069, -32447087, -13278079, -25651578, 3317160, -9943017, 930272 }, + { -15303681, -6833769, 28856490, 1357446, 23421993, 1057177, 24091212, -1388970, -22765376, -10650715 } + }, + { + { -22751231, -5303997, -12907607, -12768866, -15811511, -7797053, -14839018, -16554220, -1867018, 8398970 }, + { -31969310, 2106403, -4736360, 1362501, 12813763, 16200670, 22981545, -6291273, 18009408, -15772772 }, + { -17220923, -9545221, -27784654, 14166835, 29815394, 7444469, 29551787, -3727419, 19288549, 1325865 } + }, + { + { 15100157, -15835752, -23923978, -1005098, -26450192, 15509408, 12376730, -3479146, 33166107, -8042750 }, + { 20909231, 13023121, -9209752, 16251778, -5778415, -8094914, 12412151, 10018715, 2213263, -13878373 }, + { 32529814, -11074689, 30361439, -16689753, -9135940, 1513226, 22922121, 6382134, -5766928, 8371348 } + } +}, +{ /* 11/31 */ + { + { 9923462, 11271500, 12616794, 3544722, -29998368, -1721626, 12891687, -8193132, -26442943, 10486144 }, + { -22597207, -7012665, 8587003, -8257861, 4084309, -12970062, 361726, 2610596, -23921530, -11455195 }, + { 5408411, -1136691, -4969122, 10561668, 24145918, 14240566, 31319731, -4235541, 19985175, -3436086 } + }, + { + { -13994457, 16616821, 14549246, 3341099, 32155958, 13648976, -17577068, 8849297, 65030, 8370684 }, + { -8320926, -12049626, 31204563, 5839400, -20627288, -1057277, -19442942, 6922164, 12743482, -9800518 }, + { -2361371, 12678785, 28815050, 4759974, -23893047, 4884717, 23783145, 11038569, 18800704, 255233 } + }, + { + { -5269658, -1773886, 13957886, 7990715, 23132995, 728773, 13393847, 9066957, 19258688, -14753793 }, + { -2936654, -10827535, -10432089, 14516793, -3640786, 4372541, -31934921, 2209390, -1524053, 2055794 }, + { 580882, 16705327, 5468415, -2683018, -30926419, -14696000, -7203346, -8994389, -30021019, 7394435 } + }, + { + { 23838809, 1822728, -15738443, 15242727, 8318092, -3733104, -21672180, -3492205, -4821741, 14799921 }, + { 13345610, 9759151, 3371034, -16137791, 16353039, 8577942, 31129804, 13496856, -9056018, 7402518 }, + { 2286874, -4435931, -20042458, -2008336, -13696227, 5038122, 11006906, -15760352, 8205061, 1607563 } + }, + { + { 14414086, -8002132, 3331830, -3208217, 22249151, -5594188, 18364661, -2906958, 30019587, -9029278 }, + { -27688051, 1585953, -10775053, 931069, -29120221, -11002319, -14410829, 12029093, 9944378, 8024 }, + { 4368715, -3709630, 29874200, -15022983, -20230386, -11410704, -16114594, -999085, -8142388, 5640030 } + }, + { + { 10299610, 13746483, 11661824, 16234854, 7630238, 5998374, 9809887, -16694564, 15219798, -14327783 }, + { 27425505, -5719081, 3055006, 10660664, 23458024, 595578, -15398605, -1173195, -18342183, 9742717 }, + { 6744077, 2427284, 26042789, 2720740, -847906, 1118974, 32324614, 7406442, 12420155, 1994844 } + }, + { + { 14012521, -5024720, -18384453, -9578469, -26485342, -3936439, -13033478, -10909803, 24319929, -6446333 }, + { 16412690, -4507367, 10772641, 15929391, -17068788, -4658621, 10555945, -10484049, -30102368, -4739048 }, + { 22397382, -7767684, -9293161, -12792868, 17166287, -9755136, -27333065, 6199366, 21880021, -12250760 } + }, + { + { -4283307, 5368523, -31117018, 8163389, -30323063, 3209128, 16557151, 8890729, 8840445, 4957760 }, + { -15447727, 709327, -6919446, -10870178, -29777922, 6522332, -21720181, 12130072, -14796503, 5005757 }, + { -2114751, -14308128, 23019042, 15765735, -25269683, 6002752, 10183197, -13239326, -16395286, -2176112 } + } +}, +{ /* 12/31 */ + { + { -19025756, 1632005, 13466291, -7995100, -23640451, 16573537, -32013908, -3057104, 22208662, 2000468 }, + { 3065073, -1412761, -25598674, -361432, -17683065, -5703415, -8164212, 11248527, -3691214, -7414184 }, + { 10379208, -6045554, 8877319, 1473647, -29291284, -12507580, 16690915, 2553332, -3132688, 16400289 } + }, + { + { 15716668, 1254266, -18472690, 7446274, -8448918, 6344164, -22097271, -7285580, 26894937, 9132066 }, + { 24158887, 12938817, 11085297, -8177598, -28063478, -4457083, -30576463, 64452, -6817084, -2692882 }, + { 13488534, 7794716, 22236231, 5989356, 25426474, -12578208, 2350710, -3418511, -4688006, 2364226 } + }, + { + { 16335052, 9132434, 25640582, 6678888, 1725628, 8517937, -11807024, -11697457, 15445875, -7798101 }, + { 29004207, -7867081, 28661402, -640412, -12794003, -7943086, 31863255, -4135540, -278050, -15759279 }, + { -6122061, -14866665, -28614905, 14569919, -10857999, -3591829, 10343412, -6976290, -29828287, -10815811 } + }, + { + { 27081650, 3463984, 14099042, -4517604, 1616303, -6205604, 29542636, 15372179, 17293797, 960709 }, + { 20263915, 11434237, -5765435, 11236810, 13505955, -10857102, -16111345, 6493122, -19384511, 7639714 }, + { -2830798, -14839232, 25403038, -8215196, -8317012, -16173699, 18006287, -16043750, 29994677, -15808121 } + }, + { + { 9769828, 5202651, -24157398, -13631392, -28051003, -11561624, -24613141, -13860782, -31184575, 709464 }, + { 12286395, 13076066, -21775189, -1176622, -25003198, 4057652, -32018128, -8890874, 16102007, 13205847 }, + { 13733362, 5599946, 10557076, 3195751, -5557991, 8536970, -25540170, 8525972, 10151379, 10394400 } + }, + { + { 4024660, -16137551, 22436262, 12276534, -9099015, -2686099, 19698229, 11743039, -33302334, 8934414 }, + { -15879800, -4525240, -8580747, -2934061, 14634845, -698278, -9449077, 3137094, -11536886, 11721158 }, + { 17555939, -5013938, 8268606, 2331751, -22738815, 9761013, 9319229, 8835153, -9205489, -1280045 } + }, + { + { -461409, -7830014, 20614118, 16688288, -7514766, -4807119, 22300304, 505429, 6108462, -6183415 }, + { -5070281, 12367917, -30663534, 3234473, 32617080, -8422642, 29880583, -13483331, -26898490, -7867459 }, + { -31975283, 5726539, 26934134, 10237677, -3173717, -605053, 24199304, 3795095, 7592688, -14992079 } + }, + { + { 21594432, -14964228, 17466408, -4077222, 32537084, 2739898, 6407723, 12018833, -28256052, 4298412 }, + { -20650503, -11961496, -27236275, 570498, 3767144, -1717540, 13891942, -1569194, 13717174, 10805743 }, + { -14676630, -15644296, 15287174, 11927123, 24177847, -8175568, -796431, 14860609, -26938930, -5863836 } + } +}, +{ /* 13/31 */ + { + { 12962541, 5311799, -10060768, 11658280, 18855286, -7954201, 13286263, -12808704, -4381056, 9882022 }, + { 18512079, 11319350, -20123124, 15090309, 18818594, 5271736, -22727904, 3666879, -23967430, -3299429 }, + { -6789020, -3146043, 16192429, 13241070, 15898607, -14206114, -10084880, -6661110, -2403099, 5276065 } + }, + { + { 30169808, -5317648, 26306206, -11750859, 27814964, 7069267, 7152851, 3684982, 1449224, 13082861 }, + { 10342826, 3098505, 2119311, 193222, 25702612, 12233820, 23697382, 15056736, -21016438, -8202000 }, + { -33150110, 3261608, 22745853, 7948688, 19370557, -15177665, -26171976, 6482814, -10300080, -11060101 } + }, + { + { 32869458, -5408545, 25609743, 15678670, -10687769, -15471071, 26112421, 2521008, -22664288, 6904815 }, + { 29506923, 4457497, 3377935, -9796444, -30510046, 12935080, 1561737, 3841096, -29003639, -6657642 }, + { 10340844, -6630377, -18656632, -2278430, 12621151, -13339055, 30878497, -11824370, -25584551, 5181966 } + }, + { + { 25940115, -12658025, 17324188, -10307374, -8671468, 15029094, 24396252, -16450922, -2322852, -12388574 }, + { -21765684, 9916823, -1300409, 4079498, -1028346, 11909559, 1782390, 12641087, 20603771, -6561742 }, + { -18882287, -11673380, 24849422, 11501709, 13161720, -4768874, 1925523, 11914390, 4662781, 7820689 } + }, + { + { 12241050, -425982, 8132691, 9393934, 32846760, -1599620, 29749456, 12172924, 16136752, 15264020 }, + { -10349955, -14680563, -8211979, 2330220, -17662549, -14545780, 10658213, 6671822, 19012087, 3772772 }, + { 3753511, -3421066, 10617074, 2028709, 14841030, -6721664, 28718732, -15762884, 20527771, 12988982 } + }, + { + { -14822485, -5797269, -3707987, 12689773, -898983, -10914866, -24183046, -10564943, 3299665, -12424953 }, + { -16777703, -15253301, -9642417, 4978983, 3308785, 8755439, 6943197, 6461331, -25583147, 8991218 }, + { -17226263, 1816362, -1673288, -6086439, 31783888, -8175991, -32948145, 7417950, -30242287, 1507265 } + }, + { + { 29692663, 6829891, -10498800, 4334896, 20945975, -11906496, -28887608, 8209391, 14606362, -10647073 }, + { -3481570, 8707081, 32188102, 5672294, 22096700, 1711240, -33020695, 9761487, 4170404, -2085325 }, + { -11587470, 14855945, -4127778, -1531857, -26649089, 15084046, 22186522, 16002000, -14276837, -8400798 } + }, + { + { -4811456, 13761029, -31703877, -2483919, -3312471, 7869047, -7113572, -9620092, 13240845, 10965870 }, + { -7742563, -8256762, -14768334, -13656260, -23232383, 12387166, 4498947, 14147411, 29514390, 4302863 }, + { -13413405, -12407859, 20757302, -13801832, 14785143, 8976368, -5061276, -2144373, 17846988, -13971927 } + } +}, +{ /* 14/31 */ + { + { -2244452, -754728, -4597030, -1066309, -6247172, 1455299, -21647728, -9214789, -5222701, 12650267 }, + { -9906797, -16070310, 21134160, 12198166, -27064575, 708126, 387813, 13770293, -19134326, 10958663 }, + { 22470984, 12369526, 23446014, -5441109, -21520802, -9698723, -11772496, -11574455, -25083830, 4271862 } + }, + { + { -25169565, -10053642, -19909332, 15361595, -5984358, 2159192, 75375, -4278529, -32526221, 8469673 }, + { 15854970, 4148314, -8893890, 7259002, 11666551, 13824734, -30531198, 2697372, 24154791, -9460943 }, + { 15446137, -15806644, 29759747, 14019369, 30811221, -9610191, -31582008, 12840104, 24913809, 9815020 } + }, + { + { -4709286, -5614269, -31841498, -12288893, -14443537, 10799414, -9103676, 13438769, 18735128, 9466238 }, + { 11933045, 9281483, 5081055, -5183824, -2628162, -4905629, -7727821, -10896103, -22728655, 16199064 }, + { 14576810, 379472, -26786533, -8317236, -29426508, -10812974, -102766, 1876699, 30801119, 2164795 } + }, + { + { 15995086, 3199873, 13672555, 13712240, -19378835, -4647646, -13081610, -15496269, -13492807, 1268052 }, + { -10290614, -3659039, -3286592, 10948818, 23037027, 3794475, -3470338, -12600221, -17055369, 3565904 }, + { 29210088, -9419337, -5919792, -4952785, 10834811, -13327726, -16512102, -10820713, -27162222, -14030531 } + }, + { + { -13161890, 15508588, 16663704, -8156150, -28349942, 9019123, -29183421, -3769423, 2244111, -14001979 }, + { -5152875, -3800936, -9306475, -6071583, 16243069, 14684434, -25673088, -16180800, 13491506, 4641841 }, + { 10813417, 643330, -19188515, -728916, 30292062, -16600078, 27548447, -7721242, 14476989, -12767431 } + }, + { + { 10292079, 9984945, 6481436, 8279905, -7251514, 7032743, 27282937, -1644259, -27912810, 12651324 }, + { -31185513, -813383, 22271204, 11835308, 10201545, 15351028, 17099662, 3988035, 21721536, -3148940 }, + { 10202177, -6545839, -31373232, -9574638, -32150642, -8119683, -12906320, 3852694, 13216206, 14842320 } + }, + { + { -15815640, -10601066, -6538952, -7258995, -6984659, -6581778, -31500847, 13765824, -27434397, 9900184 }, + { 14465505, -13833331, -32133984, -14738873, -27443187, 12990492, 33046193, 15796406, -7051866, -8040114 }, + { 30924417, -8279620, 6359016, -12816335, 16508377, 9071735, -25488601, 15413635, 9524356, -7018878 } + }, + { + { 12274201, -13175547, 32627641, -1785326, 6736625, 13267305, 5237659, -5109483, 15663516, 4035784 }, + { -2951309, 8903985, 17349946, 601635, -16432815, -4612556, -13732739, -15889334, -22258478, 4659091 }, + { -16916263, -4952973, -30393711, -15158821, 20774812, 15897498, 5736189, 15026997, -2178256, -13455585 } + } +}, +{ /* 15/31 */ + { + { -8858980, -2219056, 28571666, -10155518, -474467, -10105698, -3801496, 278095, 23440562, -290208 }, + { 10226241, -5928702, 15139956, 120818, -14867693, 5218603, 32937275, 11551483, -16571960, -7442864 }, + { 17932739, -12437276, -24039557, 10749060, 11316803, 7535897, 22503767, 5561594, -3646624, 3898661 } + }, + { + { 7749907, -969567, -16339731, -16464, -25018111, 15122143, -1573531, 7152530, 21831162, 1245233 }, + { 26958459, -14658026, 4314586, 8346991, -5677764, 11960072, -32589295, -620035, -30402091, -16716212 }, + { -12165896, 9166947, 33491384, 13673479, 29787085, 13096535, 6280834, 14587357, -22338025, 13987525 } + }, + { + { -24349909, 7778775, 21116000, 15572597, -4833266, -5357778, -4300898, -5124639, -7469781, -2858068 }, + { 9681908, -6737123, -31951644, 13591838, -6883821, 386950, 31622781, 6439245, -14581012, 4091397 }, + { -8426427, 1470727, -28109679, -1596990, 3978627, -5123623, -19622683, 12092163, 29077877, -14741988 } + }, + { + { 5269168, -6859726, -13230211, -8020715, 25932563, 1763552, -5606110, -5505881, -20017847, 2357889 }, + { 32264008, -15407652, -5387735, -1160093, -2091322, -3946900, 23104804, -12869908, 5727338, 189038 }, + { 14609123, -8954470, -6000566, -16622781, -14577387, -7743898, -26745169, 10942115, -25888931, -14884697 } + }, + { + { 20513500, 5557931, -15604613, 7829531, 26413943, -2019404, -21378968, 7471781, 13913677, -5137875 }, + { -25574376, 11967826, 29233242, 12948236, -6754465, 4713227, -8940970, 14059180, 12878652, 8511905 }, + { -25656801, 3393631, -2955415, -7075526, -2250709, 9366908, -30223418, 6812974, 5568676, -3127656 } + }, + { + { 11630004, 12144454, 2116339, 13606037, 27378885, 15676917, -17408753, -13504373, -14395196, 8070818 }, + { 27117696, -10007378, -31282771, -5570088, 1127282, 12772488, -29845906, 10483306, -11552749, -1028714 }, + { 10637467, -5688064, 5674781, 1072708, -26343588, -6982302, -1683975, 9177853, -27493162, 15431203 } + }, + { + { 20525145, 10892566, -12742472, 12779443, -29493034, 16150075, -28240519, 14943142, -15056790, -7935931 }, + { -30024462, 5626926, -551567, -9981087, 753598, 11981191, 25244767, -3239766, -3356550, 9594024 }, + { -23752644, 2636870, -5163910, -10103818, 585134, 7877383, 11345683, -6492290, 13352335, -10977084 } + }, + { + { -1931799, -5407458, 3304649, -12884869, 17015806, -4877091, -29783850, -7752482, -13215537, -319204 }, + { 20239939, 6607058, 6203985, 3483793, -18386976, -779229, -20723742, 15077870, -22750759, 14523817 }, + { 27406042, -6041657, 27423596, -4497394, 4996214, 10002360, -28842031, -4545494, -30172742, -4805667 } + } +}, +{ /* 16/31 */ + { + { 11374242, 12660715, 17861383, -12540833, 10935568, 1099227, -13886076, -9091740, -27727044, 11358504 }, + { -12730809, 10311867, 1510375, 10778093, -2119455, -9145702, 32676003, 11149336, -26123651, 4985768 }, + { -19096303, 341147, -6197485, -239033, 15756973, -8796662, -983043, 13794114, -19414307, -15621255 } + }, + { + { 6490081, 11940286, 25495923, -7726360, 8668373, -8751316, 3367603, 6970005, -1691065, -9004790 }, + { 1656497, 13457317, 15370807, 6364910, 13605745, 8362338, -19174622, -5475723, -16796596, -5031438 }, + { -22273315, -13524424, -64685, -4334223, -18605636, -10921968, -20571065, -7007978, -99853, -10237333 } + }, + { + { 17747465, 10039260, 19368299, -4050591, -20630635, -16041286, 31992683, -15857976, -29260363, -5511971 }, + { 31932027, -4986141, -19612382, 16366580, 22023614, 88450, 11371999, -3744247, 4882242, -10626905 }, + { 29796507, 37186, 19818052, 10115756, -11829032, 3352736, 18551198, 3272828, -5190932, -4162409 } + }, + { + { 12501286, 4044383, -8612957, -13392385, -32430052, 5136599, -19230378, -3529697, 330070, -3659409 }, + { 6384877, 2899513, 17807477, 7663917, -2358888, 12363165, 25366522, -8573892, -271295, 12071499 }, + { -8365515, -4042521, 25133448, -4517355, -6211027, 2265927, -32769618, 1936675, -5159697, 3829363 } + }, + { + { 28425966, -5835433, -577090, -4697198, -14217555, 6870930, 7921550, -6567787, 26333140, 14267664 }, + { -11067219, 11871231, 27385719, -10559544, -4585914, -11189312, 10004786, -8709488, -21761224, 8930324 }, + { -21197785, -16396035, 25654216, -1725397, 12282012, 11008919, 1541940, 4757911, -26491501, -16408940 } + }, + { + { 13537262, -7759490, -20604840, 10961927, -5922820, -13218065, -13156584, 6217254, -15943699, 13814990 }, + { -17422573, 15157790, 18705543, 29619, 24409717, -260476, 27361681, 9257833, -1956526, -1776914 }, + { -25045300, -10191966, 15366585, 15166509, -13105086, 8423556, -29171540, 12361135, -18685978, 4578290 } + }, + { + { 24579768, 3711570, 1342322, -11180126, -27005135, 14124956, -22544529, 14074919, 21964432, 8235257 }, + { -6528613, -2411497, 9442966, -5925588, 12025640, -1487420, -2981514, -1669206, 13006806, 2355433 }, + { -16304899, -13605259, -6632427, -5142349, 16974359, -10911083, 27202044, 1719366, 1141648, -12796236 } + }, + { + { -12863944, -13219986, -8318266, -11018091, -6810145, -4843894, 13475066, -3133972, 32674895, 13715045 }, + { 11423335, -5468059, 32344216, 8962751, 24989809, 9241752, -13265253, 16086212, -28740881, -15642093 }, + { -1409668, 12530728, -6368726, 10847387, 19531186, -14132160, -11709148, 7791794, -27245943, 4383347 } + } +}, +{ /* 17/31 */ + { + { -28970898, 5271447, -1266009, -9736989, -12455236, 16732599, -4862407, -4906449, 27193557, 6245191 }, + { -15193956, 5362278, -1783893, 2695834, 4960227, 12840725, 23061898, 3260492, 22510453, 8577507 }, + { -12632451, 11257346, -32692994, 13548177, -721004, 10879011, 31168030, 13952092, -29571492, -3635906 } + }, + { + { 3877321, -9572739, 32416692, 5405324, -11004407, -13656635, 3759769, 11935320, 5611860, 8164018 }, + { -16275802, 14667797, 15906460, 12155291, -22111149, -9039718, 32003002, -8832289, 5773085, -8422109 }, + { -23788118, -8254300, 1950875, 8937633, 18686727, 16459170, -905725, 12376320, 31632953, 190926 } + }, + { + { -24593607, -16138885, -8423991, 13378746, 14162407, 6901328, -8288749, 4508564, -25341555, -3627528 }, + { 8884438, -5884009, 6023974, 10104341, -6881569, -4941533, 18722941, -14786005, -1672488, 827625 }, + { -32720583, -16289296, -32503547, 7101210, 13354605, 2659080, -1800575, -14108036, -24878478, 1541286 } + }, + { + { 2901347, -1117687, 3880376, -10059388, -17620940, -3612781, -21802117, -3567481, 20456845, -1885033 }, + { 27019610, 12299467, -13658288, -1603234, -12861660, -4861471, -19540150, -5016058, 29439641, 15138866 }, + { 21536104, -6626420, -32447818, -10690208, -22408077, 5175814, -5420040, -16361163, 7779328, 109896 } + }, + { + { 30279744, 14648750, -8044871, 6425558, 13639621, -743509, 28698390, 12180118, 23177719, -554075 }, + { 26572847, 3405927, -31701700, 12890905, -19265668, 5335866, -6493768, 2378492, 4439158, -13279347 }, + { -22716706, 3489070, -9225266, -332753, 18875722, -1140095, 14819434, -12731527, -17717757, -5461437 } + }, + { + { -5056483, 16566551, 15953661, 3767752, -10436499, 15627060, -820954, 2177225, 8550082, -15114165 }, + { -18473302, 16596775, -381660, 15663611, 22860960, 15585581, -27844109, -3582739, -23260460, -8428588 }, + { -32480551, 15707275, -8205912, -5652081, 29464558, 2713815, -22725137, 15860482, -21902570, 1494193 } + }, + { + { -19562091, -14087393, -25583872, -9299552, 13127842, 759709, 21923482, 16529112, 8742704, 12967017 }, + { -28464899, 1553205, 32536856, -10473729, -24691605, -406174, -8914625, -2933896, -29903758, 15553883 }, + { 21877909, 3230008, 9881174, 10539357, -4797115, 2841332, 11543572, 14513274, 19375923, -12647961 } + }, + { + { 8832269, -14495485, 13253511, 5137575, 5037871, 4078777, 24880818, -6222716, 2862653, 9455043 }, + { 29306751, 5123106, 20245049, -14149889, 9592566, 8447059, -2077124, -2990080, 15511449, 4789663 }, + { -20679756, 7004547, 8824831, -9434977, -4045704, -3750736, -5754762, 108893, 23513200, 16652362 } + } +}, +{ /* 18/31 */ + { + { -33256173, 4144782, -4476029, -6579123, 10770039, -7155542, -6650416, -12936300, -18319198, 10212860 }, + { 2756081, 8598110, 7383731, -6859892, 22312759, -1105012, 21179801, 2600940, -9988298, -12506466 }, + { -24645692, 13317462, -30449259, -15653928, 21365574, -10869657, 11344424, 864440, -2499677, -16710063 } + }, + { + { -26432803, 6148329, -17184412, -14474154, 18782929, -275997, -22561534, 211300, 2719757, 4940997 }, + { -1323882, 3911313, -6948744, 14759765, -30027150, 7851207, 21690126, 8518463, 26699843, 5276295 }, + { -13149873, -6429067, 9396249, 365013, 24703301, -10488939, 1321586, 149635, -15452774, 7159369 } + }, + { + { 9987780, -3404759, 17507962, 9505530, 9731535, -2165514, 22356009, 8312176, 22477218, -8403385 }, + { 18155857, -16504990, 19744716, 9006923, 15154154, -10538976, 24256460, -4864995, -22548173, 9334109 }, + { 2986088, -4911893, 10776628, -3473844, 10620590, -7083203, -21413845, 14253545, -22587149, 536906 } + }, + { + { 4377756, 8115836, 24567078, 15495314, 11625074, 13064599, 7390551, 10589625, 10838060, -15420424 }, + { -19342404, 867880, 9277171, -3218459, -14431572, -1986443, 19295826, -15796950, 6378260, 699185 }, + { 7895026, 4057113, -7081772, -13077756, -17886831, -323126, -716039, 15693155, -5045064, -13373962 } + }, + { + { -7737563, -5869402, -14566319, -7406919, 11385654, 13201616, 31730678, -10962840, -3918636, -9669325 }, + { 10188286, -15770834, -7336361, 13427543, 22223443, 14896287, 30743455, 7116568, -21786507, 5427593 }, + { 696102, 13206899, 27047647, -10632082, 15285305, -9853179, 10798490, -4578720, 19236243, 12477404 } + }, + { + { -11229439, 11243796, -17054270, -8040865, -788228, -8167967, -3897669, 11180504, -23169516, 7733644 }, + { 17800790, -14036179, -27000429, -11766671, 23887827, 3149671, 23466177, -10538171, 10322027, 15313801 }, + { 26246234, 11968874, 32263343, -5468728, 6830755, -13323031, -15794704, -101982, -24449242, 10890804 } + }, + { + { -31365647, 10271363, -12660625, -6267268, 16690207, -13062544, -14982212, 16484931, 25180797, -5334884 }, + { -586574, 10376444, -32586414, -11286356, 19801893, 10997610, 2276632, 9482883, 316878, 13820577 }, + { -9882808, -4510367, -2115506, 16457136, -11100081, 11674996, 30756178, -7515054, 30696930, -3712849 } + }, + { + { 32988917, -9603412, 12499366, 7910787, -10617257, -11931514, -7342816, -9985397, -32349517, 7392473 }, + { -8855661, 15927861, 9866406, -3649411, -2396914, -16655781, -30409476, -9134995, 25112947, -2926644 }, + { -2504044, -436966, 25621774, -5678772, 15085042, -5479877, -24884878, -13526194, 5537438, -13914319 } + } +}, +{ /* 19/31 */ + { + { -11225584, 2320285, -9584280, 10149187, -33444663, 5808648, -14876251, -1729667, 31234590, 6090599 }, + { -9633316, 116426, 26083934, 2897444, -6364437, -2688086, 609721, 15878753, -6970405, -9034768 }, + { -27757857, 247744, -15194774, -9002551, 23288161, -10011936, -23869595, 6503646, 20650474, 1804084 } + }, + { + { -27589786, 15456424, 8972517, 8469608, 15640622, 4439847, 3121995, -10329713, 27842616, -202328 }, + { -15306973, 2839644, 22530074, 10026331, 4602058, 5048462, 28248656, 5031932, -11375082, 12714369 }, + { 20807691, -7270825, 29286141, 11421711, -27876523, -13868230, -21227475, 1035546, -19733229, 12796920 } + }, + { + { 12076899, -14301286, -8785001, -11848922, -25012791, 16400684, -17591495, -12899438, 3480665, -15182815 }, + { -32361549, 5457597, 28548107, 7833186, 7303070, -11953545, -24363064, -15921875, -33374054, 2771025 }, + { -21389266, 421932, 26597266, 6860826, 22486084, -6737172, -17137485, -4210226, -24552282, 15673397 } + }, + { + { -20184622, 2338216, 19788685, -9620956, -4001265, -8740893, -20271184, 4733254, 3727144, -12934448 }, + { 6120119, 814863, -11794402, -622716, 6812205, -15747771, 2019594, 7975683, 31123697, -10958981 }, + { 30069250, -11435332, 30434654, 2958439, 18399564, -976289, 12296869, 9204260, -16432438, 9648165 } + }, + { + { 32705432, -1550977, 30705658, 7451065, -11805606, 9631813, 3305266, 5248604, -26008332, -11377501 }, + { 17219865, 2375039, -31570947, -5575615, -19459679, 9219903, 294711, 15298639, 2662509, -16297073 }, + { -1172927, -7558695, -4366770, -4287744, -21346413, -8434326, 32087529, -1222777, 32247248, -14389861 } + }, + { + { 14312628, 1221556, 17395390, -8700143, -4945741, -8684635, -28197744, -9637817, -16027623, -13378845 }, + { -1428825, -9678990, -9235681, 6549687, -7383069, -468664, 23046502, 9803137, 17597934, 2346211 }, + { 18510800, 15337574, 26171504, 981392, -22241552, 7827556, -23491134, -11323352, 3059833, -11782870 } + }, + { + { 10141598, 6082907, 17829293, -1947643, 9830092, 13613136, -25556636, -5544586, -33502212, 3592096 }, + { 33114168, -15889352, -26525686, -13343397, 33076705, 8716171, 1151462, 1521897, -982665, -6837803 }, + { -32939165, -4255815, 23947181, -324178, -33072974, -12305637, -16637686, 3891704, 26353178, 693168 } + }, + { + { 30374239, 1595580, -16884039, 13186931, 4600344, 406904, 9585294, -400668, 31375464, 14369965 }, + { -14370654, -7772529, 1510301, 6434173, -18784789, -6262728, 32732230, -13108839, 17901441, 16011505 }, + { 18171223, -11934626, -12500402, 15197122, -11038147, -15230035, -19172240, -16046376, 8764035, 12309598 } + } +}, +{ /* 20/31 */ + { + { 5975908, -5243188, -19459362, -9681747, -11541277, 14015782, -23665757, 1228319, 17544096, -10593782 }, + { 5811932, -1715293, 3442887, -2269310, -18367348, -8359541, -18044043, -15410127, -5565381, 12348900 }, + { -31399660, 11407555, 25755363, 6891399, -3256938, 14872274, -24849353, 8141295, -10632534, -585479 } + }, + { + { -12675304, 694026, -5076145, 13300344, 14015258, -14451394, -9698672, -11329050, 30944593, 1130208 }, + { 8247766, -6710942, -26562381, -7709309, -14401939, -14648910, 4652152, 2488540, 23550156, -271232 }, + { 17294316, -3788438, 7026748, 15626851, 22990044, 113481, 2267737, -5908146, -408818, -137719 } + }, + { + { 16091085, -16253926, 18599252, 7340678, 2137637, -1221657, -3364161, 14550936, 3260525, -7166271 }, + { -4910104, -13332887, 18550887, 10864893, -16459325, -7291596, -23028869, -13204905, -12748722, 2701326 }, + { -8574695, 16099415, 4629974, -16340524, -20786213, -6005432, -10018363, 9276971, 11329923, 1862132 } + }, + { + { 14763076, -15903608, -30918270, 3689867, 3511892, 10313526, -21951088, 12219231, -9037963, -940300 }, + { 8894987, -3446094, 6150753, 3013931, 301220, 15693451, -31981216, -2909717, -15438168, 11595570 }, + { 15214962, 3537601, -26238722, -14058872, 4418657, -15230761, 13947276, 10730794, -13489462, -4363670 } + }, + { + { -2538306, 7682793, 32759013, 263109, -29984731, -7955452, -22332124, -10188635, 977108, 699994 }, + { -12466472, 4195084, -9211532, 550904, -15565337, 12917920, 19118110, -439841, -30534533, -14337913 }, + { 31788461, -14507657, 4799989, 7372237, 8808585, -14747943, 9408237, -10051775, 12493932, -5409317 } + }, + { + { -25680606, 5260744, -19235809, -6284470, -3695942, 16566087, 27218280, 2607121, 29375955, 6024730 }, + { 842132, -2794693, -4763381, -8722815, 26332018, -12405641, 11831880, 6985184, -9940361, 2854096 }, + { -4847262, -7969331, 2516242, -5847713, 9695691, -7221186, 16512645, 960770, 12121869, 16648078 } + }, + { + { -15218652, 14667096, -13336229, 2013717, 30598287, -464137, -31504922, -7882064, 20237806, 2838411 }, + { -19288047, 4453152, 15298546, -16178388, 22115043, -15972604, 12544294, -13470457, 1068881, -12499905 }, + { -9558883, -16518835, 33238498, 13506958, 30505848, -1114596, -8486907, -2630053, 12521378, 4845654 } + }, + { + { -28198521, 10744108, -2958380, 10199664, 7759311, -13088600, 3409348, -873400, -6482306, -12885870 }, + { -23561822, 6230156, -20382013, 10655314, -24040585, -11621172, 10477734, -1240216, -3113227, 13974498 }, + { 12966261, 15550616, -32038948, -1615346, 21025980, -629444, 5642325, 7188737, 18895762, 12629579 } + } +}, +{ /* 21/31 */ + { + { 14741879, -14946887, 22177208, -11721237, 1279741, 8058600, 11758140, 789443, 32195181, 3895677 }, + { 10758205, 15755439, -4509950, 9243698, -4879422, 6879879, -2204575, -3566119, -8982069, 4429647 }, + { -2453894, 15725973, -20436342, -10410672, -5803908, -11040220, -7135870, -11642895, 18047436, -15281743 } + }, + { + { -25173001, -11307165, 29759956, 11776784, -22262383, -15820455, 10993114, -12850837, -17620701, -9408468 }, + { 21987233, 700364, -24505048, 14972008, -7774265, -5718395, 32155026, 2581431, -29958985, 8773375 }, + { -25568350, 454463, -13211935, 16126715, 25240068, 8594567, 20656846, 12017935, -7874389, -13920155 } + }, + { + { 6028182, 6263078, -31011806, -11301710, -818919, 2461772, -31841174, -5468042, -1721788, -2776725 }, + { -12278994, 16624277, 987579, -5922598, 32908203, 1248608, 7719845, -4166698, 28408820, 6816612 }, + { -10358094, -8237829, 19549651, -12169222, 22082623, 16147817, 20613181, 13982702, -10339570, 5067943 } + }, + { + { -30505967, -3821767, 12074681, 13582412, -19877972, 2443951, -19719286, 12746132, 5331210, -10105944 }, + { 30528811, 3601899, -1957090, 4619785, -27361822, -15436388, 24180793, -12570394, 27679908, -1648928 }, + { 9402404, -13957065, 32834043, 10838634, -26580150, -13237195, 26653274, -8685565, 22611444, -12715406 } + }, + { + { 22190590, 1118029, 22736441, 15130463, -30460692, -5991321, 19189625, -4648942, 4854859, 6622139 }, + { -8310738, -2953450, -8262579, -3388049, -10401731, -271929, 13424426, -3567227, 26404409, 13001963 }, + { -31241838, -15415700, -2994250, 8939346, 11562230, -12840670, -26064365, -11621720, -15405155, 11020693 } + }, + { + { 1866042, -7949489, -7898649, -10301010, 12483315, 13477547, 3175636, -12424163, 28761762, 1406734 }, + { -448555, -1777666, 13018551, 3194501, -9580420, -11161737, 24760585, -4347088, 25577411, -13378680 }, + { -24290378, 4759345, -690653, -1852816, 2066747, 10693769, -29595790, 9884936, -9368926, 4745410 } + }, + { + { -9141284, 6049714, -19531061, -4341411, -31260798, 9944276, -15462008, -11311852, 10931924, -11931931 }, + { -16561513, 14112680, -8012645, 4817318, -8040464, -11414606, -22853429, 10856641, -20470770, 13434654 }, + { 22759489, -10073434, -16766264, -1871422, 13637442, -10168091, 1765144, -12654326, 28445307, -5364710 } + }, + { + { 29875063, 12493613, 2795536, -3786330, 1710620, 15181182, -10195717, -8788675, 9074234, 1167180 }, + { -26205683, 11014233, -9842651, -2635485, -26908120, 7532294, -18716888, -9535498, 3843903, 9367684 }, + { -10969595, -6403711, 9591134, 9582310, 11349256, 108879, 16235123, 8601684, -139197, 4242895 } + } +}, +{ /* 22/31 */ + { + { 22092954, -13191123, -2042793, -11968512, 32186753, -11517388, -6574341, 2470660, -27417366, 16625501 }, + { -11057722, 3042016, 13770083, -9257922, 584236, -544855, -7770857, 2602725, -27351616, 14247413 }, + { 6314175, -10264892, -32772502, 15957557, -10157730, 168750, -8618807, 14290061, 27108877, -1180880 } + }, + { + { -8586597, -7170966, 13241782, 10960156, -32991015, -13794596, 33547976, -11058889, -27148451, 981874 }, + { 22833440, 9293594, -32649448, -13618667, -9136966, 14756819, -22928859, -13970780, -10479804, -16197962 }, + { -7768587, 3326786, -28111797, 10783824, 19178761, 14905060, 22680049, 13906969, -15933690, 3797899 } + }, + { + { 21721356, -4212746, -12206123, 9310182, -3882239, -13653110, 23740224, -2709232, 20491983, -8042152 }, + { 9209270, -15135055, -13256557, -6167798, -731016, 15289673, 25947805, 15286587, 30997318, -6703063 }, + { 7392032, 16618386, 23946583, -8039892, -13265164, -1533858, -14197445, -2321576, 17649998, -250080 } + }, + { + { -9301088, -14193827, 30609526, -3049543, -25175069, -1283752, -15241566, -9525724, -2233253, 7662146 }, + { -17558673, 1763594, -33114336, 15908610, -30040870, -12174295, 7335080, -8472199, -3174674, 3440183 }, + { -19889700, -5977008, -24111293, -9688870, 10799743, -16571957, 40450, -4431835, 4862400, 1133 } + }, + { + { -32856209, -7873957, -5422389, 14860950, -16319031, 7956142, 7258061, 311861, -30594991, -7379421 }, + { -3773428, -1565936, 28985340, 7499440, 24445838, 9325937, 29727763, 16527196, 18278453, 15405622 }, + { -4381906, 8508652, -19898366, -3674424, -5984453, 15149970, -13313598, 843523, -21875062, 13626197 } + }, + { + { 2281448, -13487055, -10915418, -2609910, 1879358, 16164207, -10783882, 3953792, 13340839, 15928663 }, + { 31727126, -7179855, -18437503, -8283652, 2875793, -16390330, -25269894, -7014826, -23452306, 5964753 }, + { 4100420, -5959452, -17179337, 6017714, -18705837, 12227141, -26684835, 11344144, 2538215, -7570755 } + }, + { + { -9433605, 6123113, 11159803, -2156608, 30016280, 14966241, -20474983, 1485421, -629256, -15958862 }, + { -26804558, 4260919, 11851389, 9658551, -32017107, 16367492, -20205425, -13191288, 11659922, -11115118 }, + { 26180396, 10015009, -30844224, -8581293, 5418197, 9480663, 2231568, -10170080, 33100372, -1306171 } + }, + { + { 15121113, -5201871, -10389905, 15427821, -27509937, -15992507, 21670947, 4486675, -5931810, -14466380 }, + { 16166486, -9483733, -11104130, 6023908, -31926798, -1364923, 2340060, -16254968, -10735770, -10039824 }, + { 28042865, -3557089, -12126526, 12259706, -3717498, -6945899, 6766453, -8689599, 18036436, 5803270 } + } +}, +{ /* 23/31 */ + { + { -817581, 6763912, 11803561, 1585585, 10958447, -2671165, 23855391, 4598332, -6159431, -14117438 }, + { -31031306, -14256194, 17332029, -2383520, 31312682, -5967183, 696309, 50292, -20095739, 11763584 }, + { -594563, -2514283, -32234153, 12643980, 12650761, 14811489, 665117, -12613632, -19773211, -10713562 } + }, + { + { 30464590, -11262872, -4127476, -12734478, 19835327, -7105613, -24396175, 2075773, -17020157, 992471 }, + { 18357185, -6994433, 7766382, 16342475, -29324918, 411174, 14578841, 8080033, -11574335, -10601610 }, + { 19598397, 10334610, 12555054, 2555664, 18821899, -10339780, 21873263, 16014234, 26224780, 16452269 } + }, + { + { -30223925, 5145196, 5944548, 16385966, 3976735, 2009897, -11377804, -7618186, -20533829, 3698650 }, + { 14187449, 3448569, -10636236, -10810935, -22663880, -3433596, 7268410, -10890444, 27394301, 12015369 }, + { 19695761, 16087646, 28032085, 12999827, 6817792, 11427614, 20244189, -1312777, -13259127, -3402461 } + }, + { + { 30860103, 12735208, -1888245, -4699734, -16974906, 2256940, -8166013, 12298312, -8550524, -10393462 }, + { -5719826, -11245325, -1910649, 15569035, 26642876, -7587760, -5789354, -15118654, -4976164, 12651793 }, + { -2848395, 9953421, 11531313, -5282879, 26895123, -12697089, -13118820, -16517902, 9768698, -2533218 } + }, + { + { -24719459, 1894651, -287698, -4704085, 15348719, -8156530, 32767513, 12765450, 4940095, 10678226 }, + { 18860224, 15980149, -18987240, -1562570, -26233012, -11071856, -7843882, 13944024, -24372348, 16582019 }, + { -15504260, 4970268, -29893044, 4175593, -20993212, -2199756, -11704054, 15444560, -11003761, 7989037 } + }, + { + { 31490452, 5568061, -2412803, 2182383, -32336847, 4531686, -32078269, 6200206, -19686113, -14800171 }, + { -17308668, -15879940, -31522777, -2831, -32887382, 16375549, 8680158, -16371713, 28550068, -6857132 }, + { -28126887, -5688091, 16837845, -1820458, -6850681, 12700016, -30039981, 4364038, 1155602, 5988841 } + }, + { + { 21890435, -13272907, -12624011, 12154349, -7831873, 15300496, 23148983, -4470481, 24618407, 8283181 }, + { -33136107, -10512751, 9975416, 6841041, -31559793, 16356536, 3070187, -7025928, 1466169, 10740210 }, + { -1509399, -15488185, -13503385, -10655916, 32799044, 909394, -13938903, -5779719, -32164649, -15327040 } + }, + { + { 3960823, -14267803, -28026090, -15918051, -19404858, 13146868, 15567327, 951507, -3260321, -573935 }, + { 24740841, 5052253, -30094131, 8961361, 25877428, 6165135, -24368180, 14397372, -7380369, -6144105 }, + { -28888365, 3510803, -28103278, -1158478, -11238128, -10631454, -15441463, -14453128, -1625486, -6494814 } + } +}, +{ /* 24/31 */ + { + { 793299, -9230478, 8836302, -6235707, -27360908, -2369593, 33152843, -4885251, -9906200, -621852 }, + { 5666233, 525582, 20782575, -8038419, -24538499, 14657740, 16099374, 1468826, -6171428, -15186581 }, + { -4859255, -3779343, -2917758, -6748019, 7778750, 11688288, -30404353, -9871238, -1558923, -9863646 } + }, + { + { 10896332, -7719704, 824275, 472601, -19460308, 3009587, 25248958, 14783338, -30581476, -15757844 }, + { 10566929, 12612572, -31944212, 11118703, -12633376, 12362879, 21752402, 8822496, 24003793, 14264025 }, + { 27713862, -7355973, -11008240, 9227530, 27050101, 2504721, 23886875, -13117525, 13958495, -5732453 } + }, + { + { -23481610, 4867226, -27247128, 3900521, 29838369, -8212291, -31889399, -10041781, 7340521, -15410068 }, + { 4646514, -8011124, -22766023, -11532654, 23184553, 8566613, 31366726, -1381061, -15066784, -10375192 }, + { -17270517, 12723032, -16993061, 14878794, 21619651, -6197576, 27584817, 3093888, -8843694, 3849921 } + }, + { + { -9064912, 2103172, 25561640, -15125738, -5239824, 9582958, 32477045, -9017955, 5002294, -15550259 }, + { -12057553, -11177906, 21115585, -13365155, 8808712, -12030708, 16489530, 13378448, -25845716, 12741426 }, + { -5946367, 10645103, -30911586, 15390284, -3286982, -7118677, 24306472, 15852464, 28834118, -7646072 } + }, + { + { -17335748, -9107057, -24531279, 9434953, -8472084, -583362, -13090771, 455841, 20461858, 5491305 }, + { 13669248, -16095482, -12481974, -10203039, -14569770, -11893198, -24995986, 11293807, -28588204, -9421832 }, + { 28497928, 6272777, -33022994, 14470570, 8906179, -1225630, 18504674, -14165166, 29867745, -8795943 } + }, + { + { -16207023, 13517196, -27799630, -13697798, 24009064, -6373891, -6367600, -13175392, 22853429, -4012011 }, + { 24191378, 16712145, -13931797, 15217831, 14542237, 1646131, 18603514, -11037887, 12876623, -2112447 }, + { 17902668, 4518229, -411702, -2829247, 26878217, 5258055, -12860753, 608397, 16031844, 3723494 } + }, + { + { -28632773, 12763728, -20446446, 7577504, 33001348, -13017745, 17558842, -7872890, 23896954, -4314245 }, + { -20005381, -12011952, 31520464, 605201, 2543521, 5991821, -2945064, 7229064, -9919646, -8826859 }, + { 28816045, 298879, -28165016, -15920938, 19000928, -1665890, -12680833, -2949325, -18051778, -2082915 } + }, + { + { 16000882, -344896, 3493092, -11447198, -29504595, -13159789, 12577740, 16041268, -19715240, 7847707 }, + { 10151868, 10572098, 27312476, 7922682, 14825339, 4723128, -32855931, -6519018, -10020567, 3852848 }, + { -11430470, 15697596, -21121557, -4420647, 5386314, 15063598, 16514493, -15932110, 29330899, -15076224 } + } +}, +{ /* 25/31 */ + { + { -25499735, -4378794, -15222908, -6901211, 16615731, 2051784, 3303702, 15490, -27548796, 12314391 }, + { 15683520, -6003043, 18109120, -9980648, 15337968, -5997823, -16717435, 15921866, 16103996, -3731215 }, + { -23169824, -10781249, 13588192, -1628807, -3798557, -1074929, -19273607, 5402699, -29815713, -9841101 } + }, + { + { 23190676, 2384583, -32714340, 3462154, -29903655, -1529132, -11266856, 8911517, -25205859, 2739713 }, + { 21374101, -3554250, -33524649, 9874411, 15377179, 11831242, -33529904, 6134907, 4931255, 11987849 }, + { -7732, -2978858, -16223486, 7277597, 105524, -322051, -31480539, 13861388, -30076310, 10117930 } + }, + { + { -29501170, -10744872, -26163768, 13051539, -25625564, 5089643, -6325503, 6704079, 12890019, 15728940 }, + { -21972360, -11771379, -951059, -4418840, 14704840, 2695116, 903376, -10428139, 12885167, 8311031 }, + { -17516482, 5352194, 10384213, -13811658, 7506451, 13453191, 26423267, 4384730, 1888765, -5435404 } + }, + { + { -25817338, -3107312, -13494599, -3182506, 30896459, -13921729, -32251644, -12707869, -19464434, -3340243 }, + { -23607977, -2665774, -526091, 4651136, 5765089, 4618330, 6092245, 14845197, 17151279, -9854116 }, + { -24830458, -12733720, -15165978, 10367250, -29530908, -265356, 22825805, -7087279, -16866484, 16176525 } + }, + { + { -23583256, 6564961, 20063689, 3798228, -4740178, 7359225, 2006182, -10363426, -28746253, -10197509 }, + { -10626600, -4486402, -13320562, -5125317, 3432136, -6393229, 23632037, -1940610, 32808310, 1099883 }, + { 15030977, 5768825, -27451236, -2887299, -6427378, -15361371, -15277896, -6809350, 2051441, -15225865 } + }, + { + { -3362323, -7239372, 7517890, 9824992, 23555850, 295369, 5148398, -14154188, -22686354, 16633660 }, + { 4577086, -16752288, 13249841, -15304328, 19958763, -14537274, 18559670, -10759549, 8402478, -9864273 }, + { -28406330, -1051581, -26790155, -907698, -17212414, -11030789, 9453451, -14980072, 17983010, 9967138 } + }, + { + { -25762494, 6524722, 26585488, 9969270, 24709298, 1220360, -1677990, 7806337, 17507396, 3651560 }, + { -10420457, -4118111, 14584639, 15971087, -15768321, 8861010, 26556809, -5574557, -18553322, -11357135 }, + { 2839101, 14284142, 4029895, 3472686, 14402957, 12689363, -26642121, 8459447, -5605463, -7621941 } + }, + { + { -4839289, -3535444, 9744961, 2871048, 25113978, 3187018, -25110813, -849066, 17258084, -7977739 }, + { 18164541, -10595176, -17154882, -1542417, 19237078, -9745295, 23357533, -15217008, 26908270, 12150756 }, + { -30264870, -7647865, 5112249, -7036672, -1499807, -6974257, 43168, -5537701, -32302074, 16215819 } + } +}, +{ /* 26/31 */ + { + { -6898905, 9824394, -12304779, -4401089, -31397141, -6276835, 32574489, 12532905, -7503072, -8675347 }, + { -27343522, -16515468, -27151524, -10722951, 946346, 16291093, 254968, 7168080, 21676107, -1943028 }, + { 21260961, -8424752, -16831886, -11920822, -23677961, 3968121, -3651949, -6215466, -3556191, -7913075 } + }, + { + { 16544754, 13250366, -16804428, 15546242, -4583003, 12757258, -2462308, -8680336, -18907032, -9662799 }, + { -2415239, -15577728, 18312303, 4964443, -15272530, -12653564, 26820651, 16690659, 25459437, -4564609 }, + { -25144690, 11425020, 28423002, -11020557, -6144921, -15826224, 9142795, -2391602, -6432418, -1644817 } + }, + { + { -23104652, 6253476, 16964147, -3768872, -25113972, -12296437, -27457225, -16344658, 6335692, 7249989 }, + { -30333227, 13979675, 7503222, -12368314, -11956721, -4621693, -30272269, 2682242, 25993170, -12478523 }, + { 4364628, 5930691, 32304656, -10044554, -8054781, 15091131, 22857016, -10598955, 31820368, 15075278 } + }, + { + { 31879134, -8918693, 17258761, 90626, -8041836, -4917709, 24162788, -9650886, -17970238, 12833045 }, + { 19073683, 14851414, -24403169, -11860168, 7625278, 11091125, -19619190, 2074449, -9413939, 14905377 }, + { 24483667, -11935567, -2518866, -11547418, -1553130, 15355506, -25282080, 9253129, 27628530, -7555480 } + }, + { + { 17597607, 8340603, 19355617, 552187, 26198470, -3176583, 4593324, -9157582, -14110875, 15297016 }, + { 510886, 14337390, -31785257, 16638632, 6328095, 2713355, -20217417, -11864220, 8683221, 2921426 }, + { 18606791, 11874196, 27155355, -5281482, -24031742, 6265446, -25178240, -1278924, 4674690, 13890525 } + }, + { + { 13609624, 13069022, -27372361, -13055908, 24360586, 9592974, 14977157, 9835105, 4389687, 288396 }, + { 9922506, -519394, 13613107, 5883594, -18758345, -434263, -12304062, 8317628, 23388070, 16052080 }, + { 12720016, 11937594, -31970060, -5028689, 26900120, 8561328, -20155687, -11632979, -14754271, -10812892 } + }, + { + { 15961858, 14150409, 26716931, -665832, -22794328, 13603569, 11829573, 7467844, -28822128, 929275 }, + { 11038231, -11582396, -27310482, -7316562, -10498527, -16307831, -23479533, -9371869, -21393143, 2465074 }, + { 20017163, -4323226, 27915242, 1529148, 12396362, 15675764, 13817261, -9658066, 2463391, -4622140 } + }, + { + { -16358878, -12663911, -12065183, 4996454, -1256422, 1073572, 9583558, 12851107, 4003896, 12673717 }, + { -1731589, -15155870, -3262930, 16143082, 19294135, 13385325, 14741514, -9103726, 7903886, 2348101 }, + { 24536016, -16515207, 12715592, -3862155, 1511293, 10047386, -3842346, -7129159, -28377538, 10048127 } + } +}, +{ /* 27/31 */ + { + { -12622226, -6204820, 30718825, 2591312, -10617028, 12192840, 18873298, -7297090, -32297756, 15221632 }, + { -26478122, -11103864, 11546244, -1852483, 9180880, 7656409, -21343950, 2095755, 29769758, 6593415 }, + { -31994208, -2907461, 4176912, 3264766, 12538965, -868111, 26312345, -6118678, 30958054, 8292160 } + }, + { + { 31429822, -13959116, 29173532, 15632448, 12174511, -2760094, 32808831, 3977186, 26143136, -3148876 }, + { 22648901, 1402143, -22799984, 13746059, 7936347, 365344, -8668633, -1674433, -3758243, -2304625 }, + { -15491917, 8012313, -2514730, -12702462, -23965846, -10254029, -1612713, -1535569, -16664475, 8194478 } + }, + { + { 27338066, -7507420, -7414224, 10140405, -19026427, -6589889, 27277191, 8855376, 28572286, 3005164 }, + { 26287124, 4821776, 25476601, -4145903, -3764513, -15788984, -18008582, 1182479, -26094821, -13079595 }, + { -7171154, 3178080, 23970071, 6201893, -17195577, -4489192, -21876275, -13982627, 32208683, -1198248 } + }, + { + { -16657702, 2817643, -10286362, 14811298, 6024667, 13349505, -27315504, -10497842, -27672585, -11539858 }, + { 15941029, -9405932, -21367050, 8062055, 31876073, -238629, -15278393, -1444429, 15397331, -4130193 }, + { 8934485, -13485467, -23286397, -13423241, -32446090, 14047986, 31170398, -1441021, -27505566, 15087184 } + }, + { + { -18357243, -2156491, 24524913, -16677868, 15520427, -6360776, -15502406, 11461896, 16788528, -5868942 }, + { -1947386, 16013773, 21750665, 3714552, -17401782, -16055433, -3770287, -10323320, 31322514, -11615635 }, + { 21426655, -5650218, -13648287, -5347537, -28812189, -4920970, -18275391, -14621414, 13040862, -12112948 } + }, + { + { 11293895, 12478086, -27136401, 15083750, -29307421, 14748872, 14555558, -13417103, 1613711, 4896935 }, + { -25894883, 15323294, -8489791, -8057900, 25967126, -13425460, 2825960, -4897045, -23971776, -11267415 }, + { -15924766, -5229880, -17443532, 6410664, 3622847, 10243618, 20615400, 12405433, -23753030, -8436416 } + }, + { + { -7091295, 12556208, -20191352, 9025187, -17072479, 4333801, 4378436, 2432030, 23097949, -566018 }, + { 4565804, -16025654, 20084412, -7842817, 1724999, 189254, 24767264, 10103221, -18512313, 2424778 }, + { 366633, -11976806, 8173090, -6890119, 30788634, 5745705, -7168678, 1344109, -3642553, 12412659 } + }, + { + { -24001791, 7690286, 14929416, -168257, -32210835, -13412986, 24162697, -15326504, -3141501, 11179385 }, + { 18289522, -14724954, 8056945, 16430056, -21729724, 7842514, -6001441, -1486897, -18684645, -11443503 }, + { 476239, 6601091, -6152790, -9723375, 17503545, -4863900, 27672959, 13403813, 11052904, 5219329 } + } +}, +{ /* 28/31 */ + { + { 20678546, -8375738, -32671898, 8849123, -5009758, 14574752, 31186971, -3973730, 9014762, -8579056 }, + { -13644050, -10350239, -15962508, 5075808, -1514661, -11534600, -33102500, 9160280, 8473550, -3256838 }, + { 24900749, 14435722, 17209120, -15292541, -22592275, 9878983, -7689309, -16335821, -24568481, 11788948 } + }, + { + { -3118155, -11395194, -13802089, 14797441, 9652448, -6845904, -20037437, 10410733, -24568470, -1458691 }, + { -15659161, 16736706, -22467150, 10215878, -9097177, 7563911, 11871841, -12505194, -18513325, 8464118 }, + { -23400612, 8348507, -14585951, -861714, -3950205, -6373419, 14325289, 8628612, 33313881, -8370517 } + }, + { + { -20186973, -4967935, 22367356, 5271547, -1097117, -4788838, -24805667, -10236854, -8940735, -5818269 }, + { -6948785, -1795212, -32625683, -16021179, 32635414, -7374245, 15989197, -12838188, 28358192, -4253904 }, + { -23561781, -2799059, -32351682, -1661963, -9147719, 10429267, -16637684, 4072016, -5351664, 5596589 } + }, + { + { -28236598, -3390048, 12312896, 6213178, 3117142, 16078565, 29266239, 2557221, 1768301, 15373193 }, + { -7243358, -3246960, -4593467, -7553353, -127927, -912245, -1090902, -4504991, -24660491, 3442910 }, + { -30210571, 5124043, 14181784, 8197961, 18964734, -11939093, 22597931, 7176455, -18585478, 13365930 } + }, + { + { -7877390, -1499958, 8324673, 4690079, 6261860, 890446, 24538107, -8570186, -9689599, -3031667 }, + { 25008904, -10771599, -4305031, -9638010, 16265036, 15721635, 683793, -11823784, 15723479, -15163481 }, + { -9660625, 12374379, -27006999, -7026148, -7724114, -12314514, 11879682, 5400171, 519526, -1235876 } + }, + { + { 22258397, -16332233, -7869817, 14613016, -22520255, -2950923, -20353881, 7315967, 16648397, 7605640 }, + { -8081308, -8464597, -8223311, 9719710, 19259459, -15348212, 23994942, -5281555, -9468848, 4763278 }, + { -21699244, 9220969, -15730624, 1084137, -25476107, -2852390, 31088447, -7764523, -11356529, 728112 } + }, + { + { 26047220, -11751471, -6900323, -16521798, 24092068, 9158119, -4273545, -12555558, -29365436, -5498272 }, + { 17510331, -322857, 5854289, 8403524, 17133918, -3112612, -28111007, 12327945, 10750447, 10014012 }, + { -10312768, 3936952, 9156313, -8897683, 16498692, -994647, -27481051, -666732, 3424691, 7540221 } + }, + { + { 30322361, -6964110, 11361005, -4143317, 7433304, 4989748, -7071422, -16317219, -9244265, 15258046 }, + { 13054562, -2779497, 19155474, 469045, -12482797, 4566042, 5631406, 2711395, 1062915, -5136345 }, + { -19240248, -11254599, -29509029, -7499965, -5835763, 13005411, -6066489, 12194497, 32960380, 1459310 } + } +}, +{ /* 29/31 */ + { + { 19852034, 7027924, 23669353, 10020366, 8586503, -6657907, 394197, -6101885, 18638003, -11174937 }, + { 31395534, 15098109, 26581030, 8030562, -16527914, -5007134, 9012486, -7584354, -6643087, -5442636 }, + { -9192165, -2347377, -1997099, 4529534, 25766844, 607986, -13222, 9677543, -32294889, -6456008 } + }, + { + { -2444496, -149937, 29348902, 8186665, 1873760, 12489863, -30934579, -7839692, -7852844, -8138429 }, + { -15236356, -15433509, 7766470, 746860, 26346930, -10221762, -27333451, 10754588, -9431476, 5203576 }, + { 31834314, 14135496, -770007, 5159118, 20917671, -16768096, -7467973, -7337524, 31809243, 7347066 } + }, + { + { -9606723, -11874240, 20414459, 13033986, 13716524, -11691881, 19797970, -12211255, 15192876, -2087490 }, + { -12663563, -2181719, 1168162, -3804809, 26747877, -14138091, 10609330, 12694420, 33473243, -13382104 }, + { 33184999, 11180355, 15832085, -11385430, -1633671, 225884, 15089336, -11023903, -6135662, 14480053 } + }, + { + { 31308717, -5619998, 31030840, -1897099, 15674547, -6582883, 5496208, 13685227, 27595050, 8737275 }, + { -20318852, -15150239, 10933843, -16178022, 8335352, -7546022, -31008351, -12610604, 26498114, 66511 }, + { 22644454, -8761729, -16671776, 4884562, -3105614, -13559366, 30540766, -4286747, -13327787, -7515095 } + }, + { + { -28017847, 9834845, 18617207, -2681312, -3401956, -13307506, 8205540, 13585437, -17127465, 15115439 }, + { 23711543, -672915, 31206561, -8362711, 6164647, -9709987, -33535882, -1426096, 8236921, 16492939 }, + { -23910559, -13515526, -26299483, -4503841, 25005590, -7687270, 19574902, 10071562, 6708380, -6222424 } + }, + { + { 2101391, -4930054, 19702731, 2367575, -15427167, 1047675, 5301017, 9328700, 29955601, -11678310 }, + { 3096359, 9271816, -21620864, -15521844, -14847996, -7592937, -25892142, -12635595, -9917575, 6216608 }, + { -32615849, 338663, -25195611, 2510422, -29213566, -13820213, 24822830, -6146567, -26767480, 7525079 } + }, + { + { -23066649, -13985623, 16133487, -7896178, -3389565, 778788, -910336, -2782495, -19386633, 11994101 }, + { 21691500, -13624626, -641331, -14367021, 3285881, -3483596, -25064666, 9718258, -7477437, 13381418 }, + { 18445390, -4202236, 14979846, 11622458, -1727110, -3582980, 23111648, -6375247, 28535282, 15779576 } + }, + { + { 30098053, 3089662, -9234387, 16662135, -21306940, 11308411, -14068454, 12021730, 9955285, -16303356 }, + { 9734894, -14576830, -7473633, -9138735, 2060392, 11313496, -18426029, 9924399, 20194861, 13380996 }, + { -26378102, -7965207, -22167821, 15789297, -18055342, -6168792, -1984914, 15707771, 26342023, 10146099 } + } +}, +{ /* 30/31 */ + { + { -26016874, -219943, 21339191, -41388, 19745256, -2878700, -29637280, 2227040, 21612326, -545728 }, + { -13077387, 1184228, 23562814, -5970442, -20351244, -6348714, 25764461, 12243797, -20856566, 11649658 }, + { -10031494, 11262626, 27384172, 2271902, 26947504, -15997771, 39944, 6114064, 33514190, 2333242 } + }, + { + { -21433588, -12421821, 8119782, 7219913, -21830522, -9016134, -6679750, -12670638, 24350578, -13450001 }, + { -4116307, -11271533, -23886186, 4843615, -30088339, 690623, -31536088, -10406836, 8317860, 12352766 }, + { 18200138, -14475911, -33087759, -2696619, -23702521, -9102511, -23552096, -2287550, 20712163, 6719373 } + }, + { + { 26656208, 6075253, -7858556, 1886072, -28344043, 4262326, 11117530, -3763210, 26224235, -3297458 }, + { -17168938, -14854097, -3395676, -16369877, -19954045, 14050420, 21728352, 9493610, 18620611, -16428628 }, + { -13323321, 13325349, 11432106, 5964811, 18609221, 6062965, -5269471, -9725556, -30701573, -16479657 } + }, + { + { -23860538, -11233159, 26961357, 1640861, -32413112, -16737940, 12248509, -5240639, 13735342, 1934062 }, + { 25089769, 6742589, 17081145, -13406266, 21909293, -16067981, -15136294, -3765346, -21277997, 5473616 }, + { 31883677, -7961101, 1083432, -11572403, 22828471, 13290673, -7125085, 12469656, 29111212, -5451014 } + }, + { + { 24244947, -15050407, -26262976, 2791540, -14997599, 16666678, 24367466, 6388839, -10295587, 452383 }, + { -25640782, -3417841, 5217916, 16224624, 19987036, -4082269, -24236251, -5915248, 15766062, 8407814 }, + { -20406999, 13990231, 15495425, 16395525, 5377168, 15166495, -8917023, -4388953, -8067909, 2276718 } + }, + { + { 30157918, 12924066, -17712050, 9245753, 19895028, 3368142, -23827587, 5096219, 22740376, -7303417 }, + { 2041139, -14256350, 7783687, 13876377, -25946985, -13352459, 24051124, 13742383, -15637599, 13295222 }, + { 33338237, -8505733, 12532113, 7977527, 9106186, -1715251, -17720195, -4612972, -4451357, -14669444 } + }, + { + { -20045281, 5454097, -14346548, 6447146, 28862071, 1883651, -2469266, -4141880, 7770569, 9620597 }, + { 23208068, 7979712, 33071466, 8149229, 1758231, -10834995, 30945528, -1694323, -33502340, -14767970 }, + { 1439958, -16270480, -1079989, -793782, 4625402, 10647766, -5043801, 1220118, 30494170, -11440799 } + }, + { + { -5037580, -13028295, -2970559, -3061767, 15640974, -6701666, -26739026, 926050, -1684339, -13333647 }, + { 13908495, -3549272, 30919928, -6273825, -21521863, 7989039, 9021034, 9078865, 3353509, 4033511 }, + { -29663431, -15113610, 32259991, -344482, 24295849, -12912123, 23161163, 8839127, 27485041, 7356032 } + } +}, +{ /* 31/31 */ + { + { 9661027, 705443, 11980065, -5370154, -1628543, 14661173, -6346142, 2625015, 28431036, -16771834 }, + { -23839233, -8311415, -25945511, 7480958, -17681669, -8354183, -22545972, 14150565, 15970762, 4099461 }, + { 29262576, 16756590, 26350592, -8793563, 8529671, -11208050, 13617293, -9937143, 11465739, 8317062 } + }, + { + { -25493081, -6962928, 32500200, -9419051, -23038724, -2302222, 14898637, 3848455, 20969334, -5157516 }, + { -20384450, -14347713, -18336405, 13884722, -33039454, 2842114, -21610826, -3649888, 11177095, 14989547 }, + { -24496721, -11716016, 16959896, 2278463, 12066309, 10137771, 13515641, 2581286, -28487508, 9930240 } + }, + { + { -17751622, -2097826, 16544300, -13009300, -15914807, -14949081, 18345767, -13403753, 16291481, -5314038 }, + { -33229194, 2553288, 32678213, 9875984, 8534129, 6889387, -9676774, 6957617, 4368891, 9788741 }, + { 16660756, 7281060, -10830758, 12911820, 20108584, -8101676, -21722536, -8613148, 16250552, -11111103 } + }, + { + { -19765507, 2390526, -16551031, 14161980, 1905286, 6414907, 4689584, 10604807, -30190403, 4782747 }, + { -1354539, 14736941, -7367442, -13292886, 7710542, -14155590, -9981571, 4383045, 22546403, 437323 }, + { 31665577, -12180464, -16186830, 1491339, -18368625, 3294682, 27343084, 2786261, -30633590, -14097016 } + }, + { + { -14467279, -683715, -33374107, 7448552, 19294360, 14334329, -19690631, 2355319, -19284671, -6114373 }, + { 15121312, -15796162, 6377020, -6031361, -10798111, -12957845, 18952177, 15496498, -29380133, 11754228 }, + { -2637277, -13483075, 8488727, -14303896, 12728761, -1622493, 7141596, 11724556, 22761615, -10134141 } + }, + { + { 16918416, 11729663, -18083579, 3022987, -31015732, -13339659, -28741185, -12227393, 32851222, 11717399 }, + { 11166634, 7338049, -6722523, 4531520, -29468672, -7302055, 31474879, 3483633, -1193175, -4030831 }, + { -185635, 9921305, 31456609, -13536438, -12013818, 13348923, 33142652, 6546660, -19985279, -3948376 } + }, + { + { -32460596, 11266712, -11197107, -7899103, 31703694, 3855903, -8537131, -12833048, -30772034, -15486313 }, + { -18006477, 12709068, 3991746, -6479188, -21491523, -10550425, -31135347, -16049879, 10928917, 3011958 }, + { -6957757, -15594337, 31696059, 334240, 29576716, 14796075, -30831056, -12805180, 18008031, 10258577 } + }, + { + { -22448644, 15655569, 7018479, -4410003, -30314266, -1201591, -1853465, 1367120, 25127874, 6671743 }, + { 29701166, -14373934, -10878120, 9279288, -17568, 13127210, 21382910, 11042292, 25838796, 4642684 }, + { -20430234, 14955537, -24126347, 8124619, -5369288, -5990470, 30468147, -13900640, 18423289, 4177476 } + } +} diff --git a/packages/runtime/vendor/libsodium/fe_25_5/base2.h b/packages/runtime/vendor/libsodium/fe_25_5/base2.h new file mode 100644 index 000000000..90a1457ea --- /dev/null +++ b/packages/runtime/vendor/libsodium/fe_25_5/base2.h @@ -0,0 +1,40 @@ +{ + { 25967493, -14356035, 29566456, 3660896, -12694345, 4014787, 27544626, -11754271, -6079156, 2047605 }, + { -12545711, 934262, -2722910, 3049990, -727428, 9406986, 12720692, 5043384, 19500929, -15469378 }, + { -8738181, 4489570, 9688441, -14785194, 10184609, -12363380, 29287919, 11864899, -24514362, -4438546 } +}, +{ + { 15636291, -9688557, 24204773, -7912398, 616977, -16685262, 27787600, -14772189, 28944400, -1550024 }, + { 16568933, 4717097, -11556148, -1102322, 15682896, -11807043, 16354577, -11775962, 7689662, 11199574 }, + { 30464156, -5976125, -11779434, -15670865, 23220365, 15915852, 7512774, 10017326, -17749093, -9920357 } +}, +{ + { 10861363, 11473154, 27284546, 1981175, -30064349, 12577861, 32867885, 14515107, -15438304, 10819380 }, + { 4708026, 6336745, 20377586, 9066809, -11272109, 6594696, -25653668, 12483688, -12668491, 5581306 }, + { 19563160, 16186464, -29386857, 4097519, 10237984, -4348115, 28542350, 13850243, -23678021, -15815942 } +}, +{ + { 5153746, 9909285, 1723747, -2777874, 30523605, 5516873, 19480852, 5230134, -23952439, -15175766 }, + { -30269007, -3463509, 7665486, 10083793, 28475525, 1649722, 20654025, 16520125, 30598449, 7715701 }, + { 28881845, 14381568, 9657904, 3680757, -20181635, 7843316, -31400660, 1370708, 29794553, -1409300 } +}, +{ + { -22518993, -6692182, 14201702, -8745502, -23510406, 8844726, 18474211, -1361450, -13062696, 13821877 }, + { -6455177, -7839871, 3374702, -4740862, -27098617, -10571707, 31655028, -7212327, 18853322, -14220951 }, + { 4566830, -12963868, -28974889, -12240689, -7602672, -2830569, -8514358, -10431137, 2207753, -3209784 } +}, +{ + { -25154831, -4185821, 29681144, 7868801, -6854661, -9423865, -12437364, -663000, -31111463, -16132436 }, + { 25576264, -2703214, 7349804, -11814844, 16472782, 9300885, 3844789, 15725684, 171356, 6466918 }, + { 23103977, 13316479, 9739013, -16149481, 817875, -15038942, 8965339, -14088058, -30714912, 16193877 } +}, +{ + { -33521811, 3180713, -2394130, 14003687, -16903474, -16270840, 17238398, 4729455, -18074513, 9256800 }, + { -25182317, -4174131, 32336398, 5036987, -21236817, 11360617, 22616405, 9761698, -19827198, 630305 }, + { -13720693, 2639453, -24237460, -7406481, 9494427, -5774029, -6554551, -15960994, -2449256, -14291300 } +}, +{ + { -3151181, -5046075, 9282714, 6866145, -31907062, -863023, -18940575, 15033784, 25105118, -7894876 }, + { -24326370, 15950226, -31801215, -14592823, -11662737, -5090925, 1573892, -2625887, 2198790, -15804619 }, + { -3099351, 10324967, -2241613, 7453183, -5446979, -2735503, -13812022, -16236442, -32461234, -12290683 } +} diff --git a/packages/runtime/vendor/libsodium/fe_25_5/constants.h b/packages/runtime/vendor/libsodium/fe_25_5/constants.h new file mode 100644 index 000000000..dd6da1b87 --- /dev/null +++ b/packages/runtime/vendor/libsodium/fe_25_5/constants.h @@ -0,0 +1,40 @@ +/* 37095705934669439343138083508754565189542113879843219016388785533085940283555 */ +static const fe25519 d = { + -10913610, 13857413, -15372611, 6949391, 114729, -8787816, -6275908, -3247719, -18696448, -12055116 +}; + +/* 2 * d = + * 16295367250680780974490674513165176452449235426866156013048779062215315747161 + */ +static const fe25519 d2 = { + -21827239, -5839606, -30745221, 13898782, 229458, 15978800, -12551817, -6495438, 29715968, 9444199 }; + +/* sqrt(-1) */ +static const fe25519 sqrtm1 = { + -32595792, -7943725, 9377950, 3500415, 12389472, -272473, -25146209, -2005654, 326686, 11406482 +}; + +/* A = 486662 */ +static const fe25519 curve25519_A = { + 486662, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +/* sqrt(ad - 1) with a = -1 (mod p) */ +static const fe25519 sqrtadm1 = { + 24849947, -153582, -23613485, 6347715, -21072328, -667138, -25271143, -15367704, -870347, 14525639 +}; + +/* 1 / sqrt(a - d) */ +static const fe25519 invsqrtamd = { + 6111485, 4156064, -27798727, 12243468, -25904040, 120897, 20826367, -7060776, 6093568, -1986012 +}; + +/* 1 - d ^ 2 */ +static const fe25519 onemsqd = { + 6275446, -16617371, -22938544, -3773710, 11667077, 7397348, -27922721, 1766195, -24433858, 672203 +}; + +/* (d - 1) ^ 2 */ +static const fe25519 sqdmone = { + 15551795, -11097455, -13425098, -10125071, -11896535, 10178284, -26634327, 4729244, -5282110, -10116402 +}; diff --git a/packages/runtime/vendor/libsodium/fe_25_5/fe.h b/packages/runtime/vendor/libsodium/fe_25_5/fe.h new file mode 100644 index 000000000..9e11afd11 --- /dev/null +++ b/packages/runtime/vendor/libsodium/fe_25_5/fe.h @@ -0,0 +1,220 @@ +/* + Ignores top bit of s. + */ + +void +fe25519_frombytes(fe25519 h, const unsigned char *s) +{ + int64_t h0 = load_4(s); + int64_t h1 = load_3(s + 4) << 6; + int64_t h2 = load_3(s + 7) << 5; + int64_t h3 = load_3(s + 10) << 3; + int64_t h4 = load_3(s + 13) << 2; + int64_t h5 = load_4(s + 16); + int64_t h6 = load_3(s + 20) << 7; + int64_t h7 = load_3(s + 23) << 5; + int64_t h8 = load_3(s + 26) << 4; + int64_t h9 = (load_3(s + 29) & 8388607) << 2; + + int64_t carry0; + int64_t carry1; + int64_t carry2; + int64_t carry3; + int64_t carry4; + int64_t carry5; + int64_t carry6; + int64_t carry7; + int64_t carry8; + int64_t carry9; + + carry9 = (h9 + (int64_t)(1L << 24)) >> 25; + h0 += carry9 * 19; + h9 -= carry9 * ((uint64_t) 1L << 25); + carry1 = (h1 + (int64_t)(1L << 24)) >> 25; + h2 += carry1; + h1 -= carry1 * ((uint64_t) 1L << 25); + carry3 = (h3 + (int64_t)(1L << 24)) >> 25; + h4 += carry3; + h3 -= carry3 * ((uint64_t) 1L << 25); + carry5 = (h5 + (int64_t)(1L << 24)) >> 25; + h6 += carry5; + h5 -= carry5 * ((uint64_t) 1L << 25); + carry7 = (h7 + (int64_t)(1L << 24)) >> 25; + h8 += carry7; + h7 -= carry7 * ((uint64_t) 1L << 25); + + carry0 = (h0 + (int64_t)(1L << 25)) >> 26; + h1 += carry0; + h0 -= carry0 * ((uint64_t) 1L << 26); + carry2 = (h2 + (int64_t)(1L << 25)) >> 26; + h3 += carry2; + h2 -= carry2 * ((uint64_t) 1L << 26); + carry4 = (h4 + (int64_t)(1L << 25)) >> 26; + h5 += carry4; + h4 -= carry4 * ((uint64_t) 1L << 26); + carry6 = (h6 + (int64_t)(1L << 25)) >> 26; + h7 += carry6; + h6 -= carry6 * ((uint64_t) 1L << 26); + carry8 = (h8 + (int64_t)(1L << 25)) >> 26; + h9 += carry8; + h8 -= carry8 * ((uint64_t) 1L << 26); + + h[0] = (int32_t) h0; + h[1] = (int32_t) h1; + h[2] = (int32_t) h2; + h[3] = (int32_t) h3; + h[4] = (int32_t) h4; + h[5] = (int32_t) h5; + h[6] = (int32_t) h6; + h[7] = (int32_t) h7; + h[8] = (int32_t) h8; + h[9] = (int32_t) h9; +} + +/* + Preconditions: + |h| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc. + + Write p=2^255-19; q=floor(h/p). + Basic claim: q = floor(2^(-255)(h + 19 2^(-25)h9 + 2^(-1))). + + Proof: + Have |h|<=p so |q|<=1 so |19^2 2^(-255) q|<1/4. + Also have |h-2^230 h9|<2^231 so |19 2^(-255)(h-2^230 h9)|<1/4. + + Write y=2^(-1)-19^2 2^(-255)q-19 2^(-255)(h-2^230 h9). + Then 0> 25; + q = (h0 + q) >> 26; + q = (h1 + q) >> 25; + q = (h2 + q) >> 26; + q = (h3 + q) >> 25; + q = (h4 + q) >> 26; + q = (h5 + q) >> 25; + q = (h6 + q) >> 26; + q = (h7 + q) >> 25; + q = (h8 + q) >> 26; + q = (h9 + q) >> 25; + + /* Goal: Output h-(2^255-19)q, which is between 0 and 2^255-20. */ + h0 += 19 * q; + /* Goal: Output h-2^255 q, which is between 0 and 2^255-20. */ + + carry0 = h0 >> 26; + h1 += carry0; + h0 -= carry0 * ((uint32_t) 1L << 26); + carry1 = h1 >> 25; + h2 += carry1; + h1 -= carry1 * ((uint32_t) 1L << 25); + carry2 = h2 >> 26; + h3 += carry2; + h2 -= carry2 * ((uint32_t) 1L << 26); + carry3 = h3 >> 25; + h4 += carry3; + h3 -= carry3 * ((uint32_t) 1L << 25); + carry4 = h4 >> 26; + h5 += carry4; + h4 -= carry4 * ((uint32_t) 1L << 26); + carry5 = h5 >> 25; + h6 += carry5; + h5 -= carry5 * ((uint32_t) 1L << 25); + carry6 = h6 >> 26; + h7 += carry6; + h6 -= carry6 * ((uint32_t) 1L << 26); + carry7 = h7 >> 25; + h8 += carry7; + h7 -= carry7 * ((uint32_t) 1L << 25); + carry8 = h8 >> 26; + h9 += carry8; + h8 -= carry8 * ((uint32_t) 1L << 26); + carry9 = h9 >> 25; + h9 -= carry9 * ((uint32_t) 1L << 25); + + h[0] = h0; + h[1] = h1; + h[2] = h2; + h[3] = h3; + h[4] = h4; + h[5] = h5; + h[6] = h6; + h[7] = h7; + h[8] = h8; + h[9] = h9; +} + +/* + Goal: Output h0+...+2^255 h10-2^255 q, which is between 0 and 2^255-20. + Have h0+...+2^230 h9 between 0 and 2^255-1; + evidently 2^255 h10-2^255 q = 0. + + Goal: Output h0+...+2^230 h9. + */ + +void +fe25519_tobytes(unsigned char *s, const fe25519 h) +{ + fe25519 t; + + fe25519_reduce(t, h); + s[0] = t[0] >> 0; + s[1] = t[0] >> 8; + s[2] = t[0] >> 16; + s[3] = (t[0] >> 24) | (t[1] * ((uint32_t) 1 << 2)); + s[4] = t[1] >> 6; + s[5] = t[1] >> 14; + s[6] = (t[1] >> 22) | (t[2] * ((uint32_t) 1 << 3)); + s[7] = t[2] >> 5; + s[8] = t[2] >> 13; + s[9] = (t[2] >> 21) | (t[3] * ((uint32_t) 1 << 5)); + s[10] = t[3] >> 3; + s[11] = t[3] >> 11; + s[12] = (t[3] >> 19) | (t[4] * ((uint32_t) 1 << 6)); + s[13] = t[4] >> 2; + s[14] = t[4] >> 10; + s[15] = t[4] >> 18; + s[16] = t[5] >> 0; + s[17] = t[5] >> 8; + s[18] = t[5] >> 16; + s[19] = (t[5] >> 24) | (t[6] * ((uint32_t) 1 << 1)); + s[20] = t[6] >> 7; + s[21] = t[6] >> 15; + s[22] = (t[6] >> 23) | (t[7] * ((uint32_t) 1 << 3)); + s[23] = t[7] >> 5; + s[24] = t[7] >> 13; + s[25] = (t[7] >> 21) | (t[8] * ((uint32_t) 1 << 4)); + s[26] = t[8] >> 4; + s[27] = t[8] >> 12; + s[28] = (t[8] >> 20) | (t[9] * ((uint32_t) 1 << 6)); + s[29] = t[9] >> 2; + s[30] = t[9] >> 10; + s[31] = t[9] >> 18; +} diff --git a/packages/runtime/vendor/libsodium/hash_sha512_cp.c b/packages/runtime/vendor/libsodium/hash_sha512_cp.c new file mode 100644 index 000000000..59a8b9368 --- /dev/null +++ b/packages/runtime/vendor/libsodium/hash_sha512_cp.c @@ -0,0 +1,284 @@ + +/*- + * Copyright 2005,2007,2009 Colin Percival + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + */ + +#include +#include +#include +#include + +#include + +#include "crypto_hash_sha512.h" +#include "common.h" +#include "utils.h" + +static void +be64enc_vect(unsigned char *dst, const uint64_t *src, size_t len) +{ + size_t i; + + for (i = 0; i < len / 8; i++) { + STORE64_BE(dst + i * 8, src[i]); + } +} + +static void +be64dec_vect(uint64_t *dst, const unsigned char *src, size_t len) +{ + size_t i; + + for (i = 0; i < len / 8; i++) { + dst[i] = LOAD64_BE(src + i * 8); + } +} + +static const uint64_t Krnd[80] = { + 0x428a2f98d728ae22ULL, 0x7137449123ef65cdULL, 0xb5c0fbcfec4d3b2fULL, + 0xe9b5dba58189dbbcULL, 0x3956c25bf348b538ULL, 0x59f111f1b605d019ULL, + 0x923f82a4af194f9bULL, 0xab1c5ed5da6d8118ULL, 0xd807aa98a3030242ULL, + 0x12835b0145706fbeULL, 0x243185be4ee4b28cULL, 0x550c7dc3d5ffb4e2ULL, + 0x72be5d74f27b896fULL, 0x80deb1fe3b1696b1ULL, 0x9bdc06a725c71235ULL, + 0xc19bf174cf692694ULL, 0xe49b69c19ef14ad2ULL, 0xefbe4786384f25e3ULL, + 0x0fc19dc68b8cd5b5ULL, 0x240ca1cc77ac9c65ULL, 0x2de92c6f592b0275ULL, + 0x4a7484aa6ea6e483ULL, 0x5cb0a9dcbd41fbd4ULL, 0x76f988da831153b5ULL, + 0x983e5152ee66dfabULL, 0xa831c66d2db43210ULL, 0xb00327c898fb213fULL, + 0xbf597fc7beef0ee4ULL, 0xc6e00bf33da88fc2ULL, 0xd5a79147930aa725ULL, + 0x06ca6351e003826fULL, 0x142929670a0e6e70ULL, 0x27b70a8546d22ffcULL, + 0x2e1b21385c26c926ULL, 0x4d2c6dfc5ac42aedULL, 0x53380d139d95b3dfULL, + 0x650a73548baf63deULL, 0x766a0abb3c77b2a8ULL, 0x81c2c92e47edaee6ULL, + 0x92722c851482353bULL, 0xa2bfe8a14cf10364ULL, 0xa81a664bbc423001ULL, + 0xc24b8b70d0f89791ULL, 0xc76c51a30654be30ULL, 0xd192e819d6ef5218ULL, + 0xd69906245565a910ULL, 0xf40e35855771202aULL, 0x106aa07032bbd1b8ULL, + 0x19a4c116b8d2d0c8ULL, 0x1e376c085141ab53ULL, 0x2748774cdf8eeb99ULL, + 0x34b0bcb5e19b48a8ULL, 0x391c0cb3c5c95a63ULL, 0x4ed8aa4ae3418acbULL, + 0x5b9cca4f7763e373ULL, 0x682e6ff3d6b2b8a3ULL, 0x748f82ee5defb2fcULL, + 0x78a5636f43172f60ULL, 0x84c87814a1f0ab72ULL, 0x8cc702081a6439ecULL, + 0x90befffa23631e28ULL, 0xa4506cebde82bde9ULL, 0xbef9a3f7b2c67915ULL, + 0xc67178f2e372532bULL, 0xca273eceea26619cULL, 0xd186b8c721c0c207ULL, + 0xeada7dd6cde0eb1eULL, 0xf57d4f7fee6ed178ULL, 0x06f067aa72176fbaULL, + 0x0a637dc5a2c898a6ULL, 0x113f9804bef90daeULL, 0x1b710b35131c471bULL, + 0x28db77f523047d84ULL, 0x32caab7b40c72493ULL, 0x3c9ebe0a15c9bebcULL, + 0x431d67c49c100d4cULL, 0x4cc5d4becb3e42b6ULL, 0x597f299cfc657e2aULL, + 0x5fcb6fab3ad6faecULL, 0x6c44198c4a475817ULL +}; + +#define Ch(x, y, z) ((x & (y ^ z)) ^ z) +#define Maj(x, y, z) ((x & (y | z)) | (y & z)) +#define SHR(x, n) (x >> n) +#define ROTR(x, n) ROTR64(x, n) +#define S0(x) (ROTR(x, 28) ^ ROTR(x, 34) ^ ROTR(x, 39)) +#define S1(x) (ROTR(x, 14) ^ ROTR(x, 18) ^ ROTR(x, 41)) +#define s0(x) (ROTR(x, 1) ^ ROTR(x, 8) ^ SHR(x, 7)) +#define s1(x) (ROTR(x, 19) ^ ROTR(x, 61) ^ SHR(x, 6)) + +#define RND(a, b, c, d, e, f, g, h, k) \ + h += S1(e) + Ch(e, f, g) + k; \ + d += h; \ + h += S0(a) + Maj(a, b, c); + +#define RNDr(S, W, i, ii) \ + RND(S[(80 - i) % 8], S[(81 - i) % 8], S[(82 - i) % 8], S[(83 - i) % 8], \ + S[(84 - i) % 8], S[(85 - i) % 8], S[(86 - i) % 8], S[(87 - i) % 8], \ + W[i + ii] + Krnd[i + ii]) + +#define MSCH(W, ii, i) \ + W[i + ii + 16] = \ + s1(W[i + ii + 14]) + W[i + ii + 9] + s0(W[i + ii + 1]) + W[i + ii] + +static void +SHA512_Transform(uint64_t *state, const uint8_t block[128], uint64_t W[80], + uint64_t S[8]) +{ + int i; + + be64dec_vect(W, block, 128); + memcpy(S, state, 64); + for (i = 0; i < 80; i += 16) { + RNDr(S, W, 0, i); + RNDr(S, W, 1, i); + RNDr(S, W, 2, i); + RNDr(S, W, 3, i); + RNDr(S, W, 4, i); + RNDr(S, W, 5, i); + RNDr(S, W, 6, i); + RNDr(S, W, 7, i); + RNDr(S, W, 8, i); + RNDr(S, W, 9, i); + RNDr(S, W, 10, i); + RNDr(S, W, 11, i); + RNDr(S, W, 12, i); + RNDr(S, W, 13, i); + RNDr(S, W, 14, i); + RNDr(S, W, 15, i); + if (i == 64) { + break; + } + MSCH(W, 0, i); + MSCH(W, 1, i); + MSCH(W, 2, i); + MSCH(W, 3, i); + MSCH(W, 4, i); + MSCH(W, 5, i); + MSCH(W, 6, i); + MSCH(W, 7, i); + MSCH(W, 8, i); + MSCH(W, 9, i); + MSCH(W, 10, i); + MSCH(W, 11, i); + MSCH(W, 12, i); + MSCH(W, 13, i); + MSCH(W, 14, i); + MSCH(W, 15, i); + } + for (i = 0; i < 8; i++) { + state[i] += S[i]; + } +} + +static const uint8_t PAD[128] = { + 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static void +SHA512_Pad(crypto_hash_sha512_state *state, uint64_t tmp64[80 + 8]) +{ + unsigned int r; + unsigned int i; + + ACQUIRE_FENCE; + r = (unsigned int) ((state->count[1] >> 3) & 0x7f); + if (r < 112) { + for (i = 0; i < 112 - r; i++) { + state->buf[r + i] = PAD[i]; + } + } else { + for (i = 0; i < 128 - r; i++) { + state->buf[r + i] = PAD[i]; + } + SHA512_Transform(state->state, state->buf, &tmp64[0], &tmp64[80]); + memset(&state->buf[0], 0, 112); + } + be64enc_vect(&state->buf[112], state->count, 16); + SHA512_Transform(state->state, state->buf, &tmp64[0], &tmp64[80]); +} + +int +crypto_hash_sha512_init(crypto_hash_sha512_state *state) +{ + static const uint64_t sha512_initial_state[8] = { + 0x6a09e667f3bcc908ULL, 0xbb67ae8584caa73bULL, 0x3c6ef372fe94f82bULL, + 0xa54ff53a5f1d36f1ULL, 0x510e527fade682d1ULL, 0x9b05688c2b3e6c1fULL, + 0x1f83d9abfb41bd6bULL, 0x5be0cd19137e2179ULL + }; + + state->count[0] = state->count[1] = (uint64_t) 0U; + memcpy(state->state, sha512_initial_state, sizeof sha512_initial_state); + + return 0; +} + +int +crypto_hash_sha512_update(crypto_hash_sha512_state *state, + const unsigned char *in, unsigned long long inlen) +{ + uint64_t tmp64[80 + 8]; + uint64_t bitlen[2]; + unsigned long long i; + unsigned long long r; + + if (inlen <= 0U) { + return 0; + } + ACQUIRE_FENCE; + r = (unsigned long long) ((state->count[1] >> 3) & 0x7f); + + bitlen[1] = ((uint64_t) inlen) << 3; + bitlen[0] = ((uint64_t) inlen) >> 61; + /* LCOV_EXCL_START */ + if ((state->count[1] += bitlen[1]) < bitlen[1]) { + state->count[0]++; + } + /* LCOV_EXCL_STOP */ + state->count[0] += bitlen[0]; + if (inlen < 128 - r) { + for (i = 0; i < inlen; i++) { + state->buf[r + i] = in[i]; + } + return 0; + } + for (i = 0; i < 128 - r; i++) { + state->buf[r + i] = in[i]; + } + SHA512_Transform(state->state, state->buf, &tmp64[0], &tmp64[80]); + in += 128 - r; + inlen -= 128 - r; + + while (inlen >= 128) { + SHA512_Transform(state->state, in, &tmp64[0], &tmp64[80]); + in += 128; + inlen -= 128; + } + inlen &= 127; + for (i = 0; i < inlen; i++) { + state->buf[i] = in[i]; + } + sodium_memzero((void *) tmp64, sizeof tmp64); + + return 0; +} + +int +crypto_hash_sha512_final(crypto_hash_sha512_state *state, unsigned char *out) +{ + uint64_t tmp64[80 + 8]; + + SHA512_Pad(state, tmp64); + be64enc_vect(out, state->state, 64); + sodium_memzero((void *) tmp64, sizeof tmp64); + sodium_memzero((void *) state, sizeof *state); + + return 0; +} + +int +crypto_hash_sha512(unsigned char *out, const unsigned char *in, + unsigned long long inlen) +{ + crypto_hash_sha512_state state; + + crypto_hash_sha512_init(&state); + crypto_hash_sha512_update(&state, in, inlen); + crypto_hash_sha512_final(&state, out); + + return 0; +} diff --git a/packages/runtime/vendor/libsodium/keypair.c b/packages/runtime/vendor/libsodium/keypair.c new file mode 100644 index 000000000..18059adfe --- /dev/null +++ b/packages/runtime/vendor/libsodium/keypair.c @@ -0,0 +1,84 @@ + +#include + +#include "crypto_hash_sha512.h" +#include "crypto_scalarmult_curve25519.h" +#include "crypto_sign_ed25519.h" +#include "sign_ed25519_ref10.h" +#include "ed25519_ref10.h" +#include "randombytes.h" +#include "utils.h" + +int +crypto_sign_ed25519_seed_keypair(unsigned char *pk, unsigned char *sk, + const unsigned char *seed) +{ + ge25519_p3 A; + + crypto_hash_sha512(sk, seed, 32); + sk[0] &= 248; + sk[31] &= 127; + sk[31] |= 64; + + ge25519_scalarmult_base(&A, sk); + ge25519_p3_tobytes(pk, &A); + + memmove(sk, seed, 32); + memmove(sk + 32, pk, 32); + + return 0; +} + +int +crypto_sign_ed25519_keypair(unsigned char *pk, unsigned char *sk) +{ + unsigned char seed[32]; + int ret; + + randombytes_buf(seed, sizeof seed); + ret = crypto_sign_ed25519_seed_keypair(pk, sk, seed); + sodium_memzero(seed, sizeof seed); + + return ret; +} + +int +crypto_sign_ed25519_pk_to_curve25519(unsigned char *curve25519_pk, + const unsigned char *ed25519_pk) +{ + ge25519_p3 A; + fe25519 x; + fe25519 one_minus_y; + + if (ge25519_has_small_order(ed25519_pk) != 0 || + ge25519_frombytes_negate_vartime(&A, ed25519_pk) != 0 || + ge25519_is_on_main_subgroup(&A) == 0) { + return -1; + } + fe25519_1(one_minus_y); + /* assumes A.Z=1 */ + fe25519_sub(one_minus_y, one_minus_y, A.Y); + fe25519_1(x); + fe25519_add(x, x, A.Y); + fe25519_invert(one_minus_y, one_minus_y); + fe25519_mul(x, x, one_minus_y); + fe25519_tobytes(curve25519_pk, x); + + return 0; +} + +int +crypto_sign_ed25519_sk_to_curve25519(unsigned char *curve25519_sk, + const unsigned char *ed25519_sk) +{ + unsigned char h[crypto_hash_sha512_BYTES]; + + crypto_hash_sha512(h, ed25519_sk, 32); + h[0] &= 248; + h[31] &= 127; + h[31] |= 64; + memcpy(curve25519_sk, h, crypto_scalarmult_curve25519_BYTES); + sodium_memzero(h, sizeof h); + + return 0; +} diff --git a/packages/runtime/vendor/libsodium/open.c b/packages/runtime/vendor/libsodium/open.c new file mode 100644 index 000000000..0670866d6 --- /dev/null +++ b/packages/runtime/vendor/libsodium/open.c @@ -0,0 +1,98 @@ + +#include +#include +#include + +#include "crypto_hash_sha512.h" +#include "crypto_sign_ed25519.h" +#include "crypto_verify_32.h" +#include "sign_ed25519_ref10.h" +#include "common.h" +#include "ed25519_ref10.h" +#include "utils.h" + +int +_crypto_sign_ed25519_verify_detached(const unsigned char *sig, + const unsigned char *m, + unsigned long long mlen, + const unsigned char *pk, + int prehashed) +{ + crypto_hash_sha512_state hs; + unsigned char h[64]; + unsigned char rcheck[32]; + ge25519_p3 A; + ge25519_p2 R; + + ACQUIRE_FENCE; +#ifdef ED25519_COMPAT + if (sig[63] & 224) { + return -1; + } +#else + if (sc25519_is_canonical(sig + 32) == 0 || + ge25519_has_small_order(sig) != 0) { + return -1; + } + if (ge25519_is_canonical(pk) == 0 || + ge25519_has_small_order(pk) != 0) { + return -1; + } +#endif + if (ge25519_frombytes_negate_vartime(&A, pk) != 0) { + return -1; + } + _crypto_sign_ed25519_ref10_hinit(&hs, prehashed); + crypto_hash_sha512_update(&hs, sig, 32); + crypto_hash_sha512_update(&hs, pk, 32); + crypto_hash_sha512_update(&hs, m, mlen); + crypto_hash_sha512_final(&hs, h); + sc25519_reduce(h); + + ge25519_double_scalarmult_vartime(&R, h, &A, sig + 32); + ge25519_tobytes(rcheck, &R); + + return crypto_verify_32(rcheck, sig) | (-(rcheck == sig)) | + sodium_memcmp(sig, rcheck, 32); +} + +int +crypto_sign_ed25519_verify_detached(const unsigned char *sig, + const unsigned char *m, + unsigned long long mlen, + const unsigned char *pk) +{ + return _crypto_sign_ed25519_verify_detached(sig, m, mlen, pk, 0); +} + +int +crypto_sign_ed25519_open(unsigned char *m, unsigned long long *mlen_p, + const unsigned char *sm, unsigned long long smlen, + const unsigned char *pk) +{ + unsigned long long mlen; + + if (smlen < 64 || smlen - 64 > crypto_sign_ed25519_MESSAGEBYTES_MAX) { + goto badsig; + } + mlen = smlen - 64; + if (crypto_sign_ed25519_verify_detached(sm, sm + 64, mlen, pk) != 0) { + if (m != NULL) { + memset(m, 0, mlen); + } + goto badsig; + } + if (mlen_p != NULL) { + *mlen_p = mlen; + } + if (m != NULL) { + memmove(m, sm + 64, mlen); + } + return 0; + +badsig: + if (mlen_p != NULL) { + *mlen_p = 0; + } + return -1; +} diff --git a/packages/runtime/vendor/libsodium/randombytes.h b/packages/runtime/vendor/libsodium/randombytes.h new file mode 100644 index 000000000..c83a4df50 --- /dev/null +++ b/packages/runtime/vendor/libsodium/randombytes.h @@ -0,0 +1,72 @@ + +#ifndef randombytes_H +#define randombytes_H + +#include +#include + +#include + +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +typedef struct randombytes_implementation { + const char *(*implementation_name)(void); /* required */ + uint32_t (*random)(void); /* required */ + void (*stir)(void); /* optional */ + uint32_t (*uniform)(const uint32_t upper_bound); /* optional, a default implementation will be used if NULL */ + void (*buf)(void * const buf, const size_t size); /* required */ + int (*close)(void); /* optional */ +} randombytes_implementation; + +#define randombytes_BYTES_MAX SODIUM_MIN(SODIUM_SIZE_MAX, 0xffffffffUL) + +#define randombytes_SEEDBYTES 32U +SODIUM_EXPORT +size_t randombytes_seedbytes(void); + +SODIUM_EXPORT +void randombytes_buf(void * const buf, const size_t size) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +void randombytes_buf_deterministic(void * const buf, const size_t size, + const unsigned char seed[randombytes_SEEDBYTES]) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +uint32_t randombytes_random(void); + +SODIUM_EXPORT +uint32_t randombytes_uniform(const uint32_t upper_bound); + +SODIUM_EXPORT +void randombytes_stir(void); + +SODIUM_EXPORT +int randombytes_close(void); + +SODIUM_EXPORT +int randombytes_set_implementation(const randombytes_implementation *impl) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +const char *randombytes_implementation_name(void); + +/* -- NaCl compatibility interface -- */ + +SODIUM_EXPORT +void randombytes(unsigned char * const buf, const unsigned long long buf_len) + __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/packages/runtime/vendor/libsodium/sign.c b/packages/runtime/vendor/libsodium/sign.c new file mode 100644 index 000000000..1b4a2923c --- /dev/null +++ b/packages/runtime/vendor/libsodium/sign.c @@ -0,0 +1,128 @@ + +#include + +#include "crypto_hash_sha512.h" +#include "crypto_sign_ed25519.h" +#include "sign_ed25519_ref10.h" +#include "ed25519_ref10.h" +#include "randombytes.h" +#include "utils.h" + +void +_crypto_sign_ed25519_ref10_hinit(crypto_hash_sha512_state *hs, int prehashed) +{ + static const unsigned char DOM2PREFIX[32 + 2] = { + 'S', 'i', 'g', 'E', 'd', '2', '5', '5', '1', '9', ' ', + 'n', 'o', ' ', + 'E', 'd', '2', '5', '5', '1', '9', ' ', + 'c', 'o', 'l', 'l', 'i', 's', 'i', 'o', 'n', 's', 1, 0 + }; + + crypto_hash_sha512_init(hs); + if (prehashed) { + crypto_hash_sha512_update(hs, DOM2PREFIX, sizeof DOM2PREFIX); + } +} + +static inline void +_crypto_sign_ed25519_clamp(unsigned char k[32]) +{ + k[0] &= 248; + k[31] &= 127; + k[31] |= 64; +} + +#ifdef ED25519_NONDETERMINISTIC +/* r = hash(k || K || noise || pad || M) (mod q) */ +static void +_crypto_sign_ed25519_synthetic_r_hv(crypto_hash_sha512_state *hs, + unsigned char tmp[64], + const unsigned char az[64]) +{ + crypto_hash_sha512_update(hs, az, 64); + randombytes_buf(tmp, 32); + memset(tmp + 32, 0, 32); + crypto_hash_sha512_update(hs, tmp, 64); +} +#endif + +int +_crypto_sign_ed25519_detached(unsigned char *sig, unsigned long long *siglen_p, + const unsigned char *m, unsigned long long mlen, + const unsigned char *sk, int prehashed) +{ + crypto_hash_sha512_state hs; + unsigned char az[64]; + unsigned char nonce[64]; + unsigned char hram[64]; + ge25519_p3 R; + + _crypto_sign_ed25519_ref10_hinit(&hs, prehashed); + + crypto_hash_sha512(az, sk, 32); +#ifdef ED25519_NONDETERMINISTIC + _crypto_sign_ed25519_synthetic_r_hv(&hs, nonce /* tmp */, az); +#else + crypto_hash_sha512_update(&hs, az + 32, 32); +#endif + + crypto_hash_sha512_update(&hs, m, mlen); + crypto_hash_sha512_final(&hs, nonce); + + memmove(sig + 32, sk + 32, 32); + + sc25519_reduce(nonce); + ge25519_scalarmult_base(&R, nonce); + ge25519_p3_tobytes(sig, &R); + + _crypto_sign_ed25519_ref10_hinit(&hs, prehashed); + crypto_hash_sha512_update(&hs, sig, 64); + crypto_hash_sha512_update(&hs, m, mlen); + crypto_hash_sha512_final(&hs, hram); + + sc25519_reduce(hram); + _crypto_sign_ed25519_clamp(az); + sc25519_muladd(sig + 32, hram, az, nonce); + + sodium_memzero(az, sizeof az); + sodium_memzero(nonce, sizeof nonce); + + if (siglen_p != NULL) { + *siglen_p = 64U; + } + return 0; +} + +int +crypto_sign_ed25519_detached(unsigned char *sig, unsigned long long *siglen_p, + const unsigned char *m, unsigned long long mlen, + const unsigned char *sk) +{ + return _crypto_sign_ed25519_detached(sig, siglen_p, m, mlen, sk, 0); +} + +int +crypto_sign_ed25519(unsigned char *sm, unsigned long long *smlen_p, + const unsigned char *m, unsigned long long mlen, + const unsigned char *sk) +{ + unsigned long long siglen; + + memmove(sm + crypto_sign_ed25519_BYTES, m, mlen); + /* LCOV_EXCL_START */ + if (crypto_sign_ed25519_detached( + sm, &siglen, sm + crypto_sign_ed25519_BYTES, mlen, sk) != 0 || + siglen != crypto_sign_ed25519_BYTES) { + if (smlen_p != NULL) { + *smlen_p = 0; + } + memset(sm, 0, mlen + crypto_sign_ed25519_BYTES); + return -1; + } + /* LCOV_EXCL_STOP */ + + if (smlen_p != NULL) { + *smlen_p = mlen + siglen; + } + return 0; +} diff --git a/packages/runtime/vendor/libsodium/sign_ed25519_ref10.h b/packages/runtime/vendor/libsodium/sign_ed25519_ref10.h new file mode 100644 index 000000000..29f45a854 --- /dev/null +++ b/packages/runtime/vendor/libsodium/sign_ed25519_ref10.h @@ -0,0 +1,18 @@ +#ifndef sign_ed25519_ref10_H +#define sign_ed25519_ref10_H + +void _crypto_sign_ed25519_ref10_hinit(crypto_hash_sha512_state *hs, + int prehashed); + +int _crypto_sign_ed25519_detached(unsigned char *sig, + unsigned long long *siglen_p, + const unsigned char *m, + unsigned long long mlen, + const unsigned char *sk, int prehashed); + +int _crypto_sign_ed25519_verify_detached(const unsigned char *sig, + const unsigned char *m, + unsigned long long mlen, + const unsigned char *pk, + int prehashed); +#endif diff --git a/packages/runtime/vendor/libsodium/utils.h b/packages/runtime/vendor/libsodium/utils.h new file mode 100644 index 000000000..f9b369796 --- /dev/null +++ b/packages/runtime/vendor/libsodium/utils.h @@ -0,0 +1,179 @@ + +#ifndef sodium_utils_H +#define sodium_utils_H + +#include + +#include "export.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef SODIUM_C99 +# if defined(__cplusplus) || !defined(__STDC_VERSION__) || __STDC_VERSION__ < 199901L +# define SODIUM_C99(X) +# else +# define SODIUM_C99(X) X +# endif +#endif + +SODIUM_EXPORT +void sodium_memzero(void * const pnt, const size_t len); + +SODIUM_EXPORT +void sodium_stackzero(const size_t len); + +/* + * WARNING: sodium_memcmp() must be used to verify if two secret keys + * are equal, in constant time. + * It returns 0 if the keys are equal, and -1 if they differ. + * This function is not designed for lexicographical comparisons. + */ +SODIUM_EXPORT +int sodium_memcmp(const void * const b1_, const void * const b2_, size_t len) + __attribute__ ((warn_unused_result)); + +/* + * sodium_compare() returns -1 if b1_ < b2_, 1 if b1_ > b2_ and 0 if b1_ == b2_ + * It is suitable for lexicographical comparisons, or to compare nonces + * and counters stored in little-endian format. + * However, it is slower than sodium_memcmp(). + */ +SODIUM_EXPORT +int sodium_compare(const unsigned char *b1_, const unsigned char *b2_, + size_t len) __attribute__ ((warn_unused_result)); + +SODIUM_EXPORT +int sodium_is_zero(const unsigned char *n, const size_t nlen); + +SODIUM_EXPORT +void sodium_increment(unsigned char *n, const size_t nlen); + +SODIUM_EXPORT +void sodium_add(unsigned char *a, const unsigned char *b, const size_t len); + +SODIUM_EXPORT +void sodium_sub(unsigned char *a, const unsigned char *b, const size_t len); + +SODIUM_EXPORT +char *sodium_bin2hex(char * const hex, const size_t hex_maxlen, + const unsigned char * const bin, const size_t bin_len) + __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +int sodium_hex2bin(unsigned char * const bin, const size_t bin_maxlen, + const char * const hex, const size_t hex_len, + const char * const ignore, size_t * const bin_len, + const char ** const hex_end) + __attribute__ ((nonnull(1))); + +#define sodium_base64_VARIANT_ORIGINAL 1 +#define sodium_base64_VARIANT_ORIGINAL_NO_PADDING 3 +#define sodium_base64_VARIANT_URLSAFE 5 +#define sodium_base64_VARIANT_URLSAFE_NO_PADDING 7 + +/* + * Computes the required length to encode BIN_LEN bytes as a base64 string + * using the given variant. The computed length includes a trailing \0. + */ +#define sodium_base64_ENCODED_LEN(BIN_LEN, VARIANT) \ + (((BIN_LEN) / 3U) * 4U + \ + ((((BIN_LEN) - ((BIN_LEN) / 3U) * 3U) | (((BIN_LEN) - ((BIN_LEN) / 3U) * 3U) >> 1)) & 1U) * \ + (4U - (~((((VARIANT) & 2U) >> 1) - 1U) & (3U - ((BIN_LEN) - ((BIN_LEN) / 3U) * 3U)))) + 1U) + +SODIUM_EXPORT +size_t sodium_base64_encoded_len(const size_t bin_len, const int variant); + +SODIUM_EXPORT +char *sodium_bin2base64(char * const b64, const size_t b64_maxlen, + const unsigned char * const bin, const size_t bin_len, + const int variant) __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +int sodium_base642bin(unsigned char * const bin, const size_t bin_maxlen, + const char * const b64, const size_t b64_len, + const char * const ignore, size_t * const bin_len, + const char ** const b64_end, const int variant) + __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +int sodium_mlock(void * const addr, const size_t len) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int sodium_munlock(void * const addr, const size_t len) + __attribute__ ((nonnull)); + +/* WARNING: sodium_malloc() and sodium_allocarray() are not general-purpose + * allocation functions. + * + * They return a pointer to a region filled with 0xd0 bytes, immediately + * followed by a guard page. + * As a result, accessing a single byte after the requested allocation size + * will intentionally trigger a segmentation fault. + * + * A canary and an additional guard page placed before the beginning of the + * region may also kill the process if a buffer underflow is detected. + * + * The memory layout is: + * [unprotected region size (read only)][guard page (no access)][unprotected pages (read/write)][guard page (no access)] + * With the layout of the unprotected pages being: + * [optional padding][16-bytes canary][user region] + * + * However: + * - These functions are significantly slower than standard functions + * - Each allocation requires 3 or 4 additional pages + * - The returned address will not be aligned if the allocation size is not + * a multiple of the required alignment. For this reason, these functions + * are designed to store data, such as secret keys and messages. + * + * sodium_malloc() can be used to allocate any libsodium data structure. + * + * The crypto_generichash_state structure is packed and its length is + * either 357 or 361 bytes. For this reason, when using sodium_malloc() to + * allocate a crypto_generichash_state structure, padding must be added in + * order to ensure proper alignment. crypto_generichash_statebytes() + * returns the rounded up structure size, and should be preferred to sizeof(): + * state = sodium_malloc(crypto_generichash_statebytes()); + */ + +SODIUM_EXPORT +void *sodium_malloc(const size_t size) + __attribute__ ((malloc)); + +SODIUM_EXPORT +void *sodium_allocarray(size_t count, size_t size) + __attribute__ ((malloc)); + +SODIUM_EXPORT +void sodium_free(void *ptr); + +SODIUM_EXPORT +int sodium_mprotect_noaccess(void *ptr) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int sodium_mprotect_readonly(void *ptr) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int sodium_mprotect_readwrite(void *ptr) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int sodium_pad(size_t *padded_buflen_p, unsigned char *buf, + size_t unpadded_buflen, size_t blocksize, size_t max_buflen) + __attribute__ ((nonnull(2))); + +SODIUM_EXPORT +int sodium_unpad(size_t *unpadded_buflen_p, const unsigned char *buf, + size_t padded_buflen, size_t blocksize) + __attribute__ ((nonnull(2))); + +/* -------- */ + +int _sodium_alloc_init(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/packages/runtime/vendor/libsodium/verify.c b/packages/runtime/vendor/libsodium/verify.c new file mode 100644 index 000000000..0c3323a50 --- /dev/null +++ b/packages/runtime/vendor/libsodium/verify.c @@ -0,0 +1,95 @@ + +#include +#include + +#include "crypto_verify_16.h" +#include "crypto_verify_32.h" +#include "crypto_verify_64.h" + +size_t +crypto_verify_16_bytes(void) +{ + return crypto_verify_16_BYTES; +} + +size_t +crypto_verify_32_bytes(void) +{ + return crypto_verify_32_BYTES; +} + +size_t +crypto_verify_64_bytes(void) +{ + return crypto_verify_64_BYTES; +} + +#if defined(HAVE_EMMINTRIN_H) && defined(__SSE2__) + +# include + +static inline int +crypto_verify_n(const unsigned char *x_, const unsigned char *y_, + const int n) +{ + const __m128i zero = _mm_setzero_si128(); + volatile __m128i v1, v2, z; + volatile int m; + int i; + + const volatile __m128i *volatile x = + (const volatile __m128i *volatile) (const void *) x_; + const volatile __m128i *volatile y = + (const volatile __m128i *volatile) (const void *) y_; + v1 = _mm_loadu_si128((const __m128i *) &x[0]); + v2 = _mm_loadu_si128((const __m128i *) &y[0]); + z = _mm_xor_si128(v1, v2); + for (i = 1; i < n / 16; i++) { + v1 = _mm_loadu_si128((const __m128i *) &x[i]); + v2 = _mm_loadu_si128((const __m128i *) &y[i]); + z = _mm_or_si128(z, _mm_xor_si128(v1, v2)); + } + m = _mm_movemask_epi8(_mm_cmpeq_epi32(z, zero)); + v1 = zero; v2 = zero; z = zero; + + return (int) (((uint32_t) m + 1U) >> 16) - 1; +} + +#else + +static inline int +crypto_verify_n(const unsigned char *x_, const unsigned char *y_, + const int n) +{ + const volatile unsigned char *volatile x = + (const volatile unsigned char *volatile) x_; + const volatile unsigned char *volatile y = + (const volatile unsigned char *volatile) y_; + volatile uint_fast16_t d = 0U; + int i; + + for (i = 0; i < n; i++) { + d |= x[i] ^ y[i]; + } + return (1 & ((d - 1) >> 8)) - 1; +} + +#endif + +int +crypto_verify_16(const unsigned char *x, const unsigned char *y) +{ + return crypto_verify_n(x, y, crypto_verify_16_BYTES); +} + +int +crypto_verify_32(const unsigned char *x, const unsigned char *y) +{ + return crypto_verify_n(x, y, crypto_verify_32_BYTES); +} + +int +crypto_verify_64(const unsigned char *x, const unsigned char *y) +{ + return crypto_verify_n(x, y, crypto_verify_64_BYTES); +} diff --git a/tests/corpus/7080-crypto-ed25519.mjs b/tests/corpus/7080-crypto-ed25519.mjs new file mode 100644 index 000000000..355d98225 --- /dev/null +++ b/tests/corpus/7080-crypto-ed25519.mjs @@ -0,0 +1,34 @@ +// Ed25519 KeyObjects in node:crypto: the RFC 8032 test 1 key through +// PKCS#8, SubjectPublicKeyInfo and JWK export and import, its deterministic +// signatures from crypto.sign and crypto.verify, generateKeyPairSync, the +// two-argument generateKeyPair callback, and Node's errors for digests, +// Sign objects and the RSA and EC key encodings. +import * as c from "node:crypto"; +const t = (l, f) => { try { const v = f(); console.log(l, "=>", typeof v === "object" && v !== null && !Buffer.isBuffer(v) ? JSON.stringify(v) : Buffer.isBuffer(v) ? v.toString("hex") : String(v).slice(0, 200)); } catch (e) { console.log(l, "!!", e.name, e.code, e.message); } }; +const seed = Buffer.from("9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60", "hex"); +const der = Buffer.concat([Buffer.from("302e020100300506032b657004220420", "hex"), seed]); +const k = c.createPrivateKey({ key: der, format: "der", type: "pkcs8" }); +const p = c.createPublicKey(k); +t("type", () => [k.type, k.asymmetricKeyType, JSON.stringify(k.asymmetricKeyDetails), p.type].join()); +t("pkcs8 pem", () => k.export({ type: "pkcs8", format: "pem" })); +t("spki pem", () => p.export({ type: "spki", format: "pem" })); +t("spki der", () => p.export({ type: "spki", format: "der" })); +t("jwk priv", () => k.export({ format: "jwk" })); +t("jwk pub", () => p.export({ format: "jwk" })); +t("sig empty", () => c.sign(null, Buffer.alloc(0), k)); +t("sig abc", () => c.sign(undefined, Buffer.from("abc"), k)); +t("verify", () => c.verify(null, Buffer.from("abc"), p, c.sign(null, Buffer.from("abc"), k))); +t("verify bad", () => c.verify(null, Buffer.from("abd"), p, c.sign(null, Buffer.from("abc"), k))); +t("sign sha256", () => c.sign("sha256", Buffer.from("abc"), k)); +t("createSign", () => c.createSign("sha256").update("x").sign(k)); +t("pkcs1 export", () => k.export({ type: "pkcs1", format: "pem" })); +t("sec1 export", () => k.export({ type: "sec1", format: "pem" })); +t("gen cb form", () => { c.generateKeyPair("ed25519", (e, pub, priv) => console.log("cb", e, pub.asymmetricKeyType, priv.type)); return "scheduled"; }); +t("gen", () => { const g = c.generateKeyPairSync("ed25519"); return [g.publicKey.asymmetricKeyType, Object.keys(g).join()].join(); }); +t("gen opts", () => { const g = c.generateKeyPairSync("ed25519", { publicKeyEncoding: { type: "spki", format: "der" } }); return g.publicKey.length; }); +t("jwk import", () => c.createPrivateKey({ key: k.export({ format: "jwk" }), format: "jwk" }).equals(k)); +t("jwk pub import", () => c.createPublicKey({ key: p.export({ format: "jwk" }), format: "jwk" }).equals(p)); +t("dsaEncoding", () => c.sign(null, Buffer.from("x"), { key: k, dsaEncoding: "ieee-p1363" }).length); +t("verify short sig", () => c.verify(null, Buffer.from("x"), p, Buffer.alloc(10))); +t("pem parse", () => c.createPrivateKey(k.export({ type: "pkcs8", format: "pem" })).equals(k)); +t("equals ec", () => k.equals(c.generateKeyPairSync("ec", { namedCurve: "P-256" }).privateKey)); diff --git a/tests/corpus/7081-webcrypto-ed25519.mjs b/tests/corpus/7081-webcrypto-ed25519.mjs new file mode 100644 index 000000000..5cf7728f1 --- /dev/null +++ b/tests/corpus/7081-webcrypto-ed25519.mjs @@ -0,0 +1,39 @@ +// WebCrypto Ed25519: the RFC 8032 test 1 key imported from pkcs8, jwk and +// raw, its deterministic signatures, verify, generateKey, every export +// format, and Node's DOMExceptions for usages, raw private export, short +// raw keys and mismatched JWK members. + +const t = async (label, fn) => { try { const v = await fn(); console.log(label, "=>", v instanceof ArrayBuffer ? Buffer.from(v).toString("hex") : typeof v === "object" && v !== null ? JSON.stringify(v) : v); } catch (e) { console.log(label, "!!", e.name, e.code, e.message); } }; +const seed = Buffer.from("9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60", "hex"); +const pkcs8 = Buffer.concat([Buffer.from("302e020100300506032b657004220420", "hex"), seed]); +const priv = await crypto.subtle.importKey("pkcs8", pkcs8, { name: "Ed25519" }, true, ["sign"]); +await t("algorithm", () => [JSON.stringify(priv.algorithm), priv.type, priv.usages.join(), priv.extractable].join(" ")); +await t("sign empty", () => crypto.subtle.sign("Ed25519", priv, new Uint8Array(0))); +await t("sign abc", () => crypto.subtle.sign({ name: "Ed25519" }, priv, new TextEncoder().encode("abc"))); +await t("jwk priv", () => crypto.subtle.exportKey("jwk", priv)); +await t("pkcs8 back", async () => Buffer.from(await crypto.subtle.exportKey("pkcs8", priv)).equals(pkcs8)); +const jwk = await crypto.subtle.exportKey("jwk", priv); +const pubJwk = { kty: jwk.kty, crv: jwk.crv, x: jwk.x }; +const pub = await crypto.subtle.importKey("jwk", pubJwk, "Ed25519", true, ["verify"]); +await t("raw pub", () => crypto.subtle.exportKey("raw", pub)); +await t("spki pub", () => crypto.subtle.exportKey("spki", pub)); +await t("jwk pub", () => crypto.subtle.exportKey("jwk", pub)); +const sig = await crypto.subtle.sign("Ed25519", priv, new TextEncoder().encode("abc")); +await t("verify", () => crypto.subtle.verify("Ed25519", pub, sig, new TextEncoder().encode("abc"))); +await t("verify bad", () => crypto.subtle.verify("Ed25519", pub, sig, new TextEncoder().encode("abd"))); +await t("verify short", () => crypto.subtle.verify("Ed25519", pub, new Uint8Array(10), new TextEncoder().encode("abc"))); +const rawImported = await crypto.subtle.importKey("raw", await crypto.subtle.exportKey("raw", pub), { name: "Ed25519" }, false, ["verify"]); +await t("raw import verify", () => crypto.subtle.verify("Ed25519", rawImported, sig, new TextEncoder().encode("abc"))); +const pair = await crypto.subtle.generateKey({ name: "Ed25519" }, true, ["sign", "verify"]); +await t("generated", async () => [pair.privateKey.usages.join(), pair.publicKey.usages.join(), pair.publicKey.extractable, (await crypto.subtle.exportKey("raw", pair.publicKey)).byteLength, await crypto.subtle.verify("Ed25519", pair.publicKey, await crypto.subtle.sign("Ed25519", pair.privateKey, new Uint8Array([1])), new Uint8Array([1]))].join(" ")); +await t("raw private", () => crypto.subtle.exportKey("raw", pair.privateKey)); +await t("bad usage", () => crypto.subtle.generateKey({ name: "Ed25519" }, true, ["encrypt"])); +await t("verify only", () => crypto.subtle.generateKey("Ed25519", true, ["verify"])); +await t("raw short", () => crypto.subtle.importKey("raw", new Uint8Array(31), { name: "Ed25519" }, true, ["verify"])); +await t("raw sign usage", () => crypto.subtle.importKey("raw", new Uint8Array(32), "Ed25519", true, ["sign"])); +await t("jwk alg EdDSA", async () => (await crypto.subtle.importKey("jwk", { ...pubJwk, alg: "EdDSA" }, "Ed25519", true, ["verify"])).type); +await t("jwk alg bad", () => crypto.subtle.importKey("jwk", { ...pubJwk, alg: "RS256" }, "Ed25519", true, ["verify"])); +await t("jwk crv bad", () => crypto.subtle.importKey("jwk", { ...pubJwk, crv: "Ed448" }, "Ed25519", true, ["verify"])); +await t("jwk kty bad", () => crypto.subtle.importKey("jwk", { ...pubJwk, kty: "EC" }, "Ed25519", true, ["verify"])); +await t("ecdsa key as ed", async () => { const e = await crypto.subtle.generateKey({ name: "ECDSA", namedCurve: "P-256" }, true, ["sign", "verify"]); return crypto.subtle.importKey("spki", await crypto.subtle.exportKey("spki", e.publicKey), "Ed25519", true, ["verify"]); }); +await t("sign wrong alg", () => crypto.subtle.sign({ name: "ECDSA", hash: "SHA-256" }, priv, new Uint8Array(1))); diff --git a/tests/corpus/7082-crypto-key-objects.ts b/tests/corpus/7082-crypto-key-objects.ts new file mode 100644 index 000000000..816dd6be0 --- /dev/null +++ b/tests/corpus/7082-crypto-key-objects.ts @@ -0,0 +1,132 @@ +// Private and public KeyObjects: createPrivateKey and createPublicKey from +// PEM, DER, JWK, a private KeyObject and a certificate; the type, +// asymmetricKeyType and asymmetricKeyDetails getters; export() as PKCS#1, +// SEC1, PKCS#8, SubjectPublicKeyInfo, DER and JWK; equals(); instanceof; +// and Node's errors for invalid options and inputs, including a private or +// public key passed to createHmac. +import * as crypto from "node:crypto"; + +const RSA = `-----BEGIN RSA PRIVATE KEY----- +MIICWwIBAAKBgQDWei4BREJm+4C6u/+F4NI7kTOQ9gf/a+Ecd2SZxfpXRtXT0QVN +MAI1uQNmB4abYzvd1G2V2XKsTJFJcJWibjAz56UxtxxggTpSAalFZYoPm6HfabwJ +b/YWh0K0OrNFvdkeXLLMiHQsxmIQ2lrFoycQEpZ4/yxjLe6LQF+L79k2ywIDAQAB +AoGAMWS/9ZC3zim7ssWbCkUFhaxh+M+AdgVtOXYRmAxtI+5vTjHEC8uzppWuP7Aa +Au0um17RwgHrE90qVIR2IYtI1C9K9RLUNlKKVPqnSSmr0qkXR246R/Zd8eho1XSS +MX6KmnbmRijUx9Rw1AbD2ZmYCrXsPf2HsCdH+SGQ1ZTunnECQQD090dTA21Jyu/b +ADglqgixJCPIoc6qpxst+W1LreIo4UvkSmgnRYvsKDlM7FNI+6f7igI625KXIAnl +xVlmGLXDAkEA4CNVeP07fmQUBs1aPQ9LCOvN42SV6S8Fjbf4XHIYG5Kp48/98oJj +1pFsXNa8nn8fmN9zFw8yM/yd22iZdueCWQJAWMja//po/OrhniVpNDV5awKnOYtz +xSRF1JbnhxthseFeSUKylzE8sn4trnSlBvm2+5MclcqJSd7h13Z8nWVtUwJAZ0SA +Ve0+ov4TKAsnH2jTZnnWc4VdeIFcqq3vdRBwQQvy0G59D2W6ABsidSfO4auqcDHL +gf1TYRZr2LI5usnxiQJAGt3e0QC0q0WN4p49YhyXXVuHccx79RFgfN7V1lkAyYuL +2bPV41mEtD/AbSrObtqqvOaWZjwSr8JCyPdPZZAIMw== +-----END RSA PRIVATE KEY----- +`; +const EC = `-----BEGIN EC PRIVATE KEY----- +MHcCAQEEILpVcXOEZQXpH/q3ec3AsLg4x4Bld6uZLqDC56OYKQK4oAoGCCqGSM49 +AwEHoUQDQgAE0gwi0a/4kuVxjsO3vw79rT3QSxnPY7sooVlI+ENq35D7meWZv/dp +FTGFte7Bd8lFxaZ10dMo0tl++AOtt7umPg== +-----END EC PRIVATE KEY----- +`; +const EC384 = `-----BEGIN EC PRIVATE KEY----- +MIGkAgEBBDDer7W8pQD96zdS8UWxg34nMTxqREszwP6niYYOdw75LHPmHFKWeMKW +dmG6d3n4bRugBwYFK4EEACKhZANiAATIQKDRVJ501CTQtbK2IslxdO8Oma2ZU4ee +GRuQFg6ajhKXa0iCU5o9rpdObfCecyiYApdtVpahD2SwPua5CZyq/0jUn9frwKtB +uEeB/3T/yYRCD4zGUc7TtUDh8c7Gt5c= +-----END EC PRIVATE KEY----- +`; +const CERT = `-----BEGIN CERTIFICATE----- +MIIDuzCCAqOgAwIBAgIPAPAN+s4AESIzRFVmd4iZMA0GCSqGSIb3DQEBDAUAMIGc +MQswCQYDVQQGEwJVUzETMBEGA1UECAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNU2Fu +IEZyYW5jaXNjbzEUMBIGA1UECgwLRXhhbXBsZSBPcmcxETAPBgNVBAsMCERldiBU +ZWFtMRgwFgYDVQQDDA9FeGFtcGxlIFJvb3QgQ0ExHTAbBgkqhkiG9w0BCQEWDmNh +QGV4YW1wbGUuY29tMB4XDTI2MTAyMTE2MzM1MloXDTM2MTAxODE2MzM1MlowJzER +MA8GA1UECgwITGVhZiBPcmcxEjAQBgNVBAMMCWxvY2FsaG9zdDBZMBMGByqGSM49 +AgEGCCqGSM49AwEHA0IABJVfVy9EH/VHQuRqpFFnXk0F00ncDht6APgVPDoybK8H +PlcM4T5H1yAOMHnlH29LK1jtMqU1aAOiiQRzPdCvqoujggE3MIIBMzAJBgNVHRME +AjAAMGgGA1UdEQRhMF+CCWxvY2FsaG9zdIINKi5leGFtcGxlLmNvbYcEfwAAAYcQ +AAAAAAAAAAAAAAAAAAAAAYERYWRtaW5AZXhhbXBsZS5jb22GGGh0dHBzOi8vZXhh +bXBsZS5jb20vcGF0aDBdBggrBgEFBQcBAQRRME8wIwYIKwYBBQUHMAGGF2h0dHA6 +Ly9vY3NwLmV4YW1wbGUuY29tMCgGCCsGAQUFBzAChhxodHRwOi8vY2EuZXhhbXBs +ZS5jb20vY2EuY3J0MB0GA1UdJQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjAdBgNV +HQ4EFgQUdKIx6ULFLPNP/kzwUFjSa5D19RswHwYDVR0jBBgwFoAUP+yQyItpNYEl +s26Jfv+NnciGaK8wDQYJKoZIhvcNAQEMBQADggEBABmQ8f2VsXNaMM9X1MEhi27D +LjwcOaaGEINNZq7xu/HL6UljMb1Odsuz66DkiH3Exd3MrWy6OlOpJJF0VzsqMsoD +0CRBxXF28o6Jil3vOGVwlYNmRidpkAkj4VyWDvv8FCS9VbsBtXaSHwu9wcCwePE0 +cGJRfTKoZ6KJ8vQ57DBEZ/ZszuhehOZYqrTmoUdjZ123kXdxQvK+ALn4SlIXHBhN +9unhd+8i00EmkXO/REw8paMcMVVGR+ioOEjyNHqZo6vkRqgpKggn1Yq8cTTDOMnS +P1o42EQZLlbuvx0kqInBqwqjDx4nZiPaifoDc9BF6iZPBvm8dhrEfghfB1tkNk0= +-----END CERTIFICATE----- +`; + +function attempt(label: string, run: () => unknown): void { + try { + const value = run(); + console.log(label, typeof value === "string" ? JSON.stringify(value) : value); + } catch (e) { + const err = e as NodeJS.ErrnoException; + console.log(label, "throws", err.name, err.code, err.message); + } +} + +const rsa = crypto.createPrivateKey(RSA); +const ec = crypto.createPrivateKey(Buffer.from(EC)); +const ec384 = crypto.createPrivateKey({ key: EC384, format: "pem" }); +const rsaPublic = crypto.createPublicKey(rsa); +const ecPublic = crypto.createPublicKey(EC); +const certPublic = crypto.createPublicKey(CERT); +const keys: [string, crypto.KeyObject][] = [ + ["rsa", rsa], + ["ec", ec], + ["ec384", ec384], + ["rsaPublic", rsaPublic], + ["ecPublic", ecPublic], + ["certPublic", certPublic], +]; +for (const [label, key] of keys) { + console.log(label, key.type, key.asymmetricKeyType, key.asymmetricKeyDetails, key instanceof crypto.KeyObject); +} + +attempt("pkcs1", () => rsa.export({ type: "pkcs1", format: "pem" }) === RSA + "\n"); +attempt("sec1", () => ec.export({ type: "sec1", format: "pem" }) === EC + "\n"); +attempt("rsa pkcs8", () => rsa.export({ type: "pkcs8", format: "pem" })); +attempt("ec pkcs8", () => ec.export({ type: "pkcs8", format: "pem" })); +attempt("rsa spki", () => rsaPublic.export({ type: "spki", format: "pem" })); +attempt("rsa public pkcs1", () => rsaPublic.export({ type: "pkcs1", format: "pem" })); +attempt("ec spki", () => ecPublic.export({ type: "spki", format: "pem" })); +attempt("cert spki", () => certPublic.export({ type: "spki", format: "pem" })); +attempt("der", () => (rsa.export({ type: "pkcs8", format: "der" }) as Buffer).toString("base64")); +attempt("ec jwk", () => JSON.stringify(ec.export({ format: "jwk" }))); +attempt("ec384 public jwk", () => JSON.stringify(crypto.createPublicKey(ec384).export({ format: "jwk" }))); +attempt("rsa jwk", () => JSON.stringify(rsa.export({ format: "jwk" }))); +attempt("rsa public jwk", () => JSON.stringify(rsaPublic.export({ format: "jwk" }))); + +// Round trips through DER and JWK. +const der = rsa.export({ type: "pkcs1", format: "der" }) as Buffer; +attempt("from der", () => crypto.createPrivateKey({ key: der, format: "der", type: "pkcs1" }).equals(rsa)); +const spki = ecPublic.export({ type: "spki", format: "der" }) as Buffer; +attempt("public from der", () => crypto.createPublicKey({ key: spki, format: "der", type: "spki" }).equals(ecPublic)); +attempt("from jwk", () => crypto.createPrivateKey({ key: ec.export({ format: "jwk" }), format: "jwk" }).equals(ec)); +attempt("rsa from jwk", () => crypto.createPrivateKey({ key: rsa.export({ format: "jwk" }), format: "jwk" }).equals(rsa)); +attempt("public from jwk", () => crypto.createPublicKey({ key: rsaPublic.export({ format: "jwk" }), format: "jwk" }).equals(rsaPublic)); +attempt("pkcs8 parse", () => crypto.createPrivateKey(ec.export({ type: "pkcs8", format: "pem" })).equals(ec)); +attempt("equals", () => [rsaPublic.equals(crypto.createPublicKey(RSA)), ec.equals(ecPublic), ec.equals(ec384)].join()); +attempt("tag", () => Object.prototype.toString.call(rsa)); + +// Errors. +attempt("export no options", () => rsa.export()); +attempt("export no format", () => rsa.export({} as crypto.AsymmetricKeyExportOptions<"pem">)); +attempt("export no type", () => rsa.export({ format: "pem" } as crypto.AsymmetricKeyExportOptions<"pem">)); +attempt("export spki private", () => rsa.export({ type: "spki", format: "pem" })); +attempt("export sec1 rsa", () => rsa.export({ type: "sec1", format: "pem" })); +attempt("export pkcs1 ec", () => ec.export({ type: "pkcs1", format: "der" })); +attempt("export pkcs8 public", () => ecPublic.export({ type: "pkcs8", format: "pem" })); +attempt("private from public pem", () => crypto.createPrivateKey(ecPublic.export({ type: "spki", format: "pem" }) as string)); +attempt("private from garbage", () => crypto.createPrivateKey("not a key")); +attempt("public from public", () => crypto.createPublicKey(ecPublic)); +attempt("der without type", () => crypto.createPrivateKey({ key: der, format: "der" } as crypto.PrivateKeyInput)); +attempt("hmac private key", () => crypto.createHmac("sha256", rsa)); +attempt("hmac public key", () => crypto.createHmac("sha256", ecPublic)); +// Last: OpenSSL keeps an error queued after comparing keys of different +// types, which a later call in Node can report. +attempt("equals other type", () => rsa.equals(ec)); diff --git a/tests/corpus/7083-crypto-sign-verify.ts b/tests/corpus/7083-crypto-sign-verify.ts new file mode 100644 index 000000000..437dc1640 --- /dev/null +++ b/tests/corpus/7083-crypto-sign-verify.ts @@ -0,0 +1,85 @@ +// crypto.sign and crypto.verify, and the Sign and Verify objects: RSA +// PKCS#1 v1.5 signatures (deterministic, so they compare with Node), RSA-PSS, +// ECDSA in DER and IEEE P1363 encodings, keys given as KeyObjects, PEM and +// option objects, output and signature encodings, and Node's errors. +import * as crypto from "node:crypto"; + +const RSA = `-----BEGIN RSA PRIVATE KEY----- +MIICWwIBAAKBgQDWei4BREJm+4C6u/+F4NI7kTOQ9gf/a+Ecd2SZxfpXRtXT0QVN +MAI1uQNmB4abYzvd1G2V2XKsTJFJcJWibjAz56UxtxxggTpSAalFZYoPm6HfabwJ +b/YWh0K0OrNFvdkeXLLMiHQsxmIQ2lrFoycQEpZ4/yxjLe6LQF+L79k2ywIDAQAB +AoGAMWS/9ZC3zim7ssWbCkUFhaxh+M+AdgVtOXYRmAxtI+5vTjHEC8uzppWuP7Aa +Au0um17RwgHrE90qVIR2IYtI1C9K9RLUNlKKVPqnSSmr0qkXR246R/Zd8eho1XSS +MX6KmnbmRijUx9Rw1AbD2ZmYCrXsPf2HsCdH+SGQ1ZTunnECQQD090dTA21Jyu/b +ADglqgixJCPIoc6qpxst+W1LreIo4UvkSmgnRYvsKDlM7FNI+6f7igI625KXIAnl +xVlmGLXDAkEA4CNVeP07fmQUBs1aPQ9LCOvN42SV6S8Fjbf4XHIYG5Kp48/98oJj +1pFsXNa8nn8fmN9zFw8yM/yd22iZdueCWQJAWMja//po/OrhniVpNDV5awKnOYtz +xSRF1JbnhxthseFeSUKylzE8sn4trnSlBvm2+5MclcqJSd7h13Z8nWVtUwJAZ0SA +Ve0+ov4TKAsnH2jTZnnWc4VdeIFcqq3vdRBwQQvy0G59D2W6ABsidSfO4auqcDHL +gf1TYRZr2LI5usnxiQJAGt3e0QC0q0WN4p49YhyXXVuHccx79RFgfN7V1lkAyYuL +2bPV41mEtD/AbSrObtqqvOaWZjwSr8JCyPdPZZAIMw== +-----END RSA PRIVATE KEY----- +`; +const EC = `-----BEGIN EC PRIVATE KEY----- +MHcCAQEEILpVcXOEZQXpH/q3ec3AsLg4x4Bld6uZLqDC56OYKQK4oAoGCCqGSM49 +AwEHoUQDQgAE0gwi0a/4kuVxjsO3vw79rT3QSxnPY7sooVlI+ENq35D7meWZv/dp +FTGFte7Bd8lFxaZ10dMo0tl++AOtt7umPg== +-----END EC PRIVATE KEY----- +`; + +function attempt(label: string, run: () => unknown): void { + try { + console.log(label, run()); + } catch (e) { + const err = e as NodeJS.ErrnoException; + console.log(label, "throws", err.name, err.code, err.message); + } +} + +const rsa = crypto.createPrivateKey(RSA); +const rsaPublic = crypto.createPublicKey(rsa); +const ec = crypto.createPrivateKey(EC); +const ecPublic = crypto.createPublicKey(ec); +const data = Buffer.from("signed message"); + +for (const digest of ["sha1", "sha224", "sha256", "SHA384", "RSA-SHA512", "sha256WithRSAEncryption"]) { + const signature = crypto.sign(digest, data, rsa); + console.log(digest, signature.toString("base64"), crypto.verify(digest, data, rsaPublic, signature)); +} +attempt("null digest", () => crypto.sign(null, data, RSA).equals(crypto.sign("sha256", data, rsa))); +attempt("private key verifies", () => crypto.verify("sha256", data, RSA, crypto.sign("sha256", data, rsa))); +attempt("wrong data", () => crypto.verify("sha256", Buffer.from("other"), rsaPublic, crypto.sign("sha256", data, rsa))); + +const pss = crypto.sign("sha256", data, { key: rsa, padding: crypto.constants.RSA_PKCS1_PSS_PADDING, saltLength: 32 }); +attempt("pss", () => [pss.length, crypto.verify("sha256", data, { key: rsaPublic, padding: crypto.constants.RSA_PKCS1_PSS_PADDING }, pss)].join()); +attempt("pss as pkcs1", () => crypto.verify("sha256", data, rsaPublic, pss)); +attempt("pss digest salt", () => + crypto.verify("sha256", data, { key: rsaPublic, padding: crypto.constants.RSA_PKCS1_PSS_PADDING, saltLength: crypto.constants.RSA_PSS_SALTLEN_DIGEST }, pss), +); + +const der = crypto.sign("sha256", data, ec); +attempt("ecdsa der", () => [der[0], crypto.verify("sha256", data, ecPublic, der)].join()); +const p1363 = crypto.sign("sha384", data, { key: EC, dsaEncoding: "ieee-p1363" }); +attempt("ecdsa p1363", () => [p1363.length, crypto.verify("sha384", data, { key: ecPublic, dsaEncoding: "ieee-p1363" }, p1363)].join()); +attempt("p1363 as der", () => crypto.verify("sha384", data, ecPublic, p1363)); +attempt("truncated", () => crypto.verify("sha256", data, ecPublic, der.subarray(0, 10))); + +const signer = crypto.createSign("SHA256"); +signer.update("signed "); +signer.update(Buffer.from("message")); +const hex = signer.sign(rsa, "hex"); +attempt("sign object", () => hex === crypto.sign("sha256", data, rsa).toString("hex")); +attempt("sign again", () => signer.sign(rsa)); +attempt("update after sign", () => signer.update("more")); +const verifier = crypto.createVerify("RSA-SHA256"); +verifier.update("signed message", "utf8"); +attempt("verify object", () => verifier.verify(RSA, Buffer.from(hex, "hex").toString("base64"), "base64")); +attempt("verify again", () => verifier.verify(rsaPublic, hex, "hex")); +const ecSigner = crypto.createSign("sha512").update("chained"); +const ecSignature = ecSigner.sign({ key: ec, dsaEncoding: "ieee-p1363" }); +attempt("chained", () => crypto.createVerify("sha512").update("chained").verify({ key: ecPublic, dsaEncoding: "ieee-p1363" }, ecSignature)); + +attempt("invalid digest", () => crypto.sign("nope", data, rsa)); +attempt("public key signs", () => crypto.sign("sha256", data, rsaPublic)); +attempt("invalid createSign", () => crypto.createSign("nope")); +attempt("invalid dsaEncoding", () => crypto.sign("sha256", data, { key: ec, dsaEncoding: "x" as "der" })); diff --git a/tests/corpus/7084-crypto-key-pairs.cjs b/tests/corpus/7084-crypto-key-pairs.cjs new file mode 100644 index 000000000..ed4db0310 --- /dev/null +++ b/tests/corpus/7084-crypto-key-pairs.cjs @@ -0,0 +1,64 @@ +// generateKeyPairSync and generateKeyPair for RSA and EC keys: KeyObject +// results, PEM and DER encodings, curve names and NIST aliases, the +// callback's later macrotask, and Node's errors for invalid types and +// options. +const crypto = require("node:crypto"); + +function attempt(label, run) { + try { + console.log(label, run()); + } catch (e) { + console.log(label, "throws", e.name, e.code, e.message); + } +} + +const data = Buffer.from("key pair"); +for (const curve of ["prime256v1", "P-256", "secp384r1", "P-384", "secp521r1", "P-521", "secp256k1"]) { + const { publicKey, privateKey } = crypto.generateKeyPairSync("ec", { namedCurve: curve }); + const signature = crypto.sign("sha256", data, privateKey); + console.log(curve, privateKey.type, publicKey.type, privateKey.asymmetricKeyDetails, crypto.verify("sha256", data, publicKey, signature)); +} +const rsa = crypto.generateKeyPairSync("rsa", { modulusLength: 1024 }); +console.log("rsa", rsa.privateKey.asymmetricKeyDetails, Object.keys(rsa)); +const exponent = crypto.generateKeyPairSync("rsa", { modulusLength: 1024, publicExponent: 3 }); +console.log("exponent", exponent.publicKey.asymmetricKeyDetails); +const encoded = crypto.generateKeyPairSync("ec", { + namedCurve: "P-256", + publicKeyEncoding: { type: "spki", format: "pem" }, + privateKeyEncoding: { type: "sec1", format: "der" }, +}); +console.log("encoded", typeof encoded.publicKey, encoded.publicKey.split("\n")[0], Buffer.isBuffer(encoded.privateKey)); +const reparsed = crypto.createPrivateKey({ key: encoded.privateKey, format: "der", type: "sec1" }); +console.log("reparsed", crypto.createPublicKey(reparsed).export({ type: "spki", format: "pem" }) === encoded.publicKey); +const rsaPem = crypto.generateKeyPairSync("rsa", { + modulusLength: 1024, + publicKeyEncoding: { type: "pkcs1", format: "pem" }, + privateKeyEncoding: { type: "pkcs8", format: "pem" }, +}); +console.log("rsa pem", rsaPem.publicKey.split("\n")[0], rsaPem.privateKey.split("\n")[0]); +const jwk = crypto.generateKeyPairSync("ec", { namedCurve: "secp256k1", publicKeyEncoding: { format: "jwk" } }); +console.log("jwk", Object.keys(jwk.publicKey), jwk.publicKey.crv); + +attempt("no options", () => crypto.generateKeyPairSync("rsa")); +attempt("no modulusLength", () => crypto.generateKeyPairSync("rsa", {})); +attempt("string modulusLength", () => crypto.generateKeyPairSync("rsa", { modulusLength: "2048" })); +attempt("negative modulusLength", () => crypto.generateKeyPairSync("rsa", { modulusLength: -1 })); +attempt("unknown type", () => crypto.generateKeyPairSync("foo", {})); +attempt("number type", () => crypto.generateKeyPairSync(5, {})); +attempt("no curve", () => crypto.generateKeyPairSync("ec", {})); +attempt("unknown curve", () => crypto.generateKeyPairSync("ec", { namedCurve: "nope" })); +attempt("bad encoding format", () => crypto.generateKeyPairSync("ec", { namedCurve: "P-256", publicKeyEncoding: { type: "spki", format: "xml" } })); +attempt("bad encoding type", () => crypto.generateKeyPairSync("ec", { namedCurve: "P-256", privateKeyEncoding: { type: "spki", format: "pem" } })); +attempt("encoding not object", () => crypto.generateKeyPairSync("ec", { namedCurve: "P-256", publicKeyEncoding: "pem" })); + +let returned = false; +crypto.generateKeyPair("ec", { namedCurve: "P-384" }, (err, publicKey, privateKey) => { + console.log("callback", returned, err, publicKey.type, privateKey.asymmetricKeyDetails); + crypto.generateKeyPair("rsa", { modulusLength: 1024 }, (err2, publicKey2) => { + console.log("rsa callback", err2, publicKey2.asymmetricKeyDetails.modulusLength); + }); +}); +process.nextTick(() => console.log("tick")); +attempt("callback errors throw", () => crypto.generateKeyPair("ec", {}, () => console.log("never"))); +returned = true; +console.log("returned"); diff --git a/tests/corpus/7085-webcrypto-ecdsa-rsa.ts b/tests/corpus/7085-webcrypto-ecdsa-rsa.ts new file mode 100644 index 000000000..446ed7c63 --- /dev/null +++ b/tests/corpus/7085-webcrypto-ecdsa-rsa.ts @@ -0,0 +1,66 @@ +// WebCrypto ECDSA, RSASSA-PKCS1-v1_5 and RSA-PSS: importKey from spki, +// pkcs8, jwk and raw, exportKey to each format, sign and verify (RSA +// PKCS#1 v1.5 signatures are deterministic, so they compare with Node), +// generateKey for every curve and both RSA algorithms, and the CryptoKey +// members of these keys. +const RSA_PKCS8 = "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBANZ6LgFEQmb7gLq7/4Xg0juRM5D2B/9r4Rx3ZJnF+ldG1dPRBU0wAjW5A2YHhptjO93UbZXZcqxMkUlwlaJuMDPnpTG3HGCBOlIBqUVlig+bod9pvAlv9haHQrQ6s0W92R5cssyIdCzGYhDaWsWjJxASlnj/LGMt7otAX4vv2TbLAgMBAAECgYAxZL/1kLfOKbuyxZsKRQWFrGH4z4B2BW05dhGYDG0j7m9OMcQLy7Omla4/sBoC7S6bXtHCAesT3SpUhHYhi0jUL0r1EtQ2UopU+qdJKavSqRdHbjpH9l3x6GjVdJIxfoqaduZGKNTH1HDUBsPZmZgKtew9/YewJ0f5IZDVlO6ecQJBAPT3R1MDbUnK79sAOCWqCLEkI8ihzqqnGy35bUut4ijhS+RKaCdFi+woOUzsU0j7p/uKAjrbkpcgCeXFWWYYtcMCQQDgI1V4/Tt+ZBQGzVo9D0sI683jZJXpLwWNt/hcchgbkqnjz/3ygmPWkWxc1ryefx+Y33MXDzIz/J3baJl254JZAkBYyNr/+mj86uGeJWk0NXlrAqc5i3PFJEXUlueHG2Gx4V5JQrKXMTyyfi2udKUG+bb7kxyVyolJ3uHXdnydZW1TAkBnRIBV7T6i/hMoCycfaNNmedZzhV14gVyqre91EHBBC/LQbn0PZboAGyJ1J87hq6pwMcuB/VNhFmvYsjm6yfGJAkAa3d7RALSrRY3inj1iHJddW4dxzHv1EWB83tXWWQDJi4vZs9XjWYS0P8BtKs5u2qq85pZmPBKvwkLI909lkAgz"; +const RSA_SPKI = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDWei4BREJm+4C6u/+F4NI7kTOQ9gf/a+Ecd2SZxfpXRtXT0QVNMAI1uQNmB4abYzvd1G2V2XKsTJFJcJWibjAz56UxtxxggTpSAalFZYoPm6HfabwJb/YWh0K0OrNFvdkeXLLMiHQsxmIQ2lrFoycQEpZ4/yxjLe6LQF+L79k2ywIDAQAB"; +const EC_PKCS8 = "MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgulVxc4RlBekf+rd5zcCwuDjHgGV3q5kuoMLno5gpArihRANCAATSDCLRr/iS5XGOw7e/Dv2tPdBLGc9juyihWUj4Q2rfkPuZ5Zm/92kVMYW17sF3yUXFpnXR0yjS2X74A623u6Y+"; +const EC_SPKI = "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE0gwi0a/4kuVxjsO3vw79rT3QSxnPY7sooVlI+ENq35D7meWZv/dpFTGFte7Bd8lFxaZ10dMo0tl++AOtt7umPg=="; + +const bytes = (text: string): Uint8Array => new Uint8Array(Buffer.from(text, "base64")); +const hex = (buffer: ArrayBuffer): string => Buffer.from(buffer).toString("hex"); +const data = new TextEncoder().encode("webcrypto message"); + +const rsaPrivate = await crypto.subtle.importKey("pkcs8", bytes(RSA_PKCS8), { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" }, true, ["sign"]); +const rsaPublic = await crypto.subtle.importKey("spki", bytes(RSA_SPKI), { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" }, true, ["verify"]); +console.log(rsaPrivate.type, rsaPublic.type, rsaPrivate.extractable, rsaPublic.usages); +const rsaAlgorithm = rsaPrivate.algorithm as RsaHashedKeyAlgorithm; +console.log(rsaAlgorithm.name, rsaAlgorithm.modulusLength, Array.from(rsaAlgorithm.publicExponent), rsaAlgorithm.hash.name); +const rsaSignature = await crypto.subtle.sign("RSASSA-PKCS1-v1_5", rsaPrivate, data); +console.log("rsa signature", hex(rsaSignature)); +console.log("rsa verify", await crypto.subtle.verify({ name: "RSASSA-PKCS1-v1_5" }, rsaPublic, rsaSignature, data)); +console.log("rsa spki", Buffer.from(await crypto.subtle.exportKey("spki", rsaPublic)).toString("base64") === RSA_SPKI); +console.log("rsa pkcs8", Buffer.from(await crypto.subtle.exportKey("pkcs8", rsaPrivate)).toString("base64") === RSA_PKCS8); +const rsaJwk = await crypto.subtle.exportKey("jwk", rsaPublic); +console.log("rsa jwk", JSON.stringify(rsaJwk)); +const fromJwk = await crypto.subtle.importKey("jwk", rsaJwk, { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" }, false, ["verify"]); +console.log("rsa jwk verify", await crypto.subtle.verify("RSASSA-PKCS1-v1_5", fromJwk, rsaSignature, data), fromJwk.extractable); + +const ecPrivate = await crypto.subtle.importKey("pkcs8", bytes(EC_PKCS8), { name: "ECDSA", namedCurve: "P-256" }, true, ["sign"]); +const ecPublic = await crypto.subtle.importKey("spki", bytes(EC_SPKI), { name: "ECDSA", namedCurve: "P-256" }, true, ["verify"]); +console.log(JSON.stringify(ecPrivate.algorithm), ecPrivate.usages, ecPublic.usages); +console.log("ec jwk", JSON.stringify(await crypto.subtle.exportKey("jwk", ecPrivate))); +const point = await crypto.subtle.exportKey("raw", ecPublic); +console.log("ec raw", hex(point)); +const fromPoint = await crypto.subtle.importKey("raw", point, { name: "ECDSA", namedCurve: "P-256" }, true, ["verify"]); +for (const hash of ["SHA-1", "SHA-256", "SHA-384", "SHA-512"]) { + const signature = await crypto.subtle.sign({ name: "ECDSA", hash }, ecPrivate, data); + console.log("ecdsa", hash, signature.byteLength, await crypto.subtle.verify({ name: "ECDSA", hash: { name: hash } }, fromPoint, signature, data)); +} +const ecSignature = await crypto.subtle.sign({ name: "ECDSA", hash: "SHA-256" }, ecPrivate, data); +const tampered = new Uint8Array(ecSignature); +tampered[5] ^= 1; +console.log("tampered", await crypto.subtle.verify({ name: "ECDSA", hash: "SHA-256" }, ecPublic, tampered, data)); +console.log("other data", await crypto.subtle.verify({ name: "ECDSA", hash: "SHA-256" }, ecPublic, ecSignature, new Uint8Array([1]))); + +for (const namedCurve of ["P-256", "P-384", "P-521"]) { + const pair = await crypto.subtle.generateKey({ name: "ECDSA", namedCurve }, false, ["sign", "verify"]); + const signature = await crypto.subtle.sign({ name: "ECDSA", hash: "SHA-384" }, pair.privateKey, data); + console.log(namedCurve, Object.keys(pair).join(), pair.privateKey.extractable, pair.publicKey.extractable, signature.byteLength, + await crypto.subtle.verify({ name: "ECDSA", hash: "SHA-384" }, pair.publicKey, signature, data), + (await crypto.subtle.exportKey("raw", pair.publicKey)).byteLength); +} +for (const name of ["RSASSA-PKCS1-v1_5", "RSA-PSS"]) { + const pair = await crypto.subtle.generateKey({ name, modulusLength: 1024, publicExponent: new Uint8Array([1, 0, 1]), hash: "SHA-512" }, true, ["sign", "verify"]); + const params = { name, saltLength: 20 }; + const signature = await crypto.subtle.sign(params, pair.privateKey, data); + const jwk = await crypto.subtle.exportKey("jwk", pair.privateKey); + console.log(name, signature.byteLength, await crypto.subtle.verify(params, pair.publicKey, signature, data), jwk.alg, Object.keys(jwk).join()); +} +const pss = await crypto.subtle.importKey("pkcs8", bytes(RSA_PKCS8), { name: "RSA-PSS", hash: "SHA-256" }, false, ["sign"]); +const pssPublic = await crypto.subtle.importKey("spki", bytes(RSA_SPKI), { name: "RSA-PSS", hash: "SHA-256" }, false, ["verify"]); +const pssSignature = await crypto.subtle.sign({ name: "RSA-PSS", saltLength: 32 }, pss, data); +console.log("pss", await crypto.subtle.verify({ name: "RSA-PSS", saltLength: 32 }, pssPublic, pssSignature, data), + await crypto.subtle.verify({ name: "RSA-PSS", saltLength: 0 }, pssPublic, pssSignature, data)); +console.log(ecPrivate instanceof CryptoKey, String(ecPublic), Object.prototype.toString.call(rsaPublic)); diff --git a/tests/corpus/7086-webcrypto-ecdsa-rsa-errors.mjs b/tests/corpus/7086-webcrypto-ecdsa-rsa-errors.mjs new file mode 100644 index 000000000..62292fbdd --- /dev/null +++ b/tests/corpus/7086-webcrypto-ecdsa-rsa-errors.mjs @@ -0,0 +1,58 @@ +// WebCrypto ECDSA and RSA errors: Node's TypeErrors for missing algorithm +// members, and its DOMExceptions for curves, usages, key types, formats, +// extractability and JWK members, from generateKey, importKey, exportKey, +// sign and verify. + +const t = async (label, fn) => { try { const v = await fn(); console.log(label, "=>", v instanceof ArrayBuffer ? "AB" + v.byteLength : typeof v === "object" && v !== null ? JSON.stringify(v) : v); } catch (e) { console.log(label, "!!", e.name, e.code, e.message); } }; +const e3 = new Uint8Array([1, 0, 1]); +await t("rsa no hash", () => crypto.subtle.generateKey({ name: "RSASSA-PKCS1-v1_5", modulusLength: 1024, publicExponent: e3 }, true, ["sign"])); +await t("rsa no len", () => crypto.subtle.generateKey({ name: "RSASSA-PKCS1-v1_5", publicExponent: e3, hash: "SHA-256" }, true, ["sign"])); +await t("rsa no exp", () => crypto.subtle.generateKey({ name: "RSASSA-PKCS1-v1_5", modulusLength: 1024, hash: "SHA-256" }, true, ["sign"])); +await t("rsa bad usage", () => crypto.subtle.generateKey({ name: "RSASSA-PKCS1-v1_5", modulusLength: 1024, publicExponent: e3, hash: "SHA-256" }, true, ["encrypt"])); +await t("pss bad usage", () => crypto.subtle.generateKey({ name: "RSA-PSS", modulusLength: 1024, publicExponent: e3, hash: "SHA-256" }, true, ["encrypt"])); +await t("rsa bad hash", () => crypto.subtle.generateKey({ name: "RSASSA-PKCS1-v1_5", modulusLength: 1024, publicExponent: e3, hash: "MD5" }, true, ["sign"])); +await t("rsa exp 3", async () => (await crypto.subtle.generateKey({ name: "RSASSA-PKCS1-v1_5", modulusLength: 1024, publicExponent: new Uint8Array([3]), hash: "SHA-256" }, true, ["sign"])).publicKey.algorithm.publicExponent.length); +await t("rsa exp 4", () => crypto.subtle.generateKey({ name: "RSASSA-PKCS1-v1_5", modulusLength: 1024, publicExponent: new Uint8Array([4]), hash: "SHA-256" }, true, ["sign"])); +await t("rsa small", () => crypto.subtle.generateKey({ name: "RSASSA-PKCS1-v1_5", modulusLength: 256, publicExponent: e3, hash: "SHA-256" }, true, ["sign"])); +await t("ecdsa no curve", () => crypto.subtle.generateKey({ name: "ECDSA" }, true, ["sign"])); +await t("unknown alg", () => crypto.subtle.generateKey({ name: "FOO" }, true, ["sign"])); +const ec = await crypto.subtle.generateKey({ name: "ECDSA", namedCurve: "P-256" }, true, ["sign", "verify"]); +await t("export bad format", () => crypto.subtle.exportKey("foo", ec.publicKey)); +await t("export not key", () => crypto.subtle.exportKey("spki", {})); +await t("export spki private", () => crypto.subtle.exportKey("spki", ec.privateKey)); +await t("export pkcs8 public", () => crypto.subtle.exportKey("pkcs8", ec.publicKey)); +await t("import raw private", () => crypto.subtle.importKey("raw", new Uint8Array(32), { name: "ECDSA", namedCurve: "P-256" }, true, ["sign"])); +await t("import pkcs8 verify", async () => crypto.subtle.importKey("pkcs8", await crypto.subtle.exportKey("pkcs8", ec.privateKey), { name: "ECDSA", namedCurve: "P-256" }, true, ["verify"])); +await t("import pkcs8 empty", async () => crypto.subtle.importKey("pkcs8", await crypto.subtle.exportKey("pkcs8", ec.privateKey), { name: "ECDSA", namedCurve: "P-256" }, true, [])); +await t("import spki empty", async () => (await crypto.subtle.importKey("spki", await crypto.subtle.exportKey("spki", ec.publicKey), { name: "ECDSA", namedCurve: "P-256" }, true, [])).usages); +await t("import no curve", async () => crypto.subtle.importKey("spki", await crypto.subtle.exportKey("spki", ec.publicKey), { name: "ECDSA" }, true, ["verify"])); +await t("import rsa no hash", async () => crypto.subtle.importKey("spki", await crypto.subtle.exportKey("spki", ec.publicKey), { name: "RSASSA-PKCS1-v1_5" }, true, ["verify"])); +await t("import ec as rsa", async () => crypto.subtle.importKey("spki", await crypto.subtle.exportKey("spki", ec.publicKey), { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" }, true, ["verify"])); +await t("import jwk bad", () => crypto.subtle.importKey("jwk", { kty: "EC", crv: "P-256", x: "AA", y: "AA" }, { name: "ECDSA", namedCurve: "P-256" }, true, ["verify"])); +await t("import jwk crv mismatch", async () => crypto.subtle.importKey("jwk", await crypto.subtle.exportKey("jwk", ec.publicKey), { name: "ECDSA", namedCurve: "P-384" }, true, ["verify"])); +await t("import jwk kty", async () => crypto.subtle.importKey("jwk", { ...(await crypto.subtle.exportKey("jwk", ec.publicKey)), kty: "RSA" }, { name: "ECDSA", namedCurve: "P-256" }, true, ["verify"])); +await t("jwk ext false", async () => crypto.subtle.importKey("jwk", { ...(await crypto.subtle.exportKey("jwk", ec.publicKey)), ext: false }, { name: "ECDSA", namedCurve: "P-256" }, true, ["verify"])); +await t("jwk key_ops", async () => crypto.subtle.importKey("jwk", { ...(await crypto.subtle.exportKey("jwk", ec.publicKey)), key_ops: ["sign"] }, { name: "ECDSA", namedCurve: "P-256" }, true, ["verify"])); +const data = new Uint8Array([1, 2, 3]); +const spki = await crypto.subtle.exportKey("spki", ec.publicKey); +const rsa = await crypto.subtle.generateKey({ name: "RSASSA-PKCS1-v1_5", modulusLength: 1024, publicExponent: new Uint8Array([1, 0, 1]), hash: "SHA-256" }, false, ["sign", "verify"]); +const pss = await crypto.subtle.generateKey({ name: "RSA-PSS", modulusLength: 1024, publicExponent: new Uint8Array([1, 0, 1]), hash: "SHA-384" }, true, ["sign", "verify"]); +await t("export nonextractable", () => crypto.subtle.exportKey("pkcs8", rsa.privateKey)); +await t("export raw private", () => crypto.subtle.exportKey("raw", ec.privateKey)); +await t("sign with public", () => crypto.subtle.sign({ name: "ECDSA", hash: "SHA-256" }, ec.publicKey, data)); +await t("sign wrong alg", () => crypto.subtle.sign("RSASSA-PKCS1-v1_5", ec.privateKey, data)); +await t("ecdsa no hash", () => crypto.subtle.sign({ name: "ECDSA" }, ec.privateKey, data)); +await t("bad curve", () => crypto.subtle.generateKey({ name: "ECDSA", namedCurve: "P-999" }, true, ["sign"])); +await t("bad usage", () => crypto.subtle.generateKey({ name: "ECDSA", namedCurve: "P-256" }, true, ["encrypt"])); +await t("empty usages", () => crypto.subtle.generateKey({ name: "ECDSA", namedCurve: "P-256" }, true, [])); +await t("verify usage only", async () => { const k = await crypto.subtle.generateKey({ name: "ECDSA", namedCurve: "P-384" }, true, ["verify"]); return k.privateKey.usages + "|" + k.publicKey.usages; }); +await t("import wrong curve", () => crypto.subtle.importKey("spki", spki, { name: "ECDSA", namedCurve: "P-384" }, true, ["verify"])); +await t("import sign usage public", () => crypto.subtle.importKey("spki", spki, { name: "ECDSA", namedCurve: "P-256" }, true, ["sign"])); +await t("import garbage", () => crypto.subtle.importKey("spki", new Uint8Array([1, 2, 3]), { name: "ECDSA", namedCurve: "P-256" }, true, ["verify"])); +await t("pss no salt", () => crypto.subtle.sign({ name: "RSA-PSS" }, pss.privateKey, data)); +await t("verify bad sig len", () => crypto.subtle.verify({ name: "ECDSA", hash: "SHA-256" }, ec.publicKey, new Uint8Array(10), data)); +await t("verify with private", () => crypto.subtle.verify({ name: "ECDSA", hash: "SHA-256" }, ec.privateKey, new Uint8Array(64), data)); +await t("sign hmac with ec", () => crypto.subtle.sign("HMAC", ec.privateKey, data)); +await t("sign ec hash obj", async () => (await crypto.subtle.sign({ name: "ECDSA", hash: { name: "SHA-512" } }, ec.privateKey, data)).byteLength); +await t("p521", async () => (await crypto.subtle.sign({ name: "ECDSA", hash: "SHA-256" }, (await crypto.subtle.generateKey({ name: "ECDSA", namedCurve: "P-521" }, false, ["sign"])).privateKey, data)).byteLength); +await t("raw export p384", async () => (await crypto.subtle.exportKey("raw", (await crypto.subtle.generateKey({ name: "ECDSA", namedCurve: "P-384" }, true, ["sign","verify"])).publicKey)).byteLength); diff --git a/tests/diagnostics/webcrypto-refusals.ts b/tests/diagnostics/webcrypto-refusals.ts index d162872fb..1d68813e8 100644 --- a/tests/diagnostics/webcrypto-refusals.ts +++ b/tests/diagnostics/webcrypto-refusals.ts @@ -1,17 +1,7 @@ -// The native WebCrypto surface is HMAC importKey('raw'), sign and verify, -// and the SHA-1/SHA-2 digests, called directly on crypto.subtle. The 'jwk' -// key format and crypto.subtle or its methods taken as values are refused -// by name; the bundled declarations omit the other SubtleCrypto methods +// The native WebCrypto methods are called directly on crypto.subtle: +// crypto.subtle or its methods taken as values are refused by name; the +// bundled declarations omit the other SubtleCrypto methods // (node-types/fenced.ts pins their fence under @types/node). -const fromJwk = await crypto.subtle.importKey( - "jwk", - { kty: "oct", k: "c2VjcmV0" }, - { name: "HMAC", hash: "SHA-256" }, - false, - ["sign"], -); -console.log(fromJwk.type); - const subtle = crypto.subtle; console.log(typeof subtle); diff --git a/tests/fixtures/node-types/fenced.ts b/tests/fixtures/node-types/fenced.ts index 16a74081f..622f9cad3 100644 --- a/tests/fixtures/node-types/fenced.ts +++ b/tests/fixtures/node-types/fenced.ts @@ -69,11 +69,11 @@ http2.createSecureServer({ http2.createSecureServer({ allowHTTP1: true, cert: "pem", key: "pem", streamResetBurst: 1 + 0 }); http2.connect("https://localhost"); /* The crypto surface beyond the lowered slice (randomness, the hash - * chain, the introspection statics): asymmetric-key operations name the - * missing public-key stack, symmetric ciphers the missing cipher stack, - * prime checks theirs, and setFips the FIPS truth (getFips() lowers to 0). */ -import { checkPrimeSync, createCipheriv, generateKeyPair, setFips } from "node:crypto"; -generateKeyPair("rsa", { modulusLength: 2048 }, () => {}); + * chain, the introspection statics): Diffie-Hellman names the lowered + * asymmetric surface, symmetric ciphers the missing cipher stack, prime + * checks theirs, and setFips the FIPS truth (getFips() lowers to 0). */ +import { checkPrimeSync, createCipheriv, createDiffieHellman, setFips } from "node:crypto"; +createDiffieHellman(512); createCipheriv("aes-128-ccm", Buffer.alloc(16), Buffer.alloc(12), { authTagLength: 16 }); checkPrimeSync(7n); setFips(false); @@ -103,9 +103,9 @@ cipherStream.on("data", () => {}); import { createECDH } from "node:crypto"; createECDH("sect163k1"); createECDH("prime256v1").computeSecret(Buffer.alloc(65), "hex"); -/* WebCrypto beyond the HMAC slice: @types/node declares the whole - * SubtleCrypto surface, and the methods outside importKey, sign, verify - * and digest fence by name. */ +/* WebCrypto beyond the lowered methods: @types/node declares the whole + * SubtleCrypto surface, and the methods outside generateKey, importKey, + * exportKey, sign, verify and digest fence by name. */ async function encryptWithWebCrypto(key: import("node:crypto").webcrypto.CryptoKey): Promise { await crypto.subtle.encrypt({ name: "AES-GCM", iv: new Uint8Array(12) }, key, new Uint8Array(1)); } diff --git a/tests/fixtures/node-types/keys.ts b/tests/fixtures/node-types/keys.ts new file mode 100644 index 000000000..ba91f5d18 --- /dev/null +++ b/tests/fixtures/node-types/keys.ts @@ -0,0 +1,43 @@ +import { + type KeyObject, + createPrivateKey, + createPublicKey, + createSign, + createVerify, + generateKeyPair, + generateKeyPairSync, + sign, + verify, +} from "node:crypto"; + +const { publicKey, privateKey } = generateKeyPairSync("ec", { namedCurve: "P-256" }); +const data = Buffer.from("typed keys"); +const signature: Buffer = sign("sha256", data, privateKey); +console.log(publicKey.type, privateKey.asymmetricKeyType, verify("sha256", data, publicKey, signature)); +const pem = privateKey.export({ type: "pkcs8", format: "pem" }); +const parsed: KeyObject = createPrivateKey(pem); +console.log(parsed.equals(privateKey), createPublicKey(parsed).equals(publicKey)); +const pems = generateKeyPairSync("rsa", { + modulusLength: 1024, + publicKeyEncoding: { type: "spki", format: "pem" }, + privateKeyEncoding: { type: "pkcs8", format: "pem" }, +}); +const signer = createSign("SHA256"); +signer.update("typed"); +const hex: string = signer.sign(pems.privateKey, "hex"); +const verifier = createVerify("SHA256"); +verifier.update("typed"); +console.log(pems.publicKey.split("\n")[0], verifier.verify(pems.publicKey, hex, "hex")); +const ed = generateKeyPairSync("ed25519"); +const edSignature: Buffer = sign(null, data, ed.privateKey); +console.log(ed.publicKey.asymmetricKeyType, edSignature.length, verify(null, data, ed.publicKey, edSignature)); +const edJwk = ed.publicKey.export({ format: "jwk" }); +console.log(edJwk.kty, edJwk.crv, createPublicKey({ key: edJwk, format: "jwk" }).equals(ed.publicKey)); +const edDer = generateKeyPairSync("ed25519", { + publicKeyEncoding: { type: "spki", format: "der" }, + privateKeyEncoding: { type: "pkcs8", format: "der" }, +}); +console.log(edDer.publicKey.length, edDer.privateKey.length); +generateKeyPair("rsa", { modulusLength: 1024 }, (err, rsaPublic, rsaPrivate) => { + console.log(err, rsaPublic.asymmetricKeyDetails?.modulusLength, rsaPrivate.type); +}); diff --git a/tests/fixtures/node-types/webcrypto-ecdsa.ts b/tests/fixtures/node-types/webcrypto-ecdsa.ts new file mode 100644 index 000000000..2ec7cc4a7 --- /dev/null +++ b/tests/fixtures/node-types/webcrypto-ecdsa.ts @@ -0,0 +1,34 @@ +/* WebCrypto ECDSA, Ed25519 and RSA under @types/node: generateKey, exportKey, + * importKey, sign and verify lower to the same native values as under the + * bundled declarations. */ +import type { webcrypto } from "node:crypto"; + +async function main(): Promise { + const data = new TextEncoder().encode("node-types"); + const params: webcrypto.EcKeyGenParams = { name: "ECDSA", namedCurve: "P-384" }; + const pair: webcrypto.CryptoKeyPair = await crypto.subtle.generateKey(params, true, ["sign", "verify"]); + const ecdsa: webcrypto.EcdsaParams = { name: "ECDSA", hash: "SHA-384" }; + const signature = await crypto.subtle.sign(ecdsa, pair.privateKey, data); + console.log(pair.privateKey.type, signature.byteLength, await crypto.subtle.verify(ecdsa, pair.publicKey, signature, data)); + const spki = await crypto.subtle.exportKey("spki", pair.publicKey); + const imported = await crypto.subtle.importKey("spki", spki, { name: "ECDSA", namedCurve: "P-384" }, false, ["verify"]); + const algorithm = imported.algorithm as webcrypto.EcKeyAlgorithm; + console.log(algorithm.name, algorithm.namedCurve, await crypto.subtle.verify(ecdsa, imported, signature, data)); + const jwk: webcrypto.JsonWebKey = await crypto.subtle.exportKey("jwk", pair.privateKey); + console.log(jwk.kty, jwk.crv, jwk.key_ops?.join(",")); + const rsa = await crypto.subtle.generateKey( + { name: "RSA-PSS", modulusLength: 1024, publicExponent: new Uint8Array([1, 0, 1]), hash: "SHA-256" }, + false, + ["sign", "verify"], + ); + const pss: webcrypto.RsaPssParams = { name: "RSA-PSS", saltLength: 32 }; + const rsaSignature = await crypto.subtle.sign(pss, rsa.privateKey, data); + console.log(rsaSignature.byteLength, await crypto.subtle.verify(pss, rsa.publicKey, rsaSignature, data)); + const ed = (await crypto.subtle.generateKey("Ed25519", true, ["sign", "verify"])) as webcrypto.CryptoKeyPair; + const edSignature = await crypto.subtle.sign("Ed25519", ed.privateKey, data); + const raw = await crypto.subtle.exportKey("raw", ed.publicKey); + const edPublic = await crypto.subtle.importKey("raw", raw, "Ed25519", true, ["verify"]); + console.log(edPublic.algorithm.name, raw.byteLength, edSignature.byteLength, await crypto.subtle.verify("Ed25519", edPublic, edSignature, data)); +} + +void main(); diff --git a/tests/harness/__snapshots__/node-types-fenced.txt b/tests/harness/__snapshots__/node-types-fenced.txt index 0bd13963d..93a687267 100644 --- a/tests/harness/__snapshots__/node-types-fenced.txt +++ b/tests/harness/__snapshots__/node-types-fenced.txt @@ -115,18 +115,18 @@ fenced.ts:69:71 - error SC2020: 'createSecureServer option 'streamResetBurst' wi hint: h2 session-tuning options are accepted with literal values but are not applied yet -fenced.ts:76:1 - error SC2020: 'crypto.generateKeyPair' is typed by @types/node but has no scriptc lowering yet +fenced.ts:76:1 - error SC2020: 'crypto.createDiffieHellman' is typed by @types/node but has no scriptc lowering yet - 75 | import { checkPrimeSync, createCipheriv, generateKeyPair, setFips } from "node:crypto"; - 76 | generateKeyPair("rsa", { modulusLength: 2048 }, () => {}); - | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + 75 | import { checkPrimeSync, createCipheriv, createDiffieHellman, setFips } from "node:crypto"; + 76 | createDiffieHellman(512); + | ^~~~~~~~~~~~~~~~~~~~~~~~ 77 | createCipheriv("aes-128-ccm", Buffer.alloc(16), Buffer.alloc(12), { authTagLength: 16 }); - hint: asymmetric-key operations need a public-key stack (bignum, RSA/EC/EdDSA math) and public and private KeyObjects — neither exists in the static runtime, so no faithful lowering can be small; the lowered crypto surface is hashing, randomness, secret KeyObjects, and the introspection statics + hint: Diffie-Hellman and RSA encryption have no lowering — the asymmetric crypto surface is RSA and EC KeyObjects (generateKeyPair, createPrivateKey, createPublicKey), sign, verify, createSign, createVerify, and createECDH fenced.ts:77:16 - error SC2020: 'crypto.createCipheriv with cipher 'aes-128-ccm'' is part of the standard library types but has no scriptc lowering yet - 76 | generateKeyPair("rsa", { modulusLength: 2048 }, () => {}); + 76 | createDiffieHellman(512); 77 | createCipheriv("aes-128-ccm", Buffer.alloc(16), Buffer.alloc(12), { authTagLength: 16 }); | ^~~~~~~~~~~~~ 78 | checkPrimeSync(7n); @@ -228,7 +228,7 @@ fenced.ts:105:1 - error SC2020: 'ECDH.computeSecret(key, encoding) with a Buffer 104 | createECDH("sect163k1"); 105 | createECDH("prime256v1").computeSecret(Buffer.alloc(65), "hex"); | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - 106 | /* WebCrypto beyond the HMAC slice: @types/node declares the whole + 106 | /* WebCrypto beyond the lowered methods: @types/node declares the whole hint: Node reads the second argument as the key's input encoding and answers a Buffer; pass the output encoding third: computeSecret(key, undefined, encoding) @@ -239,7 +239,7 @@ fenced.ts:110:9 - error SC2020: 'crypto.subtle.encrypt' is part of the standard | ^~~~~~~~~~~~~~~~~~~~~ 111 | } - hint: the native WebCrypto surface is crypto.subtle.importKey('raw', ...) for HMAC keys, sign and verify with HMAC, and digest with SHA-1, SHA-256, SHA-384 or SHA-512, each called directly on crypto.subtle + hint: the native WebCrypto surface is crypto.subtle.importKey('raw', ...) for HMAC keys, sign and verify with HMAC, generateKey, importKey, exportKey, sign and verify for ECDSA, Ed25519, RSASSA-PKCS1-v1_5 and RSA-PSS, and digest with SHA-1, SHA-256, SHA-384 or SHA-512, each called directly on crypto.subtle fenced.ts:115:15 - error SC2020: 'navigator.hardwareConcurrency' is typed by @types/node but has no scriptc lowering yet diff --git a/tests/harness/__snapshots__/webcrypto-refusals.ts.txt b/tests/harness/__snapshots__/webcrypto-refusals.ts.txt index 521edff3c..2821d8306 100644 --- a/tests/harness/__snapshots__/webcrypto-refusals.ts.txt +++ b/tests/harness/__snapshots__/webcrypto-refusals.ts.txt @@ -1,26 +1,17 @@ -webcrypto-refusals.ts:7:3 - error SC2020: 'crypto.subtle.importKey with the 'jwk' key format' is part of the standard library types but has no scriptc lowering yet +webcrypto-refusals.ts:5:16 - error SC2020: 'crypto.subtle as a value' is part of the standard library types but has no scriptc lowering yet - 6 | const fromJwk = await crypto.subtle.importKey( - 7 | "jwk", - | ^~~~~ - 8 | { kty: "oct", k: "c2VjcmV0" }, + 4 | // (node-types/fenced.ts pins their fence under @types/node). + 5 | const subtle = crypto.subtle; + | ^~~~~~~~~~~~~ + 6 | console.log(typeof subtle); - hint: the native WebCrypto surface is crypto.subtle.importKey('raw', ...) for HMAC keys, sign and verify with HMAC, and digest with SHA-1, SHA-256, SHA-384 or SHA-512, each called directly on crypto.subtle + hint: the native WebCrypto surface is crypto.subtle.importKey('raw', ...) for HMAC keys, sign and verify with HMAC, generateKey, importKey, exportKey, sign and verify for ECDSA, Ed25519, RSASSA-PKCS1-v1_5 and RSA-PSS, and digest with SHA-1, SHA-256, SHA-384 or SHA-512, each called directly on crypto.subtle -webcrypto-refusals.ts:15:16 - error SC2020: 'crypto.subtle as a value' is part of the standard library types but has no scriptc lowering yet +webcrypto-refusals.ts:8:20 - error SC2020: 'crypto.subtle.sign as a value' is part of the standard library types but has no scriptc lowering yet - 14 | - 15 | const subtle = crypto.subtle; - | ^~~~~~~~~~~~~ - 16 | console.log(typeof subtle); + 7 | + 8 | console.log(typeof crypto.subtle.sign); + | ^~~~~~~~~~~~~~~~~~ + 9 | - hint: the native WebCrypto surface is crypto.subtle.importKey('raw', ...) for HMAC keys, sign and verify with HMAC, and digest with SHA-1, SHA-256, SHA-384 or SHA-512, each called directly on crypto.subtle - -webcrypto-refusals.ts:18:20 - error SC2020: 'crypto.subtle.sign as a value' is part of the standard library types but has no scriptc lowering yet - - 17 | - 18 | console.log(typeof crypto.subtle.sign); - | ^~~~~~~~~~~~~~~~~~ - 19 | - - hint: the native WebCrypto surface is crypto.subtle.importKey('raw', ...) for HMAC keys, sign and verify with HMAC, and digest with SHA-1, SHA-256, SHA-384 or SHA-512, each called directly on crypto.subtle \ No newline at end of file + hint: the native WebCrypto surface is crypto.subtle.importKey('raw', ...) for HMAC keys, sign and verify with HMAC, generateKey, importKey, exportKey, sign and verify for ECDSA, Ed25519, RSASSA-PKCS1-v1_5 and RSA-PSS, and digest with SHA-1, SHA-256, SHA-384 or SHA-512, each called directly on crypto.subtle \ No newline at end of file diff --git a/tests/harness/corpus-costs/7080-crypto-ed25519.mjs.json b/tests/harness/corpus-costs/7080-crypto-ed25519.mjs.json new file mode 100644 index 000000000..8a1e96b68 --- /dev/null +++ b/tests/harness/corpus-costs/7080-crypto-ed25519.mjs.json @@ -0,0 +1 @@ +{ "plain": 4906, "san": 50709 } diff --git a/tests/harness/corpus-costs/7081-webcrypto-ed25519.mjs.json b/tests/harness/corpus-costs/7081-webcrypto-ed25519.mjs.json new file mode 100644 index 000000000..47b28eca2 --- /dev/null +++ b/tests/harness/corpus-costs/7081-webcrypto-ed25519.mjs.json @@ -0,0 +1 @@ +{ "plain": 7958, "san": 51204 } diff --git a/tests/harness/corpus-costs/7082-crypto-key-objects.ts.json b/tests/harness/corpus-costs/7082-crypto-key-objects.ts.json new file mode 100644 index 000000000..b0d8e50c9 --- /dev/null +++ b/tests/harness/corpus-costs/7082-crypto-key-objects.ts.json @@ -0,0 +1 @@ +{ "plain": 4405, "san": 7280 } diff --git a/tests/harness/corpus-costs/7083-crypto-sign-verify.ts.json b/tests/harness/corpus-costs/7083-crypto-sign-verify.ts.json new file mode 100644 index 000000000..650393982 --- /dev/null +++ b/tests/harness/corpus-costs/7083-crypto-sign-verify.ts.json @@ -0,0 +1 @@ +{ "plain": 3631, "san": 5127 } diff --git a/tests/harness/corpus-costs/7084-crypto-key-pairs.cjs.json b/tests/harness/corpus-costs/7084-crypto-key-pairs.cjs.json new file mode 100644 index 000000000..363a8de39 --- /dev/null +++ b/tests/harness/corpus-costs/7084-crypto-key-pairs.cjs.json @@ -0,0 +1 @@ +{ "plain": 6267, "san": 19680 } diff --git a/tests/harness/corpus-costs/7085-webcrypto-ecdsa-rsa.ts.json b/tests/harness/corpus-costs/7085-webcrypto-ecdsa-rsa.ts.json new file mode 100644 index 000000000..73c07085d --- /dev/null +++ b/tests/harness/corpus-costs/7085-webcrypto-ecdsa-rsa.ts.json @@ -0,0 +1 @@ +{ "plain": 5184, "san": 40791 } diff --git a/tests/harness/corpus-costs/7086-webcrypto-ecdsa-rsa-errors.mjs.json b/tests/harness/corpus-costs/7086-webcrypto-ecdsa-rsa-errors.mjs.json new file mode 100644 index 000000000..a74af7ae1 --- /dev/null +++ b/tests/harness/corpus-costs/7086-webcrypto-ecdsa-rsa-errors.mjs.json @@ -0,0 +1 @@ +{ "plain": 8513, "san": 13054 } diff --git a/tests/harness/errors.test.ts b/tests/harness/errors.test.ts index 8af6998ca..de73c6289 100644 --- a/tests/harness/errors.test.ts +++ b/tests/harness/errors.test.ts @@ -1641,7 +1641,7 @@ console.log(typeof promisePrototype, typeof promisePrototype.then, promiseProtot // Node's own rejections (unknown names, bad usages) are corpus-pinned // (6292, 6294); these refusals have no Node twin, so they live here. describe("WebCrypto refusals (JS lane)", () => { - test("recognized algorithms outside the HMAC slice reject with SC2020", async () => { + test("recognized algorithms outside the lowered ones reject with SC2020", async () => { const r = await compileAndRun( "webcrypto-unsupported-algorithms", `const bytes = new TextEncoder().encode("secret"); @@ -1653,11 +1653,10 @@ async function attempt(label, run) { console.log(label, e.name, e.code, e.message); } } -await attempt("rsa", () => - crypto.subtle.importKey("raw", bytes, { name: "RSA-PSS", hash: "SHA-256" }, false, ["verify"]), -); +await attempt("aes", () => crypto.subtle.importKey("raw", bytes, { name: "AES-GCM" }, false, ["encrypt"])); const key = await crypto.subtle.importKey("raw", bytes, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]); -await attempt("ecdsa", () => crypto.subtle.sign({ name: "ECDSA", hash: "SHA-256" }, key, bytes)); +await attempt("ed448", () => crypto.subtle.sign({ name: "Ed448" }, key, bytes)); +await attempt("ecdsa with an hmac key", () => crypto.subtle.sign({ name: "ECDSA", hash: "SHA-256" }, key, bytes)); await attempt("sha3", () => crypto.subtle.digest("SHA3-256", bytes)); await attempt("sha3 hmac", () => crypto.subtle.importKey("raw", bytes, { name: "HMAC", hash: "SHA3-256" }, false, ["sign"]), @@ -1672,15 +1671,16 @@ await attempt("computed jwk", () => expect(r.exitCode).toBe(0); expect(r.stderr).toBe(""); expect(r.stdout).toBe( - "rsa Error SC2020 crypto.subtle.importKey with the RSA-PSS algorithm is not supported yet\n" + - "ecdsa Error SC2020 crypto.subtle.sign with the ECDSA algorithm is not supported yet\n" + + "aes Error SC2020 crypto.subtle.importKey with the AES-GCM algorithm is not supported yet\n" + + "ed448 Error SC2020 crypto.subtle.sign with the Ed448 algorithm is not supported yet\n" + + "ecdsa with an hmac key InvalidAccessError 15 Key algorithm mismatch\n" + "sha3 Error SC2020 crypto.subtle.digest with the SHA3-256 algorithm is not supported yet\n" + "sha3 hmac Error SC2020 crypto.subtle.importKey with the SHA3-256 algorithm is not supported yet\n" + "computed jwk Error SC2020 crypto.subtle.importKey with the 'jwk' key format is not supported yet\n", ); }); - test("a literal 'jwk' import is a named fence where it runs", async () => { + test("a literal 'jwk' HMAC import rejects with SC2020", async () => { const r = await compileAndRun( "webcrypto-jwk-literal", `console.log("before"); @@ -1690,8 +1690,59 @@ await crypto.subtle.importKey("jwk", { kty: "oct", k: "c2VjcmV0" }, { name: "HMA ); expect(r.exitCode).toBe(1); expect(r.stdout).toBe("before\n"); - expect(r.stderr).toMatch( - /^Uncaught Error: 'crypto\.subtle\.importKey with the 'jwk' key format' is part of the standard library types but has no scriptc lowering yet.*\n$/, + expect(r.stderr).toBe( + "Uncaught Error: crypto.subtle.importKey with the 'jwk' key format is not supported yet [SC2020]\n", + ); + }); +}); + +// The Ed25519 arithmetic (scr_ed25519.c) links only into programs whose +// string literals name Ed25519. Without it, an Ed25519 public key still +// imports and exports, while private-key parsing, signing and verification +// reject with a coded SC2020 Error where Node answers; there is no Node +// twin, so this lives here. The corpus (7080, 7081) pins the linked path. +describe("Ed25519 without the Ed25519 unit (JS lane)", () => { + test("a program that never names Ed25519 refuses its arithmetic with SC2020", async () => { + const r = await compileAndRun( + "ed25519-unit-not-linked", + `import * as c from "node:crypto"; +const spki = Buffer.from("302a300506032b6570032100d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a", "hex"); +const pkcs8 = Buffer.from("302e020100300506032b6570042204209d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60", "hex"); +const pub = c.createPublicKey({ key: spki, format: "der", type: "spki" }); +console.log(pub.asymmetricKeyType, pub.export({ format: "jwk" }).x); +async function attempt(label, run) { + try { + await run(); + console.log(label, "resolved"); + } catch (e) { + console.log(label, e.name, e.code, e.message); + } +} +await attempt("pkcs8", () => c.createPrivateKey({ key: pkcs8, format: "der", type: "pkcs8" })); +await attempt("verify", () => c.verify(null, Buffer.from("x"), pub, Buffer.alloc(64))); +// ECDSA links the WebCrypto key unit; the Ed25519 name is built at run time. +const ecdsa = await crypto.subtle.generateKey({ name: "ECDSA", namedCurve: "P-256" }, false, ["sign"]); +console.log(ecdsa.privateKey.type); +const name = ["Ed", "25519"].join(""); +await attempt("generateKey", () => crypto.subtle.generateKey(name, false, ["sign", "verify"])); +await attempt("importKey", () => crypto.subtle.importKey("pkcs8", pkcs8, name, false, ["sign"])); +const raw = await crypto.subtle.importKey("raw", spki.subarray(12), name, false, ["verify"]); +await attempt("subtle verify", () => crypto.subtle.verify(name, raw, new Uint8Array(64), new Uint8Array(1))); +`, + "mjs", + ); + const refusal = + "Error SC2020 Ed25519 keys are supported when a string literal in the program names 'ed25519'"; + expect(r.exitCode).toBe(0); + expect(r.stderr).toBe(""); + expect(r.stdout).toBe( + "ed25519 11qYAYKxCrfVS_7TyWQHOg7hcvPapiMlrwIaaPcHURo\n" + + `pkcs8 ${refusal}\n` + + `verify ${refusal}\n` + + "private\n" + + `generateKey ${refusal}\n` + + `importKey ${refusal}\n` + + `subtle verify ${refusal}\n`, ); }); }); diff --git a/tests/harness/library-asyncfree.test.ts b/tests/harness/library-asyncfree.test.ts index 7c4d029cc..d924f26d1 100644 --- a/tests/harness/library-asyncfree.test.ts +++ b/tests/harness/library-asyncfree.test.ts @@ -97,6 +97,15 @@ describe("async_free detection over the IR", () => { ).toContain("child_process"); }); + test("asymmetric keys and signatures refuse", async () => { + expect( + await surfaceOf( + "pki", + `import * as crypto from "node:crypto";\nconst { privateKey } = crypto.generateKeyPairSync("ec", { namedCurve: "P-256" });\nconsole.log(crypto.sign("sha256", Buffer.from("x"), privateKey).length > 0);\n`, + ), + ).toContain("asymmetric KeyObjects"); + }); + test("process signal listeners refuse", async () => { expect( await surfaceOf( diff --git a/tests/harness/project-config.test.ts b/tests/harness/project-config.test.ts index dabb9b0bf..186ded475 100644 --- a/tests/harness/project-config.test.ts +++ b/tests/harness/project-config.test.ts @@ -1114,6 +1114,38 @@ test("node-types: ECDH matches Node under @types/node", async () => { expect(comparableStderr(native.stderr)).toBe(node.stderr); }); +test("node-types: asymmetric keys and signatures match Node under @types/node", async () => { + const outDir = outDirFor("node-keys"); + const entry = join(nodeTypesDir, "keys.ts"); + const result = await compile(entry, { outPath: join(outDir, "keys"), outDir, sanitize }); + expect(result.ok, !result.ok ? JSON.stringify(result.diagnostics, null, 2) : "").toBe(true); + if (!result.ok) return; + const [native, node] = await Promise.all([ + execFileAsync(result.binaryPath), + execFileAsync(process.execPath, ["--disable-warning=MODULE_TYPELESS_PACKAGE_JSON", entry]), + ]); + expect(native.stdout).toBe(node.stdout); + expect(comparableStderr(native.stderr)).toBe(node.stderr); +}); + +test("node-types: WebCrypto ECDSA, Ed25519 and RSA match Node under @types/node", async () => { + const outDir = outDirFor("node-webcrypto-ecdsa"); + const entry = join(nodeTypesDir, "webcrypto-ecdsa.ts"); + const result = await compile(entry, { + outPath: join(outDir, "webcrypto-ecdsa"), + outDir, + sanitize, + }); + expect(result.ok, !result.ok ? JSON.stringify(result.diagnostics, null, 2) : "").toBe(true); + if (!result.ok) return; + const [native, node] = await Promise.all([ + execFileAsync(result.binaryPath), + execFileAsync(process.execPath, ["--disable-warning=MODULE_TYPELESS_PACKAGE_JSON", entry]), + ]); + expect(native.stdout).toBe(node.stdout); + expect(comparableStderr(native.stderr)).toBe(node.stderr); +}); + test("node-types: WebCrypto HMAC matches Node under @types/node", async () => { const outDir = outDirFor("node-webcrypto-hmac"); const entry = join(nodeTypesDir, "webcrypto-hmac.ts"); diff --git a/tests/harness/self-hosting-native-toolchain.test.ts b/tests/harness/self-hosting-native-toolchain.test.ts index 7da7626b7..d1dc52c7a 100644 --- a/tests/harness/self-hosting-native-toolchain.test.ts +++ b/tests/harness/self-hosting-native-toolchain.test.ts @@ -48,6 +48,8 @@ const features: NativeLinkFeatures = { tlsCa: false, cipher: false, ecdh: false, + pki: false, + ed25519: false, webcrypto: false, perfLoop: false, }; diff --git a/tests/harness/self-hosting-runtime-pack.test.ts b/tests/harness/self-hosting-runtime-pack.test.ts index f4fde795c..908bdc5bb 100644 --- a/tests/harness/self-hosting-runtime-pack.test.ts +++ b/tests/harness/self-hosting-runtime-pack.test.ts @@ -49,6 +49,8 @@ const base: NativeLinkFeatures = { tlsCa: false, cipher: false, ecdh: false, + pki: false, + ed25519: false, webcrypto: false, perfLoop: false, }; From 1773ffbef35e8ffb2cdfb060278ac316df85116d Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 02:52:01 -0500 Subject: [PATCH 035/102] WebCrypto: the crypto global, node:crypto's webcrypto, and secret-key SubtleCrypto --- .../limitations/builtin-apis/crypto.mdx | 3 + .../src/generated/node-v24-compatibility.json | 58 +- .../generated/node-v24-internal.json | 198 ++- internal/compatibility/static-support.json | 11 +- .../ambient/scriptc-node-fallback.d.ts | 103 +- .../compiler/src/backend/llvm/lib-shared.ts | 12 + .../src/backend/native-link-info-core.ts | 5 +- .../compiler/src/backend/native/contracts.ts | 5 +- .../compiler/src/backend/native/executable.ts | 3 + .../src/backend/target-diagnostics.ts | 8 + .../src/frontend/lowering/builtins/crypto.ts | 5 +- .../frontend/lowering/builtins/webcrypto.ts | 60 +- .../lowering/expressions/identifiers.ts | 5 +- .../lowering/expressions/property-access.ts | 14 +- .../src/frontend/lowering/lower-calls.ts | 35 +- .../src/frontend/lowering/lower-stmts.ts | 10 +- .../compiler/src/frontend/lowering/lowerer.ts | 4 + .../src/frontend/lowering/surfaces.ts | 20 +- packages/compiler/src/frontend/type-mapper.ts | 10 + .../compiler/src/ir/builtin-signatures.ts | 7 + packages/compiler/src/ir/runtime-features.ts | 14 +- packages/compiler/surface-manifest.json | 12 +- .../corpus/7120-webcrypto-random-uuid.ts.json | 6 + .../7121-webcrypto-crypto-object.mjs.json | 6 + .../corpus/7122-webcrypto-node-crypto.ts.json | 6 + .../7123-webcrypto-node-crypto.cjs.json | 6 + .../corpus/7124-webcrypto-secret-keys.ts.json | 6 + .../corpus/7125-webcrypto-key-errors.mjs.json | 6 + .../tests/corpus/7126-webcrypto-aes.ts.json | 6 + .../corpus/7127-webcrypto-aes-errors.mjs.json | 6 + .../corpus/7128-webcrypto-derive.ts.json | 6 + .../7129-webcrypto-derive-errors.mjs.json | 6 + .../node-types/webcrypto-keys.ts.json | 6 + .../runtime-darwin-arm64/scripts/build.mjs | 3 +- .../runtime-pack-matrix.mjs | 4 + .../runtime-pack-common/scripts/build.mjs | 3 +- .../runtime-wasm32-wasi/scripts/build.mjs | 1 + packages/runtime/src/scr_crypto.h | 44 +- packages/runtime/src/scr_webcrypto.c | 1372 +++++++++++++++-- packages/runtime/src/scr_webcrypto_aes.c | 137 ++ packages/runtime/src/scr_webcrypto_object.c | 53 + tests/corpus/7120-webcrypto-random-uuid.ts | 22 + tests/corpus/7121-webcrypto-crypto-object.mjs | 35 + tests/corpus/7122-webcrypto-node-crypto.ts | 38 + tests/corpus/7123-webcrypto-node-crypto.cjs | 31 + tests/corpus/7124-webcrypto-secret-keys.ts | 91 ++ tests/corpus/7125-webcrypto-key-errors.mjs | 95 ++ tests/corpus/7126-webcrypto-aes.ts | 77 + tests/corpus/7127-webcrypto-aes-errors.mjs | 71 + tests/corpus/7128-webcrypto-derive.ts | 45 + tests/corpus/7129-webcrypto-derive-errors.mjs | 72 + tests/diagnostics/webcrypto-refusals.ts | 19 +- tests/fixtures/node-types/fenced.ts | 12 +- tests/fixtures/node-types/webcrypto-keys.ts | 32 + .../__snapshots__/node-types-fenced.txt | 10 +- .../__snapshots__/webcrypto-refusals.ts.txt | 31 +- .../7120-webcrypto-random-uuid.ts.json | 1 + .../7121-webcrypto-crypto-object.mjs.json | 1 + .../7122-webcrypto-node-crypto.ts.json | 1 + .../7123-webcrypto-node-crypto.cjs.json | 1 + .../7124-webcrypto-secret-keys.ts.json | 1 + .../7125-webcrypto-key-errors.mjs.json | 1 + .../corpus-costs/7126-webcrypto-aes.ts.json | 1 + .../7127-webcrypto-aes-errors.mjs.json | 1 + .../7128-webcrypto-derive.ts.json | 1 + .../7129-webcrypto-derive-errors.mjs.json | 1 + tests/harness/errors.test.ts | 31 +- tests/harness/project-config.test.ts | 18 + 68 files changed, 2688 insertions(+), 337 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7120-webcrypto-random-uuid.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7121-webcrypto-crypto-object.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7122-webcrypto-node-crypto.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7123-webcrypto-node-crypto.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7124-webcrypto-secret-keys.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7125-webcrypto-key-errors.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7126-webcrypto-aes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7127-webcrypto-aes-errors.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7128-webcrypto-derive.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7129-webcrypto-derive-errors.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/webcrypto-keys.ts.json create mode 100644 packages/runtime/src/scr_webcrypto_aes.c create mode 100644 packages/runtime/src/scr_webcrypto_object.c create mode 100644 tests/corpus/7120-webcrypto-random-uuid.ts create mode 100644 tests/corpus/7121-webcrypto-crypto-object.mjs create mode 100644 tests/corpus/7122-webcrypto-node-crypto.ts create mode 100644 tests/corpus/7123-webcrypto-node-crypto.cjs create mode 100644 tests/corpus/7124-webcrypto-secret-keys.ts create mode 100644 tests/corpus/7125-webcrypto-key-errors.mjs create mode 100644 tests/corpus/7126-webcrypto-aes.ts create mode 100644 tests/corpus/7127-webcrypto-aes-errors.mjs create mode 100644 tests/corpus/7128-webcrypto-derive.ts create mode 100644 tests/corpus/7129-webcrypto-derive-errors.mjs create mode 100644 tests/fixtures/node-types/webcrypto-keys.ts create mode 100644 tests/harness/corpus-costs/7120-webcrypto-random-uuid.ts.json create mode 100644 tests/harness/corpus-costs/7121-webcrypto-crypto-object.mjs.json create mode 100644 tests/harness/corpus-costs/7122-webcrypto-node-crypto.ts.json create mode 100644 tests/harness/corpus-costs/7123-webcrypto-node-crypto.cjs.json create mode 100644 tests/harness/corpus-costs/7124-webcrypto-secret-keys.ts.json create mode 100644 tests/harness/corpus-costs/7125-webcrypto-key-errors.mjs.json create mode 100644 tests/harness/corpus-costs/7126-webcrypto-aes.ts.json create mode 100644 tests/harness/corpus-costs/7127-webcrypto-aes-errors.mjs.json create mode 100644 tests/harness/corpus-costs/7128-webcrypto-derive.ts.json create mode 100644 tests/harness/corpus-costs/7129-webcrypto-derive-errors.mjs.json diff --git a/docs/content/limitations/builtin-apis/crypto.mdx b/docs/content/limitations/builtin-apis/crypto.mdx index 3c830c63d..b00ea438e 100644 --- a/docs/content/limitations/builtin-apis/crypto.mdx +++ b/docs/content/limitations/builtin-apis/crypto.mdx @@ -16,4 +16,7 @@ A call on an ECDH value whose arguments no @types/node overload accepts (`getPublicKey("HEX")`) is refused at compile time, as is `computeSecret(view, encoding)`: Node reads that encoding as the input encoding and answers a Buffer where @types/node declares a string. ECDH property reads and writes throw a coded SC2020 error. Other public-key operations remain unsupported. + The WebCrypto `crypto` global, which node:crypto also exports as `webcrypto`, supports `randomUUID()` and `getRandomValues()`, also read as values from untyped JavaScript. + Its `subtle` object, also node:crypto's `subtle` export, supports `generateKey()` and `exportKey()` for HMAC and AES keys, `importKey()` for HMAC, AES, PBKDF2, and HKDF keys, `encrypt()` and `decrypt()` with AES-GCM, AES-CBC, and AES-CTR on native targets, `deriveBits()` and `deriveKey()` with PBKDF2 and HKDF, HMAC `sign()` and `verify()`, and SHA-1 and SHA-2 `digest()`. + Secret keys import and export in the `raw`, `raw-secret`, and `jwk` formats; other SubtleCrypto methods, algorithms, and key formats are refused. Native derivations finish before their deferred callbacks, so computation blocks the caller. diff --git a/docs/src/generated/node-v24-compatibility.json b/docs/src/generated/node-v24-compatibility.json index 66b0ba3dd..2c09eb9be 100644 --- a/docs/src/generated/node-v24-compatibility.json +++ b/docs/src/generated/node-v24-compatibility.json @@ -12442,9 +12442,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 by a dedicated static compiler/runtime path.", + "verification": "test-backed" } }, { @@ -12465,9 +12465,9 @@ "inherited": true }, "static": { - "status": "refused", - "detail": "Explicitly rejected by a named compiler diagnostic.", - "verification": "explicit-refusal" + "status": "partial", + "detail": "Implemented by a dedicated static compiler/runtime path.", + "verification": "test-backed" } }, { @@ -79656,9 +79656,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" } }, { @@ -79680,7 +79680,7 @@ }, "static": { "status": "supported", - "detail": "Implemented by a dedicated static compiler/runtime path.", + "detail": "Implemented for the documented scriptc module-loader subset.", "verification": "test-backed" } }, @@ -79703,7 +79703,7 @@ }, "static": { "status": "supported", - "detail": "Implemented by a dedicated static compiler/runtime path.", + "detail": "Implemented for the documented scriptc module-loader subset.", "verification": "test-backed" } }, @@ -80001,9 +80001,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" } }, { @@ -80024,9 +80024,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" } }, { @@ -80047,9 +80047,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" } }, { @@ -80139,9 +80139,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" } }, { @@ -80162,9 +80162,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" } }, { @@ -80208,9 +80208,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" } }, { diff --git a/internal/compatibility/generated/node-v24-internal.json b/internal/compatibility/generated/node-v24-internal.json index c6a7a102c..c9f6dc6be 100644 --- a/internal/compatibility/generated/node-v24-internal.json +++ b/internal/compatibility/generated/node-v24-internal.json @@ -19313,6 +19313,8 @@ "tests/corpus/6703-ecdh-private-keys.ts", "tests/corpus/6704-ecdh-set-public-key.cjs", "tests/corpus/6705-ecdh-handles.ts", + "tests/corpus/7122-webcrypto-node-crypto.ts", + "tests/corpus/7123-webcrypto-node-crypto.cjs", "tests/corpus/node24-crypto-kdf-errors.ts", "tests/corpus/node24-crypto-kdf-options.ts", "tests/corpus/node24-crypto-kdf.ts", @@ -21215,8 +21217,12 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:crypto" + "status": "partial", + "evidence": "compiler-dedicated:subtle", + "tests": [ + "tests/corpus/7122-webcrypto-node-crypto.ts", + "tests/corpus/7123-webcrypto-node-crypto.cjs" + ] }, "anchorSource": "ancestor" }, @@ -21238,8 +21244,12 @@ "inherited": true }, "static": { - "status": "refused", - "evidence": "surface-manifest:unsupported:node-builtin.crypto.webcrypto" + "status": "partial", + "evidence": "compiler-dedicated:crypto.webcrypto", + "tests": [ + "tests/corpus/7122-webcrypto-node-crypto.ts", + "tests/corpus/7123-webcrypto-node-crypto.cjs" + ] }, "anchorSource": "exact" }, @@ -106607,8 +106617,6 @@ "tests/corpus/1534-crypto-hash-chain.ts", "tests/corpus/2556-crypto-introspection.ts", "tests/corpus/2890-crypto-static-utility.ts", - "tests/corpus/5442-crypto-random-values.ts", - "tests/corpus/5443-crypto-random-arguments.js", "tests/corpus/6204-crypto-get-random-values.ts", "tests/corpus/6205-crypto-get-random-values.js", "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", @@ -106616,11 +106624,20 @@ "tests/corpus/6293-webcrypto-digest.ts", "tests/corpus/6294-webcrypto-js-values.mjs", "tests/corpus/6295-jose-hs256/main.mjs", + "tests/corpus/7120-webcrypto-random-uuid.ts", + "tests/corpus/7121-webcrypto-crypto-object.mjs", + "tests/corpus/7124-webcrypto-secret-keys.ts", + "tests/corpus/7125-webcrypto-key-errors.mjs", + "tests/corpus/7126-webcrypto-aes.ts", + "tests/corpus/7127-webcrypto-aes-errors.mjs", + "tests/corpus/7128-webcrypto-derive.ts", + "tests/corpus/7129-webcrypto-derive-errors.mjs", "tests/corpus/node24-crypto-kdf-errors.ts", "tests/corpus/node24-crypto-kdf-options.ts", "tests/corpus/node24-crypto-kdf.ts", "tests/corpus/node24-crypto-sha2.ts", "tests/fixtures/node-types/webcrypto-hmac.ts", + "tests/fixtures/node-types/webcrypto-keys.ts", "tests/harness/npm-static.test.ts" ] }, @@ -110078,8 +110095,13 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:webcrypto" + "status": "partial", + "evidence": "compiler-feature:webcrypto.Crypto", + "tests": [ + "tests/corpus/7120-webcrypto-random-uuid.ts", + "tests/corpus/7121-webcrypto-crypto-object.mjs", + "tests/corpus/6293-webcrypto-digest.ts" + ] }, "anchorSource": "exact" }, @@ -110102,8 +110124,10 @@ }, "static": { "status": "supported", - "evidence": "compiler-dedicated:crypto.getRandomValues", + "evidence": "compiler-feature:webcrypto.crypto.getRandomValues", "tests": [ + "tests/corpus/7120-webcrypto-random-uuid.ts", + "tests/corpus/7121-webcrypto-crypto-object.mjs", "tests/corpus/6204-crypto-get-random-values.ts", "tests/corpus/6205-crypto-get-random-values.js" ] @@ -110129,11 +110153,12 @@ }, "static": { "status": "supported", - "evidence": "compiler-dedicated:crypto.randomUUID", + "evidence": "compiler-feature:webcrypto.crypto.randomUUID", "tests": [ - "tests/corpus/5442-crypto-random-values.ts", - "tests/corpus/5443-crypto-random-arguments.js", - "tests/corpus/1358-crypto-random.ts" + "tests/corpus/7120-webcrypto-random-uuid.ts", + "tests/corpus/7121-webcrypto-crypto-object.mjs", + "tests/corpus/6204-crypto-get-random-values.ts", + "tests/corpus/6205-crypto-get-random-values.js" ] }, "anchorSource": "exact" @@ -110189,6 +110214,7 @@ "status": "partial", "evidence": "compiler-feature:webcrypto.CryptoKey", "tests": [ + "tests/corpus/7124-webcrypto-secret-keys.ts", "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6294-webcrypto-js-values.mjs", "tests/corpus/6295-jose-hs256/main.mjs" @@ -110217,6 +110243,7 @@ "status": "partial", "evidence": "compiler-feature:webcrypto.cryptoKey.algorithm", "tests": [ + "tests/corpus/7124-webcrypto-secret-keys.ts", "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6294-webcrypto-js-values.mjs", "tests/corpus/6295-jose-hs256/main.mjs" @@ -110245,6 +110272,7 @@ "status": "partial", "evidence": "compiler-feature:webcrypto.extractable", "tests": [ + "tests/corpus/7124-webcrypto-secret-keys.ts", "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6294-webcrypto-js-values.mjs", "tests/corpus/6295-jose-hs256/main.mjs" @@ -110273,6 +110301,7 @@ "status": "partial", "evidence": "compiler-feature:webcrypto.type", "tests": [ + "tests/corpus/7124-webcrypto-secret-keys.ts", "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6294-webcrypto-js-values.mjs", "tests/corpus/6295-jose-hs256/main.mjs" @@ -110301,6 +110330,7 @@ "status": "partial", "evidence": "compiler-feature:webcrypto.usages", "tests": [ + "tests/corpus/7124-webcrypto-secret-keys.ts", "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6294-webcrypto-js-values.mjs", "tests/corpus/6295-jose-hs256/main.mjs" @@ -110471,8 +110501,23 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:webcrypto" + "status": "partial", + "evidence": "compiler-feature:webcrypto.subtle.decrypt", + "tests": [ + "tests/corpus/7128-webcrypto-derive.ts", + "tests/corpus/7129-webcrypto-derive-errors.mjs", + "tests/corpus/7126-webcrypto-aes.ts", + "tests/corpus/7127-webcrypto-aes-errors.mjs", + "tests/corpus/7124-webcrypto-secret-keys.ts", + "tests/corpus/7125-webcrypto-key-errors.mjs", + "tests/fixtures/node-types/webcrypto-keys.ts", + "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", + "tests/corpus/6292-webcrypto-hmac-errors.ts", + "tests/corpus/6293-webcrypto-digest.ts", + "tests/corpus/6294-webcrypto-js-values.mjs", + "tests/corpus/6295-jose-hs256/main.mjs", + "tests/fixtures/node-types/webcrypto-hmac.ts" + ] }, "anchorSource": "exact" }, @@ -110494,8 +110539,23 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:webcrypto" + "status": "partial", + "evidence": "compiler-feature:webcrypto.subtle.deriveBits", + "tests": [ + "tests/corpus/7128-webcrypto-derive.ts", + "tests/corpus/7129-webcrypto-derive-errors.mjs", + "tests/corpus/7126-webcrypto-aes.ts", + "tests/corpus/7127-webcrypto-aes-errors.mjs", + "tests/corpus/7124-webcrypto-secret-keys.ts", + "tests/corpus/7125-webcrypto-key-errors.mjs", + "tests/fixtures/node-types/webcrypto-keys.ts", + "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", + "tests/corpus/6292-webcrypto-hmac-errors.ts", + "tests/corpus/6293-webcrypto-digest.ts", + "tests/corpus/6294-webcrypto-js-values.mjs", + "tests/corpus/6295-jose-hs256/main.mjs", + "tests/fixtures/node-types/webcrypto-hmac.ts" + ] }, "anchorSource": "exact" }, @@ -110517,8 +110577,23 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:webcrypto" + "status": "partial", + "evidence": "compiler-feature:webcrypto.subtle.deriveKey", + "tests": [ + "tests/corpus/7128-webcrypto-derive.ts", + "tests/corpus/7129-webcrypto-derive-errors.mjs", + "tests/corpus/7126-webcrypto-aes.ts", + "tests/corpus/7127-webcrypto-aes-errors.mjs", + "tests/corpus/7124-webcrypto-secret-keys.ts", + "tests/corpus/7125-webcrypto-key-errors.mjs", + "tests/fixtures/node-types/webcrypto-keys.ts", + "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", + "tests/corpus/6292-webcrypto-hmac-errors.ts", + "tests/corpus/6293-webcrypto-digest.ts", + "tests/corpus/6294-webcrypto-js-values.mjs", + "tests/corpus/6295-jose-hs256/main.mjs", + "tests/fixtures/node-types/webcrypto-hmac.ts" + ] }, "anchorSource": "exact" }, @@ -110543,6 +110618,13 @@ "status": "partial", "evidence": "compiler-feature:webcrypto.subtle.digest", "tests": [ + "tests/corpus/7128-webcrypto-derive.ts", + "tests/corpus/7129-webcrypto-derive-errors.mjs", + "tests/corpus/7126-webcrypto-aes.ts", + "tests/corpus/7127-webcrypto-aes-errors.mjs", + "tests/corpus/7124-webcrypto-secret-keys.ts", + "tests/corpus/7125-webcrypto-key-errors.mjs", + "tests/fixtures/node-types/webcrypto-keys.ts", "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6292-webcrypto-hmac-errors.ts", "tests/corpus/6293-webcrypto-digest.ts", @@ -110617,8 +110699,23 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:webcrypto" + "status": "partial", + "evidence": "compiler-feature:webcrypto.subtle.encrypt", + "tests": [ + "tests/corpus/7128-webcrypto-derive.ts", + "tests/corpus/7129-webcrypto-derive-errors.mjs", + "tests/corpus/7126-webcrypto-aes.ts", + "tests/corpus/7127-webcrypto-aes-errors.mjs", + "tests/corpus/7124-webcrypto-secret-keys.ts", + "tests/corpus/7125-webcrypto-key-errors.mjs", + "tests/fixtures/node-types/webcrypto-keys.ts", + "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", + "tests/corpus/6292-webcrypto-hmac-errors.ts", + "tests/corpus/6293-webcrypto-digest.ts", + "tests/corpus/6294-webcrypto-js-values.mjs", + "tests/corpus/6295-jose-hs256/main.mjs", + "tests/fixtures/node-types/webcrypto-hmac.ts" + ] }, "anchorSource": "exact" }, @@ -110640,8 +110737,23 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:webcrypto" + "status": "partial", + "evidence": "compiler-feature:webcrypto.subtle.exportKey", + "tests": [ + "tests/corpus/7128-webcrypto-derive.ts", + "tests/corpus/7129-webcrypto-derive-errors.mjs", + "tests/corpus/7126-webcrypto-aes.ts", + "tests/corpus/7127-webcrypto-aes-errors.mjs", + "tests/corpus/7124-webcrypto-secret-keys.ts", + "tests/corpus/7125-webcrypto-key-errors.mjs", + "tests/fixtures/node-types/webcrypto-keys.ts", + "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", + "tests/corpus/6292-webcrypto-hmac-errors.ts", + "tests/corpus/6293-webcrypto-digest.ts", + "tests/corpus/6294-webcrypto-js-values.mjs", + "tests/corpus/6295-jose-hs256/main.mjs", + "tests/fixtures/node-types/webcrypto-hmac.ts" + ] }, "anchorSource": "exact" }, @@ -110686,8 +110798,23 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:webcrypto" + "status": "partial", + "evidence": "compiler-feature:webcrypto.subtle.generateKey", + "tests": [ + "tests/corpus/7128-webcrypto-derive.ts", + "tests/corpus/7129-webcrypto-derive-errors.mjs", + "tests/corpus/7126-webcrypto-aes.ts", + "tests/corpus/7127-webcrypto-aes-errors.mjs", + "tests/corpus/7124-webcrypto-secret-keys.ts", + "tests/corpus/7125-webcrypto-key-errors.mjs", + "tests/fixtures/node-types/webcrypto-keys.ts", + "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", + "tests/corpus/6292-webcrypto-hmac-errors.ts", + "tests/corpus/6293-webcrypto-digest.ts", + "tests/corpus/6294-webcrypto-js-values.mjs", + "tests/corpus/6295-jose-hs256/main.mjs", + "tests/fixtures/node-types/webcrypto-hmac.ts" + ] }, "anchorSource": "exact" }, @@ -110712,6 +110839,13 @@ "status": "partial", "evidence": "compiler-feature:webcrypto.subtle.importKey", "tests": [ + "tests/corpus/7128-webcrypto-derive.ts", + "tests/corpus/7129-webcrypto-derive-errors.mjs", + "tests/corpus/7126-webcrypto-aes.ts", + "tests/corpus/7127-webcrypto-aes-errors.mjs", + "tests/corpus/7124-webcrypto-secret-keys.ts", + "tests/corpus/7125-webcrypto-key-errors.mjs", + "tests/fixtures/node-types/webcrypto-keys.ts", "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6292-webcrypto-hmac-errors.ts", "tests/corpus/6293-webcrypto-digest.ts", @@ -110743,6 +110877,13 @@ "status": "partial", "evidence": "compiler-feature:webcrypto.subtle.sign", "tests": [ + "tests/corpus/7128-webcrypto-derive.ts", + "tests/corpus/7129-webcrypto-derive-errors.mjs", + "tests/corpus/7126-webcrypto-aes.ts", + "tests/corpus/7127-webcrypto-aes-errors.mjs", + "tests/corpus/7124-webcrypto-secret-keys.ts", + "tests/corpus/7125-webcrypto-key-errors.mjs", + "tests/fixtures/node-types/webcrypto-keys.ts", "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6292-webcrypto-hmac-errors.ts", "tests/corpus/6293-webcrypto-digest.ts", @@ -110797,6 +110938,13 @@ "status": "partial", "evidence": "compiler-feature:webcrypto.subtle.verify", "tests": [ + "tests/corpus/7128-webcrypto-derive.ts", + "tests/corpus/7129-webcrypto-derive-errors.mjs", + "tests/corpus/7126-webcrypto-aes.ts", + "tests/corpus/7127-webcrypto-aes-errors.mjs", + "tests/corpus/7124-webcrypto-secret-keys.ts", + "tests/corpus/7125-webcrypto-key-errors.mjs", + "tests/fixtures/node-types/webcrypto-keys.ts", "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6292-webcrypto-hmac-errors.ts", "tests/corpus/6293-webcrypto-digest.ts", diff --git a/internal/compatibility/static-support.json b/internal/compatibility/static-support.json index 23c7a159b..e7b3486c4 100644 --- a/internal/compatibility/static-support.json +++ b/internal/compatibility/static-support.json @@ -187,16 +187,18 @@ "stdlib.set": ["tests/corpus/typed-collection-iterators.ts", "tests/corpus/typed-collection-iterator-references.ts", "tests/corpus/checked-collection-iterators.ts"], "stdlib.headers": ["tests/harness/fetch-conformance.test.ts"], "stdlib.request": ["tests/harness/fetch-conformance.test.ts"], - "stdlib.webcrypto.subtle": ["tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6292-webcrypto-hmac-errors.ts", "tests/corpus/6293-webcrypto-digest.ts", "tests/corpus/6294-webcrypto-js-values.mjs", "tests/corpus/6295-jose-hs256/main.mjs"], - "stdlib.webcrypto.CryptoKey": ["tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6294-webcrypto-js-values.mjs", "tests/corpus/6295-jose-hs256/main.mjs"], + "stdlib.webcrypto.subtle": ["tests/corpus/7128-webcrypto-derive.ts", "tests/corpus/7129-webcrypto-derive-errors.mjs", "tests/corpus/7126-webcrypto-aes.ts", "tests/corpus/7127-webcrypto-aes-errors.mjs", "tests/corpus/7124-webcrypto-secret-keys.ts", "tests/corpus/7125-webcrypto-key-errors.mjs", "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6292-webcrypto-hmac-errors.ts", "tests/corpus/6293-webcrypto-digest.ts", "tests/corpus/6294-webcrypto-js-values.mjs", "tests/corpus/6295-jose-hs256/main.mjs"], + "stdlib.webcrypto.CryptoKey": ["tests/corpus/7124-webcrypto-secret-keys.ts", "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6294-webcrypto-js-values.mjs", "tests/corpus/6295-jose-hs256/main.mjs"], "stdlib.response": ["tests/harness/fetch-conformance.test.ts"], "stdlib.readable-stream": ["tests/harness/fetch-conformance.test.ts"], "stdlib.abort": ["tests/harness/fetch-conformance.test.ts"] }, "features": [ - { "chapter": "webcrypto", "symbols": ["subtle.importKey", "subtle.sign", "subtle.verify", "subtle.digest"], "status": "partial", "evidence": ["tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6292-webcrypto-hmac-errors.ts", "tests/corpus/6293-webcrypto-digest.ts", "tests/corpus/6294-webcrypto-js-values.mjs", "tests/corpus/6295-jose-hs256/main.mjs", "tests/fixtures/node-types/webcrypto-hmac.ts"] }, + { "chapter": "webcrypto", "symbols": ["subtle.importKey", "subtle.generateKey", "subtle.exportKey", "subtle.encrypt", "subtle.decrypt", "subtle.deriveBits", "subtle.deriveKey", "subtle.sign", "subtle.verify", "subtle.digest"], "status": "partial", "evidence": ["tests/corpus/7128-webcrypto-derive.ts", "tests/corpus/7129-webcrypto-derive-errors.mjs", "tests/corpus/7126-webcrypto-aes.ts", "tests/corpus/7127-webcrypto-aes-errors.mjs", "tests/corpus/7124-webcrypto-secret-keys.ts", "tests/corpus/7125-webcrypto-key-errors.mjs", "tests/fixtures/node-types/webcrypto-keys.ts", "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6292-webcrypto-hmac-errors.ts", "tests/corpus/6293-webcrypto-digest.ts", "tests/corpus/6294-webcrypto-js-values.mjs", "tests/corpus/6295-jose-hs256/main.mjs", "tests/fixtures/node-types/webcrypto-hmac.ts"] }, { "chapter": "webcrypto", "signatures": ["Class: `SubtleCrypto`", "`subtle` Type: {SubtleCrypto}"], "status": "partial", "evidence": ["tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6292-webcrypto-hmac-errors.ts", "tests/corpus/6293-webcrypto-digest.ts", "tests/corpus/6294-webcrypto-js-values.mjs", "tests/corpus/6295-jose-hs256/main.mjs"] }, - { "chapter": "webcrypto", "signatures": ["Class: `CryptoKey`", "`cryptoKey.algorithm`", "`extractable` Type: {boolean}", "`type` Type: {string} One of `'secret'`, `'private'`, or `'public'`.", "`usages` Type: {string\\[]}"], "status": "partial", "evidence": ["tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6294-webcrypto-js-values.mjs", "tests/corpus/6295-jose-hs256/main.mjs"] }, + { "chapter": "webcrypto", "signatures": ["Class: `CryptoKey`", "`cryptoKey.algorithm`", "`extractable` Type: {boolean}", "`type` Type: {string} One of `'secret'`, `'private'`, or `'public'`.", "`usages` Type: {string\\[]}"], "status": "partial", "evidence": ["tests/corpus/7124-webcrypto-secret-keys.ts", "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6294-webcrypto-js-values.mjs", "tests/corpus/6295-jose-hs256/main.mjs"] }, + { "chapter": "webcrypto", "signatures": ["Class: `Crypto`"], "status": "partial", "evidence": ["tests/corpus/7120-webcrypto-random-uuid.ts", "tests/corpus/7121-webcrypto-crypto-object.mjs", "tests/corpus/6293-webcrypto-digest.ts"] }, + { "chapter": "webcrypto", "symbols": ["crypto.randomUUID", "crypto.getRandomValues"], "status": "supported", "evidence": ["tests/corpus/7120-webcrypto-random-uuid.ts", "tests/corpus/7121-webcrypto-crypto-object.mjs", "tests/corpus/6204-crypto-get-random-values.ts", "tests/corpus/6205-crypto-get-random-values.js"] }, { "chapter": "globals", "signatures": ["`navigator`"], "status": "partial", "evidence": ["tests/fixtures/node-types/navigator.ts", "tests/harness/project-config.test.ts", "tests/corpus/6331-jose-root-entry/main.ts"] }, { "chapter": "globals", "signatures": ["`userAgent` Type: {string}"], "status": "supported", "evidence": ["tests/fixtures/node-types/navigator.ts", "tests/harness/project-config.test.ts"] }, { "chapter": "globals", "signatures": ["Class: `CryptoKey`", "Class: `SubtleCrypto`"], "status": "partial", "evidence": ["tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6292-webcrypto-hmac-errors.ts", "tests/corpus/6293-webcrypto-digest.ts", "tests/corpus/6294-webcrypto-js-values.mjs", "tests/corpus/6295-jose-hs256/main.mjs"] }, @@ -413,6 +415,7 @@ { "symbols": ["assert.deepEqual", "assert.notDeepEqual"], "status": "partial", "evidence": ["tests/corpus/5513-assert-deep-equal-loose.js", "tests/corpus/5514-assert-deep-equal-typed.ts", "tests/corpus/5516-assert-deep-equal-edges.js"] }, { "symbols": ["assert", "assert.ok", "assert.equal", "assert.notEqual", "assert.strictEqual", "assert.notStrictEqual", "assert.deepStrictEqual", "assert.notDeepStrictEqual", "assert.fail", "assert.match", "assert.doesNotMatch", "assert.throws", "assert.rejects", "assert.ifError"], "status": "partial", "evidence": ["tests/corpus/1600-assert-passing.ts", "tests/corpus/1604-assert-deep-structures.ts", "tests/corpus/1609-assert-async.ts", "tests/corpus/1721-assert-throws-regex-class.ts", "tests/corpus/2936-static-loose-equality.ts", "tests/corpus/5515-assert-deep-strict-typed-messages.ts"] }, { "chapter": "crypto", "symbols": ["Cipheriv", "cipher.update", "cipher.final", "cipher.setAAD", "cipher.getAuthTag", "cipher.setAutoPadding", "Decipheriv", "decipher.update", "decipher.final", "decipher.setAAD", "decipher.setAuthTag", "decipher.setAutoPadding"], "status": "partial", "evidence": ["tests/corpus/5250-cipher-aes-gcm.ts", "tests/corpus/5251-cipher-aes-cbc.ts", "tests/corpus/5252-cipher-aes-ctr.ts", "tests/corpus/5253-cipher-chacha20-poly1305.ts", "tests/corpus/5254-cipher-errors.js", "tests/corpus/5255-cipher-encodings.cjs", "tests/corpus/5256-cipher-deprecation.cjs", "tests/corpus/5257-cipher-vectors.ts", "tests/corpus/5258-cipher-handles.js", "tests/corpus/5259-cipher-chunked.ts", "tests/fixtures/node-types/cipher.ts"] }, + { "chapter": "crypto", "symbols": ["crypto.webcrypto", "subtle"], "status": "partial", "evidence": ["tests/corpus/7122-webcrypto-node-crypto.ts", "tests/corpus/7123-webcrypto-node-crypto.cjs"] }, { "chapter": "crypto", "symbols": ["ECDH", "ecdh.computeSecret", "ecdh.generateKeys", "ecdh.getPrivateKey", "ecdh.getPublicKey", "ecdh.setPrivateKey", "ecdh.setPublicKey"], "status": "partial", "evidence": ["tests/corpus/6700-ecdh-shared-secret.ts", "tests/corpus/6701-ecdh-formats.ts", "tests/corpus/6702-ecdh-errors.js", "tests/corpus/6703-ecdh-private-keys.ts", "tests/corpus/6704-ecdh-set-public-key.cjs", "tests/corpus/6705-ecdh-handles.ts", "tests/fixtures/node-types/ecdh.ts"] }, { "chapter": "errors", "symbols": ["ERR_CRYPTO_ECDH_INVALID_FORMAT", "ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY"], "status": "partial", "evidence": ["tests/corpus/6702-ecdh-errors.js"] }, { "symbols": ["crypto.createHash", "Hash", "hash.update", "hash.digest", "hash.copy", "crypto.createHmac", "Hmac", "hmac.update", "hmac.digest", "crypto.hash", "crypto.pbkdf2", "crypto.pbkdf2Sync"], "status": "partial", "evidence": ["tests/corpus/5760-crypto-hash-stream.ts", "tests/corpus/5768-crypto-hash-unknown.ts", "tests/corpus/5769-crypto-hash-unknown.cjs", "tests/corpus/5761-crypto-hash-stream-states.ts", "tests/corpus/5762-crypto-hash-stream.cjs", "tests/corpus/2890-crypto-static-utility.ts", "tests/corpus/node24-crypto-sha2.ts", "tests/corpus/5435-crypto-hash-algorithms.ts", "tests/corpus/5436-crypto-hash-names.js", "tests/corpus/5437-crypto-hmac-algorithms.ts", "tests/corpus/5438-crypto-kdf-digests.ts", "tests/corpus/5440-crypto-hash-encodings.js", "tests/corpus/5441-crypto-hash-output-length.ts", "tests/harness/npm-static.test.ts"] }, diff --git a/packages/compiler/ambient/scriptc-node-fallback.d.ts b/packages/compiler/ambient/scriptc-node-fallback.d.ts index dbb3cd8fd..489af1700 100644 --- a/packages/compiler/ambient/scriptc-node-fallback.d.ts +++ b/packages/compiler/ambient/scriptc-node-fallback.d.ts @@ -544,12 +544,15 @@ declare var DOMException: { readonly prototype: DOMException; }; -/* WebCrypto's HMAC slice (scr_webcrypto.c): crypto.subtle's importKey for - * raw HMAC keys, HMAC sign/verify and the SHA-1/SHA-2 digests, typed as +/* WebCrypto's secret-key slice (scr_webcrypto.c): crypto.subtle's + * importKey, generateKey and exportKey for HMAC and AES keys (importKey + * also for PBKDF2 and HKDF keys), AES-GCM/CBC/CTR encrypt and decrypt, + * PBKDF2 and HKDF deriveBits and deriveKey, HMAC sign/verify and the SHA-1/SHA-2 digests, typed as * exactly that surface (the declarations mirror @types/node's webcrypto - * shapes). Every other SubtleCrypto method and crypto member is absent, - * so a use is an honest type error. CryptoKey values are native handles - * whose four members read through the handle. */ + * shapes), plus the global's randomUUID and getRandomValues. Every other + * SubtleCrypto method and crypto member is absent, so a use is an honest + * type error. CryptoKey values are native handles whose four members read + * through the handle. */ declare var crypto: Crypto; /* The Crypto and SubtleCrypto constructors (feature probes only) stay * `unknown`; the values keep this declaration order. */ @@ -582,9 +585,44 @@ interface HmacImportParams extends Algorithm { hash: HashAlgorithmIdentifier; length?: number; } +interface HmacKeyGenParams extends Algorithm { + hash: HashAlgorithmIdentifier; + length?: number; +} +interface AesKeyGenParams extends Algorithm { + length: number; +} +interface AesGcmParams extends Algorithm { + additionalData?: BufferSource; + iv: BufferSource; + tagLength?: number; +} +interface AesCbcParams extends Algorithm { + iv: BufferSource; +} +interface AesCtrParams extends Algorithm { + counter: BufferSource; + length: number; +} +interface Pbkdf2Params extends Algorithm { + hash: HashAlgorithmIdentifier; + iterations: number; + salt: BufferSource; +} +interface HkdfParams extends Algorithm { + hash: HashAlgorithmIdentifier; + info: BufferSource; + salt: BufferSource; +} +interface AesDerivedKeyParams extends Algorithm { + length: number; +} interface KeyAlgorithm { name: string; } +interface AesKeyAlgorithm extends KeyAlgorithm { + length: number; +} interface HmacKeyAlgorithm extends KeyAlgorithm { hash: KeyAlgorithm; length: number; @@ -623,10 +661,37 @@ interface JsonWebKey { x?: string; y?: string; } -/* The 'jwk' form type-checks like @types/node's; the compiler refuses it - * (the JsonWebKey import is not implemented). */ interface SubtleCrypto { + decrypt( + algorithm: AesGcmParams | AesCbcParams | AesCtrParams, + key: CryptoKey, + data: BufferSource, + ): Promise; + deriveBits( + algorithm: Pbkdf2Params | HkdfParams, + baseKey: CryptoKey, + length?: number | null, + ): Promise; + deriveKey( + algorithm: Pbkdf2Params | HkdfParams, + baseKey: CryptoKey, + derivedKeyType: AlgorithmIdentifier | AesDerivedKeyParams | HmacImportParams, + extractable: boolean, + keyUsages: readonly KeyUsage[], + ): Promise; digest(algorithm: AlgorithmIdentifier, data: BufferSource): Promise; + encrypt( + algorithm: AesGcmParams | AesCbcParams | AesCtrParams, + key: CryptoKey, + data: BufferSource, + ): Promise; + exportKey(format: "jwk", key: CryptoKey): Promise; + exportKey(format: Exclude, key: CryptoKey): Promise; + generateKey( + algorithm: AesKeyGenParams | HmacKeyGenParams, + extractable: boolean, + keyUsages: readonly KeyUsage[], + ): Promise; importKey( format: "jwk", keyData: JsonWebKey, @@ -651,6 +716,21 @@ interface SubtleCrypto { } interface Crypto { readonly subtle: SubtleCrypto; + getRandomValues< + T extends + | Int8Array + | Uint8Array + | Uint8ClampedArray + | Int16Array + | Uint16Array + | Int32Array + | Uint32Array + | BigInt64Array + | BigUint64Array, + >( + typedArray: T, + ): T; + randomUUID(): `${string}-${string}-${string}-${string}-${string}`; } /* Capability-gated globals harness code probes behind feature guards @@ -2784,8 +2864,7 @@ declare module "crypto" { b: ArrayBufferView | ArrayBufferLike, ): boolean; /* WebCrypto's getRandomValues (also the webcrypto object's): integer - * typed arrays, filled in place and returned. The crypto GLOBAL stays - * unknown in fallback builds. */ + * typed arrays, filled in place and returned. */ type RandomValuesArray = | Int8Array | Uint8Array @@ -2797,9 +2876,9 @@ declare module "crypto" { | BigInt64Array | BigUint64Array; export function getRandomValues(typedArray: T): T; - export const webcrypto: { - getRandomValues(typedArray: T): T; - }; + /* The WebCrypto global's object and its SubtleCrypto. */ + export const webcrypto: Crypto; + export const subtle: SubtleCrypto; export function randomFillSync( buffer: T, offset?: number, diff --git a/packages/compiler/src/backend/llvm/lib-shared.ts b/packages/compiler/src/backend/llvm/lib-shared.ts index 8bb8bc3aa..507624652 100644 --- a/packages/compiler/src/backend/llvm/lib-shared.ts +++ b/packages/compiler/src/backend/llvm/lib-shared.ts @@ -615,10 +615,17 @@ export const LIB_FN_SYMS: Record = { "crypto.keyObjectInput": "scr_crypto_key_object_input", "crypto.isKeyObject": "scr_crypto_is_key_object", "webcrypto.importKey": "scr_webcrypto_import_key", + "webcrypto.generateKey": "scr_webcrypto_generate_key", + "webcrypto.exportKey": "scr_webcrypto_export_key", + "webcrypto.encrypt": "scr_webcrypto_encrypt", + "webcrypto.decrypt": "scr_webcrypto_decrypt", + "webcrypto.deriveBits": "scr_webcrypto_derive_bits", + "webcrypto.deriveKey": "scr_webcrypto_derive_key", "webcrypto.sign": "scr_webcrypto_sign", "webcrypto.verify": "scr_webcrypto_verify", "webcrypto.digest": "scr_webcrypto_digest", "webcrypto.isCryptoKey": "scr_webcrypto_is_crypto_key", + "webcrypto.object": "scr_webcrypto_object", "crypto.randomUUIDv7": "scr_crypto_random_uuid_v7", "crypto.pbkdf2": "scr_crypto_pbkdf2", "crypto.hkdf": "scr_crypto_hkdf", @@ -1573,6 +1580,11 @@ export const USES_TIMERS_LIB_FNS = new Set([ // ecdh.setPublicKey reports DEP0031 on the next tick. "crypto.ecdhNew", // WebCrypto results settle through the deferred crypto queue. + "webcrypto.generateKey", + "webcrypto.encrypt", + "webcrypto.decrypt", + "webcrypto.deriveBits", + "webcrypto.deriveKey", "webcrypto.sign", "webcrypto.verify", "webcrypto.digest", diff --git a/packages/compiler/src/backend/native-link-info-core.ts b/packages/compiler/src/backend/native-link-info-core.ts index a476e1f7f..55301948b 100644 --- a/packages/compiler/src/backend/native-link-info-core.ts +++ b/packages/compiler/src/backend/native-link-info-core.ts @@ -84,8 +84,9 @@ export interface NativeLinkFeatures { foreignFfi: boolean; nodeTest: boolean; tls: boolean; - /** crypto.createCipheriv/createDecipheriv: scr_cipher.c plus the mbedTLS - * archive. */ + /** crypto.createCipheriv/createDecipheriv and WebCrypto's encrypt and + * decrypt: scr_cipher.c plus the mbedTLS archive (and, with webcrypto, + * scr_webcrypto_aes.c). */ cipher: boolean; /** crypto.createECDH and ECDH.convertKey: scr_ecdh.c plus the mbedTLS * archive. */ diff --git a/packages/compiler/src/backend/native/contracts.ts b/packages/compiler/src/backend/native/contracts.ts index 06a41c9b2..8df233585 100644 --- a/packages/compiler/src/backend/native/contracts.ts +++ b/packages/compiler/src/backend/native/contracts.ts @@ -243,8 +243,9 @@ export interface CcOptions { * The unit also compiles whenever `tls` does — scr_tls.c consults its * default-set override and shared Windows-certificate enumerator. */ tlsCa?: boolean; - /** crypto.createCipheriv/createDecipheriv: compiles scr_cipher.c and links - * the mbedTLS archive (shared with tls). */ + /** crypto.createCipheriv/createDecipheriv and WebCrypto's encrypt and + * decrypt: compiles scr_cipher.c (and, with webcrypto, + * scr_webcrypto_aes.c) and links the mbedTLS archive (shared with tls). */ cipher?: boolean; /** crypto.createECDH and ECDH.convertKey: compiles scr_ecdh.c and links * the mbedTLS archive (shared with tls). */ diff --git a/packages/compiler/src/backend/native/executable.ts b/packages/compiler/src/backend/native/executable.ts index a551ad600..229b2f967 100644 --- a/packages/compiler/src/backend/native/executable.ts +++ b/packages/compiler/src/backend/native/executable.ts @@ -297,6 +297,8 @@ const RUNTIME_UNITS: readonly RuntimeUnit[] = [ unit((u) => u.opts.foreignFfi, "scr_ffi_queue.c"), unit((u) => u.opts.nodeTest, "scr_test.c"), unit((u) => u.opts.webcrypto, "scr_webcrypto.c"), + // The crypto global's object extends scr_async_dyn.c's. + unit((u) => u.opts.webcrypto && u.opts.dynAsync, "scr_webcrypto_object.c"), // The CA-store unit rides its own gate OR the tls one: scr_tls.c // references its default-set override unconditionally. unit((u) => u.tlsCa, "scr_tls_ca.c"), @@ -308,6 +310,7 @@ const RUNTIME_UNITS: readonly RuntimeUnit[] = [ ...(u.tls ? [u.rt(join(u.rtDir, "scr_tls.c"))] : []), ...(u.cipher ? [u.rt(join(u.rtDir, "scr_cipher.c"))] : []), ...(u.ecdh ? [u.rt(join(u.rtDir, "scr_ecdh.c"))] : []), + ...(u.cipher && u.opts.webcrypto ? [u.rt(join(u.rtDir, "scr_webcrypto_aes.c"))] : []), u.tlsArchive, // mbedTLS's win32 entropy poll is BCryptGenRandom (bcrypt.h). // The unconditional win32 libs above do not carry it. diff --git a/packages/compiler/src/backend/target-diagnostics.ts b/packages/compiler/src/backend/target-diagnostics.ts index b7049f6fe..eb70a0d2c 100644 --- a/packages/compiler/src/backend/target-diagnostics.ts +++ b/packages/compiler/src/backend/target-diagnostics.ts @@ -208,6 +208,14 @@ export function moduleWasiUnavailableSurface( }; return false; } + if (node.fn === "webcrypto.encrypt" || node.fn === "webcrypto.decrypt") { + found = { + surface: + "WebCrypto encrypt and decrypt (the wasm32-wasi runtime does not include the mbedTLS library)", + loc, + }; + return false; + } if (node.fn === "crypto.ecdhNew" || node.fn === "crypto.ecdhConvertKey") { found = { surface: "ECDH (the wasm32-wasi runtime does not include the mbedTLS library)", diff --git a/packages/compiler/src/frontend/lowering/builtins/crypto.ts b/packages/compiler/src/frontend/lowering/builtins/crypto.ts index f4270dbe8..fc1502958 100644 --- a/packages/compiler/src/frontend/lowering/builtins/crypto.ts +++ b/packages/compiler/src/frontend/lowering/builtins/crypto.ts @@ -7,6 +7,7 @@ import { type Lowerer, own } from "../lowerer.js"; import { locOf } from "../../program.js"; import { CIPHER_TYPE_NAMES } from "../../type-mapper.js"; import { CRYPTO_CIPHERS, CRYPTO_CURVES, CRYPTO_HASHES } from "../crypto-tables.js"; +import { stdlibGlobalNameOf } from "../surfaces.js"; import { BOOL, BYTES_U8, @@ -1316,8 +1317,10 @@ export function lowerCryptoGetRandomValues( } /** Whether `receiver` names a WebCrypto Crypto object: the `crypto` - * global (also through globalThis) or node:crypto's `webcrypto`. */ + * global (also through globalThis or an alias of it) or node:crypto's + * `webcrypto`. */ export function isWebCryptoReceiver(lowerer: Lowerer, receiver: ts.Expression): boolean { + if (stdlibGlobalNameOf(lowerer, receiver) === "crypto") return true; if (ts.isIdentifier(receiver)) { if (receiver.text === "crypto" && lowerer.isStdlibGlobal(receiver, "crypto")) return true; const imported = lowerer.builtinImportOf(receiver); diff --git a/packages/compiler/src/frontend/lowering/builtins/webcrypto.ts b/packages/compiler/src/frontend/lowering/builtins/webcrypto.ts index 93cba84c5..fe310294c 100644 --- a/packages/compiler/src/frontend/lowering/builtins/webcrypto.ts +++ b/packages/compiler/src/frontend/lowering/builtins/webcrypto.ts @@ -5,34 +5,57 @@ import { BOOL, DYN, type IrExpr, type IrLibFn } from "../../../ir/ir.js"; import { lowerDynObjectLiteral } from "../expressions/object-literals.js"; import { stdlibGlobalNameOf } from "../surfaces.js"; import { WEBCRYPTO_DYN_TYPES } from "../../type-mapper.js"; +import { isWebCryptoReceiver } from "./crypto.js"; -/* WebCrypto's HMAC slice (scr_webcrypto.c): `crypto.subtle.importKey`, - * `sign`, `verify` and `digest` called on the crypto global (also through - * globalThis) lower to runtime entry points that take the argument vector - * as one dyn array and answer a promise, so Web IDL conversion, algorithm - * normalization and every error stay Node-shaped at run time. CryptoKey +/* WebCrypto's secret-key slice (scr_webcrypto.c, with encrypt and + * decrypt in scr_webcrypto_aes.c): `crypto.subtle`'s `importKey`, + * `generateKey`, `exportKey`, `encrypt`, `decrypt`, `deriveBits`, + * `deriveKey`, `sign`, `verify` and `digest` + * called on the crypto global (also through + * globalThis, node:crypto's webcrypto and node:crypto's subtle) lower to + * runtime entry points that take the argument vector as one dyn array and + * answer a promise, so Web IDL conversion, algorithm normalization and + * every error stay Node-shaped at run time. CryptoKey * values are native handles; their type maps to dyn and their members * are handle reads. Other SubtleCrypto methods are refused by name. */ const SUBTLE_LOWERED: ReadonlyMap = new Map([ ["importKey", "webcrypto.importKey"], + ["generateKey", "webcrypto.generateKey"], + ["exportKey", "webcrypto.exportKey"], + ["encrypt", "webcrypto.encrypt"], + ["decrypt", "webcrypto.decrypt"], + ["deriveBits", "webcrypto.deriveBits"], + ["deriveKey", "webcrypto.deriveKey"], ["sign", "webcrypto.sign"], ["verify", "webcrypto.verify"], ["digest", "webcrypto.digest"], ]); const SUBTLE_HINT = - "the native WebCrypto surface is crypto.subtle.importKey('raw', ...) for HMAC keys, sign and verify with HMAC, and digest with SHA-1, SHA-256, SHA-384 or SHA-512, each called directly on crypto.subtle"; + "the native WebCrypto surface is crypto.subtle's importKey, generateKey and exportKey for HMAC and AES keys (importKey also for PBKDF2 and HKDF keys), encrypt and decrypt with AES-GCM, AES-CBC or AES-CTR, deriveBits and deriveKey with PBKDF2 or HKDF, sign and verify with HMAC, and digest with SHA-1, SHA-256, SHA-384 or SHA-512, each called directly on crypto.subtle"; -/** Whether `node` is `crypto.subtle` on the WebCrypto global. */ +/** Whether `node` is a SubtleCrypto object: `subtle` on a WebCrypto + * Crypto object (the global, globalThis.crypto or node:crypto's + * `webcrypto`) or node:crypto's own `subtle` export, named or through + * the namespace. */ function isSubtleReceiver(lowerer: Lowerer, node: ts.Expression): boolean { while (ts.isParenthesizedExpression(node)) node = node.expression; - return ( - ts.isPropertyAccessExpression(node) && - !node.questionDotToken && - node.name.text === "subtle" && - stdlibGlobalNameOf(lowerer, node.expression) === "crypto" - ); + if (ts.isIdentifier(node)) { + const imported = lowerer.builtinImportOf(node); + return imported?.module === "crypto" && imported.member === "subtle"; + } + if ( + !ts.isPropertyAccessExpression(node) || + node.questionDotToken || + node.name.text !== "subtle" + ) { + return false; + } + if (stdlibGlobalNameOf(lowerer, node.expression) === "crypto") return true; + if (isWebCryptoReceiver(lowerer, node.expression)) return true; + const member = lowerer.builtinMemberOf(node); + return member?.module === "crypto" && member.member === "subtle"; } /** `crypto.subtle.(...args)`: the lowered methods become their @@ -51,17 +74,6 @@ export function lowerWebCryptoCall(lowerer: Lowerer, call: ts.CallExpression): I if (call.arguments.nodes.some(ts.isSpreadElement)) { lowerer.noLowering(`crypto.subtle.${member} with spread arguments`, call, SUBTLE_HINT); } - // JsonWebKey imports are not implemented: a literal 'jwk' format is - // refused here (the runtime refuses a computed one). - const format = call.arguments.nodes[0]; - if ( - member === "importKey" && - format !== undefined && - ts.isStringLiteralLike(format) && - format.text === "jwk" - ) { - lowerer.noLowering("crypto.subtle.importKey with the 'jwk' key format", format, SUBTLE_HINT); - } const loc = locOf(call); const args = call.arguments.nodes.map((arg) => ts.isObjectLiteralExpression(arg) diff --git a/packages/compiler/src/frontend/lowering/expressions/identifiers.ts b/packages/compiler/src/frontend/lowering/expressions/identifiers.ts index b5f99d682..16cca3b13 100644 --- a/packages/compiler/src/frontend/lowering/expressions/identifiers.ts +++ b/packages/compiler/src/frontend/lowering/expressions/identifiers.ts @@ -549,6 +549,9 @@ export function lowerIdentifierExpr(lowerer: Lowerer, expr: ts.Identifier, loc: const callable = lowerer.lowerBuiltinCallableValue(bi, loc); if (callable) return callable; } + // node:crypto's webcrypto is the WebCrypto global's object. + if (bi.module === "crypto" && bi.member === "webcrypto") + return { kind: "libCall", fn: "webcrypto.object", args: [], type: DYN, loc }; // JavaScript sources: an otherwise unsupported builtin VALUE is // the same identity-token story as stdlib globals above (the // harness adds worker_threads.Worker to its identity Set). @@ -721,7 +724,7 @@ export function lowerIdentifierExpr(lowerer: Lowerer, expr: ts.Identifier, loc: return { kind: "closure", fnName: name, captures: [], type, loc }; } if (lowerer.isStdlibGlobal(expr, "crypto")) - return { kind: "libCall", fn: "crypto.native", args: [], type: DYN, loc }; + return { kind: "libCall", fn: "webcrypto.object", args: [], type: DYN, loc }; const nativeAlias = stdlibGlobalNameOf(lowerer, expr); if (nativeAlias === "Buffer" && expr.text !== "Buffer") { return { kind: "strLit", value: "[builtin Buffer]", type: STRING, loc }; diff --git a/packages/compiler/src/frontend/lowering/expressions/property-access.ts b/packages/compiler/src/frontend/lowering/expressions/property-access.ts index f0b980da0..5cd70d2a5 100644 --- a/packages/compiler/src/frontend/lowering/expressions/property-access.ts +++ b/packages/compiler/src/frontend/lowering/expressions/property-access.ts @@ -162,6 +162,7 @@ import { lowerUnionFieldRead } from "./union-fields.js"; import { errorPropertyRead } from "../error-methods.js"; import { isSafeToDiscard, isSafeToRepeat } from "./evaluation-safety.js"; import { isZlibStreamMember, lowerZlibStreamBytesWritten } from "../builtins/compression.js"; +import { isWebCryptoReceiver } from "../builtins/crypto.js"; import { isFsStreamMember, lowerFsStreamProperty } from "../builtins/fs-streams.js"; import { keyedFieldRead } from "./keyed-field-targets.js"; import { promisePrototypeValue } from "../thenables.js"; @@ -842,8 +843,16 @@ export function lowerPropertyAccessExpr( if (runtimeOptionalClassField(lowerer, handled, expr)) return handled; return iteratorResultValueRead(lowerer, handled, expr) ?? lowerer.maybeNarrow(handled, expr); } + // `globalThis.crypto` is the WebCrypto object the bare `crypto` answers. + if ( + !expr.questionDotToken && + stdlibGlobalNameOf(lowerer, expr.expression) === "globalThis" && + stdlibGlobalNameOf(lowerer, expr) === "crypto" + ) { + return { kind: "libCall", fn: "webcrypto.object", args: [], type: DYN, loc }; + } // `globalThis.` that no lowering above claimed - // (globalThis.crypto, globalThis.SubtleCrypto, globalThis.localStorage + // (globalThis.SubtleCrypto, globalThis.localStorage // — the harness's capability-conditional knownGlobals adds): the // PROPERTY spelling of the identifier chokepoint's JS rule — a stdlib // global taken as a VALUE in a JavaScript source is the same opaque @@ -2959,6 +2968,9 @@ export function lowerFieldRead(lowerer: Lowerer, expr: ts.PropertyAccessExpressi if ( receiverIr?.kind !== "object" && propSym && + // The WebCrypto object's generic getRandomValues reads off its + // dynamic object. + !isWebCryptoReceiver(lowerer, expr.expression) && isGenericCallableMemberType(lowerer.checker.getTypeOfSymbol(propSym), lowerer.checker) && // CLASS members keep the class-path fences (a poisoned class's own // diagnostics, the bound-method fence above). diff --git a/packages/compiler/src/frontend/lowering/lower-calls.ts b/packages/compiler/src/frontend/lowering/lower-calls.ts index 7102f37ab..c503f0c9c 100644 --- a/packages/compiler/src/frontend/lowering/lower-calls.ts +++ b/packages/compiler/src/frontend/lowering/lower-calls.ts @@ -1542,9 +1542,10 @@ export function lowerCall(lowerer: Lowerer, expr: ts.CallExpression): IrExpr { lowerer.fenceStaticReadableStreamMember(expr.expression, "call") ?? lowerDisposableStackUseCall(lowerer, expr, expr.expression) ?? lowerer.lowerStdlibMethodCall(expr, expr.expression) ?? - // crypto.getRandomValues on the WebCrypto global (untyped in - // fallback builds, so before the dyn receiver path) or webcrypto. - lowerWebCryptoGetRandomValues(lowerer, expr, expr.expression) ?? + // crypto.getRandomValues / randomUUID on the WebCrypto global + // (untyped in fallback builds, so before the dyn receiver path) or + // webcrypto. + lowerWebCryptoMethodCall(lowerer, expr, expr.expression) ?? // Dyn receivers (JSON.parse-derived `unknown`/`any` values) — lowerDynReceiverMethodCall(lowerer, expr, expr.expression) ?? @@ -10492,20 +10493,40 @@ export function lowerStaticNumberGlobal( return null; } -/** `crypto.getRandomValues(view)` on the WebCrypto global or webcrypto. */ -function lowerWebCryptoGetRandomValues( +/** `crypto.getRandomValues(view)` and `crypto.randomUUID()` on the + * WebCrypto global or webcrypto. Other argument counts (JavaScript only) + * invoke the dynamic object's method, which ignores extra arguments and + * throws Node's missing-argument TypeError. */ +function lowerWebCryptoMethodCall( lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, ): IrExpr | null { + const member = access.name.text; if ( - access.name.text !== "getRandomValues" || + (member !== "getRandomValues" && member !== "randomUUID") || call.questionDotToken || access.questionDotToken || !isWebCryptoReceiver(lowerer, access.expression) ) return null; - return lowerCryptoGetRandomValues(lowerer, call); + const args = call.arguments.nodes; + if (member === "getRandomValues" && args.length === 1) { + return lowerCryptoGetRandomValues(lowerer, call); + } + if (member === "randomUUID" && args.length === 0) { + return { kind: "libCall", fn: "crypto.randomUUID", args: [], type: STRING, loc: locOf(call) }; + } + if (args.some(ts.isSpreadElement)) return null; + return { + kind: "dynInvoke", + recv: lowerer.lowerExprExpecting(access.expression, DYN), + method: member, + calleeName: v8CalleeText(access), + args: args.map((arg) => lowerer.lowerExprExpecting(arg, DYN)), + type: DYN, + loc: locOf(call), + }; } /** A then handler's promise-armed result (`.then(() => cached ?? load())` diff --git a/packages/compiler/src/frontend/lowering/lower-stmts.ts b/packages/compiler/src/frontend/lowering/lower-stmts.ts index e3480cf9c..7f0854523 100644 --- a/packages/compiler/src/frontend/lowering/lower-stmts.ts +++ b/packages/compiler/src/frontend/lowering/lower-stmts.ts @@ -3964,9 +3964,13 @@ function stdlibGlobalTokenDestructure( const canonical = ts.symbolName(member) === "global" ? "globalThis" : ts.symbolName(member); token = `[builtin ${canonical}]`; alias = canonical; - // Builtin constructors read as their interned function values, the - // same values the bare and `globalThis.X` spellings read. - value = builtinGlobalValue(canonical, locOf(el), true); + // Builtin constructors read as their interned function values, and + // crypto as the WebCrypto object: the same values the bare and + // `globalThis.X` spellings read. + value = + canonical === "crypto" + ? { kind: "libCall", fn: "webcrypto.object", args: [], type: DYN, loc: locOf(el) } + : builtinGlobalValue(canonical, locOf(el), true); } else if (globalName === "console" && !CONSOLE_CALL_MEMBERS.has(propName)) { token = `[builtin console.${propName}]`; } else if (TOKEN_OPAQUE_GLOBALS.has(globalName)) { diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts index ee8ba7ecb..3fbb110ed 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -13410,6 +13410,10 @@ export class Lowerer { const callable = this.lowerBuiltinCallableValue(bi, loc); if (callable) return callable; } + // node:crypto's webcrypto is the WebCrypto global's object. + if (bi.module === "crypto" && bi.member === "webcrypto") { + return { kind: "libCall", fn: "webcrypto.object", args: [], type: DYN, loc }; + } // node:stream/web's exports are the web stream globals themselves: in // JavaScript sources the same identity token as the global spelling // (`require("stream/web").ReadableStream === globalThis.ReadableStream`). diff --git a/packages/compiler/src/frontend/lowering/surfaces.ts b/packages/compiler/src/frontend/lowering/surfaces.ts index c77938337..67950a53f 100644 --- a/packages/compiler/src/frontend/lowering/surfaces.ts +++ b/packages/compiler/src/frontend/lowering/surfaces.ts @@ -2210,15 +2210,26 @@ export const AMBIENT_SURFACE_FNS: readonly AmbientSurfaceRow[] = [ id: "stdlib.webcrypto.subtle", kind: "stdlib", name: "globalThis.crypto.subtle", - fns: ["webcrypto.importKey", "webcrypto.sign", "webcrypto.verify", "webcrypto.digest"], - note: "importKey('raw') for HMAC keys, HMAC sign and verify, and SHA-1/SHA-2 digest; other methods, algorithms and key formats are refused", + fns: [ + "webcrypto.importKey", + "webcrypto.generateKey", + "webcrypto.exportKey", + "webcrypto.encrypt", + "webcrypto.decrypt", + "webcrypto.deriveBits", + "webcrypto.deriveKey", + "webcrypto.sign", + "webcrypto.verify", + "webcrypto.digest", + ], + note: "importKey, generateKey and exportKey (raw and jwk) for HMAC and AES keys, importKey for PBKDF2 and HKDF keys, AES-GCM, AES-CBC and AES-CTR encrypt and decrypt, PBKDF2 and HKDF deriveBits and deriveKey, HMAC sign and verify, and SHA-1/SHA-2 digest; other methods, algorithms and key formats are refused", }, { id: "stdlib.webcrypto.CryptoKey", kind: "stdlib", name: "CryptoKey", fns: ["webcrypto.isCryptoKey"], - note: "secret HMAC keys with type, extractable, algorithm and usages, and instanceof CryptoKey", + note: "secret HMAC, AES, PBKDF2 and HKDF keys with type, extractable, algorithm and usages, and instanceof CryptoKey", }, { id: "stdlib.atomics", @@ -3088,9 +3099,6 @@ export const BUILTIN_MODULE_FENCE_HINTS: Record< setFips: "a compiled binary has no FIPS provider to enable, and Node itself throws on setFips(true) " + "in a non-FIPS build — getFips() answers 0 here", - webcrypto: - "the WebCrypto object has no lowering — the lowered crypto surface is randomUUID, " + - "randomBytes, and the createHash chain", }, zlib: { brotliCompressSync: BROTLI_HINT, diff --git a/packages/compiler/src/frontend/type-mapper.ts b/packages/compiler/src/frontend/type-mapper.ts index a233f0186..a491edf95 100644 --- a/packages/compiler/src/frontend/type-mapper.ts +++ b/packages/compiler/src/frontend/type-mapper.ts @@ -146,6 +146,16 @@ export const WEBCRYPTO_DYN_TYPES: ReadonlySet = new Set([ "KeyAlgorithm", "HmacImportParams", "HmacKeyAlgorithm", + "HmacKeyGenParams", + "AesKeyGenParams", + "AesKeyAlgorithm", + "JsonWebKey", + "AesGcmParams", + "AesCbcParams", + "AesCtrParams", + "Pbkdf2Params", + "HkdfParams", + "AesDerivedKeyParams", ]); export const FETCH_AMBIENT_TYPES = [ diff --git a/packages/compiler/src/ir/builtin-signatures.ts b/packages/compiler/src/ir/builtin-signatures.ts index fa7876579..416d5f18e 100644 --- a/packages/compiler/src/ir/builtin-signatures.ts +++ b/packages/compiler/src/ir/builtin-signatures.ts @@ -2846,10 +2846,17 @@ export const LIB_FN_SIGS = defineLibFnSignatures({ * one dyn array and answers a promise that argument and validation * failures reject. CryptoKey values are native handles. */ "webcrypto.importKey": { argTypes: [DYN], result: { kind: "promise", inner: DYN } }, + "webcrypto.generateKey": { argTypes: [DYN], result: { kind: "promise", inner: DYN } }, + "webcrypto.exportKey": { argTypes: [DYN], result: { kind: "promise", inner: DYN } }, + "webcrypto.encrypt": { argTypes: [DYN], result: { kind: "promise", inner: DYN } }, + "webcrypto.decrypt": { argTypes: [DYN], result: { kind: "promise", inner: DYN } }, + "webcrypto.deriveBits": { argTypes: [DYN], result: { kind: "promise", inner: DYN } }, + "webcrypto.deriveKey": { argTypes: [DYN], result: { kind: "promise", inner: DYN } }, "webcrypto.sign": { argTypes: [DYN], result: { kind: "promise", inner: DYN } }, "webcrypto.verify": { argTypes: [DYN], result: { kind: "promise", inner: BOOL } }, "webcrypto.digest": { argTypes: [DYN], result: { kind: "promise", inner: DYN } }, "webcrypto.isCryptoKey": { argTypes: [DYN], result: BOOL }, + "webcrypto.object": { argTypes: [], result: DYN }, "crypto.randomUUIDv7": { argTypes: [DYN], result: STRING }, "crypto.pbkdf2": { argTypes: [BYTES_U8, BYTES_U8, F64, F64, STRING], result: BYTES_U8 }, "crypto.randomBytesCb": { argTypes: [F64, null], result: VOID }, diff --git a/packages/compiler/src/ir/runtime-features.ts b/packages/compiler/src/ir/runtime-features.ts index 4142b6efe..61e04177b 100644 --- a/packages/compiler/src/ir/runtime-features.ts +++ b/packages/compiler/src/ir/runtime-features.ts @@ -75,6 +75,8 @@ const DYN_ASYNC_LIB_FNS: ReadonlySet = new Set([ "child.propsInstall", "child.propsResolve", "crypto.native", + // The crypto global's object extends crypto.native's. + "webcrypto.object", "dyn.promiseAll", "dyn.promiseAllSettled", "dyn.promiseAny", @@ -647,8 +649,9 @@ const RUNTIME_FEATURE_RULES = { }), /** scr_cipher.c over the mbedTLS archive; DEP0182 reports through the * process-warning unit, and unknown output encodings render through the - * inspect unit. */ - cipher: rule({ fns: ["crypto.cipherNew"] }), + * inspect unit. WebCrypto's encrypt and decrypt (scr_webcrypto_aes.c) + * link the same archive. */ + cipher: rule({ fns: ["crypto.cipherNew", "webcrypto.encrypt", "webcrypto.decrypt"] }), copying: rule({ expr: (node, _tables) => (node.kind === "arrIntrinsic" && COPYING_ARR_METHODS.has(node.method)) || @@ -675,12 +678,15 @@ const RUNTIME_FEATURE_RULES = { ), // The legacy url functions, crypto.createCipheriv and // ecdh.setPublicKey emit their deprecation warnings through the - // dyn-async unit; scr_wasm.c boxes its handles and promises through it. + // dyn-async unit (WebCrypto's encrypt and decrypt link scr_cipher.c + // too); scr_wasm.c boxes its handles and promises through it. fns: [ ...DYN_ASYNC_LIB_FNS, ...READABLE_DYN_ASYNC_LIB_FNS, ...LEGACY_URL_LIB_FNS, "crypto.cipherNew", + "webcrypto.encrypt", + "webcrypto.decrypt", "crypto.ecdhNew", ], prefixes: [...READABLE_DYN_ASYNC_PREFIXES, "wasm."], @@ -787,6 +793,8 @@ const RUNTIME_FEATURE_RULES = { "global.native", "util.styleText", "crypto.cipherNew", + "webcrypto.encrypt", + "webcrypto.decrypt", "crypto.ecdhNew", "crypto.ecdhConvertKey", ...BUILTIN_CLASS_LIB_FNS, diff --git a/packages/compiler/surface-manifest.json b/packages/compiler/surface-manifest.json index c05e994a8..3e8b9df73 100644 --- a/packages/compiler/surface-manifest.json +++ b/packages/compiler/surface-manifest.json @@ -762,14 +762,6 @@ "code": "SC2020", "note": "asymmetric-key operations need a public-key stack (bignum, RSA/EC/EdDSA math) and public and private KeyObjects — neither exists in the static runtime, so no faithful lowering can be small; the lowered crypto surface is hashing, randomness, secret KeyObjects, and the introspection statics" }, - { - "id": "node-builtin.crypto.webcrypto", - "kind": "node-builtin", - "name": "crypto.webcrypto", - "status": "unsupported", - "code": "SC2020", - "note": "the WebCrypto object has no lowering — the lowered crypto surface is randomUUID, randomBytes, and the createHash chain" - }, { "id": "node-builtin.dgram", "kind": "node-builtin", @@ -5719,14 +5711,14 @@ "kind": "stdlib", "name": "CryptoKey", "status": "static", - "note": "secret HMAC keys with type, extractable, algorithm and usages, and instanceof CryptoKey" + "note": "secret HMAC, AES, PBKDF2 and HKDF keys with type, extractable, algorithm and usages, and instanceof CryptoKey" }, { "id": "stdlib.webcrypto.subtle", "kind": "stdlib", "name": "globalThis.crypto.subtle", "status": "static", - "note": "importKey('raw') for HMAC keys, HMAC sign and verify, and SHA-1/SHA-2 digest; other methods, algorithms and key formats are refused" + "note": "importKey, generateKey and exportKey (raw and jwk) for HMAC and AES keys, importKey for PBKDF2 and HKDF keys, AES-GCM, AES-CBC and AES-CTR encrypt and decrypt, PBKDF2 and HKDF deriveBits and deriveKey, HMAC sign and verify, and SHA-1/SHA-2 digest; other methods, algorithms and key formats are refused" }, { "id": "syntax.async-generators", diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7120-webcrypto-random-uuid.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7120-webcrypto-random-uuid.ts.json new file mode 100644 index 000000000..c70fdfa63 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7120-webcrypto-random-uuid.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7120-webcrypto-random-uuid.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7121-webcrypto-crypto-object.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7121-webcrypto-crypto-object.mjs.json new file mode 100644 index 000000000..b152699ba --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7121-webcrypto-crypto-object.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7121-webcrypto-crypto-object.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7122-webcrypto-node-crypto.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7122-webcrypto-node-crypto.ts.json new file mode 100644 index 000000000..02451a516 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7122-webcrypto-node-crypto.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7122-webcrypto-node-crypto.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7123-webcrypto-node-crypto.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7123-webcrypto-node-crypto.cjs.json new file mode 100644 index 000000000..821fb378d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7123-webcrypto-node-crypto.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7123-webcrypto-node-crypto.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7124-webcrypto-secret-keys.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7124-webcrypto-secret-keys.ts.json new file mode 100644 index 000000000..8fc0dab2a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7124-webcrypto-secret-keys.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7124-webcrypto-secret-keys.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7125-webcrypto-key-errors.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7125-webcrypto-key-errors.mjs.json new file mode 100644 index 000000000..942de8c10 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7125-webcrypto-key-errors.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7125-webcrypto-key-errors.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7126-webcrypto-aes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7126-webcrypto-aes.ts.json new file mode 100644 index 000000000..f113a3ca9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7126-webcrypto-aes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7126-webcrypto-aes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7127-webcrypto-aes-errors.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7127-webcrypto-aes-errors.mjs.json new file mode 100644 index 000000000..3ec3d26f2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7127-webcrypto-aes-errors.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7127-webcrypto-aes-errors.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7128-webcrypto-derive.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7128-webcrypto-derive.ts.json new file mode 100644 index 000000000..b613fbce6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7128-webcrypto-derive.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7128-webcrypto-derive.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7129-webcrypto-derive-errors.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7129-webcrypto-derive-errors.mjs.json new file mode 100644 index 000000000..11fc8c721 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7129-webcrypto-derive-errors.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7129-webcrypto-derive-errors.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/webcrypto-keys.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/webcrypto-keys.ts.json new file mode 100644 index 000000000..19f14ed02 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/webcrypto-keys.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/node-types/webcrypto-keys.ts" + ], + "diags": [] +} diff --git a/packages/runtime-darwin-arm64/scripts/build.mjs b/packages/runtime-darwin-arm64/scripts/build.mjs index 85c5ffb00..3944b023c 100644 --- a/packages/runtime-darwin-arm64/scripts/build.mjs +++ b/packages/runtime-darwin-arm64/scripts/build.mjs @@ -172,7 +172,8 @@ async function build() { ...(unit.source === "scr_regex.c" ? ["-I", quickjs] : []), ...(unit.source === "scr_tls.c" || unit.source === "scr_cipher.c" || - unit.source === "scr_ecdh.c" + unit.source === "scr_ecdh.c" || + unit.source === "scr_webcrypto_aes.c" ? ["-I", join(mbedtls, "include")] : []), ...(unit.source === "scr_zlib.c" || unit.source === "scr_fetch.c" diff --git a/packages/runtime-pack-common/runtime-pack-matrix.mjs b/packages/runtime-pack-common/runtime-pack-matrix.mjs index 0f40218a1..3529df137 100644 --- a/packages/runtime-pack-common/runtime-pack-matrix.mjs +++ b/packages/runtime-pack-common/runtime-pack-matrix.mjs @@ -72,6 +72,8 @@ export const OPTIONAL_RUNTIME_SOURCES = [ ["scr_js_object.c", "dynTier"], ["scr_event_target.c", any("eventTarget", "nativeFetch")], ["scr_async_dyn.c", any("dynAsync", "dynInvoke", "dc", "fileHandle", "nativeFetch")], + // The crypto global's object extends scr_async_dyn.c's crypto object. + ["scr_webcrypto_object.c", all("webcrypto", "dynAsync")], // The performance timeline emits its buffer warning through scr_async_dyn.c. ["scr_perf.c", "dynAsync"], // perf_hooks event-loop metrics, only for programs that read them. @@ -151,6 +153,8 @@ export const OPTIONAL_RUNTIME_SOURCES = [ ["scr_ecdh.c", "ecdh"], ["scr_wasm.c", "wasm"], ["scr_webcrypto.c", "webcrypto"], + // WebCrypto's AES ciphers run over the cipher feature's mbedTLS archive. + ["scr_webcrypto_aes.c", all("cipher", "webcrypto")], ["scr_fetch.c", "nativeFetch"], ]; diff --git a/packages/runtime-pack-common/scripts/build.mjs b/packages/runtime-pack-common/scripts/build.mjs index b242b78aa..f59a2431f 100644 --- a/packages/runtime-pack-common/scripts/build.mjs +++ b/packages/runtime-pack-common/scripts/build.mjs @@ -223,7 +223,8 @@ async function build() { ...(unit.source === "scr_regex.c" ? ["-I", quickjs] : []), ...(unit.source === "scr_tls.c" || unit.source === "scr_cipher.c" || - unit.source === "scr_ecdh.c" + unit.source === "scr_ecdh.c" || + unit.source === "scr_webcrypto_aes.c" ? ["-I", join(mbedtls, "include")] : []), ...(unit.source === "scr_zlib.c" || unit.source === "scr_fetch.c" diff --git a/packages/runtime-wasm32-wasi/scripts/build.mjs b/packages/runtime-wasm32-wasi/scripts/build.mjs index 2dd983973..0a8699b23 100644 --- a/packages/runtime-wasm32-wasi/scripts/build.mjs +++ b/packages/runtime-wasm32-wasi/scripts/build.mjs @@ -22,6 +22,7 @@ process.env.SCRIPTC_RUNTIME_PACK_CONFIG = JSON.stringify({ "scr_tls.c", "scr_cipher.c", "scr_ecdh.c", + "scr_webcrypto_aes.c", "scr_wasm.c", "scr_fetch.c", ], diff --git a/packages/runtime/src/scr_crypto.h b/packages/runtime/src/scr_crypto.h index d12858abf..ddc306598 100644 --- a/packages/runtime/src/scr_crypto.h +++ b/packages/runtime/src/scr_crypto.h @@ -20,6 +20,9 @@ ScrStr *scr_crypto_hash_digest_bytes(ScrStr *alg, ScrBytes *data, ScrStr *enc); typedef struct ScrCryptoHash ScrCryptoHash; ScrCryptoHash *scr_crypto_hash_new(ScrStr *alg); ScrDyn *scr_crypto_native(void); +/* The crypto global as a value: scr_crypto_native's object with the Crypto + * methods (scr_webcrypto_object.c, linked with the webcrypto feature). */ +ScrDyn *scr_webcrypto_object(void); ScrCryptoHash *scr_crypto_hmac_new_str(ScrStr *alg, ScrStr *key); ScrCryptoHash *scr_crypto_hmac_new_bytes(ScrStr *alg, ScrBytes *key); ScrCryptoHash *scr_crypto_hash_retain(ScrCryptoHash *h); @@ -202,19 +205,48 @@ size_t scr_crypto_digest_raw(const char *alg, const unsigned char *data, size_t size_t scr_crypto_hmac_raw(const char *alg, const unsigned char *key, size_t keylen, const unsigned char *data, size_t len, unsigned char out[64]); /* ── WebCrypto (scr_webcrypto.c) ───────────────────────────────────── - * crypto.subtle.importKey (raw HMAC keys), sign and verify (HMAC) and - * digest (SHA-1/SHA-2) over node:crypto's digest core. Each takes the + * crypto.subtle.importKey (HMAC, AES, PBKDF2 and HKDF keys, raw and jwk), + * generateKey and exportKey (HMAC and AES keys), sign and verify (HMAC) + * and digest (SHA-1/SHA-2) over node:crypto's digest core. Each takes the * call's argument vector as one dyn array (borrowed) and answers a +1 * promise that every argument or validation failure rejects with Node's * TypeError or DOMException; algorithms and formats outside the slice - * reject with a coded SC2020 Error. importKey settles at once with a - * CryptoKey handle; sign and digest fulfill with an ArrayBuffer and - * verify with a boolean on a later loop turn. scr_webcrypto_is_crypto_key - * answers `value instanceof CryptoKey`. */ + * reject with a coded SC2020 Error. importKey and exportKey settle at + * once with a CryptoKey handle, an ArrayBuffer or a JWK object; + * generateKey fulfills with a CryptoKey, sign and digest with an + * ArrayBuffer and verify with a boolean on a later loop turn. + * scr_webcrypto_is_crypto_key answers `value instanceof CryptoKey`. */ ScrPromise *scr_webcrypto_import_key(ScrDyn *args); +ScrPromise *scr_webcrypto_generate_key(ScrDyn *args); +ScrPromise *scr_webcrypto_export_key(ScrDyn *args); ScrPromise *scr_webcrypto_sign(ScrDyn *args); ScrPromise *scr_webcrypto_verify(ScrDyn *args); ScrPromise *scr_webcrypto_digest(ScrDyn *args); +/* encrypt and decrypt (scr_webcrypto_aes.c, linked with the cipher + * feature's mbedTLS archive) run scr_webcrypto_cipher with the AES cipher + * as `aes`, which answers the +1 output bytes or NULL when the operation + * fails. encrypt and decrypt fulfill with an ArrayBuffer, or reject with + * a job failure, on a later loop turn. */ +typedef struct { + const unsigned char *iv; /* the IV, or the CTR counter block */ + size_t iv_len; + const unsigned char *aad; + size_t aad_len; + size_t tag_len; /* bytes */ + unsigned counter_bits; +} ScrWebCryptoAesParams; +typedef ScrBytes *(*ScrWebCryptoAesFn)(const char *name, bool decrypt, const unsigned char *key, + size_t key_len, const ScrWebCryptoAesParams *params, + const unsigned char *in, size_t len); +ScrPromise *scr_webcrypto_cipher(ScrDyn *args, bool decrypt, ScrWebCryptoAesFn aes); +ScrPromise *scr_webcrypto_encrypt(ScrDyn *args); +ScrPromise *scr_webcrypto_decrypt(ScrDyn *args); +/* deriveBits and deriveKey (PBKDF2 and HKDF) over node:crypto's KDF core: + * deriveBits fulfills with an ArrayBuffer (at once for a zero length) and + * deriveKey with a CryptoKey of the derived key type, on a later loop + * turn. */ +ScrPromise *scr_webcrypto_derive_bits(ScrDyn *args); +ScrPromise *scr_webcrypto_derive_key(ScrDyn *args); bool scr_webcrypto_is_crypto_key(const ScrDyn *value); /* The composed `new crypto.X509Certificate(data).fingerprint` read (the diff --git a/packages/runtime/src/scr_webcrypto.c b/packages/runtime/src/scr_webcrypto.c index 546b24151..4d2c27be4 100644 --- a/packages/runtime/src/scr_webcrypto.c +++ b/packages/runtime/src/scr_webcrypto.c @@ -1,22 +1,27 @@ -/* WebCrypto's HMAC slice: crypto.subtle.importKey (raw HMAC keys), - * sign, verify and the SHA-1/SHA-2 digests, plus the CryptoKey values - * importKey answers. +/* WebCrypto's secret-key slice: crypto.subtle.importKey, generateKey and + * exportKey for HMAC and AES keys (importKey also for PBKDF2 and HKDF + * keys), HMAC sign and verify, the SHA-1/SHA-2 digests, PBKDF2 and HKDF + * deriveBits and deriveKey, the argument and key handling of AES encrypt + * and decrypt (whose cipher runs in scr_webcrypto_aes.c), and the + * CryptoKey values those methods answer. * * This unit is only the WebCrypto layer, modeled on Node 24's - * lib/internal/crypto/webcrypto.js and mac.js: Web IDL argument - * conversion, algorithm normalization, the CryptoKey handle, promise - * wrapping and Node's error shapes. The MACs and digests themselves come - * from node:crypto's digest core (scr_crypto_hmac_raw and - * scr_crypto_digest_raw in scr_lib.c), and results settle through the - * deferred crypto queue that node:crypto's callback forms use, so sign, - * verify and digest settle on a later loop turn like Node's thread-pool - * jobs while importKey settles at once. + * lib/internal/crypto/webcrypto.js, mac.js, aes.js and keys.js: Web IDL + * argument conversion, algorithm normalization, the CryptoKey handle, the + * JSON Web Key forms, promise wrapping and Node's error shapes. The MACs + * and digests themselves come from node:crypto's digest core + * (scr_crypto_hmac_raw and scr_crypto_digest_raw in scr_lib.c), and + * results settle through the deferred crypto queue that node:crypto's + * callback forms use, so sign, verify, digest and generateKey settle on a + * later loop turn like Node's thread-pool jobs while importKey and + * exportKey settle at once. * * Every argument and validation failure rejects the returned promise. * Algorithms Node recognizes but this slice does not implement (RSA, - * ECDSA, AES, SHA-3, ...) and the 'jwk' key format reject with a coded - * SC2020 Error instead of silently diverging. The compiler links the unit - * only into programs that call these methods (the webcrypto feature). */ + * ECDSA, AES-OCB, SHA-3, ...) and the key formats of asymmetric keys + * reject with a coded SC2020 Error instead of silently diverging. The + * compiler links the unit only into programs that call these methods + * (the webcrypto feature). */ #include "scr_runtime.h" #include @@ -28,8 +33,9 @@ /* ── algorithm registry ─────────────────────────────────────────────── * The names Node 24 registers per operation (util.js's * kAlgorithmDefinitions with the conditional algorithms its OpenSSL - * build enables), matched case-insensitively. Only HMAC and the SHA-1/ - * SHA-2 digests are implemented. */ + * build enables), matched case-insensitively. HMAC, AES-CBC/CTR/GCM/KW + * keys, PBKDF2 and HKDF key imports and the SHA-1/SHA-2 digests are + * implemented. */ static const char *const scr_wc_import_names[] = { "AES-CBC", "AES-CTR", "AES-GCM", "AES-KW", "AES-OCB", "Argon2d", "Argon2i", "Argon2id", "ChaCha20-Poly1305", @@ -43,6 +49,15 @@ static const char *const scr_wc_sign_names[] = { "ECDSA", "Ed25519", "Ed448", "HMAC", "KMAC128", "KMAC256", "ML-DSA-44", "ML-DSA-65", "ML-DSA-87", "RSA-PSS", "RSASSA-PKCS1-v1_5", }; +/* generateKey and exportKey register the same algorithms. */ +static const char *const scr_wc_key_names[] = { + "AES-CBC", "AES-CTR", "AES-GCM", "AES-KW", "AES-OCB", + "ChaCha20-Poly1305", "ECDH", "ECDSA", "Ed25519", "Ed448", + "HMAC", "KMAC128", "KMAC256", "ML-DSA-44", "ML-DSA-65", + "ML-DSA-87", "ML-KEM-512", "ML-KEM-768", "ML-KEM-1024", "MLKEM768-P256", + "MLKEM768-X25519", "MLKEM1024-P384", "RSA-OAEP", "RSA-PSS", "RSASSA-PKCS1-v1_5", + "X25519", "X448", +}; static const char *const scr_wc_digest_names[] = { "SHA-1", "SHA-256", "SHA-384", "SHA-512", "SHA3-256", "SHA3-384", "SHA3-512", "cSHAKE128", "cSHAKE256", "KT128", "KT256", "TurboSHAKE128", @@ -193,7 +208,24 @@ static const char *const scr_wc_usages[] = { "deriveKey", "deriveBits", "wrapKey", "unwrapKey", "encapsulateKey", "encapsulateBits", "decapsulateKey", "decapsulateBits", }; -enum { SCR_WC_USAGE_SIGN = 1u << 2, SCR_WC_USAGE_VERIFY = 1u << 3 }; +enum { + SCR_WC_USAGE_ENCRYPT = 1u << 0, + SCR_WC_USAGE_DECRYPT = 1u << 1, + SCR_WC_USAGE_SIGN = 1u << 2, + SCR_WC_USAGE_VERIFY = 1u << 3, + SCR_WC_USAGE_DERIVE_KEY = 1u << 4, + SCR_WC_USAGE_DERIVE_BITS = 1u << 5, + SCR_WC_USAGE_WRAP_KEY = 1u << 6, + SCR_WC_USAGE_UNWRAP_KEY = 1u << 7, +}; + +/* The usage index of a KeyUsage string, or -1. */ +static int scr_wc_usage_index(const ScrStr *s) { + for (size_t k = 0; k < SCR_WC_COUNT(scr_wc_usages); k++) + if (s->len == strlen(scr_wc_usages[k]) && memcmp(s->data, scr_wc_usages[k], s->len) == 0) + return (int)k; + return -1; +} /* sequence over an array: the usage mask (-1 on failure). */ static long scr_wc_key_usages(const char *prefix, size_t index, ScrDyn *value) { @@ -215,11 +247,8 @@ static long scr_wc_key_usages(const char *prefix, size_t index, ScrDyn *value) { scr_dyn_release(plain); return -1; } - size_t k = 0; - while (k < SCR_WC_COUNT(scr_wc_usages) && - !(s->len == strlen(scr_wc_usages[k]) && memcmp(s->data, scr_wc_usages[k], s->len) == 0)) - k++; - if (k == SCR_WC_COUNT(scr_wc_usages)) { + int k = scr_wc_usage_index(s); + if (k < 0) { scr_wc_type_error("ERR_INVALID_ARG_VALUE", "%s: %s argument[%.0f] '%.*s' is not a valid enum value of type KeyUsage.", prefix, scr_wc_ordinals[index], i, (int)(s->len > 200 ? 200 : s->len), @@ -237,10 +266,10 @@ static long scr_wc_key_usages(const char *prefix, size_t index, ScrDyn *value) { /* ── algorithm normalization ────────────────────────────────────────── * normalizeAlgorithm(algorithm, op) for the members this slice reads: - * the canonical name, and for HMAC imports the hash and length. */ + * the canonical name, the HMAC hash and length, and AES key lengths. */ typedef struct { const char *name; /* canonical registered name */ - const char *hash; /* HMAC import: the normalized hash name */ + const char *hash; /* HMAC: the normalized hash name */ bool has_length; double length; } ScrWcAlgorithm; @@ -261,6 +290,28 @@ static ScrDyn *scr_wc_member(const ScrDyn *dict, const char *key) { return v ? v : scr_dyn_retain(scr_dyn_undefined()); } +/* An [EnforceRange] integer conversion: the truncated value in [0, max], + * or false with Node's TypeError pending. `context` names the value + * ("length in passed algorithm", "3rd argument"). */ +static bool scr_wc_enforce_range(const char *prefix, const char *context, const ScrDyn *value, + double max, double *out) { + double x; + if (!scr_dyn_number_coerce_js(value, &x)) return false; + if (x != x || x == 1.0 / 0.0 || x == -1.0 / 0.0) { + scr_wc_type_error("ERR_INVALID_ARG_TYPE", "%s: %s is not a finite number.", prefix, context); + return false; + } + x = trunc(x); + if (x == 0) x = 0; + if (x < 0 || x > max) { + scr_wc_type_error("ERR_OUT_OF_RANGE", "%s: %s is outside the expected range of 0 to %.0f.", + prefix, context, max); + return false; + } + *out = x; + return true; +} + /* The name an AlgorithmIdentifier carries (+1), with the Algorithm * dictionary's missing-name TypeError. `dict` names the dictionary the * value converts to. */ @@ -295,11 +346,13 @@ static const char *scr_wc_digest_algorithm(ScrDyn *identifier, const char *metho return canonical; } -/* HmacImportParams over an object: hash (required, a SHA name), then the - * optional [EnforceRange] unsigned long length. */ -static bool scr_wc_hmac_import_params(ScrDyn *identifier, ScrWcAlgorithm *out) { +/* HmacImportParams / HmacKeyGenParams (`dict`) over an object: hash + * (required, a SHA name), then the optional [EnforceRange] unsigned long + * length, which cannot be 0 (`zero_error` names that DOMException). */ +static bool scr_wc_hmac_params(ScrDyn *identifier, const char *dict, const char *zero_error, + const char *method, ScrWcAlgorithm *out) { if (!scr_wc_is_object(identifier)) { - scr_wc_missing_member("HmacImportParams", "hash"); + scr_wc_missing_member(dict, "hash"); return false; } ScrDyn *plain = scr_wc_plain(identifier); @@ -307,7 +360,7 @@ static bool scr_wc_hmac_import_params(ScrDyn *identifier, ScrWcAlgorithm *out) { ScrDyn *hash = scr_wc_member(plain, "hash"); bool ok = true; if (hash->kind == SCR_DYN_UNDEF) { - scr_wc_missing_member("HmacImportParams", "hash"); + scr_wc_missing_member(dict, "hash"); ok = false; } ScrDyn *hash_value = NULL; @@ -335,7 +388,9 @@ static bool scr_wc_hmac_import_params(ScrDyn *identifier, ScrWcAlgorithm *out) { (hash_name->data[2] | 32) == 'a'; if (hash_name) scr_str_release(hash_name); if (ok && !sha) { - scr_throw_domex("NotSupportedError", "Only SHA hashes are supported in HmacImportParams"); + char message[96]; + snprintf(message, sizeof message, "Only SHA hashes are supported in %s", dict); + scr_throw_domex("NotSupportedError", message); ok = false; } } @@ -343,34 +398,23 @@ static bool scr_wc_hmac_import_params(ScrDyn *identifier, ScrWcAlgorithm *out) { ScrDyn *length = scr_wc_member(plain, "length"); if (length->kind != SCR_DYN_UNDEF) { double x; - if (!scr_dyn_number_coerce_js(length, &x)) ok = false; - else if (x != x || x == 1.0 / 0.0 || x == -1.0 / 0.0) { - scr_wc_type_error("ERR_INVALID_ARG_TYPE", - "%s: length in passed algorithm is not a finite number.", - scr_wc_normalize_prefix); + if (!scr_wc_enforce_range(scr_wc_normalize_prefix, "length in passed algorithm", length, + 4294967295.0, &x)) + ok = false; + else if (x == 0) { + char message[96]; + snprintf(message, sizeof message, "%s.length cannot be 0", dict); + scr_throw_domex(zero_error, message); ok = false; } else { - x = trunc(x); - if (x == 0) x = 0; - if (x < 0 || x > 4294967295.0) { - scr_wc_type_error("ERR_OUT_OF_RANGE", - "%s: length in passed algorithm is outside the expected range of 0 to " - "4294967295.", - scr_wc_normalize_prefix); - ok = false; - } else if (x == 0) { - scr_throw_domex("DataError", "HmacImportParams.length cannot be 0"); - ok = false; - } else { - out->has_length = true; - out->length = x; - } + out->has_length = true; + out->length = x; } } scr_dyn_release(length); } if (ok) { - out->hash = scr_wc_digest_algorithm(hash_value, "importKey"); + out->hash = scr_wc_digest_algorithm(hash_value, method); if (!out->hash) ok = false; } if (hash_value) scr_dyn_release(hash_value); @@ -379,11 +423,51 @@ static bool scr_wc_hmac_import_params(ScrDyn *identifier, ScrWcAlgorithm *out) { return ok; } -/* normalizeAlgorithm for importKey, sign/verify (`names`) — false with - * the error pending. Only HMAC parameters are read; any other recognized - * algorithm is refused by the caller. */ -static bool scr_wc_normalize(ScrDyn *identifier, const char *const *names, size_t count, - bool import, ScrWcAlgorithm *out) { +/* AesKeyGenParams / AesDerivedKeyParams (`dict`): the required + * [EnforceRange] unsigned short length, 128, 192 or 256. */ +static bool scr_wc_aes_length_params(ScrDyn *identifier, const char *dict, ScrWcAlgorithm *out) { + ScrDyn *plain = scr_wc_plain(identifier); + if (!plain) return false; + ScrDyn *length = scr_wc_member(plain, "length"); + bool ok = false; + double x; + if (length->kind == SCR_DYN_UNDEF) scr_wc_missing_member(dict, "length"); + else if (scr_wc_enforce_range(scr_wc_normalize_prefix, "length in passed algorithm", length, + 65535.0, &x)) { + if (x != 128 && x != 192 && x != 256) { + scr_throw_domex("OperationError", "AES key length must be 128, 192, or 256 bits"); + } else { + out->has_length = true; + out->length = x; + ok = true; + } + } + scr_dyn_release(length); + scr_dyn_release(plain); + return ok; +} + +static bool scr_wc_is_aes(const char *name) { + return strcmp(name, "AES-CBC") == 0 || strcmp(name, "AES-CTR") == 0 || + strcmp(name, "AES-GCM") == 0 || strcmp(name, "AES-KW") == 0; +} + +static bool scr_wc_is_kdf(const char *name) { + return strcmp(name, "PBKDF2") == 0 || strcmp(name, "HKDF") == 0; +} + +typedef enum { + SCR_WC_OP_IMPORT, + SCR_WC_OP_SIGN, + SCR_WC_OP_GENERATE, +} ScrWcOp; + +/* normalizeAlgorithm for importKey, sign/verify and generateKey (`names`) + * — false with the error pending. Only the dictionaries of the + * implemented algorithms are read; any other recognized algorithm is + * refused by the caller. */ +static bool scr_wc_normalize(ScrDyn *identifier, const char *const *names, size_t count, ScrWcOp op, + ScrWcAlgorithm *out) { memset(out, 0, sizeof *out); ScrStr *name = scr_wc_algorithm_name(identifier, "Algorithm"); if (!name) return false; @@ -393,19 +477,27 @@ static bool scr_wc_normalize(ScrDyn *identifier, const char *const *names, size_ scr_throw_domex("NotSupportedError", "Unrecognized algorithm name"); return false; } - if (import && strcmp(out->name, "HMAC") == 0) return scr_wc_hmac_import_params(identifier, out); + bool hmac = strcmp(out->name, "HMAC") == 0; + if (op == SCR_WC_OP_IMPORT && hmac) + return scr_wc_hmac_params(identifier, "HmacImportParams", "DataError", "importKey", out); + if (op == SCR_WC_OP_GENERATE && hmac) + return scr_wc_hmac_params(identifier, "HmacKeyGenParams", "OperationError", "generateKey", out); + if (op == SCR_WC_OP_GENERATE && scr_wc_is_aes(out->name)) + return scr_wc_aes_length_params(identifier, "AesKeyGenParams", out); return true; } /* ── CryptoKey ───────────────────────────────────────────────────────── - * A secret HMAC key: the bytes, the hash, the bit length, the usage mask - * and the extractable flag. The algorithm and usages getters answer the - * same object on every read (Node caches its clones), built on first - * read. The bytes are cleared when the last reference goes. */ + * A secret key: the algorithm name, the bytes, the HMAC hash, the bit + * length (HMAC and AES keys), the usage mask and the extractable flag. + * The algorithm and usages getters answer the same object on every read + * (Node caches its clones), built on first read. The bytes are cleared + * when the last reference goes. */ typedef struct ScrCryptoKey { size_t rc; - const char *hash; /* WebCrypto hash name */ - double length; /* bits */ + const char *name; /* canonical algorithm name */ + const char *hash; /* HMAC: WebCrypto hash name */ + double length; /* HMAC and AES: bits */ unsigned usages; bool extractable; ScrDyn *algorithm; /* cached getter results, or NULL */ @@ -446,26 +538,34 @@ static ScrDyn *scr_wc_cstr(const char *s) { return out; } +/* Node's algorithm objects: { name, length, hash } for HMAC keys, + * { name, length } for AES keys and { name } for PBKDF2 and HKDF keys. */ static ScrDyn *scr_crypto_key_algorithm(ScrCryptoKey *key) { if (!key->algorithm) { - ScrDyn *hash = scr_dyn_new_obj(); - scr_dyn_obj_set(hash, "name", 4, scr_wc_cstr(key->hash)); ScrDyn *algorithm = scr_dyn_new_obj(); - scr_dyn_obj_set(algorithm, "name", 4, scr_wc_cstr("HMAC")); - scr_dyn_obj_set(algorithm, "length", 6, scr_dyn_new_num(key->length)); - scr_dyn_obj_set(algorithm, "hash", 4, hash); + scr_dyn_obj_set(algorithm, "name", 4, scr_wc_cstr(key->name)); + if (!scr_wc_is_kdf(key->name)) + scr_dyn_obj_set(algorithm, "length", 6, scr_dyn_new_num(key->length)); + if (key->hash) { + ScrDyn *hash = scr_dyn_new_obj(); + scr_dyn_obj_set(hash, "name", 4, scr_wc_cstr(key->hash)); + scr_dyn_obj_set(algorithm, "hash", 4, hash); + } key->algorithm = algorithm; } return scr_dyn_retain(key->algorithm); } +/* The usages as a fresh array in Node's canonical order (+1). */ +static ScrDyn *scr_wc_usage_array(unsigned usages) { + ScrDyn *list = scr_dyn_new_arr(); + for (size_t i = 0; i < SCR_WC_COUNT(scr_wc_usages); i++) + if (usages & (1u << i)) scr_dyn_arr_push(list, scr_wc_cstr(scr_wc_usages[i])); + return list; +} + static ScrDyn *scr_crypto_key_usages(ScrCryptoKey *key) { - if (!key->usage_list) { - ScrDyn *list = scr_dyn_new_arr(); - for (size_t i = 0; i < SCR_WC_COUNT(scr_wc_usages); i++) - if (key->usages & (1u << i)) scr_dyn_arr_push(list, scr_wc_cstr(scr_wc_usages[i])); - key->usage_list = list; - } + if (!key->usage_list) key->usage_list = scr_wc_usage_array(key->usages); return scr_dyn_retain(key->usage_list); } @@ -540,8 +640,9 @@ static const ScrDynHandleOps scr_crypto_key_ops = { .symbol_get = scr_crypto_key_symbol_get, }; -static ScrDyn *scr_crypto_key_new(const unsigned char *data, size_t len, const char *hash, - double length, unsigned usages, bool extractable) { +static ScrDyn *scr_crypto_key_new(const unsigned char *data, size_t len, const char *name, + const char *hash, double length, unsigned usages, + bool extractable) { static SCR_TL bool installed; if (!installed) { installed = true; @@ -550,6 +651,7 @@ static ScrDyn *scr_crypto_key_new(const unsigned char *data, size_t len, const c ScrCryptoKey *key = malloc(sizeof *key + (len ? len : 1)); if (!key) scr_trap("scriptc: out of memory\n"); key->rc = 1; + key->name = name; key->hash = hash; key->length = length; key->usages = usages; @@ -563,6 +665,208 @@ static ScrDyn *scr_crypto_key_new(const unsigned char *data, size_t len, const c return box; } +/* numBitsToBytes: whole bytes for `bits`, rounding up. */ +static size_t scr_wc_bits_to_bytes(double bits) { + return (size_t)(floor(bits / 8) + floor((7 + fmod(bits, 8)) / 8)); +} + +/* Clears the unused low bits of the final byte of a `bits`-long key + * (truncateToBitLength). */ +static void scr_wc_truncate_bits(unsigned char *data, size_t len, double bits) { + int extra = (int)fmod(bits, 8); + if (extra && len) data[len - 1] = (unsigned char)(data[len - 1] & (0xff << (8 - extra))); +} + +/* The usages each key algorithm accepts. */ +static unsigned scr_wc_allowed_usages(const char *name) { + if (strcmp(name, "HMAC") == 0) return SCR_WC_USAGE_SIGN | SCR_WC_USAGE_VERIFY; + if (strcmp(name, "AES-KW") == 0) return SCR_WC_USAGE_WRAP_KEY | SCR_WC_USAGE_UNWRAP_KEY; + if (scr_wc_is_kdf(name)) return SCR_WC_USAGE_DERIVE_KEY | SCR_WC_USAGE_DERIVE_BITS; + return SCR_WC_USAGE_ENCRYPT | SCR_WC_USAGE_DECRYPT | SCR_WC_USAGE_WRAP_KEY | + SCR_WC_USAGE_UNWRAP_KEY; +} + +/* validateKeyUsages: SyntaxError for a usage outside the algorithm's. */ +static bool scr_wc_check_usages(const char *name, long usages) { + if (!(usages & ~(long)scr_wc_allowed_usages(name))) return true; + char message[96]; + snprintf(message, sizeof message, "Unsupported key usage for %s%s key", + scr_wc_is_kdf(name) ? "a " : "", name); + scr_throw_domex("SyntaxError", message); + return false; +} + +/* The JWK "alg" of an HMAC hash or an AES key, or NULL. */ +static const char *scr_wc_jwk_alg(const char *name, const char *hash, double length, char *buf, + size_t size) { + if (strcmp(name, "HMAC") == 0) { + if (strcmp(hash, "SHA-1") == 0) return "HS1"; + if (strcmp(hash, "SHA-256") == 0) return "HS256"; + if (strcmp(hash, "SHA-384") == 0) return "HS384"; + if (strcmp(hash, "SHA-512") == 0) return "HS512"; + return NULL; + } + if (!scr_wc_is_aes(name)) return NULL; + snprintf(buf, size, "A%.0f%s", length, name + 4); + return buf; +} + +/* ── JSON Web Keys ───────────────────────────────────────────────────── + * The JsonWebKey dictionary members a secret key reads, converted in Web + * IDL's member order (every DOMString member converts, so a Symbol or a + * throwing toString in any of them rejects like Node). */ +typedef struct { + ScrStr *alg, *k, *kty, *use; + bool has_ext, ext; + ScrDyn *key_ops; /* array of strings, or NULL */ +} ScrWcJwk; + +static void scr_wc_jwk_drop(ScrWcJwk *jwk) { + if (jwk->alg) scr_str_release(jwk->alg); + if (jwk->k) scr_str_release(jwk->k); + if (jwk->kty) scr_str_release(jwk->kty); + if (jwk->use) scr_str_release(jwk->use); + if (jwk->key_ops) scr_dyn_release(jwk->key_ops); + memset(jwk, 0, sizeof *jwk); +} + +/* A DOMString dictionary member: NULL with *ok when absent; NULL with + * !*ok and the TypeError pending on failure. */ +static ScrStr *scr_wc_jwk_string(const char *prefix, const ScrDyn *dict, const char *key, bool *ok) { + ScrDyn *value = scr_wc_member(dict, key); + ScrStr *out = NULL; + if (value->kind == SCR_DYN_SYMBOL) { + scr_wc_type_error("ERR_INVALID_ARG_TYPE", + "%s: %s in 2nd argument is a Symbol and cannot be converted to a string.", + prefix, key); + *ok = false; + } else if (value->kind != SCR_DYN_UNDEF) { + out = scr_wc_dom_string(value); + if (!out) *ok = false; + } + scr_dyn_release(value); + return out; +} + +static bool scr_wc_jwk_convert(const char *prefix, ScrDyn *value, ScrWcJwk *out) { + memset(out, 0, sizeof *out); + if (value->kind == SCR_DYN_UNDEF || value->kind == SCR_DYN_NULL) return true; + if (!scr_wc_is_object(value)) { + scr_wc_type_error("ERR_INVALID_ARG_TYPE", "%s: 2nd argument cannot be converted to a dictionary", + prefix); + return false; + } + ScrDyn *dict = scr_wc_plain(value); + if (!dict) return false; + static const char *const members[] = {"alg", "crv", "d", "dp", "dq", "e", "ext", + "k", "key_ops", "kty", "n", "p", "priv", "pub", + "q", "qi", "use", "x", "y"}; + bool ok = true; + for (size_t i = 0; ok && i < SCR_WC_COUNT(members); i++) { + const char *key = members[i]; + if (strcmp(key, "ext") == 0) { + ScrDyn *ext = scr_wc_member(dict, key); + if (ext->kind != SCR_DYN_UNDEF) { + out->has_ext = true; + out->ext = scr_dyn_truthy(ext); + } + scr_dyn_release(ext); + } else if (strcmp(key, "key_ops") == 0) { + ScrDyn *ops = scr_wc_member(dict, key); + if (ops->kind != SCR_DYN_UNDEF) { + ScrDyn *list = scr_wc_plain(ops); + if (!list) ok = false; + else if (list->kind != SCR_DYN_ARR) { + scr_wc_type_error("ERR_INVALID_ARG_TYPE", + "%s: key_ops in 2nd argument cannot be converted to sequence.", prefix); + scr_dyn_release(list); + ok = false; + } else { + ScrDyn *strings = scr_dyn_new_arr(); + double n = scr_dyn_arr_len(list); + for (double j = 0; ok && j < n; j++) { + ScrDyn *item = scr_dyn_arr_at(list, j); + ScrStr *s = scr_wc_dom_string(item); + scr_dyn_release(item); + if (!s) ok = false; + else { + scr_dyn_arr_push(strings, scr_dyn_new_str(s)); + scr_str_release(s); + } + } + scr_dyn_release(list); + if (ok) out->key_ops = strings; + else scr_dyn_release(strings); + } + } + scr_dyn_release(ops); + } else { + ScrStr *s = scr_wc_jwk_string(prefix, dict, key, &ok); + if (strcmp(key, "alg") == 0) out->alg = s; + else if (strcmp(key, "k") == 0) out->k = s; + else if (strcmp(key, "kty") == 0) out->kty = s; + else if (strcmp(key, "use") == 0) out->use = s; + else if (s) scr_str_release(s); + } + } + scr_dyn_release(dict); + if (!ok) scr_wc_jwk_drop(out); + return ok; +} + +static bool scr_wc_str_is(const ScrStr *s, const char *literal) { + return s && s->len == strlen(literal) && memcmp(s->data, literal, s->len) == 0; +} + +/* validateJwk for an oct key, then the key bytes (+1): k decodes with + * Node's lenient base64 decoder, so any string answers bytes. */ +static ScrBytes *scr_wc_jwk_secret(const ScrWcJwk *jwk, bool extractable, long usages, + const char *expected_use) { + if (!jwk->kty) { + scr_throw_domex("DataError", "Invalid keyData"); + return NULL; + } + if (!scr_wc_str_is(jwk->kty, "oct")) { + scr_throw_domex("DataError", "Invalid JWK \"kty\" Parameter"); + return NULL; + } + if (!jwk->k) { + scr_throw_domex("DataError", "Invalid keyData"); + return NULL; + } + if (usages != 0 && jwk->use && !scr_wc_str_is(jwk->use, expected_use)) { + scr_throw_domex("DataError", "Invalid JWK \"use\" Parameter"); + return NULL; + } + if (jwk->key_ops) { + long seen = 0; + double n = scr_dyn_arr_len(jwk->key_ops); + for (double i = 0; i < n; i++) { + ScrDyn *op = scr_dyn_arr_at(jwk->key_ops, i); + int k = scr_wc_usage_index(op->v.str); + scr_dyn_release(op); + if (k < 0) continue; + if (seen & (1L << k)) { + scr_throw_domex("DataError", "Duplicate key operation"); + return NULL; + } + seen |= 1L << k; + } + if ((seen & usages) != usages) { + scr_throw_domex("DataError", "Key operations and usage mismatch"); + return NULL; + } + } + if (jwk->has_ext && !jwk->ext && extractable) { + scr_throw_domex("DataError", "JWK \"ext\" Parameter and extractable mismatch"); + return NULL; + } + ScrStr *encoding = scr_str_new("base64url", 9); + ScrBytes *bytes = scr_bytes_from_str(jwk->k, encoding); + scr_str_release(encoding); + return bytes; +} + /* ── the operations ─────────────────────────────────────────────────── * Each takes its argument vector as one dyn array (borrowed) and answers * a +1 promise. */ @@ -573,6 +877,19 @@ static ScrPromise *scr_wc_rejected(void) { return p; } +/* A promise already fulfilled with `value` (moves). */ +static ScrPromise *scr_wc_resolved(ScrDyn *value) { + return scr_promise_settled_ref(value, &scr_dyn_retain_v, &scr_dyn_release_v, NULL); +} + +/* A promise that fulfills with `value` (moves) on a later loop turn, like + * Node's crypto jobs. */ +static ScrPromise *scr_wc_deferred(ScrDyn *value) { + ScrPromise *p = scr_promise_new(); + scr_crypto_defer_dyn(value, NULL, scr_crypto_promise_callback(p), scr_crypto_promise_settle_dyn); + return p; +} + /* The argument count check every method starts with (after the receiver * check the compiler's call shape already guarantees). */ static bool scr_wc_required(const char *prefix, const ScrDyn *args, size_t required) { @@ -595,9 +912,158 @@ static void scr_wc_args_drop(ScrWcArgs *a, size_t n) { for (size_t i = 0; i < n; i++) scr_dyn_release(a->v[i]); } +/* AlgorithmIdentifier: an object, or a value converted to a DOMString. */ +static bool scr_wc_algorithm_identifier(ScrDyn *value) { + if (scr_wc_is_object(value)) return true; + ScrStr *s = scr_wc_dom_string(value); + if (!s) return false; + scr_str_release(s); + return true; +} + +/* macImportKey: the usage check, the format, then normalizeKeyLength. */ +static ScrDyn *scr_wc_import_hmac(const char *format, ScrBytes *data, const ScrWcJwk *jwk, + const ScrWcAlgorithm *algorithm, bool extractable, long usages, + bool *unsupported) { + if (!scr_wc_check_usages("HMAC", usages)) return NULL; + ScrBytes *bytes = NULL; + if (strcmp(format, "raw") == 0 || strcmp(format, "raw-secret") == 0) { + bytes = scr_bytes_retain(data); + } else if (strcmp(format, "jwk") == 0) { + bytes = scr_wc_jwk_secret(jwk, extractable, usages, "sig"); + if (!bytes) return NULL; + char buf[16]; + const char *expected = scr_wc_jwk_alg("HMAC", algorithm->hash, 0, buf, sizeof buf); + if (jwk->alg && expected && !scr_wc_str_is(jwk->alg, expected)) { + scr_bytes_release(bytes); + scr_throw_domex("DataError", "JWK \"alg\" does not match the requested algorithm"); + return NULL; + } + } else { + *unsupported = true; + return NULL; + } + ScrDyn *result = NULL; + { + ScrBytes *view = bytes; + SCR_BYTES_SNAPSHOT(view); + size_t len = (size_t)scr_bytes_byte_len(view); + double length = (double)len * 8; + if (len == 0) { + scr_throw_domex("DataError", "Zero-length key is not supported"); + goto done; + } + if (algorithm->has_length) { + if (scr_wc_bits_to_bytes(algorithm->length) != len) { + scr_throw_domex("DataError", "Invalid key length"); + goto done; + } + length = algorithm->length; + } + result = scr_crypto_key_new(view->data, len, "HMAC", algorithm->hash, length, + (unsigned)usages, extractable); + ScrCryptoKey *key = scr_crypto_key_of(result); + scr_wc_truncate_bits(key->data, key->len, length); + } +done: + scr_bytes_release(bytes); + return result; +} + +/* aesImportKey: the usage check, then the format and the key length. */ +static ScrDyn *scr_wc_import_aes(const char *format, ScrBytes *data, const ScrWcJwk *jwk, + const char *name, bool extractable, long usages, + bool *unsupported) { + if (!scr_wc_check_usages(name, usages)) return NULL; + ScrBytes *bytes = NULL; + bool from_jwk = strcmp(format, "jwk") == 0; + if (strcmp(format, "raw") == 0 || strcmp(format, "raw-secret") == 0) { + bytes = scr_bytes_retain(data); + } else if (from_jwk) { + bytes = scr_wc_jwk_secret(jwk, extractable, usages, "enc"); + if (!bytes) return NULL; + } else { + *unsupported = true; + return NULL; + } + ScrDyn *result = NULL; + { + ScrBytes *view = bytes; + SCR_BYTES_SNAPSHOT(view); + size_t len = (size_t)scr_bytes_byte_len(view); + double length = (double)len * 8; + if (length != 128 && length != 192 && length != 256) { + scr_throw_domex("DataError", "Invalid key length"); + goto done; + } + char buf[16]; + if (from_jwk && jwk->alg && + !scr_wc_str_is(jwk->alg, scr_wc_jwk_alg(name, NULL, length, buf, sizeof buf))) { + scr_throw_domex("DataError", "JWK \"alg\" does not match the requested algorithm"); + goto done; + } + result = scr_crypto_key_new(view->data, len, name, NULL, length, (unsigned)usages, extractable); + } +done: + scr_bytes_release(bytes); + return result; +} + +/* importGenericSecretKey (PBKDF2, HKDF): never extractable, derivation + * usages only, raw bytes of any length. */ +static ScrDyn *scr_wc_import_kdf(const char *format, ScrBytes *data, const char *name, + bool extractable, long usages, bool *unsupported) { + if (extractable) { + char message[64]; + snprintf(message, sizeof message, "%s keys are not extractable", name); + scr_throw_domex("SyntaxError", message); + return NULL; + } + if (!scr_wc_check_usages(name, usages)) return NULL; + if (strcmp(format, "raw") != 0 && strcmp(format, "raw-secret") != 0) { + *unsupported = true; + return NULL; + } + ScrBytes *view = data; + SCR_BYTES_SNAPSHOT(view); + return scr_crypto_key_new(view->data, (size_t)scr_bytes_byte_len(view), name, NULL, 0, + (unsigned)usages, false); +} + +/* importKeySync over converted arguments: the per-algorithm import, the + * unsupported-format NotSupportedError, then the empty-usages check. */ +static ScrDyn *scr_wc_import_key_sync(const char *format, ScrBytes *data, const ScrWcJwk *jwk, + const ScrWcAlgorithm *algorithm, bool extractable, + long usages) { + bool unsupported = false; + ScrDyn *key; + if (strcmp(algorithm->name, "HMAC") == 0) + key = scr_wc_import_hmac(format, data, jwk, algorithm, extractable, usages, &unsupported); + else if (scr_wc_is_aes(algorithm->name)) + key = scr_wc_import_aes(format, data, jwk, algorithm->name, extractable, usages, &unsupported); + else if (scr_wc_is_kdf(algorithm->name)) + key = scr_wc_import_kdf(format, data, algorithm->name, extractable, usages, &unsupported); + else { + scr_wc_unsupported_algorithm("importKey", algorithm->name); + return NULL; + } + if (unsupported) { + char message[96]; + snprintf(message, sizeof message, "Unable to import %s using %s format", algorithm->name, + format); + scr_throw_domex("NotSupportedError", message); + return NULL; + } + if (key && usages == 0) { + scr_dyn_release(key); + scr_throw_domex("SyntaxError", "Usages cannot be empty when importing a secret key."); + return NULL; + } + return key; +} + /* importKey(format, keyData, algorithm, extractable, keyUsages): Node's - * conversion order, then macImportKey's checks and importKeySync's empty - * usage check. */ + * conversion order, then normalization and importKeySync. */ static ScrDyn *scr_wc_import(const ScrDyn *args) { static const char prefix[] = "Failed to execute 'importKey' on 'SubtleCrypto'"; if (!scr_wc_required(prefix, args, 5)) return NULL; @@ -605,77 +1071,28 @@ static ScrDyn *scr_wc_import(const ScrDyn *args) { scr_wc_args_take(&a, args, 5); ScrDyn *result = NULL; ScrBytes *data = NULL; + ScrWcJwk jwk; + memset(&jwk, 0, sizeof jwk); const char *format = scr_wc_key_format(prefix, a.v[0]); if (!format) goto done; - bool jwk = strcmp(format, "jwk") == 0; - /* The JsonWebKey dictionary is not implemented; that format is refused - * after the remaining arguments convert. */ - if (!jwk) { + if (strcmp(format, "jwk") == 0) { + if (!scr_wc_jwk_convert(prefix, a.v[1], &jwk)) goto done; + } else { data = scr_wc_buffer_source(prefix, 1, a.v[1]); if (!data) goto done; } - if (!scr_wc_is_object(a.v[2])) { - ScrStr *s = scr_wc_dom_string(a.v[2]); - if (!s) goto done; - scr_str_release(s); - } + if (!scr_wc_algorithm_identifier(a.v[2])) goto done; bool extractable = scr_dyn_truthy(a.v[3]); long usages = scr_wc_key_usages(prefix, 4, a.v[4]); if (usages < 0) goto done; ScrWcAlgorithm algorithm; - if (!scr_wc_normalize(a.v[2], scr_wc_import_names, SCR_WC_COUNT(scr_wc_import_names), true, - &algorithm)) + if (!scr_wc_normalize(a.v[2], scr_wc_import_names, SCR_WC_COUNT(scr_wc_import_names), + SCR_WC_OP_IMPORT, &algorithm)) goto done; - if (strcmp(algorithm.name, "HMAC") != 0) { - scr_wc_unsupported_algorithm("importKey", algorithm.name); - goto done; - } - if (usages & ~(long)(SCR_WC_USAGE_SIGN | SCR_WC_USAGE_VERIFY)) { - scr_throw_domex("SyntaxError", "Unsupported key usage for HMAC key"); - goto done; - } - if (jwk) { - scr_wc_unsupported("importKey", "the 'jwk' key format"); - goto done; - } - if (strcmp(format, "raw") != 0 && strcmp(format, "raw-secret") != 0) { - char message[96]; - snprintf(message, sizeof message, "Unable to import HMAC using %s format", format); - scr_throw_domex("NotSupportedError", message); - goto done; - } - { - ScrBytes *view = data; - SCR_BYTES_SNAPSHOT(view); - size_t len = (size_t)scr_bytes_byte_len(view); - if (len == 0) { - scr_throw_domex("DataError", "Zero-length key is not supported"); - goto done; - } - double length = (double)len * 8; - unsigned char last = view->data[len - 1]; - if (algorithm.has_length) { - double bytes = floor(algorithm.length / 8) + floor((7 + fmod(algorithm.length, 8)) / 8); - if (bytes != (double)len) { - scr_throw_domex("DataError", "Invalid key length"); - goto done; - } - /* A length that is not a whole number of bytes clears the unused - * low bits of the final byte (truncateToBitLength). */ - int extra = (int)fmod(algorithm.length, 8); - if (extra) last = (unsigned char)(last & (0xff << (8 - extra))); - length = algorithm.length; - } - if (usages == 0) { - scr_throw_domex("SyntaxError", "Usages cannot be empty when importing a secret key."); - goto done; - } - result = scr_crypto_key_new(view->data, len, algorithm.hash, length, (unsigned)usages, - extractable); - scr_crypto_key_of(result)->data[len - 1] = last; - } + result = scr_wc_import_key_sync(format, data, &jwk, &algorithm, extractable, usages); done: if (data) scr_bytes_release(data); + scr_wc_jwk_drop(&jwk); scr_wc_args_drop(&a, 5); return result; } @@ -683,7 +1100,118 @@ done: ScrPromise *scr_webcrypto_import_key(ScrDyn *args) { ScrDyn *key = scr_wc_import(args); if (!key) return scr_wc_rejected(); - return scr_promise_settled_ref(key, &scr_dyn_retain_v, &scr_dyn_release_v, NULL); + return scr_wc_resolved(key); +} + +/* generateKey(algorithm, extractable, keyUsages) for HMAC and AES keys: + * random bytes of the requested length (an HMAC key defaults to its + * hash's block size; a length that is not a whole number of bytes clears + * the final byte's unused low bits). */ +ScrPromise *scr_webcrypto_generate_key(ScrDyn *args) { + static const char prefix[] = "Failed to execute 'generateKey' on 'SubtleCrypto'"; + if (!scr_wc_required(prefix, args, 3)) return scr_wc_rejected(); + ScrWcArgs a; + scr_wc_args_take(&a, args, 3); + ScrDyn *key = NULL; + if (!scr_wc_algorithm_identifier(a.v[0])) goto done; + bool extractable = scr_dyn_truthy(a.v[1]); + long usages = scr_wc_key_usages(prefix, 2, a.v[2]); + if (usages < 0) goto done; + ScrWcAlgorithm algorithm; + if (!scr_wc_normalize(a.v[0], scr_wc_key_names, SCR_WC_COUNT(scr_wc_key_names), + SCR_WC_OP_GENERATE, &algorithm)) + goto done; + bool hmac = strcmp(algorithm.name, "HMAC") == 0; + if (!hmac && !scr_wc_is_aes(algorithm.name)) { + scr_wc_unsupported_algorithm("generateKey", algorithm.name); + goto done; + } + if (!scr_wc_check_usages(algorithm.name, usages)) goto done; + if (usages == 0) { + scr_throw_domex("SyntaxError", "Usages cannot be empty when creating a key."); + goto done; + } + double length = algorithm.has_length ? algorithm.length + : strcmp(algorithm.hash, "SHA-384") == 0 || strcmp(algorithm.hash, "SHA-512") == 0 + ? 1024 + : 512; + size_t len = scr_wc_bits_to_bytes(length); + unsigned char *bytes = malloc(len ? len : 1); + if (!bytes) scr_trap("scriptc: out of memory\n"); + arc4random_buf(bytes, len); + scr_wc_truncate_bits(bytes, len, length); + key = scr_crypto_key_new(bytes, len, algorithm.name, hmac ? algorithm.hash : NULL, length, + (unsigned)usages, extractable); + volatile unsigned char *wipe = bytes; + for (size_t i = 0; i < len; i++) wipe[i] = 0; + free(bytes); +done: + scr_wc_args_drop(&a, 3); + if (!key) return scr_wc_rejected(); + return scr_wc_deferred(key); +} + +/* exportKeySync for secret keys: raw and raw-secret answer an ArrayBuffer + * of the key bytes, jwk an object { key_ops, ext, alg, kty, k }. */ +static ScrDyn *scr_wc_export(const ScrDyn *args) { + static const char prefix[] = "Failed to execute 'exportKey' on 'SubtleCrypto'"; + if (!scr_wc_required(prefix, args, 2)) return NULL; + ScrWcArgs a; + scr_wc_args_take(&a, args, 2); + ScrDyn *result = NULL; + const char *format = scr_wc_key_format(prefix, a.v[0]); + if (!format) goto done; + ScrCryptoKey *key = scr_crypto_key_of(a.v[1]); + if (!key) { + scr_wc_type_error("ERR_INVALID_ARG_TYPE", "%s: 2nd argument is not of type CryptoKey.", prefix); + goto done; + } + if (scr_wc_is_kdf(key->name)) { + char message[64]; + snprintf(message, sizeof message, "%s key export is not supported", key->name); + scr_throw_domex("NotSupportedError", message); + goto done; + } + if (!key->extractable) { + scr_throw_domex("InvalidAccessError", "key is not extractable"); + goto done; + } + if (strcmp(format, "raw") == 0 || strcmp(format, "raw-secret") == 0) { + ScrBytes *bytes = scr_bytes_new(SCR_BYTES_U8, (double)key->len); + if (key->len) memcpy(bytes->data, key->data, key->len); + result = scr_array_buffer_from_bytes(bytes); + scr_bytes_release(bytes); + } else if (strcmp(format, "jwk") == 0) { + char buf[16]; + const char *alg = scr_wc_jwk_alg(key->name, key->hash, key->length, buf, sizeof buf); + ScrBytes *bytes = scr_bytes_new(SCR_BYTES_U8, (double)key->len); + if (key->len) memcpy(bytes->data, key->data, key->len); + ScrStr *encoding = scr_str_new("base64url", 9); + ScrStr *k = scr_bytes_to_str(bytes, encoding); + scr_str_release(encoding); + scr_bytes_release(bytes); + result = scr_dyn_new_obj(); + scr_dyn_obj_set(result, "key_ops", 7, scr_wc_usage_array(key->usages)); + scr_dyn_obj_set(result, "ext", 3, scr_dyn_new_bool(key->extractable)); + if (alg) scr_dyn_obj_set(result, "alg", 3, scr_wc_cstr(alg)); + scr_dyn_obj_set(result, "kty", 3, scr_wc_cstr("oct")); + scr_dyn_obj_set(result, "k", 1, scr_dyn_new_str(k)); + scr_str_release(k); + } else { + char message[96]; + snprintf(message, sizeof message, "Unable to export %s secret key using %s format", key->name, + format); + scr_throw_domex("NotSupportedError", message); + } +done: + scr_wc_args_drop(&a, 2); + return result; +} + +ScrPromise *scr_webcrypto_export_key(ScrDyn *args) { + ScrDyn *result = scr_wc_export(args); + if (!result) return scr_wc_rejected(); + return scr_wc_resolved(result); } /* sign(algorithm, key, data) / verify(algorithm, key, signature, data): @@ -717,13 +1245,17 @@ static bool scr_wc_sign_verify(const ScrDyn *args, bool verify, unsigned char ma data = scr_wc_buffer_source(prefix, verify ? 3 : 2, a.v[verify ? 3 : 2]); if (!data) goto done; ScrWcAlgorithm algorithm; - if (!scr_wc_normalize(a.v[0], scr_wc_sign_names, SCR_WC_COUNT(scr_wc_sign_names), false, - &algorithm)) + if (!scr_wc_normalize(a.v[0], scr_wc_sign_names, SCR_WC_COUNT(scr_wc_sign_names), + SCR_WC_OP_SIGN, &algorithm)) goto done; if (strcmp(algorithm.name, "HMAC") != 0) { scr_wc_unsupported_algorithm(method, algorithm.name); goto done; } + if (strcmp(key->name, algorithm.name) != 0) { + scr_throw_domex("InvalidAccessError", "Key algorithm mismatch"); + goto done; + } if (!(key->usages & (verify ? SCR_WC_USAGE_VERIFY : SCR_WC_USAGE_SIGN))) { char message[64]; snprintf(message, sizeof message, "Unable to use this key to %s", method); @@ -827,3 +1359,563 @@ done: scr_crypto_promise_settle_array_buffer); return p; } + +/* ── encrypt and decrypt ────────────────────────────────────────────── + * The WebCrypto half of encrypt and decrypt: argument conversion, the + * AesCbcParams, AesCtrParams and AeadParams dictionaries, and the key + * checks. The cipher itself runs in scr_webcrypto_aes.c, which links + * with the mbedTLS archive and passes it in. */ +static const char *const scr_wc_cipher_names[] = { + "AES-CBC", "AES-CTR", "AES-GCM", "AES-OCB", "ChaCha20-Poly1305", "RSA-OAEP", +}; + +/* Node's limit on the data, IV and additional data (kMaxBufferLength). */ +static const double scr_wc_max_buffer = 2147483647.0; + +/* A BufferSource member of an algorithm dictionary: false with the error + * pending; *out stays NULL when an optional member is absent. */ +static bool scr_wc_member_buffer(const ScrDyn *dict, const char *dict_name, const char *key, + bool required, ScrBytes **out) { + ScrDyn *value = scr_wc_member(dict, key); + bool ok = true; + if (value->kind == SCR_DYN_UNDEF) { + if (required) { + scr_wc_missing_member(dict_name, key); + ok = false; + } + } else { + ScrDyn *plain = scr_wc_plain(value); + if (!plain) ok = false; + else if (plain->kind == SCR_DYN_BYTES || scr_array_buffer_is(plain)) { + *out = scr_bytes_buffer_source(plain); + } else { + scr_wc_type_error("ERR_INVALID_ARG_TYPE", + "%s: %s in passed algorithm is not instance of ArrayBuffer, Buffer, " + "TypedArray, or DataView.", + scr_wc_normalize_prefix, key); + ok = false; + } + if (plain) scr_dyn_release(plain); + } + scr_dyn_release(value); + return ok; +} + +/* validateByteLength / validateMaxBufferLength over a converted member. */ +static bool scr_wc_exact_length(const ScrBytes *bytes, const char *name, double length) { + if (scr_bytes_byte_len(bytes) == length) return true; + char message[96]; + snprintf(message, sizeof message, "%s must contain exactly %.0f bytes", name, length); + scr_throw_domex("OperationError", message); + return false; +} + +static bool scr_wc_max_length(const ScrBytes *bytes, const char *name) { + if (scr_bytes_byte_len(bytes) <= scr_wc_max_buffer) return true; + char message[96]; + snprintf(message, sizeof message, "%s must be at most %.0f bytes", name, scr_wc_max_buffer); + scr_throw_domex("OperationError", message); + return false; +} + +typedef struct { + ScrBytes *iv; /* the IV or the CTR counter block */ + ScrBytes *aad; + double tag_bits; + double counter_bits; +} ScrWcCipherParams; + +static void scr_wc_cipher_params_drop(ScrWcCipherParams *params) { + if (params->iv) scr_bytes_release(params->iv); + if (params->aad) scr_bytes_release(params->aad); + params->iv = params->aad = NULL; +} + +/* An optional or required [EnforceRange] octet member: false with the + * error pending; *present says whether it was given. */ +static bool scr_wc_member_octet(const ScrDyn *dict, const char *dict_name, const char *key, + bool required, bool *present, double *out) { + ScrDyn *value = scr_wc_member(dict, key); + bool ok = true; + *present = value->kind != SCR_DYN_UNDEF; + if (!*present) { + if (required) { + scr_wc_missing_member(dict_name, key); + ok = false; + } + } else { + char context[48]; + snprintf(context, sizeof context, "%s in passed algorithm", key); + ok = scr_wc_enforce_range(scr_wc_normalize_prefix, context, value, 255, out); + } + scr_dyn_release(value); + return ok; +} + +/* normalizeAlgorithm(algorithm, 'encrypt' / 'decrypt'): the canonical + * name and the AES dictionaries' members, in Web IDL member order with + * each member's validator right after its conversion. */ +static const char *scr_wc_normalize_cipher(ScrDyn *identifier, const char *method, + ScrWcCipherParams *params) { + memset(params, 0, sizeof *params); + params->tag_bits = 128; + ScrStr *name = scr_wc_algorithm_name(identifier, "Algorithm"); + if (!name) return NULL; + const char *canonical = + scr_wc_lookup(scr_wc_cipher_names, SCR_WC_COUNT(scr_wc_cipher_names), name); + scr_str_release(name); + if (!canonical) { + scr_throw_domex("NotSupportedError", "Unrecognized algorithm name"); + return NULL; + } + if (!scr_wc_is_aes(canonical)) { + scr_wc_unsupported_algorithm(method, canonical); + return NULL; + } + ScrDyn *dict = scr_wc_is_object(identifier) ? scr_wc_plain(identifier) + : scr_dyn_retain(scr_dyn_undefined()); + if (!dict) return NULL; + bool ok = true; + bool present; + if (strcmp(canonical, "AES-CBC") == 0) { + ok = scr_wc_member_buffer(dict, "AesCbcParams", "iv", true, ¶ms->iv) && + scr_wc_exact_length(params->iv, "algorithm.iv", 16); + } else if (strcmp(canonical, "AES-CTR") == 0) { + ok = scr_wc_member_buffer(dict, "AesCtrParams", "counter", true, ¶ms->iv) && + scr_wc_exact_length(params->iv, "algorithm.counter", 16) && + scr_wc_member_octet(dict, "AesCtrParams", "length", true, &present, + ¶ms->counter_bits); + if (ok && (params->counter_bits == 0 || params->counter_bits > 128)) { + scr_throw_domex("OperationError", "AES-CTR algorithm.length must be between 1 and 128"); + ok = false; + } + } else { + ok = scr_wc_member_buffer(dict, "AeadParams", "additionalData", false, ¶ms->aad) && + (!params->aad || scr_wc_max_length(params->aad, "algorithm.additionalData")) && + scr_wc_member_buffer(dict, "AeadParams", "iv", true, ¶ms->iv) && + scr_wc_max_length(params->iv, "algorithm.iv") && + scr_wc_member_octet(dict, "AeadParams", "tagLength", false, &present, ¶ms->tag_bits); + if (ok && !present) params->tag_bits = 128; + double t = params->tag_bits; + if (ok && t != 32 && t != 64 && t != 96 && t != 104 && t != 112 && t != 120 && t != 128) { + char message[64]; + snprintf(message, sizeof message, "%.0f is not a valid AES-GCM tag length", t); + scr_throw_domex("OperationError", message); + ok = false; + } + } + scr_dyn_release(dict); + if (!ok) { + scr_wc_cipher_params_drop(params); + return NULL; + } + return canonical; +} + +static void *scr_wc_caught_retain(void *c) { return scr_caught_retain(c); } +static void scr_wc_caught_release(void *c) { scr_caught_release(c); } + +static void scr_wc_settle_rethrow(ScrClosure *cb, ScrError *error, ScrBytes *value) { + (void)error; + (void)value; + ScrPromise *p; + ScrCaught *caught; + memcpy(&p, &cb->caps[0]->slot, sizeof p); + memcpy(&caught, &cb->caps[1]->slot, sizeof caught); + scr_rethrow(caught); + scr_promise_reject_pending(p); +} + +/* A job failure: a fresh promise that rejects with the pending exception + * on a later loop turn, as Node's job promises do (+1). */ +static ScrPromise *scr_wc_deferred_rejection(void) { + ScrPromise *p = scr_promise_new(); + ScrClosure *cb = scr_closure_new(NULL, 2); + cb->caps[0] = scr_box_new_obj(scr_promise_retain_v, scr_promise_release_v, NULL); + scr_box_set_ref(cb->caps[0], scr_promise_retain(p)); + cb->caps[1] = scr_box_new_obj(scr_wc_caught_retain, scr_wc_caught_release, scr_caught_trace_v); + scr_box_set_ref(cb->caps[1], scr_exc_take()); + scr_crypto_defer_bytes(NULL, NULL, cb, scr_wc_settle_rethrow); + return p; +} + +/* A promise that fulfills with an ArrayBuffer of `bytes` (moves) on a + * later loop turn. */ +static ScrPromise *scr_wc_deferred_buffer(ScrBytes *bytes) { + ScrPromise *p = scr_promise_new(); + scr_crypto_defer_bytes(bytes, NULL, scr_crypto_promise_callback(p), + scr_crypto_promise_settle_array_buffer); + return p; +} + +ScrPromise *scr_webcrypto_cipher(ScrDyn *args, bool decrypt, ScrWebCryptoAesFn aes) { + const char *method = decrypt ? "decrypt" : "encrypt"; + const char *prefix = decrypt ? "Failed to execute 'decrypt' on 'SubtleCrypto'" + : "Failed to execute 'encrypt' on 'SubtleCrypto'"; + if (!scr_wc_required(prefix, args, 3)) return scr_wc_rejected(); + ScrWcArgs a; + scr_wc_args_take(&a, args, 3); + ScrBytes *data = NULL; + ScrWcCipherParams params; + memset(¶ms, 0, sizeof params); + ScrPromise *result = NULL; + if (!scr_wc_algorithm_identifier(a.v[0])) goto done; + ScrCryptoKey *key = scr_crypto_key_of(a.v[1]); + if (!key) { + scr_wc_type_error("ERR_INVALID_ARG_TYPE", "%s: 2nd argument is not of type CryptoKey.", prefix); + goto done; + } + data = scr_wc_buffer_source(prefix, 2, a.v[2]); + if (!data) goto done; + const char *name = scr_wc_normalize_cipher(a.v[0], method, ¶ms); + if (!name) goto done; + if (strcmp(key->name, name) != 0) { + scr_throw_domex("InvalidAccessError", "Key algorithm mismatch"); + goto done; + } + if (!(key->usages & (decrypt ? SCR_WC_USAGE_DECRYPT : SCR_WC_USAGE_ENCRYPT))) { + char message[64]; + snprintf(message, sizeof message, "Unable to use this key to %s", method); + scr_throw_domex("InvalidAccessError", message); + goto done; + } + if (!scr_wc_max_length(data, "data")) goto done; + { + ScrBytes *view = data; + SCR_BYTES_SNAPSHOT(view); + ScrBytes *iv = params.iv; + SCR_BYTES_SNAPSHOT(iv); + if (!params.aad) params.aad = scr_bytes_new(SCR_BYTES_U8, 0); + ScrBytes *aad = params.aad; + SCR_BYTES_SNAPSHOT(aad); + ScrWebCryptoAesParams run = { + .iv = iv->data, + .iv_len = (size_t)scr_bytes_byte_len(iv), + .aad = aad->data, + .aad_len = (size_t)scr_bytes_byte_len(aad), + .tag_len = (size_t)(params.tag_bits / 8), + .counter_bits = (unsigned)params.counter_bits, + }; + ScrBytes *out = aes(name, decrypt, key->data, key->len, &run, view->data, + (size_t)scr_bytes_byte_len(view)); + if (out) { + result = scr_wc_deferred_buffer(out); + } else { + scr_throw_domex("OperationError", "The operation failed for an operation-specific reason"); + result = scr_wc_deferred_rejection(); + } + } +done: + if (data) scr_bytes_release(data); + scr_wc_cipher_params_drop(¶ms); + scr_wc_args_drop(&a, 3); + return result ? result : scr_wc_rejected(); +} + +/* ── deriveBits and deriveKey ───────────────────────────────────────── + * PBKDF2 and HKDF over node:crypto's KDF core (scr_crypto_pbkdf2 and + * scr_crypto_hkdf_bytes in scr_lib.c), with Node's Pbkdf2Params and + * HkdfParams dictionaries, length rules and key checks. deriveKey derives + * the bits the derived key type needs and imports them as a raw-secret + * key of that type. */ +static const char *const scr_wc_derive_names[] = { + "Argon2d", "Argon2i", "Argon2id", "ECDH", "HKDF", "PBKDF2", "X25519", "X448", +}; +/* The algorithms 'get key length' registers. */ +static const char *const scr_wc_length_names[] = { + "AES-CBC", "AES-CTR", "AES-GCM", "AES-KW", "AES-OCB", "Argon2d", "Argon2i", + "Argon2id", "ChaCha20-Poly1305", "HKDF", "HMAC", "KMAC128", "KMAC256", "PBKDF2", +}; + +typedef struct { + const char *name; + const char *hash; + double iterations; + ScrBytes *salt; + ScrBytes *info; +} ScrWcKdfParams; + +static void scr_wc_kdf_params_drop(ScrWcKdfParams *params) { + if (params->salt) scr_bytes_release(params->salt); + if (params->info) scr_bytes_release(params->info); + params->salt = params->info = NULL; +} + +/* A HashAlgorithmIdentifier member with ensureSHA (`dict` names the + * dictionary); *hash is the member value for the later digest + * normalization (+1). */ +static bool scr_wc_member_hash(const ScrDyn *dict, const char *dict_name, ScrDyn **hash) { + ScrDyn *value = scr_wc_member(dict, "hash"); + if (value->kind == SCR_DYN_UNDEF) { + scr_dyn_release(value); + scr_wc_missing_member(dict_name, "hash"); + return false; + } + ScrStr *name = NULL; + bool ok = true; + if (scr_wc_is_object(value)) { + ScrDyn *plain = scr_wc_plain(value); + ScrDyn *member = plain ? scr_wc_member(plain, "name") : NULL; + if (plain) scr_dyn_release(plain); + if (!member) ok = false; + else { + if (member->kind == SCR_DYN_STR) name = scr_str_retain(member->v.str); + scr_dyn_release(member); + } + *hash = scr_dyn_retain(value); + } else { + name = scr_wc_dom_string(value); + if (!name) ok = false; + *hash = name ? scr_dyn_new_str(name) : NULL; + } + scr_dyn_release(value); + bool sha = name && name->len >= 3 && (name->data[0] | 32) == 's' && + (name->data[1] | 32) == 'h' && (name->data[2] | 32) == 'a'; + if (name) scr_str_release(name); + if (ok && !sha) { + char message[96]; + snprintf(message, sizeof message, "Only SHA hashes are supported in %s", dict_name); + scr_throw_domex("NotSupportedError", message); + ok = false; + } + if (!ok && *hash) { + scr_dyn_release(*hash); + *hash = NULL; + } + return ok; +} + +/* normalizeAlgorithm(algorithm, 'deriveBits') for PBKDF2 and HKDF. */ +static bool scr_wc_normalize_kdf(ScrDyn *identifier, const char *method, ScrWcKdfParams *params) { + memset(params, 0, sizeof *params); + ScrStr *name = scr_wc_algorithm_name(identifier, "Algorithm"); + if (!name) return false; + params->name = scr_wc_lookup(scr_wc_derive_names, SCR_WC_COUNT(scr_wc_derive_names), name); + scr_str_release(name); + if (!params->name) { + scr_throw_domex("NotSupportedError", "Unrecognized algorithm name"); + return false; + } + if (!scr_wc_is_kdf(params->name)) { + scr_wc_unsupported_algorithm(method, params->name); + return false; + } + bool pbkdf2 = strcmp(params->name, "PBKDF2") == 0; + const char *dict_name = pbkdf2 ? "Pbkdf2Params" : "HkdfParams"; + ScrDyn *dict = scr_wc_is_object(identifier) ? scr_wc_plain(identifier) + : scr_dyn_retain(scr_dyn_undefined()); + if (!dict) return false; + ScrDyn *hash = NULL; + bool ok = scr_wc_member_hash(dict, dict_name, &hash); + if (ok && pbkdf2) { + ScrDyn *iterations = scr_wc_member(dict, "iterations"); + if (iterations->kind == SCR_DYN_UNDEF) { + scr_wc_missing_member(dict_name, "iterations"); + ok = false; + } else if (!scr_wc_enforce_range(scr_wc_normalize_prefix, "iterations in passed algorithm", + iterations, 4294967295.0, ¶ms->iterations)) { + ok = false; + } else if (params->iterations == 0) { + scr_throw_domex("OperationError", "iterations cannot be zero"); + ok = false; + } else if (params->iterations > 2147483647.0) { + scr_throw_domex("NotSupportedError", "iterations exceeds the implementation limit"); + ok = false; + } + scr_dyn_release(iterations); + ok = ok && scr_wc_member_buffer(dict, dict_name, "salt", true, ¶ms->salt); + } else if (ok) { + ok = scr_wc_member_buffer(dict, dict_name, "info", true, ¶ms->info); + if (ok && scr_bytes_byte_len(params->info) > 1024) { + scr_throw_domex("OperationError", "algorithm.info must be at most 1024 bytes"); + ok = false; + } + ok = ok && scr_wc_member_buffer(dict, dict_name, "salt", true, ¶ms->salt); + } + scr_dyn_release(dict); + if (ok) { + params->hash = scr_wc_digest_algorithm(hash, method); + if (!params->hash) ok = false; + } + if (hash) scr_dyn_release(hash); + if (!ok) scr_wc_kdf_params_drop(params); + return ok; +} + +/* The length rules of pbkdf2DeriveBits and hkdfDeriveBits; `null_length` + * says the length was null. */ +static bool scr_wc_kdf_length(const ScrWcKdfParams *params, bool null_length, double length) { + if (null_length) { + scr_throw_domex("OperationError", "length cannot be null"); + return false; + } + if (fmod(length, 8) != 0) { + scr_throw_domex("OperationError", "length must be a multiple of 8"); + return false; + } + if (strcmp(params->name, "HKDF") == 0) { + double digest = strcmp(params->hash, "SHA-1") == 0 ? 20 + : strcmp(params->hash, "SHA-256") == 0 ? 32 + : strcmp(params->hash, "SHA-384") == 0 ? 48 + : 64; + if (length > 255 * digest * 8) { + scr_throw_domex("OperationError", "length exceeds the maximum derived bit length"); + return false; + } + } + return true; +} + +/* The derived bytes (+1); length is a nonzero multiple of 8. */ +static ScrBytes *scr_wc_kdf_derive(const ScrWcKdfParams *params, const ScrCryptoKey *key, + double length) { + ScrBytes *secret = scr_bytes_new(SCR_BYTES_U8, (double)key->len); + if (key->len) memcpy(secret->data, key->data, key->len); + const char *native = scr_wc_native_hash(params->hash); + ScrStr *digest = scr_str_new(native, strlen(native)); + ScrBytes *out; + if (strcmp(params->name, "PBKDF2") == 0) { + out = scr_crypto_pbkdf2(secret, params->salt, params->iterations, length / 8, digest); + } else { + out = scr_crypto_hkdf_bytes(digest, secret, params->salt, params->info, length / 8); + } + scr_str_release(digest); + volatile unsigned char *wipe = secret->data; + for (size_t i = 0; i < key->len; i++) wipe[i] = 0; + scr_bytes_release(secret); + return out; +} + +/* The base key checks deriveBits and deriveKey share. */ +static bool scr_wc_check_base_key(const ScrCryptoKey *key, const char *algorithm, unsigned usage, + const char *usage_name) { + if (!(key->usages & usage)) { + char message[64]; + snprintf(message, sizeof message, "baseKey does not have %s usage", usage_name); + scr_throw_domex("InvalidAccessError", message); + return false; + } + if (strcmp(key->name, algorithm) != 0) { + scr_throw_domex("InvalidAccessError", "Key algorithm mismatch"); + return false; + } + return true; +} + +/* deriveBits(algorithm, baseKey[, length]). */ +ScrPromise *scr_webcrypto_derive_bits(ScrDyn *args) { + static const char prefix[] = "Failed to execute 'deriveBits' on 'SubtleCrypto'"; + if (!scr_wc_required(prefix, args, 2)) return scr_wc_rejected(); + size_t argc = (size_t)scr_dyn_arr_len(args); + ScrWcArgs a; + size_t n = argc > 3 ? 3 : argc; + scr_wc_args_take(&a, args, n); + ScrWcKdfParams params; + memset(¶ms, 0, sizeof params); + ScrPromise *result = NULL; + if (!scr_wc_algorithm_identifier(a.v[0])) goto done; + ScrCryptoKey *key = scr_crypto_key_of(a.v[1]); + if (!key) { + scr_wc_type_error("ERR_INVALID_ARG_TYPE", "%s: 2nd argument is not of type CryptoKey.", prefix); + goto done; + } + /* length defaults to null when absent or undefined. */ + bool null_length = n < 3 || a.v[2]->kind == SCR_DYN_UNDEF || a.v[2]->kind == SCR_DYN_NULL; + double length = 0; + if (!null_length && !scr_wc_enforce_range(prefix, "3rd argument", a.v[2], 4294967295.0, &length)) + goto done; + if (!scr_wc_normalize_kdf(a.v[0], "deriveBits", ¶ms)) goto done; + if (!scr_wc_check_base_key(key, params.name, SCR_WC_USAGE_DERIVE_BITS, "deriveBits")) goto done; + if (!scr_wc_kdf_length(¶ms, null_length, length)) goto done; + if (length == 0) { + ScrBytes *empty = scr_bytes_new(SCR_BYTES_U8, 0); + result = scr_wc_resolved(scr_array_buffer_from_bytes(empty)); + scr_bytes_release(empty); + goto done; + } + ScrBytes *bits = scr_wc_kdf_derive(¶ms, key, length); + if (bits) result = scr_wc_deferred_buffer(bits); +done: + scr_wc_kdf_params_drop(¶ms); + scr_wc_args_drop(&a, n); + return result ? result : scr_wc_rejected(); +} + +/* getKeyLength for the derived key type: the bits to derive, or *null + * for the KDF types (whose derivation then rejects). */ +static bool scr_wc_derived_length(ScrDyn *identifier, const ScrWcAlgorithm *imported, + bool *null_length, double *length) { + ScrStr *name = scr_wc_algorithm_name(identifier, "Algorithm"); + if (!name) return false; + const char *canonical = + scr_wc_lookup(scr_wc_length_names, SCR_WC_COUNT(scr_wc_length_names), name); + scr_str_release(name); + if (!canonical) { + scr_throw_domex("NotSupportedError", "Unrecognized algorithm name"); + return false; + } + *null_length = false; + if (scr_wc_is_aes(canonical)) { + ScrWcAlgorithm aes; + memset(&aes, 0, sizeof aes); + if (!scr_wc_aes_length_params(identifier, "AesDerivedKeyParams", &aes)) return false; + *length = aes.length; + return true; + } + if (strcmp(canonical, "HMAC") == 0 && imported->hash) { + *length = imported->has_length ? imported->length + : strcmp(imported->hash, "SHA-384") == 0 || strcmp(imported->hash, "SHA-512") == 0 + ? 1024 + : 512; + return true; + } + *null_length = true; + return true; +} + +/* deriveKey(algorithm, baseKey, derivedKeyType, extractable, keyUsages): + * the derivation's errors reject at once; the import of the derived bits + * settles, or rejects, on a later loop turn. */ +ScrPromise *scr_webcrypto_derive_key(ScrDyn *args) { + static const char prefix[] = "Failed to execute 'deriveKey' on 'SubtleCrypto'"; + if (!scr_wc_required(prefix, args, 5)) return scr_wc_rejected(); + ScrWcArgs a; + scr_wc_args_take(&a, args, 5); + ScrWcKdfParams params; + memset(¶ms, 0, sizeof params); + ScrPromise *result = NULL; + if (!scr_wc_algorithm_identifier(a.v[0])) goto done; + ScrCryptoKey *key = scr_crypto_key_of(a.v[1]); + if (!key) { + scr_wc_type_error("ERR_INVALID_ARG_TYPE", "%s: 2nd argument is not of type CryptoKey.", prefix); + goto done; + } + if (!scr_wc_algorithm_identifier(a.v[2])) goto done; + bool extractable = scr_dyn_truthy(a.v[3]); + long usages = scr_wc_key_usages(prefix, 4, a.v[4]); + if (usages < 0) goto done; + if (!scr_wc_normalize_kdf(a.v[0], "deriveKey", ¶ms)) goto done; + ScrWcAlgorithm imported; + if (!scr_wc_normalize(a.v[2], scr_wc_import_names, SCR_WC_COUNT(scr_wc_import_names), + SCR_WC_OP_IMPORT, &imported)) + goto done; + bool null_length; + double length; + if (!scr_wc_derived_length(a.v[2], &imported, &null_length, &length)) goto done; + if (strcmp(imported.name, "HMAC") != 0 && !scr_wc_is_aes(imported.name) && + !scr_wc_is_kdf(imported.name)) { + scr_wc_unsupported_algorithm("deriveKey", imported.name); + goto done; + } + if (!scr_wc_check_base_key(key, params.name, SCR_WC_USAGE_DERIVE_KEY, "deriveKey")) goto done; + if (!scr_wc_kdf_length(¶ms, null_length, length)) goto done; + ScrBytes *bits = scr_wc_kdf_derive(¶ms, key, length); + if (!bits) goto done; + ScrDyn *derived = scr_wc_import_key_sync("raw-secret", bits, NULL, &imported, extractable, usages); + scr_bytes_release(bits); + result = derived ? scr_wc_deferred(derived) : scr_wc_deferred_rejection(); +done: + scr_wc_kdf_params_drop(¶ms); + scr_wc_args_drop(&a, 5); + return result ? result : scr_wc_rejected(); +} diff --git a/packages/runtime/src/scr_webcrypto_aes.c b/packages/runtime/src/scr_webcrypto_aes.c new file mode 100644 index 000000000..7cb63f561 --- /dev/null +++ b/packages/runtime/src/scr_webcrypto_aes.c @@ -0,0 +1,137 @@ +/* WebCrypto's AES ciphers: crypto.subtle.encrypt and decrypt with AES-CBC, + * AES-CTR and AES-GCM keys, over the vendored mbedTLS block cipher. + * + * scr_webcrypto.c converts and validates the arguments, normalizes the + * algorithm and checks the key; this unit runs the cipher itself, the way + * Node 24's src/crypto/crypto_aes.cc does: CBC with PKCS#7 padding, CTR + * with a counter that wraps within its low `length` bits (and fails when + * the input needs more blocks than those bits can count), and GCM with a + * 12 to 128 byte IV and a 4 to 16 byte tag appended to the ciphertext. + * The unit links only into programs that call these methods, alongside + * the cipher feature's mbedTLS archive. */ +#include "scr_runtime.h" + +#include +#include + +#include "mbedtls/aes.h" +#include "mbedtls/gcm.h" +#include "mbedtls/platform_util.h" + +static ScrBytes *scr_wc_aes_gcm(bool decrypt, const unsigned char *key, size_t key_len, + const ScrWebCryptoAesParams *p, const unsigned char *in, + size_t len) { + if (p->iv_len < 12 || p->iv_len > 128) return NULL; + if (decrypt && len < p->tag_len) return NULL; + size_t out_len = decrypt ? len - p->tag_len : len + p->tag_len; + ScrBytes *out = scr_bytes_new(SCR_BYTES_U8, (double)out_len); + mbedtls_gcm_context gcm; + mbedtls_gcm_init(&gcm); + int rc = mbedtls_gcm_setkey(&gcm, MBEDTLS_CIPHER_ID_AES, key, (unsigned)(key_len * 8)); + if (rc == 0 && decrypt) { + rc = mbedtls_gcm_auth_decrypt(&gcm, out_len, p->iv, p->iv_len, p->aad, p->aad_len, + in + out_len, p->tag_len, in, out->data); + } else if (rc == 0) { + rc = mbedtls_gcm_crypt_and_tag(&gcm, MBEDTLS_GCM_ENCRYPT, len, p->iv, p->iv_len, p->aad, + p->aad_len, in, out->data, p->tag_len, out->data + len); + } + mbedtls_gcm_free(&gcm); + if (rc != 0) { + mbedtls_platform_zeroize(out->data, out_len); + scr_bytes_release(out); + return NULL; + } + return out; +} + +static ScrBytes *scr_wc_aes_cbc(bool decrypt, const unsigned char *key, size_t key_len, + const ScrWebCryptoAesParams *p, const unsigned char *in, + size_t len) { + if (decrypt && (len == 0 || len % 16 != 0)) return NULL; + size_t padded = decrypt ? len : (len / 16 + 1) * 16; + unsigned char *buf = malloc(padded); + if (!buf) scr_trap("scriptc: out of memory\n"); + memcpy(buf, in, len); + if (!decrypt) memset(buf + len, (int)(padded - len), padded - len); + unsigned char iv[16]; + memcpy(iv, p->iv, 16); + mbedtls_aes_context aes; + mbedtls_aes_init(&aes); + int rc = decrypt ? mbedtls_aes_setkey_dec(&aes, key, (unsigned)(key_len * 8)) + : mbedtls_aes_setkey_enc(&aes, key, (unsigned)(key_len * 8)); + if (rc == 0) + rc = mbedtls_aes_crypt_cbc(&aes, decrypt ? MBEDTLS_AES_DECRYPT : MBEDTLS_AES_ENCRYPT, padded, + iv, buf, buf); + mbedtls_aes_free(&aes); + size_t out_len = padded; + if (rc == 0 && decrypt) { + /* PKCS#7: the final byte names 1 to 16 bytes of padding, each of + * which holds that value. Checked without data-dependent branches. */ + unsigned char pad = buf[padded - 1]; + unsigned char diff = (unsigned char)-(pad == 0 || pad > 16); + for (unsigned i = 1; i <= 16; i++) + diff |= (unsigned char)((buf[padded - i] ^ pad) & (unsigned char)-(i <= pad)); + if (diff) rc = -1; + else out_len = padded - pad; + } + ScrBytes *out = NULL; + if (rc == 0) { + out = scr_bytes_new(SCR_BYTES_U8, (double)out_len); + memcpy(out->data, buf, out_len); + } + mbedtls_platform_zeroize(buf, padded); + free(buf); + return out; +} + +/* Adds one to the low `bits` bits of a big-endian counter block, leaving + * the bits above them unchanged. */ +static void scr_wc_ctr_increment(unsigned char block[16], unsigned bits) { + for (int i = 15; i >= 0 && bits > 0; i--) { + unsigned width = bits >= 8 ? 8 : bits; + unsigned mask = (1u << width) - 1; + unsigned low = ((unsigned)block[i] + 1) & mask; + block[i] = (unsigned char)((block[i] & ~mask) | low); + bits -= width; + if (low != 0) return; + } +} + +static ScrBytes *scr_wc_aes_ctr(const unsigned char *key, size_t key_len, + const ScrWebCryptoAesParams *p, const unsigned char *in, + size_t len) { + size_t blocks = (len + 15) / 16; + if (p->counter_bits < 64 && (double)blocks > (double)(1ull << p->counter_bits)) return NULL; + mbedtls_aes_context aes; + mbedtls_aes_init(&aes); + if (mbedtls_aes_setkey_enc(&aes, key, (unsigned)(key_len * 8)) != 0) { + mbedtls_aes_free(&aes); + return NULL; + } + ScrBytes *out = scr_bytes_new(SCR_BYTES_U8, (double)len); + unsigned char counter[16], stream[16]; + memcpy(counter, p->iv, 16); + for (size_t off = 0; off < len; off += 16) { + mbedtls_aes_crypt_ecb(&aes, MBEDTLS_AES_ENCRYPT, counter, stream); + size_t n = len - off < 16 ? len - off : 16; + for (size_t i = 0; i < n; i++) out->data[off + i] = (unsigned char)(in[off + i] ^ stream[i]); + scr_wc_ctr_increment(counter, p->counter_bits); + } + mbedtls_platform_zeroize(stream, sizeof stream); + mbedtls_aes_free(&aes); + return out; +} + +/* The cipher scr_webcrypto_cipher runs: +1 output bytes, or NULL when the + * operation fails (Node's OperationError). */ +static ScrBytes *scr_wc_aes(const char *name, bool decrypt, const unsigned char *key, + size_t key_len, const ScrWebCryptoAesParams *p, + const unsigned char *in, size_t len) { + if (strcmp(name, "AES-GCM") == 0) return scr_wc_aes_gcm(decrypt, key, key_len, p, in, len); + if (strcmp(name, "AES-CBC") == 0) return scr_wc_aes_cbc(decrypt, key, key_len, p, in, len); + return scr_wc_aes_ctr(key, key_len, p, in, len); +} + +ScrPromise *scr_webcrypto_encrypt(ScrDyn *args) { return scr_webcrypto_cipher(args, false, scr_wc_aes); } + +ScrPromise *scr_webcrypto_decrypt(ScrDyn *args) { return scr_webcrypto_cipher(args, true, scr_wc_aes); } diff --git a/packages/runtime/src/scr_webcrypto_object.c b/packages/runtime/src/scr_webcrypto_object.c new file mode 100644 index 000000000..c20ef13dc --- /dev/null +++ b/packages/runtime/src/scr_webcrypto_object.c @@ -0,0 +1,53 @@ +/* The crypto global as a value: node:crypto's dynamic Crypto object + * (scr_crypto_native in scr_async_dyn.c, which carries subtle.digest) with + * the Crypto object's own randomUUID and getRandomValues methods, for + * untyped reads such as uuid's `crypto.randomUUID && crypto.randomUUID()`. + * Node's receiver check (ERR_INVALID_THIS on a detached call) is not + * modeled. There is one object per thread, so every spelling of the + * global (crypto, globalThis.crypto, node:crypto's webcrypto) is the same + * value; it is released at exit. Linked only into programs that read the + * global as a value. */ +#include "scr_runtime.h" + +static ScrDyn *scr_webcrypto_random_uuid_call(ScrClosure *closure, ScrDyn *const *args, size_t argc) { + (void)closure; + (void)args; + (void)argc; + ScrStr *uuid = scr_crypto_random_uuid(); + ScrDyn *result = scr_dyn_new_str(uuid); + scr_str_release(uuid); + return result; +} + +static ScrDyn *scr_webcrypto_get_random_values_call(ScrClosure *closure, ScrDyn *const *args, + size_t argc) { + (void)closure; + if (argc == 0) { + static const char message[] = + "Failed to execute 'getRandomValues' on 'Crypto': 1 argument required, but only 0 present."; + scr_throw_error_msg_code(SCR_ERR_TYPE, message, sizeof message - 1, "ERR_MISSING_ARGS"); + return NULL; + } + return scr_crypto_get_random_values_dyn(args[0]); +} + +static SCR_TL ScrDyn *scr_webcrypto_object_value; + +static void scr_webcrypto_object_cleanup(void) { + if (scr_webcrypto_object_value) scr_dyn_release(scr_webcrypto_object_value); + scr_webcrypto_object_value = NULL; +} + +ScrDyn *scr_webcrypto_object(void) { + if (scr_webcrypto_object_value) return scr_dyn_retain(scr_webcrypto_object_value); + ScrDyn *result = scr_crypto_native(); + scr_dyn_obj_set(result, "randomUUID", 10, + scr_dyn_new_func(scr_closure_new(NULL, 0), scr_webcrypto_random_uuid_call, 0, + "crypto.randomUUID", "randomUUID")); + scr_dyn_obj_set(result, "getRandomValues", 15, + scr_dyn_new_func(scr_closure_new(NULL, 0), scr_webcrypto_get_random_values_call, 1, + "crypto.getRandomValues", "getRandomValues")); + scr_webcrypto_object_value = result; + scr_atexit(scr_webcrypto_object_cleanup); + return scr_dyn_retain(result); +} diff --git a/tests/corpus/7120-webcrypto-random-uuid.ts b/tests/corpus/7120-webcrypto-random-uuid.ts new file mode 100644 index 000000000..d35df97cc --- /dev/null +++ b/tests/corpus/7120-webcrypto-random-uuid.ts @@ -0,0 +1,22 @@ +// crypto.randomUUID() on the WebCrypto global, directly and through +// globalThis: version-4 UUIDs, distinct on every call, and inside +// closures and default parameters the way request-id middleware uses it. +const shape = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/; + +const direct: string = crypto.randomUUID(); +console.log(direct.length, shape.test(direct)); +const viaGlobalThis = globalThis.crypto.randomUUID(); +console.log(viaGlobalThis.length, shape.test(viaGlobalThis), viaGlobalThis !== direct); + +const seen = new Set(); +for (let i = 0; i < 100; i++) seen.add(crypto.randomUUID()); +console.log("distinct", seen.size); + +function requestId(generator: () => string = () => crypto.randomUUID()): string { + return generator(); +} +console.log(shape.test(requestId()), requestId(() => "fixed")); + +const ids = ["a", "b", "c"].map((name) => ({ name, id: crypto.randomUUID() })); +console.log(ids.every((entry) => shape.test(entry.id)), ids[0]!.id !== ids[1]!.id); +console.log(typeof crypto.randomUUID()); diff --git a/tests/corpus/7121-webcrypto-crypto-object.mjs b/tests/corpus/7121-webcrypto-crypto-object.mjs new file mode 100644 index 000000000..058e72153 --- /dev/null +++ b/tests/corpus/7121-webcrypto-crypto-object.mjs @@ -0,0 +1,35 @@ +// The crypto global from JavaScript: uuid's feature test +// (`crypto.randomUUID && crypto.randomUUID()`), the methods read as values, +// and getRandomValues through the dynamic object, including its +// missing-argument and non-integer-view errors. +const shape = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/; + +function v4(options) { + if (!options && crypto.randomUUID) { + return crypto.randomUUID(); + } + return "fallback"; +} +console.log(shape.test(v4()), v4({})); +console.log(shape.test(globalThis.crypto.randomUUID())); +console.log(typeof crypto.randomUUID, typeof crypto.getRandomValues, typeof crypto.subtle); +console.log(crypto.randomUUID.name, crypto.getRandomValues.name, crypto.getRandomValues.length); + +const native = typeof crypto !== "undefined" && crypto.randomUUID ? { randomUUID: crypto.randomUUID.bind(crypto) } : {}; +console.log(shape.test(native.randomUUID())); + +const rng = (n) => crypto.getRandomValues(new Uint8Array(n)); +console.log(rng(16).length, rng(16) instanceof Uint8Array); +const words = new Uint32Array(4); +console.log(crypto.getRandomValues(words) === words); + +function attempt(label, run) { + try { + console.log(label, run()); + } catch (e) { + console.log(label, e.name, e.code, e.message); + } +} +attempt("no argument", () => crypto.getRandomValues()); +attempt("float view", () => crypto.getRandomValues(new Float64Array(2))); +attempt("too long", () => crypto.getRandomValues(new Uint8Array(65537))); diff --git a/tests/corpus/7122-webcrypto-node-crypto.ts b/tests/corpus/7122-webcrypto-node-crypto.ts new file mode 100644 index 000000000..c0ada7939 --- /dev/null +++ b/tests/corpus/7122-webcrypto-node-crypto.ts @@ -0,0 +1,38 @@ +// WebCrypto reached through node:crypto: the webcrypto export (named and +// through the namespace), the module's own subtle export, and their +// identity with the crypto global. Each form runs the same HMAC and +// digest calls as the global. +import * as nodeCrypto from "node:crypto"; +import { subtle, webcrypto } from "node:crypto"; + +const encoder = new TextEncoder(); +const message = encoder.encode("node:crypto webcrypto"); + +function hex(buffer: ArrayBuffer): string { + return Buffer.from(buffer).toString("hex"); +} + +console.log(webcrypto === crypto, webcrypto === globalThis.crypto, nodeCrypto.webcrypto === crypto); +console.log(hex(await webcrypto.subtle.digest("SHA-256", message))); +console.log(hex(await subtle.digest("SHA-1", message))); +console.log(hex(await nodeCrypto.subtle.digest({ name: "SHA-384" }, message))); +console.log(hex(await nodeCrypto.webcrypto.subtle.digest("SHA-512", message))); + +const secret = encoder.encode("shared secret"); +const params = { name: "HMAC", hash: "SHA-256" }; +const signer = await webcrypto.subtle.importKey("raw", secret, params, false, ["sign"]); +const verifier = await subtle.importKey("raw", secret, params, false, ["verify"]); +const signature = await nodeCrypto.subtle.sign("HMAC", signer, message); +console.log(hex(signature)); +console.log(await nodeCrypto.webcrypto.subtle.verify("HMAC", verifier, signature, message)); +console.log(await subtle.verify("HMAC", verifier, signature, encoder.encode("other"))); +console.log(signer instanceof CryptoKey, signer.algorithm.name, verifier.usages.join(",")); + +const shape = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/; +console.log(shape.test(webcrypto.randomUUID()), shape.test(nodeCrypto.webcrypto.randomUUID())); +console.log(webcrypto.getRandomValues(new Uint32Array(4)).length); +try { + await subtle.digest("MD5", message); +} catch (e) { + console.log((e as Error).name, (e as Error).message); +} diff --git a/tests/corpus/7123-webcrypto-node-crypto.cjs b/tests/corpus/7123-webcrypto-node-crypto.cjs new file mode 100644 index 000000000..b11131d4b --- /dev/null +++ b/tests/corpus/7123-webcrypto-node-crypto.cjs @@ -0,0 +1,31 @@ +// node:crypto's WebCrypto from CommonJS: destructured webcrypto and +// subtle, the module object's members, the +// `globalThis.crypto ?? require("crypto").webcrypto` fallback libraries +// use to find a Crypto object, and crypto destructured from globalThis, +// all the same object. +const nodeCrypto = require("node:crypto"); +const { webcrypto, subtle } = require("crypto"); + +const encoder = new TextEncoder(); +const hex = (buffer) => Buffer.from(new Uint8Array(buffer)).toString("hex"); + +function cryptoObject() { + return globalThis.crypto ?? nodeCrypto.webcrypto; +} + +async function main() { + console.log(webcrypto === globalThis.crypto, cryptoObject() === crypto, typeof subtle); + console.log(hex(await webcrypto.subtle.digest("SHA-256", encoder.encode("abc")))); + console.log(hex(await subtle.digest("SHA-1", encoder.encode("abc")))); + console.log(hex(await nodeCrypto.subtle.digest("SHA-256", encoder.encode("abc")))); + const key = await nodeCrypto.webcrypto.subtle.importKey("raw", encoder.encode("k"), { name: "HMAC", hash: "SHA-1" }, true, ["sign"]); + console.log(hex(await subtle.sign("HMAC", key, encoder.encode("abc")))); + const wc = cryptoObject(); + console.log(wc.randomUUID().length, wc.getRandomValues(new Uint8Array(8)).length); + console.log(typeof webcrypto.randomUUID, typeof nodeCrypto.webcrypto.getRandomValues); + const { crypto: destructured } = globalThis; + console.log(destructured === webcrypto, destructured.randomUUID().length); + console.log(hex(await destructured.subtle.digest("SHA-1", encoder.encode("abc")))); +} + +main(); diff --git a/tests/corpus/7124-webcrypto-secret-keys.ts b/tests/corpus/7124-webcrypto-secret-keys.ts new file mode 100644 index 000000000..8f1f5d601 --- /dev/null +++ b/tests/corpus/7124-webcrypto-secret-keys.ts @@ -0,0 +1,91 @@ +// crypto.crypto.subtle.generateKey, exportKey and importKey for secret keys: +// HMAC and AES keys generated at every length, exported as raw bytes and +// as JSON Web Keys, imported back from both forms, and PBKDF2 and HKDF +// base keys imported from raw bytes. Random key bytes are checked by +// length and round trip, not by value. +const encoder = new TextEncoder(); + +type Key = Awaited>; + +function describe(key: Key): string { + return JSON.stringify({ + type: key.type, + extractable: key.extractable, + algorithm: key.algorithm, + usages: key.usages, + }); +} + +function hex(buffer: ArrayBuffer): string { + return Buffer.from(buffer).toString("hex"); +} + +async function show(label: string, run: () => Promise): Promise { + try { + console.log(label, await run()); + } catch (e) { + const error = e as Error & { code?: string }; + console.log(label, "rejects", error.name, error.code, error.message); + } +} + +for (const hash of ["SHA-1", "SHA-256", "SHA-384", "SHA-512"]) { + await show(`hmac ${hash}`, async () => { + const key = await crypto.subtle.generateKey({ name: "HMAC", hash }, true, ["sign", "verify"]); + const raw = await crypto.subtle.exportKey("raw", key); + return `${describe(key)} ${raw.byteLength}`; + }); +} +await show("hmac length 100", async () => { + const key = await crypto.subtle.generateKey({ name: "HMAC", hash: { name: "SHA-512" }, length: 100 }, true, ["sign"]); + const raw = new Uint8Array(await crypto.subtle.exportKey("raw", key)); + return `${describe(key)} ${raw.length} ${raw[12]! & 0x0f}`; +}); +for (const name of ["AES-GCM", "AES-CBC", "AES-CTR", "AES-KW"]) { + for (const length of [128, 192, 256]) { + await show(`${name} ${length}`, async () => { + const usages: ("wrapKey" | "unwrapKey" | "encrypt" | "decrypt")[] = + name === "AES-KW" ? ["wrapKey", "unwrapKey"] : ["encrypt", "decrypt"]; + const key = await crypto.subtle.generateKey({ name, length }, true, usages); + const jwk = await crypto.subtle.exportKey("jwk", key); + return `${describe(key)} ${jwk.alg} ${jwk.kty} ${jwk.k!.length} ${JSON.stringify(jwk.key_ops)} ${jwk.ext}`; + }); + } +} + +// Fixed key bytes: the exported forms are deterministic. +const bytes = new Uint8Array(32); +for (let i = 0; i < bytes.length; i++) bytes[i] = i * 7 + 1; +const hmac = await crypto.subtle.importKey("raw", bytes, { name: "HMAC", hash: "SHA-384" }, true, ["verify", "sign"]); +const hmacJwk = await crypto.subtle.exportKey("jwk", hmac); +console.log(JSON.stringify(hmacJwk), Object.keys(hmacJwk).join(",")); +console.log(hex(await crypto.subtle.exportKey("raw", hmac)) === Buffer.from(bytes).toString("hex")); +const reimported = await crypto.subtle.importKey("jwk", hmacJwk, { name: "HMAC", hash: "SHA-384" }, true, ["sign"]); +console.log(describe(reimported)); +const signature = await crypto.subtle.sign("HMAC", reimported, encoder.encode("payload")); +console.log(await crypto.subtle.verify("HMAC", hmac, signature, encoder.encode("payload"))); + +const short = await crypto.subtle.importKey("raw", bytes.subarray(0, 20), { name: "HMAC", hash: "SHA-1", length: 156 }, true, ["sign"]); +console.log(describe(short), JSON.stringify(await crypto.subtle.exportKey("jwk", short))); +console.log(hex(await crypto.subtle.exportKey("raw-secret", short))); + +for (const length of [16, 24, 32]) { + const key = await crypto.subtle.importKey("raw", bytes.subarray(0, length), "AES-GCM", true, ["encrypt"]); + const jwk = await crypto.subtle.exportKey("jwk", key); + console.log(describe(key), JSON.stringify(jwk)); + const back = await crypto.subtle.importKey("jwk", jwk, { name: "AES-GCM" }, false, ["encrypt"]); + console.log(describe(back)); +} +const cbc = await crypto.subtle.importKey("raw-secret", bytes.subarray(0, 16), "aes-cbc", true, ["decrypt", "unwrapKey"]); +console.log(describe(cbc), hex(await crypto.subtle.exportKey("raw", cbc))); +const wrap = await crypto.subtle.importKey("raw", bytes.subarray(0, 24), "AES-KW", true, ["unwrapKey", "wrapKey"]); +console.log(describe(wrap), JSON.stringify(await crypto.subtle.exportKey("jwk", wrap))); + +const password = encoder.encode("correct horse battery staple"); +const pbkdf2 = await crypto.subtle.importKey("raw", password, "PBKDF2", false, ["deriveBits", "deriveKey"]); +console.log(describe(pbkdf2)); +const hkdf = await crypto.subtle.importKey("raw-secret", bytes, { name: "hkdf" }, false, ["deriveKey"]); +console.log(describe(hkdf)); +const empty = await crypto.subtle.importKey("raw", new Uint8Array(0), "PBKDF2", false, ["deriveBits"]); +console.log(describe(empty)); +console.log(hmac instanceof CryptoKey, pbkdf2 instanceof CryptoKey); diff --git a/tests/corpus/7125-webcrypto-key-errors.mjs b/tests/corpus/7125-webcrypto-key-errors.mjs new file mode 100644 index 000000000..7f14ae0d7 --- /dev/null +++ b/tests/corpus/7125-webcrypto-key-errors.mjs @@ -0,0 +1,95 @@ +// Rejections of crypto.crypto.subtle.generateKey, exportKey and importKey for +// secret keys, in Node's order: argument conversion, algorithm +// normalization, usages, then the per-algorithm checks, and the JSON Web +// Key validation of oct keys. + +async function attempt(label, run) { + try { + const value = await run(); + const shown = value instanceof ArrayBuffer ? `ArrayBuffer(${value.byteLength})` : value instanceof CryptoKey ? JSON.stringify(value.algorithm) : JSON.stringify(value); + console.log(label, "resolves", shown); + } catch (e) { + console.log(label, e.name, e.code, e.message); + } +} + +await attempt("generate too few", () => crypto.subtle.generateKey({ name: "HMAC", hash: "SHA-1" }, true)); +await attempt("generate unknown", () => crypto.subtle.generateKey({ name: "FOO" }, true, ["sign"])); +await attempt("generate PBKDF2", () => crypto.subtle.generateKey({ name: "PBKDF2" }, false, ["deriveBits"])); +await attempt("generate no name", () => crypto.subtle.generateKey({ hash: "SHA-1" }, true, ["sign"])); +await attempt("generate hmac string", () => crypto.subtle.generateKey("HMAC", true, ["sign"])); +await attempt("generate hmac no hash", () => crypto.subtle.generateKey({ name: "HMAC" }, true, ["sign"])); +await attempt("generate hmac md5", () => crypto.subtle.generateKey({ name: "HMAC", hash: "MD5" }, true, ["sign"])); +await attempt("generate hmac bogus hash", () => crypto.subtle.generateKey({ name: "HMAC", hash: "SHA-999" }, true, ["sign"])); +await attempt("generate hmac length 0", () => crypto.subtle.generateKey({ name: "HMAC", hash: "SHA-1", length: 0 }, true, ["sign"])); +await attempt("generate hmac length NaN", () => crypto.subtle.generateKey({ name: "HMAC", hash: "SHA-1", length: NaN }, true, ["sign"])); +await attempt("generate hmac length -1", () => crypto.subtle.generateKey({ name: "HMAC", hash: "SHA-1", length: -1 }, true, ["sign"])); +await attempt("generate hmac encrypt", () => crypto.subtle.generateKey({ name: "HMAC", hash: "SHA-1" }, true, ["encrypt"])); +await attempt("generate hmac no usages", () => crypto.subtle.generateKey({ name: "HMAC", hash: "SHA-1" }, true, [])); +await attempt("generate bad usage", () => crypto.subtle.generateKey({ name: "HMAC", hash: "SHA-1" }, true, ["fly"])); +await attempt("generate usages string", () => crypto.subtle.generateKey({ name: "HMAC", hash: "SHA-1" }, true, "sign")); +await attempt("generate aes no length", () => crypto.subtle.generateKey({ name: "AES-GCM" }, true, ["encrypt"])); +await attempt("generate aes length 100", () => crypto.subtle.generateKey({ name: "AES-GCM", length: 100 }, true, ["encrypt"])); +await attempt("generate aes length 70000", () => crypto.subtle.generateKey({ name: "AES-CBC", length: 70000 }, true, ["encrypt"])); +await attempt("generate aes sign", () => crypto.subtle.generateKey({ name: "AES-CTR", length: 128 }, true, ["sign"])); +await attempt("generate aes-kw encrypt", () => crypto.subtle.generateKey({ name: "AES-KW", length: 128 }, true, ["encrypt"])); +await attempt("generate aes no usages", () => crypto.subtle.generateKey({ name: "AES-GCM", length: 128 }, true, [])); +await attempt("generate aes string length", async () => (await crypto.subtle.generateKey({ name: "aes-gcm", length: "256" }, true, ["encrypt"])).algorithm); + +const hmac = await crypto.subtle.importKey("raw", new Uint8Array(20), { name: "HMAC", hash: "SHA-256" }, true, ["sign"]); +const locked = await crypto.subtle.importKey("raw", new Uint8Array(16), "AES-GCM", false, ["encrypt"]); +const pbkdf2 = await crypto.subtle.importKey("raw", new Uint8Array(4), "PBKDF2", false, ["deriveBits"]); +await attempt("export too few", () => crypto.subtle.exportKey("raw")); +await attempt("export bad format", () => crypto.subtle.exportKey("pem", hmac)); +await attempt("export not a key", () => crypto.subtle.exportKey("raw", { type: "secret" })); +await attempt("export spki", () => crypto.subtle.exportKey("spki", hmac)); +await attempt("export pkcs8", () => crypto.subtle.exportKey("pkcs8", hmac)); +await attempt("export raw-public", () => crypto.subtle.exportKey("raw-public", hmac)); +await attempt("export non-extractable", () => crypto.subtle.exportKey("raw", locked)); +await attempt("export pbkdf2", () => crypto.subtle.exportKey("raw", pbkdf2)); +await attempt("export pbkdf2 jwk", () => crypto.subtle.exportKey("jwk", pbkdf2)); + +const sixteen = new Uint8Array(16); +await attempt("import aes 15 bytes", () => crypto.subtle.importKey("raw", new Uint8Array(15), "AES-GCM", true, ["encrypt"])); +await attempt("import aes sign", () => crypto.subtle.importKey("raw", sixteen, "AES-GCM", true, ["sign"])); +await attempt("import aes-kw encrypt", () => crypto.subtle.importKey("raw", sixteen, "AES-KW", true, ["encrypt"])); +await attempt("import aes no usages", () => crypto.subtle.importKey("raw", sixteen, "AES-CBC", true, [])); +await attempt("import aes spki", () => crypto.subtle.importKey("spki", sixteen, "AES-CBC", true, ["encrypt"])); +await attempt("import aes length ignored", () => crypto.subtle.importKey("raw", sixteen, { name: "AES-CTR", length: 256 }, true, ["encrypt"])); +await attempt("import pbkdf2 extractable", () => crypto.subtle.importKey("raw", sixteen, "PBKDF2", true, ["deriveBits"])); +await attempt("import pbkdf2 sign", () => crypto.subtle.importKey("raw", sixteen, "PBKDF2", false, ["sign"])); +await attempt("import pbkdf2 no usages", () => crypto.subtle.importKey("raw", sixteen, "PBKDF2", false, [])); +await attempt("import hkdf jwk", () => crypto.subtle.importKey("jwk", { kty: "oct", k: "AAAA" }, "HKDF", false, ["deriveKey"])); +await attempt("import hkdf pkcs8", () => crypto.subtle.importKey("pkcs8", sixteen, "HKDF", false, ["deriveKey"])); +await attempt("sign with aes key", () => crypto.subtle.sign("HMAC", locked, sixteen)); + +const hs256 = { name: "HMAC", hash: "SHA-256" }; +const jwk = (data, alg = hs256, extractable = true, usages = ["sign"]) => crypto.subtle.importKey("jwk", data, alg, extractable, usages); +await attempt("jwk ok", () => jwk({ kty: "oct", k: "AAECAwQFBgc" })); +await attempt("jwk alg match", () => jwk({ kty: "oct", k: "AAECAwQFBgc", alg: "HS256" })); +await attempt("jwk alg mismatch", () => jwk({ kty: "oct", k: "AAECAwQFBgc", alg: "HS512" })); +await attempt("jwk no kty", () => jwk({ k: "AAECAwQFBgc" })); +await attempt("jwk kty RSA", () => jwk({ kty: "RSA", k: "AAECAwQFBgc" })); +await attempt("jwk no k", () => jwk({ kty: "oct" })); +await attempt("jwk k number", () => jwk({ kty: "oct", k: 5 })); +await attempt("jwk k empty", () => jwk({ kty: "oct", k: "" })); +await attempt("jwk k standard alphabet", () => jwk({ kty: "oct", k: "AA+/AA==" })); +await attempt("jwk k junk", () => jwk({ kty: "oct", k: "!!!!" })); +await attempt("jwk use enc", () => jwk({ kty: "oct", k: "AAECAwQFBgc", use: "enc" })); +await attempt("jwk use sig", () => jwk({ kty: "oct", k: "AAECAwQFBgc", use: "sig" })); +await attempt("jwk key_ops superset", () => jwk({ kty: "oct", k: "AAECAwQFBgc", key_ops: ["sign", "verify", "fly"] })); +await attempt("jwk key_ops missing", () => jwk({ kty: "oct", k: "AAECAwQFBgc", key_ops: ["verify"] })); +await attempt("jwk key_ops duplicate", () => jwk({ kty: "oct", k: "AAECAwQFBgc", key_ops: ["sign", "sign"] })); +await attempt("jwk key_ops string", () => jwk({ kty: "oct", k: "AAECAwQFBgc", key_ops: "sign" })); +await attempt("jwk ext false", () => jwk({ kty: "oct", k: "AAECAwQFBgc", ext: false })); +await attempt("jwk ext false locked", () => jwk({ kty: "oct", k: "AAECAwQFBgc", ext: false }, hs256, false)); +await attempt("jwk not an object", () => jwk("key")); +await attempt("jwk null", () => jwk(null)); +await attempt("jwk kty symbol", () => jwk({ kty: Symbol("oct"), k: "AA" })); +await attempt("jwk hmac length", () => jwk({ kty: "oct", k: "AAECAwQFBgc" }, { name: "HMAC", hash: "SHA-1", length: 60 })); +await attempt("jwk hmac length mismatch", () => jwk({ kty: "oct", k: "AAECAwQFBgc" }, { name: "HMAC", hash: "SHA-1", length: 128 })); +await attempt("jwk no usages", () => jwk({ kty: "oct", k: "AAECAwQFBgc" }, hs256, true, [])); +await attempt("jwk aes", () => jwk({ kty: "oct", k: "AAECAwQFBgcICQoLDA0ODw", alg: "A128GCM" }, "AES-GCM", true, ["encrypt"])); +await attempt("jwk aes alg mismatch", () => jwk({ kty: "oct", k: "AAECAwQFBgcICQoLDA0ODw", alg: "A256GCM" }, "AES-GCM", true, ["encrypt"])); +await attempt("jwk aes use sig", () => jwk({ kty: "oct", k: "AAECAwQFBgcICQoLDA0ODw", use: "sig" }, "AES-GCM", true, ["encrypt"])); +await attempt("jwk aes length", () => jwk({ kty: "oct", k: "AAECAwQFBgc" }, "AES-CBC", true, ["encrypt"])); diff --git a/tests/corpus/7126-webcrypto-aes.ts b/tests/corpus/7126-webcrypto-aes.ts new file mode 100644 index 000000000..0e7be7548 --- /dev/null +++ b/tests/corpus/7126-webcrypto-aes.ts @@ -0,0 +1,77 @@ +// crypto.crypto.subtle.encrypt and decrypt with AES-GCM, AES-CBC and AES-CTR: +// fixed keys, IVs and inputs give Node's exact ciphertexts, every key +// length and GCM tag length round-trips, and CTR counters wrap within +// their low `length` bits. +const encoder = new TextEncoder(); +const decoder = new TextDecoder(); + +function hex(buffer: ArrayBuffer): string { + return Buffer.from(buffer).toString("hex"); +} + +function bytes(length: number, seed: number): Uint8Array { + const out = new Uint8Array(length); + for (let i = 0; i < length; i++) out[i] = (i * 31 + seed) & 0xff; + return out; +} + +const plaintext = encoder.encode("The quick brown fox jumps over the lazy dog"); +for (const length of [16, 24, 32]) { + const raw = bytes(length, length); + const gcm = await crypto.subtle.importKey("raw", raw, "AES-GCM", false, ["encrypt", "decrypt"]); + const cbc = await crypto.subtle.importKey("raw", raw, "AES-CBC", false, ["encrypt", "decrypt"]); + const ctr = await crypto.subtle.importKey("raw", raw, "AES-CTR", false, ["encrypt", "decrypt"]); + const iv = bytes(12, 7); + const sealed = await crypto.subtle.encrypt({ name: "AES-GCM", iv }, gcm, plaintext); + console.log("gcm", length, sealed.byteLength, hex(sealed)); + console.log(decoder.decode(await crypto.subtle.decrypt({ name: "AES-GCM", iv }, gcm, sealed))); + const aad = encoder.encode("header"); + const tagged = await crypto.subtle.encrypt({ name: "AES-GCM", iv, additionalData: aad, tagLength: 96 }, gcm, plaintext); + console.log("gcm aad", length, hex(tagged)); + console.log(decoder.decode(await crypto.subtle.decrypt({ name: "AES-GCM", iv, additionalData: aad, tagLength: 96 }, gcm, tagged))); + const cbcIv = bytes(16, 3); + const padded = await crypto.subtle.encrypt({ name: "AES-CBC", iv: cbcIv }, cbc, plaintext); + console.log("cbc", length, padded.byteLength, hex(padded)); + console.log(decoder.decode(await crypto.subtle.decrypt({ name: "AES-CBC", iv: cbcIv }, cbc, padded))); + const counter = bytes(16, 9); + const streamed = await crypto.subtle.encrypt({ name: "AES-CTR", counter, length: 64 }, ctr, plaintext); + console.log("ctr", length, hex(streamed)); + console.log(decoder.decode(await crypto.subtle.decrypt({ name: "AES-CTR", counter, length: 64 }, ctr, streamed))); +} + +const key = await crypto.subtle.importKey("raw", bytes(16, 1), "AES-GCM", true, ["encrypt", "decrypt"]); +for (const tagLength of [32, 64, 96, 104, 112, 120, 128]) { + const iv = bytes(16, tagLength); + const sealed = await crypto.subtle.encrypt({ name: "AES-GCM", iv, tagLength }, key, plaintext.subarray(0, 5)); + const opened = await crypto.subtle.decrypt({ name: "AES-GCM", iv, tagLength }, key, sealed); + console.log("tag", tagLength, sealed.byteLength, hex(sealed), decoder.decode(opened)); +} +console.log("gcm empty", hex(await crypto.subtle.encrypt({ name: "AES-GCM", iv: new Uint8Array(12) }, key, new Uint8Array(0)))); +console.log("gcm long iv", hex(await crypto.subtle.encrypt({ name: "AES-GCM", iv: bytes(128, 5) }, key, plaintext.subarray(0, 3)))); + +const cbcKey = await crypto.subtle.importKey("raw", bytes(16, 2), "AES-CBC", false, ["encrypt", "decrypt"]); +for (const length of [0, 1, 15, 16, 17, 32]) { + const sealed = await crypto.subtle.encrypt({ name: "AES-CBC", iv: new Uint8Array(16) }, cbcKey, bytes(length, 4)); + const opened = await crypto.subtle.decrypt({ name: "AES-CBC", iv: new Uint8Array(16) }, cbcKey, sealed); + console.log("cbc length", length, sealed.byteLength, opened.byteLength, hex(opened) === hex(bytes(length, 4).buffer as ArrayBuffer)); +} + +const ctrKey = await crypto.subtle.importKey("raw", new Uint8Array(16), "AES-CTR", false, ["encrypt"]); +const allOnes = new Uint8Array(16).fill(0xff); +const zeros = new Uint8Array(64); +console.log("ctr wrap 4", hex(await crypto.subtle.encrypt({ name: "AES-CTR", counter: allOnes, length: 4 }, ctrKey, zeros))); +console.log("ctr wrap 128", hex(await crypto.subtle.encrypt({ name: "AES-CTR", counter: allOnes, length: 128 }, ctrKey, zeros))); +console.log("ctr wrap 2", hex(await crypto.subtle.encrypt({ name: "AES-CTR", counter: allOnes, length: 2 }, ctrKey, zeros))); +console.log("ctr 1 bit, 2 blocks", hex(await crypto.subtle.encrypt({ name: "AES-CTR", counter: new Uint8Array(16), length: 1 }, ctrKey, zeros.subarray(0, 32)))); +console.log("ctr partial", hex(await crypto.subtle.encrypt({ name: "AES-CTR", counter: bytes(16, 6), length: 128 }, ctrKey, zeros.subarray(0, 21)))); + +const generated = await crypto.subtle.generateKey({ name: "AES-GCM", length: 256 }, true, ["encrypt", "decrypt"]); +const iv = crypto.getRandomValues(new Uint8Array(12)); +const message = encoder.encode("generated key round trip"); +const sealed = await crypto.subtle.encrypt({ name: "AES-GCM", iv }, generated, message); +console.log(sealed.byteLength, decoder.decode(await crypto.subtle.decrypt({ name: "AES-GCM", iv }, generated, sealed))); +const exported = await crypto.subtle.exportKey("jwk", generated); +const reimported = await crypto.subtle.importKey("jwk", exported, "AES-GCM", false, ["decrypt"]); +console.log(decoder.decode(await crypto.subtle.decrypt({ name: "AES-GCM", iv }, reimported, sealed))); +console.log(decoder.decode(await crypto.subtle.decrypt({ name: "AES-GCM", iv }, generated, new DataView(sealed)))); +console.log(decoder.decode(await crypto.subtle.decrypt({ name: "AES-GCM", iv: iv.buffer as ArrayBuffer }, generated, Buffer.from(sealed)))); diff --git a/tests/corpus/7127-webcrypto-aes-errors.mjs b/tests/corpus/7127-webcrypto-aes-errors.mjs new file mode 100644 index 000000000..7ce51230a --- /dev/null +++ b/tests/corpus/7127-webcrypto-aes-errors.mjs @@ -0,0 +1,71 @@ +// Rejections of crypto.crypto.subtle.encrypt and decrypt in Node's order: +// argument conversion, the AesCbcParams, AesCtrParams and AeadParams +// dictionaries, the key checks, then the cipher's own OperationErrors +// (bad tags, bad padding, IV and counter limits). + +async function attempt(label, run) { + try { + const value = await run(); + console.log(label, "resolves", value instanceof ArrayBuffer ? `ArrayBuffer(${value.byteLength})` : value); + } catch (e) { + console.log(label, e.name, e.code, e.message); + } +} + +const raw = new Uint8Array(16).map((_, i) => i); +const gcm = await crypto.subtle.importKey("raw", raw, "AES-GCM", true, ["encrypt", "decrypt"]); +const cbc = await crypto.subtle.importKey("raw", raw, "AES-CBC", true, ["encrypt", "decrypt"]); +const ctr = await crypto.subtle.importKey("raw", raw, "AES-CTR", true, ["encrypt", "decrypt"]); +const encryptOnly = await crypto.subtle.importKey("raw", raw, "AES-GCM", true, ["encrypt"]); +const hmac = await crypto.subtle.importKey("raw", raw, { name: "HMAC", hash: "SHA-1" }, true, ["sign"]); +const iv12 = new Uint8Array(12); +const iv16 = new Uint8Array(16); +const data = new TextEncoder().encode("hello world"); + +await attempt("too few", () => crypto.subtle.encrypt({ name: "AES-GCM", iv: iv12 }, gcm)); +await attempt("decrypt too few", () => crypto.subtle.decrypt({ name: "AES-GCM", iv: iv12 })); +await attempt("not a key", () => crypto.subtle.encrypt({ name: "AES-GCM", iv: iv12 }, JSON.parse("{}"), data)); +await attempt("data string", () => crypto.subtle.encrypt({ name: "AES-GCM", iv: iv12 }, gcm, "hello")); +await attempt("unknown algorithm", () => crypto.subtle.encrypt({ name: "AES-XTS" }, gcm, data)); +await attempt("AES-KW", () => crypto.subtle.encrypt({ name: "AES-KW" }, gcm, data)); +await attempt("no name", () => crypto.subtle.encrypt({ iv: iv12 }, gcm, data)); +await attempt("string algorithm", () => crypto.subtle.encrypt("AES-GCM", gcm, data)); +await attempt("gcm no iv", () => crypto.subtle.encrypt({ name: "AES-GCM" }, gcm, data)); +await attempt("gcm iv string", () => crypto.subtle.encrypt({ name: "AES-GCM", iv: "abc" }, gcm, data)); +await attempt("gcm aad string", () => crypto.subtle.encrypt({ name: "AES-GCM", iv: iv12, additionalData: "x" }, gcm, data)); +await attempt("gcm aad null", () => crypto.subtle.encrypt({ name: "AES-GCM", iv: iv12, additionalData: null }, gcm, data)); +await attempt("gcm tag 100", () => crypto.subtle.encrypt({ name: "AES-GCM", iv: iv12, tagLength: 100 }, gcm, data)); +await attempt("gcm tag 300", () => crypto.subtle.encrypt({ name: "AES-GCM", iv: iv12, tagLength: 300 }, gcm, data)); +await attempt("gcm tag NaN", () => crypto.subtle.encrypt({ name: "AES-GCM", iv: iv12, tagLength: NaN }, gcm, data)); +await attempt("gcm tag string", () => crypto.subtle.encrypt({ name: "aes-gcm", iv: iv12, tagLength: "96" }, gcm, data)); +await attempt("gcm iv 11 bytes", () => crypto.subtle.encrypt({ name: "AES-GCM", iv: new Uint8Array(11) }, gcm, data)); +await attempt("gcm iv 129 bytes", () => crypto.subtle.encrypt({ name: "AES-GCM", iv: new Uint8Array(129) }, gcm, data)); +await attempt("gcm iv empty", () => crypto.subtle.encrypt({ name: "AES-GCM", iv: new Uint8Array(0) }, gcm, data)); +const sealed = new Uint8Array(await crypto.subtle.encrypt({ name: "AES-GCM", iv: iv12 }, gcm, data)); +const tampered = sealed.slice(); +tampered[0] ^= 1; +await attempt("gcm tampered", () => crypto.subtle.decrypt({ name: "AES-GCM", iv: iv12 }, gcm, tampered)); +await attempt("gcm wrong aad", () => crypto.subtle.decrypt({ name: "AES-GCM", iv: iv12, additionalData: data }, gcm, sealed)); +await attempt("gcm wrong tag length", () => crypto.subtle.decrypt({ name: "AES-GCM", iv: iv12, tagLength: 96 }, gcm, sealed)); +await attempt("gcm shorter than tag", () => crypto.subtle.decrypt({ name: "AES-GCM", iv: iv12 }, gcm, new Uint8Array(15))); +await attempt("gcm tag only", () => crypto.subtle.decrypt({ name: "AES-GCM", iv: iv12 }, gcm, new Uint8Array(16))); +await attempt("cbc no iv", () => crypto.subtle.encrypt({ name: "AES-CBC" }, cbc, data)); +await attempt("cbc iv 12 bytes", () => crypto.subtle.encrypt({ name: "AES-CBC", iv: iv12 }, cbc, data)); +await attempt("cbc decrypt 15 bytes", () => crypto.subtle.decrypt({ name: "AES-CBC", iv: iv16 }, cbc, new Uint8Array(15))); +await attempt("cbc decrypt empty", () => crypto.subtle.decrypt({ name: "AES-CBC", iv: iv16 }, cbc, new Uint8Array(0))); +const block = new Uint8Array(await crypto.subtle.encrypt({ name: "AES-CBC", iv: iv16 }, cbc, data)); +const badPad = block.slice(); +badPad[15] ^= 0x55; +await attempt("cbc bad padding", () => crypto.subtle.decrypt({ name: "AES-CBC", iv: iv16 }, cbc, badPad)); +await attempt("cbc other iv", () => crypto.subtle.decrypt({ name: "AES-CBC", iv: new Uint8Array(16).fill(1) }, cbc, block)); +await attempt("ctr no counter", () => crypto.subtle.encrypt({ name: "AES-CTR", length: 64 }, ctr, data)); +await attempt("ctr no length", () => crypto.subtle.encrypt({ name: "AES-CTR", counter: iv16 }, ctr, data)); +await attempt("ctr length 0", () => crypto.subtle.encrypt({ name: "AES-CTR", counter: iv16, length: 0 }, ctr, data)); +await attempt("ctr length 129", () => crypto.subtle.encrypt({ name: "AES-CTR", counter: iv16, length: 129 }, ctr, data)); +await attempt("ctr length 300", () => crypto.subtle.encrypt({ name: "AES-CTR", counter: iv16, length: 300 }, ctr, data)); +await attempt("ctr counter 8 bytes", () => crypto.subtle.encrypt({ name: "AES-CTR", counter: new Uint8Array(8), length: 64 }, ctr, data)); +await attempt("ctr 1 bit, 3 blocks", () => crypto.subtle.encrypt({ name: "AES-CTR", counter: iv16, length: 1 }, ctr, new Uint8Array(48))); +await attempt("ctr empty", () => crypto.subtle.encrypt({ name: "AES-CTR", counter: iv16, length: 1 }, ctr, new Uint8Array(0))); +await attempt("algorithm mismatch", () => crypto.subtle.encrypt({ name: "AES-CBC", iv: iv16 }, gcm, data)); +await attempt("hmac key", () => crypto.subtle.encrypt({ name: "AES-GCM", iv: iv12 }, hmac, data)); +await attempt("missing usage", () => crypto.subtle.decrypt({ name: "AES-GCM", iv: iv12 }, encryptOnly, sealed)); diff --git a/tests/corpus/7128-webcrypto-derive.ts b/tests/corpus/7128-webcrypto-derive.ts new file mode 100644 index 000000000..4badedb66 --- /dev/null +++ b/tests/corpus/7128-webcrypto-derive.ts @@ -0,0 +1,45 @@ +// crypto.crypto.subtle.deriveBits and deriveKey with PBKDF2 and HKDF: Node's +// exact derived bytes for every SHA digest, zero-length derivations, the +// SCRAM-style PBKDF2-then-HMAC chain, and derived AES and HMAC keys that +// encrypt and sign. +const encoder = new TextEncoder(); + +function hex(buffer: ArrayBuffer): string { + return Buffer.from(buffer).toString("hex"); +} + +const password = await crypto.subtle.importKey("raw", encoder.encode("pencil"), "PBKDF2", false, ["deriveBits", "deriveKey"]); +const ikm = await crypto.subtle.importKey("raw", encoder.encode("input keying material"), { name: "HKDF" }, false, ["deriveBits", "deriveKey"]); +const salt = encoder.encode("QSXCR+Q6sek8bf92"); +const info = encoder.encode("context"); + +for (const hash of ["SHA-1", "SHA-256", "SHA-384", "SHA-512"]) { + console.log("pbkdf2", hash, hex(await crypto.subtle.deriveBits({ name: "PBKDF2", hash, salt, iterations: 4096 }, password, 256))); + console.log("hkdf", hash, hex(await crypto.subtle.deriveBits({ name: "HKDF", hash: { name: hash }, salt, info }, ikm, 256))); +} +console.log("pbkdf2 0", (await crypto.subtle.deriveBits({ name: "PBKDF2", hash: "SHA-256", salt, iterations: 1 }, password, 0)).byteLength); +console.log("hkdf 0", (await crypto.subtle.deriveBits({ name: "HKDF", hash: "SHA-256", salt, info }, ikm, 0)).byteLength); +console.log("hkdf empty salt and info", hex(await crypto.subtle.deriveBits({ name: "hkdf", hash: "SHA-256", salt: new Uint8Array(0), info: new Uint8Array(0) }, ikm, 128))); +console.log("hkdf max", (await crypto.subtle.deriveBits({ name: "HKDF", hash: "SHA-1", salt, info }, ikm, 255 * 20 * 8)).byteLength); + +// SCRAM-SHA-256's client proof inputs, the way database drivers compute them. +const saltedPassword = await crypto.subtle.deriveBits({ name: "PBKDF2", hash: "SHA-256", salt, iterations: 4096 }, password, 256); +const salted = await crypto.subtle.importKey("raw", saltedPassword, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]); +const clientKey = await crypto.subtle.sign("HMAC", salted, encoder.encode("Client Key")); +console.log("client key", hex(clientKey)); +console.log("stored key", hex(await crypto.subtle.digest("SHA-256", clientKey))); + +const aes = await crypto.subtle.deriveKey({ name: "PBKDF2", hash: "SHA-256", salt, iterations: 1000 }, password, { name: "AES-GCM", length: 256 }, true, ["encrypt", "decrypt"]); +console.log(JSON.stringify(aes.algorithm), aes.usages.join(","), aes.extractable); +console.log("aes key", hex(await crypto.subtle.exportKey("raw", aes))); +const iv = new Uint8Array(12); +const sealed = await crypto.subtle.encrypt({ name: "AES-GCM", iv }, aes, encoder.encode("derived")); +console.log(hex(sealed), new TextDecoder().decode(await crypto.subtle.decrypt({ name: "AES-GCM", iv }, aes, sealed))); + +const mac = await crypto.subtle.deriveKey({ name: "HKDF", hash: "SHA-256", salt, info }, ikm, { name: "HMAC", hash: "SHA-384" }, false, ["sign", "verify"]); +console.log(JSON.stringify(mac.algorithm), mac.extractable); +console.log("mac", hex(await crypto.subtle.sign("HMAC", mac, encoder.encode("message")))); +const shortMac = await crypto.subtle.deriveKey({ name: "HKDF", hash: "SHA-1", salt, info }, ikm, { name: "HMAC", hash: "SHA-1", length: 128 }, true, ["sign"]); +console.log(JSON.stringify(shortMac.algorithm), hex(await crypto.subtle.exportKey("raw", shortMac))); +const wrap = await crypto.subtle.deriveKey({ name: "HKDF", hash: "SHA-512", salt, info }, ikm, { name: "AES-KW", length: 128 }, true, ["wrapKey"]); +console.log(JSON.stringify(wrap.algorithm), JSON.stringify(await crypto.subtle.exportKey("jwk", wrap))); diff --git a/tests/corpus/7129-webcrypto-derive-errors.mjs b/tests/corpus/7129-webcrypto-derive-errors.mjs new file mode 100644 index 000000000..83149b61b --- /dev/null +++ b/tests/corpus/7129-webcrypto-derive-errors.mjs @@ -0,0 +1,72 @@ +// Rejections of crypto.crypto.subtle.deriveBits and deriveKey in Node's order: +// argument conversion, the Pbkdf2Params and HkdfParams dictionaries, the +// base key's usages and algorithm, the length rules, and for deriveKey +// the derived key type's normalization and import. +const encoder = new TextEncoder(); + +async function attempt(label, run) { + try { + const value = await run(); + const shown = value instanceof ArrayBuffer ? `ArrayBuffer(${value.byteLength})` : value instanceof CryptoKey ? JSON.stringify(value.algorithm) : value; + console.log(label, "resolves", shown); + } catch (e) { + console.log(label, e.name, e.code, e.message); + } +} + +const password = await crypto.subtle.importKey("raw", encoder.encode("password"), "PBKDF2", false, ["deriveBits", "deriveKey"]); +const ikm = await crypto.subtle.importKey("raw", encoder.encode("input key"), "HKDF", false, ["deriveBits", "deriveKey"]); +const bitsOnly = await crypto.subtle.importKey("raw", encoder.encode("x"), "PBKDF2", false, ["deriveBits"]); +const keyOnly = await crypto.subtle.importKey("raw", encoder.encode("x"), "PBKDF2", false, ["deriveKey"]); +const hmac = await crypto.subtle.importKey("raw", encoder.encode("x"), { name: "HMAC", hash: "SHA-1" }, false, ["sign"]); +const salt = encoder.encode("salt"); +const pbkdf2 = (extra = {}) => ({ name: "PBKDF2", hash: "SHA-256", salt, iterations: 1000, ...extra }); +const hkdf = (extra = {}) => ({ name: "HKDF", hash: "SHA-256", salt, info: encoder.encode("info"), ...extra }); + +await attempt("bits too few", () => crypto.subtle.deriveBits(pbkdf2())); +await attempt("bits not a key", () => crypto.subtle.deriveBits(pbkdf2(), JSON.parse("{}"), 64)); +await attempt("bits length null", () => crypto.subtle.deriveBits(pbkdf2(), password, null)); +await attempt("bits length undefined", () => crypto.subtle.deriveBits(pbkdf2(), password, undefined)); +await attempt("bits length absent", () => crypto.subtle.deriveBits(pbkdf2(), password)); +await attempt("bits length 12", () => crypto.subtle.deriveBits(pbkdf2(), password, 12)); +await attempt("bits length -1", () => crypto.subtle.deriveBits(pbkdf2(), password, -1)); +await attempt("bits length NaN", () => crypto.subtle.deriveBits(pbkdf2(), password, NaN)); +await attempt("bits length string", () => crypto.subtle.deriveBits(pbkdf2(), password, "64")); +await attempt("bits unknown", () => crypto.subtle.deriveBits({ name: "SCRYPT" }, password, 64)); +await attempt("bits no name", () => crypto.subtle.deriveBits({ hash: "SHA-1" }, password, 64)); +await attempt("pbkdf2 iterations 0", () => crypto.subtle.deriveBits(pbkdf2({ iterations: 0 }), password, 64)); +await attempt("pbkdf2 iterations 2^31", () => crypto.subtle.deriveBits(pbkdf2({ iterations: 2 ** 31 }), password, 64)); +await attempt("pbkdf2 iterations -1", () => crypto.subtle.deriveBits(pbkdf2({ iterations: -1 }), password, 64)); +await attempt("pbkdf2 no iterations", () => crypto.subtle.deriveBits({ name: "PBKDF2", hash: "SHA-256", salt }, password, 64)); +await attempt("pbkdf2 no salt", () => crypto.subtle.deriveBits({ name: "PBKDF2", hash: "SHA-256", iterations: 1 }, password, 64)); +await attempt("pbkdf2 no hash", () => crypto.subtle.deriveBits({ name: "PBKDF2", salt, iterations: 1 }, password, 64)); +await attempt("pbkdf2 string", () => crypto.subtle.deriveBits("PBKDF2", password, 64)); +await attempt("pbkdf2 md5", () => crypto.subtle.deriveBits(pbkdf2({ hash: "MD5" }), password, 64)); +await attempt("pbkdf2 bogus sha", () => crypto.subtle.deriveBits(pbkdf2({ hash: "SHA-999" }), password, 64)); +await attempt("pbkdf2 salt string", () => crypto.subtle.deriveBits(pbkdf2({ salt: "salt" }), password, 64)); +await attempt("pbkdf2 hkdf key", () => crypto.subtle.deriveBits(pbkdf2(), ikm, 64)); +await attempt("pbkdf2 hmac key", () => crypto.subtle.deriveBits(pbkdf2(), hmac, 64)); +await attempt("pbkdf2 no deriveBits usage", () => crypto.subtle.deriveBits(pbkdf2(), keyOnly, 64)); +await attempt("hkdf no info", () => crypto.subtle.deriveBits({ name: "HKDF", hash: "SHA-256", salt }, ikm, 64)); +await attempt("hkdf no salt", () => crypto.subtle.deriveBits({ name: "HKDF", hash: "SHA-256", info: salt }, ikm, 64)); +await attempt("hkdf info 1025 bytes", () => crypto.subtle.deriveBits(hkdf({ info: new Uint8Array(1025) }), ikm, 64)); +await attempt("hkdf over maximum", () => crypto.subtle.deriveBits(hkdf({ hash: "SHA-1" }), ikm, 255 * 20 * 8 + 8)); +await attempt("hkdf length 4", () => crypto.subtle.deriveBits(hkdf(), ikm, 4)); +await attempt("hkdf null", () => crypto.subtle.deriveBits(hkdf(), ikm, null)); + +const aes = { name: "AES-GCM", length: 128 }; +await attempt("key too few", () => crypto.subtle.deriveKey(pbkdf2(), password, aes, true)); +await attempt("key not a key", () => crypto.subtle.deriveKey(pbkdf2(), "key", aes, true, ["encrypt"])); +await attempt("key no deriveKey usage", () => crypto.subtle.deriveKey(pbkdf2(), bitsOnly, aes, true, ["encrypt"])); +await attempt("key mismatch", () => crypto.subtle.deriveKey(hkdf(), password, aes, true, ["encrypt"])); +await attempt("key aes no length", () => crypto.subtle.deriveKey(pbkdf2(), password, { name: "AES-GCM" }, true, ["encrypt"])); +await attempt("key aes length 100", () => crypto.subtle.deriveKey(pbkdf2(), password, { name: "AES-CBC", length: 100 }, true, ["encrypt"])); +await attempt("key aes sign usage", () => crypto.subtle.deriveKey(pbkdf2(), password, aes, true, ["sign"])); +await attempt("key aes no usages", () => crypto.subtle.deriveKey(pbkdf2(), password, aes, true, [])); +await attempt("key hmac no hash", () => crypto.subtle.deriveKey(pbkdf2(), password, { name: "HMAC" }, true, ["sign"])); +await attempt("key hmac length 0", () => crypto.subtle.deriveKey(pbkdf2(), password, { name: "HMAC", hash: "SHA-1", length: 0 }, true, ["sign"])); +await attempt("key hmac length 100", () => crypto.subtle.deriveKey(pbkdf2(), password, { name: "HMAC", hash: "SHA-1", length: 100 }, true, ["sign"])); +await attempt("key hkdf type", () => crypto.subtle.deriveKey(pbkdf2(), password, "HKDF", false, ["deriveBits"])); +await attempt("key unknown type", () => crypto.subtle.deriveKey(pbkdf2(), password, { name: "TWOFISH" }, true, ["encrypt"])); +await attempt("key pbkdf2 type", () => crypto.subtle.deriveKey(hkdf(), ikm, { name: "PBKDF2" }, false, ["deriveKey"])); +await attempt("key ok", () => crypto.subtle.deriveKey(pbkdf2(), password, aes, false, ["encrypt"])); diff --git a/tests/diagnostics/webcrypto-refusals.ts b/tests/diagnostics/webcrypto-refusals.ts index d162872fb..309e70c4e 100644 --- a/tests/diagnostics/webcrypto-refusals.ts +++ b/tests/diagnostics/webcrypto-refusals.ts @@ -1,17 +1,8 @@ -// The native WebCrypto surface is HMAC importKey('raw'), sign and verify, -// and the SHA-1/SHA-2 digests, called directly on crypto.subtle. The 'jwk' -// key format and crypto.subtle or its methods taken as values are refused -// by name; the bundled declarations omit the other SubtleCrypto methods -// (node-types/fenced.ts pins their fence under @types/node). -const fromJwk = await crypto.subtle.importKey( - "jwk", - { kty: "oct", k: "c2VjcmV0" }, - { name: "HMAC", hash: "SHA-256" }, - false, - ["sign"], -); -console.log(fromJwk.type); - +// The native WebCrypto surface is crypto.subtle's secret-key slice, called +// directly on crypto.subtle. crypto.subtle or its methods taken as values +// are refused by name; the bundled declarations omit the other +// SubtleCrypto methods (node-types/fenced.ts pins their fence under +// @types/node). const subtle = crypto.subtle; console.log(typeof subtle); diff --git a/tests/fixtures/node-types/fenced.ts b/tests/fixtures/node-types/fenced.ts index 16a74081f..dfd07d446 100644 --- a/tests/fixtures/node-types/fenced.ts +++ b/tests/fixtures/node-types/fenced.ts @@ -103,13 +103,13 @@ cipherStream.on("data", () => {}); import { createECDH } from "node:crypto"; createECDH("sect163k1"); createECDH("prime256v1").computeSecret(Buffer.alloc(65), "hex"); -/* WebCrypto beyond the HMAC slice: @types/node declares the whole - * SubtleCrypto surface, and the methods outside importKey, sign, verify - * and digest fence by name. */ -async function encryptWithWebCrypto(key: import("node:crypto").webcrypto.CryptoKey): Promise { - await crypto.subtle.encrypt({ name: "AES-GCM", iv: new Uint8Array(12) }, key, new Uint8Array(1)); +/* WebCrypto beyond the secret-key slice: @types/node declares the whole + * SubtleCrypto surface, and the methods outside the slice, such as + * wrapKey, fence by name. */ +async function wrapWithWebCrypto(key: import("node:crypto").webcrypto.CryptoKey): Promise { + await crypto.subtle.wrapKey("raw", key, key, "AES-KW"); } -void encryptWithWebCrypto; +void wrapWithWebCrypto; /* Node's navigator global: typeof navigator and navigator.userAgent * compile; the other members fence by name. */ const cores = navigator.hardwareConcurrency; diff --git a/tests/fixtures/node-types/webcrypto-keys.ts b/tests/fixtures/node-types/webcrypto-keys.ts new file mode 100644 index 000000000..be16271d8 --- /dev/null +++ b/tests/fixtures/node-types/webcrypto-keys.ts @@ -0,0 +1,32 @@ +/* WebCrypto secret keys under @types/node: generateKey, exportKey and + * importKey for HMAC and AES keys, and PBKDF2 key imports, lower to the + * same native values as under the bundled declarations. @types/node + * names the dictionary, key and JSON Web Key types in node:crypto's + * webcrypto namespace. */ +import type { webcrypto } from "node:crypto"; + +async function main(): Promise { + const hmacParams: webcrypto.HmacKeyGenParams = { name: "HMAC", hash: "SHA-256", length: 256 }; + const hmac: webcrypto.CryptoKey = await crypto.subtle.generateKey(hmacParams, true, ["sign", "verify"]); + const hmacAlgorithm = hmac.algorithm as webcrypto.HmacKeyAlgorithm; + console.log(hmac.type, hmacAlgorithm.name, hmacAlgorithm.length, hmacAlgorithm.hash.name, hmac.usages.join(",")); + const raw: ArrayBuffer = await crypto.subtle.exportKey("raw", hmac); + console.log(raw.byteLength); + + const aesParams: webcrypto.AesKeyGenParams = { name: "AES-GCM", length: 192 }; + const aes = await crypto.subtle.generateKey(aesParams, true, ["encrypt", "decrypt"]); + const aesAlgorithm = aes.algorithm as webcrypto.AesKeyAlgorithm; + console.log(aesAlgorithm.name, aesAlgorithm.length, aes.extractable); + const jwk: webcrypto.JsonWebKey = await crypto.subtle.exportKey("jwk", aes); + console.log(jwk.kty, jwk.alg, jwk.ext, jwk.key_ops?.join(","), jwk.k?.length); + const back = await crypto.subtle.importKey("jwk", jwk, "AES-GCM", false, ["decrypt"]); + console.log(back.algorithm.name, back.extractable, back.usages.join(",")); + + const fixed = new Uint8Array(16).fill(9); + const imported = await crypto.subtle.importKey("raw", fixed, { name: "AES-CBC" }, true, ["encrypt"]); + console.log(Buffer.from(await crypto.subtle.exportKey("raw", imported)).toString("hex")); + const password = await crypto.subtle.importKey("raw", new TextEncoder().encode("pw"), "PBKDF2", false, ["deriveBits"]); + console.log(password.algorithm.name, password.extractable, password.usages.join(",")); +} + +void main(); diff --git a/tests/harness/__snapshots__/node-types-fenced.txt b/tests/harness/__snapshots__/node-types-fenced.txt index 0bd13963d..2f1f8cb2e 100644 --- a/tests/harness/__snapshots__/node-types-fenced.txt +++ b/tests/harness/__snapshots__/node-types-fenced.txt @@ -228,18 +228,18 @@ fenced.ts:105:1 - error SC2020: 'ECDH.computeSecret(key, encoding) with a Buffer 104 | createECDH("sect163k1"); 105 | createECDH("prime256v1").computeSecret(Buffer.alloc(65), "hex"); | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - 106 | /* WebCrypto beyond the HMAC slice: @types/node declares the whole + 106 | /* WebCrypto beyond the secret-key slice: @types/node declares the whole hint: Node reads the second argument as the key's input encoding and answers a Buffer; pass the output encoding third: computeSecret(key, undefined, encoding) -fenced.ts:110:9 - error SC2020: 'crypto.subtle.encrypt' is part of the standard library types but has no scriptc lowering yet +fenced.ts:110:9 - error SC2020: 'crypto.subtle.wrapKey' is part of the standard library types but has no scriptc lowering yet - 109 | async function encryptWithWebCrypto(key: import("node:crypto").webcrypto.CryptoKey): Promise { - 110 | await crypto.subtle.encrypt({ name: "AES-GCM", iv: new Uint8Array(12) }, key, new Uint8Array(1)); + 109 | async function wrapWithWebCrypto(key: import("node:crypto").webcrypto.CryptoKey): Promise { + 110 | await crypto.subtle.wrapKey("raw", key, key, "AES-KW"); | ^~~~~~~~~~~~~~~~~~~~~ 111 | } - hint: the native WebCrypto surface is crypto.subtle.importKey('raw', ...) for HMAC keys, sign and verify with HMAC, and digest with SHA-1, SHA-256, SHA-384 or SHA-512, each called directly on crypto.subtle + hint: the native WebCrypto surface is crypto.subtle's importKey, generateKey and exportKey for HMAC and AES keys (importKey also for PBKDF2 and HKDF keys), encrypt and decrypt with AES-GCM, AES-CBC or AES-CTR, deriveBits and deriveKey with PBKDF2 or HKDF, sign and verify with HMAC, and digest with SHA-1, SHA-256, SHA-384 or SHA-512, each called directly on crypto.subtle fenced.ts:115:15 - error SC2020: 'navigator.hardwareConcurrency' is typed by @types/node but has no scriptc lowering yet diff --git a/tests/harness/__snapshots__/webcrypto-refusals.ts.txt b/tests/harness/__snapshots__/webcrypto-refusals.ts.txt index 521edff3c..e46099f69 100644 --- a/tests/harness/__snapshots__/webcrypto-refusals.ts.txt +++ b/tests/harness/__snapshots__/webcrypto-refusals.ts.txt @@ -1,26 +1,17 @@ -webcrypto-refusals.ts:7:3 - error SC2020: 'crypto.subtle.importKey with the 'jwk' key format' is part of the standard library types but has no scriptc lowering yet +webcrypto-refusals.ts:6:16 - error SC2020: 'crypto.subtle as a value' is part of the standard library types but has no scriptc lowering yet - 6 | const fromJwk = await crypto.subtle.importKey( - 7 | "jwk", - | ^~~~~ - 8 | { kty: "oct", k: "c2VjcmV0" }, + 5 | // @types/node). + 6 | const subtle = crypto.subtle; + | ^~~~~~~~~~~~~ + 7 | console.log(typeof subtle); - hint: the native WebCrypto surface is crypto.subtle.importKey('raw', ...) for HMAC keys, sign and verify with HMAC, and digest with SHA-1, SHA-256, SHA-384 or SHA-512, each called directly on crypto.subtle + hint: the native WebCrypto surface is crypto.subtle's importKey, generateKey and exportKey for HMAC and AES keys (importKey also for PBKDF2 and HKDF keys), encrypt and decrypt with AES-GCM, AES-CBC or AES-CTR, deriveBits and deriveKey with PBKDF2 or HKDF, sign and verify with HMAC, and digest with SHA-1, SHA-256, SHA-384 or SHA-512, each called directly on crypto.subtle -webcrypto-refusals.ts:15:16 - error SC2020: 'crypto.subtle as a value' is part of the standard library types but has no scriptc lowering yet +webcrypto-refusals.ts:9:20 - error SC2020: 'crypto.subtle.sign as a value' is part of the standard library types but has no scriptc lowering yet - 14 | - 15 | const subtle = crypto.subtle; - | ^~~~~~~~~~~~~ - 16 | console.log(typeof subtle); - - hint: the native WebCrypto surface is crypto.subtle.importKey('raw', ...) for HMAC keys, sign and verify with HMAC, and digest with SHA-1, SHA-256, SHA-384 or SHA-512, each called directly on crypto.subtle - -webcrypto-refusals.ts:18:20 - error SC2020: 'crypto.subtle.sign as a value' is part of the standard library types but has no scriptc lowering yet - - 17 | - 18 | console.log(typeof crypto.subtle.sign); + 8 | + 9 | console.log(typeof crypto.subtle.sign); | ^~~~~~~~~~~~~~~~~~ - 19 | + 10 | - hint: the native WebCrypto surface is crypto.subtle.importKey('raw', ...) for HMAC keys, sign and verify with HMAC, and digest with SHA-1, SHA-256, SHA-384 or SHA-512, each called directly on crypto.subtle \ No newline at end of file + hint: the native WebCrypto surface is crypto.subtle's importKey, generateKey and exportKey for HMAC and AES keys (importKey also for PBKDF2 and HKDF keys), encrypt and decrypt with AES-GCM, AES-CBC or AES-CTR, deriveBits and deriveKey with PBKDF2 or HKDF, sign and verify with HMAC, and digest with SHA-1, SHA-256, SHA-384 or SHA-512, each called directly on crypto.subtle \ No newline at end of file diff --git a/tests/harness/corpus-costs/7120-webcrypto-random-uuid.ts.json b/tests/harness/corpus-costs/7120-webcrypto-random-uuid.ts.json new file mode 100644 index 000000000..ce52548ca --- /dev/null +++ b/tests/harness/corpus-costs/7120-webcrypto-random-uuid.ts.json @@ -0,0 +1 @@ +{ "plain": 4431, "san": 4365 } diff --git a/tests/harness/corpus-costs/7121-webcrypto-crypto-object.mjs.json b/tests/harness/corpus-costs/7121-webcrypto-crypto-object.mjs.json new file mode 100644 index 000000000..db431c2ca --- /dev/null +++ b/tests/harness/corpus-costs/7121-webcrypto-crypto-object.mjs.json @@ -0,0 +1 @@ +{ "plain": 5043, "san": 4705 } diff --git a/tests/harness/corpus-costs/7122-webcrypto-node-crypto.ts.json b/tests/harness/corpus-costs/7122-webcrypto-node-crypto.ts.json new file mode 100644 index 000000000..46469f2a9 --- /dev/null +++ b/tests/harness/corpus-costs/7122-webcrypto-node-crypto.ts.json @@ -0,0 +1 @@ +{ "plain": 4805, "san": 6923 } diff --git a/tests/harness/corpus-costs/7123-webcrypto-node-crypto.cjs.json b/tests/harness/corpus-costs/7123-webcrypto-node-crypto.cjs.json new file mode 100644 index 000000000..682ba704a --- /dev/null +++ b/tests/harness/corpus-costs/7123-webcrypto-node-crypto.cjs.json @@ -0,0 +1 @@ +{ "plain": 4728, "san": 6725 } diff --git a/tests/harness/corpus-costs/7124-webcrypto-secret-keys.ts.json b/tests/harness/corpus-costs/7124-webcrypto-secret-keys.ts.json new file mode 100644 index 000000000..73f1ce847 --- /dev/null +++ b/tests/harness/corpus-costs/7124-webcrypto-secret-keys.ts.json @@ -0,0 +1 @@ +{ "plain": 5860, "san": 9241 } diff --git a/tests/harness/corpus-costs/7125-webcrypto-key-errors.mjs.json b/tests/harness/corpus-costs/7125-webcrypto-key-errors.mjs.json new file mode 100644 index 000000000..ceff344eb --- /dev/null +++ b/tests/harness/corpus-costs/7125-webcrypto-key-errors.mjs.json @@ -0,0 +1 @@ +{ "plain": 6582, "san": 9054 } diff --git a/tests/harness/corpus-costs/7126-webcrypto-aes.ts.json b/tests/harness/corpus-costs/7126-webcrypto-aes.ts.json new file mode 100644 index 000000000..b1680985c --- /dev/null +++ b/tests/harness/corpus-costs/7126-webcrypto-aes.ts.json @@ -0,0 +1 @@ +{ "plain": 4563, "san": 6500 } diff --git a/tests/harness/corpus-costs/7127-webcrypto-aes-errors.mjs.json b/tests/harness/corpus-costs/7127-webcrypto-aes-errors.mjs.json new file mode 100644 index 000000000..1ebb743b0 --- /dev/null +++ b/tests/harness/corpus-costs/7127-webcrypto-aes-errors.mjs.json @@ -0,0 +1 @@ +{ "plain": 4385, "san": 8939 } diff --git a/tests/harness/corpus-costs/7128-webcrypto-derive.ts.json b/tests/harness/corpus-costs/7128-webcrypto-derive.ts.json new file mode 100644 index 000000000..2888d22eb --- /dev/null +++ b/tests/harness/corpus-costs/7128-webcrypto-derive.ts.json @@ -0,0 +1 @@ +{ "plain": 5042, "san": 9143 } diff --git a/tests/harness/corpus-costs/7129-webcrypto-derive-errors.mjs.json b/tests/harness/corpus-costs/7129-webcrypto-derive-errors.mjs.json new file mode 100644 index 000000000..b2f70bf57 --- /dev/null +++ b/tests/harness/corpus-costs/7129-webcrypto-derive-errors.mjs.json @@ -0,0 +1 @@ +{ "plain": 5549, "san": 7441 } diff --git a/tests/harness/errors.test.ts b/tests/harness/errors.test.ts index 8af6998ca..00ee40043 100644 --- a/tests/harness/errors.test.ts +++ b/tests/harness/errors.test.ts @@ -1634,14 +1634,14 @@ console.log(typeof promisePrototype, typeof promisePrototype.then, promiseProtot }); }); -// WebCrypto's native slice is HMAC importKey('raw'), sign and verify, and -// the SHA-1/SHA-2 digests. Algorithms Node recognizes outside that slice -// reject with a coded SC2020 Error instead of a Node-shaped success, and a -// JavaScript call with the 'jwk' format meets its named fence when it runs. +// WebCrypto's native slice is crypto.subtle's secret-key methods. +// Algorithms Node recognizes outside that slice reject with a coded SC2020 +// Error instead of a Node-shaped success, and a JavaScript call of a +// method outside it meets its named fence when it runs. // Node's own rejections (unknown names, bad usages) are corpus-pinned // (6292, 6294); these refusals have no Node twin, so they live here. describe("WebCrypto refusals (JS lane)", () => { - test("recognized algorithms outside the HMAC slice reject with SC2020", async () => { + test("recognized algorithms outside the secret-key slice reject with SC2020", async () => { const r = await compileAndRun( "webcrypto-unsupported-algorithms", `const bytes = new TextEncoder().encode("secret"); @@ -1662,10 +1662,10 @@ await attempt("sha3", () => crypto.subtle.digest("SHA3-256", bytes)); await attempt("sha3 hmac", () => crypto.subtle.importKey("raw", bytes, { name: "HMAC", hash: "SHA3-256" }, false, ["sign"]), ); -const format = JSON.parse('"jwk"'); -await attempt("computed jwk", () => - crypto.subtle.importKey(format, { kty: "oct", k: "c2VjcmV0" }, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]), -); +await attempt("ed25519 key", () => crypto.subtle.generateKey({ name: "Ed25519" }, false, ["sign"])); +const aes = await crypto.subtle.generateKey({ name: "AES-GCM", length: 128 }, false, ["encrypt"]); +await attempt("aes-ocb", () => crypto.subtle.encrypt({ name: "AES-OCB", iv: new Uint8Array(12) }, aes, bytes)); +await attempt("ecdh bits", () => crypto.subtle.deriveBits({ name: "ECDH" }, key, 256)); `, "mjs", ); @@ -1676,22 +1676,25 @@ await attempt("computed jwk", () => "ecdsa Error SC2020 crypto.subtle.sign with the ECDSA algorithm is not supported yet\n" + "sha3 Error SC2020 crypto.subtle.digest with the SHA3-256 algorithm is not supported yet\n" + "sha3 hmac Error SC2020 crypto.subtle.importKey with the SHA3-256 algorithm is not supported yet\n" + - "computed jwk Error SC2020 crypto.subtle.importKey with the 'jwk' key format is not supported yet\n", + "ed25519 key Error SC2020 crypto.subtle.generateKey with the Ed25519 algorithm is not supported yet\n" + + "aes-ocb Error SC2020 crypto.subtle.encrypt with the AES-OCB algorithm is not supported yet\n" + + "ecdh bits Error SC2020 crypto.subtle.deriveBits with the ECDH algorithm is not supported yet\n", ); }); - test("a literal 'jwk' import is a named fence where it runs", async () => { + test("a method outside the slice is a named fence where it runs", async () => { const r = await compileAndRun( - "webcrypto-jwk-literal", + "webcrypto-wrap-key", `console.log("before"); -await crypto.subtle.importKey("jwk", { kty: "oct", k: "c2VjcmV0" }, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]); +const key = await crypto.subtle.generateKey({ name: "AES-KW", length: 128 }, true, ["wrapKey"]); +await crypto.subtle.wrapKey("raw", key, key, "AES-KW"); `, "mjs", ); expect(r.exitCode).toBe(1); expect(r.stdout).toBe("before\n"); expect(r.stderr).toMatch( - /^Uncaught Error: 'crypto\.subtle\.importKey with the 'jwk' key format' is part of the standard library types but has no scriptc lowering yet.*\n$/, + /^Uncaught Error: 'crypto\.subtle\.wrapKey' is part of the standard library types but has no scriptc lowering yet.*\n$/, ); }); }); diff --git a/tests/harness/project-config.test.ts b/tests/harness/project-config.test.ts index dabb9b0bf..8532ad6e9 100644 --- a/tests/harness/project-config.test.ts +++ b/tests/harness/project-config.test.ts @@ -1132,6 +1132,24 @@ test("node-types: WebCrypto HMAC matches Node under @types/node", async () => { expect(comparableStderr(native.stderr)).toBe(node.stderr); }); +test("node-types: WebCrypto secret keys match Node under @types/node", async () => { + const outDir = outDirFor("node-webcrypto-keys"); + const entry = join(nodeTypesDir, "webcrypto-keys.ts"); + const result = await compile(entry, { + outPath: join(outDir, "webcrypto-keys"), + outDir, + sanitize, + }); + expect(result.ok, !result.ok ? JSON.stringify(result.diagnostics, null, 2) : "").toBe(true); + if (!result.ok) return; + const [native, node] = await Promise.all([ + execFileAsync(result.binaryPath), + execFileAsync(process.execPath, ["--disable-warning=MODULE_TYPELESS_PACKAGE_JSON", entry]), + ]); + expect(native.stdout).toBe(node.stdout); + expect(comparableStderr(native.stderr)).toBe(node.stderr); +}); + test("node-types: the navigator global's runtime probe matches Node under @types/node", async () => { const outDir = outDirFor("node-navigator"); const entry = join(nodeTypesDir, "navigator.ts"); From f00428ccb1aa6a7e0b3a384cb71b53bd4fe28217 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 02:53:03 -0500 Subject: [PATCH 036/102] Keep pipe() answering its destination and evaluate pipeline() arguments in source order --- .../frontend/lowering/builtins/hash-stream.ts | 16 +++--- .../src/frontend/lowering/lower-stream.ts | 52 +++++++++++++------ tests/corpus/7055-cipher-streams.ts | 40 ++++++++++++++ 3 files changed, 87 insertions(+), 21 deletions(-) diff --git a/packages/compiler/src/frontend/lowering/builtins/hash-stream.ts b/packages/compiler/src/frontend/lowering/builtins/hash-stream.ts index f2f3625dd..88f6c2d95 100644 --- a/packages/compiler/src/frontend/lowering/builtins/hash-stream.ts +++ b/packages/compiler/src/frontend/lowering/builtins/hash-stream.ts @@ -82,7 +82,10 @@ export function lowerHashStreamCall( if (!isValueStream(lowerer, access.expression)) return null; const info = lowerer.classes.get(TRANSFORM_CLASS); if (!info) return null; - return withValueStreamReceiver(lowerer, access.expression, locOf(call), () => + // pipe(dest) answers its destination, which may be a Transform too; + // the other members typed as the Transform answer `this` + const answersThis = name !== "pipe"; + return withValueStreamReceiver(lowerer, access.expression, locOf(call), answersThis, () => streamMember ? lowerStreamMethodCall(lowerer, call, access, info) : lowerEmitterMethodCall(lowerer, call, access, info), @@ -98,19 +101,20 @@ export function lowerValueStreamProperty( if (expr.questionDotToken || !isValueStream(lowerer, expr.expression)) return null; const info = lowerer.classes.get(TRANSFORM_CLASS); if (!info) return null; - return withValueStreamReceiver(lowerer, expr.expression, locOf(expr), () => + return withValueStreamReceiver(lowerer, expr.expression, locOf(expr), true, () => lowerStreamProperty(lowerer, expr, info), ); } /** Evaluates the value `receiver` names once into a hidden local and runs - * `lower` with the receiver lowering to that value's Transform. A result - * typed as the Transform (a member that answers `this`) answers the value - * itself. */ + * `lower` with the receiver lowering to that value's Transform. When + * `answersThis`, a result typed as the Transform (the member answered + * `this`) answers the value itself. */ function withValueStreamReceiver( lowerer: Lowerer, receiver: ts.Expression, loc: SrcLoc, + answersThis: boolean, lower: () => IrExpr | null, ): IrExpr | null { const value = lowerer.lowerExpr(receiver); @@ -124,7 +128,7 @@ function withValueStreamReceiver( } if (!lowered) return null; const answersStream = - lowered.type.kind === "object" && lowered.type.className === TRANSFORM_CLASS; + answersThis && lowered.type.kind === "object" && lowered.type.className === TRANSFORM_CLASS; const result: IrExpr = answersStream ? { kind: "seqExpr", diff --git a/packages/compiler/src/frontend/lowering/lower-stream.ts b/packages/compiler/src/frontend/lowering/lower-stream.ts index ab21b8a7e..d6f89dc11 100644 --- a/packages/compiler/src/frontend/lowering/lower-stream.ts +++ b/packages/compiler/src/frontend/lowering/lower-stream.ts @@ -2935,6 +2935,10 @@ function lowerPipelineStages( // What the next function stage receives: null before the first stage, // else the previous stream's type or the previous stage's generator. let srcT: IrType | null = null; + // The streams and stages in argument order: the head lists all streams + // before all stages, so when a stage precedes a stream the arguments + // are bound to locals first, keeping JavaScript's evaluation order. + const argOrder: { list: IrExpr[]; index: number }[] = []; for (let j = 0; j < stageArgs.length; j++) { const arg = stageArgs[j]!; const fn = pipelineStageFunction(lowerer, arg); @@ -2948,6 +2952,7 @@ function lowerPipelineStages( const source = lowerIterableSource(lowerer, arg, syncSourceFn ? fn : null, loc); if (source === null) lowerer.noLowering("pipeline over this source", arg); positions += 1; + argOrder.push({ list: stages, index: stages.length }); stages.push(source!.closure); srcT = source!.out; continue; @@ -2974,6 +2979,7 @@ function lowerPipelineStages( if (e instanceof StreamArgTypeThrow) lowerer.noLowering("pipeline over this value", arg); throw e; } + argOrder.push({ list: streams, index: streams.length }); streams.push(stream); srcT = stream.type; continue; @@ -3022,6 +3028,7 @@ function lowerPipelineStages( mask |= 1 << stages.length; } positions += 2 ** j; + argOrder.push({ list: stages, index: stages.length }); stages.push(lowered.closure); if (lowered.out.kind === "promise") { dest = 2; @@ -3048,6 +3055,20 @@ function lowerPipelineStages( } helperArgs.push(pipelineBoxHelper(lowerer, destPromise!, loc)); } + const argDecls: IrStmt[] = []; + const firstStage = argOrder.findIndex((a) => a.list === stages); + if (firstStage >= 0 && argOrder.slice(firstStage).some((a) => a.list === streams)) { + for (const a of argOrder) { + const init = a.list[a.index]!; + const local = lowerer.declareHiddenLocal("%pipelineArg", init.type); + argDecls.push({ kind: "varDecl", localId: local.id, init, loc: init.loc }); + a.list[a.index] = varRef(local.id, init.type, init.loc); + } + } + const bindArgs = (call: IrExpr): IrExpr => + argDecls.length === 0 + ? call + : { kind: "seqExpr", stmts: argDecls, result: call, type: call.type, loc }; // SCR_PIPE_* flags: bits 1-2 the destination, bit 5 the signal and abort. const flags = (dest << 1) | (mask !== 0 ? 32 : 0); const head: IrExpr[] = [ @@ -3062,7 +3083,7 @@ function lowerPipelineStages( ]; const last: IrType = dest === 2 ? { kind: "object", className: "%PassThrough" } : streams[streams.length - 1]!.type; - if (mask === 0) return { args: head, last, dest, destPromise, wrap: (call) => call }; + if (mask === 0) return { args: head, last, dest, destPromise, wrap: bindArgs }; // const ac = new AbortController(): its signal goes to the stages, and // finishImpl's ac.abort() runs through the abort closure. const ac = lowerer.declareHiddenLocal("%pipelineAbort", DYN); @@ -3079,20 +3100,21 @@ function lowerPipelineStages( last, dest, destPromise, - wrap: (call) => ({ - kind: "seqExpr", - stmts: [ - { - kind: "varDecl", - localId: ac.id, - init: { kind: "libCall", fn: "fetch.abortControllerNew", args: [], type: DYN, loc }, - loc, - }, - ], - result: call, - type: call.type, - loc, - }), + wrap: (call) => + bindArgs({ + kind: "seqExpr", + stmts: [ + { + kind: "varDecl", + localId: ac.id, + init: { kind: "libCall", fn: "fetch.abortControllerNew", args: [], type: DYN, loc }, + loc, + }, + ], + result: call, + type: call.type, + loc, + }), }; } diff --git a/tests/corpus/7055-cipher-streams.ts b/tests/corpus/7055-cipher-streams.ts index 8befd2339..8f9e0d1ea 100644 --- a/tests/corpus/7055-cipher-streams.ts +++ b/tests/corpus/7055-cipher-streams.ts @@ -8,6 +8,7 @@ import * as crypto from "node:crypto"; import { PassThrough, Readable, + Transform, Writable, addAbortSignal, compose, @@ -65,6 +66,43 @@ async function viaPipeAndForAwait(): Promise { console.log("pipe + for await:", text); } +async function viaPipeIntoTransform(): Promise { + const cipher = crypto.createCipheriv("aes-256-cbc", key, iv); + const upper = new Transform({ + transform(chunk: Buffer, _enc: string, cb: (err: Error | null, data?: Buffer) => void) { + cb(null, Buffer.from(chunk.toString("hex").toUpperCase())); + }, + }); + const out = cipher.pipe(upper); + console.log("pipe answers its destination:", out === upper); + cipher.end("into a transform"); + let hex = ""; + for await (const chunk of out) hex += chunk; + console.log("pipe into transform:", hex); +} + +async function viaPipelineArgumentOrder(): Promise { + const order: string[] = []; + const source = (): string[] => { + order.push("source"); + return ["x", "y"]; + }; + const cipherStage = (): crypto.Cipheriv => { + order.push("cipher"); + return crypto.createCipheriv("aes-256-ctr", key, iv); + }; + const hash = crypto.createHash("sha256"); + await pipelinePromise( + source(), + async function* (src: AsyncIterable) { + for await (const chunk of src) yield chunk.toUpperCase(); + }, + cipherStage(), + hash, + ); + console.log("pipeline argument order:", order.join(" "), hash.digest("hex")); +} + async function viaEvents(): Promise { const cipher = crypto.createCipheriv("aes-128-cbc", Buffer.alloc(16, 1), Buffer.alloc(16, 2)); cipher.setEncoding("hex"); @@ -176,6 +214,8 @@ async function main(): Promise { await viaCallbackPipeline(); await viaPromisePipeline(); await viaPipeAndForAwait(); + await viaPipeIntoTransform(); + await viaPipelineArgumentOrder(); await viaEvents(); await gcm(); } From 70697b45c327c515559e65cd8e4a8602bc98941b Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 02:56:39 -0500 Subject: [PATCH 037/102] Give generic arrow bindings Node's behavior before their declarations run Generic arrow and function-expression bindings compile to shared instances, and their declarations emit no store. Code that can run before the declaration then diverged from Node. - Inside a function, a nested function lowered before the declaration reads the binding through a TDZ box that nothing initialized. That covers closures above the declaration and hoisted function declarations. Such a read threw a ReferenceError even after the declaration ran. The declaration now stores the instance its declared signature pins into that box. - At module scope, calls and pinned value reads went straight to the instances even when a hoisted function or an earlier closure ran them before the declaration. A binding with such a use now has a flag that its declaration sets. - Uses that can run first check the flag. - A let or const throws Node's ReferenceError before the arguments run. - A var runs the arguments and then throws "is not a function". - Uses that follow the declaration stay direct calls: later statements, closures created after it, its own initializer, and function declarations that only such code calls. A var binding inside a function that is called from a place that can run before its declaration would need a per-call flag shared with its closures. That shape now fails with SC1090 instead of calling the instance. --- .../frontend/lowering/generic-functions.ts | 330 +++++++++++++++++- .../src/frontend/lowering/lower-stmts.ts | 17 +- .../compiler/src/frontend/lowering/lowerer.ts | 3 + ...0-generic-local-binding-early-uses.ts.json | 6 + .../7181-generic-module-binding-tdz.ts.json | 6 + .../7182-generic-binding-direct-calls.ts.json | 6 + .../7180-generic-local-binding-early-uses.ts | 53 +++ .../corpus/7181-generic-module-binding-tdz.ts | 49 +++ .../7182-generic-binding-direct-calls.ts | 42 +++ tests/diagnostics/generic-value-bindings.ts | 12 + .../generic-value-bindings.ts.txt | 9 +- ...0-generic-local-binding-early-uses.ts.json | 1 + .../7181-generic-module-binding-tdz.ts.json | 1 + .../7182-generic-binding-direct-calls.ts.json | 1 + 14 files changed, 531 insertions(+), 5 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7180-generic-local-binding-early-uses.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7181-generic-module-binding-tdz.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7182-generic-binding-direct-calls.ts.json create mode 100644 tests/corpus/7180-generic-local-binding-early-uses.ts create mode 100644 tests/corpus/7181-generic-module-binding-tdz.ts create mode 100644 tests/corpus/7182-generic-binding-direct-calls.ts create mode 100644 tests/harness/corpus-costs/7180-generic-local-binding-early-uses.ts.json create mode 100644 tests/harness/corpus-costs/7181-generic-module-binding-tdz.ts.json create mode 100644 tests/harness/corpus-costs/7182-generic-binding-direct-calls.ts.json diff --git a/packages/compiler/src/frontend/lowering/generic-functions.ts b/packages/compiler/src/frontend/lowering/generic-functions.ts index abcd5a584..d0e07582c 100644 --- a/packages/compiler/src/frontend/lowering/generic-functions.ts +++ b/packages/compiler/src/frontend/lowering/generic-functions.ts @@ -3,15 +3,20 @@ import * as ts from "../ts7/adapter.js"; import { bodyReadsArguments } from "../arguments-usage.js"; import type { Lowerer } from "./lowerer.js"; import { + BOOL, DYN, type IrExpr, type IrFunction, type IrParam, type IrStmt, type IrType, + type SrcLoc, + STRING, + VOID, isUnitType, typeEquals, } from "../../ir/ir.js"; +import { nodeThrowExpr } from "../../ir/build.js"; import { isJsSourceFile, locOf } from "../program.js"; import { typeKey } from "../type-mapper.js"; import { functionCanReturnUndefined } from "../function-completion.js"; @@ -22,7 +27,7 @@ import { nsPathPrefix } from "./lower-namespaces.js"; import { declSymbolOf } from "./lower-modules.js"; import { npmStaticPackageOfPath } from "../npm-static.js"; import { rejectStaticThis } from "./static-this.js"; -import { jsBindingHasOpenWrites } from "./lower-stmts.js"; +import { isVarDeclared, jsBindingHasOpenWrites } from "./lower-stmts.js"; import { type ParamShape, paramShapes, @@ -91,6 +96,15 @@ export interface GenericFnInfo { * declaration makes a new function object in JavaScript, while the * compiled instances are shared module functions, so only calls lower. */ functionScoped?: true; + /** The declaration of a generic arrow/function-expression binding. */ + bindingDecl?: ts.VariableDeclaration; + /** A module-scope binding that code can use before its declaration + * runs: the BOOL global its declaration sets, and whether it is a + * `let`/`const` (a temporal dead zone) or a `var` (undefined). */ + presence?: { flagId: string; lexical: boolean }; + /** runsAfterDeclaration's answers for the function declarations whose + * calls it placed. */ + ordering?: Map; /** IMPLICIT-ANY monomorphization (npm-static JS): parallel to * decl.parameters — the param's own symbol when the slot is a BINDABLE * implicit-any parameter (untyped, identifier-named, never written in @@ -257,7 +271,14 @@ export function lowerGenericCall( ? implicitCallInstance(lowerer, expr, info) : genericCallInstance(lowerer, expr, info); const args = lowerer.completeArgs(expr.arguments.nodes, instance.params, loc, expr); - return { kind: "call", callee: instance.name, args, type: instance.returnType, loc }; + const call: IrExpr & { kind: "call" } = { + kind: "call", + callee: instance.name, + args, + type: instance.returnType, + loc, + }; + return guardEarlyBindingCall(lowerer, info, expr, call); } /** The instance a CALL of a generic function-like names: resolved @@ -1233,6 +1254,47 @@ export function lowerGenericFnValue( } } if (!target) fenceUnpinned(); + return guardEarlyBindingValue( + lowerer, + info, + ref, + pinnedGenericClosure(lowerer, ref, info, target, fenceUnpinned), + ); +} + +/** The value a generic binding declared inside a function stores when a + * nested function read it before the declaration lowered (`const read = + * () => id; const id: (x: number) => number = (x: T): T => x`): such + * a read resolves to an ordinary TDZ local, so the declaration assigns it + * the instance its concrete declared signature pins. */ +export function genericBindingStoredValue( + lowerer: Lowerer, + decl: ts.VariableDeclaration, + info: GenericFnInfo, +): IrExpr { + const name = decl.name as ts.Identifier; + const fenceUnpinned = (): never => + lowerer.unsupported( + "SC1090", + name, + `generic function bindings read before their declaration without a concrete declared signature (annotate '${info.baseName}' with one, or declare it before its uses)`, + ); + const sigs = lowerer.checker.getCallSignatures(lowerer.typeOf(name)); + if (sigs.length !== 1) fenceUnpinned(); + return pinnedGenericClosure(lowerer, name, info, sigs[0]!, fenceUnpinned); +} + +/** The closure of the instance of `info` that `target` pins, for a value + * read at `ref`. `fenceUnpinned` reports a signature that leaves a type + * parameter unbound. */ +function pinnedGenericClosure( + lowerer: Lowerer, + ref: ts.Expression, + info: GenericFnInfo, + target: ts.Signature, + fenceUnpinned: () => never, +): IrExpr { + const loc = locOf(ref); const bindings = new Map(); unifySignatureBindings(lowerer, info, target, bindings); const hofBinding = runtimeOptionalHofGenericBinding(lowerer, ref, info); @@ -2565,9 +2627,18 @@ export function bindingGenericFnInfoOf( typeParams, instances: new Map(), ...(functionScoped ? { functionScoped: true as const } : {}), + bindingDecl: decl, }; lowerer.bindingGenericFns.set(fnNode, info); lowerer.genericFnsBySymbol.set(sym, info); + // Module-scope uses resolve to the instances from the start, so those + // that can run first need the flag. Inside a function the declaration + // registers before any later use lowers, and earlier uses read a TDZ + // box (genericBindingStoredValue). + if (!functionScoped) { + const presence = bindingPresenceOf(lowerer, info, decl, sym); + if (presence !== undefined) info.presence = presence; + } if (ts.isFunctionExpression(fnNode) && fnNode.name !== undefined) { const inner = lowerer.checker.getSymbolAtLocation(fnNode.name); if (inner) lowerer.genericFnsBySymbol.set(inner, info); @@ -2575,6 +2646,261 @@ export function bindingGenericFnInfoOf( return info; } +/** Whether `use`, a reference to the binding `info` declares, can only + * run after the declaration has run: it follows the declaration in its + * statement list (closures count where they are created), sits inside the + * initializer itself, or is inside a function declaration whose every + * reference does. References from other modules run after this module's + * body, and export specifiers only export. A use the check cannot place + * answers false. */ +export function runsAfterDeclaration(lowerer: Lowerer, info: GenericFnInfo, use: ts.Node): boolean { + const decl = info.bindingDecl; + if (decl === undefined) return true; + info.ordering ??= new Map(); + return useRunsAfter(lowerer, decl, use, info.ordering, new Set()); +} + +function useRunsAfter( + lowerer: Lowerer, + decl: ts.VariableDeclaration, + use: ts.Node, + memo: Map, + inProgress: Set, +): boolean { + if (ts.getSourceFileOfNode(use) !== ts.getSourceFileOfNode(decl)) return true; + const init = decl.initializer; + if (init !== undefined && use.pos >= init.pos && use.end <= init.end) return true; + const stmt = decl.parent?.parent; + const list = stmt?.parent; + if (stmt === undefined || list === undefined) return false; + for (let n: ts.Node = use; n.parent !== undefined; n = n.parent) { + if (n.parent === list) return n === stmt ? use.pos >= decl.end : n.pos >= stmt.end; + if (ts.isFunctionDeclaration(n)) return functionRunsAfter(lowerer, decl, n, memo, inProgress); + } + return false; +} + +/** Whether every call of the function declaration `fn` runs after `decl` + * has run. A function in progress counts as running after: its calls of + * itself, directly or through other functions, add no earlier caller. + * Only answers that depend on no function in progress are memoized. */ +function functionRunsAfter( + lowerer: Lowerer, + decl: ts.VariableDeclaration, + fn: ts.FunctionDeclaration, + memo: Map, + inProgress: Set, +): boolean { + const known = memo.get(fn); + if (known !== undefined) return known; + if (inProgress.has(fn)) return true; + // `export default function () {}`: only importers call it, after this + // module's body has run. + if (fn.name === undefined) return true; + inProgress.add(fn); + let result = true; + try { + const symbol = lowerer.checker.getSymbolAtLocation(fn.name); + if (symbol === undefined) result = false; + else { + for (const ref of bindingReferences(lowerer, ts.getSourceFileOfNode(fn), symbol, fn.name)) { + if (ref.pos >= fn.pos && ref.end <= fn.end) continue; + if (!useRunsAfter(lowerer, decl, ref, memo, inProgress)) { + result = false; + break; + } + } + } + } finally { + inProgress.delete(fn); + } + if (inProgress.size === 0) memo.set(fn, result); + return result; +} + +/** The value references of `symbol` in `file` other than `name` (its + * declaration name): identifiers spelled like it that resolve to it, + * outside type positions and export specifiers. */ +function bindingReferences( + lowerer: Lowerer, + file: ts.SourceFile, + symbol: ts.Symbol, + name: ts.Identifier, +): ts.Identifier[] { + let byName = lowerer.bindingIdentifiers.get(file); + if (byName === undefined) { + byName = new Map(); + lowerer.bindingIdentifiers.set(file, byName); + } + let idents = byName.get(name.text); + if (idents === undefined) { + const found: ts.Identifier[] = []; + ts.walkPreorder(file, (node) => { + if (ts.isIdentifier(node) && node.text === name.text) found.push(node); + return undefined; + }); + lowerer.checker.prefetchSymbolNodesExact(found); + byName.set(name.text, found); + idents = found; + } + return idents.filter((ident) => { + if (ident === name) return false; + const parent = ident.parent; + if (parent === undefined || ts.isExportSpecifier(parent) || ts.isExportAssignment(parent)) + return false; + let resolved = lowerer.checker.getSymbolAtLocation(ident); + if (ts.isShorthandPropertyAssignment(parent) && parent.name === ident) + resolved = lowerer.checker.getShorthandAssignmentValueSymbol(parent) ?? resolved; + if (resolved !== symbol) return false; + for (let p: ts.Node | undefined = parent; p !== undefined; p = p.parent) { + if (ts.isTypeNode(p) && p.kind !== ts.SyntaxKind.ExpressionWithTypeArguments) return false; + if (ts.isStatement(p) || ts.isFunctionLike(p)) break; + } + return true; + }); +} + +/** The presence flag of a module-scope generic binding that code can use + * before its declaration runs (a hoisted function or an earlier closure + * called during module evaluation), or undefined when every use runs + * after it. The declaration statement sets the flag. */ +function bindingPresenceOf( + lowerer: Lowerer, + info: GenericFnInfo, + decl: ts.VariableDeclaration, + symbol: ts.Symbol, +): GenericFnInfo["presence"] { + const name = decl.name as ts.Identifier; + const early = bindingReferences(lowerer, ts.getSourceFileOfNode(decl), symbol, name).some( + (ref) => !runsAfterDeclaration(lowerer, info, ref), + ); + if (!early) return undefined; + const flagId = `%g.${info.qualifiedName}%initialized`; + lowerer.globalsList.push({ id: flagId, name: "%initialized", type: BOOL, mutable: true }); + return { flagId, lexical: !isVarDeclared(decl) }; +} + +/** The statement that records a generic binding's declaration as run, + * for a binding with a presence flag. */ +export function genericBindingPresenceStore( + info: GenericFnInfo, + decl: ts.VariableDeclaration, +): IrStmt | null { + if (info.presence === undefined) return null; + const loc = locOf(decl); + return { + kind: "assign", + localId: info.presence.flagId, + value: { kind: "boolLit", value: true, type: BOOL, loc }, + loc, + }; +} + +/** A call of a generic binding where the binding may not be initialized + * yet. A `let`/`const` binding in its temporal dead zone throws Node's + * ReferenceError before the arguments run; an unassigned `var` is + * undefined, so the arguments run and the call throws "is not a + * function". Calls that run after the declaration stay direct. */ +function guardEarlyBindingCall( + lowerer: Lowerer, + info: GenericFnInfo, + expr: ts.CallExpression, + call: IrExpr & { kind: "call" }, +): IrExpr { + if (info.bindingDecl === undefined || runsAfterDeclaration(lowerer, info, expr)) return call; + const loc = call.loc; + const presence = requirePresence(lowerer, info, expr.expression); + const flag: IrExpr = { kind: "varRef", localId: presence.flagId, type: BOOL, loc }; + if (presence.lexical) + return { + kind: "seqExpr", + stmts: [tdzCheck(flag, info.baseName, loc)], + result: call, + type: call.type, + loc, + }; + // Arguments first, in order, then the check: Node evaluates them + // before it finds the callee is not callable. + const stmts: IrStmt[] = []; + const args = call.args.map((arg): IrExpr => { + const id = `%earlyCallArg.${lowerer.ctx.locals.length}`; + lowerer.ctx.locals.push({ id, name: "%earlyCallArg", type: arg.type, mutable: false }); + stmts.push({ kind: "varDecl", localId: id, init: arg, loc }); + return { kind: "varRef", localId: id, type: arg.type, loc }; + }); + return { + kind: "seqExpr", + stmts, + result: { + kind: "ternary", + cond: flag, + then: { ...call, args }, + else_: nodeThrowExpr(1, "", `${info.baseName} is not a function`, call.type, loc), + type: call.type, + loc, + }, + type: call.type, + loc, + }; +} + +/** A generic binding read as a value where it may not be initialized + * yet: a `let`/`const` binding checks its temporal dead zone first. */ +function guardEarlyBindingValue( + lowerer: Lowerer, + info: GenericFnInfo, + ref: ts.Expression, + value: IrExpr, +): IrExpr { + if (info.bindingDecl === undefined || runsAfterDeclaration(lowerer, info, ref)) return value; + const presence = requirePresence(lowerer, info, ref); + if (!presence.lexical) + lowerer.unsupported( + "SC1090", + ref, + `generic 'var' bindings read as values before their declaration runs (Node reads undefined there; declare '${info.baseName}' with const)`, + ); + const loc = value.loc; + const flag: IrExpr = { kind: "varRef", localId: presence.flagId, type: BOOL, loc }; + return { + kind: "seqExpr", + stmts: [tdzCheck(flag, info.baseName, loc)], + result: value, + type: value.type, + loc, + }; +} + +/** The presence flag a use that can run before the declaration checks. + * Only module-scope bindings have one: a binding inside a function would + * need a per-call flag that its closures share. */ +function requirePresence( + lowerer: Lowerer, + info: GenericFnInfo, + blame: ts.Node, +): NonNullable { + if (info.presence !== undefined) return info.presence; + return lowerer.unsupported( + "SC1090", + blame, + `generic arrow/function-expression bindings declared inside functions that code can call before their declaration runs (the binding '${info.baseName}' is a 'var' in a branch or block, or is called from a place that can run first — declare it with const before its uses)`, + ); +} + +function tdzCheck(flag: IrExpr, name: string, loc: SrcLoc): IrStmt { + return { + kind: "exprStmt", + expr: { + kind: "intrinsic", + name: "module.tdzCheck", + args: [flag, { kind: "strLit", value: name, type: STRING, loc }], + type: VOID, + loc, + }, + loc, + }; +} + /** `const h = id` — a binding ALIASING a generic function (a top-level * declaration, a registered generic binding, or another alias — resolved * left to right in declaration order). The alias registers the SAME info diff --git a/packages/compiler/src/frontend/lowering/lower-stmts.ts b/packages/compiler/src/frontend/lowering/lower-stmts.ts index e3480cf9c..7d9425a28 100644 --- a/packages/compiler/src/frontend/lowering/lower-stmts.ts +++ b/packages/compiler/src/frontend/lowering/lower-stmts.ts @@ -138,6 +138,8 @@ import { bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, + genericBindingPresenceStore, + genericBindingStoredValue, implicitLocalFnInfoOf, implicitLocalFnNodeOf, implicitMethodCallInfersReturn, @@ -5108,8 +5110,19 @@ export function lowerVarDecl( { const gfnNode = bindingGenericFnNodeOf(decl) ?? bindingContextualGenericFnNodeOf(lowerer, decl); if (gfnNode) { - bindingGenericFnInfoOf(lowerer, decl, gfnNode); - return null; + const info = bindingGenericFnInfoOf(lowerer, decl, gfnNode); + // A nested function that lowered before this declaration read the + // binding as an ordinary TDZ box (predeclareForwardCapture); the + // declaration initializes it, so those reads see the function once + // it runs and a ReferenceError before. + const symbol = lowerer.checker.getSymbolAtLocation(decl.name); + const pre = symbol ? lowerer.ctx.tdzPredeclared.get(symbol) : undefined; + if (pre) { + lowerer.ctx.tdzPredeclared.delete(symbol!); + const value = genericBindingStoredValue(lowerer, decl, info); + return { kind: "assign", localId: pre.id, value, initializes: true, loc: locOf(decl) }; + } + return genericBindingPresenceStore(info, decl); } } diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts index ee8ba7ecb..751aca523 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -1906,6 +1906,9 @@ export class Lowerer { * pinned values resolve through genericFnOf exactly like top-level * generic function declarations (bindingGenericFnInfoOf). */ readonly bindingGenericFns = new Map(); + /** Identifiers by spelling, per file, for the generic bindings' use + * ordering (runsAfterDeclaration). */ + readonly bindingIdentifiers = new Map>(); /** Per-symbol result of the never-reassigned file scan * (bindingNeverReassigned — object-literal generic-method receivers). */ readonly neverReassignedCache = new Map(); diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7180-generic-local-binding-early-uses.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7180-generic-local-binding-early-uses.ts.json new file mode 100644 index 000000000..5fb971826 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7180-generic-local-binding-early-uses.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7180-generic-local-binding-early-uses.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7181-generic-module-binding-tdz.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7181-generic-module-binding-tdz.ts.json new file mode 100644 index 000000000..a67424e94 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7181-generic-module-binding-tdz.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7181-generic-module-binding-tdz.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7182-generic-binding-direct-calls.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7182-generic-binding-direct-calls.ts.json new file mode 100644 index 000000000..b641615f8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7182-generic-binding-direct-calls.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7182-generic-binding-direct-calls.ts" + ], + "diags": [] +} diff --git a/tests/corpus/7180-generic-local-binding-early-uses.ts b/tests/corpus/7180-generic-local-binding-early-uses.ts new file mode 100644 index 000000000..85458d973 --- /dev/null +++ b/tests/corpus/7180-generic-local-binding-early-uses.ts @@ -0,0 +1,53 @@ +// Generic arrow bindings declared inside functions, used by code that runs +// before or after the declaration: closures created above the declaration +// and hoisted function declarations read the binding like any const, so a +// use before the declaration throws a ReferenceError and a later one sees +// the function. +function describe(error: unknown): string { + return error instanceof Error ? `${error.name}: ${error.message}` : String(error); +} + +function make(): (x: number) => number { + const read = (): ((x: number) => number) => id; + const id: (x: number) => number = (x: T): T => x; + return read(); +} +console.log(make()(7)); + +function outer(flag: boolean): number { + if (flag) return helper(); + const id: (x: number) => number = (x: T): T => x; + return helper(); + + function helper(): number { + return id(1); + } +} +console.log(outer(false)); +try { + console.log(outer(true)); +} catch (error) { + console.log(describe(error)); +} + +function run(): void { + const early = (): number => id(2); + try { + early(); + } catch (error) { + console.log(describe(error)); + } + const id: (x: number) => number = (x: T): T => x; + console.log(early()); +} +run(); + +function counter(): () => number { + let total = 0; + const step = (): number => (total = add(total, 1)); + const add: (a: number, b: number) => number = (a: T, b: T): number => a + b; + step(); + step(); + return step; +} +console.log(counter()()); diff --git a/tests/corpus/7181-generic-module-binding-tdz.ts b/tests/corpus/7181-generic-module-binding-tdz.ts new file mode 100644 index 000000000..d2d2915fb --- /dev/null +++ b/tests/corpus/7181-generic-module-binding-tdz.ts @@ -0,0 +1,49 @@ +// A module-scope generic arrow binding is in its temporal dead zone until +// its declaration runs: a hoisted function or an earlier closure that calls +// it during module evaluation throws a ReferenceError, and calls made after +// the declaration reach the function. A `var` binding is undefined until +// then: the call's arguments run, then it throws "is not a function". +function describe(error: unknown): string { + return error instanceof Error ? `${error.name}: ${error.message}` : String(error); +} + +function early(): number { + return id(1); +} +const before = (): string => wrap("b"); + +try { + console.log(early()); +} catch (error) { + console.log(describe(error)); +} +try { + console.log(before()); +} catch (error) { + console.log(describe(error)); +} + +const id = (x: T): T => x; +let wrap = (x: T): string => `[${String(x)}]`; + +console.log(early(), before(), id("direct"), wrap(2)); + +function later(): string { + return wrap(id(3)); +} +console.log(later()); + +function callMissing(): number { + return missing(log("argument")); +} +function log(text: string): number { + console.log(text); + return 1; +} +try { + console.log(callMissing()); +} catch (error) { + console.log(describe(error)); +} +var missing = (x: T): T => x; +console.log(callMissing(), missing(5)); diff --git a/tests/corpus/7182-generic-binding-direct-calls.ts b/tests/corpus/7182-generic-binding-direct-calls.ts new file mode 100644 index 000000000..c7b5397e1 --- /dev/null +++ b/tests/corpus/7182-generic-binding-direct-calls.ts @@ -0,0 +1,42 @@ +// Generic arrow bindings whose uses all run after the declaration: later +// statements, closures created after it, later declarators, recursion and +// function declarations that only later code calls. These calls go +// straight to the compiled instances. +const pair = (x: T): [T, T] => [x, x]; +const doubled = pair(2), labels = pair("a"); +console.log(doubled.join(","), labels.join(",")); + +function useLater(): string { + return pair(true).join(","); +} +console.log(useLater()); + +export function exported(n: number): number { + return pair(n)[0] + 1; +} +console.log(exported(4)); + +function local(): string { + var twice = (x: T): number => x * 2; + const call = (): number => twice(4); + const depth = (xs: T[], n: number): number => (n <= 0 ? xs.length : depth(xs, n - 1) + 1); + return `${twice(1)} ${call()} ${depth([1, 2], 3)} ${helper()}`; + + function helper(): string { + return pair("h").join(""); + } +} +console.log(local()); + +function loop(): string[] { + const out: string[] = []; + const later: (() => string)[] = []; + for (let i = 0; i < 3; i++) { + const tag = (x: T): string => `#${String(x)}`; + later.push(() => tag("late")); + out.push(tag(i * 10)); + } + for (const f of later) out.push(f()); + return out; +} +console.log(loop().join(" ")); diff --git a/tests/diagnostics/generic-value-bindings.ts b/tests/diagnostics/generic-value-bindings.ts index a7de7aa1b..7c786c67c 100644 --- a/tests/diagnostics/generic-value-bindings.ts +++ b/tests/diagnostics/generic-value-bindings.ts @@ -60,3 +60,15 @@ function throughParam(a: Amb): void { console.log(a.m(4)); } throughParam(amb); + +// A `var` binding inside a function, declared in a branch and called from +// a closure: when the branch does not run, Node finds the binding undefined. +// The compiled instances have no per-call flag for that, so the call fences. +function branchVar(flag: boolean): number { + if (flag) { + var picked = (x: T): T => x; + } + const invoke = (): number => picked(1); + return invoke(); +} +console.log(branchVar(true)); diff --git a/tests/harness/__snapshots__/generic-value-bindings.ts.txt b/tests/harness/__snapshots__/generic-value-bindings.ts.txt index 04fa9d069..835b84fa7 100644 --- a/tests/harness/__snapshots__/generic-value-bindings.ts.txt +++ b/tests/harness/__snapshots__/generic-value-bindings.ts.txt @@ -92,4 +92,11 @@ generic-value-bindings.ts:60:15 - error SC1090: calls of the generic method 'm' 59 | function throughParam(a: Amb): void { 60 | console.log(a.m(4)); | ^~~~~~ - 61 | } \ No newline at end of file + 61 | } + +generic-value-bindings.ts:71:32 - error SC1090: generic arrow/function-expression bindings declared inside functions that code can call before their declaration runs (the binding 'picked' is a 'var' in a branch or block, or is called from a place that can run first — declare it with const before its uses) are not supported yet + + 70 | } + 71 | const invoke = (): number => picked(1); + | ^~~~~~ + 72 | return invoke(); \ No newline at end of file diff --git a/tests/harness/corpus-costs/7180-generic-local-binding-early-uses.ts.json b/tests/harness/corpus-costs/7180-generic-local-binding-early-uses.ts.json new file mode 100644 index 000000000..929b49d23 --- /dev/null +++ b/tests/harness/corpus-costs/7180-generic-local-binding-early-uses.ts.json @@ -0,0 +1 @@ +{ "plain": 2542, "san": 2911 } diff --git a/tests/harness/corpus-costs/7181-generic-module-binding-tdz.ts.json b/tests/harness/corpus-costs/7181-generic-module-binding-tdz.ts.json new file mode 100644 index 000000000..321663d8b --- /dev/null +++ b/tests/harness/corpus-costs/7181-generic-module-binding-tdz.ts.json @@ -0,0 +1 @@ +{ "plain": 2500, "san": 2870 } diff --git a/tests/harness/corpus-costs/7182-generic-binding-direct-calls.ts.json b/tests/harness/corpus-costs/7182-generic-binding-direct-calls.ts.json new file mode 100644 index 000000000..e9da8d46e --- /dev/null +++ b/tests/harness/corpus-costs/7182-generic-binding-direct-calls.ts.json @@ -0,0 +1 @@ +{ "plain": 2686, "san": 3069 } From 32da078c118daa1400cad25e5d46bbe9b07f366a Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 03:00:21 -0500 Subject: [PATCH 038/102] Match Node's AsyncLocalStorage context in async prefixes and generator steps --- packages/compiler/src/backend/llvm/emitter.ts | 14 +-- .../compiler/test/await-call-emission.test.ts | 14 +-- .../7106-async-prefix-enter-with.ts.json | 6 ++ .../corpus/7107-for-await-context.ts.json | 6 ++ .../7108-generator-step-context.ts.json | 6 ++ packages/runtime/src/scr_async.c | 83 +++++++++++++---- packages/runtime/src/scr_async.h | 10 ++- tests/corpus/7106-async-prefix-enter-with.ts | 88 +++++++++++++++++++ tests/corpus/7107-for-await-context.ts | 37 ++++++++ tests/corpus/7108-generator-step-context.ts | 49 +++++++++++ .../7106-async-prefix-enter-with.ts.json | 1 + .../7107-for-await-context.ts.json | 1 + .../7108-generator-step-context.ts.json | 1 + 13 files changed, 281 insertions(+), 35 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7106-async-prefix-enter-with.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7107-for-await-context.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7108-generator-step-context.ts.json create mode 100644 tests/corpus/7106-async-prefix-enter-with.ts create mode 100644 tests/corpus/7107-for-await-context.ts create mode 100644 tests/corpus/7108-generator-step-context.ts create mode 100644 tests/harness/corpus-costs/7106-async-prefix-enter-with.ts.json create mode 100644 tests/harness/corpus-costs/7107-for-await-context.ts.json create mode 100644 tests/harness/corpus-costs/7108-generator-step-context.ts.json diff --git a/packages/compiler/src/backend/llvm/emitter.ts b/packages/compiler/src/backend/llvm/emitter.ts index c254d0907..4ab2a42fa 100644 --- a/packages/compiler/src/backend/llvm/emitter.ts +++ b/packages/compiler/src/backend/llvm/emitter.ts @@ -1885,14 +1885,14 @@ export class LlEmitter { /** Whether a fiberless body running on its caller's stack needs the * frame scr_async_inline_enter/exit keep: it isolates the Error.stack - * frame chain, which only stack-observing programs push, and the - * AsyncLocalStorage context, which only programs that enter stores - * change (RuntimeFeatures asyncContext), as a fresh fiber would. Other - * programs run the body with a plain call. The frame also counts the - * bodies running on a fiber's stack for the runtime's trap on a fiberless - * body that suspends. */ + * frame chain, which only stack-observing programs push, as a fresh fiber + * would. Other programs run the body with a plain call. The body runs in + * its caller's AsyncLocalStorage context either way, as Node runs an async + * body up to its first await. The frame also counts the bodies running on + * a fiber's stack for the runtime's trap on a fiberless body that + * suspends. */ get fiberlessFrames(): boolean { - return this.stackTraces || this.schedulesInContext; + return this.stackTraces; } /** The spawn wrapper of a fiberless async function: runs the body on the diff --git a/packages/compiler/test/await-call-emission.test.ts b/packages/compiler/test/await-call-emission.test.ts index 96c039155..5a967cc5f 100644 --- a/packages/compiler/test/await-call-emission.test.ts +++ b/packages/compiler/test/await-call-emission.test.ts @@ -222,7 +222,8 @@ test("bodies that suspend only at their own awaits compile to stackless coroutin }); const framedSources = { - // Entering a store makes the frame isolate the AsyncLocalStorage context. + // Entering a store needs no frame: the body runs in its caller's context, + // as Node runs an async body's synchronous prefix. context: ` import { AsyncLocalStorage } from "node:async_hooks"; const store = new AsyncLocalStorage(); @@ -238,7 +239,7 @@ async function leaf(x: number): Promise { }`, }; -test("fiberless bodies keep their frame where it isolates a context or a stack", async () => { +test("fiberless bodies keep their frame only where it isolates a stack", async () => { for (const [name, prefix] of Object.entries(framedSources)) { const llvm = await emit(`${prefix} async function slow(x: number): Promise { @@ -262,9 +263,12 @@ async function main(): Promise { void main(); `); for (const symbol of ["sc_ai_leaf", "sc_aw_leaf", "sc_as_leaf"]) { - expect(definition(llvm, symbol), `${name} ${symbol}`).toContain( - "call void @scr_async_inline_enter(ptr %frame)", - ); + const body = definition(llvm, symbol); + if (name === "stack") + expect(body, `${name} ${symbol}`).toContain( + "call void @scr_async_inline_enter(ptr %frame)", + ); + else expect(body, `${name} ${symbol}`).not.toContain("@scr_async_inline_enter"); } } }); diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7106-async-prefix-enter-with.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7106-async-prefix-enter-with.ts.json new file mode 100644 index 000000000..2945faca5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7106-async-prefix-enter-with.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7106-async-prefix-enter-with.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7107-for-await-context.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7107-for-await-context.ts.json new file mode 100644 index 000000000..331f64937 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7107-for-await-context.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7107-for-await-context.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7108-generator-step-context.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7108-generator-step-context.ts.json new file mode 100644 index 000000000..e7c5876ac --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7108-generator-step-context.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7108-generator-step-context.ts" + ], + "diags": [] +} diff --git a/packages/runtime/src/scr_async.c b/packages/runtime/src/scr_async.c index db1e54295..9d3a25469 100644 --- a/packages/runtime/src/scr_async.c +++ b/packages/runtime/src/scr_async.c @@ -623,6 +623,10 @@ struct ScrFiber { * awaiter destroys the record when it takes the result. */ bool direct; struct ScrFiber *direct_awaiter; + /* While an async body runs its synchronous prefix (until its first await + * or its end), the AsyncLocalStorage slot of the execution that spawned + * it; NULL afterwards (scr_als_prefix_end). */ + ScrAlsCtx **prefix_slot; #ifdef SCR_ASAN_FIBERS void *fake_stack; /* Live stackless async fibers (scr_async_spawn_stackless) form a list @@ -670,6 +674,34 @@ void scr_als_ctx_release(ScrAlsCtx *c) { free(c); } +/* The end of an async body's synchronous prefix: its first await, or its + * end. Node runs that prefix inside the caller's execution, so a store it + * entered (enterWith) is still the caller's store after the call; the body + * keeps its own copy of the context for what runs after its await. */ +static void scr_als_prefix_end(ScrFiber *f) { + ScrAlsCtx **slot = f->prefix_slot; + if (slot == NULL) return; + f->prefix_slot = NULL; + if (*slot != f->als) { + scr_als_ctx_release(*slot); + *slot = scr_als_ctx_retain(f->als); + } +} + +/* A synchronous generator has no context of its own: each step runs in its + * resumer's execution, as Node runs it. A fiber-backed one switches to its + * own slot, so its step starts from the resumer's store and a store it + * enters is the resumer's after the step (scr_als_prefix_end on the way + * back); a stackless one runs in the resumer's slot (scr_gen_coro_hop). */ +static void scr_als_step_begin(ScrFiber *f) { + ScrAlsCtx **slot = SCR_ALS_SLOT(); + if (f->als != *slot) { + scr_als_ctx_release(f->als); + f->als = scr_als_ctx_retain(*slot); + } + f->prefix_slot = slot; +} + /* The lifetime region a new async fiber carries (ScrFiber.region). */ static inline void *scr_fiber_region_capture(void) { const ScrRgnFiberHooks *regions = atomic_load_explicit(&scr_region_fiber_hooks, memory_order_relaxed); @@ -1889,6 +1921,7 @@ static void scr_trampoline(void) { ScrFiber *self = scr_current; self->entry(self, self->argpack); scr_fiber_finish(self); + scr_als_prefix_end(self); /* The loop reaps the fiber that comes back to it finished, which need * not be the one it resumed: a fiber that continued in place for the * awaiters it parked (scr_await_yield) returns to the loop too. */ @@ -2010,6 +2043,7 @@ static ScrPromise *scr_async_spawn_impl(void (*entry)(ScrFiber *, void *), void /* AsyncLocalStorage: the child runs in the SPAWNER's context (Node's * init-time capture); snapshots are immutable, so a retain suffices. */ f->als = scr_als_ctx_retain(*SCR_ALS_SLOT()); + f->prefix_slot = SCR_ALS_SLOT(); f->region = scr_fiber_region_capture(); scr_fibers_live++; @@ -2023,13 +2057,15 @@ static ScrPromise *scr_async_spawn_impl(void (*entry)(ScrFiber *, void *), void #elif defined(__wasi__) (void)awaiter; ScrFiber *spawner = scr_current; + ScrAlsCtx **spawner_slot = scr_als_active; scr_current = f; scr_exc_swap_cell(&f->exc); scr_als_active = &f->als; entry(f, argpack); /* eager prefix; returns at suspend/final suspend */ + scr_als_prefix_end(f); scr_current = spawner; scr_exc_swap_cell(spawner ? &spawner->exc : NULL); - scr_als_active = spawner ? &spawner->als : &scr_als_main_slot; + scr_als_active = spawner_slot; ScrPromise *result = scr_promise_retain(f->promise); if (f->done) { scr_promise_release(f->promise); @@ -2057,6 +2093,7 @@ static ScrPromise *scr_async_spawn_impl(void (*entry)(ScrFiber *, void *), void #endif f->return_to = home; ScrFiber *spawner = scr_current; + ScrAlsCtx **spawner_slot = scr_als_active; scr_switch(home, &f->ctx, f); /* back: the fiber suspended or finished. The switch back targeted NULL * (the child doesn't know who spawned it), which pointed both the current @@ -2066,7 +2103,7 @@ static ScrPromise *scr_async_spawn_impl(void (*entry)(ScrFiber *, void *), void * `undefined` rejection while the real payload leaks). */ scr_current = spawner; scr_exc_swap_cell(spawner ? &spawner->exc : NULL); - scr_als_active = spawner ? &spawner->als : &scr_als_main_slot; + scr_als_active = spawner_slot; if (awaited != NULL) { /* Parked by the child: the loop owns (and may have reaped) it. */ if (awaiter->await_parked) return awaited; @@ -2172,6 +2209,7 @@ static ScrFiber *scr_spawn_stackless_fiber(void (*entry)(ScrFiber *, void *), vo scr_fiber_track(f); f->stackless = true; f->als = scr_als_ctx_retain(*SCR_ALS_SLOT()); + f->prefix_slot = SCR_ALS_SLOT(); /* The lifetime region the eager prefix runs in, which every later step * resumes in (scr_resume_fiber), as a fiber's body does. */ f->region = scr_fiber_region_capture(); @@ -2183,6 +2221,7 @@ static ScrFiber *scr_spawn_stackless_fiber(void (*entry)(ScrFiber *, void *), vo scr_stackless_fibers = f; #endif ScrFiber *spawner = scr_current; + ScrAlsCtx **spawner_slot = scr_als_active; #ifndef _WIN32 uintptr_t guard = scr_stack_guard; if (guard != 0 && (uintptr_t)__builtin_frame_address(0) < guard + SCR_STACKLESS_PREFIX_ROOM) { @@ -2195,9 +2234,10 @@ static ScrFiber *scr_spawn_stackless_fiber(void (*entry)(ScrFiber *, void *), vo scr_als_active = &f->als; entry(f, argpack); /* the eager prefix: returns at a suspension or the end */ } + scr_als_prefix_end(f); scr_current = spawner; scr_exc_swap_cell(spawner ? &spawner->exc : NULL); - scr_als_active = spawner ? &spawner->als : &scr_als_main_slot; + scr_als_active = spawner_slot; return f; } @@ -2303,8 +2343,10 @@ void *scr_async_spawn_await_ref(void (*entry)(ScrFiber *, void *), void *argpack * settled promise is created and settled in the same order, rejections * enter the unhandled ledger through the same settle path, and the frame * isolates what a fresh fiber would — the Error.stack frame chain - * (cell->stack) and the AsyncLocalStorage context (enterWith inside the - * body stays inside it). The caller's exception cell is clean at any call + * (cell->stack). The AsyncLocalStorage context is the caller's throughout: + * the whole body is the synchronous prefix Node runs in the caller's + * execution, so a store it enters stays entered after the call + * (scr_als_prefix_end). The caller's exception cell is clean at any call * (try/finally stashes in-flight exceptions), so a pending exception * after the body is the body's own throw. */ static void scr_inline_park_trap(void) { @@ -2321,21 +2363,12 @@ void scr_async_inline_enter(ScrAsyncInline *frame) { ScrExcCell *cell = scr_exc_current_cell(); frame->stack = cell->stack; cell->stack = NULL; - frame->als = scr_als_ctx_retain(*SCR_ALS_SLOT()); if (scr_current != NULL) scr_current->inline_depth++; } void scr_async_inline_exit(ScrAsyncInline *frame) { if (scr_current != NULL) scr_current->inline_depth--; scr_exc_current_cell()->stack = (ScrStackFrame *)frame->stack; - ScrAlsCtx *saved = (ScrAlsCtx *)frame->als; - ScrAlsCtx **slot = SCR_ALS_SLOT(); - if (*slot != saved) { - scr_als_ctx_release(*slot); - *slot = saved; /* the frame's reference moves back in */ - } else { - scr_als_ctx_release(saved); - } } ScrPromise *scr_async_inline_leave(ScrAsyncInline *frame) { @@ -2379,11 +2412,14 @@ ScrPromise *scr_async_spawn_after(ScrPromise *dependency, * switch to its own resumer: park it here, for each such awaiter up the * chain, and switch there directly. Nothing runs in between either way. */ static ScrCtx *scr_fiber_park_awaiters(ScrFiber *self) { + scr_als_prefix_end(self); ScrCtx *to = self->return_to; #ifdef SCR_SPAWN_AWAIT for (ScrFiber *cur = self; cur->awaiter != NULL;) { ScrFiber *aw = cur->awaiter; cur->awaiter = NULL; + /* The awaiter's await is its own suspension: its prefix ends here. */ + scr_als_prefix_end(aw); scr_promise_add_waiter(cur->promise, aw); aw->await_parked = true; to = aw->return_to; @@ -5675,9 +5711,13 @@ __attribute__((always_inline)) static inline void scr_gen_coro_hop(ScrGen *g, bo if (retain) scr_gen_retain(g); g->state = SCR_GEN_RUNNING; f->resumer = scr_current; + ScrAlsCtx **resumer_slot = scr_als_active; scr_current = f; scr_exc_swap_cell(&f->exc); - scr_als_active = &f->als; + /* A synchronous generator has no AsyncLocalStorage context of its own: + * its step runs in the resumer's slot, as Node runs it in the execution + * that called next(). An async generator's step runs in its own. */ + if (g->is_async) scr_als_active = &f->als; if (f->coro == NULL) f->entry(f, f->argpack); else scr_coro_resume(f->coro); /* A running generator cannot be resumed again, so neither its fiber nor @@ -5686,7 +5726,7 @@ __attribute__((always_inline)) static inline void scr_gen_coro_hop(ScrGen *g, bo ScrFiber *me = f->resumer; scr_current = me; scr_exc_swap_cell(me != NULL ? &me->exc : NULL); - scr_als_active = me != NULL ? &me->als : &scr_als_main_slot; + scr_als_active = resumer_slot; scr_gen_switched_back(g, f, retain, true); } @@ -5708,6 +5748,7 @@ static void scr_gen_switch_in(ScrGen *g) { #endif scr_gen_retain(g); g->state = SCR_GEN_RUNNING; + if (!g->is_async) scr_als_step_begin(f); #ifdef _WIN32 ScrCtx here = scr_win_self(); #elif defined(__wasi__) @@ -5717,6 +5758,7 @@ static void scr_gen_switch_in(ScrGen *g) { #endif f->return_to = &here; ScrFiber *me = scr_current; + ScrAlsCtx **resumer_slot = scr_als_active; #ifdef __wasi__ scr_current = f; scr_exc_swap_cell(&f->exc); @@ -5725,14 +5767,17 @@ static void scr_gen_switch_in(ScrGen *g) { else scr_wasi_coro_resume(f->coro); scr_current = me; scr_exc_swap_cell(me != NULL ? &me->exc : NULL); - scr_als_active = me != NULL ? &me->als : &scr_als_main_slot; + scr_als_active = resumer_slot; #else scr_switch(&here, &f->ctx, f); - /* Back on the consumer: restore identity + the consumer's cell (the - * yield/finish switch targeted NULL — main's cell). */ + /* Back on the consumer: restore identity, the consumer's cell and its + * AsyncLocalStorage slot (the yield/finish switch targeted NULL — main's + * cell and slot). */ scr_current = me; scr_exc_swap_cell(me != NULL ? &me->exc : NULL); + scr_als_active = resumer_slot; #endif + scr_als_prefix_end(f); scr_gen_switched_back(g, f, true, false); } diff --git a/packages/runtime/src/scr_async.h b/packages/runtime/src/scr_async.h index 827c303f9..fc0128294 100644 --- a/packages/runtime/src/scr_async.h +++ b/packages/runtime/src/scr_async.h @@ -62,12 +62,14 @@ ScrPromise *scr_async_spawn_after(ScrPromise *dependency, /* Fiberless async call (native targets): the compiler proves an async body * can never park its execution context and runs it directly on the * caller's stack between enter and leave. The frame saves what a fresh - * fiber would isolate — the Error.stack frame chain and the - * AsyncLocalStorage context — and leave restores both, returning a fresh - * pending promise (+1) the caller settles from the body's outcome. */ + * fiber would isolate, the Error.stack frame chain, and leave restores it, + * returning a fresh pending promise (+1) the caller settles from the body's + * outcome. The body runs in the caller's AsyncLocalStorage context, as + * Node runs an async body's synchronous prefix. The second word is unused; + * emitted frames keep its size. */ typedef struct ScrAsyncInline { void *stack; - void *als; + void *reserved; } ScrAsyncInline; void scr_async_inline_enter(ScrAsyncInline *frame); ScrPromise *scr_async_inline_leave(ScrAsyncInline *frame); diff --git a/tests/corpus/7106-async-prefix-enter-with.ts b/tests/corpus/7106-async-prefix-enter-with.ts new file mode 100644 index 000000000..27dff250b --- /dev/null +++ b/tests/corpus/7106-async-prefix-enter-with.ts @@ -0,0 +1,88 @@ +// AsyncLocalStorage.enterWith in an async callee: before the callee's first +// await it runs in the caller's execution, so the caller sees the store +// after the call (Node's semantics), and the callee keeps it after its own +// await; after the first await it stays inside the callee. Covers callees +// that never suspend, stackless and fiber-backed callees, nested callees, +// run() scopes inside the prefix, and calls without an await. +import { AsyncLocalStorage } from "node:async_hooks"; + +const store = new AsyncLocalStorage(); +const log: string[] = []; +const current = (): string => store.getStore() ?? "none"; + +async function neverSuspends(tag: string): Promise { + store.enterWith(`never-${tag}`); + return 1; +} +async function prefixThenAwait(tag: string): Promise { + store.enterWith(`prefix-${tag}`); + await null; + log.push(`callee ${tag} after its await: ${current()}`); + return 2; +} +async function afterAwait(tag: string): Promise { + await null; + store.enterWith(`after-${tag}`); + return 3; +} +async function nested(tag: string): Promise { + await neverSuspends(`inner-${tag}`); + log.push(`nested ${tag} after its callee: ${current()}`); + return 4; +} +async function runInPrefix(tag: string): Promise { + store.run(`run-${tag}`, () => store.enterWith("inside-run")); + return 5; +} +async function* ticks(): AsyncGenerator { + yield 1; +} +async function fibered(tag: string): Promise { + store.enterWith(`fibered-${tag}`); + let n = 0; + for await (const t of ticks()) n += t; + log.push(`fibered ${tag} after its loop: ${current()}`); + return n; +} + +async function main(): Promise { + await store.run("A", async () => { + await neverSuspends("1"); + log.push(`A after neverSuspends: ${current()}`); + }); + await store.run("B", async () => { + const pending = prefixThenAwait("2"); + log.push(`B after the call: ${current()}`); + store.enterWith("B-later"); + await pending; + log.push(`B after its await: ${current()}`); + }); + await store.run("C", async () => { + await afterAwait("3"); + log.push(`C after afterAwait: ${current()}`); + }); + await store.run("D", async () => { + await nested("4"); + log.push(`D after nested: ${current()}`); + }); + await store.run("E", async () => { + await runInPrefix("5"); + log.push(`E after runInPrefix: ${current()}`); + }); + await store.run("F", async () => { + void neverSuspends("6"); + log.push(`F after an unawaited call: ${current()}`); + await null; + log.push(`F later: ${current()}`); + }); + store.run("G", () => { + void neverSuspends("7"); + log.push(`G synchronous caller: ${current()}`); + }); + await store.run("H", async () => { + await fibered("8"); + log.push(`H after fibered: ${current()}`); + }); + for (const line of log) console.log(line); +} +void main(); diff --git a/tests/corpus/7107-for-await-context.ts b/tests/corpus/7107-for-await-context.ts new file mode 100644 index 000000000..8e21933b9 --- /dev/null +++ b/tests/corpus/7107-for-await-context.ts @@ -0,0 +1,37 @@ +// An async function's AsyncLocalStorage store across `for await` over an +// async generator: the consumer keeps its store after each resumption of +// the generator, whether it came from run(), from enterWith before the +// loop, or from enterWith after an earlier await. +import { AsyncLocalStorage } from "node:async_hooks"; + +const store = new AsyncLocalStorage(); +const current = (): string => store.getStore() ?? "none"; + +async function* numbers(n: number): AsyncGenerator { + for (let i = 0; i < n; i++) { + await null; + yield i; + } +} + +async function consume(label: string): Promise { + let sum = 0; + for await (const v of numbers(3)) { + sum += v; + console.log(`${label} step ${v}: ${current()}`); + } + console.log(`${label} after the loop (${sum}): ${current()}`); +} + +async function entered(): Promise { + await null; + store.enterWith("entered"); + await consume("entered"); +} + +async function main(): Promise { + await store.run("run", () => consume("run")); + await entered(); + console.log(`main: ${current()}`); +} +void main(); diff --git a/tests/corpus/7108-generator-step-context.ts b/tests/corpus/7108-generator-step-context.ts new file mode 100644 index 000000000..3e9a01a5f --- /dev/null +++ b/tests/corpus/7108-generator-step-context.ts @@ -0,0 +1,49 @@ +// A synchronous generator has no AsyncLocalStorage context of its own: each +// step runs in its resumer's execution, so it sees the store current at +// that next() call, and a store it enters is the resumer's after the step. +// Covers steps inside and outside run(), for-of, spread and early return. +import { AsyncLocalStorage } from "node:async_hooks"; + +const store = new AsyncLocalStorage(); +const current = (): string => store.getStore() ?? "none"; + +function* steps(): Generator { + console.log(`start sees ${current()}`); + yield "a"; + console.log(`step 2 sees ${current()}`); + store.enterWith("entered-in-step-2"); + yield "b"; + console.log(`step 3 sees ${current()}`); +} + +function* labels(): Generator { + yield current(); + yield current(); +} + +store.run("S1", () => { + const g = steps(); + g.next(); + store.run("S2", () => g.next()); + console.log(`caller after the S2 step: ${current()}`); + store.enterWith("S3"); + g.next(); + console.log(`caller after step 3: ${current()}`); +}); + +store.run("forof", () => { + const seen: string[] = []; + for (const label of labels()) seen.push(label); + console.log(`for-of: ${seen.join(",")}`); + console.log(`spread: ${[...labels()].join(",")}`); +}); + +store.run("outer", () => { + const g = steps(); + g.next(); + g.next(); + console.log(`caller after entering step: ${current()}`); + g.return(); + console.log(`caller after return: ${current()}`); +}); +console.log(`top level: ${current()}`); diff --git a/tests/harness/corpus-costs/7106-async-prefix-enter-with.ts.json b/tests/harness/corpus-costs/7106-async-prefix-enter-with.ts.json new file mode 100644 index 000000000..74a3101e8 --- /dev/null +++ b/tests/harness/corpus-costs/7106-async-prefix-enter-with.ts.json @@ -0,0 +1 @@ +{ "plain": 3100, "san": 4000 } diff --git a/tests/harness/corpus-costs/7107-for-await-context.ts.json b/tests/harness/corpus-costs/7107-for-await-context.ts.json new file mode 100644 index 000000000..111fd2885 --- /dev/null +++ b/tests/harness/corpus-costs/7107-for-await-context.ts.json @@ -0,0 +1 @@ +{ "plain": 2200, "san": 3000 } diff --git a/tests/harness/corpus-costs/7108-generator-step-context.ts.json b/tests/harness/corpus-costs/7108-generator-step-context.ts.json new file mode 100644 index 000000000..a5e618da8 --- /dev/null +++ b/tests/harness/corpus-costs/7108-generator-step-context.ts.json @@ -0,0 +1 @@ +{ "plain": 2400, "san": 3100 } From b2b216c3df6184fd964ad3aee3ee69c07e7ecd07 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 03:10:12 -0500 Subject: [PATCH 039/102] Extend a generic factory's anonymous local class returned through a constructor type A generic factory declared to return a constructor type now also extends when it returns an anonymous class expression (`return class { ... } as Struct`) or a `const` bound to one (`const Hold = class { ... }; return Hold`). The result's class value is the class expression's own constructor type; before, it was read through the class's name, so an anonymous class refused with SC1090 and SC2008. --- .../frontend/lowering/generic-functions.ts | 34 ++++++++++++++----- .../corpus/6912-extend-factory-local-class.ts | 32 +++++++++++++++++ 2 files changed, 57 insertions(+), 9 deletions(-) diff --git a/packages/compiler/src/frontend/lowering/generic-functions.ts b/packages/compiler/src/frontend/lowering/generic-functions.ts index 0f549d889..e843b6909 100644 --- a/packages/compiler/src/frontend/lowering/generic-functions.ts +++ b/packages/compiler/src/frontend/lowering/generic-functions.ts @@ -496,10 +496,18 @@ function localClassResultInstance( const viaConstructorType = retTs.getSymbol()?.valueDeclaration !== resultClass; const returnType = withInstanceScope(lowerer, info, inst, () => { if (!viaConstructorType) return lowerer.mapTypeOf(retTs); - const classSymbol = resultClass.name - ? lowerer.checker.getSymbolAtLocation(resultClass.name) - : undefined; - return classSymbol ? lowerer.mapTypeOf(lowerer.checker.getTypeOfSymbol(classSymbol)) : null; + // The local class's own constructor type: a class expression's type is + // its constructor type, named or not (`return class { ... } as Struct`). + const classSymbol = + !ts.isClassExpression(resultClass) && resultClass.name + ? lowerer.checker.getSymbolAtLocation(resultClass.name) + : undefined; + const classType = ts.isClassExpression(resultClass) + ? lowerer.checker.getTypeAtLocation(resultClass) + : classSymbol + ? lowerer.checker.getTypeOfSymbol(classSymbol) + : undefined; + return classType ? lowerer.mapTypeOf(classType) : null; }); if (!returnType) { fenceGenericSignatureResult(lowerer, expr, retTs); @@ -646,11 +654,19 @@ function returnedLocalClass(lowerer: Lowerer, info: GenericFnInfo): ts.ClassLike if (ts.isClassExpression(expr)) return declaredInside(expr, info.decl) ? expr : null; if (!ts.isIdentifier(expr)) return null; const declaration = lowerer.checker.getSymbolAtLocation(expr)?.valueDeclaration; - return declaration && - ts.isClassDeclaration(declaration) && - declaredInside(declaration, info.decl) - ? declaration - : null; + if (!declaration || !declaredInside(declaration, info.decl)) return null; + if (ts.isClassDeclaration(declaration)) return declaration; + // A `const` bound to a class expression (`const C = class { ... }; return C`). + if ( + ts.isVariableDeclaration(declaration) && + ts.getCombinedNodeFlags(declaration) & ts.NodeFlags.Const && + declaration.initializer + ) { + let init: ts.Expression = declaration.initializer; + while (ts.isParenthesizedExpression(init)) init = init.expression; + if (ts.isClassExpression(init)) return init; + } + return null; }; if (!ts.isBlock(body)) return classOf(body as ts.Expression); let found: ts.ClassLikeDeclaration | null = null; diff --git a/tests/corpus/6912-extend-factory-local-class.ts b/tests/corpus/6912-extend-factory-local-class.ts index 8848280e2..e33a59c77 100644 --- a/tests/corpus/6912-extend-factory-local-class.ts +++ b/tests/corpus/6912-extend-factory-local-class.ts @@ -65,3 +65,35 @@ function twice(n: number): number { return K.double() + K.quad(); } console.log(twice(3), twice(5)); + +// The factory returns an anonymous class expression, directly or through a +// `const` binding. +function anonymous(value: S): Struct { + return class { + static decode(_input: unknown): S { + return value; + } + } as unknown as Struct; +} +class Anonymous extends anonymous({ tag: "anon" }) {} +console.log(Anonymous.decode(null).tag); + +type Holder = (new (held: T) => { held: T }) & { readonly seed: () => T }; +function holder(initial: T): Holder { + const Hold = class { + held: T; + constructor(held: T) { + this.held = held; + } + static seed(): T { + return initial; + } + }; + return Hold; +} +class Boxed extends holder(7) { + twice(): number { + return this.held * 2; + } +} +console.log(new Boxed(4).twice(), Boxed.seed()); From 42dd9390c13551dd40383e3a1decbeeaa5de33af Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 03:10:30 -0500 Subject: [PATCH 040/102] Compute index temps of a typed-array loop counter as integers In `for (let i = 0; i < out.length; i++) { const j = i * 4; ... px[j + 1] }` the fast copy of the typed-array loop version computed `j` as a double and converted every index back. The version gives each affine index operand its range under the guard's bound on the counter, but kept the range an operand already had, and the counter of a loop to a length is only known to be below 2^53, so `i * 4` stayed a double multiply. The version now narrows the existing range to the guard's. A constant number local whose initializer has an exact integer form now keeps that integer in an i64 slot beside the double, and its reads carry both, so `px[j + 1]` indexes with integer arithmetic. Only optimized synchronous functions keep these integers, and every other declaration of the local drops its integer, since one declaration is emitted once per loop copy. --- .../backend/llvm/bytes-loop-versions.test.ts | 44 ++++++ .../src/backend/llvm/bytes-loop-versions.ts | 10 +- .../src/backend/llvm/emit-function.ts | 2 + .../src/backend/llvm/emit-statements.ts | 44 ++++++ packages/compiler/src/backend/llvm/emitter.ts | 11 ++ .../src/backend/llvm/expr-primitives.ts | 3 +- .../6996-typed-array-index-temps.ts.json | 6 + tests/corpus/6996-typed-array-index-temps.ts | 134 ++++++++++++++++++ .../6996-typed-array-index-temps.ts.json | 1 + 9 files changed, 252 insertions(+), 3 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6996-typed-array-index-temps.ts.json create mode 100644 tests/corpus/6996-typed-array-index-temps.ts create mode 100644 tests/harness/corpus-costs/6996-typed-array-index-temps.ts.json diff --git a/packages/compiler/src/backend/llvm/bytes-loop-versions.test.ts b/packages/compiler/src/backend/llvm/bytes-loop-versions.test.ts index 3fbc01cc5..28194c7b3 100644 --- a/packages/compiler/src/backend/llvm/bytes-loop-versions.test.ts +++ b/packages/compiler/src/backend/llvm/bytes-loop-versions.test.ts @@ -281,6 +281,50 @@ test("worker programs test each receiver's shared storage once in the guard", () expect(slow).toContain("store atomic double"); }); +test("index temps of a version's counter are integers in the fast copy", () => { + // for (let i = 0; i < out.length; i++) { const j = i * 4; out[i] = src[j] + src[j + 1] } + const length: IrExpr = { + kind: "bytesIntrinsic", + method: "length", + receiver: ref("out", f64s), + args: [], + type: F64, + loc, + }; + const loop = counted( + [ + { kind: "varDecl", localId: "at", init: bin("*", ref("i"), num(4)), loc }, + set( + ref("out", f64s), + ref("i"), + bin( + "+", + get(ref("src", f64s), ref("at")), + get(ref("src", f64s), bin("+", ref("at"), num(1))), + ), + ), + ], + length, + ); + const mod: IrModule = { + irVersion: 17, + sourceFile: loc.file, + entry: "__main", + functions: [ + { name: "__main", params: [], returnType: VOID, locals: [], body: [], loc }, + fn([loop], [local("at", F64)]), + ], + }; + const body = /^define internal [^\n]*@sc_bf_kernel[^]*?^}/m.exec(emitLlvmModule(mod))![0]; + const fast = /^bytes\.version\.fast\d+:$[^]*?^bytes\.version\.done\d+:$/m.exec(body)![0]; + expect(body).toContain("alloca i64 ; integer at"); + expect(fast).toMatch(/mul nsw i64 %\S+, 4/); + expect(fast).toMatch(/add nsw i64 %\S+, 1/); + expect(fast).not.toContain("fmul"); + expect(fast).not.toContain("fptosi"); + expect(fast).not.toContain("bytes.index"); +}); + test("Float16Array accesses version in elements and share the element tag", () => { const f16s: IrType = { kind: "bytes", elem: "f16" }; const withHalves = (body: IrStmt[]): IrFunction => { diff --git a/packages/compiler/src/backend/llvm/bytes-loop-versions.ts b/packages/compiler/src/backend/llvm/bytes-loop-versions.ts index dcb735e61..8c7f668a0 100644 --- a/packages/compiler/src/backend/llvm/bytes-loop-versions.ts +++ b/packages/compiler/src/backend/llvm/bytes-loop-versions.ts @@ -427,7 +427,6 @@ export function matchBytesLoopVersion( used.add(group.check.receiver); for (const node of group.nodes) bounds.add(node); for (const operand of group.operands) { - if (facts.ranges.get(operand)) continue; const shape = shapes.get(operand)!; const a = shape.counter * counterLow, b = shape.counter * counterHigh; @@ -438,7 +437,14 @@ export function matchBytesLoopVersion( min += term.sign > 0 ? r.min : -r.max; max += term.sign > 0 ? r.max : -r.min; } - if (counterLow <= counterHigh) ranges.set(operand, { min, max }); + if (counterLow > counterHigh) continue; + // The guard's bound on the counter can narrow a range the operand + // already has (a loop to a length proves only `i < 2^53`), so that + // `i * 4` in the fast copy is exact integer arithmetic. + const known = facts.ranges.get(operand); + if (!known) ranges.set(operand, { min, max }); + else if (min > known.min || max < known.max) + ranges.set(operand, { min: Math.max(min, known.min), max: Math.min(max, known.max) }); } } // Renumber the receivers the kept checks use. diff --git a/packages/compiler/src/backend/llvm/emit-function.ts b/packages/compiler/src/backend/llvm/emit-function.ts index 5053c1b54..09e6551c3 100644 --- a/packages/compiler/src/backend/llvm/emit-function.ts +++ b/packages/compiler/src/backend/llvm/emit-function.ts @@ -128,6 +128,8 @@ export function emitFunction(emitter: LlEmitter, fn: IrFunction): string { emitter.stableCaptureIds = fn.captures !== undefined ? emitter.lazyCaptures.stableCaptures(fn.name) : new Set(); emitter.integerLoopBindings.clear(); + emitter.integerTemps.clear(); + emitter.integerTempsEnabled = emitter.debug === null && !fn.async && !fn.generator; emitter.countedLoopsEnabled = emitter.debug === null && !fn.async && !fn.generator; emitter.speculativeLoopsEnabled = emitter.countedLoopsEnabled; emitter.speculativeFunction = fn.name; diff --git a/packages/compiler/src/backend/llvm/emit-statements.ts b/packages/compiler/src/backend/llvm/emit-statements.ts index d2e96994b..7f189c066 100644 --- a/packages/compiler/src/backend/llvm/emit-statements.ts +++ b/packages/compiler/src/backend/llvm/emit-statements.ts @@ -50,6 +50,7 @@ import { emitBytesLoopVersionGuard } from "./bytes-loop-versions.js"; import { mangleLocal } from "../mangle.js"; import { LlvmUnsupportedError } from "./unsupported.js"; import type { LlValue } from "./expr-context.js"; +import { widenInteger } from "./integer-values.js"; import { SCALAR_UNION_RESULT } from "./int32-abi.js"; import { emitLiteralSwitch } from "./switch-dispatch.js"; import { @@ -267,6 +268,7 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { else emitter.toFrame(v); B.line(`store ${emitter.llType(b.type)} ${v.name}, ptr ${b.slot}`); emitter.storeIntegerView(s.localId, v, s.init); + storeIntegerTemp(emitter, s.localId, b, v); if (isRefCounted(b.type)) { emitter.scopes[emitter.scopes.length - 1]!.push({ slot: b.slot, type: b.type }); emitter.noteLastUseMove(s, b); @@ -1544,6 +1546,48 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { * Abrupt completions inside tryBody/catchBody ride the finallyStack: * returns inline copies at the return site, while break/continue use the * shared region walk before branching to their resolved target. */ +/** A constant number local whose initializer has an exact integer form + * (such as `const j = i * 4` in a typed-array loop version) keeps that + * integer in an i64 slot beside the double, so reads such as `px[j + 1]` + * index with integer arithmetic instead of converting the double back. + * Every other declaration of the local drops the integer: the same + * declaration is emitted once per loop copy, and a copy must not read the + * integer another copy stored. */ +function storeIntegerTemp( + emitter: LlEmitter, + localId: string, + b: ReturnType, + v: LlValue, +): void { + const local = b.local; + if ( + !emitter.integerTempsEnabled || + b.kind !== "local" || + !local || + local.type.kind !== "f64" || + local.mutable || + local.tdz === true || + emitter.captureIds.has(localId) || + !v.integer + ) { + emitter.integerTemps.delete(localId); + return; + } + const B = emitter.B; + let slot = emitter.integerTemps.get(localId)?.slot; + if (slot === undefined) { + slot = B.slot(); + B.entryAllocas.push(`${slot} = alloca i64 ; integer ${local.name}`); + } + B.line(`store i64 ${widenInteger(emitter, v.integer)}, ptr ${slot}`); + emitter.integerTemps.set(localId, { + slot, + type: "i64", + signed: true, + range: v.integer.range, + }); +} + export function emitTryCatch(emitter: LlEmitter, s: IrStmt & { kind: "tryCatch" }): void { const B = emitter.B; const hasCatch = s.catchBody !== null; diff --git a/packages/compiler/src/backend/llvm/emitter.ts b/packages/compiler/src/backend/llvm/emitter.ts index c254d0907..e11622b9b 100644 --- a/packages/compiler/src/backend/llvm/emitter.ts +++ b/packages/compiler/src/backend/llvm/emitter.ts @@ -1081,6 +1081,17 @@ export class LlEmitter { string, { slot: string; type: "i32" | "i64"; signed?: boolean; range?: { min: number; max: number } } >(); + /** Constant number locals whose latest emitted declaration stored an + * exact integer beside the double, such as `const j = i * 4` in a + * typed-array loop version: an i64 slot and the integer's range. */ + integerTemps = new Map< + string, + { slot: string; type: "i64"; signed: true; range: IntegerRange } + >(); + /** Integer temps are kept only in optimized synchronous functions: an + * async or generator body resumes with its locals in its frame, which + * an entry alloca is not part of. */ + integerTempsEnabled = false; countedLoopsEnabled = false; /** Speculative integer loops (speculative-integers.ts) run in this function. */ speculativeLoopsEnabled = false; diff --git a/packages/compiler/src/backend/llvm/expr-primitives.ts b/packages/compiler/src/backend/llvm/expr-primitives.ts index 12e488b6d..354004e9e 100644 --- a/packages/compiler/src/backend/llvm/expr-primitives.ts +++ b/packages/compiler/src/backend/llvm/expr-primitives.ts @@ -59,7 +59,8 @@ export function emitLiteralExpr( throw new InternalCompilerError(`llvm emitter bug: bare unitLit '${e.unit}'`); case "varRef": { host.materializeSplitLocal(e.localId); - const integerSlot = host.integerLoopBindings.get(e.localId); + const integerSlot = + host.integerLoopBindings.get(e.localId) ?? host.integerTemps.get(e.localId); if (integerSlot !== undefined) { const integer = B.tmp(); const number = B.tmp(); diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6996-typed-array-index-temps.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6996-typed-array-index-temps.ts.json new file mode 100644 index 000000000..b5f88af99 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6996-typed-array-index-temps.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6996-typed-array-index-temps.ts" + ], + "diags": [] +} diff --git a/tests/corpus/6996-typed-array-index-temps.ts b/tests/corpus/6996-typed-array-index-temps.ts new file mode 100644 index 000000000..a19561ef0 --- /dev/null +++ b/tests/corpus/6996-typed-array-index-temps.ts @@ -0,0 +1,134 @@ +// Constant index temps derived from a loop counter (`const j = i * 4`) in +// typed-array loops: as indices and as numbers, in loops whose bounds guard +// passes or fails, nested, captured by closures, read after an await or a +// yield, and in loops whose counter reaches large values. + +function gray(px: Uint8Array, out: Uint8Array): void { + for (let i = 0; i < out.length; i++) { + const j = i * 4; + out[i] = (px[j]! * 77 + px[j + 1]! * 150 + px[j + 2]! * 29) >> 8; + } +} + +function interleave(a: Float32Array, b: Float32Array, out: Float32Array): void { + for (let i = 0; i < a.length; i++) { + const at = 2 * i; + out[at] = a[i]!; + out[at + 1] = b[i]!; + } +} + +function strided(src: Int16Array, out: Int32Array): string { + const seen: number[] = []; + for (let i = 0; i < out.length; i++) { + const at = i * 3 + 2; + out[i] = src[at]! - src[at - 2]!; + if (i % 5 === 0) seen.push(at, at / 2, -at, at % 4); + } + return seen.join(","); +} + +function previous(src: Float64Array, out: Float64Array): string { + const edges: string[] = []; + for (let i = 0; i < out.length; i++) { + const before = i - 1; + out[i] = src[before]! + 1; + if (before < 1) edges.push(`${before}:${Object.is(before * 0, -0)}:${1 / (before * 0)}`); + } + return edges.join(" "); +} + +function rows(cells: Uint32Array, width: number, sums: Float64Array): void { + for (let r = 0; r < sums.length; r++) { + const base = r * width; + let total = 0; + for (let c = 0; c < width; c++) { + const at = base + c; + total += cells[at]!; + } + sums[r] = total; + } +} + +function captured(values: Uint8Array): number { + const readers: (() => number)[] = []; + for (let i = 0; i < values.length; i++) { + const at = i * 2; + readers.push(() => at + values[i]!); + } + let sum = 0; + for (const read of readers) sum += read(); + return sum; +} + +function wide(start: number, count: number): string { + const out: number[] = []; + for (let i = start; i < start + count; i++) { + const next = i + 1; + const twice = i * 2; + out.push(next, twice, next - i); + } + return out.join(","); +} + +async function afterAwait(values: Float64Array): Promise { + const out: number[] = []; + for (let i = 0; i < values.length; i++) { + const at = i * 2; + await null; + out.push(at, values[at] ?? -1); + } + return out.join(","); +} + +function* acrossYield(values: Int8Array): Generator { + for (let i = 0; i < values.length; i++) { + const at = i + 1; + yield values[i]!; + yield at * 10 + (values[at] ?? 0); + } +} + +const px = new Uint8Array(64); +for (let i = 0; i < px.length; i++) px[i] = (i * 41 + 7) & 255; +const g = new Uint8Array(16); +gray(px, g); +console.log("gray", g.join(",")); +const tall = new Uint8Array(20); +gray(px, tall); +console.log("gray past input", tall.join(",")); + +const fa = new Float32Array([1.5, -2.25, 3.125, 0.1]); +const fb = new Float32Array([10, 20, 30, 40]); +const pairs = new Float32Array(8); +interleave(fa, fb, pairs); +console.log("interleave", pairs.join(",")); +const short = new Float32Array(5); +interleave(fa, fb, short); +console.log("interleave short", short.join(",")); + +const src16 = new Int16Array(40); +for (let i = 0; i < src16.length; i++) src16[i] = (i * 9973) % 32768 - 16384; +const diff = new Int32Array(12); +console.log("strided", strided(src16, diff), diff.join(",")); +const far = new Int32Array(20); +console.log("strided past input", strided(src16, far), far.join(",")); + +const src64 = new Float64Array([0.5, 1.5, 2.5]); +const shifted = new Float64Array(4); +console.log("previous", previous(src64, shifted), shifted.join(",")); + +const cells = new Uint32Array(30); +for (let i = 0; i < cells.length; i++) cells[i] = (i * 2654435761) >>> 0; +const sums = new Float64Array(5); +rows(cells, 6, sums); +console.log("rows", sums.join(",")); +const partial = new Float64Array(6); +rows(cells, 6, partial); +console.log("rows past input", partial.join(",")); + +console.log("captured", captured(new Uint8Array([5, 6, 7]))); +console.log("wide", wide(2 ** 53 - 4, 3)); +console.log("wide negative", wide(-3, 4)); +console.log("across yield", [...acrossYield(new Int8Array([3, -4, 5]))].join(",")); +afterAwait(new Float64Array([0.25, 1.25, 2.25, 3.25, 4.25])).then((line) => console.log("after await", line)); diff --git a/tests/harness/corpus-costs/6996-typed-array-index-temps.ts.json b/tests/harness/corpus-costs/6996-typed-array-index-temps.ts.json new file mode 100644 index 000000000..4dc6b88cb --- /dev/null +++ b/tests/harness/corpus-costs/6996-typed-array-index-temps.ts.json @@ -0,0 +1 @@ +{ "plain": 3500, "san": 4600 } From ec0574f44b2feb927745961916974b647121297e Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 03:13:24 -0500 Subject: [PATCH 041/102] Read the byte offset of every untyped ArrayBuffer Buffer.from in one place All Buffer.from paths over an untyped ArrayBuffer or SharedArrayBuffer now go through one function that takes the byte offset explicitly, as Node's fromArrayBuffer does. The start-offset RangeError prints the offset as JavaScript does (-1.5, -1e+21, -Infinity) and builds its message without a fixed-size buffer, which a large negative offset overran. --- packages/runtime/src/scr_bytes_io.c | 77 ++++++++++--------- .../6868-buffer-from-untyped-array-buffer.cjs | 2 +- 2 files changed, 43 insertions(+), 36 deletions(-) diff --git a/packages/runtime/src/scr_bytes_io.c b/packages/runtime/src/scr_bytes_io.c index bd79d9089..137208938 100644 --- a/packages/runtime/src/scr_bytes_io.c +++ b/packages/runtime/src/scr_bytes_io.c @@ -1299,20 +1299,48 @@ ScrBytes *scr_buffer_concat_len_dyn(const ScrDyn *list, double total) { return scr_buffer_concat_dyn_impl(list, total, true); } -/* Buffer.from(arrayBuffer) over a checked value: a Buffer over all of the - * ArrayBuffer or SharedArrayBuffer that shares its memory, as in Node. The - * calls that reach it have no second argument or a literal encoding name, - * which as a byte offset converts to NaN, offset 0; other second arguments - * take scr_buffer_from_dyn_offset_pooled, which applies the offset. */ -static ScrBytes *scr_buffer_from_storage(const ScrDyn *storage) { - ScrBytes *out = scr_bytes_buffer_view(storage->v.handle.ptr, SCR_BYTES_U8, 0, false, 0); +/* Buffer.from(arrayBuffer, byteOffset) over a checked ArrayBuffer or + * SharedArrayBuffer, as Node's fromArrayBuffer: a Buffer from the offset to + * the end of the buffer that shares its memory. The offset converts with + * ToNumber, where a missing offset (NULL) or undefined and NaN are 0; an + * offset past the end throws ERR_BUFFER_OUT_OF_BOUNDS, and one at or below + * -1 V8's start-offset RangeError. NULL with the exception pending. */ +static ScrBytes *scr_buffer_from_storage(const ScrDyn *storage, const ScrDyn *offset_value) { + double offset = 0; + if (offset_value && offset_value->kind != SCR_DYN_UNDEF) { + if (!scr_dyn_number_coerce_js(offset_value, &offset)) return NULL; + if (isnan(offset)) offset = 0; + } + ScrBytes *bytes = storage->v.handle.ptr; + ScrBytes *owner = bytes->backing ? bytes->backing : bytes; + if ((double)scr_bytes_byte_len(owner) - offset < 0) { + static const char msg[] = "\"offset\" is outside of buffer bounds"; + scr_throw_error_msg_code(SCR_ERR_RANGE, msg, sizeof msg - 1, "ERR_BUFFER_OUT_OF_BOUNDS"); + return NULL; + } + double start = trunc(offset); + if (start < 0) { + /* The offset as JavaScript prints it (-1.5, -1e+21, -Infinity). */ + ScrStr *parts[3] = { + scr_str_new("Start offset ", 13), + scr_f64_to_scrstr(offset), + scr_str_new(" is outside the bounds of the buffer", 36), + }; + ScrStr *message = scr_str_concat_parts(parts, 3); + for (size_t i = 0; i < 3; i++) scr_str_release(parts[i]); + scr_throw_error(SCR_ERR_RANGE, message); + return NULL; + } + ScrBytes *out = scr_bytes_buffer_view(bytes, SCR_BYTES_U8, start, false, 0); if (out) out->is_buffer = true; return out; } ScrBytes *scr_buffer_from_dyn(const ScrDyn *value, const ScrStr *encoding) { if (value->kind == SCR_DYN_STR) return scr_bytes_from_str(value->v.str, encoding); - if (scr_buffer_storage_is(value)) return scr_buffer_from_storage(value); + /* The second argument here is an encoding name, which as a byte offset + * converts to NaN: offset 0. */ + if (scr_buffer_storage_is(value)) return scr_buffer_from_storage(value, NULL); if (value->kind == SCR_DYN_BYTES) return scr_bytes_convert(SCR_BYTES_U8, value->v.bytes); if (value->kind == SCR_DYN_ARR) { return scr_buffer_from_array_like(value, (double)value->v.arr.len); @@ -1356,8 +1384,9 @@ ScrBytes *scr_buffer_from_dyn_pooled(const ScrDyn *value, const ScrStr *encoding if (value->kind == SCR_DYN_STR) return scr_buffer_from_str(value->v.str, encoding); if (value->kind == SCR_DYN_BYTES && !value->v.bytes->is_data_view) return scr_buffer_from_bytes(value->v.bytes); - /* A view of an ArrayBuffer shares its memory, so it never comes from the pool. */ - if (scr_buffer_storage_is(value)) return scr_buffer_from_storage(value); + /* A view of an ArrayBuffer shares its memory, so it never comes from the + * pool. The second argument here is an encoding name: offset 0. */ + if (scr_buffer_storage_is(value)) return scr_buffer_from_storage(value, NULL); ScrBytes *out = scr_buffer_from_dyn(value, encoding); if (!out) return NULL; out->is_buffer = true; @@ -1384,9 +1413,8 @@ ScrBytes *scr_buffer_from_dyn_ref_pooled(const ScrDyn *value, const ScrStr *enco /* Buffer.from(value, second) over checked values whose second argument is * not a literal encoding name: an ArrayBuffer or SharedArrayBuffer takes it - * as the byte offset, as Node's fromArrayBuffer does (undefined and NaN are - * 0, the rest of the buffer is the length, ERR_BUFFER_OUT_OF_BOUNDS past the - * end); other values convert as scr_buffer_from_dyn_ref_pooled with utf8. */ + * as the byte offset (scr_buffer_from_storage); other values convert as + * scr_buffer_from_dyn_ref_pooled with utf8. */ ScrBytes *scr_buffer_from_dyn_offset_pooled(const ScrDyn *value, const ScrDyn *second) { if (!scr_buffer_storage_is(value)) { ScrStr *utf8 = scr_str_new("utf8", 4); @@ -1394,28 +1422,7 @@ ScrBytes *scr_buffer_from_dyn_offset_pooled(const ScrDyn *value, const ScrDyn *s scr_str_release(utf8); return out; } - double offset = 0; - if (second->kind != SCR_DYN_UNDEF) { - if (!scr_dyn_number_coerce_js(second, &offset)) return NULL; - if (isnan(offset)) offset = 0; - } - ScrBytes *storage = value->v.handle.ptr; - ScrBytes *owner = storage->backing ? storage->backing : storage; - if ((double)scr_bytes_byte_len(owner) - offset < 0) { - static const char msg[] = "\"offset\" is outside of buffer bounds"; - scr_throw_error_msg_code(SCR_ERR_RANGE, msg, sizeof msg - 1, "ERR_BUFFER_OUT_OF_BOUNDS"); - return NULL; - } - double start = trunc(offset); - if (start < 0) { - char msg[96]; - int n = snprintf(msg, sizeof msg, "Start offset %.0f is outside the bounds of the buffer", start); - scr_throw_error_msg(SCR_ERR_RANGE, msg, (size_t)n); - return NULL; - } - ScrBytes *out = scr_bytes_buffer_view(storage, SCR_BYTES_U8, start, false, 0); - if (out) out->is_buffer = true; - return out; + return scr_buffer_from_storage(value, second); } /* new Buffer(number, encoding) — the deprecated ctor's string arm with a diff --git a/tests/corpus/6868-buffer-from-untyped-array-buffer.cjs b/tests/corpus/6868-buffer-from-untyped-array-buffer.cjs index e30b5873e..ff2c59a46 100644 --- a/tests/corpus/6868-buffer-from-untyped-array-buffer.cjs +++ b/tests/corpus/6868-buffer-from-untyped-array-buffer.cjs @@ -23,7 +23,7 @@ if (isMainThread) { const offsets = new Map(); offsets.set('storage', new ArrayBuffer(8)); const storage = offsets.get('storage'); - for (const offset of [2, 1.5, '3', NaN, null, undefined, true, 8, 9, -1, -0.5]) { + for (const offset of [2, 1.5, '3', NaN, null, undefined, true, 8, 9, -1, -0.5, -1.5, -1e21, -Number.MAX_VALUE, -Infinity]) { try { const view = Buffer.from(storage, offset); view.fill(offset === 2 ? 0x11 : 0); From c4d91bf2d9a65e65579fbc87c588beb2eadeb101 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 03:18:35 -0500 Subject: [PATCH 042/102] Give runtime globals definitions, export only the declared library symbols, and fence the new libFn spellings --- packages/compiler/src/frontend/lowering/surfaces.ts | 1 + packages/runtime/src/scr_json.c | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/packages/compiler/src/frontend/lowering/surfaces.ts b/packages/compiler/src/frontend/lowering/surfaces.ts index adc11e35a..64227ed08 100644 --- a/packages/compiler/src/frontend/lowering/surfaces.ts +++ b/packages/compiler/src/frontend/lowering/surfaces.ts @@ -2263,6 +2263,7 @@ export const AMBIENT_SURFACE_FNS: readonly AmbientSurfaceRow[] = [ "date.nativeNewFields", "date.nativeNewValue", "date.argumentsTime", + "date.classOperation", ], note: "zero arguments, one milliseconds/date-string argument, or local-time year/month fields; values are the read-only TimeClip scalar slice", }, diff --git a/packages/runtime/src/scr_json.c b/packages/runtime/src/scr_json.c index 549ca9165..cab709bf6 100644 --- a/packages/runtime/src/scr_json.c +++ b/packages/runtime/src/scr_json.c @@ -37,7 +37,7 @@ static SCR_TL ScrDyn *scr_builtin_object_prototype; -const ScrDateClassHooks *scr_date_class_hooks; +const ScrDateClassHooks *scr_date_class_hooks = NULL; /* The checked-dynamic Error.prototype (scr_dyn_error_prototype) is not the * prototype of scriptc's Error instances, so a change to it would not reach From 3a879f4f05489d5915a7d49ecdf2501c7643fe6e Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 03:24:50 -0500 Subject: [PATCH 043/102] Read error constructors as values and destructure workerData in JavaScript --- .../lowering/expressions/object-literals.ts | 25 +++++- .../lowering/expressions/property-access.ts | 20 ++++- .../src/frontend/lowering/lower-stmts.ts | 3 + .../6870-error-constructor-values.js.json | 6 ++ .../6871-worker-data-destructuring.cjs.json | 6 ++ packages/runtime/src/scr_dyn.h | 3 + packages/runtime/src/scr_dyn_invoke.c | 2 + packages/runtime/src/scr_json.c | 79 ++++++++++++++++--- tests/corpus/6870-error-constructor-values.js | 55 +++++++++++++ .../corpus/6871-worker-data-destructuring.cjs | 30 +++++++ .../6870-error-constructor-values.js.json | 1 + .../6871-worker-data-destructuring.cjs.json | 1 + 12 files changed, 216 insertions(+), 15 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6870-error-constructor-values.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6871-worker-data-destructuring.cjs.json create mode 100644 tests/corpus/6870-error-constructor-values.js create mode 100644 tests/corpus/6871-worker-data-destructuring.cjs create mode 100644 tests/harness/corpus-costs/6870-error-constructor-values.js.json create mode 100644 tests/harness/corpus-costs/6871-worker-data-destructuring.cjs.json diff --git a/packages/compiler/src/frontend/lowering/expressions/object-literals.ts b/packages/compiler/src/frontend/lowering/expressions/object-literals.ts index 565db0cd8..a17af9b83 100644 --- a/packages/compiler/src/frontend/lowering/expressions/object-literals.ts +++ b/packages/compiler/src/frontend/lowering/expressions/object-literals.ts @@ -35,6 +35,7 @@ import { tryLowerExpression } from "./try-lower-expression.js"; import { fenceSymbolFieldCopy } from "../symbol-fields.js"; import { planUnionRetag } from "../union-retag.js"; import { jsHoldsDynObject, runtimeOptionalStorageOperand } from "../lower-exprs.js"; +import { builtinGlobalValue } from "./property-access.js"; /** `{ a: 1, b: "x" }` → recordLit. The record type comes from the * contextual type when tsc has one (annotated declarations, arguments, @@ -393,9 +394,11 @@ export function lowerDynObjectLiteral( const lowerValue = (): IrExpr => ts.isMethodDeclaration(prop) ? lowerer.lowerLambda(prop, true) - : !boxValue && ts.isObjectLiteralExpression(valueExpr) - ? lowerer.lowerExprExpecting(valueExpr, DYN) - : lowerer.lowerExpr(valueExpr as ts.Expression); + : ts.isShorthandPropertyAssignment(prop) && shorthandBuiltinValue(lowerer, prop) + ? shorthandBuiltinValue(lowerer, prop)! + : !boxValue && ts.isObjectLiteralExpression(valueExpr) + ? lowerer.lowerExprExpecting(valueExpr, DYN) + : lowerer.lowerExpr(valueExpr as ts.Expression); raw = fenceClosureProbe(lowerer, valueExpr, undefined, lowerValue) ?? lowerValue(); } catch (err) { // A PURE member read a JS file cannot lower (a namespace object @@ -3153,6 +3156,20 @@ function lowerDeclaredSpreadMerge( /** The value of a shorthand property (`{ x }`): the binding `x` refers to. * The property name's own symbol is the PROPERTY, so resolution goes * through getShorthandAssignmentValueSymbol. */ +/** `{ TypeError }`: a stdlib global in shorthand position reads as the value + * its name reads as elsewhere (the interned constructor or function value), + * or null when the global has no such value. The shorthand's name carries + * the property's symbol, so the identifier path cannot resolve it. */ +function shorthandBuiltinValue( + lowerer: Lowerer, + prop: ts.ShorthandPropertyAssignment, +): IrExpr | null { + const symbol = lowerer.checker.getShorthandAssignmentValueSymbol(prop); + if (!symbol || !lowerer.isStdlibSymbol(symbol)) return null; + const js = isJsSourceFile(ts.getSourceFileOfNode(prop)); + return builtinGlobalValue(ts.symbolName(symbol), locOf(prop.name), js); +} + export function lowerShorthandValue( lowerer: Lowerer, prop: ts.ShorthandPropertyAssignment, @@ -3169,6 +3186,8 @@ export function lowerShorthandValue( const callable = lowerer.lowerBuiltinCallableValue(builtin, loc); if (callable) return callable; } + const builtinValue = shorthandBuiltinValue(lowerer, prop); + if (builtinValue) return builtinValue; if (symbol) { if (lowerer.ctx.selfSymbol === symbol) { return { kind: "selfRef", type: lowerer.ctx.selfType!, loc }; diff --git a/packages/compiler/src/frontend/lowering/expressions/property-access.ts b/packages/compiler/src/frontend/lowering/expressions/property-access.ts index 5cd70d2a5..c55ec29bb 100644 --- a/packages/compiler/src/frontend/lowering/expressions/property-access.ts +++ b/packages/compiler/src/frontend/lowering/expressions/property-access.ts @@ -4020,10 +4020,26 @@ function lowerStreamObjectProperty( return lowerStreamProperty(lowerer, expr, info); } +/** The error constructors among GLOBAL_CONSTRUCTOR_VALUES. Their statics + * (`Error.stackTraceLimit`, `Error.captureStackTrace`) keep their own + * lowerings, so fenceBuiltinConstructorStaticRead leaves them alone. */ +const ERROR_CONSTRUCTOR_VALUES: ReadonlySet = new Set([ + "Error", + "TypeError", + "RangeError", + "SyntaxError", + "ReferenceError", + "EvalError", + "URIError", + "AggregateError", +]); + /** The builtin constructors JavaScript sources read as real function * values rather than identity tokens: the runtime interns one function per * constructor, and dynamic values answer `.constructor` with the same one, - * so `o.constructor === Object` is an exact identity test. */ + * so `o.constructor === Object` and `err.constructor === TypeError` are + * exact identity tests, and `err.constructor.name` is the constructor's + * name. */ const GLOBAL_CONSTRUCTOR_VALUES: ReadonlySet = new Set([ "Object", "Function", @@ -4034,6 +4050,7 @@ const GLOBAL_CONSTRUCTOR_VALUES: ReadonlySet = new Set([ "Promise", "WeakMap", "WeakSet", + ...ERROR_CONSTRUCTOR_VALUES, ]); /** The builtin global functions JavaScript sources read as interned @@ -4176,6 +4193,7 @@ function fenceBuiltinConstructorStaticRead( symbol !== undefined && ts.symbolName(symbol).endsWith("Constructor") && GLOBAL_CONSTRUCTOR_VALUES.has(ts.symbolName(symbol).slice(0, -"Constructor".length)) && + !ERROR_CONSTRUCTOR_VALUES.has(ts.symbolName(symbol).slice(0, -"Constructor".length)) && lowerer.isStdlibSymbol(symbol) ) lowerer.stdlibMemberFence(access); diff --git a/packages/compiler/src/frontend/lowering/lower-stmts.ts b/packages/compiler/src/frontend/lowering/lower-stmts.ts index 7f0854523..31c0e4565 100644 --- a/packages/compiler/src/frontend/lowering/lower-stmts.ts +++ b/packages/compiler/src/frontend/lowering/lower-stmts.ts @@ -3888,6 +3888,9 @@ function stdlibGlobalTokenDestructure( if (decl.initializer === undefined || !isJsSourceFile(ts.getSourceFileOfNode(decl))) return null; const globalName = stdlibGlobalNameOf(lowerer, decl.initializer); if (globalName === null) return null; + // `workerData` is a value (the data the worker was started with), not an + // API surface: its members destructure as any untyped value's do. + if (globalName === "workerData") return null; if (!ts.isObjectBindingPattern(decl.name)) { lowerer.unsupported( "SC1031", diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6870-error-constructor-values.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6870-error-constructor-values.js.json new file mode 100644 index 000000000..a2f0e02ea --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6870-error-constructor-values.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6870-error-constructor-values.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6871-worker-data-destructuring.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6871-worker-data-destructuring.cjs.json new file mode 100644 index 000000000..b610a5878 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6871-worker-data-destructuring.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6871-worker-data-destructuring.cjs" + ], + "diags": [] +} diff --git a/packages/runtime/src/scr_dyn.h b/packages/runtime/src/scr_dyn.h index 02c4d828f..1310d5fd8 100644 --- a/packages/runtime/src/scr_dyn.h +++ b/packages/runtime/src/scr_dyn.h @@ -725,6 +725,9 @@ ScrDyn *scr_dyn_array_constructor(void); /* The interned builtin constructor `name` (Object, Date, RegExp, Map, Set, * Promise, WeakMap, WeakSet) as a dynamic function value: +1. */ ScrDyn *scr_dyn_global_constructor(const ScrStr *name); +/* The interned function value of an error constructor ("TypeError"), or + * NULL for other names. */ +ScrDyn *scr_dyn_error_constructor(const char *name); /* A builtin global function (setTimeout, setImmediate, process.nextTick, ...) * as an interned dynamic function value: +1. */ ScrDyn *scr_dyn_builtin_function(const ScrStr *name); diff --git a/packages/runtime/src/scr_dyn_invoke.c b/packages/runtime/src/scr_dyn_invoke.c index 2a010f213..7b375018b 100644 --- a/packages/runtime/src/scr_dyn_invoke.c +++ b/packages/runtime/src/scr_dyn_invoke.c @@ -1913,6 +1913,8 @@ static ScrDyn *dyn_function_constructor(void) { ScrDyn *scr_dyn_global_constructor(const ScrStr *name) { if (strcmp(name->data, dyn_s20) == 0) return dyn_function_constructor(); + ScrDyn *error = scr_dyn_error_constructor(name->data); + if (error) return error; ScrDyn *ctor = dyn_global_ctor(name->data); if (!ctor) scr_trap(dyn_s3); return ctor; diff --git a/packages/runtime/src/scr_json.c b/packages/runtime/src/scr_json.c index b8f16630b..e308958d7 100644 --- a/packages/runtime/src/scr_json.c +++ b/packages/runtime/src/scr_json.c @@ -1799,6 +1799,55 @@ static void scr_builtin_object_prototype_cleanup(void) { scr_dyn_release(prototype); } +/* The error constructors as values (an error's `constructor`, and the + * globals in JavaScript): one interned function per constructor and thread, + * indexed like scr_error_vts, with the constructor's name and length. + * Calling one through the value is not supported yet, as for the other + * interned constructors (scr_dyn_global_constructor). */ +static const char *const scr_error_ctor_names[] = { + "Error", "TypeError", "RangeError", "SyntaxError", NULL, + "ReferenceError", "EvalError", "URIError", "AggregateError", +}; +#define SCR_ERROR_CTORS (sizeof scr_error_ctor_names / sizeof scr_error_ctor_names[0]) +static SCR_TL ScrDyn *scr_error_ctor_values[SCR_ERROR_CTORS]; +static SCR_TL bool scr_error_ctors_registered; + +static void scr_error_ctors_cleanup(void) { + for (size_t i = 0; i < SCR_ERROR_CTORS; i++) { + scr_dyn_release(scr_error_ctor_values[i]); + scr_error_ctor_values[i] = NULL; + } +} + +static ScrDyn *scr_error_ctor_call(ScrClosure *closure, ScrDyn *const *args, size_t argc) { + (void)args; + (void)argc; + char message[128]; + int length = snprintf(message, sizeof message, + "calling the %s constructor through a stored value is not supported yet", + (const char *)closure->fn); + scr_throw_error_msg_code(SCR_ERR_ERROR, message, (size_t)length, "SC2020"); + return NULL; +} + +ScrDyn *scr_dyn_error_constructor(const char *name) { + for (size_t i = 0; i < SCR_ERROR_CTORS; i++) { + if (!scr_error_ctor_names[i] || strcmp(scr_error_ctor_names[i], name) != 0) continue; + if (!scr_error_ctors_registered) { + scr_error_ctors_registered = true; + scr_atexit(scr_error_ctors_cleanup); + } + if (!scr_error_ctor_values[i]) { + uint32_t length = strcmp(name, "AggregateError") == 0 ? 2 : 1; + scr_error_ctor_values[i] = + scr_dyn_new_func(scr_closure_new((void *)scr_error_ctor_names[i], 0), scr_error_ctor_call, length, + "native:constructor", scr_error_ctor_names[i]); + } + return scr_dyn_retain(scr_error_ctor_values[i]); + } + return NULL; +} + ScrDyn *scr_dyn_object_prototype(void) { if (!scr_builtin_object_prototype) { scr_builtin_object_prototype = scr_dyn_alloc(SCR_DYN_OBJ); @@ -7704,6 +7753,17 @@ ScrStr *scr_dyn_to_string(const ScrDyn *d, const ScrStr *enc) { return out; } case SCR_DYN_FUNC: { + /* The interned builtin constructors print with their names, as in Node + * (function Map() { [native code] }); other functions without a source + * text print the anonymous native form. */ + if (d->v.fn.sig && strcmp(d->v.fn.sig, "native:constructor") == 0 && d->v.fn.name) { + ScrJsonBuf b; + scr_jb_init(&b); + scr_jb_puts(&b, "function "); + scr_jb_puts(&b, d->v.fn.name); + scr_jb_puts(&b, "() { [native code] }"); + return scr_jb_finish(&b); + } static const char f[] = "function () { [native code] }"; return scr_str_new(f, sizeof f - 1); } @@ -11657,21 +11717,18 @@ static ScrDyn *scr_dyn_obj_read_receiver(const ScrDyn *d, const char *key, size_ ScrDyn *own = scr_dyn_obj_get(d, key, key_len); if (own) return scr_dyn_retain(own); if (key_len == 11 && memcmp(key, "constructor", 11) == 0) { - static const char *const tokens[] = { - "[builtin Error]", "[builtin TypeError]", - "[builtin RangeError]", "[builtin SyntaxError]", - NULL, "[builtin ReferenceError]", "[builtin EvalError]", "[builtin URIError]", - "[builtin AggregateError]", + /* An error's constructor: the interned function value its global + * reads as (scr_dyn_error_constructor). */ + static const char *const names[] = { + "Error", "TypeError", "RangeError", "SyntaxError", NULL, + "ReferenceError", "EvalError", "URIError", "AggregateError", }; size_t hit = scr_errdyn_find(d, false); const ScrVt *vt = hit == SIZE_MAX ? NULL : scr_errdyn_cache[hit].err->vt; - for (size_t kind = 0; vt && kind < sizeof tokens / sizeof tokens[0]; kind++) { - if (!tokens[kind]) continue; + for (size_t kind = 0; vt && kind < sizeof names / sizeof names[0]; kind++) { + if (!names[kind]) continue; if (vt != &scr_error_vts[kind]) continue; - ScrStr *token = scr_str_new(tokens[kind], strlen(tokens[kind])); - ScrDyn *result = scr_dyn_new_str(token); - scr_str_release(token); - return result; + return scr_dyn_error_constructor(names[kind]); } } return scr_dyn_retain(scr_dyn_undefined()); diff --git a/tests/corpus/6870-error-constructor-values.js b/tests/corpus/6870-error-constructor-values.js new file mode 100644 index 000000000..81f5086d2 --- /dev/null +++ b/tests/corpus/6870-error-constructor-values.js @@ -0,0 +1,55 @@ +// The error constructors as values in JavaScript: an error's `constructor` +// is the same function the global names, whose name, length, typeof and +// String() are Node's, for errors the program throws, errors the runtime +// throws, and errors read back from catch bindings and containers. +function describe(label, error) { + const ctor = error.constructor; + console.log(label, error.name, error.constructor.name, typeof ctor, ctor.length, String(ctor)); +} + +describe('Error', new Error('e')); +describe('TypeError', new TypeError('t')); +describe('RangeError', new RangeError('r')); +describe('SyntaxError', new SyntaxError('s')); +describe('ReferenceError', new ReferenceError('f')); +describe('EvalError', new EvalError('v')); +describe('URIError', new URIError('u')); +describe('AggregateError', new AggregateError([], 'a')); + +const thrown = [ + () => JSON.parse('{'), + () => { + const holder = JSON.parse('{"value":null}'); + return holder.value.missing; + }, + () => new Array(-1), + () => decodeURIComponent('%'), + () => { + throw new TypeError('own'); + }, +]; +const constructors = { SyntaxError, TypeError, RangeError, URIError }; +const caught = []; +for (const run of thrown) { + try { + run(); + } catch (error) { + caught.push(error); + console.log('caught', error.constructor.name, error.constructor === constructors[error.name]); + } +} + +const byName = new Map(); +for (const error of caught) byName.set(error.constructor.name, (byName.get(error.constructor.name) ?? 0) + 1); +console.log('kinds', JSON.stringify([...byName])); + +console.log('identity', new TypeError('x').constructor === TypeError, new RangeError('x').constructor === TypeError); +console.log('globals', Error.name, TypeError.length, AggregateError.length, typeof RangeError, String(SyntaxError)); + +const renamed = new TypeError('x'); +renamed.name = 'Custom'; +console.log('renamed', renamed.name, renamed.constructor.name); + +class ParseFailure extends SyntaxError {} +const failure = new ParseFailure('p'); +console.log('subclass', failure.name, failure.constructor.name, failure instanceof SyntaxError); diff --git a/tests/corpus/6871-worker-data-destructuring.cjs b/tests/corpus/6871-worker-data-destructuring.cjs new file mode 100644 index 000000000..63ae789bd --- /dev/null +++ b/tests/corpus/6871-worker-data-destructuring.cjs @@ -0,0 +1,30 @@ +// Destructuring the members of a worker's workerData in JavaScript: plain, +// renamed, defaulted, nested and rest bindings read the data the worker was +// started with, as reading `workerData.` does. +'use strict'; +const { Worker, isMainThread, parentPort, workerData } = require('node:worker_threads'); + +if (isMainThread) { + const sab = new SharedArrayBuffer(8); + const data = { name: 'job-7', size: 3, options: { verbose: true, tags: ['a', 'b'] }, counters: new Int32Array(sab), extra: 1, more: 'x' }; + const worker = new Worker(__filename, { workerData: data }); + worker.on('message', (lines) => { + for (const line of lines) console.log(line); + console.log('main sees', new Int32Array(sab)[0]); + }); +} else { + const lines = []; + const { name, size } = workerData; + lines.push(`plain ${name} ${size}`); + const { name: jobName, missing = 'fallback', size: count = 10 } = workerData; + lines.push(`renamed ${jobName} ${missing} ${count}`); + const { + options: { verbose, tags: [firstTag, ...otherTags] }, + } = workerData; + lines.push(`nested ${verbose} ${firstTag} ${JSON.stringify(otherTags)}`); + const { name: ignored, size: alsoIgnored, options, counters, ...rest } = workerData; + lines.push(`rest ${JSON.stringify(rest)} ${typeof options} ${ignored === name && alsoIgnored === size}`); + counters[0] = 41; + counters[0] += 1; + parentPort.postMessage(lines); +} diff --git a/tests/harness/corpus-costs/6870-error-constructor-values.js.json b/tests/harness/corpus-costs/6870-error-constructor-values.js.json new file mode 100644 index 000000000..c608ce33a --- /dev/null +++ b/tests/harness/corpus-costs/6870-error-constructor-values.js.json @@ -0,0 +1 @@ +{ "plain": 1200, "san": 3400 } diff --git a/tests/harness/corpus-costs/6871-worker-data-destructuring.cjs.json b/tests/harness/corpus-costs/6871-worker-data-destructuring.cjs.json new file mode 100644 index 000000000..d6c0cb9ee --- /dev/null +++ b/tests/harness/corpus-costs/6871-worker-data-destructuring.cjs.json @@ -0,0 +1 @@ +{ "plain": 1300, "san": 3490 } From e37b94cc94c673743d9e4eead55a6968b0a145fe Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 03:29:38 -0500 Subject: [PATCH 044/102] Serialize the self-hosted emitter's IR compactly in its test The pretty-printed IR of the self-hosted LLVM emitter is close to the JavaScript string length limit on CI checkouts, so any growth of the emitter fails the test with "Invalid string length". --- tests/harness/self-hosting-llvm-emitter.test.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/harness/self-hosting-llvm-emitter.test.ts b/tests/harness/self-hosting-llvm-emitter.test.ts index 9c24d50cb..cb9cd69c4 100644 --- a/tests/harness/self-hosting-llvm-emitter.test.ts +++ b/tests/harness/self-hosting-llvm-emitter.test.ts @@ -161,7 +161,7 @@ for (const backend of ["llvm"] as const) { name: string, request = llvmEmitterRequest(), ): Promise => { - writeFileSync(input, serializeModule(mod)); + writeFileSync(input, serializeModule(mod, true)); writeFileSync(config, JSON.stringify(request)); const result = await execFileAsync(stage, [input, output, config], { ...runOptions, @@ -195,7 +195,7 @@ for (const backend of ["llvm"] as const) { loc: { file: rejected.sourceFile, start: 0, end: 0 }, }, ]; - writeFileSync(input, serializeModule(rejected)); + writeFileSync(input, serializeModule(rejected, true)); writeFileSync(config, JSON.stringify(llvmEmitterRequest())); writeFileSync(output, "untouched"); const args = [input, output, config]; From 931f6d48b5952b71485b20501ead419797ffe9f3 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 03:35:33 -0500 Subject: [PATCH 045/102] Evaluate the extends expression of classes defined inside functions A class defined inside a function whose base resolves to a known class lowered to its class value alone, so the `extends` expression never ran. Node evaluates it each time the definition runs, so its calls and other effects were missing (`class Local extends select(2) {}` never called select). The class value now follows the heritage expression's evaluation when that expression can have effects: a call, construction, assignment, update, delete, await or yield outside nested functions. Module-scope classes already evaluated it. --- .../src/frontend/lowering/lower-classes.ts | 56 ++++++++++++++++--- .../7183-local-class-heritage-effects.ts.json | 6 ++ .../7183-local-class-heritage-effects.ts | 54 ++++++++++++++++++ .../7183-local-class-heritage-effects.ts.json | 1 + 4 files changed, 110 insertions(+), 7 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7183-local-class-heritage-effects.ts.json create mode 100644 tests/corpus/7183-local-class-heritage-effects.ts create mode 100644 tests/harness/corpus-costs/7183-local-class-heritage-effects.ts.json diff --git a/packages/compiler/src/frontend/lowering/lower-classes.ts b/packages/compiler/src/frontend/lowering/lower-classes.ts index 505b4d709..7e6f80f2c 100644 --- a/packages/compiler/src/frontend/lowering/lower-classes.ts +++ b/packages/compiler/src/frontend/lowering/lower-classes.ts @@ -6142,13 +6142,55 @@ export function lowerClassExpression(lowerer: Lowerer, expr: ts.ClassLikeDeclara loc, }); } - return info.localClass - ? initializeRuntimeStatics( - lowerer, - info, - value.kind === "classRef" ? { ...value, captures: info.localClass.captureSources } : value, - ) - : value; + if (!info.localClass) return value; + const classValue = initializeRuntimeStatics( + lowerer, + info, + value.kind === "classRef" ? { ...value, captures: info.localClass.captureSources } : value, + ); + // The base resolves statically here, but Node still evaluates the + // heritage expression each time the class definition runs, first. + const heritage = heritageWithEffects(expr); + if (heritage === undefined) return classValue; + return { + kind: "seqExpr", + stmts: [lowerer.lowerExprStatement(heritage)], + result: classValue, + type: classValue.type, + loc: classValue.loc, + }; +} + +/** The `extends` expression of `decl` when evaluating it can have effects + * (a call, construction, assignment, update, delete, await or yield + * outside nested functions). */ +function heritageWithEffects(decl: ts.ClassLikeDeclaration): ts.Expression | undefined { + const heritage = decl.heritageClauses?.nodes.find( + (clause) => clause.token === ts.SyntaxKind.ExtendsKeyword, + )?.types?.nodes[0]?.expression; + if (heritage === undefined) return undefined; + const effects = (node: ts.Node): boolean => { + if (ts.isFunctionLike(node) || ts.isClassDeclaration(node) || ts.isClassExpression(node)) + return false; + if ( + ts.isCallExpression(node) || + ts.isNewExpression(node) || + ts.isTaggedTemplateExpression(node) || + ts.isDeleteExpression(node) || + ts.isAwaitExpression(node) || + ts.isYieldExpression(node) || + (ts.isPrefixUnaryExpression(node) && + (node.operator === ts.SyntaxKind.PlusPlusToken || + node.operator === ts.SyntaxKind.MinusMinusToken)) || + ts.isPostfixUnaryExpression(node) || + (ts.isBinaryExpression(node) && + node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment && + node.operatorToken.kind <= ts.SyntaxKind.LastAssignment) + ) + return true; + return ts.forEachChild(node, (child) => effects(child) || undefined) ?? false; + }; + return effects(heritage) ? heritage : undefined; } /** The EXACT class a receiver expression is statically known to BE (not diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7183-local-class-heritage-effects.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7183-local-class-heritage-effects.ts.json new file mode 100644 index 000000000..8f0ebb3c2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7183-local-class-heritage-effects.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7183-local-class-heritage-effects.ts" + ], + "diags": [] +} diff --git a/tests/corpus/7183-local-class-heritage-effects.ts b/tests/corpus/7183-local-class-heritage-effects.ts new file mode 100644 index 000000000..514449fdb --- /dev/null +++ b/tests/corpus/7183-local-class-heritage-effects.ts @@ -0,0 +1,54 @@ +// A class defined inside a function evaluates its `extends` expression +// every time the definition runs, even when the base it names is fixed: +// calls in the heritage run in order, and a heritage call that throws +// stops the definition. +class Base { + tag(): string { + return "base"; + } +} +const log: string[] = []; +function select(note: string): typeof Base { + log.push(`select ${note}`); + return Base; +} + +function define(round: number): string { + class Local extends select(`declaration ${round}`) {} + return new Local().tag(); +} +for (let round = 0; round < 2; round++) log.push(define(round)); + +function expressionForm(): string { + const Made = class extends select("expression") {}; + return new Made().tag(); +} +log.push(expressionForm()); + +function nested(): string { + class Outer extends select("outer") {} + class Inner extends Outer {} + return new Inner().tag(); +} +log.push(nested()); + +function refuse(): typeof Base { + throw new Error("heritage failed"); +} +function failing(): void { + try { + class Never extends refuse() {} + log.push(new Never().tag()); + } catch (error) { + log.push((error as Error).message); + } +} +failing(); + +const arrow = (n: number): string => { + class InArrow extends select(`arrow ${n}`) {} + return new InArrow().tag(); +}; +log.push(arrow(1)); + +console.log(log.join("\n")); diff --git a/tests/harness/corpus-costs/7183-local-class-heritage-effects.ts.json b/tests/harness/corpus-costs/7183-local-class-heritage-effects.ts.json new file mode 100644 index 000000000..6bcb3bc35 --- /dev/null +++ b/tests/harness/corpus-costs/7183-local-class-heritage-effects.ts.json @@ -0,0 +1 @@ +{ "plain": 2573, "san": 3208 } From 144bfb27242bb2fc5c50f6363511f25ea895e94e Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 03:41:43 -0500 Subject: [PATCH 046/102] Store assignment expressions into module lets declared without an initializer A module `let` declared without an initializer whose type uses its null pointer as the TDZ sentinel (a function, for example) is initialized when its declaration runs, while its slot is still empty. markUninitializedWrites marked the assignment statements that run after the declaration as initializing, but not assignments in expression position. Those ran the pointer check and threw "ReferenceError: Cannot access 'g' before initialization" where Node stores the value, so the deferred-resolver pattern `let resolve!: ...; new Promise((r) => (resolve = r))` failed, as did `(h) => (g = h)` and `const r = (g = h)`. An assignment expression to such a binding now becomes an initializing `assign` whose value a temp holds and yields. Writes that can run before the declaration keep the flag check, so they still throw Node's ReferenceError. --- .../frontend/lowering/cycle-initialization.ts | 30 +++++++-- ...ialized-let-assignment-expressions.ts.json | 6 ++ ...ninitialized-let-assignment-expressions.ts | 63 +++++++++++++++++++ ...ialized-let-assignment-expressions.ts.json | 1 + 4 files changed, 96 insertions(+), 4 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7109-uninitialized-let-assignment-expressions.ts.json create mode 100644 tests/corpus/7109-uninitialized-let-assignment-expressions.ts create mode 100644 tests/harness/corpus-costs/7109-uninitialized-let-assignment-expressions.ts.json diff --git a/packages/compiler/src/frontend/lowering/cycle-initialization.ts b/packages/compiler/src/frontend/lowering/cycle-initialization.ts index 092588a6e..4b1e74fcf 100644 --- a/packages/compiler/src/frontend/lowering/cycle-initialization.ts +++ b/packages/compiler/src/frontend/lowering/cycle-initialization.ts @@ -463,16 +463,38 @@ export function checkCycleBindingAccesses(lowerer: Lowerer, mod: IrModule): void /** Writes to a binding declared without an initializer that run after its * declaration store into an initialized binding whose slot may still be * empty: the pointer guard must not refuse them. Writes that can run - * earlier carry the flag check rewriteFunction inserted. */ + * earlier carry the flag check rewriteFunction inserted. An assignment in + * expression position (`(f = v)`) becomes an initializing `assign` whose + * value a temp holds and yields. */ function markUninitializedWrites(lowerer: Lowerer, mod: IrModule): void { const ids = new Set(); for (const [id, flag] of lowerer.cycleInitFlags) if (flag.uninitialized) ids.add(id); if (ids.size === 0) return; const mark = (s: IrStmt): IrStmt => s.kind === "assign" && !s.initializes && ids.has(s.localId) ? { ...s, initializes: true } : s; - const rewriteExpr = (e: IrExpr): IrExpr => mapExprChildren(e, rewriteExpr, rewriteStmt); - const rewriteStmt = (s: IrStmt): IrStmt => mark(mapStmtChildren(s, rewriteExpr, rewriteStmt)); - for (const fn of mod.functions) fn.body = fn.body.map(rewriteStmt); + for (const fn of mod.functions) { + let temps = 0; + const markExpr = (e: IrExpr): IrExpr => { + if (e.kind !== "assignExpr" || !ids.has(e.localId)) return e; + const t = `%uninitWrite.${temps++}`; + fn.locals.push({ id: t, name: "%uninitWrite", type: e.value.type, mutable: false }); + const value: IrExpr = { kind: "varRef", localId: t, type: e.value.type, loc: e.loc }; + return { + kind: "seqExpr", + stmts: [ + { kind: "varDecl", localId: t, init: e.value, loc: e.loc }, + { kind: "assign", localId: e.localId, value, initializes: true, loc: e.loc }, + ], + result: value, + type: e.type, + loc: e.loc, + }; + }; + const rewriteExpr = (e: IrExpr): IrExpr => + markExpr(mapExprChildren(e, rewriteExpr, rewriteStmt)); + const rewriteStmt = (s: IrStmt): IrStmt => mark(mapStmtChildren(s, rewriteExpr, rewriteStmt)); + fn.body = fn.body.map(rewriteStmt); + } } function rewriteFunction( diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7109-uninitialized-let-assignment-expressions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7109-uninitialized-let-assignment-expressions.ts.json new file mode 100644 index 000000000..47973fee5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7109-uninitialized-let-assignment-expressions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7109-uninitialized-let-assignment-expressions.ts" + ], + "diags": [] +} diff --git a/tests/corpus/7109-uninitialized-let-assignment-expressions.ts b/tests/corpus/7109-uninitialized-let-assignment-expressions.ts new file mode 100644 index 000000000..1354ab100 --- /dev/null +++ b/tests/corpus/7109-uninitialized-let-assignment-expressions.ts @@ -0,0 +1,63 @@ +// A module `let` declared without an initializer is initialized (to +// undefined) when its declaration runs. Assignments in expression +// position store into it like assignment statements do. + +// The deferred-resolver pattern: an expression-bodied executor. +let resolve!: (value: number) => void; +const pending = new Promise((r) => (resolve = r)); +resolve(1); +console.log("resolved", await pending); + +// An expression-bodied setter, and the assignment's value. +let handler!: (n: number) => string; +const setHandler = (h: (n: number) => string) => (handler = h); +const returned = setHandler((n) => `handled ${n}`); +console.log(returned(2), handler(3)); + +// The value held in a binding first. +let next!: () => string; +const install = (f: () => string) => { + const r = (next = f); + return r; +}; +console.log(install(() => "installed")(), next()); + +// Chained, conditional and argument positions. +let first!: (n: number) => number; +let second!: (n: number) => number; +first = second = (n) => n + 1; +console.log("chained", first(1), second(2)); +let picked!: () => string; +const choose = (flag: boolean) => (flag ? (picked = () => "yes") : (picked = () => "no")); +choose(false); +console.log("conditional", picked()); +const call = (f: () => string) => f(); +let passed!: () => string; +console.log("argument", call((passed = () => "passed")), passed()); + +// Reassignment releases the earlier function and keeps the new one. +let counter!: () => number; +const make = (start: number) => { + let n = start; + return (counter = () => ++n); +}; +make(10); +make(20); +console.log("reassigned", counter(), counter()); + +// An optional binding behaves the same way. +let maybe: ((s: string) => string) | undefined; +const setMaybe = (f: (s: string) => string) => (maybe = f); +console.log("optional", setMaybe((s) => s.toUpperCase())("a"), maybe?.("b")); + +// A write that runs before the declaration still throws. +function early(): () => number { + return (late = () => 1); +} +try { + early(); +} catch (e) { + console.log((e as Error).name, (e as Error).message); +} +let late!: () => number; +console.log("after declaration", early()(), late()); diff --git a/tests/harness/corpus-costs/7109-uninitialized-let-assignment-expressions.ts.json b/tests/harness/corpus-costs/7109-uninitialized-let-assignment-expressions.ts.json new file mode 100644 index 000000000..46c7f7832 --- /dev/null +++ b/tests/harness/corpus-costs/7109-uninitialized-let-assignment-expressions.ts.json @@ -0,0 +1 @@ +{ "plain": 3300, "san": 4500 } From 79684d0ef491b6213c9b80bdba3a673e29650214 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 03:44:38 -0500 Subject: [PATCH 047/102] Name lowered helpers and closures independently of lowering order Lowering named helpers by the size of their registry at first use (%union.retag.N, %arr.map.N, ...), lifted closures and optional-chain locals by compiler-wide counters (%fnN, chain.N), generic instances by their instance count, and records and unions by creation order (rN, uN). Class expressions, mixin instances, function-local generics, non-exported namespace segments and some module globals carried the byte offset of their declaration. A name therefore depended on which unit lowered first and on the positions of unrelated code. Helpers, instances, records and unions are now named by a hash of the key they are interned by (keyedHelperName). Closures and optional-chain ids are named by their lowering unit, their structural position and a count per key within the unit. Offset-based names use the structural position: the chain of enclosing named declarations (each with its kind, name and ordinal) and the node's ordinal among same-kind nodes inside the nearest one, so an edit outside that declaration leaves the name unchanged. Interfaces and type aliases anchor the positions inside them, and default library files are named by their base name, so tsgo and tsc-ts, which install them in different directories, give the same positions. Recursive record and union placeholders are named by the printed type, the structural position of the declaration and the same for up to three levels of type arguments; a description that two types still share gets a numbered suffix for the later one. A generic class instance keyed by a literal type argument is named by the literal's text or the argument's description instead of its checker type id. Two different keys with the same name throw an InternalCompilerError. The SC6101 performance warning recognizes the new closure names (fn., with _ for a named function expression) and lists the functions that rank alike in source order. The module lists its records and unions by id. The generated program is unchanged apart from these names and that order, and test:lowering-order now fails on any name difference. --- package.json | 2 +- packages/compiler/src/contracts/check.ts | 3 +- .../lowering/array-indexed-mutation.ts | 3 +- .../src/frontend/lowering/array-values.ts | 5 +- .../frontend/lowering/builtins/arguments.ts | 3 +- .../lowering/builtins/child-process-async.ts | 3 +- .../lowering/builtins/child-process-sync.ts | 3 +- .../lowering/builtins/disposable-stack.ts | 3 +- .../frontend/lowering/builtins/filesystem.ts | 3 +- .../src/frontend/lowering/builtins/json.ts | 3 +- .../lowering/builtins/operating-system.ts | 7 +- .../frontend/lowering/builtins/performance.ts | 5 +- .../src/frontend/lowering/builtins/process.ts | 5 +- .../frontend/lowering/builtins/promises.ts | 5 +- .../lowering/builtins/promisify-callback.ts | 3 +- .../frontend/lowering/builtins/text-codecs.ts | 3 +- .../src/frontend/lowering/builtins/timers.ts | 2 +- .../src/frontend/lowering/builtins/url.ts | 7 +- .../src/frontend/lowering/builtins/v8.ts | 3 +- .../src/frontend/lowering/call-arguments.ts | 3 +- .../src/frontend/lowering/call-signatures.ts | 7 +- .../src/frontend/lowering/class-assertions.ts | 5 +- .../src/frontend/lowering/class-unions.ts | 3 +- .../lowering/coercions/function-adapters.ts | 11 +- .../frontend/lowering/coercions/structural.ts | 15 +-- .../src/frontend/lowering/coercions/unions.ts | 15 +-- .../frontend/lowering/collection-ingestion.ts | 3 +- .../lowering/containers/array-callbacks.ts | 25 ++-- .../lowering/containers/array-concat.ts | 3 +- .../lowering/containers/array-construction.ts | 7 +- .../lowering/containers/array-methods.ts | 11 +- .../lowering/containers/array-pipelines.ts | 3 +- .../src/frontend/lowering/containers/bytes.ts | 5 +- .../lowering/containers/callback-arguments.ts | 3 +- .../containers/collection-grouping.ts | 5 +- .../lowering/containers/collection-methods.ts | 15 +-- .../lowering/containers/indexed-objects.ts | 15 +-- .../lowering/containers/iterator-helpers.ts | 7 +- .../lowering/containers/string-and-regexp.ts | 11 +- .../lowering/containers/string-replacement.ts | 3 +- .../src/frontend/lowering/dynamic-tier.ts | 20 +++- .../frontend/lowering/expressions/binary.ts | 3 +- .../lowering/expressions/object-literals.ts | 7 +- .../lowering/expressions/optional-chains.ts | 10 +- .../lowering/expressions/property-access.ts | 3 +- .../lowering/expressions/relational.ts | 5 +- .../frontend/lowering/generic-functions.ts | 17 ++- .../src/frontend/lowering/intern-tables.ts | 7 +- .../frontend/lowering/iterator-adapters.ts | 17 +-- .../frontend/lowering/js-dynamic-objects.ts | 5 +- .../src/frontend/lowering/json-require.ts | 3 +- .../src/frontend/lowering/lifetime-regions.ts | 3 +- .../src/frontend/lowering/lower-assert.ts | 11 +- .../src/frontend/lowering/lower-calls.ts | 49 ++++---- .../src/frontend/lowering/lower-classes.ts | 28 ++++- .../src/frontend/lowering/lower-dgram.ts | 5 +- .../frontend/lowering/lower-event-emitter.ts | 13 +- .../src/frontend/lowering/lower-exprs.ts | 9 +- .../src/frontend/lowering/lower-functions.ts | 2 +- .../src/frontend/lowering/lower-inspect.ts | 7 +- .../src/frontend/lowering/lower-mixins.ts | 3 +- .../src/frontend/lowering/lower-mock.ts | 3 +- .../frontend/lowering/lower-modules.test.ts | 4 +- .../src/frontend/lowering/lower-modules.ts | 15 ++- .../src/frontend/lowering/lower-namespaces.ts | 11 +- .../src/frontend/lowering/lower-server.ts | 13 +- .../src/frontend/lowering/lower-stdlib.ts | 2 +- .../src/frontend/lowering/lower-stream.ts | 15 +-- .../src/frontend/lowering/lower-timers.ts | 7 +- .../src/frontend/lowering/lowerer.test.ts | 30 +++-- .../compiler/src/frontend/lowering/lowerer.ts | 107 ++++++++++++++--- .../src/frontend/lowering/native-ffi.ts | 2 +- .../lowering/object-enumeration-receiver.ts | 3 +- .../src/frontend/lowering/pairs-snapshot.ts | 3 +- .../lowering/promise-executor-adapter.ts | 3 +- .../lowering/require-initialization.ts | 3 +- .../src/frontend/lowering/stable-names.ts | 48 ++++++++ .../src/frontend/lowering/strict-equality.ts | 3 +- .../frontend/lowering/structural-positions.ts | 111 +++++++++++++++++ packages/compiler/src/frontend/ts7/ast.ts | 90 +++++++++++++- .../compiler/src/frontend/type-mapper.test.ts | 2 +- packages/compiler/src/frontend/type-mapper.ts | 93 +++++++++++++-- .../test/array-pipeline-fusion.test.ts | 2 +- .../test/format-float-arguments.test.ts | 2 +- .../test/in-runtime-key-emission.test.ts | 2 +- packages/compiler/test/stable-names.test.ts | 112 ++++++++++++++++++ .../compiler/test/type-mapper-unions.test.ts | 3 +- 87 files changed, 900 insertions(+), 262 deletions(-) create mode 100644 packages/compiler/src/frontend/lowering/stable-names.ts create mode 100644 packages/compiler/src/frontend/lowering/structural-positions.ts create mode 100644 packages/compiler/test/stable-names.test.ts diff --git a/package.json b/package.json index 5cc30d9f8..d1a8e34ae 100644 --- a/package.json +++ b/package.json @@ -20,7 +20,7 @@ "test:test262": "tsx tests/test262/run.ts", "test:test262:fetch": "node tests/test262/fetch.mjs", "test:cache-identity": "node tests/harness/cache-identity.mjs", - "test:lowering-order": "node scripts/lowering-order.mjs --fail-on content", + "test:lowering-order": "node scripts/lowering-order.mjs --fail-on names", "test:sandbox": "node scripts/sandbox-test.mjs", "test:sandbox:image": "node scripts/sandbox-image.mjs", "test:watch": "vitest", diff --git a/packages/compiler/src/contracts/check.ts b/packages/compiler/src/contracts/check.ts index 5934624bf..c80468961 100644 --- a/packages/compiler/src/contracts/check.ts +++ b/packages/compiler/src/contracts/check.ts @@ -174,7 +174,8 @@ class ContractChecker { return `${owner}.${method[2]}`; } if (fn?.sourceName !== undefined && fn.sourceName !== "") return fn.sourceName; - if (fn !== undefined && /^%fn\d+$/.test(fnName)) return `the function at ${this.where(fn.loc)}`; + if (fn !== undefined && /^%fn\.[0-9a-f]{12}$/.test(fnName)) + return `the function at ${this.where(fn.loc)}`; return fnName.replace(/^%/, ""); } diff --git a/packages/compiler/src/frontend/lowering/array-indexed-mutation.ts b/packages/compiler/src/frontend/lowering/array-indexed-mutation.ts index 6d539212e..0ded460da 100644 --- a/packages/compiler/src/frontend/lowering/array-indexed-mutation.ts +++ b/packages/compiler/src/frontend/lowering/array-indexed-mutation.ts @@ -9,6 +9,7 @@ import { type SrcLoc, typeEquals, } from "../../ir/ir.js"; +import { keyedHelperName } from "./stable-names.js"; import { numLit, varRef } from "../../ir/build.js"; import { typeKey } from "../type-mapper.js"; import type { Lowerer } from "./lowerer.js"; @@ -125,7 +126,7 @@ export function lowerArrayFill( writeNull; let name = lowerer.arrHofHelpers.get(key); if (!name) { - name = "%arr.fill." + lowerer.arrHofHelpers.size; + name = keyedHelperName(lowerer, "%arr.fill", key); lowerer.arrHofHelpers.set(key, name); const a = varRef("a.0", arrType, loc); const n = varRef("n.0", F64, loc); diff --git a/packages/compiler/src/frontend/lowering/array-values.ts b/packages/compiler/src/frontend/lowering/array-values.ts index 0ca8503df..314cdfd24 100644 --- a/packages/compiler/src/frontend/lowering/array-values.ts +++ b/packages/compiler/src/frontend/lowering/array-values.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { InternalCompilerError } from "../../errors.js"; import { dynUndefinedExpr, helperLoc, varRef } from "../../ir/build.js"; import { @@ -252,7 +253,7 @@ export function lowerSafeIndexRead( let name = lowerer.arrHofHelpers.get(key); if (!name) { const at = helperLoc(loc); - name = `%arr.idxOr.${lowerer.arrHofHelpers.size}`; + name = keyedHelperName(lowerer, "%arr.idxOr", key); lowerer.arrHofHelpers.set(key, name); const arrT = arr.type; lowerer.liftedFns.push({ @@ -298,7 +299,7 @@ export function lowerSafeBytesRead( let name = lowerer.arrHofHelpers.get(key); if (!name) { const at = helperLoc(loc); - name = `%bytes.idxOr.${lowerer.arrHofHelpers.size}`; + name = keyedHelperName(lowerer, "%bytes.idxOr", key); lowerer.arrHofHelpers.set(key, name); const b = varRef("b.0", bytesT, at); const i = varRef("i.0", F64, at); diff --git a/packages/compiler/src/frontend/lowering/builtins/arguments.ts b/packages/compiler/src/frontend/lowering/builtins/arguments.ts index 7f862f603..d2fc430dd 100644 --- a/packages/compiler/src/frontend/lowering/builtins/arguments.ts +++ b/packages/compiler/src/frontend/lowering/builtins/arguments.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { BYTES_U8, BOOL, @@ -72,7 +73,7 @@ export function lowerOptionalNumberPredicate( const key = `number.optionalPredicate:${fn}:${typeKey(widened)}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%number.optionalPredicate.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%number.optionalPredicate", key); lowerer.valueHelpers.set(key, helper); const input = varRef("value.0", widened, loc); lowerer.liftedFns.push({ diff --git a/packages/compiler/src/frontend/lowering/builtins/child-process-async.ts b/packages/compiler/src/frontend/lowering/builtins/child-process-async.ts index 5590fbe9f..d0991dce5 100644 --- a/packages/compiler/src/frontend/lowering/builtins/child-process-async.ts +++ b/packages/compiler/src/frontend/lowering/builtins/child-process-async.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { recordToEnvPairs } from "./environment.js"; import { lowerChildArgsArg } from "./child-process.js"; import { boolLit, numLit, varRef } from "../../../ir/build.js"; @@ -218,7 +219,7 @@ function execFileAsyncHelper( const key = shell ? "execAsync" : "execFileAsync"; const existing = lowerer.valueHelpers.get(key); if (existing) return { name: existing, shapeId, envShapeId }; - const name = `%${key}.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, `%${key}`, key); lowerer.valueHelpers.set(key, name); const recT: IrType = { kind: "record", shapeId }; const envRecT: IrType = { kind: "record", shapeId: envShapeId }; diff --git a/packages/compiler/src/frontend/lowering/builtins/child-process-sync.ts b/packages/compiler/src/frontend/lowering/builtins/child-process-sync.ts index 24adcc1ba..b9858e768 100644 --- a/packages/compiler/src/frontend/lowering/builtins/child-process-sync.ts +++ b/packages/compiler/src/frontend/lowering/builtins/child-process-sync.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { recordToEnvPairs } from "./environment.js"; import { lowerChildArgsArg } from "./child-process.js"; import { boolLit, numLit, strLit, varRef } from "../../../ir/build.js"; @@ -541,7 +542,7 @@ function execStdioModeHelper( const key = `cp.stdiomode:${shapeId}:${fd}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = `%cp.stdioMode.${fd}.${lowerer.arrHofHelpers.size}`; + const name = keyedHelperName(lowerer, `%cp.stdioMode.${fd}`, key); lowerer.arrHofHelpers.set(key, name); const optsT: IrType = { kind: "record", shapeId }; diff --git a/packages/compiler/src/frontend/lowering/builtins/disposable-stack.ts b/packages/compiler/src/frontend/lowering/builtins/disposable-stack.ts index 1b9a9c03a..375c3f1e7 100644 --- a/packages/compiler/src/frontend/lowering/builtins/disposable-stack.ts +++ b/packages/compiler/src/frontend/lowering/builtins/disposable-stack.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import * as ts from "../../ts7/adapter.js"; import { type Lowerer } from "../lowerer.js"; import { locOf } from "../../program.js"; @@ -84,7 +85,7 @@ export function lowerDisposableStackUseCall( const key = `disposableStack.use:${className}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%disposableStack.use.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%disposableStack.use", key); lowerer.valueHelpers.set(key, helper); const context = newFnCtx(false, null, null, VOID); lowerer.fnStack.push(context); diff --git a/packages/compiler/src/frontend/lowering/builtins/filesystem.ts b/packages/compiler/src/frontend/lowering/builtins/filesystem.ts index 0e1c062c5..6b988c491 100644 --- a/packages/compiler/src/frontend/lowering/builtins/filesystem.ts +++ b/packages/compiler/src/frontend/lowering/builtins/filesystem.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { dynUndefinedExpr, boolLit, numLit, varRef } from "../../../ir/build.js"; import * as ts from "../../ts7/adapter.js"; import { type Lowerer, ladderFenceExpr } from "../lowerer.js"; @@ -442,7 +443,7 @@ export function lowerStringOrBytesWrite( const key = `fs.${append ? "append" : "write"}:${dataType.unionId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%fs.writeData.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%fs.writeData", key); lowerer.valueHelpers.set(key, helper); const body: IrStmt[] = []; for (let tag = 0; tag < arms.length; tag++) { diff --git a/packages/compiler/src/frontend/lowering/builtins/json.ts b/packages/compiler/src/frontend/lowering/builtins/json.ts index 7eb8aa9b2..64f829865 100644 --- a/packages/compiler/src/frontend/lowering/builtins/json.ts +++ b/packages/compiler/src/frontend/lowering/builtins/json.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { isDateJsonSource } from "./dates.js"; import { dynUndefinedExpr, varRef } from "../../../ir/build.js"; import { InternalCompilerError } from "../../../errors.js"; @@ -253,7 +254,7 @@ function lowerOptionalStringifyRoot( const key = `json.optionalString:${value.type.unionId}:${JSON.stringify(indent)}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%json.optionalString.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%json.optionalString", key); lowerer.valueHelpers.set(key, helper); const input = varRef("value.0", value.type, loc); const serialized: IrExpr = { diff --git a/packages/compiler/src/frontend/lowering/builtins/operating-system.ts b/packages/compiler/src/frontend/lowering/builtins/operating-system.ts index c10465039..ee189a1f3 100644 --- a/packages/compiler/src/frontend/lowering/builtins/operating-system.ts +++ b/packages/compiler/src/frontend/lowering/builtins/operating-system.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { numLit, strLit, varRef } from "../../../ir/build.js"; import * as ts from "../../ts7/adapter.js"; import { type Lowerer } from "../lowerer.js"; @@ -219,7 +220,7 @@ export function lowerOsCpusCall(lowerer: Lowerer, call: ts.CallExpression, loc: const key = `os.cpus:${typeKey(result)}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%os.cpus.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%os.cpus", key); lowerer.valueHelpers.set(key, helper); const index = varRef("i.0", F64, loc); const field = (k: number): IrExpr => ({ @@ -346,7 +347,7 @@ export function lowerPathParseCall( const key = `${fn}:${typeKey(result)}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%path.parse.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%path.parse", key); lowerer.valueHelpers.set(key, helper); const parts = varRef("parts.0", arrayOf(STRING), loc); lowerer.liftedFns.push({ @@ -448,7 +449,7 @@ export function lowerPathFormatCall( const key = `${fn}:${typeKey(recordT)}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%path.format.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%path.format", key); lowerer.valueHelpers.set(key, helper); const object = varRef("object.0", recordT, loc); const read = (name: string): IrExpr => { diff --git a/packages/compiler/src/frontend/lowering/builtins/performance.ts b/packages/compiler/src/frontend/lowering/builtins/performance.ts index 72304e6a9..bae525c17 100644 --- a/packages/compiler/src/frontend/lowering/builtins/performance.ts +++ b/packages/compiler/src/frontend/lowering/builtins/performance.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import * as ts from "../../ts7/adapter.js"; import { type Lowerer } from "../lowerer.js"; import { locOf } from "../../program.js"; @@ -330,7 +331,7 @@ function lowerPerfTimelineCall( const key = `perf.${many ? "entries" : timeline.fn}:${typeKey(result)}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%perf.${many ? "entries" : member}.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, `%perf.${many ? "entries" : member}`, key); lowerer.valueHelpers.set(key, helper); const argsRef = varRef("a.0", DYN, loc); const whichRef = varRef("w.0", F64, loc); @@ -461,7 +462,7 @@ export function perfEntryTag( const key = `perf.tag:${entryT.shapeId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%perf.tag.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%perf.tag", key); lowerer.valueHelpers.set(key, helper); const e = varRef("e.0", entryT, loc); lowerer.liftedFns.push({ diff --git a/packages/compiler/src/frontend/lowering/builtins/process.ts b/packages/compiler/src/frontend/lowering/builtins/process.ts index 25653f541..842f42b57 100644 --- a/packages/compiler/src/frontend/lowering/builtins/process.ts +++ b/packages/compiler/src/frontend/lowering/builtins/process.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { stdinKeypressListener } from "./readline.js"; import { envSnapshotHelper, lowerProcessLoadEnvFile } from "./environment.js"; import { dynUndefinedExpr, boolLit, numLit, strLit, varRef } from "../../../ir/build.js"; @@ -1561,7 +1562,7 @@ export function lowerProcessMethodCall( const key = `${prefix}usage.diff:${prevT.shapeId}:${t.shapeId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%${prefix}usage.diff.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, `%${prefix}usage.diff`, key); lowerer.valueHelpers.set(key, helper); const pRef: IrExpr = { kind: "varRef", localId: "p.0", type: prevT, loc }; const fieldOf = (name: string): IrExpr => ({ @@ -1636,7 +1637,7 @@ export function lowerProcessMethodCall( const key = `process.memoryUsage:${t.shapeId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%process.memoryUsage.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%process.memoryUsage", key); lowerer.valueHelpers.set(key, helper); lowerer.liftedFns.push({ name: helper, diff --git a/packages/compiler/src/frontend/lowering/builtins/promises.ts b/packages/compiler/src/frontend/lowering/builtins/promises.ts index 668ef01f8..75e527aa5 100644 --- a/packages/compiler/src/frontend/lowering/builtins/promises.ts +++ b/packages/compiler/src/frontend/lowering/builtins/promises.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { checkedPromiseAll, thenReader } from "../checked-promise-all.js"; import { InternalCompilerError } from "../../../errors.js"; import * as ts from "../../ts7/adapter.js"; @@ -55,7 +56,7 @@ function lowerTuplePromiseAll( const key = `${elems.map((e) => typeKey(e.type)).join(",")}->${typeKey(resultT.inner)}`; let name = lowerer.arrHofHelpers.get(`promise.allTuple:${key}`); if (name === undefined) { - name = `%promise.allTuple.${lowerer.arrHofHelpers.size}`; + name = keyedHelperName(lowerer, "%promise.allTuple", `promise.allTuple:${key}`); lowerer.arrHofHelpers.set(`promise.allTuple:${key}`, name); const ctx = newFnCtx(false, null, null, resultT.inner); ctx.isAsync = true; @@ -557,7 +558,7 @@ export function lowerPromiseStaticCall( const key = `promise.try:${typeKey(f.type)}:${args.map((a) => typeKey(a.type)).join(",")}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%promise.try.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%promise.try", key); lowerer.arrHofHelpers.set(key, helper); const fRef: IrExpr = { kind: "varRef", localId: "f.0", type: f.type, loc }; const argLocals = args.map((a, i) => ({ id: `a${i}.0`, name: `a${i}`, type: a.type })); diff --git a/packages/compiler/src/frontend/lowering/builtins/promisify-callback.ts b/packages/compiler/src/frontend/lowering/builtins/promisify-callback.ts index 822a4fecc..b4dbbf513 100644 --- a/packages/compiler/src/frontend/lowering/builtins/promisify-callback.ts +++ b/packages/compiler/src/frontend/lowering/builtins/promisify-callback.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import * as ts from "../../ts7/adapter.js"; import { type Lowerer } from "../lowerer.js"; import { varRef } from "../../../ir/build.js"; @@ -170,7 +171,7 @@ function promisifyMaker(lowerer: Lowerer, shape: CallbackShape, loc: SrcLoc): st const key = `promisify:${typeKey(shape.fnT)}=>${typeKey(shape.resultT)}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const base = `%promisify.${lowerer.arrHofHelpers.size}`; + const base = keyedHelperName(lowerer, "%promisify", key); lowerer.arrHofHelpers.set(key, base); const { fnT, resultT, args, callbackT, callbackParamT, inner, error } = shape; const promiseT = resultT.ret; diff --git a/packages/compiler/src/frontend/lowering/builtins/text-codecs.ts b/packages/compiler/src/frontend/lowering/builtins/text-codecs.ts index 7229d5b84..8d47c8e3a 100644 --- a/packages/compiler/src/frontend/lowering/builtins/text-codecs.ts +++ b/packages/compiler/src/frontend/lowering/builtins/text-codecs.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { isBuiltinClassInstance } from "./receiver-types.js"; import { strLit, varRef, dynUndefinedExpr } from "../../../ir/build.js"; import { staticTextDecoderEncoding } from "../text-decoder-encoding.js"; @@ -129,7 +130,7 @@ function stringDecoderHelper( const key = `strdec.${op}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%strdec.${op}.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, `%strdec.${op}`, key); lowerer.valueHelpers.set(key, name); const recT: IrType = { kind: "record", shapeId }; diff --git a/packages/compiler/src/frontend/lowering/builtins/timers.ts b/packages/compiler/src/frontend/lowering/builtins/timers.ts index 2d531663f..d7cbd63b5 100644 --- a/packages/compiler/src/frontend/lowering/builtins/timers.ts +++ b/packages/compiler/src/frontend/lowering/builtins/timers.ts @@ -85,7 +85,7 @@ export function lowerTimersPromisesSetInterval( const genT = timersPromisesIntervalType(lowerer, expr); if (genT === null) lowerer.badType(expr, lowerer.typeOf(expr)); const yielded = lowerer.coerceInto(valueNode, value, genT.yieldT); - const fnName = `%fn${lowerer.lambdaCounter++}_tpInterval`; + const fnName = lowerer.closureName(loc, "_tpInterval"); const msParam: IrLocal = { id: "%tp.ms", name: "delay", type: F64, mutable: false }; const valueParam: IrLocal = { id: "%tp.value", name: "value", type: genT.yieldT, mutable: false }; const promiseVoid: IrType = { kind: "promise", inner: VOID }; diff --git a/packages/compiler/src/frontend/lowering/builtins/url.ts b/packages/compiler/src/frontend/lowering/builtins/url.ts index dca8a7cc0..2a77fa85c 100644 --- a/packages/compiler/src/frontend/lowering/builtins/url.ts +++ b/packages/compiler/src/frontend/lowering/builtins/url.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { nodeThrowExpr, countedFor, strLit, varRef, dynUndefinedExpr } from "../../../ir/build.js"; import * as ts from "../../ts7/adapter.js"; import { type Lowerer, own } from "../lowerer.js"; @@ -292,7 +293,7 @@ function searchParamsFromTuples( const key = `sp.fromTuples:${row.shapeId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%sp.fromTuples.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%sp.fromTuples", key); lowerer.valueHelpers.set(key, helper); const pairsT = init.type; const sp = (): IrExpr => varRef("sp.0", SEARCH_PARAMS_T, loc); @@ -372,7 +373,7 @@ function lowerOptionalStringSearchParams( const key = `sp.optionalString:${init.type.unionId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%sp.optionalString.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%sp.optionalString", key); lowerer.valueHelpers.set(key, helper); const value = varRef("init.0", init.type, loc); lowerer.liftedFns.push({ @@ -678,7 +679,7 @@ function lowerSpForEachCall( const key = `${arity}:${typeKey(fnRet)}`; let helper = lowerer.spHofHelpers.get(key); if (!helper) { - helper = `%sp.forEach.${lowerer.spHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%sp.forEach", key); lowerer.spHofHelpers.set(key, helper); lowerer.liftedFns.push(buildSpForEachFn(helper, arity, fnRet, loc)); } diff --git a/packages/compiler/src/frontend/lowering/builtins/v8.ts b/packages/compiler/src/frontend/lowering/builtins/v8.ts index 3582ce8ae..989a61a3f 100644 --- a/packages/compiler/src/frontend/lowering/builtins/v8.ts +++ b/packages/compiler/src/frontend/lowering/builtins/v8.ts @@ -5,6 +5,7 @@ * spirit of process.memoryUsage(): approximate values, not V8 heap * figures (a compiled binary embeds no V8 engine). Every other member * fences at its use with the by-design reason (builtinFenceHintOf). */ +import { keyedHelperName } from "../stable-names.js"; import { numLit } from "../../../ir/build.js"; import * as ts from "../../ts7/adapter.js"; import { type Lowerer } from "../lowerer.js"; @@ -55,7 +56,7 @@ export function lowerV8HeapStatisticsCall( const key = `v8.getHeapStatistics:${t.shapeId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%v8.getHeapStatistics.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%v8.getHeapStatistics", key); lowerer.valueHelpers.set(key, helper); const sample = (index: number): IrExpr => ({ kind: "libCall", diff --git a/packages/compiler/src/frontend/lowering/call-arguments.ts b/packages/compiler/src/frontend/lowering/call-arguments.ts index 49f7c8ec0..060ffe9d2 100644 --- a/packages/compiler/src/frontend/lowering/call-arguments.ts +++ b/packages/compiler/src/frontend/lowering/call-arguments.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { forwardedTupleType, pureForwardedValues, stripTypeWrappers } from "./typed-arguments.js"; import { dynUndefinedExpr } from "../../ir/build.js"; import { InternalCompilerError } from "../../errors.js"; @@ -753,7 +754,7 @@ function holeReadingLift(lowerer: Lowerer, from: IrType, to: IrType, loc: SrcLoc const key = `arr.holes:${typeKey(elem)}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%arr.holes.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, "%arr.holes", key); lowerer.valueHelpers.set(key, name); lowerer.liftedFns.push( buildArrayConversion( diff --git a/packages/compiler/src/frontend/lowering/call-signatures.ts b/packages/compiler/src/frontend/lowering/call-signatures.ts index 34343ad27..dacb4d324 100644 --- a/packages/compiler/src/frontend/lowering/call-signatures.ts +++ b/packages/compiler/src/frontend/lowering/call-signatures.ts @@ -849,7 +849,10 @@ export function collectSignatureInner(lowerer: Lowerer, decl: ts.FunctionDeclara lowerer.genericFnsBySymbol.set(symbol, { decl, baseName: nameText, - qualifiedName: lowerer.qualify(ts.getSourceFileOfNode(decl), nsPathPrefix(decl) + nameText), + qualifiedName: lowerer.qualify( + ts.getSourceFileOfNode(decl), + nsPathPrefix(lowerer, decl) + nameText, + ), typeParams: [], instances: new Map(), implicitParams: implicit, @@ -897,7 +900,7 @@ export function collectSignatureInner(lowerer: Lowerer, decl: ts.FunctionDeclara // "%default" spelling ('%' cannot appear in a user identifier). name: lowerer.qualify( ts.getSourceFileOfNode(decl), - nsPathPrefix(decl) + (decl.name?.text ?? "%default"), + nsPathPrefix(lowerer, decl) + (decl.name?.text ?? "%default"), ), params, returnType, diff --git a/packages/compiler/src/frontend/lowering/class-assertions.ts b/packages/compiler/src/frontend/lowering/class-assertions.ts index 900c32426..52654fab8 100644 --- a/packages/compiler/src/frontend/lowering/class-assertions.ts +++ b/packages/compiler/src/frontend/lowering/class-assertions.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { nodeThrowExpr, varRef } from "../../ir/build.js"; import { BOOL, @@ -122,7 +123,7 @@ export function checkedClassAssertion( const key = `classassert:${typeKey(source.type)}:${typeKey(target)}`; let name = lowerer.coercions.retags.get(key); if (!name) { - name = `%class.assert.${lowerer.coercions.retags.size}`; + name = keyedHelperName(lowerer, "%class.assert", key); lowerer.coercions.retags.set(key, name); const input = varRef("value.0", source.type, loc); const body: IrStmt[] = []; @@ -228,7 +229,7 @@ export function checkedClassUnionAssertion( const key = `classunionassert:${typeKey(value.type)}:${typeKey(target)}`; let name = lowerer.coercions.retags.get(key); if (!name) { - name = `%class.assert.${lowerer.coercions.retags.size}`; + name = keyedHelperName(lowerer, "%class.assert", key); lowerer.coercions.retags.set(key, name); const input = varRef("value.0", value.type, loc); const locals = [{ id: "value.0", name: "value", type: value.type, mutable: false }]; diff --git a/packages/compiler/src/frontend/lowering/class-unions.ts b/packages/compiler/src/frontend/lowering/class-unions.ts index f52026ba4..0021b2cf8 100644 --- a/packages/compiler/src/frontend/lowering/class-unions.ts +++ b/packages/compiler/src/frontend/lowering/class-unions.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import * as ts from "../ts7/adapter.js"; import { BOOL, typeKey, type IrExpr, type IrStmt, type IrType } from "../../ir/ir.js"; import { nodeThrowExpr, varRef } from "../../ir/build.js"; @@ -132,7 +133,7 @@ export function narrowClassUnion( const key = `classUnion:${source.className}:${target.unionId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%class.union.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%class.union", key); lowerer.valueHelpers.set(key, helper); const input = varRef("value.0", source, loc); // Rank by ancestry before sorting: returning zero for unrelated pairs diff --git a/packages/compiler/src/frontend/lowering/coercions/function-adapters.ts b/packages/compiler/src/frontend/lowering/coercions/function-adapters.ts index ffdac19f0..fe3c14605 100644 --- a/packages/compiler/src/frontend/lowering/coercions/function-adapters.ts +++ b/packages/compiler/src/frontend/lowering/coercions/function-adapters.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { dynUndefinedExpr } from "../../../ir/build.js"; import { buildFunctionAdapter } from "./builders.js"; import { InternalCompilerError } from "../../../errors.js"; @@ -33,7 +34,7 @@ export function funcReturnWidthAdapter( const key = `fn:${typeKey(fromT.ret.elem)}:${typeKey(toT.ret.elem)}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%fn.width.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, "%fn.width", key); lowerer.valueHelpers.set(key, name); lowerer.freshClosureAdapters.add(name); // The returned closure's body: call the captured original, width-map. @@ -163,7 +164,7 @@ function restPackingAdapter( const key = `fnrestadapt:${typeKey(fromT)}:${typeKey(toT)}`; const existing = lowerer.coercions.retags.get(key); if (existing) return existing; - const name = `%fn.adapt.${lowerer.coercions.retags.size}`; + const name = keyedHelperName(lowerer, "%fn.adapt", key); lowerer.coercions.retags.set(key, name); lowerer.freshClosureAdapters.add(name); const fixed = fromT.params.length - 1; @@ -220,7 +221,7 @@ function funcIntoDynRestAdapter( const key = `fnadapt:${typeKey(fromT)}:${typeKey(toT)}`; const existing = lowerer.coercions.retags.get(key); if (existing) return existing; - const name = `%fn.adapt.${lowerer.coercions.retags.size}`; + const name = keyedHelperName(lowerer, "%fn.adapt", key); lowerer.coercions.retags.set(key, name); lowerer.freshClosureAdapters.add(name); const params: IrParam[] = [{ localId: "rest.0", name: "args", type: DYN }]; @@ -376,7 +377,7 @@ export function funcCoerceAdapter( const key = `fnadapt:${typeKey(fromT)}:${typeKey(toT)}`; const existing = lowerer.coercions.retags.get(key); if (existing) return existing; - const name = `%fn.adapt.${lowerer.coercions.retags.size}`; + const name = keyedHelperName(lowerer, "%fn.adapt", key); lowerer.coercions.retags.set(key, name); lowerer.freshClosureAdapters.add(name); const params: IrParam[] = toT.params.map((t, i) => ({ @@ -604,7 +605,7 @@ export function spawnResFnAdapter( const key = `fnspawn:${typeKey(fromT)}:${typeKey(toT)}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%fnval.spawnres.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, "%fnval.spawnres", key); lowerer.valueHelpers.set(key, name); lowerer.freshClosureAdapters.add(name); const params: IrParam[] = toT.params.map((p, i) => ({ diff --git a/packages/compiler/src/frontend/lowering/coercions/structural.ts b/packages/compiler/src/frontend/lowering/coercions/structural.ts index 496a29607..5b5e283b3 100644 --- a/packages/compiler/src/frontend/lowering/coercions/structural.ts +++ b/packages/compiler/src/frontend/lowering/coercions/structural.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { constructedValue } from "../constructor-returns.js"; import { dynUndefinedExpr, varRef } from "../../../ir/build.js"; import type { FieldLift } from "./structural-plans.js"; @@ -253,7 +254,7 @@ export function unionRecordWidthHelper( const key = `unionWidth:${fromId}:${target.shapeId}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%union.record.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, "%union.record", key); lowerer.valueHelpers.set(key, name); const type: IrType = { kind: "union", unionId: fromId }; const value = varRef("value.0", type, loc); @@ -312,7 +313,7 @@ export function recordWidthHelper( const key = `rec:${fromId}:${toId}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%rec.width.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, "%rec.width", key); // Interned BEFORE the body builds: a recursive nested-width field // (self-referential shapes) resolves to this helper itself. lowerer.valueHelpers.set(key, name); @@ -341,7 +342,7 @@ export function tupleArrayWidthHelper( const key = `tuparr:${fromId}:${typeKey(toT.elem)}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%tup.arr.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, "%tup.arr", key); lowerer.valueHelpers.set(key, name); const fromT: IrType = { kind: "record", shapeId: fromId }; const t: IrExpr = { kind: "varRef", localId: "t.0", type: fromT, loc }; @@ -388,7 +389,7 @@ export function emptyArrayLiftHelper( const key = `emptyarr:${typeKey(fromT.elem)}:${typeKey(toT.elem)}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%arr.empty.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, "%arr.empty", key); lowerer.valueHelpers.set(key, name); const a: IrExpr = { kind: "varRef", localId: "a.0", type: fromT, loc }; lowerer.liftedFns.push({ @@ -452,7 +453,7 @@ export function arrayWidthHelper( const key = `arr:${typeKey(fromElem)}:${typeKey(toElem)}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%arr.width.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, "%arr.width", key); lowerer.valueHelpers.set(key, name); const arrT: IrType = { kind: "array", elem: fromElem }; const outT: IrType = { kind: "array", elem: toElem }; @@ -492,7 +493,7 @@ export function objRecordWidthHelper( const key = `obj:${className}:${toId}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%obj.width.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, "%obj.width", key); lowerer.valueHelpers.set(key, name); const fromT: IrType = { kind: "object", className }; lowerer.liftedFns.push(buildRecordProjection(lowerer, name, fromT, to, plan, loc)); @@ -517,7 +518,7 @@ export function recordClassWidthHelper( const key = `cls:${fromId}:${className}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%cls.width.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, "%cls.width", key); lowerer.valueHelpers.set(key, name); lowerer.noteEdge(`%${className}.constructor`); const fromT: IrType = { kind: "record", shapeId: fromId }; diff --git a/packages/compiler/src/frontend/lowering/coercions/unions.ts b/packages/compiler/src/frontend/lowering/coercions/unions.ts index 06c0af9c6..434e687a5 100644 --- a/packages/compiler/src/frontend/lowering/coercions/unions.ts +++ b/packages/compiler/src/frontend/lowering/coercions/unions.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { buildUnionNarrow, unionNarrowFailureMessage } from "../union-narrow.js"; import { isSafeToRepeat } from "../expressions/evaluation-safety.js"; import { nodeThrowExpr } from "../../../ir/build.js"; @@ -147,7 +148,7 @@ export function strandedUnitTrap( const key = `strandunit:${typeKey(expected)}:${expr.type.kind}`; let name = lowerer.coercions.retags.get(key); if (!name) { - name = `%unit.strand.${lowerer.coercions.retags.size}`; + name = keyedHelperName(lowerer, "%unit.strand", key); lowerer.coercions.retags.set(key, name); lowerer.liftedFns.push({ name, @@ -227,7 +228,7 @@ export function strandedCoercionTrap( const key = `strand:${expected.unionId}:${typeKey(src)}`; let name = lowerer.coercions.retags.get(key); if (!name) { - name = `%union.strand.${lowerer.coercions.retags.size}`; + name = keyedHelperName(lowerer, "%union.strand", key); lowerer.coercions.retags.set(key, name); const toT: IrType = { kind: "union", unionId: expected.unionId }; lowerer.liftedFns.push({ @@ -275,7 +276,7 @@ export function recordUnionWrapHelper( const key = `recordWrap:${source.shapeId}:${toId}`; const existing = lowerer.coercions.retags.get(key); if (existing) return existing; - const name = `%record.wrap.${lowerer.coercions.retags.size}`; + const name = keyedHelperName(lowerer, "%record.wrap", key); lowerer.coercions.retags.set(key, name); lowerer.liftedFns.push( buildRecordUnionWrap(name, source, to, plan, loc, (lift, value, dst) => @@ -307,7 +308,7 @@ export function recordUnionRouteHelper( (from, dst) => lowerer.widthLiftPlan(from, dst), ); if (!plan) return null; - const name = `%record.route.${lowerer.coercions.retags.size}`; + const name = keyedHelperName(lowerer, "%record.route", key); lowerer.coercions.retags.set(key, name); lowerer.liftedFns.push( buildRecordUnionWrap(name, source, to, plan, loc, (lift, value, dst) => @@ -352,7 +353,7 @@ export function unionRetagHelper( }); const key = `${fromId}:${toId}:${stranded.join(".")}`; const existing = lowerer.coercions.retags.get(key); - const name = existing ?? `%union.retag.${lowerer.coercions.retags.size}`; + const name = existing ?? keyedHelperName(lowerer, "%union.retag", key); if (!existing) { lowerer.coercions.retags.set(key, name); lowerer.liftedFns.push( @@ -410,7 +411,7 @@ export function narrowedArmHelper( lowerer.coercions.checkedNarrows.add(existing); return existing; } - const name = `%union.narrow.${lowerer.coercions.narrows.size}`; + const name = keyedHelperName(lowerer, "%union.narrow", key); lowerer.coercions.narrows.set(key, name); lowerer.coercions.checkedNarrows.add(name); const fn = buildUnionNarrow(name, from, target, loc, (type) => lowerer.fmt(type)); @@ -587,7 +588,7 @@ export function deferredReadHelper( const key = `deferred:${fromId}:${tag}`; const existing = lowerer.coercions.narrows.get(key); if (existing) return existing; - const name = `%deferred.read.${lowerer.coercions.narrows.size}`; + const name = keyedHelperName(lowerer, "%deferred.read", key); lowerer.coercions.narrows.set(key, name); const dflt: IrExpr = target.kind === "bool" diff --git a/packages/compiler/src/frontend/lowering/collection-ingestion.ts b/packages/compiler/src/frontend/lowering/collection-ingestion.ts index 5d14d5492..8fe2a6bbb 100644 --- a/packages/compiler/src/frontend/lowering/collection-ingestion.ts +++ b/packages/compiler/src/frontend/lowering/collection-ingestion.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import * as ts from "../ts7/adapter.js"; import { InternalCompilerError } from "../../errors.js"; import { typeKey } from "../type-mapper.js"; @@ -197,7 +198,7 @@ export function ingestCollection( const key = `ingest:${input.collection ? typeKey(input.collection) + ":" + input.selection : "cursor:" + typeKey(input.element)}:${typeKey(destination)}:${mapper ? typeKey(mapper.type) : "copy"}`; let name = lowerer.arrHofHelpers.get(key); if (!name) { - name = `%collection.ingest.${lowerer.arrHofHelpers.size}`; + name = keyedHelperName(lowerer, "%collection.ingest", key); lowerer.arrHofHelpers.set(key, name); const context = newFnCtx(false, null, null, destination); lowerer.fnStack.push(context); diff --git a/packages/compiler/src/frontend/lowering/containers/array-callbacks.ts b/packages/compiler/src/frontend/lowering/containers/array-callbacks.ts index eb99592bb..7ca69d9ba 100644 --- a/packages/compiler/src/frontend/lowering/containers/array-callbacks.ts +++ b/packages/compiler/src/frontend/lowering/containers/array-callbacks.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { boolLit, countedFor, numLit, varRef } from "../../../ir/build.js"; import { transformStmtList } from "../../../ir/traverse.js"; import type { ScrDiagnostic } from "../../../diagnostics/diagnostic.js"; @@ -506,7 +507,7 @@ function arrayHofHelper( const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}:${typeKey(outElem)}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`; + const name = keyedHelperName(lowerer, `%arr.${method}`, key); lowerer.arrHofHelpers.set(key, name); lowerer.arrHofInfo.set(name, { method, elem, fnRet, arity, outElem, present, split: !!fastT }); const fn = buildArrayHofFn( @@ -619,7 +620,7 @@ function arrayUnionHofHelper( const key = `union:${method}:${receiverT.unionId}:${typeKey(callbackT)}:${typeKey(resultT)}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = `%arr.union.${lowerer.arrHofHelpers.size}`; + const name = keyedHelperName(lowerer, "%arr.union", key); lowerer.arrHofHelpers.set(key, name); const receiver = varRef("a.0", receiverT, loc); const callback = varRef("f.0", callbackT, loc); @@ -1204,7 +1205,7 @@ function findHelper( const key = `${method}:${typeKey(elem)}:${typeKey(resultT)}:${typeKey(fnRet)}:${arity}${site}${present ? ":present" : ""}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`; + const name = keyedHelperName(lowerer, `%arr.${method}`, key); lowerer.arrHofHelpers.set(key, name); const arrT = arrayOf(elem); const valueT = callbackValueType(lowerer, elem, present); @@ -1304,7 +1305,7 @@ function findIndexHelper( const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`; + const name = keyedHelperName(lowerer, `%arr.${method}`, key); lowerer.arrHofHelpers.set(key, name); if (!last) lowerer.arrHofInfo.set(name, { @@ -1388,7 +1389,7 @@ function someEveryHelper( const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`; + const name = keyedHelperName(lowerer, `%arr.${method}`, key); lowerer.arrHofHelpers.set(key, name); lowerer.arrHofInfo.set(name, { method, @@ -1587,7 +1588,7 @@ function flatMapHelper( const key = `flatMap:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = `%arr.flatMap.${lowerer.arrHofHelpers.size}`; + const name = keyedHelperName(lowerer, "%arr.flatMap", key); lowerer.arrHofHelpers.set(key, name); lowerer.arrHofInfo.set(name, { method: "flatMapArray", @@ -1829,7 +1830,7 @@ function reduceHelper( const key = `${method}:${typeKey(elem)}:${typeKey(accT)}:${typeKey(fnRet)}:${arity}:${hasInit ? "init" : "seed"}${site}${fastT ? ":split" : ""}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`; + const name = keyedHelperName(lowerer, `%arr.${method}`, key); lowerer.arrHofHelpers.set(key, name); if (method === "reduce") lowerer.arrHofInfo.set(name, { @@ -2121,7 +2122,7 @@ export function lowerArraySortCall( const key = `${method}:${typeKey(elem)}:${arity}${native ? ":native" : ""}${keyed ? `:keyed${order}${reads ? `:field${reads.length}` : ""}` : ""}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%arr.${method}.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, `%arr.${method}`, key); lowerer.arrHofHelpers.set(key, helper); const undefinedTag = elem.kind === "union" ? lowerer.armTag(elem.unionId, UNDEFINED_T) : -1; lowerer.liftedFns.push( @@ -2167,7 +2168,7 @@ function sortKeyReader( const cacheKey = `sortKey:${typeKey(elem)}:${sortKeysId(reads.map((read) => ({ order: 1, read })))}`; let reader = lowerer.arrHofHelpers.get(cacheKey); if (!reader) { - reader = `%arr.sortKey.${lowerer.arrHofHelpers.size}`; + reader = keyedHelperName(lowerer, "%arr.sortKey", cacheKey); lowerer.arrHofHelpers.set(cacheKey, reader); lowerer.liftedFns.push(buildSortKeyFn(reader, elem, reads, loc)); } @@ -2308,7 +2309,7 @@ function dynFlatMapHelper(lowerer: Lowerer, elemT: IrType, arity: number, loc: S const key = `dynflatmap:${typeKey(elemT)}:${arity}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = `%dyn.flatmap.${lowerer.arrHofHelpers.size}`; + const name = keyedHelperName(lowerer, "%dyn.flatmap", key); lowerer.arrHofHelpers.set(key, name); lowerer.liftedFns.push(buildDynFlatMapFn(name, elemT, arity, loc)); return name; @@ -2481,7 +2482,7 @@ function dynFilterHelper(lowerer: Lowerer, elemT: IrType, arity: number, loc: Sr const key = `dynfilter:${typeKey(elemT)}:${arity}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = `%dyn.filter.${lowerer.arrHofHelpers.size}`; + const name = keyedHelperName(lowerer, "%dyn.filter", key); lowerer.arrHofHelpers.set(key, name); lowerer.liftedFns.push(buildDynFilterFn(name, elemT, arity, loc)); return name; @@ -2676,7 +2677,7 @@ export function lowerTuplePredicateCall( const key = `tuple.${method}:${typeKey(receiver.type)}:${typeKey(fnArg.type)}:${typeKey(resultT)}:${arity}${callbackSite(fnArg)}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%tuple.${method}.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, `%tuple.${method}`, key); lowerer.arrHofHelpers.set(key, helper); const v = varRef("v.0", elem, loc); const out = varRef("out.0", resultT, loc); diff --git a/packages/compiler/src/frontend/lowering/containers/array-concat.ts b/packages/compiler/src/frontend/lowering/containers/array-concat.ts index 4f6e4ca43..b4e285ee9 100644 --- a/packages/compiler/src/frontend/lowering/containers/array-concat.ts +++ b/packages/compiler/src/frontend/lowering/containers/array-concat.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { identityPreservingWidening } from "../coercions/identity.js"; import { countedFor, numLit, varRef } from "../../../ir/build.js"; import { @@ -28,7 +29,7 @@ export function arrayConcatHelper( const key = `concat:${typeKey(elem)}:${shape.map((type) => (type ? `a:${typeKey(type)}` : "e")).join(";")}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = `%arr.concat.${lowerer.arrHofHelpers.size}`; + const name = keyedHelperName(lowerer, "%arr.concat", key); const arrT = arrayOf(elem); const params = [ { localId: "a.0", name: "a", type: arrT }, diff --git a/packages/compiler/src/frontend/lowering/containers/array-construction.ts b/packages/compiler/src/frontend/lowering/containers/array-construction.ts index 40e4d6436..1f10640c0 100644 --- a/packages/compiler/src/frontend/lowering/containers/array-construction.ts +++ b/packages/compiler/src/frontend/lowering/containers/array-construction.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { generatorDrain } from "../iterator-adapters.js"; import { identityPreservingWidening } from "../coercions/identity.js"; import { liftedFreshSpread } from "../coercions/fresh-spread.js"; @@ -256,7 +257,7 @@ function appendWidenedArrayValues( const key = `insertValues:${typeKey(sourceType.elem)}:${typeKey(elem)}`; let name = lowerer.arrHofHelpers.get(key); if (!name) { - name = `%arr.insertValues.${lowerer.arrHofHelpers.size}`; + name = keyedHelperName(lowerer, "%arr.insertValues", key); lowerer.arrHofHelpers.set(key, name); const outType = arrayOf(elem); const valueType = arrayValueType(lowerer, source.type.elem); @@ -1035,7 +1036,7 @@ export function lowerArrayFromCall( const key = `fromArray:${typeKey(arrT.elem)}:${typeKey(outElem)}:${typeKey(fnRet)}:${arity}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%arr.fromArray.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%arr.fromArray", key); lowerer.arrHofHelpers.set(key, helper); lowerer.liftedFns.push( buildArrayFromArrayFn(lowerer, helper, arrT.elem, outElem, fnRet, arity, loc), @@ -1122,7 +1123,7 @@ export function lowerArrayFromCall( const key = `fromLen:${typeKey(fnRet)}:${arity}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%arr.fromLen.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%arr.fromLen", key); lowerer.arrHofHelpers.set(key, helper); lowerer.liftedFns.push(buildArrayFromLenFn(helper, fnRet, arity, loc)); } diff --git a/packages/compiler/src/frontend/lowering/containers/array-methods.ts b/packages/compiler/src/frontend/lowering/containers/array-methods.ts index e9a130a2d..44182fbda 100644 --- a/packages/compiler/src/frontend/lowering/containers/array-methods.ts +++ b/packages/compiler/src/frontend/lowering/containers/array-methods.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { liftedFreshSpread } from "../coercions/fresh-spread.js"; import { lowerArrayIteratorValue } from "../iterator-adapters.js"; import { identityPreservingWidening } from "../coercions/identity.js"; @@ -1616,7 +1617,7 @@ function arraySearchHelper( const key = `${method}:${typeKey(elem)}:${typeKey(valueT)}:${typeKey(needleT)}:${directNeedle}:${typeKey(fromT)}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`; + const name = keyedHelperName(lowerer, `%arr.${method}`, key); lowerer.arrHofHelpers.set(key, name); const arrT = arrayOf(elem); const resultT = method === "includes" ? BOOL : F64; @@ -1972,7 +1973,7 @@ export function lowerTupleReadMethodCall( let helper = lowerer.arrHofHelpers.get(key); const resultType = method === "includes" ? BOOL : F64; if (!helper) { - helper = `%tuple.${method}.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, `%tuple.${method}`, key); lowerer.arrHofHelpers.set(key, helper); const params = [ { localId: "a.0", name: "a", type: receiver.type }, @@ -2034,7 +2035,7 @@ export function lowerTupleReadMethodCall( const key = `tuple.slice:${typeKey(receiver.type)}:${args.length}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%tuple.slice.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%tuple.slice", key); lowerer.arrHofHelpers.set(key, helper); const params = [receiver, ...args].map((arg, i) => ({ localId: i === 0 ? "a.0" : `arg.${i}`, @@ -2125,7 +2126,7 @@ export function lowerTupleReadMethodCall( const key = `tuple.${method}:${typeKey(receiver.type)}:${typeKey(fnArg.type)}:${typeKey(outElem)}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%tuple.${method}.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, `%tuple.${method}`, key); lowerer.arrHofHelpers.set(key, helper); const out = varRef("out.0", outType, loc); const result = varRef("r.0", ret, loc); @@ -2253,7 +2254,7 @@ function lowerArrayAtCall( const key = `at:${typeKey(elem)}:${typeKey(resultT)}:${typeKey(index.type)}`; let name = lowerer.arrHofHelpers.get(key); if (!name) { - name = `%arr.at.${lowerer.arrHofHelpers.size}`; + name = keyedHelperName(lowerer, "%arr.at", key); lowerer.arrHofHelpers.set(key, name); const arrT = arrayOf(elem); diff --git a/packages/compiler/src/frontend/lowering/containers/array-pipelines.ts b/packages/compiler/src/frontend/lowering/containers/array-pipelines.ts index cf45a7575..180f40435 100644 --- a/packages/compiler/src/frontend/lowering/containers/array-pipelines.ts +++ b/packages/compiler/src/frontend/lowering/containers/array-pipelines.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { boolLit, countedFor, numLit, varRef } from "../../../ir/build.js"; import { BOOL, @@ -851,7 +852,7 @@ class PipelineFusion { if (!built) return null; let name = this.helpers.get(built.key); if (!name) { - name = `%arr.fused.${this.helpers.size}`; + name = keyedHelperName(this.lowerer, "%arr.fused", built.key); this.helpers.set(built.key, name); this.added.push({ ...built.fn, name }); } diff --git a/packages/compiler/src/frontend/lowering/containers/bytes.ts b/packages/compiler/src/frontend/lowering/containers/bytes.ts index 9d8def80e..8a4364754 100644 --- a/packages/compiler/src/frontend/lowering/containers/bytes.ts +++ b/packages/compiler/src/frontend/lowering/containers/bytes.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { boolLit, dynUndefinedExpr, numLit, varRef } from "../../../ir/build.js"; import { BUF_NUM_METHODS } from "./buffer-numeric-methods.js"; import * as ts from "../../ts7/adapter.js"; @@ -77,7 +78,7 @@ function lowerBytesSortCall( const cacheKey = `bytes.${method}:${bytesT.elem}:${key}`; let helper = lowerer.arrHofHelpers.get(cacheKey); if (!helper) { - helper = `%bytes.${method}.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, `%bytes.${method}`, cacheKey); lowerer.arrHofHelpers.set(cacheKey, helper); lowerer.liftedFns.push( buildBytesSortFn(helper, bytesT, arity, hasComparator, copyFirst, order, loc), @@ -270,7 +271,7 @@ function bytesCallbackHelper( const key = `bytes.${method}:${bytesT.elem}:${typeKey(resultT)}:${typeKey(fnRet)}:${arity}:${hasInit ? "init" : ""}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = `%bytes.${method}.${lowerer.arrHofHelpers.size}`; + const name = keyedHelperName(lowerer, `%bytes.${method}`, key); lowerer.arrHofHelpers.set(key, name); const reduce = method === "reduce" || method === "reduceRight"; const backward = method === "reduceRight" || method === "findLast" || method === "findLastIndex"; diff --git a/packages/compiler/src/frontend/lowering/containers/callback-arguments.ts b/packages/compiler/src/frontend/lowering/containers/callback-arguments.ts index 18754f088..f39c8e86c 100644 --- a/packages/compiler/src/frontend/lowering/containers/callback-arguments.ts +++ b/packages/compiler/src/frontend/lowering/containers/callback-arguments.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import * as ts from "../../ts7/adapter.js"; import type { Lowerer } from "../lowerer.js"; import { isJsSourceFile, locOf } from "../../program.js"; @@ -285,7 +286,7 @@ export function truthyFilterCallback( const key = `filterBoolean:${typeKey(valueT)}`; let name = lowerer.arrHofHelpers.get(key); if (!name) { - name = `%arr.filterBoolean.${lowerer.arrHofHelpers.size}`; + name = keyedHelperName(lowerer, "%arr.filterBoolean", key); lowerer.arrHofHelpers.set(key, name); const value = varRef("v.0", valueT, loc); lowerer.liftedFns.push({ diff --git a/packages/compiler/src/frontend/lowering/containers/collection-grouping.ts b/packages/compiler/src/frontend/lowering/containers/collection-grouping.ts index 0bf126830..dae68d518 100644 --- a/packages/compiler/src/frontend/lowering/containers/collection-grouping.ts +++ b/packages/compiler/src/frontend/lowering/containers/collection-grouping.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { countedFor, numLit, varRef } from "../../../ir/build.js"; import * as ts from "../../ts7/adapter.js"; import type { Lowerer } from "../lowerer.js"; @@ -104,7 +105,7 @@ export function lowerGroupByStaticCall( const key = `map.groupBy:${typeKey(items.type)}:${typeKey(f.type)}`; let helper = lowerer.mapHofHelpers.get(key); if (!helper) { - helper = `%map.groupBy.${lowerer.mapHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%map.groupBy", key); lowerer.mapHofHelpers.set(key, helper); lowerer.liftedFns.push(buildGroupByFn(lowerer, helper, items.type, f.type, resultT, loc)); } @@ -141,7 +142,7 @@ export function lowerGroupByStaticCall( const key = `object.groupBy:${typeKey(items.type)}:${typeKey(f.type)}`; let helper = lowerer.mapHofHelpers.get(key); if (!helper) { - helper = `%object.groupBy.${lowerer.mapHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%object.groupBy", key); lowerer.mapHofHelpers.set(key, helper); lowerer.liftedFns.push(buildGroupByFn(lowerer, helper, items.type, f.type, resultT, loc)); } diff --git a/packages/compiler/src/frontend/lowering/containers/collection-methods.ts b/packages/compiler/src/frontend/lowering/containers/collection-methods.ts index 370974c85..d3169ec5c 100644 --- a/packages/compiler/src/frontend/lowering/containers/collection-methods.ts +++ b/packages/compiler/src/frontend/lowering/containers/collection-methods.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { nodeThrowExpr, boolLit, countedFor, numLit, strLit, varRef } from "../../../ir/build.js"; import { InternalCompilerError } from "../../../errors.js"; import * as ts from "../../ts7/adapter.js"; @@ -232,7 +233,7 @@ function lowerMapIterDrainCall( const key = `${method}:${typeKey(mapT.key)}:${typeKey(mapT.value)}`; let helper = lowerer.mapHofHelpers.get(key); if (!helper) { - helper = `%map.${method}.${lowerer.mapHofHelpers.size}`; + helper = keyedHelperName(lowerer, `%map.${method}`, key); lowerer.mapHofHelpers.set(key, helper); lowerer.liftedFns.push(buildMapIterDrainFn(helper, mapT, method, elemT, tupleT, loc)); } @@ -348,7 +349,7 @@ export function mapEntriesArray(lowerer: Lowerer, receiver: IrExpr): IrExpr { const key = `entries:${typeKey(mapT.key)}:${typeKey(mapT.value)}`; let helper = lowerer.mapHofHelpers.get(key); if (!helper) { - helper = `%map.entries.${lowerer.mapHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%map.entries", key); lowerer.mapHofHelpers.set(key, helper); lowerer.liftedFns.push( buildMapIterDrainFn(helper, mapT, "entries", tupleT, tupleT, receiver.loc), @@ -519,7 +520,7 @@ export function lowerMapForEachCall( const key = `${typeKey(mapT.key)}:${typeKey(mapT.value)}:${arity}:${typeKey(fnRet)}`; let helper = lowerer.mapHofHelpers.get(key); if (!helper) { - helper = `%map.forEach.${lowerer.mapHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%map.forEach", key); lowerer.mapHofHelpers.set(key, helper); lowerer.liftedFns.push(buildCollectionForEachFn(helper, mapT, arity, fnRet, loc)); } @@ -693,7 +694,7 @@ export function lowerSetForEachCall( const key = `${typeKey(setT.elem)}:${arity}:${typeKey(fnRet)}`; let helper = lowerer.setHofHelpers.get(key); if (!helper) { - helper = `%set.forEach.${lowerer.setHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%set.forEach", key); lowerer.setHofHelpers.set(key, helper); lowerer.liftedFns.push(buildCollectionForEachFn(helper, setT, arity, fnRet, loc)); } @@ -745,7 +746,7 @@ function lowerSetCombineCall( const key = `${name}:${typeKey(setT.elem)}:${typeKey(otherT)}`; let helper = lowerer.setHofHelpers.get(key); if (!helper) { - helper = `%set.${name}.${lowerer.setHofHelpers.size}`; + helper = keyedHelperName(lowerer, `%set.${name}`, key); lowerer.setHofHelpers.set(key, helper); lowerer.liftedFns.push(buildSetCombineFn(helper, name, setT, otherT, loc)); } @@ -1357,7 +1358,7 @@ export function mapFromSeedValue( const key = `checked-seed:${typeKey(mapT)}`; let name = lowerer.mapHofHelpers.get(key); if (!name) { - name = `%map.checkedSeed.${lowerer.mapHofHelpers.size}`; + name = keyedHelperName(lowerer, "%map.checkedSeed", key); lowerer.mapHofHelpers.set(key, name); const source = varRef("source.0", DYN, loc); const entries = varRef("entries.0", DYN, loc); @@ -1457,7 +1458,7 @@ export function mapFromSeedValue( const key = `seed:${typeKey(mapT.key)}:${typeKey(mapT.value)}:${elem.shapeId}`; let helper = lowerer.mapHofHelpers.get(key); if (!helper) { - helper = `%map.seed.${lowerer.mapHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%map.seed", key); lowerer.mapHofHelpers.set(key, helper); lowerer.liftedFns.push(buildMapSeedFn(mapT, helper, seed.type, elem, kT, vT, loc)); } diff --git a/packages/compiler/src/frontend/lowering/containers/indexed-objects.ts b/packages/compiler/src/frontend/lowering/containers/indexed-objects.ts index efc173ffc..b3faf649e 100644 --- a/packages/compiler/src/frontend/lowering/containers/indexed-objects.ts +++ b/packages/compiler/src/frontend/lowering/containers/indexed-objects.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { nullProtoRecordShape, recordNullProtoTest } from "../null-prototype.js"; import { countedFor, numLit, varRef } from "../../../ir/build.js"; import { objectEnumerationReceiver } from "../object-enumeration-receiver.js"; @@ -184,7 +185,7 @@ export function objectIterOverIndexShape( const key = `obj.${member}:ovf:${argIr.shapeId}:${typeKey(resultT)}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%obj.${member}.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, `%obj.${member}`, key); const outRef = varRef("out.0", resultT, loc); const rRef = varRef("r.0", argIr, loc); @@ -608,7 +609,7 @@ function lowerTypedObjectFromEntriesCall( const key = `obj.fromEntries:${argIr.elem.shapeId}:${resultT.shapeId}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%obj.fromEntries.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%obj.fromEntries", key); const tupleT = argIr.elem as IrType & { kind: "record" }; const tRef = varRef("t.0", tupleT, loc); @@ -712,7 +713,7 @@ function lowerFromEntriesStringRows( const key = `obj.fromEntries:strrows:${resultT.shapeId}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%obj.fromEntries.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%obj.fromEntries", key); const tRef = varRef("t.0", rowT, loc); const rowLen: IrExpr = { @@ -931,7 +932,7 @@ export function lowerRecordOvfCaptureHelper( const key = `ovf:${fromId}:${toId}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%rec.capture.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, "%rec.capture", key); lowerer.valueHelpers.set(key, name); const fromT: IrType = { kind: "record", shapeId: fromId }; const toT: IrType = { kind: "record", shapeId: toId }; @@ -1204,7 +1205,7 @@ export function lowerObjectAssignIndexShape( const key = `assign:${targetIr.shapeId}:${plan.fromId}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%obj.assign.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, "%obj.assign", key); lowerer.valueHelpers.set(key, name); const toT: IrType = { kind: "record", shapeId: targetIr.shapeId }; const fromT: IrType = { kind: "record", shapeId: plan.fromId }; @@ -1474,7 +1475,7 @@ export function lowerIndexMergeHelper( .join(","); const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%rec.merge.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, "%rec.merge", key); lowerer.valueHelpers.set(key, name); const toT: IrType = { kind: "record", shapeId: toId }; const ksT = arrayOf(STRING); @@ -1805,7 +1806,7 @@ export function lowerEnvToPairsHelper( const key = `env.pairs:${shapeId}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%env.pairs.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, "%env.pairs", key); lowerer.valueHelpers.set(key, name); const recT: IrType = { kind: "record", shapeId }; const arrT = arrayOf(STRING); diff --git a/packages/compiler/src/frontend/lowering/containers/iterator-helpers.ts b/packages/compiler/src/frontend/lowering/containers/iterator-helpers.ts index 540518284..ba5d0684d 100644 --- a/packages/compiler/src/frontend/lowering/containers/iterator-helpers.ts +++ b/packages/compiler/src/frontend/lowering/containers/iterator-helpers.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { boolLit, numLit, varRef } from "../../../ir/build.js"; import { InternalCompilerError } from "../../../errors.js"; import * as ts from "../../ts7/adapter.js"; @@ -966,7 +967,7 @@ function lowerFusedChain( const key = `iter:${srcKey}:${stageKeys.join(",")}:${terminal}:${termArgs.map((a) => typeKey(a.type)).join(",")}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%iter.${terminal}.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, `%iter.${terminal}`, key); lowerer.arrHofHelpers.set(key, helper); lowerer.liftedFns.push( buildIterChainFn( @@ -1038,7 +1039,7 @@ function lowerHelperObject( const key = `iterHelper:${stage.kind}:${srcKey}:${typeKey(srcElem)}:${typeKey(arg.type)}:${typeKey(outT)}`; let name = lowerer.arrHofHelpers.get(key); if (!name) { - name = `%iter.${stage.kind}.${lowerer.arrHofHelpers.size}`; + name = keyedHelperName(lowerer, `%iter.${stage.kind}`, key); lowerer.arrHofHelpers.set(key, name); lowerer.liftedFns.push( buildHelperGenFn(lowerer, name, source, srcElem, stage, arg.type, outT, resultType, loc), @@ -1058,7 +1059,7 @@ function internBudgetChecker(lowerer: Lowerer, loc: SrcLoc, srcT: GenType | null const key = srcT === null ? "iter:budget" : `iter:budget:close:${typeKey(srcT)}`; let name = lowerer.arrHofHelpers.get(key); if (name !== undefined) return name; - name = srcT === null ? "%iter.budget" : `%iter.budget.close.${lowerer.arrHofHelpers.size}`; + name = srcT === null ? "%iter.budget" : keyedHelperName(lowerer, "%iter.budget.close", key); lowerer.arrHofHelpers.set(key, name); const v = (): IrExpr => ({ kind: "varRef", localId: "v.0", type: F64, loc }); diff --git a/packages/compiler/src/frontend/lowering/containers/string-and-regexp.ts b/packages/compiler/src/frontend/lowering/containers/string-and-regexp.ts index 38865093f..1947f0d75 100644 --- a/packages/compiler/src/frontend/lowering/containers/string-and-regexp.ts +++ b/packages/compiler/src/frontend/lowering/containers/string-and-regexp.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { matchAllRowsReadByElements } from "./match-row-uses.js"; import { boolLit, @@ -159,7 +160,7 @@ export function lowerStringSplitCall( const key = `str.split:${receiver.type.kind === "union" ? typeKey(receiver.type) : receiver.type.kind}:${typeKey(separator.type)}:${typeKey(limit.type)}:${absent}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%str.split.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%str.split", key); const values = [receiver, separator, limit]; const params = values.map((value, index) => ({ localId: `arg.${index}`, @@ -395,7 +396,7 @@ function stringIndexHelperCall( const key = `str.index:${method}:${typeKey(receiver.type)}:${typeKey(index.type)}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%str.index.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%str.index", key); lowerer.valueHelpers.set(key, helper); const rawReceiver = varRef("arg.0", receiver.type, loc); const rawIndex = varRef("arg.1", index.type, loc); @@ -673,7 +674,7 @@ export function lowerStringPaddingCall( const key = `str.pad:${method}:${values.map((value) => typeKey(value.type)).join(":")}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%str.pad.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%str.pad", key); const params = values.map((value, index) => ({ localId: `arg.${index}`, name: `arg${index}`, @@ -1309,7 +1310,7 @@ export function lowerStringMethodCall( const key = `str.positions:${entry.method}:${typeKey(needle.type)}:${typeKey(position.type)}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%str.positions.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%str.positions", key); const params = [receiver, needle, position].map((arg, index) => ({ localId: `arg.${index}`, name: `arg${index}`, @@ -1411,7 +1412,7 @@ export function lowerStringMethodCall( const key = `str.positions:${entry.method}:${args.map((arg) => typeKey(arg.type)).join(":")}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%str.positions.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%str.positions", key); const params = [receiver, ...args].map((arg, index) => ({ localId: `arg.${index}`, name: `arg${index}`, diff --git a/packages/compiler/src/frontend/lowering/containers/string-replacement.ts b/packages/compiler/src/frontend/lowering/containers/string-replacement.ts index 6856bc50b..780c77d0f 100644 --- a/packages/compiler/src/frontend/lowering/containers/string-replacement.ts +++ b/packages/compiler/src/frontend/lowering/containers/string-replacement.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import * as ts from "../../ts7/adapter.js"; import { BOOL, @@ -162,7 +163,7 @@ function lowerStringReplacementValues( const key = `str.${method}:${typeKey(replacement.type)}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%str.${method}.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, `%str.${method}`, key); lowerer.valueHelpers.set(key, helper); const subject = varRef("s.0", STRING, loc); const needle = varRef("search.0", STRING, loc); diff --git a/packages/compiler/src/frontend/lowering/dynamic-tier.ts b/packages/compiler/src/frontend/lowering/dynamic-tier.ts index 0293f9ab7..3e0cea20a 100644 --- a/packages/compiler/src/frontend/lowering/dynamic-tier.ts +++ b/packages/compiler/src/frontend/lowering/dynamic-tier.ts @@ -304,7 +304,18 @@ export function scanDynamicTier(lowerer: Lowerer, module: IrModule): DynamicTier }); } const rank = { loop: 0, "called-in-loop": 1, recursive: 2 } as const; - hot.sort((a, b) => rank[a.hot] - rank[b.hot] || b.loopOperations - a.loopOperations); + // Functions that rank alike list in source order: by the file's place in + // the module order, then by position. + const fileOrder = new Map(lowerer.moduleOrder.map((sf, index) => [sf.fileName, index])); + const fileRank = (file: string): number => fileOrder.get(file) ?? lowerer.moduleOrder.length; + hot.sort( + (a, b) => + rank[a.hot] - rank[b.hot] || + b.loopOperations - a.loopOperations || + fileRank(a.loc.file) - fileRank(b.loc.file) || + (a.loc.file < b.loc.file ? -1 : a.loc.file > b.loc.file ? 1 : 0) || + a.loc.start - b.loc.start, + ); return { hot, packages: [...packages] @@ -332,14 +343,15 @@ function boundName(lowerer: Lowerer, loc: SrcLoc): string | null { /** A function's name as the source spells it, without a module prefix * (`%%m144.Session.finish` → `Session.finish`, `m163.find` → `find`). A - * function expression (`%fn`) takes its own name, else the name it is - * bound to, else `anonymous function`. */ + * function expression (`%fn.`, with `_` when the expression is + * named) takes its own name, else the name it is bound to, else + * `anonymous function`. */ function displayName(lowerer: Lowerer, f: HotDynamicFunction): string { const plain = f.name .replace(/^%+/, "") .replace(/^m\d+\./, "") .replace(/^%+/, ""); - const lambda = /^fn\d+(?:_(.+))?$/.exec(plain); + const lambda = /^fn\.[0-9a-f]+(?:_(.+))?$/.exec(plain); if (lambda === null) return plain; return lambda[1] ?? boundName(lowerer, f.loc) ?? "anonymous function"; } diff --git a/packages/compiler/src/frontend/lowering/expressions/binary.ts b/packages/compiler/src/frontend/lowering/expressions/binary.ts index fafbbf695..7e449f12b 100644 --- a/packages/compiler/src/frontend/lowering/expressions/binary.ts +++ b/packages/compiler/src/frontend/lowering/expressions/binary.ts @@ -1,4 +1,5 @@ /* Binary operators: arithmetic, comparisons and equality, logical and nullish pairs, and string conversion for concatenation. */ +import { keyedHelperName } from "../stable-names.js"; import * as ts from "../../ts7/adapter.js"; import { cleanFuncAdaptable } from "../coercions/function-adapters.js"; import { type Lowerer, jsFuncNameOf } from "../lowerer.js"; @@ -801,7 +802,7 @@ function nullProtoToString(lowerer: Lowerer, e: IrExpr, t: IrType & { kind: "rec const key = `nullProtoToString:${t.shapeId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%rec.tostr.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%rec.tostr", key); lowerer.valueHelpers.set(key, helper); const r = varRef("r.0", t, loc); lowerer.liftedFns.push({ diff --git a/packages/compiler/src/frontend/lowering/expressions/object-literals.ts b/packages/compiler/src/frontend/lowering/expressions/object-literals.ts index a17af9b83..a2f399e34 100644 --- a/packages/compiler/src/frontend/lowering/expressions/object-literals.ts +++ b/packages/compiler/src/frontend/lowering/expressions/object-literals.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "../stable-names.js"; import { dateJsonType, isDateJsonSource } from "../builtins/dates.js"; import { dynUndefinedExpr, numLit, strLit, varRef } from "../../../ir/build.js"; import { pathModuleValue } from "../lower-builtin-values.js"; @@ -409,7 +410,7 @@ export function lowerDynObjectLiteral( if (!(err instanceof PoisonError) || !pureMember) throw err; const fence = lowerer.deferToRuntimeFence(propDiagsBefore, prop, { kind: "closure", - name: () => `%fn${lowerer.lambdaCounter++}_dynfence`, + name: () => lowerer.closureName(loc, "_dynfence"), returnType: VOID, type: { kind: "func", params: [], ret: VOID }, }); @@ -464,7 +465,7 @@ export function lowerDynObjectLiteral( if (!(err instanceof PoisonError)) throw err; const fence = lowerer.deferToRuntimeFence(convDiagsBefore, prop, { kind: "closure", - name: () => `%fn${lowerer.lambdaCounter++}_dynfence`, + name: () => lowerer.closureName(loc, "_dynfence"), returnType: VOID, type: { kind: "func", params: [], ret: VOID }, }); @@ -2959,7 +2960,7 @@ function lowerDeclaredSpreadMerge( const key = `declmerge-source:${type.shapeId}:${source.shapeId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%rec.declmerge.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%rec.declmerge", key); const sourceType = source.value.type; const destination = varRef("out.0", type, loc); const receiver = varRef("source.0", sourceType, loc); diff --git a/packages/compiler/src/frontend/lowering/expressions/optional-chains.ts b/packages/compiler/src/frontend/lowering/expressions/optional-chains.ts index fbcecdc32..4b8c5692a 100644 --- a/packages/compiler/src/frontend/lowering/expressions/optional-chains.ts +++ b/packages/compiler/src/frontend/lowering/expressions/optional-chains.ts @@ -240,7 +240,7 @@ export function lowerOptionalChain( const receiver = lowerer.runtimeOptionalSourceValue(recvNode, loweredReceiver) ?? loweredReceiver; if (receiver.type.kind === "dyn") { if (dotNode === expr && ts.isCallExpression(expr)) { - const id = `chain.${lowerer.chainCounter++}`; + const id = lowerer.closureName(loc, "", "chain"); const callee: IrExpr = { kind: "chainRecv", id, type: DYN, loc }; const stmts: IrStmt[] = []; let guarded = receiver; @@ -298,7 +298,7 @@ export function lowerOptionalChain( ); } if (dotNode === expr && ts.isElementAccessExpression(expr)) { - const id = `chain.${lowerer.chainCounter++}`; + const id = lowerer.closureName(loc, "", "chain"); const reference: IrExpr = { kind: "chainRecv", id, type: DYN, loc }; lowerer.chainRecvByNode.set(recvNode, reference); lowerer.chainHandled.add(dotNode); @@ -331,7 +331,7 @@ export function lowerOptionalChain( dotNode === expr.expression ) { const m = dotNode.name.text; - const id = `chain.${lowerer.chainCounter++}`; + const id = lowerer.closureName(loc, "", "chain"); const recvRef: IrExpr = { kind: "chainRecv", id, type: DYN, loc: locOf(recvNode) }; lowerer.chainRecvByNode.set(recvNode, recvRef); lowerer.chainHandled.add(dotNode); @@ -358,7 +358,7 @@ export function lowerOptionalChain( } return { kind: "optChain", id, receiver, body, type: DYN, loc }; } - const id = `chain.${lowerer.chainCounter++}`; + const id = lowerer.closureName(loc, "", "chain"); const reference: IrExpr = { kind: "chainRecv", id, type: DYN, loc }; lowerer.chainRecvByNode.set(recvNode, reference); lowerer.chainHandled.add(dotNode); @@ -420,7 +420,7 @@ export function lowerOptionalChain( rest.length === 1 ? rest[0]! : { kind: "union" as const, unionId: lowerer.unions.transform(def, rest) }; - const id = `chain.${lowerer.chainCounter++}`; + const id = lowerer.closureName(loc, "", "chain"); // A single present arm binds its payload. Multiple present arms bind // the original tagged value, then retag inside the guarded body. The // nullish arms never enter that body, and each record keeps its identity. diff --git a/packages/compiler/src/frontend/lowering/expressions/property-access.ts b/packages/compiler/src/frontend/lowering/expressions/property-access.ts index ea075c528..d66110950 100644 --- a/packages/compiler/src/frontend/lowering/expressions/property-access.ts +++ b/packages/compiler/src/frontend/lowering/expressions/property-access.ts @@ -1,4 +1,5 @@ /* Property reads (`a.b`): lowerExprInner's property-access branch, intrinsic and union properties, field reads and targets, and match-group reads. */ +import { keyedHelperName } from "../stable-names.js"; import { staticallySelected } from "../static-typeof.js"; import * as ts from "../../ts7/adapter.js"; import { lowerHistogramProperty } from "../builtins/performance.js"; @@ -2793,7 +2794,7 @@ export function lowerGroupsProjection( const key = `regexgroups:${shapeId}:${groups.map((g) => `${g.name}=${g.index}`).join(",")}:${recvKey}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%regex.groups.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%regex.groups", key); lowerer.valueHelpers.set(key, helper); const body: IrStmt[] = []; const locals: IrLocal[] = [{ id: "m.0", name: "m", type: recv.type, mutable: true }]; diff --git a/packages/compiler/src/frontend/lowering/expressions/relational.ts b/packages/compiler/src/frontend/lowering/expressions/relational.ts index 088b45cff..836391835 100644 --- a/packages/compiler/src/frontend/lowering/expressions/relational.ts +++ b/packages/compiler/src/frontend/lowering/expressions/relational.ts @@ -1,4 +1,5 @@ /* instanceof and in, including private-name and runtime-key in. */ +import { keyedHelperName } from "../stable-names.js"; import * as ts from "../../ts7/adapter.js"; import { builtinClassInstanceOfAny, builtinClassKind } from "../builtins/builtin-class-dyn.js"; import { @@ -647,7 +648,7 @@ export function lowerInstanceOf(lowerer: Lowerer, expr: ts.BinaryExpression, loc const key = `instanceof.union:${unionId}:${target.def.name}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%instanceof.union.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%instanceof.union", key); lowerer.valueHelpers.set(key, helper); const value: IrExpr = { kind: "varRef", localId: "value.0", type: left.type, loc }; const body: IrStmt[] = []; @@ -1847,7 +1848,7 @@ function lowerRuntimeKeyIn( const hkey = `haskey:${recvT.shapeId}`; let helper = lowerer.valueHelpers.get(hkey); if (!helper) { - helper = `%rec.haskey.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%rec.haskey", hkey); lowerer.valueHelpers.set(hkey, helper); const recT: IrType = { kind: "record", shapeId: recvT.shapeId }; diff --git a/packages/compiler/src/frontend/lowering/generic-functions.ts b/packages/compiler/src/frontend/lowering/generic-functions.ts index e843b6909..1fff26585 100644 --- a/packages/compiler/src/frontend/lowering/generic-functions.ts +++ b/packages/compiler/src/frontend/lowering/generic-functions.ts @@ -1,4 +1,6 @@ import { staticNameBindings } from "./static-function-names.js"; +import { positionTag } from "./structural-positions.js"; +import { keyedHelperName } from "./stable-names.js"; import * as ts from "../ts7/adapter.js"; import { bodyReadsArguments } from "../arguments-usage.js"; import type { Lowerer } from "./lowerer.js"; @@ -233,7 +235,10 @@ export function collectGenericSignature(lowerer: Lowerer, decl: ts.FunctionDecla lowerer.genericFnsBySymbol.set(symbol, { decl, baseName: nameText, - qualifiedName: lowerer.qualify(ts.getSourceFileOfNode(decl), nsPathPrefix(decl) + nameText), + qualifiedName: lowerer.qualify( + ts.getSourceFileOfNode(decl), + nsPathPrefix(lowerer, decl) + nameText, + ), typeParams, instances: new Map(), }); @@ -774,7 +779,7 @@ function internGenericInstance( const typeArgsText = `<${rendered.length > 80 ? rendered.slice(0, 77) + "..." : rendered}>`; inst = { path, - name: `${info.qualifiedName}%${info.instances.size}`, + name: keyedHelperName(lowerer, `${info.qualifiedName}%`, key, ""), ordinal: info.instances.size, params, returnType, @@ -2252,7 +2257,7 @@ function internImplicitInstance( const declared = dynamicBroadPromise ? null : implicitDeclaredReturn(lowerer, info); inst = { path, - name: `${info.qualifiedName}%${info.instances.size}`, + name: keyedHelperName(lowerer, `${info.qualifiedName}%`, key, ""), ordinal: info.instances.size, params: shapes, // The promise callers rely on before the body settles it: the @@ -2440,7 +2445,7 @@ export function implicitLocalFnInfoOf( baseName: name, qualifiedName: lowerer.qualify( ts.getSourceFileOfNode(decl), - nsPathPrefix(stmt ?? decl, decl) + `${name}%l${ts.tokenStartOfNode(decl)}`, + nsPathPrefix(lowerer, stmt ?? decl, decl) + `${name}%l${positionTag(lowerer, decl)}`, ), typeParams: [], instances: new Map(), @@ -2536,7 +2541,7 @@ export function objLitGenericFnInfoOf( baseName: name, qualifiedName: lowerer.qualify( ts.getSourceFileOfNode(fnNode), - `%ol${ts.tokenStartOfNode(fnNode)}.${name}`, + `%ol${positionTag(lowerer, fnNode)}.${name}`, ), typeParams, instances: new Map(), @@ -2682,7 +2687,7 @@ export function bindingGenericFnInfoOf( baseName: name, qualifiedName: lowerer.qualify( ts.getSourceFileOfNode(decl), - nsPathPrefix(stmt ?? decl, decl) + + nsPathPrefix(lowerer, stmt ?? decl, decl) + (topLevel ? name : `${name}%l${ts.tokenStartOfNode(decl)}`), ), typeParams, diff --git a/packages/compiler/src/frontend/lowering/intern-tables.ts b/packages/compiler/src/frontend/lowering/intern-tables.ts index fc69237db..e3f2b0889 100644 --- a/packages/compiler/src/frontend/lowering/intern-tables.ts +++ b/packages/compiler/src/frontend/lowering/intern-tables.ts @@ -23,6 +23,7 @@ * The entry handles that itable.find and itable.insert answer stay inside * these lowerings: f64 locals that only reach toBool and itable.value. * Any other use of the class or its members as values is refused. */ +import { keyedHelperName } from "./stable-names.js"; import { dynUndefinedExpr } from "../../ir/build.js"; import { BOOL, F64, STRING, funcOf, typeKey } from "../../ir/ir.js"; import type { IrExpr, IrFunction, IrStmt, IrType, SrcLoc } from "../../ir/ir.js"; @@ -447,7 +448,11 @@ function helperName(lowerer: Lowerer, member: InternTableMember, signature: stri } function registerHelper(lowerer: Lowerer, member: InternTableMember, signature: string): string { - const name = `%${INTERN_TABLE_CLASS}.${member}.${lowerer.internTableHelpers.size}`; + const name = keyedHelperName( + lowerer, + `%${INTERN_TABLE_CLASS}.${member}`, + `${member}|${signature}`, + ); lowerer.internTableHelpers.set(`${member}|${signature}`, name); return name; } diff --git a/packages/compiler/src/frontend/lowering/iterator-adapters.ts b/packages/compiler/src/frontend/lowering/iterator-adapters.ts index 898c46f20..e50652182 100644 --- a/packages/compiler/src/frontend/lowering/iterator-adapters.ts +++ b/packages/compiler/src/frontend/lowering/iterator-adapters.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { dynUndefinedExpr, varRef } from "../../ir/build.js"; import { BOOL, @@ -86,7 +87,7 @@ function dynIteratorAdapter( const key = `iterAdapt:${typeKey(expected)}`; let name = lowerer.valueHelpers.get(key); if (!name) { - name = `%iter.adapt.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, "%iter.adapt", key); lowerer.valueHelpers.set(key, name); const locals: IrLocal[] = []; const local = (id: string, type: IrType, mutable = false): IrExpr => { @@ -313,7 +314,7 @@ export function lowerCollectionIteratorValue( loc, }; if (!typeEquals(yielded.type, type.yieldT)) return null; - name = `%coll.iter.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, "%coll.iter", key); lowerer.valueHelpers.set(key, name); lowerer.liftedFns.push({ name, @@ -411,7 +412,7 @@ export function lowerBytesIteratorValue( const key = `bytesIter:${method}:${typeKey(bytesT)}:${typeKey(type)}`; let name = lowerer.valueHelpers.get(key); if (!name) { - name = `%bytes.iter.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, "%bytes.iter", key); lowerer.valueHelpers.set(key, name); const list = varRef("list.0", bytesT, loc); const index = varRef("index.0", F64, loc); @@ -517,7 +518,7 @@ export function lowerStringIteratorValue( const key = `strIter:${typeKey(type)}`; let name = lowerer.valueHelpers.get(key); if (!name) { - name = `%str.iter.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, "%str.iter", key); lowerer.valueHelpers.set(key, name); const text = varRef("text.0", STRING, loc); const index = varRef("index.0", F64, loc); @@ -677,7 +678,7 @@ function generatorRetypeAdapter( type: resumeType(expected.nextT), loc, }; - name = `%gen.retype.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, "%gen.retype", key); lowerer.valueHelpers.set(key, name); lowerer.liftedFns.push({ name, @@ -794,7 +795,7 @@ export function generatorDrain( const outRef = varRef("out.0", arrT, loc); const value = lowerer.coerceToExpected(genValue(genRef, loc), elem); if (!typeEquals(value.type, elem)) return null; - name = `%gen.drain.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, "%gen.drain", key); lowerer.valueHelpers.set(key, name); lowerer.liftedFns.push({ name, @@ -856,7 +857,7 @@ export function generatorDrain( if (!raw) return null; const value = lowerer.coerceToExpected(raw, elem); if (!typeEquals(value.type, elem)) return null; - name = `%gen.drain.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, "%gen.drain", key); lowerer.valueHelpers.set(key, name); lowerer.liftedFns.push({ name, @@ -978,7 +979,7 @@ export function lowerArrayIteratorValue( }; } if (!yielded || !typeEquals(yielded.type, type.yieldT)) return null; - name = `%arr.iter.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, "%arr.iter", key); lowerer.valueHelpers.set(key, name); lowerer.liftedFns.push({ name, diff --git a/packages/compiler/src/frontend/lowering/js-dynamic-objects.ts b/packages/compiler/src/frontend/lowering/js-dynamic-objects.ts index b9bbf6216..e27dd4183 100644 --- a/packages/compiler/src/frontend/lowering/js-dynamic-objects.ts +++ b/packages/compiler/src/frontend/lowering/js-dynamic-objects.ts @@ -21,6 +21,7 @@ * files only, and an empty answer leaves every mapping unchanged, so * TypeScript programs and JavaScript that never uses these patterns * compile exactly as before. */ +import { keyedHelperName } from "./stable-names.js"; import * as ts from "../ts7/adapter.js"; import { isJsSourceFile, locOf } from "../program.js"; import { BOOL, DYN, type IrExpr, type IrStmt } from "../../ir/ir.js"; @@ -215,10 +216,10 @@ export function lowerValueReturningConstructorNew( "spread arguments when constructing a class whose constructor returns a value", ); } - const key = `ctorValue:${ts.getSourceFileOfNode(decl).fileName}:${ts.tokenStartOfNode(decl)}`; + const key = `ctorValue:${lowerer.positions.of(decl)}`; let name = lowerer.valueHelpers.get(key); if (name === undefined) { - name = `%ctorValue.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, "%ctorValue", key); lowerer.valueHelpers.set(key, name); const savedClass = lowerer.currentClass; lowerer.currentClass = null; diff --git a/packages/compiler/src/frontend/lowering/json-require.ts b/packages/compiler/src/frontend/lowering/json-require.ts index 927745253..d6c2da571 100644 --- a/packages/compiler/src/frontend/lowering/json-require.ts +++ b/packages/compiler/src/frontend/lowering/json-require.ts @@ -10,6 +10,7 @@ * JSON module is ordinary storage holding that object — destructuring * copies its properties at the require, exactly like Node. ES-module JSON * imports keep their own record (Node's ESM loader caches separately). */ +import { keyedHelperName } from "./stable-names.js"; import * as ts from "../ts7/adapter.js"; import type { Lowerer } from "./lowerer.js"; import { PoisonError } from "./lowerer.js"; @@ -84,7 +85,7 @@ export function collectJsonRequires(lowerer: Lowerer, parts: FileParts[]): void ); throw new PoisonError(); } - const id = `%g.jsonRequire.${lowerer.jsonRequireModules.size}`; + const id = keyedHelperName(lowerer, "%g.jsonRequire", jsonSf.fileName); const global: IrGlobal = { id, name: "%json", type: mapped, mutable: true }; const loadedId = `${id}%loaded`; lowerer.globalsList.push(global, { diff --git a/packages/compiler/src/frontend/lowering/lifetime-regions.ts b/packages/compiler/src/frontend/lowering/lifetime-regions.ts index b212ae473..b684c0395 100644 --- a/packages/compiler/src/frontend/lowering/lifetime-regions.ts +++ b/packages/compiler/src/frontend/lowering/lifetime-regions.ts @@ -14,6 +14,7 @@ * Any other use of the class or its methods as values is refused. The * module is marked lifetimeRegions, which moves every ProgramLifetime * class into counted regions. */ +import { keyedHelperName } from "./stable-names.js"; import { F64, VOID, funcOf, typeKey } from "../../ir/ir.js"; import type { IrExpr, IrFunction, IrStmt, IrType, SrcLoc } from "../../ir/ir.js"; import { experimentalImportOf, lifetimeRegionMemberOf } from "../experimental-import.js"; @@ -152,7 +153,7 @@ function runHelper(lowerer: Lowerer, fnType: IrType & { kind: "func" }, loc: Src const key = typeKey(fnType); const known = lowerer.regionRunHelpers.get(key); if (known !== undefined) return known; - const name = `%${LIFETIME_REGION_CLASS}.run.${lowerer.regionRunHelpers.size}`; + const name = keyedHelperName(lowerer, `%${LIFETIME_REGION_CLASS}.run`, key); lowerer.regionRunHelpers.set(key, name); const regionT = lifetimeRegionType(lowerer); const ret = fnType.ret; diff --git a/packages/compiler/src/frontend/lowering/lower-assert.ts b/packages/compiler/src/frontend/lowering/lower-assert.ts index 460f4d53a..bc51a9382 100644 --- a/packages/compiler/src/frontend/lowering/lower-assert.ts +++ b/packages/compiler/src/frontend/lowering/lower-assert.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { InternalCompilerError } from "../../errors.js"; /* The node:assert lowering (a spoke module like lower-dgram.ts): the * callable module form (`assert(x)` through a default import or a CJS @@ -667,7 +668,7 @@ function partialEqHelper(lowerer: Lowerer, ta: IrType, tb: IrType, loc: SrcLoc): const key = `assert.pdeq:${typeKey(ta)}|${typeKey(tb)}`; const existing = lowerer.assertHelpers.get(key); if (existing) return existing; - const name = `%assert.pdeq.${lowerer.assertHelpers.size}`; + const name = keyedHelperName(lowerer, "%assert.pdeq", key); lowerer.assertHelpers.set(key, name); const a = (): IrExpr => varRef("a.0", ta, loc); const b = (): IrExpr => varRef("b.0", tb, loc); @@ -1280,7 +1281,7 @@ function deepCheckCall( const key = `assert.dcheck:${variant}:${negated}:${typeKey(a.type)}:${typeKey(b.type)}`; let name = lowerer.assertHelpers.get(key); if (!name) { - name = `%assert.dcheck.${lowerer.assertHelpers.size}`; + name = keyedHelperName(lowerer, "%assert.dcheck", key); lowerer.assertHelpers.set(key, name); const pa = varRef("a.0", a.type, loc); const pb = varRef("b.0", b.type, loc); @@ -1844,7 +1845,7 @@ function assertThrowsHelper( const key = `assert.${mode}:${recvIsPromise ? "p" : "f"}:${typeKey(recvType)}:${sig}`; const existing = lowerer.assertHelpers.get(key); if (existing) return existing; - const name = `%assert.${mode}.${lowerer.assertHelpers.size}`; + const name = keyedHelperName(lowerer, `%assert.${mode}`, key); lowerer.assertHelpers.set(key, name); const caughtRef = (): IrExpr => varRef("e.0", CAUGHT, loc); @@ -2293,7 +2294,7 @@ function ifErrorHelper(lowerer: Lowerer, t: IrType & { kind: "union" }, loc: Src const key = `assert.iferr:${typeKey(t)}`; const existing = lowerer.assertHelpers.get(key); if (existing) return existing; - const name = `%assert.iferr.${lowerer.assertHelpers.size}`; + const name = keyedHelperName(lowerer, "%assert.iferr", key); lowerer.assertHelpers.set(key, name); const def = lowerer.unions.get(t.unionId); if (!def) throw new InternalCompilerError(`assert.ifError over unknown union ${t.unionId}`); @@ -2464,7 +2465,7 @@ function deepEqHelper(lowerer: Lowerer, t: IrType, loc: SrcLoc, loose = false): const key = `assert.${prefix}:${typeKey(t)}`; const existing = lowerer.assertHelpers.get(key); if (existing) return existing; - const name = `%assert.${prefix}.${lowerer.assertHelpers.size}`; + const name = keyedHelperName(lowerer, `%assert.${prefix}`, key); lowerer.assertHelpers.set(key, name); const a = (): IrExpr => varRef("a.0", t, loc); diff --git a/packages/compiler/src/frontend/lowering/lower-calls.ts b/packages/compiler/src/frontend/lowering/lower-calls.ts index c503f0c9c..c5e34306c 100644 --- a/packages/compiler/src/frontend/lowering/lower-calls.ts +++ b/packages/compiler/src/frontend/lowering/lower-calls.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { isForwardedTupleSpread, lowerForwardingApply } from "./typed-arguments.js"; import { guardNullProto, nullProtoRecordShape } from "./null-prototype.js"; import { lowerDynStreamMemberCall } from "./dyn-streams.js"; @@ -2095,7 +2096,7 @@ function lowerOptionalNumberDefault( const key = `number.optionalDefault:${widened.unionId}:${dflt}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%number.optionalDefault.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%number.optionalDefault", key); lowerer.valueHelpers.set(key, helper); const input = varRef("value.0", widened, loc); lowerer.liftedFns.push({ @@ -2204,7 +2205,7 @@ function primitiveConversionHandler( const key = `then.${name}:${typeKey(inner)}`; let fnName = lowerer.arrHofHelpers.get(key); if (fnName === undefined) { - fnName = `%then.${name}.${lowerer.arrHofHelpers.size}`; + fnName = keyedHelperName(lowerer, `%then.${name}`, key); lowerer.arrHofHelpers.set(key, fnName); const value = varRef("v.0", inner, loc); let body: IrExpr; @@ -2373,7 +2374,7 @@ function lowerBigIntConstructorValue(lowerer: Lowerer, arg: IrExpr, loc: SrcLoc) const key = `bigint.scalar:${unionId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%bigint.scalar.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%bigint.scalar", key); lowerer.valueHelpers.set(key, helper); const value = varRef("value.0", arg.type, loc); const body: IrStmt[] = []; @@ -3235,7 +3236,7 @@ function lowerScalarUnionNumber( const key = `number.scalar:${arg.type.unionId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%number.scalar.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%number.scalar", key); lowerer.valueHelpers.set(key, helper); const value = varRef("value.0", arg.type, loc); const nan: IrExpr = { @@ -3280,7 +3281,7 @@ function lowerOptionalStringNumber( const key = `${label}.optionalString:${arg.type.unionId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%${label}.optionalString.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, `%${label}.optionalString`, key); lowerer.valueHelpers.set(key, helper); const value = varRef("value.0", arg.type, loc); lowerer.liftedFns.push({ @@ -4707,7 +4708,7 @@ function lowerDefaultToStringCall( const key = `objToStr:${typeKey(recv.type)}${missing ? `:${missing}` : ""}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%obj.tostr.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%obj.tostr", key); lowerer.valueHelpers.set(key, helper); const o = varRef("o.0", recv.type, loc); lowerer.liftedFns.push({ @@ -5394,7 +5395,7 @@ function loweredTemplateStrings( const site = lowerer.globalsList.length; const globalId = `%g.templateStrings.${site}`; const readyId = `%g.templateStringsReady.${site}`; - getter = `%templateStrings.get.${lowerer.valueHelpers.size}`; + getter = keyedHelperName(lowerer, "%templateStrings.get", key); lowerer.valueHelpers.set(key, getter); lowerer.globalsList.push( { id: globalId, name: "%templateStrings", type, mutable: true }, @@ -5575,7 +5576,7 @@ export function lowerPromiseMethodCall( // IS the spec's identity/thrower/no-op substitution for all three // members. An argument expression, when present, is undefined/null // by construction — nothing to evaluate. - const fnName = `%fn${lowerer.lambdaCounter++}_${member}pass`; + const fnName = lowerer.closureName(loc, `_${member}pass`); const funcType: IrType & { kind: "func" } = { kind: "func", params: [promT], ret: promT }; const fnCtx = newFnCtx(true, null, funcType, inner); fnCtx.isAsync = true; @@ -5672,7 +5673,7 @@ export function lowerPromiseMethodCall( // Evaluate both callback expressions before the wrapper runs, in source order. const fulfilled = fulfilledAbsent ? null : boxHandler(fulfilledNode, true); const rejected = rejectedAbsent ? null : boxHandler(rejectedNode, false); - const fnName = `%fn${lowerer.lambdaCounter++}_then2`; + const fnName = lowerer.closureName(loc, "_then2"); const paramTypes: IrType[] = [ promT, ...(fulfilled ? [fulfilled.value.type] : []), @@ -5921,7 +5922,7 @@ export function lowerPromiseMethodCall( ); }; const resultT: IrType & { kind: "promise" } = { kind: "promise", inner: DYN }; - const fnName = `%fn${lowerer.lambdaCounter++}_then`; + const fnName = lowerer.closureName(loc, "_then"); const funcType: IrType & { kind: "func" } = { kind: "func", params: [promT, DYN], @@ -6016,7 +6017,7 @@ export function lowerPromiseMethodCall( ); } const R = resultT.inner; - const fnName = `%fn${lowerer.lambdaCounter++}_then`; + const fnName = lowerer.closureName(loc, "_then"); const funcType: IrType & { kind: "func" } = { kind: "func", params: [promT, cb.type], @@ -6119,7 +6120,7 @@ export function lowerPromiseMethodCall( "finally callbacks with parameters or a return value (use () => { ... })", ); } - const fnName = `%fn${lowerer.lambdaCounter++}_finally`; + const fnName = lowerer.closureName(loc, "_finally"); const funcType: IrType & { kind: "func" } = { kind: "func", params: [promT, cb.type], @@ -6222,7 +6223,7 @@ export function lowerPromiseMethodCall( } if (cb.type.kind === "dyn") { const resultT: IrType & { kind: "promise" } = { kind: "promise", inner: DYN }; - const fnName = `%fn${lowerer.lambdaCounter++}_catchdyn`; + const fnName = lowerer.closureName(loc, "_catchdyn"); const funcType: IrType & { kind: "func" } = { kind: "func", params: [promT, DYN], @@ -6352,7 +6353,7 @@ export function lowerPromiseMethodCall( ); } const R = resultT.inner; - const fnName = `%fn${lowerer.lambdaCounter++}_catch`; + const fnName = lowerer.closureName(loc, "_catch"); const funcType: IrType & { kind: "func" } = { kind: "func", params: [promT], ret: resultT }; const fnCtx = newFnCtx(true, null, funcType, R); fnCtx.isAsync = true; @@ -6589,7 +6590,7 @@ function filterNarrowHelper( const key = `filterNarrow:${test}:${typeKey(elem)}:${typeKey(outElem)}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const name = `%arr.filterNarrow.${lowerer.arrHofHelpers.size}`; + const name = keyedHelperName(lowerer, "%arr.filterNarrow", key); lowerer.arrHofHelpers.set(key, name); const arrT = arrayOf(elem); @@ -6835,7 +6836,7 @@ export function recordKeysArrayCall( const key = `obj.keys:${argIr.shapeId}:${typeKey(resultT)}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%obj.keys.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%obj.keys", key); const ref: IrExpr = { kind: "varRef", localId: "r.0", type: argIr, loc }; const outRef: IrExpr = { kind: "varRef", localId: "out.0", type: resultT, loc }; lowerer.arrHofHelpers.set(key, helper); @@ -6905,7 +6906,7 @@ function recordHasOwnHelper(lowerer: Lowerer, shapeId: string, loc: SrcLoc): str const key = `obj.hasOwn:${shapeId}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const helper = `%obj.hasOwn.${lowerer.arrHofHelpers.size}`; + const helper = keyedHelperName(lowerer, "%obj.hasOwn", key); lowerer.arrHofHelpers.set(key, helper); const shape = lowerer.shapes.get(shapeId)!; const recT: IrType = { kind: "record", shapeId }; @@ -6990,7 +6991,7 @@ function classAssignHelper( const key = `obj.assignClass:${className}:${srcShapeId}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const helper = `%obj.assignClass.${lowerer.arrHofHelpers.size}`; + const helper = keyedHelperName(lowerer, "%obj.assignClass", key); lowerer.arrHofHelpers.set(key, helper); const sShape = lowerer.shapes.get(srcShapeId)!; const oT: IrType = { kind: "object", className }; @@ -7058,7 +7059,7 @@ function recordAssignHelper( const key = `obj.assign:${targetShapeId}:${srcShapeId}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; - const helper = `%obj.assign.${lowerer.arrHofHelpers.size}`; + const helper = keyedHelperName(lowerer, "%obj.assign", key); lowerer.arrHofHelpers.set(key, helper); const sShape = lowerer.shapes.get(srcShapeId)!; const tShape = lowerer.shapes.get(targetShapeId)!; @@ -8515,7 +8516,7 @@ function lowerObjectStaticCall( const key = `obj.${member}:${argIr.shapeId}:${typeKey(resultT)}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%obj.${member}.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, `%obj.${member}`, key); const recT = argIr; const ref: IrExpr = { kind: "varRef", localId: "r.0", type: recT, loc }; const outRef: IrExpr = { kind: "varRef", localId: "out.0", type: resultT, loc }; @@ -9151,7 +9152,7 @@ function lowerInlineArrowBind( const length = firstDefault < 0 ? arrow.parameters.nodes.length : firstDefault; const key = `arrow.bind:${typeKey(type)}:${length}`; const existing = lowerer.arrHofHelpers.get(key); - const name = existing ?? `%arrow.bind.${lowerer.arrHofHelpers.size}`; + const name = existing ?? keyedHelperName(lowerer, "%arrow.bind", key); if (!existing) { lowerer.arrHofHelpers.set(key, name); lowerer.freshClosureAdapters.add(name); @@ -10080,7 +10081,7 @@ function lowerUnionObjectDynFieldCall( const receiverRef = varRef(receiverLocal.id, receiverT, loc); let helper = lowerer.unionCallHelpers.get(key); if (!helper) { - helper = `%union.call.${lowerer.unionCallHelpers.size}`; + helper = keyedHelperName(lowerer, "%union.call", key); lowerer.unionCallHelpers.set(key, helper); const receiverRef = varRef("this.0", receiverT, loc); const branch = (plan: (typeof plans)[number]): IrStmt[] => { @@ -10173,7 +10174,7 @@ function unionObjectMethodHelper( const key = `${receiverT.unionId}:${method}:${shapes.map((shape) => `${shape.mode}:${typeKey(shape.type)}`).join(",")}:${typeKey(resultT)}`; const existing = lowerer.unionCallHelpers.get(key); if (existing) return existing; - const name = `%union.call.${lowerer.unionCallHelpers.size}`; + const name = keyedHelperName(lowerer, "%union.call", key); lowerer.unionCallHelpers.set(key, name); // A probe that catches a refusal while the body lowers must not leave // the name registered for a helper that was never emitted. @@ -10367,7 +10368,7 @@ export function lowerStaticNumberGlobal( const key = `parseInt.optional:${unionT.unionId}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%parseInt.optional.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%parseInt.optional", key); lowerer.valueHelpers.set(key, helper); const value: IrExpr = { kind: "varRef", localId: "value.0", type: unionT, loc }; const radixRef: IrExpr = { kind: "varRef", localId: "radix.0", type: F64, loc }; diff --git a/packages/compiler/src/frontend/lowering/lower-classes.ts b/packages/compiler/src/frontend/lowering/lower-classes.ts index 7e6f80f2c..4ea4583f6 100644 --- a/packages/compiler/src/frontend/lowering/lower-classes.ts +++ b/packages/compiler/src/frontend/lowering/lower-classes.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { lowerValueReturningConstructorNew } from "./js-dynamic-objects.js"; import { adaptPromiseExecutor } from "./promise-executor-adapter.js"; import { dynUndefinedExpr, nodeThrowExpr, varRef } from "../../ir/build.js"; @@ -84,6 +85,7 @@ import { } from "./call-signatures.js"; import { omittedArgFor } from "./call-arguments.js"; import { + checkerTypeDescription, isGenericCallableMemberType, jsOpenObjectType, typeKey, @@ -4664,7 +4666,25 @@ export function genericClassInstanceType( ); } const ordinal = gci.instances.size; - const name = `${gci.family.def.name}%${ordinal}`; + // The name does not take the checker type ids of the key: a literal + // argument is named by its text, another checker type by its + // description. Two keys that still describe alike number the later one. + const nameKey = + mapped.map(typeKey).join(",") + + (gci.literalSensitive.size > 0 + ? `@${gci.typeParams + .map((_, i) => + sensitive(i) + ? (literalText(i) ?? checkerTypeDescription(tsArgs[i]!, lowerer.typeCtx)) + : "*", + ) + .join(",")}` + : ""); + const prefix = `${gci.family.def.name}%`; + const taken = new Set([...gci.instances.values()].map((instance) => instance.name)); + let name = keyedHelperName(lowerer, prefix, nameKey, ""); + for (let n = 1; taken.has(name); n++) + name = keyedHelperName(lowerer, prefix, `${nameKey}#${n}`, ""); const entry: { name: string; info: ClassInfo | null; poisoned?: boolean } = { name, info: null }; gci.instances.set(key, entry); const bindings = new Map(); @@ -7954,7 +7974,7 @@ export function classIteratorDrainCall( const key = `${cit.className}:${typeKey(outElem)}`; let name = lowerer.iterDrainHelpers.get(key); if (!name) { - name = `%iter.drain.${lowerer.iterDrainHelpers.size}`; + name = keyedHelperName(lowerer, "%iter.drain", key); lowerer.iterDrainHelpers.set(key, name); const recvT: IrType = { kind: "object", className: cit.className }; const recvRef: IrExpr = { kind: "varRef", localId: "r.0", type: recvT, loc }; @@ -8068,7 +8088,7 @@ export function classIteratorRestDrainCall( const key = `it:${cit.iterT.className}`; let name = lowerer.iterDrainHelpers.get(key); if (!name) { - name = `%iter.drain.${lowerer.iterDrainHelpers.size}`; + name = keyedHelperName(lowerer, "%iter.drain", key); lowerer.iterDrainHelpers.set(key, name); const itRef: IrExpr = { kind: "varRef", localId: "it.0", type: cit.iterT, loc }; const outRef: IrExpr = { kind: "varRef", localId: "out.0", type: outT, loc }; @@ -10576,7 +10596,7 @@ export function lowerNew(lowerer: Lowerer, expr: ts.NewExpression): IrExpr { const key = `x509.record:${isBytes ? "bytes" : "str"}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%x509.record.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%x509.record", key); lowerer.valueHelpers.set(key, helper); const dataT = data.type; const dRef: IrExpr = { kind: "varRef", localId: "d.0", type: dataT, loc }; diff --git a/packages/compiler/src/frontend/lowering/lower-dgram.ts b/packages/compiler/src/frontend/lowering/lower-dgram.ts index 5c99ebc82..aa90fc7c7 100644 --- a/packages/compiler/src/frontend/lowering/lower-dgram.ts +++ b/packages/compiler/src/frontend/lowering/lower-dgram.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { dynUndefinedExpr, boolLit } from "../../ir/build.js"; /* The dgram/dns-surface lowering (node:dgram + node:dns — a spoke module * like lower-server.ts): module-function calls (dgram createSocket, dns @@ -357,7 +358,7 @@ function checkedDynPromise( const key = `dns.promise:${typeKey(declared)}`; let helper = lowerer.valueHelpers.get(key); if (!helper) { - helper = `%dns.promise.${lowerer.valueHelpers.size}`; + helper = keyedHelperName(lowerer, "%dns.promise", key); lowerer.valueHelpers.set(key, helper); const promiseT: IrType = { kind: "promise", inner: DYN }; lowerer.liftedFns.push({ @@ -891,7 +892,7 @@ export function lowerPromisifiedDnsCall( const key = `dnsPromise:${JSON.stringify(value)}`; let name = lowerer.valueHelpers.get(key); if (!name) { - name = `%dnsPromise.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, "%dnsPromise", key); lowerer.valueHelpers.set(key, name); lowerer.liftedFns.push({ name, diff --git a/packages/compiler/src/frontend/lowering/lower-event-emitter.ts b/packages/compiler/src/frontend/lowering/lower-event-emitter.ts index f472672b2..f105af786 100644 --- a/packages/compiler/src/frontend/lowering/lower-event-emitter.ts +++ b/packages/compiler/src/frontend/lowering/lower-event-emitter.ts @@ -42,6 +42,7 @@ * emit-overrides block at the bottom of this file (per-event * monomorphization of the override body, dispatch on the dynamic class, * super.emit as the prototype chain). */ +import { keyedHelperName } from "./stable-names.js"; import { checkKeypressListener } from "./builtins/readline.js"; import * as ts from "../ts7/adapter.js"; import type { Lowerer } from "./lowerer.js"; @@ -631,7 +632,7 @@ function lowerFlexListenerCall( const key = `emitter.${registering ? "onFlex" : "offDyn"}:${typeKey(recvT)}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%emitter.${registering ? "onFlex" : "offFlex"}.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, `%emitter.${registering ? "onFlex" : "offFlex"}`, key); lowerer.arrHofHelpers.set(key, helper); const params: IrParam[] = [ { localId: "r.0", name: "r", type: recvT }, @@ -850,7 +851,7 @@ function lowerDynListenerCall( const existing = lowerer.arrHofHelpers.get(key); let helper = existing; if (!helper) { - helper = `%emitter.${registering ? "onDyn" : "offDyn"}.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, `%emitter.${registering ? "onDyn" : "offDyn"}`, key); lowerer.arrHofHelpers.set(key, helper); const check: IrStmt = { kind: "exprStmt", @@ -1000,7 +1001,7 @@ export function lowerDynamicEmitterEmit( const key = `emitter.dynEmit:${typeKey(recvT)}:${k}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%emitter.dynEmit.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%emitter.dynEmit", key); lowerer.arrHofHelpers.set(key, helper); const params: IrParam[] = [ { localId: "r.0", name: "r", type: recvT }, @@ -1092,7 +1093,7 @@ export function lowerDynamicEmitterOn( const key = `emitter.dynOn:${typeKey(recvT)}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%emitter.dynOn.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%emitter.dynOn", key); lowerer.arrHofHelpers.set(key, helper); const params: IrParam[] = [ { localId: "r.0", name: "r", type: recvT }, @@ -2359,7 +2360,7 @@ function emitDispatchExpr( const key = `emitter.emitDispatch:${typeKey(recvT)}:${name}`; let helper = lowerer.arrHofHelpers.get(key); if (!helper) { - helper = `%emitter.emitDispatch.${lowerer.arrHofHelpers.size}`; + helper = keyedHelperName(lowerer, "%emitter.emitDispatch", key); lowerer.arrHofHelpers.set(key, helper); const params: IrParam[] = [ { localId: "r.0", name: "r", type: recvT }, @@ -2424,7 +2425,7 @@ function eventsOnceBoxer( const key = `eventsOnce:${typeKey(fnType)}`; let name = lowerer.valueHelpers.get(key); if (name === undefined) { - name = `%events.onceArgs.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, "%events.onceArgs", key); lowerer.valueHelpers.set(key, name); const params: IrParam[] = tuple.map((type, i) => ({ localId: `%once.a${i}`, diff --git a/packages/compiler/src/frontend/lowering/lower-exprs.ts b/packages/compiler/src/frontend/lowering/lower-exprs.ts index e7a1b79a8..ba96bea8c 100644 --- a/packages/compiler/src/frontend/lowering/lower-exprs.ts +++ b/packages/compiler/src/frontend/lowering/lower-exprs.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { lowerWebAssemblyValue, refuseWebAssemblyUse } from "./builtins/webassembly.js"; import { dynUndefinedExpr, nodeThrowExpr, numLit, strLit, varRef } from "../../ir/build.js"; import { InternalCompilerError } from "../../errors.js"; @@ -2274,7 +2275,11 @@ export function cjsAccessorSnapshotOf( if (!lexerVisibleAccessors(ts.getSourceFileOfNode(getter)).includes(getter)) return null; const call = cjsAccessorCall(lowerer, getter, locOf(getter)); if (call === null) return null; - const snapshot = { id: `%g.cjsSnapshot.${lowerer.cjsAccessorSnapshots.size}`, type: call.type }; + const at = locOf(getter); + const snapshot = { + id: keyedHelperName(lowerer, "%g.cjsSnapshot", `${at.file}:${at.start}:${at.end}`), + type: call.type, + }; lowerer.globalsList.push({ id: snapshot.id, name: "%cjsSnapshot", @@ -2299,7 +2304,7 @@ export function cjsAccessorSnapshotStores( if (getters.length === 0) return []; let readyId = lowerer.cjsSnapshotReady.get(dep); if (readyId === undefined) { - readyId = `%g.cjsSnapshotReady.${lowerer.cjsSnapshotReady.size}`; + readyId = keyedHelperName(lowerer, "%g.cjsSnapshotReady", dep.fileName); lowerer.globalsList.push({ id: readyId, name: "%cjsSnapshotReady", type: BOOL, mutable: true }); lowerer.cjsSnapshotReady.set(dep, readyId); } diff --git a/packages/compiler/src/frontend/lowering/lower-functions.ts b/packages/compiler/src/frontend/lowering/lower-functions.ts index cd8dc31d1..653c0d837 100644 --- a/packages/compiler/src/frontend/lowering/lower-functions.ts +++ b/packages/compiler/src/frontend/lowering/lower-functions.ts @@ -270,7 +270,7 @@ export function lowerLambda( const nameIdent = !ts.isArrowFunction(node) && node.name && ts.isIdentifier(node.name) ? node.name : null; const baseName = nameIdent ? nameIdent.text : ""; - const fnName = `%fn${lowerer.lambdaCounter++}${baseName ? `_${baseName}` : ""}`; + const fnName = lowerer.closureName(locOf(node), baseName ? `_${baseName}` : ""); // Named function expressions/declarations can self-reference by name; an // object-literal method's name is a PROPERTY, not a binding — no self. const selfSymbol = diff --git a/packages/compiler/src/frontend/lowering/lower-inspect.ts b/packages/compiler/src/frontend/lowering/lower-inspect.ts index 4be5d0b7e..1979b43aa 100644 --- a/packages/compiler/src/frontend/lowering/lower-inspect.ts +++ b/packages/compiler/src/frontend/lowering/lower-inspect.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { dynUndefinedExpr, boolLit, @@ -268,7 +269,7 @@ function errorInspectHelper( const key = `insp.userError:${typeKey(t)}`; const existing = lowerer.inspectHelpers.get(key); if (existing) return existing; - const name = `%util.insp.${lowerer.inspectHelpers.size}`; + const name = keyedHelperName(lowerer, "%util.insp", key); lowerer.inspectHelpers.set(key, name); const v = (): IrExpr => varRef("v.0", t, loc); const r = (): IrExpr => varRef("r.0", F64, loc); @@ -1145,7 +1146,7 @@ function inspectHelper(lowerer: Lowerer, t: IrType, loc: SrcLoc): string { const key = `insp:${typeKey(t)}`; const existing = lowerer.inspectHelpers.get(key); if (existing) return existing; - const name = `%util.insp.${lowerer.inspectHelpers.size}`; + const name = keyedHelperName(lowerer, "%util.insp", key); lowerer.inspectHelpers.set(key, name); const v = (): IrExpr => varRef("v.0", t, loc); @@ -2074,7 +2075,7 @@ function formatUnionHelper( const existing = lowerer.inspectHelpers.get(key); if (existing) return existing; const loc = helperLoc(site); - const name = `%util.fmtv.${lowerer.inspectHelpers.size}`; + const name = keyedHelperName(lowerer, "%util.fmtv", key); lowerer.inspectHelpers.set(key, name); const def = lowerer.unions.get(t.unionId); if (!def) throw new InternalCompilerError(`format value over unknown union ${t.unionId}`); diff --git a/packages/compiler/src/frontend/lowering/lower-mixins.ts b/packages/compiler/src/frontend/lowering/lower-mixins.ts index 766059dfb..9de027563 100644 --- a/packages/compiler/src/frontend/lowering/lower-mixins.ts +++ b/packages/compiler/src/frontend/lowering/lower-mixins.ts @@ -34,6 +34,7 @@ * statics-bearing mixin classes outside a plain top-level statement * (their declaration-time code must run exactly where the call * evaluates). */ +import { positionTag } from "./structural-positions.js"; import * as ts from "../ts7/adapter.js"; import type { Lowerer } from "./lowerer.js"; import { PoisonError } from "./lowerer.js"; @@ -452,7 +453,7 @@ function instantiateMixinCall( const base = mixinBaseClassOf(lowerer, call.arguments.nodes[0]!); const instName = lowerer.qualify( ts.getSourceFileOfNode(call), - `%mx${ts.tokenStartOfNode(call)}.${shape.classNode.name?.text ?? ""}`, + `%mx${positionTag(lowerer, call)}.${shape.classNode.name?.text ?? ""}`, ); const ordinal = lowerer.mixinOrdinals.get(shape.classNode) ?? 0; lowerer.mixinOrdinals.set(shape.classNode, ordinal + 1); diff --git a/packages/compiler/src/frontend/lowering/lower-mock.ts b/packages/compiler/src/frontend/lowering/lower-mock.ts index fcc68c787..8c50dee46 100644 --- a/packages/compiler/src/frontend/lowering/lower-mock.ts +++ b/packages/compiler/src/frontend/lowering/lower-mock.ts @@ -17,6 +17,7 @@ * writes the original back on restore(). Each mock registers a closure * that calls its restore() with its tracker (scr_test.c): the module's * `mock`, or the test's t.mock, which is reset when the test ends. */ +import { keyedHelperName } from "./stable-names.js"; import * as ts from "../ts7/adapter.js"; import { BOOL, @@ -136,7 +137,7 @@ function liftOnce( const key = `mock.${role}:${owner}`; const existing = lowerer.assertHelpers.get(key); if (existing) return existing; - const name = `%mock.${role}.${lowerer.assertHelpers.size}`; + const name = keyedHelperName(lowerer, `%mock.${role}`, key); lowerer.assertHelpers.set(key, name); build(name); return name; diff --git a/packages/compiler/src/frontend/lowering/lower-modules.test.ts b/packages/compiler/src/frontend/lowering/lower-modules.test.ts index 84cc96e7d..f1021e4da 100644 --- a/packages/compiler/src/frontend/lowering/lower-modules.test.ts +++ b/packages/compiler/src/frontend/lowering/lower-modules.test.ts @@ -34,7 +34,7 @@ test("retains dependencies from function storage, captures, generator channels a const completed = record("completed"); const body = record("body"); const global = record("global", record("nested")); - const wanted = lowerer.shapes.shapes.map((shape) => shape.id); + const wanted = lowerer.shapes.shapes.map((shape) => shape.id).sort(); record("unused"); const unionId = lowerer.unions.intern([body, UNDEFINED_T]); const unusedUnion = lowerer.unions.intern([F64, UNDEFINED_T]); @@ -162,7 +162,7 @@ test("closes nested structural types and index-signature values", () => { sent = record("sent"), indexed = record("indexed"); const containerId = lowerer.shapes.intern([], false, indexed); - const wanted = lowerer.shapes.shapes.map((shape) => shape.id); + const wanted = lowerer.shapes.shapes.map((shape) => shape.id).sort(); record("unused"); const nested: IrType = { kind: "func", diff --git a/packages/compiler/src/frontend/lowering/lower-modules.ts b/packages/compiler/src/frontend/lowering/lower-modules.ts index d1f276d44..0b99e88d3 100644 --- a/packages/compiler/src/frontend/lowering/lower-modules.ts +++ b/packages/compiler/src/frontend/lowering/lower-modules.ts @@ -1,4 +1,5 @@ import { THREADS_MODULE } from "../threads-import.js"; +import { positionTag } from "./structural-positions.js"; import { EXPERIMENTAL_MODULE } from "../experimental-import.js"; import { dynUndefinedExpr } from "../../ir/build.js"; import { everyStmtList, everyTypeChild } from "../../ir/traverse.js"; @@ -1074,8 +1075,14 @@ export function moduleArtifacts( else delete rest.abstractMethods; return rest; }), - records: lowerer.shapes.shapes.filter((r) => shapeIds.has(r.id)), - unions: lowerer.unions.unions.filter((u) => unionIds.has(u.id)), + // Ids come from what each shape and union is (keyedHelperName), so + // ordering by id gives every lowering order the same module. + records: lowerer.shapes.shapes + .filter((r) => shapeIds.has(r.id)) + .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)), + unions: lowerer.unions.unions + .filter((u) => unionIds.has(u.id)) + .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)), }; } @@ -1677,7 +1684,7 @@ export function collectGlobals( } if (type.kind === "void") lowerer.badType(stmt.name, lowerer.typeOf(stmt.name)); const g: IrGlobal = { - id: `%g.${tag}${nsPathPrefix(stmt)}%alias.${stmt.name.text}%${ts.tokenStartOfNode(stmt)}`, + id: `%g.${tag}${nsPathPrefix(lowerer, stmt)}%alias.${stmt.name.text}%${positionTag(lowerer, stmt)}`, name: stmt.name.text, type, mutable: false, @@ -1754,7 +1761,7 @@ export function collectGlobals( // (`%g.e.A%B.x`), so `namespace A { export const x }` and a // top-level `const x` never collide; non-exported members add the // declaring block's position (block-local bindings). - const nsPrefix = nsPathPrefix(stmt, list.declarations.nodes[0]); + const nsPrefix = nsPathPrefix(lowerer, stmt, list.declarations.nodes[0]); for (const decl of list.declarations.nodes) { // --provenance-sources: an elided pure-annotated dead const in a // fetched source module registers no global (the statement diff --git a/packages/compiler/src/frontend/lowering/lower-namespaces.ts b/packages/compiler/src/frontend/lowering/lower-namespaces.ts index dca835d77..19123dae3 100644 --- a/packages/compiler/src/frontend/lowering/lower-namespaces.ts +++ b/packages/compiler/src/frontend/lowering/lower-namespaces.ts @@ -36,6 +36,7 @@ * of the compiler already takes (a body running before the declaring * statement is not modeled — same as top-level const reads through early * calls). */ +import { positionTag, type PositionTagOwner } from "./structural-positions.js"; import * as ts from "../ts7/adapter.js"; import { packageShimFor } from "../package-shims.js"; import type { Lowerer } from "./lowerer.js"; @@ -164,7 +165,11 @@ function registerTypeOnlyBlocks(lowerer: Lowerer, decl: ts.ModuleDeclaration): v * distinct (resolution is by symbol; names only need uniqueness and * determinism). `modifierDecl` carries the declaration whose modifiers * decide exportedness (the first declarator of a variable statement). */ -export function nsPathPrefix(node: ts.Node, modifierDecl?: ts.Node): string { +export function nsPathPrefix( + owner: PositionTagOwner, + node: ts.Node, + modifierDecl?: ts.Node, +): string { const parent = node.parent; if (parent === undefined || !ts.isModuleBlock(parent)) return ""; const flagsHost = modifierDecl ?? node; @@ -179,10 +184,10 @@ export function nsPathPrefix(node: ts.Node, modifierDecl?: ts.Node): string { const nested = p.parent !== undefined && ts.isModuleBlock(p.parent); const nonExported = nested && (ts.getCombinedModifierFlags(p) & ts.ModifierFlags.Export) === 0; - segs.unshift(p.name.text + (nonExported ? `%${ts.tokenStartOfNode(p)}` : "")); + segs.unshift(p.name.text + (nonExported ? `%${positionTag(owner, p)}` : "")); } } - return `${segs.join("%")}${exported ? "" : `%${ts.tokenStartOfNode(parent)}`}.`; + return `${segs.join("%")}${exported ? "" : `%${positionTag(owner, parent)}`}.`; } /** The registered namespace-block kind a symbol's declaration sits in diff --git a/packages/compiler/src/frontend/lowering/lower-server.ts b/packages/compiler/src/frontend/lowering/lower-server.ts index 058d7874a..94d49d8b3 100644 --- a/packages/compiler/src/frontend/lowering/lower-server.ts +++ b/packages/compiler/src/frontend/lowering/lower-server.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { dynUndefinedExpr, nodeThrowExpr, @@ -183,7 +184,7 @@ export function voidizedCallback(lowerer: Lowerer, cb: IrExpr, loc: SrcLoc): IrE const toT = funcOf([...fromT.params], VOID); const key = `server.voidcb:${typeKey(fromT)}`; const existing = lowerer.arrHofHelpers.get(key); - const name = existing ?? `%server.voidcb.${lowerer.arrHofHelpers.size}`; + const name = existing ?? keyedHelperName(lowerer, "%server.voidcb", key); if (!existing) { lowerer.arrHofHelpers.set(key, name); const impl = `${name}.impl`; @@ -279,7 +280,7 @@ function receiverReturningCall( ): IrExpr { const key = `server.recvret:${fn}:${opts?.prefix?.fn ?? ""}:${(opts?.mainArgIndices ?? []).join(".")}:${callArgs.map((a) => typeKey(a.type)).join(",")}`; const existing = lowerer.arrHofHelpers.get(key); - const name = existing ?? `%server.recvret.${lowerer.arrHofHelpers.size}`; + const name = existing ?? keyedHelperName(lowerer, "%server.recvret", key); if (!existing) { lowerer.arrHofHelpers.set(key, name); const params = callArgs.map((a, i) => ({ localId: `p${i}.0`, name: `p${i}`, type: a.type })); @@ -590,7 +591,7 @@ function h2HeadersCallbackAdapter( ); const key = `h2.hdrcb:${handleKind}:${withStatus}:${typeKey(fromT)}:${shapeId ?? ""}`; const existing = lowerer.arrHofHelpers.get(key); - const name = existing ?? `%h2.hdrcb.${lowerer.arrHofHelpers.size}`; + const name = existing ?? keyedHelperName(lowerer, "%h2.hdrcb", key); if (!existing) { lowerer.arrHofHelpers.set(key, name); const impl = `${name}.impl`; @@ -3583,7 +3584,7 @@ export function lowerCompatReqStreamOptionalCall( type: unionT, loc, }; - const id = `chain.${lowerer.chainCounter++}`; + const id = lowerer.closureName(loc, "", "chain"); const body = lowerH2StreamMethodCall(lowerer, call, call.expression, { kind: "chainRecv", id, @@ -4424,7 +4425,7 @@ function lowerHttpCreateServerForms( const hasMax = opts.maxHeaderSize !== null; const key = `server.opts:${opts.joinDup ? 1 : 0}:${opts.allowMissingHost ? 1 : 0}:${hasBuffer ? 1 : 0}:${hasMax ? 1 : 0}`; const existing = lowerer.arrHofHelpers.get(key); - const name = existing ?? `%server.opts.${lowerer.arrHofHelpers.size}`; + const name = existing ?? keyedHelperName(lowerer, "%server.opts", key); if (!existing) { lowerer.arrHofHelpers.set(key, name); const params = [ @@ -8009,7 +8010,7 @@ function lowerHttpResMethodCall( const all = [...callArgs, cb]; const key = `server.endcb:${fn}:${all.map((a) => typeKey(a.type)).join(",")}`; const existing = lowerer.arrHofHelpers.get(key); - const helper = existing ?? `%server.endcb.${lowerer.arrHofHelpers.size}`; + const helper = existing ?? keyedHelperName(lowerer, "%server.endcb", key); if (!existing) { lowerer.arrHofHelpers.set(key, helper); const params = all.map((a, i) => ({ localId: `p${i}.0`, name: `p${i}`, type: a.type })); diff --git a/packages/compiler/src/frontend/lowering/lower-stdlib.ts b/packages/compiler/src/frontend/lowering/lower-stdlib.ts index 2ad3657c7..0beb24a0e 100644 --- a/packages/compiler/src/frontend/lowering/lower-stdlib.ts +++ b/packages/compiler/src/frontend/lowering/lower-stdlib.ts @@ -2278,7 +2278,7 @@ function lowerStaticNamespaceImport( ): IrExpr { const loc = locOf(call); const resultT: IrType & { kind: "promise" } = { kind: "promise", inner: ns }; - const fnName = `%fn${lowerer.lambdaCounter++}_staticImport`; + const fnName = lowerer.closureName(loc, "_staticImport"); const fnType: IrType & { kind: "func" } = { kind: "func", params: [], ret: resultT }; const fnCtx = newFnCtx(true, null, fnType, ns); fnCtx.isAsync = true; diff --git a/packages/compiler/src/frontend/lowering/lower-stream.ts b/packages/compiler/src/frontend/lowering/lower-stream.ts index 33c842f6d..d6f89dc11 100644 --- a/packages/compiler/src/frontend/lowering/lower-stream.ts +++ b/packages/compiler/src/frontend/lowering/lower-stream.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { nodeThrowExpr, boolLit, numLit, strLit } from "../../ir/build.js"; import { isValueStream, valueStreamOf } from "./builtins/hash-stream.js"; import { InternalCompilerError } from "../../errors.js"; @@ -315,7 +316,7 @@ function lowerStreamCallback( ); } } - const fnName = `%fn${lowerer.lambdaCounter++}_${which}cb`; + const fnName = lowerer.closureName(loc, `_${which}cb`); const fnCtx = newFnCtx(true, null, funcType, funcType.ret); lowerer.fnStack.push(fnCtx); try { @@ -1148,7 +1149,7 @@ function streamMethodWrapper( paramTypes.push(got.type); } const ret = found.sig.ret; - const fnName = `%fn${lowerer.lambdaCounter++}_${which}vt`; + const fnName = lowerer.closureName(loc, `_${which}vt`); const funcType = funcOf([thisType, ...paramTypes], ret); lowerer.fnStack.push(newFnCtx(true, null, funcType, ret)); try { @@ -1694,7 +1695,7 @@ function fromGenHelpers( const key = `streamFromGen:${role}:${typeKey(gen)}`; let name = lowerer.valueHelpers.get(key); if (!name) { - name = `%stream.fromGen.${role}.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, `%stream.fromGen.${role}`, key); lowerer.valueHelpers.set(key, name); lowerer.liftedFns.push({ name, @@ -1783,7 +1784,7 @@ function classIteratorObject( const key = `streamFromIter:${cit.iterT.className}`; let name = lowerer.valueHelpers.get(key); if (!name) { - name = `%stream.fromIter.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, "%stream.fromIter", key); lowerer.valueHelpers.set(key, name); const nextName = `${name}.next`; const nextT = funcOf([], DYN); @@ -1944,7 +1945,7 @@ function classAsyncIteratorObject( const key = `streamFromAsyncIter:${cit.className}`; let name = lowerer.valueHelpers.get(key); if (!name) { - name = `%stream.fromAsyncIter.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, "%stream.fromAsyncIter", key); lowerer.valueHelpers.set(key, name); const it: IrLocal = { id: "it.0", name: "it", type: cit.iterT, mutable: false, boxed: true }; const src: IrLocal = { @@ -3128,7 +3129,7 @@ function pipelineBoxHelper( const key = `pipelineBox:${typeKey(promiseT)}`; let name = lowerer.valueHelpers.get(key); if (!name) { - name = `%stream.pipelineBox.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, "%stream.pipelineBox", key); lowerer.valueHelpers.set(key, name); lowerer.liftedFns.push({ name, @@ -3155,7 +3156,7 @@ function pipelineAbortHelper(lowerer: Lowerer, ac: IrExpr, loc: SrcLoc): IrExpr let name = lowerer.valueHelpers.get(key); const abortT = funcOf([], VOID); if (!name) { - name = `%stream.pipelineAbort.${lowerer.valueHelpers.size}`; + name = keyedHelperName(lowerer, "%stream.pipelineAbort", key); lowerer.valueHelpers.set(key, name); const acLocal: IrLocal = { id: "ac.0", name: "ac", type: DYN, mutable: false, boxed: true }; const acRef = varRef(acLocal.id, DYN, loc); diff --git a/packages/compiler/src/frontend/lowering/lower-timers.ts b/packages/compiler/src/frontend/lowering/lower-timers.ts index 7d4bba34b..03c9c5c1f 100644 --- a/packages/compiler/src/frontend/lowering/lower-timers.ts +++ b/packages/compiler/src/frontend/lowering/lower-timers.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { dynUndefinedExpr, numLit, varRef } from "../../ir/build.js"; import * as ts from "../ts7/adapter.js"; import { isJsSourceFile } from "../program.js"; @@ -55,7 +56,7 @@ export function adaptZeroArgTimerCallback( const toT: IrType = { kind: "func", params: [], ret: VOID }; const key = `timer.dropret:${typeKey(fromT)}`; const existing = lowerer.arrHofHelpers.get(key); - const name = existing ?? `%timer.dropret.${lowerer.arrHofHelpers.size}`; + const name = existing ?? keyedHelperName(lowerer, "%timer.dropret", key); if (!existing) { lowerer.arrHofHelpers.set(key, name); lowerer.liftedFns.push( @@ -117,7 +118,7 @@ export function adaptZeroArgTimerCallback( const toT: IrType = { kind: "func", params: [], ret: VOID }; const key = `timer.droparg:${typeKey(fromT)}`; const existing = lowerer.arrHofHelpers.get(key); - const name = existing ?? `%timer.droparg.${lowerer.arrHofHelpers.size}`; + const name = existing ?? keyedHelperName(lowerer, "%timer.droparg", key); if (!existing) { lowerer.arrHofHelpers.set(key, name); lowerer.liftedFns.push( @@ -203,7 +204,7 @@ function makeTimerArgsThunk( const toT: IrType = { kind: "func", params: [], ret: VOID }; const key = `timer.argsthunk:${n}`; const existing = lowerer.arrHofHelpers.get(key); - const name = existing ?? `%timer.argsthunk.${lowerer.arrHofHelpers.size}`; + const name = existing ?? keyedHelperName(lowerer, "%timer.argsthunk", key); if (!existing) { lowerer.arrHofHelpers.set(key, name); const impl = `${name}.impl`; diff --git a/packages/compiler/src/frontend/lowering/lowerer.test.ts b/packages/compiler/src/frontend/lowering/lowerer.test.ts index bacdc7941..7fbb9661f 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.test.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.test.ts @@ -10,6 +10,7 @@ import { } from "../../ir/ir.js"; import type { Node, Program, SourceFile, Symbol, Type } from "../ts7/adapter.js"; import { Lowerer } from "./lowerer.js"; +import { UnionRegistry } from "../type-mapper.js"; import { classMethodValue } from "./class-method-values.js"; const loc = { file: "island.ts", start: 0, end: 1 }; @@ -32,7 +33,7 @@ test("reuses complete copy routes without repeating discriminator planning", () expect(plan).not.toHaveBeenCalled(); expect(lowerer.liftedFns.filter((fn) => fn.name === helper)).toHaveLength(1); const recursive = {} as Type; - lowerer.shapes.recursiveRef(recursive); + lowerer.shapes.recursiveRef(recursive, () => "Recursive"); lowerer.shapes.finalizeRecursive(recursive, [{ name: "kind", type: STRING }]); expect(lowerer.unionRetagHelper(from, to, loc)).toBe(helper); expect(plan).toHaveBeenCalled(); @@ -54,7 +55,7 @@ test("replans after a recursive union gains its final arms", () => { const lowerer = context(); const recursive = {} as Type; const from = lowerer.unions.intern([UNDEFINED_T, NULL_T]); - const to = lowerer.unions.recursiveRef(recursive); + const to = lowerer.unions.recursiveRef(recursive, () => "Recursive"); const trapped = lowerer.unionRetagHelper(from, to, loc); expect(trapped).not.toBeNull(); lowerer.unions.finalizeRecursive(recursive, [UNDEFINED_T]); @@ -75,7 +76,7 @@ test("rechecks width conversions after recursive record definitions settle", () const lowerer = context(); const recursive = {} as Type; const source = record(lowerer.shapes.intern([{ name: "value", type: F64 }])); - const target = record(lowerer.shapes.recursiveRef(recursive)); + const target = record(lowerer.shapes.recursiveRef(recursive, () => "Recursive")); const from = lowerer.unions.intern([source, UNDEFINED_T]); const to = lowerer.unions.intern([target, NULL_T]); expect(lowerer.unionRetagHelper(from, to, loc)).not.toBeNull(); @@ -129,7 +130,7 @@ test("literal ownership is reused across values and rechecked when recursive rec expect(inspect).not.toHaveBeenCalled(); const recursive = {} as Type; - const pendingShape = record(lowerer.shapes.recursiveRef(recursive)); + const pendingShape = record(lowerer.shapes.recursiveRef(recursive, () => "Recursive")); const pending = lowerer.unions.intern([pendingShape], { field: "kind", cases: [{ tag: 0, values: ["a"] }], @@ -143,7 +144,7 @@ test("literal ownership is reused across values and rechecked when recursive rec test("literal ownership sees a recursive union's finalized discriminator", () => { const lowerer = context(); const recursive = {} as Type; - const union = lowerer.unions.recursiveRef(recursive); + const union = lowerer.unions.recursiveRef(recursive, () => "Recursive"); const shape = record(lowerer.shapes.intern([{ name: "kind", type: STRING }])); expect(lowerer.literalUnionArm(union, ["ready"])).toBeNull(); lowerer.unions.finalizeRecursive(recursive, [shape], { @@ -182,7 +183,10 @@ test("removing undefined reuses the discriminator transformation without hiding ); const recursive = {} as Type; - const pending: IrType = { kind: "union", unionId: lowerer.unions.recursiveRef(recursive) }; + const pending: IrType = { + kind: "union", + unionId: lowerer.unions.recursiveRef(recursive, () => "Recursive"), + }; expect(lowerer.stripUndefinedArm(pending)).toEqual(pending); lowerer.unions.finalizeRecursive(recursive, [STRING, UNDEFINED_T]); expect(lowerer.stripUndefinedArm(pending)).toEqual(STRING); @@ -215,7 +219,10 @@ test("adding undefined reuses semantic union transformations and sees recursive expect(lowerer.unions.get(added.unionId)?.discriminant).toEqual(discriminant); const recursive = {} as Type; - const pending: IrType = { kind: "union", unionId: lowerer.unions.recursiveRef(recursive) }; + const pending: IrType = { + kind: "union", + unionId: lowerer.unions.recursiveRef(recursive, () => "Recursive"), + }; const before = lowerer.withUndefinedArmOf(pending); lowerer.unions.finalizeRecursive(recursive, [a, b], discriminant); expect(lowerer.withUndefinedArmOf(pending)).toEqual(added); @@ -227,13 +234,18 @@ test("adding undefined reuses semantic union transformations and sees recursive test("optional union widening keeps refused and missing contracts current", () => { const lowerer = context(); const recursive = {} as Type; - const pending: IrType = { kind: "union", unionId: lowerer.unions.recursiveRef(recursive) }; + const pending: IrType = { + kind: "union", + unionId: lowerer.unions.recursiveRef(recursive, () => "Recursive"), + }; expect(lowerer.withUndefinedArmOf(pending)).not.toBeNull(); lowerer.unions.finalizeRecursive(recursive, [{ kind: "date" }, STRING]); expect(lowerer.withUndefinedArmOf(pending)).toBeNull(); expect(lowerer.withUndefinedArmOf(pending)).toBeNull(); - const missing: IrType = { kind: "union", unionId: `u${lowerer.unions.unions.length}` }; + // Union ids come from their arms, so a fresh registry names the union + // this one has not interned yet. + const missing: IrType = { kind: "union", unionId: new UnionRegistry().intern([F64, STRING]) }; expect(lowerer.withUndefinedArmOf(missing)).toBeNull(); expect(lowerer.unions.intern([F64, STRING])).toBe(missing.unionId); expect(lowerer.withUndefinedArmOf(missing)?.kind).toBe("union"); diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts index ac68fc972..d8b86b59a 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -1,4 +1,6 @@ import { relieveHeapPressure } from "../../heap-pressure.js"; +import { keyedHelperName } from "./stable-names.js"; +import { positionTag, StructuralPositions } from "./structural-positions.js"; import { onlyForwarded, stripTypeWrappers } from "./typed-arguments.js"; import { needsGeneralNodeStreams, @@ -1004,6 +1006,11 @@ function lowerShuffle(): ((wave: string[]) => void) | null { * the bodies reachable emit did NOT mark (plus deferred collection * diagnostics nothing flushed), reported separately: whole-program analysis without * letting unreached code fail builds. */ +/** The closure root of an emit-override specialization body. */ +function emitSpecRoot(spec: EmitSpecRequest): string { + return `%emit.${spec.info.def.name}.${spec.event}.${spec.ordinal}`; +} + export function lowerToIr( program: ts.Program, entry: ts.SourceFile, @@ -2807,6 +2814,8 @@ export class Lowerer { /** Generated value helpers, keyed by operation and type. Callers own * their key prefixes; this includes more than structural conversions. */ readonly valueHelpers = new Map(); + /** Each name keyedHelperName made, with a second hash of its key. */ + readonly keyedNameKeys = new Map(); /** structuralNarrowing's assignable classes, keyed by static and * narrowed class name. */ readonly structuralClassPeers = new Map(); @@ -2943,7 +2952,6 @@ export class Lowerer { ctx: FnCtx; } >(); - chainCounter = 0; /** Keyed by program-wide qualified class name (what IR object types carry). */ readonly classes = new Map(); readonly classBySymbol = new Map(); @@ -3173,7 +3181,53 @@ export class Lowerer { * dispatch revision needs no weak-key identity or process-global state. */ errorMethodDispatchRevision: string | null = null; errorPropertyDispatchRevision: string | null = null; - lambdaCounter = 0; + /** Structural source positions (structural-positions.ts) for names that + * stay the same when unrelated code moves. */ + /** Default library files are named by their base name: two checkers + * install them in different directories. */ + readonly positions = new StructuralPositions((sf) => + this.program.isSourceFileDefaultLibrary(sf) + ? `lib:${sf.fileName.slice(sf.fileName.lastIndexOf("/") + 1)}` + : sf.fileName, + ); + + /** The outermost node whose token span is exactly `loc`, or null. */ + nodeAtLoc(loc: SrcLoc): ts.Node | null { + const sf = this.program.getSourceFile(loc.file); + return sf === undefined ? null : (ts.nodeAtSpan(sf, loc.start, loc.end) ?? null); + } + + /** The lowering unit whose name scopes the closures it lifts. */ + private closureRoot = "%pre"; + private readonly closureNameCounts = new Map(); + + /** Runs `fn` with the closures it lifts named under `root`. */ + withClosureRoot(root: string, fn: () => T): T { + const previous = this.closureRoot; + this.closureRoot = root; + try { + return fn(); + } finally { + this.closureRoot = previous; + } + } + + /** The name of a closure (or wrapper) lifted for the source at `loc`: + * `.` of the current lowering unit, the location and + * `suffix`, then `suffix`. A unit that lifts several functions for the same + * location and suffix numbers them in the order it lifts them, so a + * closure's name depends only on its unit, not on which units lowered + * before it. */ + closureName(loc: SrcLoc, suffix = "", prefix = "%fn"): string { + const node = this.nodeAtLoc(loc); + const where = node === null ? `${loc.file}:${loc.start}:${loc.end}` : this.positions.of(node); + const key = `${prefix}|${this.closureRoot}|${where}|${suffix}`; + const first = keyedHelperName(this, prefix, key); + const seen = this.closureNameCounts.get(first) ?? 0; + this.closureNameCounts.set(first, seen + 1); + return (seen === 0 ? first : keyedHelperName(this, prefix, `${key}|${seen}`)) + suffix; + } + readonly preparedClassFactories = new Map(); readonly preparingClassFactories = new Set(); @@ -3526,6 +3580,7 @@ export class Lowerer { this.checker = program.getTypeChecker(); this.typeCtx = { checker: this.checker, + positionOf: (node) => this.positions.of(node), shapes: this.shapes, unions: this.unions, classNamer: this.classNamer, @@ -3818,11 +3873,11 @@ export class Lowerer { })() ? this.qualify( ts.getSourceFileOfNode(decl), - `%cx${ts.tokenStartOfNode(decl)}.${decl.name?.text ?? ""}`, + `%cx${positionTag(this, decl)}.${decl.name?.text ?? ""}`, ) : this.qualify( ts.getSourceFileOfNode(decl), - nsPathPrefix(decl) + (decl.name ? decl.name.text : "%anon"), + nsPathPrefix(this, decl) + (decl.name ? decl.name.text : "%anon"), ); for (let index = this.localClassInstantiations.length - 1; index >= 0; index--) { const entry = this.localClassInstantiations[index]!; @@ -7381,7 +7436,10 @@ export class Lowerer { } for (const decl of fp.classDecls) { const info = this.classes.get(this.classNamer(decl)); - if (info) functions.push(...this.lowerClassMembers(info)); + if (info) + functions.push( + ...this.withClosureRoot(info.def.name, () => this.lowerClassMembers(info)), + ); else if (this.countsSkips()) this.countSkippedBody(decl); } } @@ -7394,7 +7452,10 @@ export class Lowerer { // are reachable by definition, already counted by reachable emit. if (!this.remainder) { for (const fp of parts) { - functions.push(this.lowerFileInit(fp.sf, fp.topStmts, this.initNameOf.get(fp.sf)!)); + const initName = this.initNameOf.get(fp.sf)!; + functions.push( + this.withClosureRoot(initName, () => this.lowerFileInit(fp.sf, fp.topStmts, initName)), + ); } functions.push(this.buildMain()); } @@ -7436,7 +7497,9 @@ export class Lowerer { // default): the diagnostic is recorded — the instance skips // like a signature-blocked function (lowerFunction's rule). try { - functions.push(this.lowerGenericInstance(info, inst)); + functions.push( + this.withClosureRoot(inst.name, () => this.lowerGenericInstance(info, inst)), + ); } catch (e) { if (!(e instanceof PoisonError)) throw e; } @@ -7446,7 +7509,10 @@ export class Lowerer { // instances of its own; the joint fixpoint covers both). while (es < this.emitSpecQueue.length) { try { - const fn = lowerEmitOverrideSpec(this, this.emitSpecQueue[es++]!); + const spec = this.emitSpecQueue[es++]!; + const fn = this.withClosureRoot(emitSpecRoot(spec), () => + lowerEmitOverrideSpec(this, spec), + ); if (fn) functions.push(fn); } catch (e) { if (!(e instanceof PoisonError)) throw e; @@ -8000,7 +8066,9 @@ export class Lowerer { this.genericClassDemandPriority.set(info, ref); instanceFunctions.push( ...this.withGenericDemandOwner(owner, () => - this.shapes.withDeclaredOrderPriority(ref, () => this.lowerClassMembers(info)), + this.shapes.withDeclaredOrderPriority(ref, () => + this.withClosureRoot(info.def.name, () => this.lowerClassMembers(info)), + ), ), ); relieveHeapPressure(); @@ -8027,7 +8095,7 @@ export class Lowerer { instanceFunctions.push( this.withGenericDemandOwner(owner, () => this.shapes.withDeclaredOrderPriority(ref, () => - this.lowerGenericInstance(info, inst), + this.withClosureRoot(inst.name, () => this.lowerGenericInstance(info, inst)), ), ), ); @@ -8060,9 +8128,12 @@ export class Lowerer { ); while (specLowered < waveEnd) { try { - const fn = this.shapes.withDeclaredOrderPriority([4, instanceMetadataOrder++], () => - lowerEmitOverrideSpec(this, this.emitSpecQueue[specLowered++]!), - ); + const fn = this.shapes.withDeclaredOrderPriority([4, instanceMetadataOrder++], () => { + const spec = this.emitSpecQueue[specLowered++]!; + return this.withClosureRoot(emitSpecRoot(spec), () => + lowerEmitOverrideSpec(this, spec), + ); + }); if (fn) instanceFunctions.push(fn); } catch (e) { if (!(e instanceof PoisonError)) throw e; @@ -8090,7 +8161,9 @@ export class Lowerer { initFunctions.push( this.withGenericDemandOwner(owner, () => this.shapes.withDeclaredOrderPriority(priority, () => - this.lowerFileInit(fp.sf, fp.topStmts, this.initNameOf.get(fp.sf)!), + this.withClosureRoot(this.initNameOf.get(fp.sf)!, () => + this.lowerFileInit(fp.sf, fp.topStmts, this.initNameOf.get(fp.sf)!), + ), ), ), ); @@ -8116,7 +8189,9 @@ export class Lowerer { const priority = metadataPriority.get(name) ?? [3, expressionMetadataOrder++]; const owner = demandOwner(priority); const fn = this.withGenericDemandOwner(owner, () => - this.shapes.withDeclaredOrderPriority(priority, unit.lower), + this.shapes.withDeclaredOrderPriority(priority, () => + this.withClosureRoot(name, unit.lower), + ), ); if (fn) loweredUnits.set(name, fn); relieveHeapPressure(); @@ -13504,7 +13579,7 @@ export class Lowerer { const key = `${fn.valueFn ?? fn.fn}:${typeKey(funcType)}:${adapterShape}`; let fnName = this.builtinCallableValueFns.get(key); if (!fnName) { - fnName = `%builtin.value.${fn.valueFn ?? fn.fn}.${this.builtinCallableValueFns.size}`; + fnName = keyedHelperName(this, `%builtin.value.${fn.valueFn ?? fn.fn}`, key); this.builtinCallableValueFns.set(key, fnName); this.builtinCallableValueNames.set(fnName, display.slice(display.lastIndexOf(".") + 1)); const params = funcType.params.map((type, index) => ({ diff --git a/packages/compiler/src/frontend/lowering/native-ffi.ts b/packages/compiler/src/frontend/lowering/native-ffi.ts index 0f932ba93..62f2be9f1 100644 --- a/packages/compiler/src/frontend/lowering/native-ffi.ts +++ b/packages/compiler/src/frontend/lowering/native-ffi.ts @@ -562,7 +562,7 @@ export function lowerFfiMemoryModule(lowerer: Lowerer, loc: SrcLoc): IrExpr { const entries = lowerer.ffiImports .filter((entry) => entry.library !== undefined) .map((entry) => { - const name = `%ffi.module.${lowerer.lambdaCounter++}`; + const name = lowerer.closureName(loc, "", "%ffi.module"); const sourceTypes = ffiSourceParamTypes(entry.params); const locals: IrLocal[] = sourceTypes.map((_, i) => ({ id: `%arg${i}`, diff --git a/packages/compiler/src/frontend/lowering/object-enumeration-receiver.ts b/packages/compiler/src/frontend/lowering/object-enumeration-receiver.ts index 855da3bda..388ac3904 100644 --- a/packages/compiler/src/frontend/lowering/object-enumeration-receiver.ts +++ b/packages/compiler/src/frontend/lowering/object-enumeration-receiver.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { BOOL, STRING, @@ -27,7 +28,7 @@ export function objectEnumerationReceiver( const key = `obj.receiver:${source.unionId}:${expected.shapeId}`; let name = lowerer.arrHofHelpers.get(key); if (name === undefined) { - name = `%obj.receiver.${lowerer.arrHofHelpers.size}`; + name = keyedHelperName(lowerer, "%obj.receiver", key); lowerer.arrHofHelpers.set(key, name); const value = varRef("value.0", source, loc); lowerer.liftedFns.push({ diff --git a/packages/compiler/src/frontend/lowering/pairs-snapshot.ts b/packages/compiler/src/frontend/lowering/pairs-snapshot.ts index 3b33fb0cd..acf7b3bf9 100644 --- a/packages/compiler/src/frontend/lowering/pairs-snapshot.ts +++ b/packages/compiler/src/frontend/lowering/pairs-snapshot.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { arrayOf, BOOL, @@ -49,7 +50,7 @@ export function pairsSnapshotHelper( const key = `${options.keyPrefix}.snapshot:${shapeId}`; const existing = lowerer.valueHelpers.get(key); if (existing) return existing; - const name = `%${options.keyPrefix}.snapshot.${lowerer.valueHelpers.size}`; + const name = keyedHelperName(lowerer, `%${options.keyPrefix}.snapshot`, key); lowerer.valueHelpers.set(key, name); const recordType: IrType = { kind: "record", shapeId }; const pairsType = arrayOf(STRING); diff --git a/packages/compiler/src/frontend/lowering/promise-executor-adapter.ts b/packages/compiler/src/frontend/lowering/promise-executor-adapter.ts index 09d228b05..84aa8dac0 100644 --- a/packages/compiler/src/frontend/lowering/promise-executor-adapter.ts +++ b/packages/compiler/src/frontend/lowering/promise-executor-adapter.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { varRef } from "../../ir/build.js"; import { type IrExpr, @@ -40,7 +41,7 @@ export function adaptPromiseExecutor( const key = `promise.executor:${typeKey(execT)}:${typeKey(inner)}`; let name = lowerer.arrHofHelpers.get(key); if (name === undefined) { - name = `%promise.executor.${lowerer.arrHofHelpers.size}`; + name = keyedHelperName(lowerer, "%promise.executor", key); lowerer.arrHofHelpers.set(key, name); const impl = `${name}.impl`; const captured: IrLocal = { id: "f.0", name: "f", type: execT, mutable: false, boxed: true }; diff --git a/packages/compiler/src/frontend/lowering/require-initialization.ts b/packages/compiler/src/frontend/lowering/require-initialization.ts index d979423b0..c8fc9c730 100644 --- a/packages/compiler/src/frontend/lowering/require-initialization.ts +++ b/packages/compiler/src/frontend/lowering/require-initialization.ts @@ -9,6 +9,7 @@ * and every reference that can run earlier checks it first — the same * module.tdzCheck the import-cycle bindings use. A reference whose lowering * leaves no expression to check keeps the SC1013 fence. */ +import { positionTag } from "./structural-positions.js"; import * as ts from "../ts7/adapter.js"; import type { Lowerer } from "./lowerer.js"; import { @@ -119,7 +120,7 @@ export function markRequireEarlyBindings(lowerer: Lowerer): void { const tag = rawTag === "" ? "e." : rawTag.replace(/^%/, ""); const bySymbol = new Map(); for (const { decl } of declared) { - const flagId = `%g.${tag}%required.${ts.tokenStartOfNode(decl)}`; + const flagId = `%g.${tag}%required.${positionTag(lowerer, decl)}`; lowerer.globalsList.push({ id: flagId, name: "%initialized", type: BOOL, mutable: true }); const flag: RequireInitFlag = { flagId, names: new Map() }; for (const id of boundNames(decl.name)) { diff --git a/packages/compiler/src/frontend/lowering/stable-names.ts b/packages/compiler/src/frontend/lowering/stable-names.ts new file mode 100644 index 000000000..8f7d0967e --- /dev/null +++ b/packages/compiler/src/frontend/lowering/stable-names.ts @@ -0,0 +1,48 @@ +import { InternalCompilerError } from "../../errors.js"; + +/** The owner of the names keyedHelperName hands out. */ +export interface KeyedNameOwner { + /** Each keyed name with a second hash of the key it was made from, which + * tells a repeated key from a different key with the same name. */ + readonly keyedNameKeys: Map; +} + +/** 48 bits of two FNV-1a hashes of `key`, as 12 hex digits. */ +function keyHash(key: string): string { + let a = 0x811c9dc5; + let b = 0x01000193 ^ 0x5bd1e995; + for (let i = 0; i < key.length; i++) { + const c = key.charCodeAt(i); + a = Math.imul(a ^ c, 0x01000193); + b = Math.imul(b ^ c, 0x01000193) ^ (b >>> 13); + } + const high = (b >>> 0).toString(16).padStart(8, "0").slice(4); + return high + (a >>> 0).toString(16).padStart(8, "0"); +} + +/** A 32-bit hash of `key` independent of keyHash's bits. */ +function checkHash(key: string): number { + let h = 0x9e3779b9; + for (let i = 0; i < key.length; i++) + h = Math.imul(h ^ key.charCodeAt(i), 0x85ebca6b) ^ (h >>> 15); + return h >>> 0; +} + +/** The name of a helper interned by `key`: ``. It depends only on the key, not on how many helpers were interned + * before, so a helper has the same name whichever unit first needs it. Two + * keys that hash to the same name throw an InternalCompilerError. */ +export function keyedHelperName( + owner: KeyedNameOwner, + prefix: string, + key: string, + separator = ".", +): string { + const name = `${prefix}${separator}${keyHash(key)}`; + const check = checkHash(key); + const previous = owner.keyedNameKeys.get(name); + if (previous === undefined) owner.keyedNameKeys.set(name, check); + else if (previous !== check) + throw new InternalCompilerError(`helper name ${name} is shared by two helper keys`); + return name; +} diff --git a/packages/compiler/src/frontend/lowering/strict-equality.ts b/packages/compiler/src/frontend/lowering/strict-equality.ts index 7b9b6902b..8a87c8111 100644 --- a/packages/compiler/src/frontend/lowering/strict-equality.ts +++ b/packages/compiler/src/frontend/lowering/strict-equality.ts @@ -1,3 +1,4 @@ +import { keyedHelperName } from "./stable-names.js"; import { boolLit, varRef } from "../../ir/build.js"; import { BOOL, @@ -135,7 +136,7 @@ export function lowerUnionEquality( loc, ); if (!result) return null; - name = `%value.eq.${lowerer.equalityHelpers.size}`; + name = keyedHelperName(lowerer, "%value.eq", key); lowerer.equalityHelpers.set(key, name); lowerer.liftedFns.push({ name, diff --git a/packages/compiler/src/frontend/lowering/structural-positions.ts b/packages/compiler/src/frontend/lowering/structural-positions.ts new file mode 100644 index 000000000..43b6d4a79 --- /dev/null +++ b/packages/compiler/src/frontend/lowering/structural-positions.ts @@ -0,0 +1,111 @@ +import * as ts from "../ts7/adapter.js"; +import { keyedHelperName, type KeyedNameOwner } from "./stable-names.js"; + +/** The declaration kinds whose names anchor the positions inside them. */ +const ANCHOR_KINDS: ReadonlySet = new Set([ + ts.SyntaxKind.FunctionDeclaration, + ts.SyntaxKind.ClassDeclaration, + ts.SyntaxKind.ClassExpression, + ts.SyntaxKind.VariableDeclaration, + ts.SyntaxKind.MethodDeclaration, + ts.SyntaxKind.GetAccessor, + ts.SyntaxKind.SetAccessor, + ts.SyntaxKind.PropertyDeclaration, + ts.SyntaxKind.PropertyAssignment, + ts.SyntaxKind.ModuleDeclaration, + ts.SyntaxKind.EnumDeclaration, + ts.SyntaxKind.Constructor, + ts.SyntaxKind.InterfaceDeclaration, + ts.SyntaxKind.TypeAliasDeclaration, +]); + +/** The name of `node` when it is a named declaration that anchors the + * positions of the nodes inside it, or null. */ +function anchorName(node: ts.Node): string | null { + return ts.declarationNameAt(node, node.index, ANCHOR_KINDS); +} + +/** The nearest enclosing anchor of `node` (not `node` itself), or its + * source file. */ +function anchorOf(node: ts.Node): ts.Node { + for (let parent = node.parent; parent !== undefined; parent = parent.parent) { + if (ts.isSourceFile(parent) || anchorName(parent) !== null) return parent; + } + return ts.getSourceFileOfNode(node); +} + +/** Source positions that stay the same when code outside the enclosing + * declaration changes. A node's structural position is its file, the chain + * of enclosing named declarations (each with its kind, its name and its + * ordinal among the declarations of the same kind and name in its own + * anchor), and its ordinal among the nodes of its kind whose nearest anchor + * is the same declaration. Editing another declaration, or code nested in another + * named declaration of the same anchor, leaves the position unchanged. */ +export class StructuralPositions { + /** Per anchor and key: the indices of the nodes with that key whose + * nearest anchor it is, in preorder (anchoredNodes). */ + private readonly nodesByKey = new Map>(); + private readonly paths = new Map(); + + /** `fileKey` names a source file in positions (its file name when + * absent). */ + constructor(private readonly fileKey?: (sf: ts.SourceFile) => string) {} + + /** The ordinal of `node` among the nodes of `anchor` with its key. */ + private ordinalIn(anchor: ts.Node, node: ts.Node, key: string): number { + let byKey = this.nodesByKey.get(anchor); + if (byKey === undefined) this.nodesByKey.set(anchor, (byKey = new Map())); + let indices = byKey.get(key); + if (indices === undefined) { + indices = ts.anchoredNodes(anchor, key, ANCHOR_KINDS); + byKey.set(key, indices); + } + // Indices increase in preorder. + let low = 0; + let high = indices.length - 1; + while (low <= high) { + const middle = (low + high) >> 1; + const at = indices[middle]!; + if (at === node.index) return middle; + if (at < node.index) low = middle + 1; + else high = middle - 1; + } + return -1; + } + + /** The anchor chain of `anchor` from the file down. */ + private pathOf(anchor: ts.Node): string { + const cached = this.paths.get(anchor); + if (cached !== undefined) return cached; + let path: string; + if (ts.isSourceFile(anchor)) path = this.fileKey?.(anchor) ?? anchor.fileName; + else { + const parent = anchorOf(anchor); + // The kind keeps declarations of one name apart: a getter and its + // setter, or a class and the namespace merged with it. + const key = `${anchor.kind}:${anchorName(anchor)}`; + path = `${this.pathOf(parent)}/${key}#${this.ordinalIn(parent, anchor, key)}`; + } + this.paths.set(anchor, path); + return path; + } + + /** The structural position of `node`. */ + of(node: ts.Node): string { + const anchor = anchorOf(node); + const name = anchorName(node); + const key = name === null ? `${node.kind}` : `${node.kind}:${name}`; + return `${this.pathOf(anchor)}|${key}#${this.ordinalIn(anchor, node, key)}`; + } +} + +/** The owner of structural positions and the names made from them. */ +export interface PositionTagOwner extends KeyedNameOwner { + readonly positions: StructuralPositions; +} + +/** A short tag for `node`'s structural position, for names that must stay + * unique per source node (class expressions, namespace blocks). */ +export function positionTag(owner: PositionTagOwner, node: ts.Node): string { + return keyedHelperName(owner, "", owner.positions.of(node), ""); +} diff --git a/packages/compiler/src/frontend/ts7/ast.ts b/packages/compiler/src/frontend/ts7/ast.ts index 369213d89..0bddd1a80 100644 --- a/packages/compiler/src/frontend/ts7/ast.ts +++ b/packages/compiler/src/frontend/ts7/ast.ts @@ -47,8 +47,9 @@ import { } from "./ast-guards.generated.js"; import type { Ts7DiagnosticData as Diagnostic } from "./session-schema.generated.js"; import { ModifierFlags, SyntaxKind } from "./enums.js"; -import { AstKind } from "./ast-schema.generated.js"; +import { AstKind, KIND_NODE_LIST } from "./ast-schema.generated.js"; import { PREORDER_LIST } from "./ast-wire.js"; +import { tokenStartOfNode } from "./node-functions.js"; /* ---- everything 7 kept under the same name ---- */ @@ -196,6 +197,93 @@ function walkLinkedPreorder( } } +/** The semantic children of a wire node: list items stand in for their + * list, and attached JSDoc trees are left out (the walkPreorder view). */ +function semanticChildIndices(root: Node, index: number, out: number[]): void { + const wire = root.file.wire; + for (let child = wire.firstChild(index); child !== 0; child = wire.next(child)) { + const kind = wire.kind(child); + if (kind === KIND_NODE_LIST) { + for (let item = wire.firstChild(child); item !== 0; item = wire.next(item)) out.push(item); + } else if (kind !== AstKind.JSDoc) out.push(child); + } +} + +/** The outermost node of `sourceFile` whose token span is exactly + * [start, end), or undefined. Only nodes ending at `end` are + * materialized. */ +export function nodeAtSpan(sourceFile: SourceFile, start: number, end: number): Node | undefined { + const wire = sourceFile.file.wire; + const children: number[] = []; + let index = sourceFile.index; + for (;;) { + children.length = 0; + semanticChildIndices(sourceFile, index, children); + let next = 0; + for (const child of children) { + if (wire.pos(child) > start || wire.end(child) < end) continue; + if (wire.end(child) === end) { + const node = sourceFile.file.node(child); + if (tokenStartOfNode(node) === start) return node; + } + next = child; + break; + } + if (next === 0) return undefined; + index = next; + } +} + +/** The name of the declaration at wire `index` in `root`'s file when its + * kind is in `kinds`: its identifier, private identifier or string literal + * name, "constructor" for a constructor, or null. Reads the wire without + * materializing nodes. */ +export function declarationNameAt( + root: Node, + index: number, + kinds: ReadonlySet, +): string | null { + const wire = root.file.wire; + const kind = wire.kind(index); + if (!kinds.has(kind)) return null; + if (kind === SyntaxKind.Constructor) return "constructor"; + const name = wire.namedChild(index, "name"); + if (name === 0) return null; + const nameKind = wire.kind(name); + if ( + nameKind !== SyntaxKind.Identifier && + nameKind !== SyntaxKind.PrivateIdentifier && + nameKind !== SyntaxKind.StringLiteral + ) + return null; + return wire.text(name) ?? null; +} + +/** The indices, in preorder, of the nodes below `root` that have `key` and + * are not inside a nested named declaration (declarationNameAt with + * `kinds`). A named declaration is keyed `:` and its subtree is + * not visited; other nodes are keyed by their kind. No node is + * materialized. */ +export function anchoredNodes(root: Node, key: string, kinds: ReadonlySet): number[] { + const wire = root.file.wire; + const out: number[] = []; + const children: number[] = []; + const stack: number[] = []; + semanticChildIndices(root, root.index, children); + for (let i = children.length - 1; i >= 0; i--) stack.push(children[i]!); + while (stack.length > 0) { + const index = stack.pop()!; + const kind = wire.kind(index); + const name = declarationNameAt(root, index, kinds); + if ((name === null ? String(kind) : `${kind}:${name}`) === key) out.push(index); + if (name !== null) continue; + children.length = 0; + semanticChildIndices(root, index, children); + for (let i = children.length - 1; i >= 0; i--) stack.push(children[i]!); + } + return out; +} + export function getLineAndCharacterOfPosition( sourceFile: SourceFile, position: number, diff --git a/packages/compiler/src/frontend/type-mapper.test.ts b/packages/compiler/src/frontend/type-mapper.test.ts index cf78554b4..163ba7b9e 100644 --- a/packages/compiler/src/frontend/type-mapper.test.ts +++ b/packages/compiler/src/frontend/type-mapper.test.ts @@ -41,7 +41,7 @@ describe("union arm lookup", () => { test("sees finalized recursive arms after a missing lookup", () => { const unions = new UnionRegistry(); const recursive = {} as Type; - const union = unions.recursiveRef(recursive); + const union = unions.recursiveRef(recursive, () => "Recursive"); expect(unions.armTag(union, STRING)).toBe(-1); unions.finalizeRecursive(recursive, [ F64, diff --git a/packages/compiler/src/frontend/type-mapper.ts b/packages/compiler/src/frontend/type-mapper.ts index af88a7448..9abd5a0b0 100644 --- a/packages/compiler/src/frontend/type-mapper.ts +++ b/packages/compiler/src/frontend/type-mapper.ts @@ -1,4 +1,5 @@ import { InternalCompilerError } from "../errors.js"; +import { keyedHelperName, type KeyedNameOwner } from "./lowering/stable-names.js"; import { mockCallRecordType, mockContextType } from "./mock-shapes.js"; import * as ts from "./ts7/adapter.js"; import { bodyReadsArguments } from "./arguments-usage.js"; @@ -262,6 +263,8 @@ function comparePriority(left: DeclaredOrderPriority, right: DeclaredOrderPriori export class ShapeRegistry { /** Existing layouts change only when a recursive placeholder closes. */ revision = 0; + /** Each shape id with a second hash of its key (keyedHelperName). */ + readonly keyedNameKeys = new Map(); private readonly byKey = new Map(); private readonly byId = new Map(); /** Historical emit-order rank of the declaration-order metadata each @@ -280,7 +283,7 @@ export class ShapeRegistry { * writer after all priority candidates have closed. */ private readonly derivedDeclaredOrderFinalizers: (() => void)[] = []; private currentDeclaredOrderPriority: DeclaredOrderPriority = [0, 0]; - /** All interned shapes in first-seen (`r0`, `r1`, ...) order. */ + /** All interned shapes in first-seen order. */ readonly shapes: IrRecordShape[] = []; /** ts.Types currently being mapped — a BACK-REFERENCE to one of these is * the recursive knot (`interface TreeNode { children: TreeNode[] }`): @@ -400,11 +403,12 @@ export class ShapeRegistry { /** The shape id a back-reference to an in-progress type resolves to: * reuses the type's persistent recursive id or mints a PLACEHOLDER - * entry (empty fields) the outer frame finalizes. */ - recursiveRef(t: ts.Type): string { + * entry (empty fields) the outer frame finalizes. `describe` names a new + * placeholder (checkerTypeDescription). */ + recursiveRef(t: ts.Type, describe: () => string): string { let id = this.recIds.get(t); if (id === undefined) { - id = `r${this.shapes.length}`; + id = recursivePlaceholderName(this, "r", describe(), (name) => this.byId.has(name)); const shape: IrRecordShape = { id, fields: [] }; this.byId.set(id, shape); this.shapes.push(shape); @@ -473,7 +477,7 @@ export class ShapeRegistry { const key = this.keyOf(fields, tuple, indexValue); let id = this.byKey.get(key); if (id === undefined) { - id = `r${this.shapes.length}`; + id = keyedHelperName(this, "r", key, ""); const shape: IrRecordShape = { id, fields, @@ -551,6 +555,58 @@ export class ShapeRegistry { } } +/** The id of a recursive placeholder described by `description`. Two + * different types can still share a description (checkerTypeDescription stops + * after a few levels of type arguments); the later one takes the first free + * name with a numbered suffix. */ +function recursivePlaceholderName( + owner: KeyedNameOwner, + prefix: string, + description: string, + taken: (name: string) => boolean, +): string { + let name = keyedHelperName(owner, prefix, `recursive:${description}`, ""); + for (let n = 1; taken(name); n++) + name = keyedHelperName(owner, prefix, `recursive:${description}#${n}`, ""); + return name; +} + +/** How many levels of type arguments checkerTypeDescription describes. */ +const RECURSIVE_NAME_DEPTH = 3; + +/** A checker type's description for names that must not depend on checker + * type ids (a recursive placeholder, a generic class instance keyed by a + * literal): its printed form, the structural position of its first + * declaration, and the same for its type arguments (two instantiations + * print the same when their type arguments are type parameters or classes + * of the same name from different declarations). */ +export function checkerTypeDescription( + t: ts.Type, + ctx: Pick, + depth = 0, +): string { + const symbol = t.getAliasSymbol() ?? t.getSymbol(); + const declaration = symbol?.declarations[0]; + const where = declaration + ? (ctx.positionOf?.(declaration) ?? + `${ts.getSourceFileOfNode(declaration).fileName}:${declaration.pos}`) + : ""; + let description = `${ctx.checker.typeToString(t)}@${where}`; + if (depth < RECURSIVE_NAME_DEPTH) { + const aliasArguments = + t.getAliasSymbol() !== undefined ? (t.getAliasTypeArguments() ?? []) : []; + const typeArguments = + aliasArguments.length > 0 + ? aliasArguments + : t.isTypeReference() + ? ctx.checker.getTypeArguments(t) + : []; + if (typeArguments.length > 0) + description += `<${typeArguments.map((arg) => checkerTypeDescription(arg, ctx, depth + 1)).join(",")}>`; + } + return description; +} + /** The frontend's union interner — mirrors ShapeRegistry. A union's * canonical identity includes its typeKey-sorted arms and literal * discriminator contract. An arm's index in that list IS its runtime tag. @@ -558,10 +614,12 @@ export class ShapeRegistry { export class UnionRegistry { /** Existing arm/discriminator contracts change when a placeholder closes. */ revision = 0; + /** Each union id with a second hash of its key (keyedHelperName). */ + readonly keyedNameKeys = new Map(); private readonly byKey = new Map(); private readonly byId = new Map(); private readonly armTags = new Map>(); - /** All interned unions in first-seen (`u0`, `u1`, ...) order. */ + /** All interned unions in first-seen order. */ readonly unions: IrUnionDef[] = []; /** ts.Types currently being mapped — a back-reference to one is the * recursive knot passing through a union (`type Tree = Leaf | Branch` @@ -577,11 +635,12 @@ export class UnionRegistry { /** The union id a back-reference to an in-progress union resolves to: * reuses the type's persistent recursive id or mints a PLACEHOLDER - * entry (empty arms) the outer frame finalizes. */ - recursiveRef(t: ts.Type): string { + * entry (empty arms) the outer frame finalizes. `describe` names a new + * placeholder (checkerTypeDescription). */ + recursiveRef(t: ts.Type, describe: () => string): string { let id = this.recIds.get(t); if (id === undefined) { - id = `u${this.unions.length}`; + id = recursivePlaceholderName(this, "u", describe(), (name) => this.byId.has(name)); const def: IrUnionDef = { id, arms: [] }; this.byId.set(id, def); this.unions.push(def); @@ -631,7 +690,7 @@ export class UnionRegistry { const key = JSON.stringify([arms.map(typeKey), discriminant]); let id = this.byKey.get(key); if (id === undefined) { - id = `u${this.unions.length}`; + id = keyedHelperName(this, "u", key, ""); const def: IrUnionDef = { id, arms, ...(discriminant ? { discriminant } : {}) }; this.byKey.set(key, id); this.byId.set(id, def); @@ -1131,6 +1190,10 @@ export interface TypeMapperCtx { * instance being lowered, the instantiated result at its calls. */ localClassValue?: (type: ts.Type) => IrType | null; checker: ts.TypeChecker; + /** The structural position of a declaration (structural-positions.ts), + * which names recursive placeholders independently of where unrelated + * code sits. The Lowerer supplies it. */ + positionOf?: (node: ts.Node) => string; /** JavaScript declarations whose instance or object-literal types only * the checked-dynamic representation holds (js-dynamic-objects.ts). * Absent when the program has none: every mapping is unchanged. */ @@ -4672,7 +4735,10 @@ function mapTypeInner(type: ts.Type, ctx: TypeMapperCtx): IrType | null { const knownRecursive = unions.recursiveUnionFor(widened); if (knownRecursive !== undefined) return { kind: "union", unionId: knownRecursive }; if (unions.inProgress.has(widened)) { - return { kind: "union", unionId: unions.recursiveRef(widened) }; + return { + kind: "union", + unionId: unions.recursiveRef(widened, () => checkerTypeDescription(widened, ctx)), + }; } unions.inProgress.add(widened); const sensitivityAtEntry = contextResolutions; @@ -7016,7 +7082,10 @@ function mapRecordType(widened: ts.Type, ctx: TypeMapperCtx): IrType | null { // frame completes (finalizeRecursive below). Backends represent records // as heap references, so the self-reference is an ordinary pointer. if (shapes.inProgress.has(widened)) { - return { kind: "record", shapeId: shapes.recursiveRef(widened) }; + return { + kind: "record", + shapeId: shapes.recursiveRef(widened, () => checkerTypeDescription(widened, ctx)), + }; } shapes.inProgress.add(widened); const sensitivityAtEntry = contextResolutions; diff --git a/packages/compiler/test/array-pipeline-fusion.test.ts b/packages/compiler/test/array-pipeline-fusion.test.ts index f5d743265..55cd0025e 100644 --- a/packages/compiler/test/array-pipeline-fusion.test.ts +++ b/packages/compiler/test/array-pipeline-fusion.test.ts @@ -26,7 +26,7 @@ function helperCalls(fn: IrFunction): string[] { everyStmtList(fn.body, { expr: (e) => { if (e.kind === "call" && e.callee.startsWith("%arr.")) - calls.push(e.callee.replace(/\.\d+$/, "")); + calls.push(e.callee.replace(/\.[0-9a-f]+$/, "")); return true; }, stmt: () => true, diff --git a/packages/compiler/test/format-float-arguments.test.ts b/packages/compiler/test/format-float-arguments.test.ts index e59e023ca..6ce9c4bc0 100644 --- a/packages/compiler/test/format-float-arguments.test.ts +++ b/packages/compiler/test/format-float-arguments.test.ts @@ -27,7 +27,7 @@ test("util.format %f lowers a boolean argument once", async () => { const helpers = mod.functions .map((f) => f.name) .filter((name) => name.startsWith("%arr.")) - .map((name) => name.replace(/\.\d+$/, "")) + .map((name) => name.replace(/\.[0-9a-f]+$/, "")) .sort(); expect(helpers).toEqual(["%arr.every", "%arr.some"]); } finally { diff --git a/packages/compiler/test/in-runtime-key-emission.test.ts b/packages/compiler/test/in-runtime-key-emission.test.ts index aebbb2ea4..589685a7a 100644 --- a/packages/compiler/test/in-runtime-key-emission.test.ts +++ b/packages/compiler/test/in-runtime-key-emission.test.ts @@ -55,7 +55,7 @@ const d: Record = {}; d["a"] = 1; console.log(has(d, "a"), has(d, "b")); `); - const helper = body(llvm, /sc_b?f__x25_rec_haskey_\d+/); + const helper = body(llvm, /sc_b?f__x25_rec_haskey_[0-9a-f]+/); expect(helper).toContain("@scr_map_has_str("); // Not a scan over a fresh key snapshot per probe. expect(helper).not.toContain("@scr_map_keys_js_order("); diff --git a/packages/compiler/test/stable-names.test.ts b/packages/compiler/test/stable-names.test.ts new file mode 100644 index 000000000..720472556 --- /dev/null +++ b/packages/compiler/test/stable-names.test.ts @@ -0,0 +1,112 @@ +import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { expect, test } from "vitest"; +import { compile, deserializeModule, type IrModule } from "../src/index.js"; + +/** Lowers each source in turn as the same file, so names that include the + * file's path compare equal. */ +async function lower(...sources: string[]): Promise { + const dir = await mkdtemp(join(tmpdir(), "scriptc-stable-names-")); + try { + const entry = join(dir, "main.ts"); + const outPath = join(dir, "main.ir.json"); + const modules: IrModule[] = []; + for (const source of sources) { + await writeFile(entry, source); + const result = await compile(entry, { outDir: dir, outPath, outputKind: "ir" }); + if (!result.ok) + throw new Error(result.diagnostics.map((d) => `${d.code}: ${d.message}`).join("\n")); + modules.push(deserializeModule(await readFile(outPath, "utf8"))); + } + return modules; + } finally { + await rm(dir, { recursive: true, force: true }); + } +} + +function names(mod: IrModule): string[] { + return [ + ...mod.records.map((record) => record.id), + ...mod.unions.map((union) => union.id), + ...mod.functions.map((fn) => fn.name), + ...mod.classes.map((cls) => cls.name), + ].sort(); +} + +const recursive = ` +type Tree = { value: number; children: Tree[]; parent: Tree | null }; +function total(tree: Tree): number { + let sum = tree.value; + for (const child of tree.children) sum += total(child); + return sum; +} +const root: Tree = { value: 1, children: [], parent: null }; +root.children.push({ value: 2, children: [], parent: root }); +console.log(total(root)); +`; + +test("recursive record and union ids do not depend on the code above the type", async () => { + const [before, after] = await lower( + recursive, + `// A comment above the type.\n\ntype Unrelated = { name: string };\n\n${recursive}`, + ); + expect(before.records.some((record) => record.fields.some((f) => f.name === "children"))).toBe( + true, + ); + expect(names(after)).toEqual(names(before)); +}); + +test("recursive instantiations that print alike get distinct placeholders", async () => { + const [mod] = await lower(` +namespace A { + export class Item { + a = 1; + } +} +namespace B { + export class Item { + b = "b"; + } +} +type Chain = { item: T; next: Chain | null }; +const first: Chain = { item: new A.Item(), next: null }; +const second: Chain = { item: new B.Item(), next: null }; +first.next = { item: new A.Item(), next: null }; +second.next = { item: new B.Item(), next: null }; +console.log(first.next.item.a, second.next.item.b); +`); + const chains = mod.records.filter((record) => record.fields.some((f) => f.name === "next")); + expect(new Set(chains.map((record) => record.id)).size).toBe(chains.length); + expect(chains.length).toBeGreaterThanOrEqual(2); +}); + +test("a getter and a setter of one name keep their local classes apart", async () => { + const [mod] = await lower(` +class Box { + private v = 0; + get value(): number { + class Local { + n(): number { + return 1; + } + } + return new Local().n() + this.v; + } + set value(x: number) { + class Local { + n(): number { + return 2; + } + } + this.v = x * new Local().n(); + } +} +const box = new Box(); +box.value = 5; +console.log(box.value); +`); + const locals = mod.classes.filter((cls) => cls.name.includes("Local")); + expect(locals).toHaveLength(2); + expect(locals[0]!.name).not.toBe(locals[1]!.name); +}); diff --git a/packages/compiler/test/type-mapper-unions.test.ts b/packages/compiler/test/type-mapper-unions.test.ts index c714df4d7..684960002 100644 --- a/packages/compiler/test/type-mapper-unions.test.ts +++ b/packages/compiler/test/type-mapper-unions.test.ts @@ -139,7 +139,8 @@ describe("checker and synthesized optional union identity", () => { nullable.arms.filter((arm) => arm.kind !== "nullT" && arm.kind !== "undefinedT"), ), ).toBe(required.unionId); - expect(nullable.discriminant!.cases.map((entry) => entry.values)).toEqual([ + // Cases follow the arms, which are ordered by their type keys. + expect(nullable.discriminant!.cases.map((entry) => entry.values).sort()).toEqual([ ["a", "alias"], ["b"], ]); From ebbc6c1831827649525ff5b3aff5b875a6062a80 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 03:56:15 -0500 Subject: [PATCH 048/102] Fix recursive JSON unions and primitive constructors as array callbacks --- .../lowering/containers/callback-arguments.ts | 59 +++++++++++++ .../lowering/expressions/array-literals.ts | 15 ++++ .../lowering/expressions/identifiers.ts | 51 ++++++++++-- .../src/frontend/lowering/lower-calls.ts | 34 ++++++++ .../src/frontend/lowering/lower-exprs.ts | 8 +- .../6826-map-primitive-constructors.ts.json | 6 ++ ...27-recursive-union-nested-literals.ts.json | 6 ++ ...828-recursive-union-object-walkers.ts.json | 6 ++ .../corpus/6826-map-primitive-constructors.ts | 25 ++++++ .../6827-recursive-union-nested-literals.ts | 29 +++++++ .../6828-recursive-union-object-walkers.ts | 83 +++++++++++++++++++ .../6826-map-primitive-constructors.ts.json | 1 + ...27-recursive-union-nested-literals.ts.json | 1 + ...828-recursive-union-object-walkers.ts.json | 1 + 14 files changed, 316 insertions(+), 9 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6826-map-primitive-constructors.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6827-recursive-union-nested-literals.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6828-recursive-union-object-walkers.ts.json create mode 100644 tests/corpus/6826-map-primitive-constructors.ts create mode 100644 tests/corpus/6827-recursive-union-nested-literals.ts create mode 100644 tests/corpus/6828-recursive-union-object-walkers.ts create mode 100644 tests/harness/corpus-costs/6826-map-primitive-constructors.ts.json create mode 100644 tests/harness/corpus-costs/6827-recursive-union-nested-literals.ts.json create mode 100644 tests/harness/corpus-costs/6828-recursive-union-object-walkers.ts.json diff --git a/packages/compiler/src/frontend/lowering/containers/callback-arguments.ts b/packages/compiler/src/frontend/lowering/containers/callback-arguments.ts index f39c8e86c..9db04e95b 100644 --- a/packages/compiler/src/frontend/lowering/containers/callback-arguments.ts +++ b/packages/compiler/src/frontend/lowering/containers/callback-arguments.ts @@ -6,7 +6,9 @@ import { varRef } from "../../../ir/build.js"; import { typeKey } from "../../type-mapper.js"; import { BOOL, + DYN, F64, + STRING, type IrExpr, type IrType, type SrcLoc, @@ -69,6 +71,20 @@ export function lowerArrayCallback( if (valueT.kind === "union") lowerer.requireTruthyUnion(valueT.unionId, argNode); return { fnArg: truthyFilterCallback(lowerer, valueT, locOf(argNode)), arity: 1 }; } + // The ambient `String` (`values.map(String)`): String(value) converts its + // first argument as a direct call does, whatever the element type; the + // constructor's own value form takes a string. + if ( + ts.isIdentifier(argNode) && + argNode.text === "String" && + !isJsSourceFile(ts.getSourceFileOfNode(argNode)) && + lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(argNode) ?? undefined) + ) { + const valueT = lead[0]; + if (valueT === undefined || valueT.kind === "void") + lowerer.badType(argNode, lowerer.typeOf(argNode)); + return { fnArg: stringConversionCallback(lowerer, valueT, argNode), arity: 1 }; + } const full = [...lead, F64, arrT]; // A DYN-receiver HOF's callback (`parsed.flatMap((value) => ...)`): // the contextual signature types the unannotated param `any` (the @@ -274,6 +290,49 @@ function runtimeOptionalPairVariant(lowerer: Lowerer, expected: IrType, mapped: return lowerer.isRuntimeOptionalRecordVariant(strip(expected), strip(mapped)); } +/** `String` as a one-parameter callback over `valueT`: the conversion a + * direct `String(value)` call lowers to (the runtime's String() for unknown + * values and unions holding a symbol, ToString otherwise), interned per + * value type. */ +function stringConversionCallback( + lowerer: Lowerer, + valueT: IrType, + node: ts.Expression, +): IrExpr & { type: IrType & { kind: "func" } } { + const loc = locOf(node); + const fnT: IrType & { kind: "func" } = { kind: "func", params: [valueT], ret: STRING }; + const key = `mapString:${typeKey(valueT)}`; + let name = lowerer.arrHofHelpers.get(key); + if (!name) { + name = `%arr.mapString.${lowerer.arrHofHelpers.size}`; + lowerer.arrHofHelpers.set(key, name); + const value = varRef("v.0", valueT, loc); + const runtimeString = + valueT.kind === "dyn" || + (valueT.kind === "union" && + lowerer.unions.get(valueT.unionId)?.arms.some((arm) => arm.kind === "symbol") === true && + lowerer.dynConvertible(valueT)); + const converted: IrExpr = runtimeString + ? { + kind: "libCall", + fn: "dyn.stringConstructor", + args: [lowerer.coerceToExpected(value, DYN)], + type: STRING, + loc, + } + : lowerer.ensureString(value, node); + lowerer.liftedFns.push({ + name, + params: [{ localId: "v.0", name: "v", type: valueT }], + returnType: STRING, + locals: [{ id: "v.0", name: "v", type: valueT, mutable: false }], + body: [{ kind: "return", value: converted, loc }], + loc, + }); + } + return { kind: "closure", fnName: name, captures: [], type: fnT, loc }; +} + /** A native closure for the ambient Boolean callback. Reifying the * JavaScript constructor itself is unnecessary; Array#filter only observes * its one-argument ToBoolean result. */ diff --git a/packages/compiler/src/frontend/lowering/expressions/array-literals.ts b/packages/compiler/src/frontend/lowering/expressions/array-literals.ts index 00eae1041..8f119504c 100644 --- a/packages/compiler/src/frontend/lowering/expressions/array-literals.ts +++ b/packages/compiler/src/frontend/lowering/expressions/array-literals.ts @@ -184,6 +184,21 @@ export function lowerArrayLiteral( if (arms.length === 1) mapped = arms[0]!; } } + // A NON-EMPTY literal whose own type is an array, under a union with + // exactly one array arm and no tuple arm (`[1, { n: true }]` in a + // `Json[]` arm of a recursive `Json`): the checker types each element + // from the arm, so its object literals lower as the arm's elements, + // and the literal's own element type (`number | { n: boolean }`) + // cannot hold them. Build it as the arm; its value only flows into the + // union slot. + if (ctxUnion && expr.elements.nodes.length > 0 && mapped?.kind === "array") { + const def = lowerer.unions.get(ctxUnion.unionId); + const arrayArms = def?.arms.filter((a) => a.kind === "array") ?? []; + const tupleArms = + def?.arms.filter((a) => a.kind === "record" && !!lowerer.shapes.get(a.shapeId)?.tuple) ?? + []; + if (arrayArms.length === 1 && tupleArms.length === 0) mapped = arrayArms[0]!; + } } // A Date's toJSON() element keeps its null in a literal with no declared // destination: the lib types say string. diff --git a/packages/compiler/src/frontend/lowering/expressions/identifiers.ts b/packages/compiler/src/frontend/lowering/expressions/identifiers.ts index 16cca3b13..1f74cea42 100644 --- a/packages/compiler/src/frontend/lowering/expressions/identifiers.ts +++ b/packages/compiler/src/frontend/lowering/expressions/identifiers.ts @@ -11,6 +11,7 @@ import { DYN, F64, type IrExpr, + type IrLocal, type IrType, STRING, type SrcLoc, @@ -226,7 +227,10 @@ export function lowerIdentifierExpr(lowerer: Lowerer, expr: ts.Identifier, loc: if (use?.kind === "element") { const key = runtimeOptionalElementKey(use.access.argumentExpression); if (key === null) { - return varRef(local.id, local.type, loc); + return ( + runtimeOptionalKeyedRecord(lowerer, expr, local, loc) ?? + varRef(local.id, local.type, loc) + ); } return runtimeOptionalReceiverRead(lowerer, expr, local, key, loc); } @@ -938,10 +942,43 @@ function moduleFileName(lowerer: Lowerer, sf: ts.SourceFile): string { : sf.fileName; } -/** Object.keys/Object.entries require an object receiver, but their first - * argument is not syntactically a member receiver. Recognize that one - * standard-library position so a runtime-optional loop element can be - * checked against the checker-narrowed record arm before builtin lowering. */ +/** A computed-key access (`value[key]` after `typeof value === "object"`) + * of a runtime-optional binding the checker narrowed to one record arm of a + * wider union. The binding re-tags to that record or undefined, so the keyed + * read or write evaluates its operands and then throws Node's TypeError for + * an undefined receiver. The other arms, which the checker excluded, fail + * the checked re-tag. Null when the binding stores only the record and + * undefined, or the narrowed record is not one of its arms. */ +function runtimeOptionalKeyedRecord( + lowerer: Lowerer, + expr: ts.Identifier, + local: IrLocal, + loc: SrcLoc, +): IrExpr | null { + if (local.type.kind !== "union") return null; + const narrowed = lowerer.mapTypeOf(lowerer.typeOf(expr)); + if (narrowed?.kind !== "record") return null; + const fromId = local.type.unionId; + const arms = lowerer.unions.get(fromId)?.arms; + const recordTag = lowerer.armTag(fromId, narrowed); + const undefTag = lowerer.armTag(fromId, UNDEFINED_T); + if (!arms || arms.length <= 2 || recordTag < 0 || undefTag < 0) return null; + const target = lowerer.withUndefinedArm(narrowed); + if (target.kind !== "union") return null; + const trappable = new Set(); + for (let tag = 0; tag < arms.length; tag++) { + if (tag !== recordTag && tag !== undefTag) trappable.add(tag); + } + const helper = lowerer.unionRetagHelper(fromId, target.unionId, loc, trappable); + if (!helper) return null; + return lowerer.checkedNarrowCall(helper, varRef(local.id, local.type, loc), target, loc); +} + +/** Object.keys, Object.values and Object.entries require an object + * receiver, but their first argument is not syntactically a member + * receiver. Recognize that one standard-library position so a + * runtime-optional loop element can be checked against the checker-narrowed + * record arm before builtin lowering. */ function runtimeOptionalObjectWalkerArg(lowerer: Lowerer, expr: ts.Expression): boolean { let arg = expr; while ( @@ -962,7 +999,9 @@ function runtimeOptionalObjectWalkerArg(lowerer: Lowerer, expr: ts.Expression): return false; const access = call.expression; return ( - (access.name.text === "keys" || access.name.text === "entries") && + (access.name.text === "keys" || + access.name.text === "values" || + access.name.text === "entries") && lowerer.isStdlibMember(access) ); } diff --git a/packages/compiler/src/frontend/lowering/lower-calls.ts b/packages/compiler/src/frontend/lowering/lower-calls.ts index c5e34306c..46f98871e 100644 --- a/packages/compiler/src/frontend/lowering/lower-calls.ts +++ b/packages/compiler/src/frontend/lowering/lower-calls.ts @@ -173,6 +173,7 @@ import { stringWrapperToString, symbolFieldInfo, templateRawTextOf, + primitiveCtorClosure, } from "./lower-exprs.js"; import { isSafeToDiscard } from "./expressions/evaluation-safety.js"; import { tryLowerExpression } from "./expressions/try-lower-expression.js"; @@ -4343,7 +4344,25 @@ export function lowerDynDispatchMethodCall( } } } + // `String`, `Number` or `Boolean` as the callback of an array method + // (`values.map(String)` over an unknown array): the method calls it with + // each element, whatever its type, and cannot observe which function + // value it received, so it gets the constructor's form that converts any + // argument rather than the string-input form typed code stores. + const arrayCallbackReceiver = + ARRAY_CALLBACK_METHODS.has(method) && + lowerer.checker.isArrayType(lowerer.typeOf(access.expression)); const args = call.arguments.nodes.map((arg, i) => { + const primitive = + i === 0 && arrayCallbackReceiver && ts.isIdentifier(arg) + ? stdlibGlobalNameOf(lowerer, arg) + : null; + if (primitive === "String" || primitive === "Number" || primitive === "Boolean") + return lowerer.coerceInto( + arg, + primitiveCtorClosure(lowerer, primitive, locOf(arg), true), + DYN, + ); if (i === 0 && predicate) return lowerer.coerceInto(arg, predicate, DYN); const undefinedArg = lowerStaticallyUndefinedArgument(lowerer, arg); return undefinedArg @@ -4361,6 +4380,21 @@ export function lowerDynDispatchMethodCall( }; } +/** Array.prototype methods whose first argument is a callback they call + * with the elements. */ +const ARRAY_CALLBACK_METHODS = new Set([ + "map", + "filter", + "forEach", + "some", + "every", + "find", + "findIndex", + "findLast", + "findLastIndex", + "flatMap", +]); + /** Every String.prototype method name a typed or dyn string lowering * answers. */ function isStringMethodName(name: string): boolean { diff --git a/packages/compiler/src/frontend/lowering/lower-exprs.ts b/packages/compiler/src/frontend/lowering/lower-exprs.ts index ba96bea8c..b5acaf9e6 100644 --- a/packages/compiler/src/frontend/lowering/lower-exprs.ts +++ b/packages/compiler/src/frontend/lowering/lower-exprs.ts @@ -3057,8 +3057,10 @@ export function lowerFieldCompound( * returns the zero-capture closure over it. Typed sources use the mapped * `(value: string) => primitive` signature; a recognized JavaScript * concise-arrow selector (`() => String`, the picocolors fallback) takes - * dyn so its ordinary coercion signature survives inference residue. The - * dyn bodies run exact ToString/ToNumber/ToBoolean, including object hooks. + * dyn so its ordinary coercion signature survives inference residue, and a + * boxed constructor value takes dyn too (coerceToExpected). The dyn bodies + * run what the constructors do for any argument: String() (a symbol's + * description form included), ToNumber and ToBoolean, with object hooks. * Interning makes every reference under one ABI the SAME immortal closure, * so `opt.type === String` compares like JS function identity. */ export function primitiveCtorClosure( @@ -3081,7 +3083,7 @@ export function primitiveCtorClosure( ? name === "BigInt" ? { kind: "libCall", fn: "dyn.bigintConstructor", args: [v], type: BIGINT_T, loc } : name === "String" - ? { kind: "libCall", fn: "dyn.toStringCoerce", args: [v], type: STRING, loc } + ? { kind: "libCall", fn: "dyn.stringConstructor", args: [v], type: STRING, loc } : name === "Number" ? { kind: "libCall", fn: "dyn.numberConstructor", args: [v], type: F64, loc } : { kind: "dynTest", test: "truthy", value: v, type: BOOL, loc } diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6826-map-primitive-constructors.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6826-map-primitive-constructors.ts.json new file mode 100644 index 000000000..0bf7b0871 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6826-map-primitive-constructors.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6826-map-primitive-constructors.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6827-recursive-union-nested-literals.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6827-recursive-union-nested-literals.ts.json new file mode 100644 index 000000000..6e11aa685 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6827-recursive-union-nested-literals.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6827-recursive-union-nested-literals.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6828-recursive-union-object-walkers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6828-recursive-union-object-walkers.ts.json new file mode 100644 index 000000000..65c965b9e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6828-recursive-union-object-walkers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6828-recursive-union-object-walkers.ts" + ], + "diags": [] +} diff --git a/tests/corpus/6826-map-primitive-constructors.ts b/tests/corpus/6826-map-primitive-constructors.ts new file mode 100644 index 000000000..f6d61bd48 --- /dev/null +++ b/tests/corpus/6826-map-primitive-constructors.ts @@ -0,0 +1,25 @@ +// The String, Number and Boolean constructors passed as callbacks: over +// unknown arrays they convert any element, over typed arrays String converts +// each element as String(value) does, and the boxed values keep identity. +const values: unknown[] = [1, "b", true, null, undefined, Symbol("s"), [1, 2], { a: 1 }, 2n]; +console.log(values.map(String).join("|")); +console.log(values.slice(0, 5).map(Number), values.map(Boolean)); + +function joinAll(...parts: unknown[]): string { + return parts.map(String).join(","); +} +console.log(joinAll(1, "a", false, null)); + +const numbers = [1, 2.5, -0, NaN, Infinity]; +console.log(numbers.map(String)); +const mixed: (number | string | boolean)[] = [1, "x", false]; +console.log(mixed.map(String)); +const symbols: (symbol | string)[] = [Symbol("q"), "r", Symbol()]; +console.log(symbols.map(String)); +console.log([10n, -3n].map(String)); +console.log(["1", " 2 ", "x", ""].map(Number), ["", "0", "a"].map(Boolean)); + +const boxed: unknown = String; +const table: { [name: string]: unknown } = { s: String, n: Number, b: Boolean }; +console.log(boxed === String, table.n === Number, table.b === String, typeof boxed); +console.log(values.filter(Boolean).length, values.some(Boolean), numbers.every(Boolean)); diff --git a/tests/corpus/6827-recursive-union-nested-literals.ts b/tests/corpus/6827-recursive-union-nested-literals.ts new file mode 100644 index 000000000..900bbf977 --- /dev/null +++ b/tests/corpus/6827-recursive-union-nested-literals.ts @@ -0,0 +1,29 @@ +// A recursive JSON-like union with an array arm and an index-signature +// record arm: nested literals mix records into arrays and arrays into +// records at every depth. +type Json = null | boolean | number | string | Json[] | { [key: string]: Json }; + +function show(value: Json): string { + return JSON.stringify(value); +} + +const config: Json = { list: [1, "two", null, { nested: [true, { deeper: [] }] }], flag: false }; +console.log(show(config)); +console.log(show({ list: [{ n: true }] })); +console.log(show([1, { k: null }, [{ a: [2] }]])); +console.log(show({ a: { b: [{ c: "x" }, 3] } })); + +const rows: Json[] = [{ id: 1, tags: ["a", { t: 2 }] }, [null, { x: [] }]]; +console.log(rows.map(show).join(" | ")); + +let value: Json = []; +value = { replaced: [1, { again: [true] }] }; +console.log(show(value)); + +const doc: { [key: string]: Json } = { items: [{ name: "x", parts: [1, { p: "q" }] }] }; +console.log(show(doc)); +const items = doc["items"]; +if (Array.isArray(items)) { + items.push({ added: [9] }); + console.log(items.length, show(items)); +} diff --git a/tests/corpus/6828-recursive-union-object-walkers.ts b/tests/corpus/6828-recursive-union-object-walkers.ts new file mode 100644 index 000000000..5c854eb94 --- /dev/null +++ b/tests/corpus/6828-recursive-union-object-walkers.ts @@ -0,0 +1,83 @@ +// Recursive walkers over a JSON-like union: the array branch calls the +// walker for each element, and the record branch reads the narrowed record +// with Object.values, Object.keys and Object.entries. +type Json = null | boolean | number | string | Json[] | { [key: string]: Json }; + +function depth(value: Json): number { + if (Array.isArray(value)) return 1 + Math.max(0, ...value.map(depth)); + if (value !== null && typeof value === "object") return 1 + Math.max(0, ...Object.values(value).map(depth)); + return 0; +} + +function count(value: Json): number { + let total = 1; + if (Array.isArray(value)) { + for (const item of value) total += count(item); + } else if (value !== null && typeof value === "object") { + for (const item of Object.values(value)) total += count(item); + } + return total; +} + +function paths(value: Json, prefix: string): string[] { + if (Array.isArray(value)) return value.flatMap((item, index) => paths(item, `${prefix}[${index}]`)); + if (value !== null && typeof value === "object") { + const out: string[] = []; + for (const key of Object.keys(value)) out.push(...paths(value[key]!, `${prefix}.${key}`)); + for (const [key, item] of Object.entries(value)) if (item === null) out.push(`${prefix}.${key}=null`); + return out; + } + return [`${prefix}=${String(value)}`]; +} + +const doc: Json = JSON.parse('{"a":[1,{"b":[true,null]}],"c":{"d":"x"},"e":[]}'); +console.log(depth(doc), count(doc)); +console.log(paths(doc, "$").join(" ")); +console.log(depth(3), count([[[]]]), paths([], "$")); + +// A computed-key read or write in a branch that an array hole reaches throws +// Node's TypeError after the key (and, for a write, the value) evaluates. +type Bag = number | string | number[] | { [key: string]: number }; +const keys: string[] = []; +function keyOf(k: string): string { + keys.push(k); + return k; +} +function isBag(value: Bag): value is { [key: string]: number } { + return !Array.isArray(value) && typeof value !== "string" && typeof value !== "number"; +} +function bump(value: Bag, k: string): string { + if (isBag(value)) { + value[keyOf(k)] = (value[keyOf(k)] ?? 0) + 1; + return String(value[keyOf(k)]); + } + return "-"; +} +function put(value: Bag, k: string): string { + if (isBag(value)) { + value[keyOf(k)] = keys.length; + return "put"; + } + return "-"; +} +function peek(value: Bag, k: string): string { + if (isBag(value)) return typeof value[keyOf(k)]; + return "-"; +} +const bags: Bag[] = [{ a: 1 }, "s", [1]]; +bags.length = 4; +for (const which of ["bump", "put", "peek"]) { + const out: string[] = []; + for (let i = 0; i < bags.length; i++) { + try { + const k = "a" + which.length; + if (which === "bump") out.push(bump(bags[i], k)); + else if (which === "put") out.push(put(bags[i], k)); + else out.push(peek(bags[i], k)); + } catch (e) { + out.push(e instanceof TypeError ? e.message : "other"); + } + } + console.log(out.join(" | ")); +} +console.log(keys.join(","), JSON.stringify(bags)); diff --git a/tests/harness/corpus-costs/6826-map-primitive-constructors.ts.json b/tests/harness/corpus-costs/6826-map-primitive-constructors.ts.json new file mode 100644 index 000000000..d2c795829 --- /dev/null +++ b/tests/harness/corpus-costs/6826-map-primitive-constructors.ts.json @@ -0,0 +1 @@ +{ "plain": 3700, "san": 3500 } diff --git a/tests/harness/corpus-costs/6827-recursive-union-nested-literals.ts.json b/tests/harness/corpus-costs/6827-recursive-union-nested-literals.ts.json new file mode 100644 index 000000000..f44e89d4f --- /dev/null +++ b/tests/harness/corpus-costs/6827-recursive-union-nested-literals.ts.json @@ -0,0 +1 @@ +{ "plain": 3500, "san": 3400 } diff --git a/tests/harness/corpus-costs/6828-recursive-union-object-walkers.ts.json b/tests/harness/corpus-costs/6828-recursive-union-object-walkers.ts.json new file mode 100644 index 000000000..77ddc81f8 --- /dev/null +++ b/tests/harness/corpus-costs/6828-recursive-union-object-walkers.ts.json @@ -0,0 +1 @@ +{ "plain": 4200, "san": 5800 } From b99094543f67f874867a3eece221c8b2fde463e7 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 04:04:16 -0500 Subject: [PATCH 049/102] Revert "Read error constructors as values and destructure workerData in JavaScript" This reverts #1776, which made main CI fail. --- .../lowering/expressions/object-literals.ts | 25 +----- .../lowering/expressions/property-access.ts | 20 +---- .../src/frontend/lowering/lower-stmts.ts | 3 - .../6870-error-constructor-values.js.json | 6 -- .../6871-worker-data-destructuring.cjs.json | 6 -- packages/runtime/src/scr_dyn.h | 3 - packages/runtime/src/scr_dyn_invoke.c | 2 - packages/runtime/src/scr_json.c | 79 +++---------------- tests/corpus/6870-error-constructor-values.js | 55 ------------- .../corpus/6871-worker-data-destructuring.cjs | 30 ------- .../6870-error-constructor-values.js.json | 1 - .../6871-worker-data-destructuring.cjs.json | 1 - 12 files changed, 15 insertions(+), 216 deletions(-) delete mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6870-error-constructor-values.js.json delete mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6871-worker-data-destructuring.cjs.json delete mode 100644 tests/corpus/6870-error-constructor-values.js delete mode 100644 tests/corpus/6871-worker-data-destructuring.cjs delete mode 100644 tests/harness/corpus-costs/6870-error-constructor-values.js.json delete mode 100644 tests/harness/corpus-costs/6871-worker-data-destructuring.cjs.json diff --git a/packages/compiler/src/frontend/lowering/expressions/object-literals.ts b/packages/compiler/src/frontend/lowering/expressions/object-literals.ts index a2f399e34..93bf43e95 100644 --- a/packages/compiler/src/frontend/lowering/expressions/object-literals.ts +++ b/packages/compiler/src/frontend/lowering/expressions/object-literals.ts @@ -36,7 +36,6 @@ import { tryLowerExpression } from "./try-lower-expression.js"; import { fenceSymbolFieldCopy } from "../symbol-fields.js"; import { planUnionRetag } from "../union-retag.js"; import { jsHoldsDynObject, runtimeOptionalStorageOperand } from "../lower-exprs.js"; -import { builtinGlobalValue } from "./property-access.js"; /** `{ a: 1, b: "x" }` → recordLit. The record type comes from the * contextual type when tsc has one (annotated declarations, arguments, @@ -395,11 +394,9 @@ export function lowerDynObjectLiteral( const lowerValue = (): IrExpr => ts.isMethodDeclaration(prop) ? lowerer.lowerLambda(prop, true) - : ts.isShorthandPropertyAssignment(prop) && shorthandBuiltinValue(lowerer, prop) - ? shorthandBuiltinValue(lowerer, prop)! - : !boxValue && ts.isObjectLiteralExpression(valueExpr) - ? lowerer.lowerExprExpecting(valueExpr, DYN) - : lowerer.lowerExpr(valueExpr as ts.Expression); + : !boxValue && ts.isObjectLiteralExpression(valueExpr) + ? lowerer.lowerExprExpecting(valueExpr, DYN) + : lowerer.lowerExpr(valueExpr as ts.Expression); raw = fenceClosureProbe(lowerer, valueExpr, undefined, lowerValue) ?? lowerValue(); } catch (err) { // A PURE member read a JS file cannot lower (a namespace object @@ -3157,20 +3154,6 @@ function lowerDeclaredSpreadMerge( /** The value of a shorthand property (`{ x }`): the binding `x` refers to. * The property name's own symbol is the PROPERTY, so resolution goes * through getShorthandAssignmentValueSymbol. */ -/** `{ TypeError }`: a stdlib global in shorthand position reads as the value - * its name reads as elsewhere (the interned constructor or function value), - * or null when the global has no such value. The shorthand's name carries - * the property's symbol, so the identifier path cannot resolve it. */ -function shorthandBuiltinValue( - lowerer: Lowerer, - prop: ts.ShorthandPropertyAssignment, -): IrExpr | null { - const symbol = lowerer.checker.getShorthandAssignmentValueSymbol(prop); - if (!symbol || !lowerer.isStdlibSymbol(symbol)) return null; - const js = isJsSourceFile(ts.getSourceFileOfNode(prop)); - return builtinGlobalValue(ts.symbolName(symbol), locOf(prop.name), js); -} - export function lowerShorthandValue( lowerer: Lowerer, prop: ts.ShorthandPropertyAssignment, @@ -3187,8 +3170,6 @@ export function lowerShorthandValue( const callable = lowerer.lowerBuiltinCallableValue(builtin, loc); if (callable) return callable; } - const builtinValue = shorthandBuiltinValue(lowerer, prop); - if (builtinValue) return builtinValue; if (symbol) { if (lowerer.ctx.selfSymbol === symbol) { return { kind: "selfRef", type: lowerer.ctx.selfType!, loc }; diff --git a/packages/compiler/src/frontend/lowering/expressions/property-access.ts b/packages/compiler/src/frontend/lowering/expressions/property-access.ts index d66110950..06186c4dc 100644 --- a/packages/compiler/src/frontend/lowering/expressions/property-access.ts +++ b/packages/compiler/src/frontend/lowering/expressions/property-access.ts @@ -4024,26 +4024,10 @@ function lowerStreamObjectProperty( return lowerStreamProperty(lowerer, expr, info); } -/** The error constructors among GLOBAL_CONSTRUCTOR_VALUES. Their statics - * (`Error.stackTraceLimit`, `Error.captureStackTrace`) keep their own - * lowerings, so fenceBuiltinConstructorStaticRead leaves them alone. */ -const ERROR_CONSTRUCTOR_VALUES: ReadonlySet = new Set([ - "Error", - "TypeError", - "RangeError", - "SyntaxError", - "ReferenceError", - "EvalError", - "URIError", - "AggregateError", -]); - /** The builtin constructors JavaScript sources read as real function * values rather than identity tokens: the runtime interns one function per * constructor, and dynamic values answer `.constructor` with the same one, - * so `o.constructor === Object` and `err.constructor === TypeError` are - * exact identity tests, and `err.constructor.name` is the constructor's - * name. */ + * so `o.constructor === Object` is an exact identity test. */ const GLOBAL_CONSTRUCTOR_VALUES: ReadonlySet = new Set([ "Object", "Function", @@ -4054,7 +4038,6 @@ const GLOBAL_CONSTRUCTOR_VALUES: ReadonlySet = new Set([ "Promise", "WeakMap", "WeakSet", - ...ERROR_CONSTRUCTOR_VALUES, ]); /** The builtin global functions JavaScript sources read as interned @@ -4197,7 +4180,6 @@ function fenceBuiltinConstructorStaticRead( symbol !== undefined && ts.symbolName(symbol).endsWith("Constructor") && GLOBAL_CONSTRUCTOR_VALUES.has(ts.symbolName(symbol).slice(0, -"Constructor".length)) && - !ERROR_CONSTRUCTOR_VALUES.has(ts.symbolName(symbol).slice(0, -"Constructor".length)) && lowerer.isStdlibSymbol(symbol) ) lowerer.stdlibMemberFence(access); diff --git a/packages/compiler/src/frontend/lowering/lower-stmts.ts b/packages/compiler/src/frontend/lowering/lower-stmts.ts index 7dc0b87cc..84c54307a 100644 --- a/packages/compiler/src/frontend/lowering/lower-stmts.ts +++ b/packages/compiler/src/frontend/lowering/lower-stmts.ts @@ -3889,9 +3889,6 @@ function stdlibGlobalTokenDestructure( if (decl.initializer === undefined || !isJsSourceFile(ts.getSourceFileOfNode(decl))) return null; const globalName = stdlibGlobalNameOf(lowerer, decl.initializer); if (globalName === null) return null; - // `workerData` is a value (the data the worker was started with), not an - // API surface: its members destructure as any untyped value's do. - if (globalName === "workerData") return null; if (!ts.isObjectBindingPattern(decl.name)) { lowerer.unsupported( "SC1031", diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6870-error-constructor-values.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6870-error-constructor-values.js.json deleted file mode 100644 index a2f0e02ea..000000000 --- a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6870-error-constructor-values.js.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "order": [ - "/tests/corpus/6870-error-constructor-values.js" - ], - "diags": [] -} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6871-worker-data-destructuring.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6871-worker-data-destructuring.cjs.json deleted file mode 100644 index b610a5878..000000000 --- a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6871-worker-data-destructuring.cjs.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "order": [ - "/tests/corpus/6871-worker-data-destructuring.cjs" - ], - "diags": [] -} diff --git a/packages/runtime/src/scr_dyn.h b/packages/runtime/src/scr_dyn.h index 1d8a7f1d4..cafc8d07e 100644 --- a/packages/runtime/src/scr_dyn.h +++ b/packages/runtime/src/scr_dyn.h @@ -725,9 +725,6 @@ ScrDyn *scr_dyn_array_constructor(void); /* The interned builtin constructor `name` (Object, Date, RegExp, Map, Set, * Promise, WeakMap, WeakSet) as a dynamic function value: +1. */ ScrDyn *scr_dyn_global_constructor(const ScrStr *name); -/* The interned function value of an error constructor ("TypeError"), or - * NULL for other names. */ -ScrDyn *scr_dyn_error_constructor(const char *name); /* A builtin global function (setTimeout, setImmediate, process.nextTick, ...) * as an interned dynamic function value: +1. */ ScrDyn *scr_dyn_builtin_function(const ScrStr *name); diff --git a/packages/runtime/src/scr_dyn_invoke.c b/packages/runtime/src/scr_dyn_invoke.c index 7b375018b..2a010f213 100644 --- a/packages/runtime/src/scr_dyn_invoke.c +++ b/packages/runtime/src/scr_dyn_invoke.c @@ -1913,8 +1913,6 @@ static ScrDyn *dyn_function_constructor(void) { ScrDyn *scr_dyn_global_constructor(const ScrStr *name) { if (strcmp(name->data, dyn_s20) == 0) return dyn_function_constructor(); - ScrDyn *error = scr_dyn_error_constructor(name->data); - if (error) return error; ScrDyn *ctor = dyn_global_ctor(name->data); if (!ctor) scr_trap(dyn_s3); return ctor; diff --git a/packages/runtime/src/scr_json.c b/packages/runtime/src/scr_json.c index 57846b041..194ade887 100644 --- a/packages/runtime/src/scr_json.c +++ b/packages/runtime/src/scr_json.c @@ -1801,55 +1801,6 @@ static void scr_builtin_object_prototype_cleanup(void) { scr_dyn_release(prototype); } -/* The error constructors as values (an error's `constructor`, and the - * globals in JavaScript): one interned function per constructor and thread, - * indexed like scr_error_vts, with the constructor's name and length. - * Calling one through the value is not supported yet, as for the other - * interned constructors (scr_dyn_global_constructor). */ -static const char *const scr_error_ctor_names[] = { - "Error", "TypeError", "RangeError", "SyntaxError", NULL, - "ReferenceError", "EvalError", "URIError", "AggregateError", -}; -#define SCR_ERROR_CTORS (sizeof scr_error_ctor_names / sizeof scr_error_ctor_names[0]) -static SCR_TL ScrDyn *scr_error_ctor_values[SCR_ERROR_CTORS]; -static SCR_TL bool scr_error_ctors_registered; - -static void scr_error_ctors_cleanup(void) { - for (size_t i = 0; i < SCR_ERROR_CTORS; i++) { - scr_dyn_release(scr_error_ctor_values[i]); - scr_error_ctor_values[i] = NULL; - } -} - -static ScrDyn *scr_error_ctor_call(ScrClosure *closure, ScrDyn *const *args, size_t argc) { - (void)args; - (void)argc; - char message[128]; - int length = snprintf(message, sizeof message, - "calling the %s constructor through a stored value is not supported yet", - (const char *)closure->fn); - scr_throw_error_msg_code(SCR_ERR_ERROR, message, (size_t)length, "SC2020"); - return NULL; -} - -ScrDyn *scr_dyn_error_constructor(const char *name) { - for (size_t i = 0; i < SCR_ERROR_CTORS; i++) { - if (!scr_error_ctor_names[i] || strcmp(scr_error_ctor_names[i], name) != 0) continue; - if (!scr_error_ctors_registered) { - scr_error_ctors_registered = true; - scr_atexit(scr_error_ctors_cleanup); - } - if (!scr_error_ctor_values[i]) { - uint32_t length = strcmp(name, "AggregateError") == 0 ? 2 : 1; - scr_error_ctor_values[i] = - scr_dyn_new_func(scr_closure_new((void *)scr_error_ctor_names[i], 0), scr_error_ctor_call, length, - "native:constructor", scr_error_ctor_names[i]); - } - return scr_dyn_retain(scr_error_ctor_values[i]); - } - return NULL; -} - ScrDyn *scr_dyn_object_prototype(void) { if (!scr_builtin_object_prototype) { scr_builtin_object_prototype = scr_dyn_alloc(SCR_DYN_OBJ); @@ -7756,17 +7707,6 @@ ScrStr *scr_dyn_to_string(const ScrDyn *d, const ScrStr *enc) { return out; } case SCR_DYN_FUNC: { - /* The interned builtin constructors print with their names, as in Node - * (function Map() { [native code] }); other functions without a source - * text print the anonymous native form. */ - if (d->v.fn.sig && strcmp(d->v.fn.sig, "native:constructor") == 0 && d->v.fn.name) { - ScrJsonBuf b; - scr_jb_init(&b); - scr_jb_puts(&b, "function "); - scr_jb_puts(&b, d->v.fn.name); - scr_jb_puts(&b, "() { [native code] }"); - return scr_jb_finish(&b); - } static const char f[] = "function () { [native code] }"; return scr_str_new(f, sizeof f - 1); } @@ -11720,18 +11660,21 @@ static ScrDyn *scr_dyn_obj_read_receiver(const ScrDyn *d, const char *key, size_ ScrDyn *own = scr_dyn_obj_get(d, key, key_len); if (own) return scr_dyn_retain(own); if (key_len == 11 && memcmp(key, "constructor", 11) == 0) { - /* An error's constructor: the interned function value its global - * reads as (scr_dyn_error_constructor). */ - static const char *const names[] = { - "Error", "TypeError", "RangeError", "SyntaxError", NULL, - "ReferenceError", "EvalError", "URIError", "AggregateError", + static const char *const tokens[] = { + "[builtin Error]", "[builtin TypeError]", + "[builtin RangeError]", "[builtin SyntaxError]", + NULL, "[builtin ReferenceError]", "[builtin EvalError]", "[builtin URIError]", + "[builtin AggregateError]", }; size_t hit = scr_errdyn_find(d, false); const ScrVt *vt = hit == SIZE_MAX ? NULL : scr_errdyn_cache[hit].err->vt; - for (size_t kind = 0; vt && kind < sizeof names / sizeof names[0]; kind++) { - if (!names[kind]) continue; + for (size_t kind = 0; vt && kind < sizeof tokens / sizeof tokens[0]; kind++) { + if (!tokens[kind]) continue; if (vt != &scr_error_vts[kind]) continue; - return scr_dyn_error_constructor(names[kind]); + ScrStr *token = scr_str_new(tokens[kind], strlen(tokens[kind])); + ScrDyn *result = scr_dyn_new_str(token); + scr_str_release(token); + return result; } } return scr_dyn_retain(scr_dyn_undefined()); diff --git a/tests/corpus/6870-error-constructor-values.js b/tests/corpus/6870-error-constructor-values.js deleted file mode 100644 index 81f5086d2..000000000 --- a/tests/corpus/6870-error-constructor-values.js +++ /dev/null @@ -1,55 +0,0 @@ -// The error constructors as values in JavaScript: an error's `constructor` -// is the same function the global names, whose name, length, typeof and -// String() are Node's, for errors the program throws, errors the runtime -// throws, and errors read back from catch bindings and containers. -function describe(label, error) { - const ctor = error.constructor; - console.log(label, error.name, error.constructor.name, typeof ctor, ctor.length, String(ctor)); -} - -describe('Error', new Error('e')); -describe('TypeError', new TypeError('t')); -describe('RangeError', new RangeError('r')); -describe('SyntaxError', new SyntaxError('s')); -describe('ReferenceError', new ReferenceError('f')); -describe('EvalError', new EvalError('v')); -describe('URIError', new URIError('u')); -describe('AggregateError', new AggregateError([], 'a')); - -const thrown = [ - () => JSON.parse('{'), - () => { - const holder = JSON.parse('{"value":null}'); - return holder.value.missing; - }, - () => new Array(-1), - () => decodeURIComponent('%'), - () => { - throw new TypeError('own'); - }, -]; -const constructors = { SyntaxError, TypeError, RangeError, URIError }; -const caught = []; -for (const run of thrown) { - try { - run(); - } catch (error) { - caught.push(error); - console.log('caught', error.constructor.name, error.constructor === constructors[error.name]); - } -} - -const byName = new Map(); -for (const error of caught) byName.set(error.constructor.name, (byName.get(error.constructor.name) ?? 0) + 1); -console.log('kinds', JSON.stringify([...byName])); - -console.log('identity', new TypeError('x').constructor === TypeError, new RangeError('x').constructor === TypeError); -console.log('globals', Error.name, TypeError.length, AggregateError.length, typeof RangeError, String(SyntaxError)); - -const renamed = new TypeError('x'); -renamed.name = 'Custom'; -console.log('renamed', renamed.name, renamed.constructor.name); - -class ParseFailure extends SyntaxError {} -const failure = new ParseFailure('p'); -console.log('subclass', failure.name, failure.constructor.name, failure instanceof SyntaxError); diff --git a/tests/corpus/6871-worker-data-destructuring.cjs b/tests/corpus/6871-worker-data-destructuring.cjs deleted file mode 100644 index 63ae789bd..000000000 --- a/tests/corpus/6871-worker-data-destructuring.cjs +++ /dev/null @@ -1,30 +0,0 @@ -// Destructuring the members of a worker's workerData in JavaScript: plain, -// renamed, defaulted, nested and rest bindings read the data the worker was -// started with, as reading `workerData.` does. -'use strict'; -const { Worker, isMainThread, parentPort, workerData } = require('node:worker_threads'); - -if (isMainThread) { - const sab = new SharedArrayBuffer(8); - const data = { name: 'job-7', size: 3, options: { verbose: true, tags: ['a', 'b'] }, counters: new Int32Array(sab), extra: 1, more: 'x' }; - const worker = new Worker(__filename, { workerData: data }); - worker.on('message', (lines) => { - for (const line of lines) console.log(line); - console.log('main sees', new Int32Array(sab)[0]); - }); -} else { - const lines = []; - const { name, size } = workerData; - lines.push(`plain ${name} ${size}`); - const { name: jobName, missing = 'fallback', size: count = 10 } = workerData; - lines.push(`renamed ${jobName} ${missing} ${count}`); - const { - options: { verbose, tags: [firstTag, ...otherTags] }, - } = workerData; - lines.push(`nested ${verbose} ${firstTag} ${JSON.stringify(otherTags)}`); - const { name: ignored, size: alsoIgnored, options, counters, ...rest } = workerData; - lines.push(`rest ${JSON.stringify(rest)} ${typeof options} ${ignored === name && alsoIgnored === size}`); - counters[0] = 41; - counters[0] += 1; - parentPort.postMessage(lines); -} diff --git a/tests/harness/corpus-costs/6870-error-constructor-values.js.json b/tests/harness/corpus-costs/6870-error-constructor-values.js.json deleted file mode 100644 index c608ce33a..000000000 --- a/tests/harness/corpus-costs/6870-error-constructor-values.js.json +++ /dev/null @@ -1 +0,0 @@ -{ "plain": 1200, "san": 3400 } diff --git a/tests/harness/corpus-costs/6871-worker-data-destructuring.cjs.json b/tests/harness/corpus-costs/6871-worker-data-destructuring.cjs.json deleted file mode 100644 index d6c0cb9ee..000000000 --- a/tests/harness/corpus-costs/6871-worker-data-destructuring.cjs.json +++ /dev/null @@ -1 +0,0 @@ -{ "plain": 1300, "san": 3490 } From 4919576d097984a23f6005cf52d9fb33bda2b6a3 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 04:16:06 -0500 Subject: [PATCH 050/102] Filter regex start positions by their leading character sets --- .../src/backend/llvm/regex-matchers.test.ts | 19 ++ .../src/backend/llvm/regex-matchers.ts | 163 +++++++++++++++++- .../corpus/6872-regex-start-filter.ts.json | 6 + tests/corpus/6872-regex-start-filter.ts | 79 +++++++++ .../6872-regex-start-filter.ts.json | 1 + 5 files changed, 262 insertions(+), 6 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6872-regex-start-filter.ts.json create mode 100644 tests/corpus/6872-regex-start-filter.ts create mode 100644 tests/harness/corpus-costs/6872-regex-start-filter.ts.json diff --git a/packages/compiler/src/backend/llvm/regex-matchers.test.ts b/packages/compiler/src/backend/llvm/regex-matchers.test.ts index 1acd9c465..d009de7c9 100644 --- a/packages/compiler/src/backend/llvm/regex-matchers.test.ts +++ b/packages/compiler/src/backend/llvm/regex-matchers.test.ts @@ -110,6 +110,25 @@ describe("regex literal matcher code", () => { expect(body("a\\d{1,3}")).not.toContain("<16 x i8>"); }); + test("fixed leading characters filter 16 start positions at once", () => { + // Both alternatives' first characters are tested at every offset and + // combined, and the reads reach seven characters past the block. + const text = body("agggtaaa|tttaccct", "gi"); + expect(text.match(/load <16 x i8>/g)!.length).toBeGreaterThanOrEqual(16); + expect(text).toMatch(/and i16 /); + expect(text).toMatch(/or i16 /); + expect(text).toMatch(/add i32 %t\d+, 7\n/); + // A class sequence with a fixed count extends the filter. + expect(body("[cg]x{3}y")).toMatch(/and i16 /); + // An optional first character, a single first character and a + // variable-length start keep the first-character search. + expect(body("[ab]?cd")).not.toMatch(/and i16 /); + expect(body("[ab]*cd")).not.toMatch(/and i16 /); + expect(body("xy|zw")).toMatch(/and i16 /); + expect(body("[ab]|cd")).not.toMatch(/and i16 /); + expect(body("agggtaaa|tttaccct", "gi", false)).not.toContain("<16 x i8>"); + }); + test("loops no continuation can share push no backtrack entries", () => { // \d+ then a dot; [^\]]+ then ]; the run at the end of the pattern. expect(body("\\d+\\.\\d+")).not.toContain("@scr_regex_stack_grow"); diff --git a/packages/compiler/src/backend/llvm/regex-matchers.ts b/packages/compiler/src/backend/llvm/regex-matchers.ts index 001f081e5..77f8a06eb 100644 --- a/packages/compiler/src/backend/llvm/regex-matchers.ts +++ b/packages/compiler/src/backend/llvm/regex-matchers.ts @@ -589,6 +589,90 @@ function firstOf(node: RxNode): FirstInfo { } } +/** Positions the start filter tests and alternatives it keeps. */ +const PREFIX_LENGTH = 8; +const PREFIX_ALTERNATIVES = 8; + +/** The character sets a match's first characters must belong to: every + * match of the node begins with the characters of some entry of `alts`, + * one set per character. `complete` means every match is exactly as long as + * its entry (so a following node continues the sequences). Null when the + * node gives no usable condition (an alternative that can start with + * anything, or too many alternatives). Assertions add no characters: the + * result stays a necessary condition. */ +interface Prefix { + alts: CharSet[][]; + complete: boolean; +} + +/** Each head followed by each tail, cut to PREFIX_LENGTH sets; null past + * PREFIX_ALTERNATIVES entries. */ +function crossPrefixes(heads: CharSet[][], tails: CharSet[][]): CharSet[][] | null { + if (heads.length * tails.length > PREFIX_ALTERNATIVES) return null; + const out: CharSet[][] = []; + for (const head of heads) + for (const tail of tails) out.push([...head, ...tail].slice(0, PREFIX_LENGTH)); + return out; +} + +/** Whether no entry was cut at PREFIX_LENGTH. */ +function uncut(alts: CharSet[][]): boolean { + return alts.every((alt) => alt.length < PREFIX_LENGTH); +} + +function prefixOf(node: RxNode): Prefix | null { + switch (node.kind) { + case "set": + return { alts: [[node.set]], complete: true }; + case "assert": + return { alts: [[]], complete: true }; + case "cap": + return prefixOf(node.body); + case "alt": { + const alts: CharSet[][] = []; + let complete = true; + for (const alt of node.alts) { + const p = prefixOf(alt); + if (p === null) return null; + alts.push(...p.alts); + complete &&= p.complete; + } + return alts.length <= PREFIX_ALTERNATIVES ? { alts, complete } : null; + } + case "seq": { + let alts: CharSet[][] = [[]]; + for (const item of node.items) { + const p = prefixOf(item); + if (p === null) return { alts, complete: false }; + const joined = crossPrefixes(alts, p.alts); + if (joined === null) return { alts, complete: false }; + alts = joined; + if (!p.complete || !uncut(alts)) return { alts, complete: false }; + } + return { alts, complete: true }; + } + case "rep": { + if (node.max === 0) return { alts: [[]], complete: true }; + if (node.min === 0) return { alts: [[]], complete: false }; + const body = prefixOf(node.body); + if (body === null) return null; + // The first `min` iterations are required; they extend the sequences + // while the body has a fixed length. + let alts = body.alts; + let covered = 1; + while (covered < node.min && body.complete && uncut(alts)) { + const joined = crossPrefixes(alts, body.alts); + if (joined === null) break; + alts = joined; + covered++; + } + const complete = + body.complete && covered === node.min && node.min === node.max && uncut(alts); + return { alts, complete }; + } + } +} + /** Whether a node can match without consuming (assertions included). */ function canMatchEmpty(node: RxNode): boolean { switch (node.kind) { @@ -721,16 +805,74 @@ class RxGen { return wide; } + /** The vector plans of a start filter (prefixOf): per alternative, the + * plans of its first sets up to the first set without one. Null unless + * every alternative keeps at least two positions, where the filter is + * more selective than the first character alone. */ + prefixPlans(prefix: Prefix | null): { ranges: number[][]; negate: boolean }[][] | null { + if (prefix === null || !this.vector) return null; + const plans: { ranges: number[][]; negate: boolean }[][] = []; + for (const alt of prefix.alts) { + const row: { ranges: number[][]; negate: boolean }[] = []; + for (const set of alt) { + const plan = this.vectorPlan(set); + if (plan === null) break; + row.push(plan); + } + if (row.length < 2) return null; + plans.push(row); + } + return plans.length === 0 ? null : plans; + } + + /** Start positions s[index..index+16) where some alternative of the + * filter matches its first sets: an i16 mask. */ + testPrefix(plans: { ranges: number[][]; negate: boolean }[][], index: string): string { + let any = ""; + for (const row of plans) { + let all = ""; + for (let k = 0; k < row.length; k++) { + let at = index; + if (k > 0) { + at = this.tmp(); + this.line(`${at} = add i32 ${index}, ${k}`); + } + const bits = this.testVector(row[k]!, at); + if (all === "") all = bits; + else { + const both = this.tmp(); + this.line(`${both} = and i16 ${all}, ${bits}`); + all = both; + } + } + if (any === "") any = all; + else { + const either = this.tmp(); + this.line(`${either} = or i16 ${any}, ${all}`); + any = either; + } + } + return any; + } + /** The first-character search: from %at, store the next position whose - * character is in `set` and branch to %attempt, or branch to %nomatch. */ - emitSeek(set: CharSet): void { + * character is in `set` and branch to %attempt, or branch to %nomatch. + * With a start filter (`prefix`), the vector loop tests the filter's + * first sets of each alternative at 16 start positions at once and stops + * only where one of them matches all of its sets; a match can start + * nowhere else, so the attempts that remain are the ones that can + * succeed, in the same order. */ + emitSeek(set: CharSet, prefix: Prefix | null = null): void { this.block("seek"); const a = this.tmp(); this.line(`${a} = load i32, ptr %at`); + const filter = this.prefixPlans(prefix); const plan = this.vectorPlan(set); + // The filter reads s[i + reach + 15] at its farthest. + const reach = filter === null ? 0 : Math.max(...filter.map((row) => row.length)) - 1; let from = "seek", start = a; - if (plan !== null) { + if (plan !== null || filter !== null) { const head = this.label("vsh"), load = this.label("vsl"), next = this.label("vsn"), @@ -743,10 +885,16 @@ class RxGen { fits = this.tmp(); this.line(`${i} = phi i32 [ ${a}, %seek ], [ ${i16}, %${next} ]`); this.line(`${i16} = add i32 ${i}, 16`); - this.line(`${fits} = icmp sle i32 ${i16}, %len`); + if (reach === 0) { + this.line(`${fits} = icmp sle i32 ${i16}, %len`); + } else { + const last = this.tmp(); + this.line(`${last} = add i32 ${i16}, ${reach}`); + this.line(`${fits} = icmp sle i32 ${last}, %len`); + } this.line(`br i1 ${fits}, label %${load}, label %${tail}`); this.block(load); - const mask = this.testVector(plan, i), + const mask = filter !== null ? this.testPrefix(filter, i) : this.testVector(plan!, i), any = this.tmp(); this.line(`${any} = icmp ne i16 ${mask}, 0`); this.line(`br i1 ${any}, label %${hit}, label %${next}`); @@ -1769,7 +1917,10 @@ export function compileRegexMatcher( fn.push(` store i32 %off.n, ptr %at`); fn.push(` br label %attempt`); } else { - gen.emitSeek(first.set); + // A start filter over the first few characters (a single first byte + // keeps memchr). + const prefix = prefixOf(root); + gen.emitSeek(first.set, gen.prefixPlans(prefix) === null ? null : prefix); } } diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6872-regex-start-filter.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6872-regex-start-filter.ts.json new file mode 100644 index 000000000..e2c97c71f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6872-regex-start-filter.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6872-regex-start-filter.ts" + ], + "diags": [] +} diff --git a/tests/corpus/6872-regex-start-filter.ts b/tests/corpus/6872-regex-start-filter.ts new file mode 100644 index 000000000..872342e93 --- /dev/null +++ b/tests/corpus/6872-regex-start-filter.ts @@ -0,0 +1,79 @@ +// Searches whose patterns begin with fixed sequences of characters and +// classes (literal alternations, classes, fixed repetitions), over subjects +// of every length from 0 to 80 and with matches at every offset: match, +// matchAll, search, exec with captures, global and sticky lastIndex, +// replace, case-insensitive letters, multiline anchors and word boundaries. +// Results must not depend on where a match falls relative to 16-character +// blocks or the end of the subject. +const patterns: RegExp[] = [ + /agggtaaa|tttaccct/gi, + /[cgt]gggtaaa|tttaccc[acg]/gi, + /ab|abc|b/g, + /(ab)(c|d)x/g, + /x[0-9]{3}y/g, + /(?:no|yes)(!+)/gi, + /^ab/gm, + /\bcat\b/g, + /a{2}(b+)c/g, + /[A-Z][a-z]{2}-[0-9]/g, +]; + +function describe(re: RegExp, subject: string): string { + const parts: string[] = []; + const all = subject.match(re); + parts.push(`match=${all === null ? "null" : JSON.stringify(all)}`); + parts.push(`search=${subject.search(re)}`); + const rows: string[] = []; + for (const m of subject.matchAll(re)) rows.push(`${m.index}:${JSON.stringify(m.slice(0))}`); + parts.push(`all=[${rows.join(" ")}]`); + parts.push(`replace=${JSON.stringify(subject.replace(re, "<$&>"))}`); + return parts.join(" "); +} + +const filler = "qwertyuiopasdfghjklzxcvbnm"; +const needles = ["agggtaaa", "TTTACCCT", "tttacccg", "abcx", "abdx", "x123y", "NO!!", "yes!", "cat", "aabbbc", "Abc-1", "ab"]; +let checksum = 0; +let lines = 0; +for (let length = 0; length <= 80; length += 7) { + for (const needle of needles) { + for (const offset of [0, 1, 14, 15, 16, 17, 31, 32, 33]) { + if (offset + needle.length > length) continue; + let subject = ""; + while (subject.length < length) subject += filler; + subject = subject.slice(0, offset) + needle + subject.slice(offset + needle.length, length); + for (const re of patterns) { + const text = describe(re, subject); + for (let i = 0; i < text.length; i++) checksum = (checksum * 31 + text.charCodeAt(i)) >>> 0; + lines++; + if (length === 35 && (offset === 15 || offset === 16)) console.log(re.source, offset, needle, text); + } + } + } +} +console.log("lines", lines, "checksum", checksum); + +// Overlapping candidates: every start position looks like a match for the +// first characters, and only some complete. +const dense = "agggtaa".repeat(9) + "agggtaaa" + "tttaccc".repeat(5) + "tttaccct"; +console.log(describe(/agggtaaa|tttaccct/g, dense)); + +// exec with lastIndex, global and sticky. +const re = /x[0-9]{3}y/g; +const text = "zzx111yzzzzzzzzzzzzzzzzzzx222yx333y" + "z".repeat(20) + "x444y"; +let m: RegExpExecArray | null; +const found: string[] = []; +while ((m = re.exec(text)) !== null) found.push(`${m[0]}@${m.index}->${re.lastIndex}`); +console.log("exec", found.join(" ")); +const sticky = /x[0-9]{3}y/y; +sticky.lastIndex = 2; +console.log("sticky", sticky.test(text), sticky.lastIndex, sticky.test(text), sticky.lastIndex); + +// Short subjects and the tail. +for (const subject of ["", "a", "agggtaa", "agggtaaa", "zagggtaaa", "z".repeat(16) + "agggtaaa", "z".repeat(23) + "tttaccct"]) { + console.log(JSON.stringify(subject.slice(-12)), subject.length, describe(/agggtaaa|tttaccct/gi, subject)); +} + +// A long subject with matches spread through it. +let long = ""; +for (let i = 0; i < 2000; i++) long += i % 97 === 0 ? "aGgGtAaA" : i % 89 === 0 ? "tttACCCt" : filler[i % filler.length]; +console.log("long", (long.match(/agggtaaa|tttaccct/gi) ?? []).length, long.search(/tttaccct/i)); diff --git a/tests/harness/corpus-costs/6872-regex-start-filter.ts.json b/tests/harness/corpus-costs/6872-regex-start-filter.ts.json new file mode 100644 index 000000000..c9d5dd264 --- /dev/null +++ b/tests/harness/corpus-costs/6872-regex-start-filter.ts.json @@ -0,0 +1 @@ +{ "plain": 2430, "san": 8860 } From 67247dd26bb8af65349e69c73ffa80603254632c Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 04:21:55 -0500 Subject: [PATCH 051/102] Support objectMode streams with any value as a chunk Readable, Writable, Duplex, Transform and PassThrough take the objectMode option, and a Duplex, Transform or PassThrough the readableObjectMode and writableObjectMode options, as true or false literals in an options object literal or in an options value. An object-mode side holds any value that converts to a checked-dynamic value: push, unshift, write, end, pipe, pipeline, for await, 'data' listeners, Readable.from and the transform callback carry values in TypeScript and JavaScript, and constructor-function streams and options held in variables do the same. The object-mode high-water mark counts values and defaults to 16. A readable buffer that mixes strings, Buffers and other values holds them all, and push(undefined) and other values on a byte-mode stream report ERR_INVALID_ARG_TYPE through 'error', as in Node. In typed code a write or transform callback, or a _write or _transform method, may declare its chunk with any such type, which converts when the callback runs. Writes pass the encoding argument to _write and _transform as Node does: undefined when absent, null when a callback took its place, otherwise the value unchanged. A parameter declared string | null | undefined receives that value and one declared string receives "" for undefined and null. write(chunk, encoding) on a byte-mode stream encodes a string chunk with any known encoding and throws ERR_UNKNOWN_ENCODING for an unknown one. Readable.from takes typed Maps and Sets of any such value, and arrays that mix strings and Buffers. for await over a readable-only stream that will emit 'close' now ends after 'close', as Node's eos does. Buffered writes that complete inside clearBuffer run their callbacks in order, and 'finish' waits for a deferred afterWrite that carries a callback, as Node's pendingcb does, unless a _final callback schedules it. The 'data' listener adapters take three slots and write and transform callbacks read their chunk and encoding through runtime accessors, so RUNTIME_ABI_VERSION is now 26. --- .../builtin-apis/streams-and-readline.mdx | 10 +- .../limitations/builtin-function-values.mdx | 2 +- packages/cli/test/native-link-info.test.ts | 4 +- .../ambient/scriptc-node-fallback.d.ts | 85 +- .../src/backend/llvm/expr-stream-callbacks.ts | 217 +++- .../compiler/src/backend/llvm/lib-process.ts | 37 +- .../compiler/src/backend/llvm/lib-shared.ts | 5 + .../compiler/src/backend/llvm/lib-stream.ts | 52 +- packages/compiler/src/backend/runtime-abi.ts | 4 +- .../src/backend/runtime-pack-targets.test.ts | 2 +- .../compiler/src/backend/runtime-pack.test.ts | 2 +- .../lowering/lower-async-iteration.ts | 4 +- .../frontend/lowering/lower-event-emitter.ts | 51 +- .../src/frontend/lowering/lower-stream.ts | 323 ++++-- packages/compiler/src/ir/builtin-effects.ts | 2 + .../compiler/src/ir/builtin-signatures.ts | 14 +- packages/compiler/src/ir/runtime-features.ts | 2 + packages/compiler/src/ir/validate.ts | 9 +- .../test/native-codegen-integration.test.ts | 4 +- .../corpus/7240-objectmode-streams.ts.json | 6 + .../corpus/7241-objectmode-streams.mjs.json | 6 + .../corpus/7242-objectmode-dynamic.cjs.json | 6 + .../7243-for-await-close-order.mjs.json | 6 + .../corpus/7244-objectmode-subclasses.ts.json | 6 + .../7245-writable-callback-order.mjs.json | 6 + .../runtime-darwin-arm64/scripts/build.mjs | 2 +- .../runtime-pack-common/scripts/build.mjs | 2 +- packages/runtime/src/scr_console.c | 2 +- packages/runtime/src/scr_core.h | 2 +- packages/runtime/src/scr_dyn_builtin_stream.c | 58 +- packages/runtime/src/scr_stream.c | 951 +++++++++++++----- packages/runtime/src/scr_stream.h | 25 + packages/runtime/src/scr_stream_ops.c | 12 +- tests/corpus/7240-objectmode-streams.ts | 130 +++ tests/corpus/7241-objectmode-streams.mjs | 148 +++ tests/corpus/7242-objectmode-dynamic.cjs | 93 ++ tests/corpus/7243-for-await-close-order.mjs | 58 ++ tests/corpus/7244-objectmode-subclasses.ts | 79 ++ tests/corpus/7245-writable-callback-order.mjs | 71 ++ .../7240-objectmode-streams.ts.json | 1 + .../7241-objectmode-streams.mjs.json | 1 + .../7242-objectmode-dynamic.cjs.json | 1 + .../7243-for-await-close-order.mjs.json | 1 + .../7244-objectmode-subclasses.ts.json | 1 + .../7245-writable-callback-order.mjs.json | 1 + .../self-hosting-native-toolchain.test.ts | 2 +- 46 files changed, 2064 insertions(+), 442 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7240-objectmode-streams.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7241-objectmode-streams.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7242-objectmode-dynamic.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7243-for-await-close-order.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7244-objectmode-subclasses.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7245-writable-callback-order.mjs.json create mode 100644 tests/corpus/7240-objectmode-streams.ts create mode 100644 tests/corpus/7241-objectmode-streams.mjs create mode 100644 tests/corpus/7242-objectmode-dynamic.cjs create mode 100644 tests/corpus/7243-for-await-close-order.mjs create mode 100644 tests/corpus/7244-objectmode-subclasses.ts create mode 100644 tests/corpus/7245-writable-callback-order.mjs create mode 100644 tests/harness/corpus-costs/7240-objectmode-streams.ts.json create mode 100644 tests/harness/corpus-costs/7241-objectmode-streams.mjs.json create mode 100644 tests/harness/corpus-costs/7242-objectmode-dynamic.cjs.json create mode 100644 tests/harness/corpus-costs/7243-for-await-close-order.mjs.json create mode 100644 tests/harness/corpus-costs/7244-objectmode-subclasses.ts.json create mode 100644 tests/harness/corpus-costs/7245-writable-callback-order.mjs.json diff --git a/docs/content/limitations/builtin-apis/streams-and-readline.mdx b/docs/content/limitations/builtin-apis/streams-and-readline.mdx index 4e0832c26..8461cc71c 100644 --- a/docs/content/limitations/builtin-apis/streams-and-readline.mdx +++ b/docs/content/limitations/builtin-apis/streams-and-readline.mdx @@ -1,13 +1,17 @@ -- **Streams and readline:** Stream chunks are Buffers or strings. +- **Streams and readline:** Stream chunks are Buffers or strings, and on an object-mode side any value that converts to a checked-dynamic value. `NodeJS.ReadableStream` and `NodeJS.WritableStream`, and `stream.Readable` and `stream.Writable` under `@types/node`, accept every stream: when a program passes file, zlib, or `node:stream` streams through them, child-process pipes and `process.stdout` and `process.stderr` join those streams as `Readable` and `Writable` instances. `readable.pipe(process.stdout)` and `readable.pipe(process.stderr)` compile and, as in Node, do not end the process stream. When an untyped value reaches `NodeJS.ReadableStream` or `NodeJS.WritableStream`, those two interfaces hold any value, so JavaScript stream objects (constructor-function streams, plain objects with `on` and `pipe`) pass through TypeScript functions typed with them and come back to JavaScript as the same objects. Member calls on such a value use the native stream when it is one and call the object's own members otherwise; `readable.pipe()` into a JavaScript destination follows Node's pipe protocol. A `pipeline` stage and a `for await` source that arrive as untyped values must be native streams, or `Cipheriv` and `Decipheriv` values, at run time; other values throw a not-supported error. Native streams expose no `emit` to JavaScript, so a JavaScript stream whose own `pipe()` emits on its destination (the legacy `Stream` pipe) cannot pipe into one. - `Readable.from` accepts arrays, Sets, Map and Set iterators, generators, async generators, and class iterables and async iterables whose values are strings or Buffers, and in JavaScript any iterable or async iterable of them; a stream that mixes strings and Buffers is unsupported. + `Readable.from` accepts strings, Buffers, arrays, Sets, Maps, Map and Set iterators, generators, async generators, and class iterables and async iterables, and in JavaScript any iterable or async iterable. In JavaScript, a sync iterator value with a `then` method that is not a promise, and an object whose `[Symbol.asyncIterator]` or `[Symbol.iterator]` method is a generator method, are unsupported. - Object-mode streams of other values (including `Readable.from` over a `Map`, whose values are entry arrays) are unsupported. + The `objectMode` option, and the `readableObjectMode` and `writableObjectMode` options of a `Duplex`, `Transform`, or `PassThrough`, take `true` or `false` literals in an options object literal; options passed as a value are read when the stream is built. + In typed code, a `write` or `transform` callback, or a `_write` or `_transform` method, may declare its chunk with any type that converts to a checked-dynamic value: the chunk converts when the callback runs, and a value of another type throws a TypeError there. + An object-mode write passes its encoding argument to `write` and `transform` as Node does (`undefined` when absent, `null` when a callback took its place); a parameter declared `string` receives `""` for `undefined` and `null`, and one declared `string | null | undefined` receives Node's value. + `readable.read()` on an object-mode stream answers its Buffers; another value throws a not-supported error (read such values with `'data'` listeners, `for await`, or `pipe`). + `node:stream/consumers` and readline interfaces read object-mode streams of strings and Buffers; other values throw a not-supported error. `pipeline` accepts function stages anywhere among its streams: async generator functions (`async function* (source)`, iterating `source` with `for await`), an async generator source function (`async function* ({ signal })`), and an async function destination whose value resolves the promise form and reaches the callback's second argument. A stage is written inline, or named by a function declaration or a `const` bound to a function expression that nothing reassigns. The source may also be an array, a string, a synchronous generator object, or a synchronous generator function without parameters; their elements reach the next stage on the same ticks as in Node. diff --git a/docs/content/limitations/builtin-function-values.mdx b/docs/content/limitations/builtin-function-values.mdx index 37ed8eb48..c1bab6680 100644 --- a/docs/content/limitations/builtin-function-values.mdx +++ b/docs/content/limitations/builtin-function-values.mdx @@ -28,7 +28,7 @@ The `captureRejections` option and `events.errorMonitor` listeners are not suppo The stream calls the object's `_read`, `_write`, `_final`, `_transform`, `_flush`, and `_destroy` with the object as `this`, and the stream prototypes' methods and accessors work on it. Its listeners live in the native stream rather than in `_events`, and `_readableState` and `_writableState` are read-only views that answer the commonly read fields. Typed code that receives such an object as a stream class uses its native stream, and piping a native stream into it works. -The options the native streams refuse (`objectMode`, `decodeStrings: false`, `signal`, and others) are refused here too, as are `_writev`, `_construct`, symbol event names, `listeners()`, `rawListeners()`, `wrap()`, strings written in encodings other than UTF-8, and pipes into a destination that overrides `write()` or `end()`. +The options the native streams refuse (`decodeStrings: false`, `signal`, and others) are refused here too, as are `_writev`, `_construct`, symbol event names, `listeners()`, `rawListeners()`, `wrap()`, strings written to a byte-mode stream in encodings other than UTF-8, and pipes into a destination that overrides `write()` or `end()`. Other class constructors passed to `util.inherits` or `util.deprecate` are refused. Deprecation warnings are emitted on the next tick and follow assignments to `process.noDeprecation` and `process.throwDeprecation`; compiled binaries take no Node command-line flags such as `--no-deprecation` or `--trace-deprecation`, and `process.traceDeprecation` is unsupported. A stored `util.deprecate` reports a `length` of 4, where Node reports 3. diff --git a/packages/cli/test/native-link-info.test.ts b/packages/cli/test/native-link-info.test.ts index 56ca46878..630ef7173 100644 --- a/packages/cli/test/native-link-info.test.ts +++ b/packages/cli/test/native-link-info.test.ts @@ -72,7 +72,7 @@ describe.runIf(supported)("macOS arm64 native link info", () => { minimum_os: "14.0", }, program: { object, entry_symbol: "main" }, - runtime_abi: { version: 25, marker: "scr_runtime_abi_v25" }, + runtime_abi: { version: 26, marker: "scr_runtime_abi_v26" }, runtime_pack: { kind: "precompiled", package: "@scriptc/runtime-darwin-arm64", @@ -165,6 +165,6 @@ describe.runIf(supported)("macOS arm64 native link info", () => { () => null, (failure: { stderr?: string }) => failure, ); - expect(error?.stderr).toContain("scr_runtime_abi_v25"); + expect(error?.stderr).toContain("scr_runtime_abi_v26"); }); }); diff --git a/packages/compiler/ambient/scriptc-node-fallback.d.ts b/packages/compiler/ambient/scriptc-node-fallback.d.ts index 936283d40..0d6c3eb1e 100644 --- a/packages/compiler/ambient/scriptc-node-fallback.d.ts +++ b/packages/compiler/ambient/scriptc-node-fallback.d.ts @@ -6710,11 +6710,10 @@ declare module "node:events" { * write(chunk, enc, cb) {} })`, Duplex/Transform/PassThrough, push/read, * flowing vs paused, write/end backpressure + 'drain', pipe/unpipe, and * destroy — with Node's event orderings. Chunks are BYTES (Buffer), with - * utf8 strings converted at push/write like Node; objectMode and - * setEncoding are declared so uses fence at their sites with their own - * words. `class My extends Readable` (the _read override form) is a - * separate feature and fences at the class declaration. The runtime-fired - * events carry per-class FORCED argument tuples ('data' is one Buffer, + * strings converted at push/write like Node, and any value on an + * object-mode side (objectMode, readableObjectMode, writableObjectMode — + * the object-mode constructor overloads come first). The runtime-fired + * events carry per-class FORCED argument tuples ('data' is one chunk, * 'error' one Error, 'pipe'/'unpipe' one Readable, the rest empty) — the * overloads below hand tsc the same contract so unannotated listener * parameters contextually type in .js sources. */ @@ -6820,6 +6819,51 @@ declare module "stream" { signal?: AbortSignal; } + /* Object-mode options (objectMode: true, or a Duplex's or Transform's + * readableObjectMode / writableObjectMode): chunks and completion data + * are any values, and an object-mode write's encoding argument reaches + * write/transform as passed (undefined when absent, null when a + * callback took its place). The constructors take these before the + * byte-mode options, so a byte-mode stream's callbacks keep Buffer + * chunks. */ + type ObjectModeEncoding = string | null | undefined; + type ObjectModeFlag = + | { objectMode: true } + | { readableObjectMode: true } + | { writableObjectMode: true }; + interface ObjectWritableOptions extends Omit { + objectMode: true; + write?( + this: Writable, + chunk: any, + encoding: ObjectModeEncoding, + callback: (error?: Error | null) => void, + ): void; + } + type ObjectDuplexOptions = Omit & { + write?( + this: Duplex, + chunk: any, + encoding: ObjectModeEncoding, + callback: (error?: Error | null) => void, + ): void; + } & ObjectModeFlag; + type ObjectTransformOptions = Omit & { + transform?( + this: Transform, + chunk: any, + encoding: ObjectModeEncoding, + callback: (error?: Error | null, data?: any) => void, + ): void; + flush?(this: Transform, callback: (error?: Error | null, data?: any) => void): void; + write?( + this: Transform, + chunk: any, + encoding: ObjectModeEncoding, + callback: (error?: Error | null) => void, + ): void; + } & ObjectModeFlag; + /* The operators' options: concurrency and highWaterMark bound map's * in-flight callbacks and queued results. */ interface ArrayOptions { @@ -6839,7 +6883,10 @@ declare module "stream" { [Symbol.asyncIterator](): AsyncIterableIterator; iterator(options?: { destroyOnReturn?: boolean }): AsyncIterableIterator; push(chunk: Buffer | string | null, encoding?: string): boolean; + /* An object-mode stream's values. */ + push(chunk: any, encoding?: string): boolean; unshift(chunk: Buffer | string, encoding?: string): void; + unshift(chunk: any, encoding?: string): void; read(size?: number): Buffer | null; pause(): this; resume(): this; @@ -6946,6 +6993,7 @@ declare module "stream" { } class Writable extends EventEmitter { + constructor(opts: ObjectWritableOptions); constructor(opts?: WritableOptions); /* The underscore-method surface (see Readable). */ _write(chunk: any, encoding: string, callback: (error?: Error | null) => void): void; @@ -6961,9 +7009,19 @@ declare module "stream" { encoding: string, callback?: (error?: Error | null) => void, ): boolean; + /* An object-mode stream's values (the encoding argument reaches + * _write as passed). */ + write(chunk: any, callback?: (error?: Error | null) => void): boolean; + write( + chunk: any, + encoding: ObjectModeEncoding, + callback?: (error?: Error | null) => void, + ): boolean; end(callback?: () => void): this; end(chunk: Buffer | string, callback?: () => void): this; end(chunk: Buffer | string, encoding: string, callback?: () => void): this; + end(chunk: any, callback?: () => void): this; + end(chunk: any, encoding: ObjectModeEncoding, callback?: () => void): this; cork(): void; uncork(): void; setDefaultEncoding(encoding: string): this; @@ -7013,6 +7071,7 @@ declare module "stream" { * mirrors @types/node: extends Readable, the writable half declared * again. The lowering treats both halves as first-class. */ class Duplex extends Readable { + constructor(opts: ObjectDuplexOptions); constructor(opts?: DuplexOptions); /* The underscore-method surface (see Readable). */ _write(chunk: any, encoding: string, callback: (error?: Error | null) => void): void; @@ -7027,9 +7086,19 @@ declare module "stream" { encoding: string, callback?: (error?: Error | null) => void, ): boolean; + /* An object-mode stream's values (the encoding argument reaches + * _write as passed). */ + write(chunk: any, callback?: (error?: Error | null) => void): boolean; + write( + chunk: any, + encoding: ObjectModeEncoding, + callback?: (error?: Error | null) => void, + ): boolean; end(callback?: () => void): this; end(chunk: Buffer | string, callback?: () => void): this; end(chunk: Buffer | string, encoding: string, callback?: () => void): this; + end(chunk: any, callback?: () => void): this; + end(chunk: any, encoding: ObjectModeEncoding, callback?: () => void): this; cork(): void; uncork(): void; setDefaultEncoding(encoding: string): this; @@ -7101,16 +7170,18 @@ declare module "stream" { } class Transform extends Duplex { + constructor(opts: ObjectTransformOptions); constructor(opts?: TransformOptions); /* The underscore-method surface (see Readable). */ _transform( chunk: any, encoding: string, - callback: (error?: Error | null, data?: Buffer | string) => void, + callback: (error?: Error | null, data?: any) => void, ): void; - _flush(callback: (error?: Error | null, data?: Buffer | string) => void): void; + _flush(callback: (error?: Error | null, data?: any) => void): void; } class PassThrough extends Transform { + constructor(opts: ObjectTransformOptions); constructor(opts?: TransformOptions); } diff --git a/packages/compiler/src/backend/llvm/expr-stream-callbacks.ts b/packages/compiler/src/backend/llvm/expr-stream-callbacks.ts index 9be757a20..17507e128 100644 --- a/packages/compiler/src/backend/llvm/expr-stream-callbacks.ts +++ b/packages/compiler/src/backend/llvm/expr-stream-callbacks.ts @@ -15,23 +15,55 @@ export function streamDataAdapter( sym = `sc_ee_dad_${host.resolveThunks.size}`; host.resolveThunks.set(key, sym); const p = cbT.params[0]; - if ( - cbT.params.length > 1 || - (p && p.kind !== "bytes" && p.kind !== "string" && p.kind !== "dyn" && p.kind !== "union") - ) { + if (cbT.params.length > 1) { throw new InternalCompilerError( "llvm emitter bug: stream data listener param shape (frontend must fence)", ); } + // A `Buffer | string` union wraps the filled slot; any other union (or + // other type) converts from the chunk's checked-dynamic value. + const bytesOrString = + p?.kind === "union" && + (() => { + const def = host.unionsById.get(p.unionId); + return ( + def !== undefined && + !host.nullableUnions.has(p.unionId) && + def.arms.length === 2 && + def.arms.some((a) => a.kind === "bytes" && a.elem === "u8") && + def.arms.some((a) => a.kind === "string") + ); + })(); host.declare(`declare ptr @scr_box_get_ref(ptr)`); host.declare(`declare void @scr_closure_release(ptr)`); + // The emit ABI's three slots (scr_stream_emit_data): the bytes chunk, + // the string chunk, and an object-mode entry's value. const d: string[] = [ - `define internal void @${sym}(ptr %cb, ptr %a0, ptr %a1) ${FN_ATTRS} { ; stream 'data' adapter ${typeKey(cbT)}`, + `define internal void @${sym}(ptr %cb, ptr %a0, ptr %a1, ptr %a2) ${FN_ATTRS} { ; stream 'data' adapter ${typeKey(cbT)}`, `entry:`, ` %capsp = getelementptr inbounds %ScrClosure, ptr %cb, i64 1`, ` %bx = load ptr, ptr %capsp`, ` %orig = call ptr @scr_box_get_ref(ptr %bx) ; the listener, +1`, ]; + const finishTyped = (arg: string, argTy: string): void => { + d.push( + ` %fnp = getelementptr inbounds %ScrClosure, ptr %orig, i64 0, i32 1`, + ` %fn = load ptr, ptr %fnp`, + ); + const retTy = host.llType(cbT.ret); + const argList = `ptr %orig, ${argTy} ${arg}`; + if (retTy === "void") { + d.push(` call void %fn(${argList})`); + } else { + d.push(` %ret = call ${retTy} %fn(${argList})`); + if (isRefCounted(cbT.ret)) { + d.push( + ` call void ${releaseSym(host.shapeHost, cbT.ret)}(ptr %ret) ; discarded listener result`, + ); + } + } + d.push(` call void @scr_closure_release(ptr %orig)`, ` ret void`); + }; const finish = (arg: string | null): void => { d.push( ` %fnp = getelementptr inbounds %ScrClosure, ptr %orig, i64 0, i32 1`, @@ -57,8 +89,8 @@ export function streamDataAdapter( } else if (p.kind === "bytes" || p.kind === "string") { const msg = p.kind === "bytes" - ? "a 'data' listener declaring a Buffer chunk received a string (the stream has an encoding set)" - : "a 'data' listener declaring a string chunk received a Buffer (call setEncoding, or declare the chunk as a Buffer)"; + ? "a 'data' listener declaring a Buffer chunk received a string or an object-mode value (the stream has an encoding set, or is in object mode)" + : "a 'data' listener declaring a string chunk received a Buffer or an object-mode value (call setEncoding, or declare the chunk's type)"; const slot = p.kind === "bytes" ? "%a0" : "%a1"; host.declare(`declare void @scr_throw_error_msg(i32, ptr, ${host.sizeType})`); d.push( @@ -73,7 +105,7 @@ export function streamDataAdapter( ); finish("%r0"); d.push(`}`, ``); - } else if (p.kind === "union") { + } else if (p.kind === "union" && bytesOrString) { // A `Buffer | string` chunk: wrap whichever slot the stream filled at // its arm of the (boxed) union. const def = host.unionsById.get(p.unionId); @@ -114,11 +146,20 @@ export function streamDataAdapter( finish("%uv"); d.push(`}`, ``); } else { - // dyn: box by runtime tag — the JS lane's adapter parameter. + // dyn: the object-mode value, else box by runtime tag — the JS lane's + // adapter parameter. Any other type converts from that value. host.declare(`declare ptr @scr_dyn_new_buffer(ptr)`); host.declare(`declare ptr @scr_dyn_new_str(ptr)`); + host.declare(`declare ptr @scr_dyn_retain_v(ptr)`); d.push( ` %dslot = alloca ptr`, + ` %isv = icmp ne ptr %a2, null`, + ` br i1 %isv, label %val, label %chunk`, + `val:`, + ` %dvv = call ptr @scr_dyn_retain_v(ptr %a2)`, + ` store ptr %dvv, ptr %dslot`, + ` br label %go`, + `chunk:`, ` %isb = icmp ne ptr %a0, null`, ` br i1 %isb, label %buf, label %str`, `buf:`, @@ -132,7 +173,25 @@ export function streamDataAdapter( `go:`, ` %dv = load ptr, ptr %dslot`, ); - finish("%dv"); + if (p.kind === "dyn") { + finish("%dv"); + } else { + const helper = host.dyn.dynCheckHelper(p, false); + const ty = host.llType(p); + host.declare(`declare void @scr_dyn_release(ptr)`); + host.declare(`declare zeroext i1 @scr_exc_pending()`); + d.push( + ` %tv = call ${ty === "i1" ? "zeroext i1" : ty} @${helper}(ptr %dv, ptr null)`, + ` call void @scr_dyn_release(ptr %dv)`, + ` %pend = call zeroext i1 @scr_exc_pending()`, + ` br i1 %pend, label %fail, label %conv`, + `fail:`, + ` call void @scr_closure_release(ptr %orig)`, + ` ret void`, + `conv:`, + ); + finishTyped("%tv", ty); + } d.push(`}`, ``); } host.resolveThunkDefs.push(...d); @@ -164,12 +223,25 @@ export function streamDoneFnFor( const dataT = kind === "t" || kind === "l" ? doneT.params[1] : undefined; let bytesTag = -1; let strTag = -1; + // data of any type other than a union of Buffer, string, undefined and + // null (an object-mode Transform's value) completes through the + // value entry points with the data boxed. + let valueData = false; if (dataT !== undefined) { - if (dataT.kind !== "union") - throw new InternalCompilerError("llvm emitter bug: stream done data param not a union"); - const def = host.unionsById.get(dataT.unionId); - bytesTag = def ? def.arms.findIndex((a) => a.kind === "bytes") : -1; - strTag = def ? def.arms.findIndex((a) => a.kind === "string") : -1; + const def = dataT.kind === "union" ? host.unionsById.get(dataT.unionId) : undefined; + valueData = + def === undefined || + !def.arms.every( + (a) => + (a.kind === "bytes" && a.elem === "u8") || + a.kind === "string" || + a.kind === "undefinedT" || + a.kind === "nullT", + ); + if (!valueData) { + bytesTag = def!.arms.findIndex((a) => a.kind === "bytes"); + strTag = def!.arms.findIndex((a) => a.kind === "string"); + } } const entry = kind === "w" @@ -179,10 +251,16 @@ export function streamDoneFnFor( : kind === "d" ? "scr_stream_destroy_done" : kind === "t" - ? "scr_stream_transform_done" - : "scr_stream_flush_done"; - const twoSlot = kind === "t" || kind === "l"; - host.declare(`declare void @${entry}(ptr, ptr${twoSlot ? ", ptr, ptr" : ""})`); + ? valueData + ? "scr_stream_transform_done_value" + : "scr_stream_transform_done" + : valueData + ? "scr_stream_flush_done_value" + : "scr_stream_flush_done"; + const twoSlot = (kind === "t" || kind === "l") && !valueData; + host.declare( + `declare void @${entry}(ptr, ptr${twoSlot ? ", ptr, ptr" : valueData ? ", ptr" : ""})`, + ); host.declare(`declare ptr @scr_box_get_ref(ptr)`); host.declare(`declare void @scr_stream_release_v(ptr)`); host.declare(`declare ptr @scr_error_retain_v(ptr)`); @@ -190,7 +268,7 @@ export function streamDoneFnFor( const params = [ "ptr %self", ...(errT !== undefined ? ["ptr %e"] : []), - ...(dataT !== undefined ? ["ptr %d"] : []), + ...(dataT !== undefined ? [`${host.llType(dataT)} %d`] : []), ]; const d: string[] = [ `define internal void @${sym}(${params.join(", ")}) ${FN_ATTRS} { ; stream '${kind}' done ${typeKey(doneT)}`, @@ -234,7 +312,15 @@ export function streamDoneFnFor( unwrap("%d", strTag, "@scr_str_retain_v", "%sslot"); } d.push(` %ev = load ptr, ptr %eslot`); - if (twoSlot) { + if (valueData) { + const conv = host.dyn.toDynHelper(dataT!); + host.declare(`declare void @scr_dyn_release(ptr)`); + d.push( + ` %dv = call ptr @${conv}(${host.llType(dataT!)} %d)`, + ` call void @${entry}(ptr %s, ptr %ev, ptr %dv) ; moves err; borrows s and the value`, + ` call void @scr_dyn_release(ptr %dv)`, + ); + } else if (twoSlot) { d.push( ` %bv = load ptr, ptr %bslot`, ` %sv = load ptr, ptr %sslot`, @@ -245,7 +331,8 @@ export function streamDoneFnFor( } d.push(` call void @scr_stream_release_v(ptr %s)`); if (errT !== undefined) d.push(` call void ${releaseSym(host.shapeHost, errT)}(ptr %e)`); - if (dataT !== undefined) d.push(` call void ${releaseSym(host.shapeHost, dataT)}(ptr %d)`); + if (dataT !== undefined && isRefCounted(dataT)) + d.push(` call void ${releaseSym(host.shapeHost, dataT)}(ptr %d)`); d.push(` ret void`, `}`, ``); host.resolveThunkDefs.push(...d); return sym; @@ -611,18 +698,14 @@ export function streamCbThunkFor( : pos === 1; if (p.kind === "dyn") { if (isChunkPos) { - host.declare(`declare ptr @scr_dyn_new_buffer(ptr)`); - d.push(` %dc${i} = call ptr @scr_dyn_new_buffer(ptr %chunk)`); + // the chunk's value: a Buffer, or an object-mode side's value + host.declare(`declare ptr @scr_stream_chunk_value(ptr, ptr)`); + d.push(` %dc${i} = call ptr @scr_stream_chunk_value(ptr %s, ptr %chunk)`); passed.push(`ptr %dc${i}`); } else if (isEncPos) { - host.declare(`declare ptr @scr_str_new(ptr, ${host.sizeType})`); - host.declare(`declare ptr @scr_dyn_new_str(ptr)`); - host.declare(`declare void @scr_str_release(ptr)`); - d.push( - ` %es${i} = call ptr @scr_str_new(ptr ${host.cstr("buffer")}, ${host.sizeType} 6)`, - ` %ed${i} = call ptr @scr_dyn_new_str(ptr %es${i})`, - ` call void @scr_str_release(ptr %es${i})`, - ); + // 'buffer', or the encoding argument an object-mode write passed + host.declare(`declare ptr @scr_stream_chunk_encoding_value(ptr)`); + d.push(` %ed${i} = call ptr @scr_stream_chunk_encoding_value(ptr %s)`); passed.push(`ptr %ed${i}`); } else if (isErrPos) { // finished/pipeline succeed with UNDEFINED (Node calls the eos @@ -673,15 +756,71 @@ export function streamCbThunkFor( } continue; } - if (isChunkPos) { - host.declare(`declare ptr @scr_bytes_retain_v(ptr)`); - d.push(` %rc${i} = call ptr @scr_bytes_retain_v(ptr %chunk)`); + if (isChunkPos && p.kind === "bytes") { + // A Buffer, which an object-mode side's value must be (else a + // TypeError, thrown out of the write). + host.declare(`declare ptr @scr_stream_chunk_bytes(ptr, ptr)`); + d.push( + ` %rc${i} = call ptr @scr_stream_chunk_bytes(ptr %s, ptr %chunk)`, + ` %rcbad${i} = icmp eq ptr %rc${i}, null`, + ` br i1 %rcbad${i}, label %rcfail${i}, label %rcok${i}`, + `rcfail${i}:`, + ...(hasThis ? [` call void @scr_stream_release_v(ptr %sr)`] : []), + ` ret void`, + `rcok${i}:`, + ); + if (hasThis) host.declare(`declare void @scr_stream_release_v(ptr)`); passed.push(`ptr %rc${i}`); - } else if (isEncPos) { - // Node's encoding for decoded (Buffer) chunks is 'buffer'. - host.declare(`declare ptr @scr_str_new(ptr, ${host.sizeType})`); - d.push(` %en${i} = call ptr @scr_str_new(ptr ${host.cstr("buffer")}, ${host.sizeType} 6)`); + } else if (isChunkPos) { + // Any other declared type converts from the chunk's value (an + // object-mode side's value, or the Buffer), or throws out of the + // write. + const helper = host.dyn.dynCheckHelper(p, false); + const ty = host.llType(p); + host.declare(`declare ptr @scr_stream_chunk_value(ptr, ptr)`); + host.declare(`declare void @scr_dyn_release(ptr)`); + host.declare(`declare zeroext i1 @scr_exc_pending()`); + if (hasThis) host.declare(`declare void @scr_stream_release_v(ptr)`); + d.push( + ` %cv${i} = call ptr @scr_stream_chunk_value(ptr %s, ptr %chunk)`, + ` %ct${i} = call ${ty === "i1" ? "zeroext i1" : ty} @${helper}(ptr %cv${i}, ptr null)`, + ` call void @scr_dyn_release(ptr %cv${i})`, + ` %ctbad${i} = call zeroext i1 @scr_exc_pending()`, + ` br i1 %ctbad${i}, label %ctfail${i}, label %ctok${i}`, + `ctfail${i}:`, + ...(hasThis ? [` call void @scr_stream_release_v(ptr %sr)`] : []), + ` ret void`, + `ctok${i}:`, + ); + passed.push(`${ty} %ct${i}`); + } else if (isEncPos && p.kind === "string") { + // Node's encoding for decoded (Buffer) chunks is 'buffer'; an + // object-mode side passes the write's encoding argument ("" for + // undefined and null). + host.declare(`declare ptr @scr_stream_chunk_encoding(ptr)`); + d.push(` %en${i} = call ptr @scr_stream_chunk_encoding(ptr %s)`); passed.push(`ptr %en${i}`); + } else if (isEncPos) { + // Another declared type (string | null | undefined) converts from + // the encoding argument's value. + const helper = host.dyn.dynCheckHelper(p, false); + const ty = host.llType(p); + host.declare(`declare ptr @scr_stream_chunk_encoding_value(ptr)`); + host.declare(`declare void @scr_dyn_release(ptr)`); + host.declare(`declare zeroext i1 @scr_exc_pending()`); + if (hasThis) host.declare(`declare void @scr_stream_release_v(ptr)`); + d.push( + ` %ev${i} = call ptr @scr_stream_chunk_encoding_value(ptr %s)`, + ` %et${i} = call ${ty === "i1" ? "zeroext i1" : ty} @${helper}(ptr %ev${i}, ptr null)`, + ` call void @scr_dyn_release(ptr %ev${i})`, + ` %etbad${i} = call zeroext i1 @scr_exc_pending()`, + ` br i1 %etbad${i}, label %etfail${i}, label %etok${i}`, + `etfail${i}:`, + ...(hasThis ? [` call void @scr_stream_release_v(ptr %sr)`] : []), + ` ret void`, + `etok${i}:`, + ); + passed.push(`${ty} %et${i}`); } else if (isErrPos) { // destroy's error argument: `Error | null` — wrap type-directedly. // The finished/pipeline callback ("e") may declare `Error | null | diff --git a/packages/compiler/src/backend/llvm/lib-process.ts b/packages/compiler/src/backend/llvm/lib-process.ts index 699e52575..3e8a9bff5 100644 --- a/packages/compiler/src/backend/llvm/lib-process.ts +++ b/packages/compiler/src/backend/llvm/lib-process.ts @@ -924,32 +924,41 @@ export function emitErrorsEventsLibCall(host: LlvmEmitterContext, e: LibCallExpr } if (e.fn === "emitter.emitData") { // A user emit('data', chunk) on a stream-rooted receiver: fill the - // matching payload slot of the two-slot 'data' ABI, NULL the other. + // matching payload slot of the three-slot 'data' ABI (bytes, string, + // object-mode value), NULL the others; a checked-dynamic chunk fills + // them by tag (scr_stream_emit_value). const args = e.args.map((a) => host.emitExpr(a)); const chunkT = e.args[2]!.type; - const both = - chunkT.kind === "string" - ? [`ptr null`, `ptr ${args[2]!.name}`] - : [`ptr ${args[2]!.name}`, `ptr null`]; - host.declare(`declare zeroext i1 @scr_emitter_emit(ptr, ptr, ...)`); const t = B.tmp(); - B.line( - `${t} = call zeroext i1 (ptr, ptr, ...) @scr_emitter_emit(ptr ${args[0]!.name}, ptr ${args[1]!.name}, ${both.join(", ")})`, - ); + if (chunkT.kind === "dyn") { + host.declare(`declare zeroext i1 @scr_stream_emit_value(ptr, ptr, ptr)`); + B.line( + `${t} = call zeroext i1 @scr_stream_emit_value(ptr ${args[0]!.name}, ptr ${args[1]!.name}, ptr ${args[2]!.name})`, + ); + } else { + const slots = + chunkT.kind === "string" + ? [`ptr null`, `ptr ${args[2]!.name}`, `ptr null`] + : [`ptr ${args[2]!.name}`, `ptr null`, `ptr null`]; + host.declare(`declare zeroext i1 @scr_emitter_emit(ptr, ptr, ...)`); + B.line( + `${t} = call zeroext i1 (ptr, ptr, ...) @scr_emitter_emit(ptr ${args[0]!.name}, ptr ${args[1]!.name}, ${slots.join(", ")})`, + ); + } host.emitPendingCheck(); return e.type.kind === "void" ? { name: "", type: e.type } : { name: t, type: e.type }; } if (e.fn === "emitter.onData" || e.fn === "emitter.onDataDyn") { // The stream-'data' registration: same runtime entries as - // emitter.on/onDyn, but the DATA adapter (the two-slot payload ABI - // — scr_stream_emit_data) behind the arity-2 fixed shim. + // emitter.on/onDyn, but the DATA adapter (the three-slot payload ABI + // — scr_stream_emit_data) behind the arity-3 fixed shim. const isDyn = e.fn === "emitter.onDataDyn"; const cbT = e.args[isDyn ? 3 : 2]!.type; if (cbT.kind !== "func") throw new InternalCompilerError(`llvm emitter bug: ${e.fn} listener not a func`); const args = e.args.map((a) => host.emitExpr(a)); const adapterFn = host.streamDataAdapter(cbT); - host.declare(`declare void @scr_ee_inv_fixed2(ptr, ptr)`); + host.declare(`declare void @scr_ee_inv_fixed3(ptr, ptr)`); const t = B.tmp(); if (isDyn) { host.toHeap(args[3]!); @@ -959,7 +968,7 @@ export function emitErrorsEventsLibCall(host: LlvmEmitterContext, e: LibCallExpr ); B.line( `${t} = call ptr @scr_emitter_on_dyn(ptr ${args[0]!.name}, ptr ${args[1]!.name}, ` + - `ptr ${args[2]!.name}, ptr ${wrapped}, ptr @scr_ee_inv_fixed2, i1 ${args[4]!.name}, i1 ${args[5]!.name})`, + `ptr ${args[2]!.name}, ptr ${wrapped}, ptr @scr_ee_inv_fixed3, i1 ${args[4]!.name}, i1 ${args[5]!.name})`, ); } else { host.declare(`declare ptr @scr_closure_retain_v(ptr)`); @@ -972,7 +981,7 @@ export function emitErrorsEventsLibCall(host: LlvmEmitterContext, e: LibCallExpr ); B.line( `${t} = call ptr @scr_emitter_on_via(ptr ${args[0]!.name}, ptr ${args[1]!.name}, ` + - `ptr ${args[2]!.name}, ptr ${wrapped}, ptr @scr_ee_inv_fixed2, i1 ${args[3]!.name}, i1 ${args[4]!.name})`, + `ptr ${args[2]!.name}, ptr ${wrapped}, ptr @scr_ee_inv_fixed3, i1 ${args[3]!.name}, i1 ${args[4]!.name})`, ); } const out = host.own({ name: t, type: e.type }); diff --git a/packages/compiler/src/backend/llvm/lib-shared.ts b/packages/compiler/src/backend/llvm/lib-shared.ts index c08d7b720..032d44d50 100644 --- a/packages/compiler/src/backend/llvm/lib-shared.ts +++ b/packages/compiler/src/backend/llvm/lib-shared.ts @@ -1113,10 +1113,13 @@ export const LIB_FN_SYMS: Record = { "readable.pushStr": "scr_stream_push_str", "readable.pushStrEnc": "scr_stream_push_str_enc", "readable.pushEncoding": "scr_stream_set_push_encoding", + "stream.objectMode": "scr_stream_object_mode", + "stream.chunkDone": "scr_stream_chunk_done", "readable.pushNull": "scr_stream_push_null", "readable.pushDyn": "scr_stream_push_dyn", "readable.unshift": "scr_stream_unshift", "readable.unshiftStr": "scr_stream_unshift_str", + "readable.unshiftDyn": "scr_stream_unshift_dyn", "readable.pause": "scr_stream_pause", "readable.resume": "scr_stream_resume", "readable.isPaused": "scr_stream_is_paused", @@ -1667,6 +1670,7 @@ export const USES_TIMERS_LIB_FNS = new Set([ "readable.pushDyn", "readable.unshift", "readable.unshiftStr", + "readable.unshiftDyn", "readable.read", "readable.readDyn", "readable.setEncoding", @@ -1698,6 +1702,7 @@ export const USES_TIMERS_LIB_FNS = new Set([ "console.write", "writable.writeU", "writable.writeDyn", + "writable.writeEnc", "writable.end", "writable.uncork", "stream.destroy", diff --git a/packages/compiler/src/backend/llvm/lib-stream.ts b/packages/compiler/src/backend/llvm/lib-stream.ts index 5d198d306..6d6c6f99c 100644 --- a/packages/compiler/src/backend/llvm/lib-stream.ts +++ b/packages/compiler/src/backend/llvm/lib-stream.ts @@ -419,10 +419,34 @@ export function emitStreamLibCall(host: LlvmEmitterContext, e: LibCallExpr): LlV host.emitPendingCheck(); return e.type.kind === "void" ? { name: "", type: e.type } : { name: t, type: e.type }; } + if (e.fn === "writable.writeEnc") { + // (recv, flags, chunk[, encoding][, cb]) — flags: 1 encoding, 2 + // callback (MOVES). Without an encoding the argument is undefined, or + // null when the callback took its place. + const flagsArg = e.args[1]!; + if (flagsArg.kind !== "numLit") + throw new InternalCompilerError("llvm emitter bug: writable.writeEnc flags not a literal"); + const flags = flagsArg.value; + const args = e.args.map((a) => host.emitExpr(a)); + let at = 3; + const enc = flags & 1 ? args[at++]!.name : writeEncNull(host, flags & 2 ? "null" : "undef"); + let cb = "null"; + if (flags & 2) { + host.toHeap(args[at]!); + cb = args[at]!.name; + } + host.declare(`declare zeroext i1 @scr_stream_write_enc(ptr, ptr, ptr, ptr)`); + const t = B.tmp(); + B.line( + `${t} = call zeroext i1 @scr_stream_write_enc(ptr ${args[0]!.name}, ptr ${args[2]!.name}, ptr ${enc}, ptr ${cb})`, + ); + host.emitPendingCheck(); + return e.type.kind === "void" ? { name: "", type: e.type } : { name: t, type: e.type }; + } if (e.fn === "writable.end") { - // (recv, flags[, chunk][, cb]) — flags: 1 bytes chunk, 2 string - // chunk, 8 dyn chunk (write first, Node's end(chunk) decomposition), - // 4 callback. + // (recv, flags[, chunk][, encoding][, cb]) — flags: 1 bytes chunk, 2 + // string chunk, 8 dyn chunk (write first, Node's end(chunk) + // decomposition), 16 an encoding after the dyn chunk, 4 callback. const flagsArg = e.args[1]!; if (flagsArg.kind !== "numLit") throw new InternalCompilerError("llvm emitter bug: writable.end flags not a literal"); @@ -432,19 +456,27 @@ export function emitStreamLibCall(host: LlvmEmitterContext, e: LibCallExpr): LlV let chunkB = "null"; let chunkS = "null"; let chunkD: string | null = null; + let encD = "null"; if (flags & 1) chunkB = args[at++]!.name; else if (flags & 2) chunkS = args[at++]!.name; else if (flags & 8) chunkD = args[at++]!.name; + if (flags & 16) encD = args[at++]!.name; + else if (chunkD !== null && flags & 4) encD = writeEncNull(host, "null"); let cbName = "null"; if (flags & 4) { host.toHeap(args[at]!); cbName = args[at]!.name; } if (chunkD !== null) { - host.declare(`declare zeroext i1 @scr_stream_write_dyn(ptr, ptr, ptr)`); + // end(chunk, cb) writes with a null encoding argument (Node's end + // shifts the callback out of it) + host.declare(`declare zeroext i1 @scr_stream_write_enc(ptr, ptr, ptr, ptr)`); B.line( - `${B.tmp()} = call zeroext i1 @scr_stream_write_dyn(ptr ${args[0]!.name}, ptr ${chunkD}, ptr null)`, + `${B.tmp()} = call zeroext i1 @scr_stream_write_enc(ptr ${args[0]!.name}, ptr ${chunkD}, ptr ${encD}, ptr null)`, ); + // a write that throws (an unknown encoding) leaves the stream as it + // was: Node's end() throws before it ends the stream + host.emitPendingCheck(); } host.declare(`declare ptr @scr_stream_end(ptr, ptr, ptr, ptr)`); const t = B.tmp(); @@ -771,3 +803,13 @@ export function emitStreamLibCall(host: LlvmEmitterContext, e: LibCallExpr): LlV // adapters; the handful of union-wrapped reads use the envGet shapes. return host.emitGenericLibCall(e); } + +/** The encoding argument a write passes when the call has none: undefined + * (a null pointer), or the null value when a callback took its place. */ +function writeEncNull(host: LlvmEmitterContext, which: "null" | "undef"): string { + if (which === "undef") return "null"; + host.declare(`declare ptr @scr_dyn_new_null()`); + const t = host.B.tmp(); + host.B.line(`${t} = call ptr @scr_dyn_new_null()`); + return t; +} diff --git a/packages/compiler/src/backend/runtime-abi.ts b/packages/compiler/src/backend/runtime-abi.ts index f02510338..703e8fe48 100644 --- a/packages/compiler/src/backend/runtime-abi.ts +++ b/packages/compiler/src/backend/runtime-abi.ts @@ -2,8 +2,8 @@ * of the link contract: a program object keeps this symbol undefined and the * matching runtime defines it, so incompatible manual links fail before the * program can start. */ -export const RUNTIME_ABI_VERSION = 25 as const; -export const RUNTIME_ABI_MARKER = "scr_runtime_abi_v25" as const; +export const RUNTIME_ABI_VERSION = 26 as const; +export const RUNTIME_ABI_MARKER = "scr_runtime_abi_v26" as const; /** Object consumption is useful today, but the complete scr_* surface may * still change before 1.0. The versioned marker prevents accidental mixing; diff --git a/packages/compiler/src/backend/runtime-pack-targets.test.ts b/packages/compiler/src/backend/runtime-pack-targets.test.ts index 8bdbc8492..a49c36ac3 100644 --- a/packages/compiler/src/backend/runtime-pack-targets.test.ts +++ b/packages/compiler/src/backend/runtime-pack-targets.test.ts @@ -52,7 +52,7 @@ async function fixture(target: NativeTargetSpec, workers = false) { object_format: target.objectFormat, minimum_os: target.minimumOs, }, - runtime_abi: { version: 25, marker: "scr_runtime_abi_v25" }, + runtime_abi: { version: 26, marker: "scr_runtime_abi_v26" }, compiler: { command: "fixture", identity: "fixture", target: target.llvmTriple }, macros: { executable: [], excluded: ["SCR_LIB"], sanitizer: "external-toolchain-required" }, flavors: { diff --git a/packages/compiler/src/backend/runtime-pack.test.ts b/packages/compiler/src/backend/runtime-pack.test.ts index a3ac9fe5d..53afafe16 100644 --- a/packages/compiler/src/backend/runtime-pack.test.ts +++ b/packages/compiler/src/backend/runtime-pack.test.ts @@ -124,7 +124,7 @@ async function fixture(target: NativeTargetSpec = MACOS_ARM64_TARGET) { object_format: target.objectFormat, minimum_os: target.minimumOs, }, - runtime_abi: { version: 25, marker: "scr_runtime_abi_v25" }, + runtime_abi: { version: 26, marker: "scr_runtime_abi_v26" }, compiler: { command: "clang", identity: "fixture clang", diff --git a/packages/compiler/src/frontend/lowering/lower-async-iteration.ts b/packages/compiler/src/frontend/lowering/lower-async-iteration.ts index 0e48f2040..5b427a750 100644 --- a/packages/compiler/src/frontend/lowering/lower-async-iteration.ts +++ b/packages/compiler/src/frontend/lowering/lower-async-iteration.ts @@ -428,7 +428,9 @@ function lowerNodeReadable( }, { kind: "if", - cond: { kind: "dynTest", test: "undefined", value: chunkRef, type: BOOL, loc }, + // the end is the done marker: an object-mode stream can yield + // undefined + cond: { kind: "libCall", fn: "stream.chunkDone", args: [chunkRef], type: BOOL, loc }, then: [{ kind: "break", loc }], else_: null, loc, diff --git a/packages/compiler/src/frontend/lowering/lower-event-emitter.ts b/packages/compiler/src/frontend/lowering/lower-event-emitter.ts index f105af786..f44a3d6d8 100644 --- a/packages/compiler/src/frontend/lowering/lower-event-emitter.ts +++ b/packages/compiler/src/frontend/lowering/lower-event-emitter.ts @@ -1458,10 +1458,11 @@ export function lowerEmitterMethodCall( const receiver = lowerReceiver(); const once = member === "once" || member === "prependOnceListener"; const prepend = member === "prependListener" || member === "prependOnceListener"; - // Stream 'data' rides its own two-slot payload ABI (bytes + string — - // encoded streams deliver strings; scr_stream_emit_data): listeners - // on readable-sided receivers register through DATA thunks that - // unwrap the declared side (typed) or box by tag (dyn). + // Stream 'data' rides its own three-slot payload ABI (bytes, string — + // encoded streams deliver strings — and an object-mode value; + // scr_stream_emit_data): listeners on readable-sided receivers + // register through DATA thunks that unwrap the declared side, convert + // to the declared type, or take the value (dyn). const sides = streamSidesOf(lowerer, info); if (name === "data" && (sides === "r" || sides === "rw")) { const dynFlavor = dynListenerFlavor(lowerer, args[1]!); @@ -1500,16 +1501,25 @@ export function lowerEmitterMethodCall( (lowerer.unions.get(p.unionId)?.arms ?? []).every( (arm) => (arm.kind === "bytes" && arm.elem === "u8") || arm.kind === "string", ); + // Any other chunk type converts from the chunk's value (an + // object-mode stream's value, or the Buffer or string) when the + // listener runs, or throws a TypeError there. if ( p !== undefined && !(p.kind === "bytes" && p.elem === "u8") && p.kind !== "string" && - !chunkUnion + !chunkUnion && + (p.kind === "func" || + !canConvertToDyn( + p, + (id) => lowerer.shapes.get(id), + (id) => lowerer.unions.get(id), + )) ) { lowerer.noLowering( `a 'data' listener whose chunk parameter is '${lowerer.fmt(p)}'`, args[1]!, - "chunks are Buffers — or strings once setEncoding/the encoding option applies", + "declare the chunk as a type that converts from a checked-dynamic value", ); } if (!registering) { @@ -1654,8 +1664,10 @@ export function lowerEmitterMethodCall( loc, ); } - // Stream 'data' rides the two-slot payload ABI: a user emit fills - // the chunk's slot (bytes or string), NULLs the other. + // Stream 'data' rides the three-slot payload ABI: a user emit fills + // the chunk's slot (bytes or string) and NULLs the others; any other + // value is emitted as a checked-dynamic value, filling the slots by + // its tag. const emitSides = streamSidesOf(lowerer, info); if (name === "data" && (emitSides === "r" || emitSides === "rw")) { if (args.length !== 2) { @@ -1665,16 +1677,27 @@ export function lowerEmitterMethodCall( "the event carries one chunk (a Buffer or string)", ); } - const chunk = lowerer.lowerExpr(args[1]!); + let chunk = lowerer.lowerExpr(args[1]!); if ( !(chunk.type.kind === "bytes" && chunk.type.elem === "u8") && chunk.type.kind !== "string" ) { - lowerer.noLowering( - `emit('data') with a '${lowerer.fmt(chunk.type)}' chunk`, - args[1]!, - "chunks are Buffers or strings", - ); + if ( + chunk.type.kind === "func" || + (chunk.type.kind !== "dyn" && + !canConvertToDyn( + chunk.type, + (id) => lowerer.shapes.get(id), + (id) => lowerer.unions.get(id), + )) + ) { + lowerer.noLowering( + `emit('data') with a '${lowerer.fmt(chunk.type)}' chunk`, + args[1]!, + "the chunk is a value that converts to a checked-dynamic value", + ); + } + chunk = lowerer.coerceToExpected(chunk, DYN); } return { kind: "libCall", diff --git a/packages/compiler/src/frontend/lowering/lower-stream.ts b/packages/compiler/src/frontend/lowering/lower-stream.ts index d6f89dc11..14062051f 100644 --- a/packages/compiler/src/frontend/lowering/lower-stream.ts +++ b/packages/compiler/src/frontend/lowering/lower-stream.ts @@ -308,6 +308,21 @@ function lowerStreamCallback( // boxes each position by kind (the completion callback arrives as a // callable dyn whose glue dispatches to the runtime's *_done). if (funcType.params[i]!.kind === "dyn") continue; + // A write or transform chunk of another type converts from the + // chunk's value when the callback runs (an object-mode side's value, + // or the Buffer), or throws a TypeError there; an encoding of another + // type (`string | null | undefined`) from the encoding argument's. + if ( + (i === 0 || i === 1) && + (which === "write" || which === "transform") && + funcType.params[i]!.kind !== "func" && + canConvertToDyn( + funcType.params[i]!, + (id) => lowerer.shapes.get(id), + (id) => lowerer.unions.get(id), + ) + ) + continue; if (!typeEquals(funcType.params[i]!, fullTuple[i]!)) { lowerer.noLowering( `a '${which}' callback whose parameter ${i} is '${lowerer.fmt(funcType.params[i]!)}' where Node passes '${lowerer.fmt(fullTuple[i]!)}'`, @@ -404,11 +419,52 @@ interface StreamOptions { * right after construction (Node's constructors call addAbortSignal * once the state exists), or null when absent. */ signal: IrExpr | null; + /** The objectMode option's sides (a Duplex's readableObjectMode and + * writableObjectMode set one side): applied with stream.objectMode + * right after construction. */ + readableObject: boolean; + writableObject: boolean; /** Present callbacks in canonical order with their flag bits. */ flags: number; cbs: IrExpr[]; } +/** The objectMode, readableObjectMode and writableObjectMode members of a + * stream options literal (boolean literals; the sided keys count only on + * a Duplex, Transform or PassThrough, as in Node). */ +function streamObjectModes( + lowerer: Lowerer, + ctorName: string, + optsLit: ts.ObjectLiteralExpression | undefined, +): { readable: boolean; writable: boolean } { + const out = { readable: false, writable: false }; + const duplexish = ctorName !== "Readable" && ctorName !== "Writable"; + for (const prop of optsLit?.properties?.nodes ?? []) { + if (!ts.isPropertyAssignment(prop)) continue; + const name = + ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name) ? prop.name.text : null; + if (name !== "objectMode" && name !== "readableObjectMode" && name !== "writableObjectMode") + continue; + const value = prop.initializer; + if (value.kind === ts.SyntaxKind.FalseKeyword) continue; + if (value.kind !== ts.SyntaxKind.TrueKeyword) { + lowerer.noLowering( + `${ctorName} with a runtime '${name}' value`, + prop, + `write '${name}: true' or '${name}: false'`, + ); + } + if (name === "objectMode") { + out.readable = true; + out.writable = true; + } else if (duplexish) { + if (name === "readableObjectMode") out.readable = true; + else out.writable = true; + } + } + return out; +} + /** The full Node parameter tuples of the option callbacks, given the * concrete stream's `this` type. The trailing completion callbacks keep * whatever func type the checker contextually gave the user's parameter @@ -657,6 +713,8 @@ function parseStreamOptions( badEncoding: null, pushEncoding: null, signal: null, + readableObject: false, + writableObject: false, flags: 0, cbs: [], }; @@ -669,6 +727,18 @@ function parseStreamOptions( "the options must be an object literal, inline or through const-initialized bindings (the callbacks lower as compile-time closures)", ); } + // Read before the callbacks lower: an object-mode readable side keeps a + // completion callback's `data: any` (its values are not only strings and + // Buffers). An object-mode side's high-water mark defaults to 16. + const objectModes = streamObjectModes( + lowerer, + ctorName, + optsLit !== undefined && ts.isObjectLiteralExpression(optsLit) ? optsLit : undefined, + ); + out.readableObject = objectModes.readable; + out.writableObject = objectModes.writable; + if (out.readableObject) out.hwmR = numLit(16, loc); + if (out.writableObject) out.hwmW = numLit(16, loc); const tuples = cbTuples(lowerer); const present = new Map(); for (const prop of optsLit?.properties?.nodes ?? []) { @@ -715,7 +785,7 @@ function parseStreamOptions( continue; } const full = tuples[name]!.map((t) => (t === "fn" ? null : t)); - const pinned = pinAnyDataCompletion(lowerer, name, fnNode); + const pinned = out.readableObject ? null : pinAnyDataCompletion(lowerer, name, fnNode); try { // The completion-callback tail: typed by the checker contextually; // accept the user's declared func type as the tuple's entry so the @@ -776,16 +846,9 @@ function parseStreamOptions( break; case "objectMode": case "readableObjectMode": - case "writableObjectMode": { - // `objectMode: false` is the byte default — admit the literal. - if (value.kind === ts.SyntaxKind.FalseKeyword) break; - lowerer.noLowering( - `${ctorName} in objectMode`, - prop, - "object-mode streams have no static chunk type yet — chunks are Buffers (utf8 strings convert at push/write)", - ); + case "writableObjectMode": + // read up front (streamObjectModes) break; - } case "decodeStrings": { if (value.kind === ts.SyntaxKind.TrueKeyword) break; // Node's default lowerer.noLowering( @@ -942,6 +1005,8 @@ function streamCtorArgs( badEncoding: string | null; pushEncoding: string | null; signal: IrExpr | null; + readableObject: boolean; + writableObject: boolean; } { const shape = streamCtorShape(cls); const o = parseStreamOptions( @@ -971,6 +1036,8 @@ function streamCtorArgs( badEncoding: o.badEncoding, pushEncoding: o.pushEncoding, signal: o.signal, + readableObject: o.readableObject, + writableObject: o.writableObject, }; } @@ -1015,6 +1082,17 @@ export function lowerStreamNew(lowerer: Lowerer, expr: ts.NewExpression, info: C ); } let built: IrExpr = { kind: "libCall", fn, args: parsed.args, type: thisType, loc }; + if (parsed.readableObject || parsed.writableObject) { + // { objectMode }: applied before any other follow-up (answers the + // receiver +1). + built = { + kind: "libCall", + fn: "stream.objectMode", + args: [built, boolLit(parsed.readableObject, loc), boolLit(parsed.writableObject, loc)], + type: thisType, + loc, + }; + } if (parsed.pushEncoding !== null) { // { defaultEncoding }: chain the push-side decode default (the // setEncoding chaining shape — answers the receiver +1). @@ -1133,6 +1211,22 @@ function streamMethodWrapper( ); } } else if (!typeEquals(got.type, want)) { + // A write or transform encoding of another type (`string | null | + // undefined`) converts from the encoding argument's value: an + // object-mode write passes undefined, null or the name. + if ( + i === 1 && + (which === "write" || which === "transform") && + got.type.kind !== "func" && + canConvertToDyn( + got.type, + (id) => lowerer.shapes.get(id), + (id) => lowerer.unions.get(id), + ) + ) { + paramTypes.push(got.type); + continue; + } // A declared supertype of what Node passes (`chunk: Buffer | string`) // is sound: the wrapper takes Node's value and widens it into the // declared parameter. @@ -1140,6 +1234,22 @@ function streamMethodWrapper( paramTypes.push(want); continue; } + // A write or transform chunk of another type converts from the + // chunk's value when the method runs (an object-mode side's value, + // or the Buffer), or throws a TypeError there. + if ( + i === 0 && + (which === "write" || which === "transform") && + got.type.kind !== "func" && + canConvertToDyn( + got.type, + (id) => lowerer.shapes.get(id), + (id) => lowerer.unions.get(id), + ) + ) { + paramTypes.push(got.type); + continue; + } lowerer.noLowering( `a '${methodName}' method whose parameter ${i} is '${lowerer.fmt(got.type)}' where Node passes '${lowerer.fmt(want)}'`, blame, @@ -1301,6 +1411,19 @@ export function lowerStreamSuperCall( loc, }, ]; + if (parsed.readableObject || parsed.writableObject) { + out.push({ + kind: "exprStmt", + expr: { + kind: "libCall", + fn: "stream.objectMode", + args: [thisRef(), boolLit(parsed.readableObject, loc), boolLit(parsed.writableObject, loc)], + type: thisType, + loc, + }, + loc, + }); + } if (parsed.pushEncoding !== null) { out.push({ kind: "exprStmt", @@ -1602,7 +1725,17 @@ export function lowerStreamStaticCall( } const anySrc = srcT?.kind === "dyn" || - (srcT?.kind === "set" && typedElem(srcT.elem) !== null) || + // a Set or Map (entry arrays) of other values: the checked-dynamic + // view iterates the collection itself + ((srcT?.kind === "set" || srcT?.kind === "map") && + canConvertToDyn( + srcT, + (id) => lowerer.shapes.get(id), + (id) => lowerer.unions.get(id), + )) || + // an array of other values: the object-mode entries come from its + // checked-dynamic copy + (srcT?.kind === "array" && fromGenChunk(lowerer, srcT.elem) && typedElem(srcT.elem) === null) || (srcNode !== undefined && srcT === null && (lowerer.typeOf(srcNode).flags & ts.TypeFlags.Any) !== 0); @@ -1623,20 +1756,24 @@ export function lowerStreamStaticCall( lowerer.noLowering( `Readable.from over a '${srcT ? lowerer.fmt(srcT) : "?"}' source`, srcNode ?? call, - "the supported sources are a string or Buffer, and arrays, Sets, generators and class iterables of strings or Buffers", + "the supported sources are a string or Buffer, and arrays, Sets, Maps, generators and class iterables of values that convert to checked-dynamic values", ); } -/** Whether a generator's yields are stream chunks: strings, Buffers, a - * union of them (null included: the runtime destroys the stream with - * ERR_STREAM_NULL_VALUES), or checked-dynamic values (checked when - * pushed). */ +/** Whether a generator's yields can be stream chunks: values that box + * into checked-dynamic values (null included: the runtime destroys the + * stream with ERR_STREAM_NULL_VALUES). An object-mode stream takes any of + * them; a byte-mode one checks them when they are pushed or written. */ function fromGenChunk(lowerer: Lowerer, t: IrType): boolean { - const chunk = (a: IrType): boolean => - a.kind === "string" || (a.kind === "bytes" && a.elem === "u8") || a.kind === "nullT"; - if (t.kind === "dyn" || (chunk(t) && t.kind !== "nullT")) return true; - if (t.kind !== "union") return false; - return lowerer.unions.get(t.unionId)?.arms.every(chunk) ?? false; + if (t.kind === "nullT" || t.kind === "void" || t.kind === "func") return false; + return ( + t.kind === "dyn" || + canConvertToDyn( + t, + (id) => lowerer.shapes.get(id), + (id) => lowerer.unions.get(id), + ) + ); } /** The helpers Readable.from pulls a compiled generator through, as @@ -3587,14 +3724,6 @@ function lowerStreamOperator( throw new InternalCompilerError(`unknown stream operator ${member}`); } -/** The literal 'buffer' encoding on write()/end(): Node 24 takes it for a - * Buffer chunk and throws ERR_UNKNOWN_ENCODING for a string chunk. */ -function isBufferEncoding(lowerer: Lowerer, arg: ts.Expression | undefined): boolean { - if (arg === undefined) return false; - const t = lowerer.typeOf(arg); - return t.isStringLiteralType() && t.value === "buffer"; -} - /** The one supported encoding argument: utf8 (Node's default), as a * compile-time literal or absent. */ function checkUtf8Encoding(lowerer: Lowerer, member: string, arg: ts.Expression | undefined): void { @@ -3925,10 +4054,24 @@ export function lowerStreamMethodCall( if (probed?.type.kind === "dyn") return "dyn"; if (probed?.type.kind === "nullT") return "null"; } + // Any other value is a checked-dynamic chunk: one entry on an + // object-mode side, Node's chunk type error on a byte-mode one + // (undefined, which a byte-mode push ignores, included). + if (t?.kind === "void" || t?.kind === "undefinedT") return "dyn"; + if ( + t !== null && + t.kind !== "func" && + canConvertToDyn( + t, + (id) => lowerer.shapes.get(id), + (id) => lowerer.unions.get(id), + ) + ) + return "dyn"; lowerer.noLowering( `${member} with a '${t ? lowerer.fmt(t) : "?"}' chunk`, node, - "chunks are Buffers or utf8 strings — or unions of those with null (objectMode is not lowered)", + "chunks are values that convert to checked-dynamic values: Buffers, strings, numbers, records, arrays and class instances", ); }; @@ -3973,11 +4116,17 @@ export function lowerStreamMethodCall( checkUtf8Encoding(lowerer, member, args[1]); const kind = chunkKind(args[0]!); if ((kind === "null" || kind === "union" || kind === "dyn") && member === "unshift") { - lowerer.noLowering( - kind === "null" ? "unshift(null)" : "unshift with a nullable or dynamic chunk", - call, - "EOF signals through push(null)", - ); + // unshift(value): an object-mode stream's value at the front, null + // the end of the stream, as Node's readableAddChunk takes them + const receiver = lowerer.lowerExpr(access.expression); + const chunk = lowerer.lowerExprExpecting(args[0]!, DYN); + return { + kind: "libCall", + fn: "readable.unshiftDyn", + args: [receiver, chunk], + type: VOID, + loc, + }; } const receiver = lowerer.lowerExpr(access.expression); if (kind === "null") { @@ -4237,9 +4386,54 @@ export function lowerStreamMethodCall( } const kind = chunkKind(args[0]!); if (kind === "null") lowerer.noLowering("write(null)", call, "end() finishes a writable"); + const lowerWriteCb = (cbArg: ts.Expression): IrExpr => { + const cb = callbackDeclaresParameters(cbArg) + ? null + : lowerer.lowerExprExpecting(cbArg, funcOf([], VOID)); + if (cb === null || cb.type.kind !== "func" || cb.type.params.length > 0) { + lowerer.noLowering( + "write completion callbacks taking the error argument", + cbArg, + "() => void callbacks are supported (listen for 'error' to observe failures)", + ); + } + return cb!; + }; + // write(chunk, encoding[, cb]), and write(value, cb): the encoding + // argument reaches an object-mode side's _write as passed, null when + // the callback took its place (a byte-mode side encodes a string + // chunk with it). + const writeEnc = (encArg: ts.Expression | undefined, cbArg: ts.Expression | undefined) => { + const receiver = lowerer.lowerExpr(access.expression); + const chunk = lowerer.lowerExprExpecting(args[0]!, DYN); + const tail: IrExpr[] = []; + if (encArg !== undefined) tail.push(lowerer.lowerExprExpecting(encArg, DYN)); + if (cbArg !== undefined) tail.push(lowerWriteCb(cbArg)); + const flags = (encArg !== undefined ? 1 : 0) | (cbArg !== undefined ? 2 : 0); + return { + kind: "libCall", + fn: "writable.writeEnc", + args: [receiver, numLit(flags, loc), chunk, ...tail], + type: BOOL, + loc, + } satisfies IrExpr; + }; if (kind === "dyn") { - if (args.length > 1) - lowerer.noLowering("write with a dynamic chunk and more arguments", call); + if (args.length === 3) return writeEnc(args[1], args[2]); + if (args.length === 2) { + // Node's write takes a function there as the callback, anything + // else as the encoding + const t = lowerer.mapTypeOf(lowerer.typeOf(args[1]!)); + if (t?.kind === "func") return writeEnc(undefined, args[1]); + if (t === null || t === undefined || t.kind === "dyn") { + lowerer.noLowering( + "write with a dynamic second argument", + args[1]!, + "pass an encoding string or a completion callback", + ); + } + return writeEnc(args[1], undefined); + } const receiver = lowerer.lowerExpr(access.expression); const chunk = lowerer.lowerExprExpecting(args[0]!, DYN); return { kind: "libCall", fn: "writable.writeDyn", args: [receiver, chunk], type: BOOL, loc }; @@ -4263,19 +4457,15 @@ export function lowerStreamMethodCall( return { kind: "libCall", fn, args: [receiver, chunk], type: BOOL, loc }; } // Disambiguate (chunk, cb?) vs (chunk, encoding, cb?) by the second - // argument's static type. + // argument's static type. A write with an encoding runs through + // writeEnc, whose runtime checks and applies it as Node's _write does. let cbArg: ts.Expression | undefined; - if (args.length >= 2 && isBufferEncoding(lowerer, args[1])) { - if (kind !== "bytes") - return nodeThrowExpr(1, "ERR_UNKNOWN_ENCODING", "Unknown encoding: buffer", BOOL, loc); - cbArg = args[2]; - } else if (args.length === 2) { + if (args.length === 3) return writeEnc(args[1], args[2]); + if (args.length === 2) { const t = lowerer.mapTypeOf(lowerer.typeOf(args[1]!)); - if (t?.kind === "string") checkUtf8Encoding(lowerer, "write", args[1]); - else cbArg = args[1]; - } else if (args.length === 3) { - checkUtf8Encoding(lowerer, "write", args[1]); - cbArg = args[2]; + if (t?.kind === "string" || t?.kind === "nullT" || t?.kind === "undefinedT") + return writeEnc(args[1], undefined); + cbArg = args[1]; } const receiver = lowerer.lowerExpr(access.expression); const chunk = @@ -4284,16 +4474,7 @@ export function lowerStreamMethodCall( : lowerer.lowerExprExpecting(args[0]!, STRING); const fn = kind === "bytes" ? "writable.write" : "writable.writeStr"; if (cbArg !== undefined) { - const cb = callbackDeclaresParameters(cbArg) - ? null - : lowerer.lowerExprExpecting(cbArg, funcOf([], VOID)); - if (cb === null || cb.type.kind !== "func" || cb.type.params.length > 0) { - lowerer.noLowering( - "write completion callbacks taking the error argument", - cbArg, - "() => void callbacks are supported (listen for 'error' to observe failures)", - ); - } + const cb = lowerWriteCb(cbArg); return { kind: "libCall", fn, args: [receiver, chunk, cb], type: BOOL, loc }; } return { kind: "libCall", fn, args: [receiver, chunk], type: BOOL, loc }; @@ -4305,34 +4486,29 @@ export function lowerStreamMethodCall( // Forms: (), (cb), (chunk), (chunk, cb), (chunk, encoding, cb). let chunkNode: ts.Expression | undefined; let cbArg: ts.Expression | undefined; + let encNode: ts.Expression | undefined; if (args.length === 1) { const t = lowerer.mapTypeOf(lowerer.typeOf(args[0]!)); if (t?.kind === "func") cbArg = args[0]; else chunkNode = args[0]; - } else if (args.length >= 2 && isBufferEncoding(lowerer, args[1])) { - chunkNode = args[0]; - const endKind = chunkKind(args[0]!); - if (endKind === "string") { - const endT = lowerer.mapTypeOf(lowerer.typeOf(call)) ?? DYN; - return nodeThrowExpr(1, "ERR_UNKNOWN_ENCODING", "Unknown encoding: buffer", endT, loc); - } - if (endKind !== "bytes") checkUtf8Encoding(lowerer, "end", args[1]); - cbArg = args[2]; } else if (args.length === 2) { chunkNode = args[0]; const t = lowerer.mapTypeOf(lowerer.typeOf(args[1]!)); - if (t?.kind === "string") checkUtf8Encoding(lowerer, "end", args[1]); + if (t?.kind === "string" || t?.kind === "nullT" || t?.kind === "undefinedT") + encNode = args[1]; else cbArg = args[1]; } else if (args.length === 3) { chunkNode = args[0]; - checkUtf8Encoding(lowerer, "end", args[1]); + encNode = args[1]; cbArg = args[2]; } const receiver = lowerer.lowerExpr(access.expression); let flags = 0; const tail: IrExpr[] = []; if (chunkNode !== undefined) { - const kind = chunkKind(chunkNode); + // end(chunk, encoding[, cb]) writes the chunk with the encoding + // argument as passed (flags 16), through the dyn write + const kind = encNode !== undefined ? "dyn" : chunkKind(chunkNode); if (kind === "null" || kind === "union") lowerer.noLowering("end(null)", call); flags |= kind === "bytes" ? 1 : kind === "dyn" ? 8 : 2; tail.push( @@ -4342,6 +4518,10 @@ export function lowerStreamMethodCall( ? lowerer.lowerExprExpecting(chunkNode, DYN) : lowerer.lowerExprExpecting(chunkNode, STRING), ); + if (encNode !== undefined) { + flags |= 16; + tail.push(lowerer.lowerExprExpecting(encNode, DYN)); + } } if (cbArg !== undefined) { const cb = callbackDeclaresParameters(cbArg) @@ -4604,8 +4784,7 @@ export function lowerStreamProperty( return propCall(BOOL); } if (name === "writableObjectMode" && writableSide) { - // objectMode construction fences, so the answer is compile-time false. - return boolLit(false, loc); + return propCall(BOOL); } if (name === "allowHalfOpen" && sides === "rw") { return propCall(BOOL); diff --git a/packages/compiler/src/ir/builtin-effects.ts b/packages/compiler/src/ir/builtin-effects.ts index dd82d06c2..8a4e1848d 100644 --- a/packages/compiler/src/ir/builtin-effects.ts +++ b/packages/compiler/src/ir/builtin-effects.ts @@ -358,6 +358,7 @@ export const MAY_THROW_LIB_FNS: ReadonlySet = new Set([ "readable.pushU", "readable.pushDyn", "readable.unshift", + "readable.unshiftDyn", "readable.unshiftStr", "readable.read", "readable.readDyn", @@ -370,6 +371,7 @@ export const MAY_THROW_LIB_FNS: ReadonlySet = new Set([ "writable.writeStr", "writable.writeU", "writable.writeDyn", + "writable.writeEnc", "writable.end", "writable.uncork", "stream.destroy", diff --git a/packages/compiler/src/ir/builtin-signatures.ts b/packages/compiler/src/ir/builtin-signatures.ts index 8f5928d12..8104c7392 100644 --- a/packages/compiler/src/ir/builtin-signatures.ts +++ b/packages/compiler/src/ir/builtin-signatures.ts @@ -3875,7 +3875,11 @@ export const LIB_FN_SIGS = defineLibFnSignatures({ * readable.unpipe (recv[, dst]) → recv +1. * writable.write/writeStr: (recv, chunk[, cb]) → below-hwm bool (cb * MOVES when present, called after the user write completes). - * writable.end: (recv, flags[, chunk][, cb]) → recv +1. cork/uncork are + * writable.writeEnc: (recv, flags, chunk[, encoding][, cb]) — flags 1 + * an encoding argument, 2 a callback (the encoding is then null, as + * Node's write shifts it). + * writable.end: (recv, flags[, chunk][, encoding][, cb]) → recv +1; + * flags 16: an encoding argument follows the dyn chunk. cork/uncork are * void. stream.destroy/destroyErr: (recv[, err]) → recv +1. * stream.prop: (recv, name-literal) → the flag/number the name asks * for; stream.errored → Error|null union; readable.flowing → @@ -4014,6 +4018,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({ "readable.pushU": { argTypes: [null, null], result: BOOL }, "readable.pushDyn": { argTypes: [null, DYN], result: BOOL }, "readable.unshift": { argTypes: [null, BYTES_U8], result: VOID }, + "readable.unshiftDyn": { argTypes: [null, DYN], result: VOID }, "readable.unshiftStr": { argTypes: [null, STRING], result: VOID }, "stream.onDyn": { argTypes: [null, STRING, DYN, BOOL, BOOL], result: VOID }, "readable.readDyn": { argTypes: [null, DYN], result: DYN }, @@ -4025,6 +4030,12 @@ export const LIB_FN_SIGS = defineLibFnSignatures({ * Buffer.from(chunk, enc)); both carry the CANONICAL literal. */ "readable.pushStrEnc": { argTypes: [null, STRING, STRING], result: BOOL }, "readable.pushEncoding": { argTypes: [null, STRING], result: VOID }, + /** The objectMode option's sides (readable, writable), applied right + * after construction; answers the receiver (+1, the chaining shape). */ + "stream.objectMode": { argTypes: [null, BOOL, BOOL], result: VOID }, + /** Whether a readable.nextChunkDyn step answered the end (the done + * marker; an object-mode stream can yield undefined). */ + "stream.chunkDone": { argTypes: [DYN], result: BOOL }, /** for-await over a readable (the desugared loop's per-pass promise): * +1 promise of the next chunk — buffered content, the EOF sentinel * (empty Buffer / dyn undefined), or a rejection with the stream's @@ -4078,6 +4089,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({ "writable.writeStr": { argTypes: [null, STRING], result: BOOL }, "writable.writeU": { argTypes: [null, null], result: BOOL }, "writable.writeDyn": { argTypes: [null, DYN], result: BOOL }, + "writable.writeEnc": { argTypes: [null, F64, DYN], result: BOOL }, "writable.end": { argTypes: [null, F64], result: VOID }, "writable.cork": { argTypes: [null], result: VOID }, "writable.uncork": { argTypes: [null], result: VOID }, diff --git a/packages/compiler/src/ir/runtime-features.ts b/packages/compiler/src/ir/runtime-features.ts index 9531d7845..1528242c4 100644 --- a/packages/compiler/src/ir/runtime-features.ts +++ b/packages/compiler/src/ir/runtime-features.ts @@ -216,6 +216,8 @@ const ABORT_SIGNAL_LIB_FNS: ReadonlySet = new Set([ /** Entry points that link the stream unit (with STREAM_LIB_PREFIXES). */ const STREAM_LIB_FNS: ReadonlySet = new Set([ "child.stdioStream", + "stream.chunkDone", + "stream.objectMode", "console.bind", "crypto.hashStream", "crypto.hashStreamPiped", diff --git a/packages/compiler/src/ir/validate.ts b/packages/compiler/src/ir/validate.ts index 9de1b5b62..bb36c7007 100644 --- a/packages/compiler/src/ir/validate.ts +++ b/packages/compiler/src/ir/validate.ts @@ -4109,6 +4109,7 @@ function validateFunction( e.fn === "writable.write" || e.fn === "writable.writeStr" || e.fn === "writable.writeU" || + e.fn === "writable.writeEnc" || e.fn === "writable.end" || e.fn === "readable.unpipe" || e.fn === "rl.create" || @@ -5492,6 +5493,7 @@ function validateFunction( e.fn.startsWith("passthrough.") || e.fn === "stream.destroy" || e.fn === "stream.destroyErr" || + e.fn === "stream.objectMode" || e.fn === "stream.iteratorClose" || e.fn === "stream.prop" || e.fn === "stream.errored" || @@ -5782,6 +5784,7 @@ function validateFunction( e.fn === "writable.end" || e.fn === "readable.setEncoding" || e.fn === "readable.pushEncoding" || + e.fn === "stream.objectMode" || e.fn === "stream.destroy" || e.fn === "stream.destroyErr" || e.fn === "stream.iteratorClose" @@ -5898,8 +5901,10 @@ function validateFunction( const chunkT = e.args[2]?.type; const ok = chunkT !== undefined && - ((chunkT.kind === "bytes" && chunkT.elem === "u8") || chunkT.kind === "string"); - if (!ok) err(`libCall emitter.emitData chunk must be bytes or string`, e.loc); + ((chunkT.kind === "bytes" && chunkT.elem === "u8") || + chunkT.kind === "string" || + chunkT.kind === "dyn"); + if (!ok) err(`libCall emitter.emitData chunk must be bytes, string or dyn`, e.loc); if (e.type.kind !== "bool") err(`libCall emitter.emitData must be bool`, e.loc); return true; } diff --git a/packages/compiler/test/native-codegen-integration.test.ts b/packages/compiler/test/native-codegen-integration.test.ts index c05e7f994..af8d9b724 100644 --- a/packages/compiler/test/native-codegen-integration.test.ts +++ b/packages/compiler/test/native-codegen-integration.test.ts @@ -378,7 +378,7 @@ done: expect(await symbols(helperObject, ["-u"])).toEqual(await symbols(clangObject, ["-u"])); expect(await symbols(helperObject, ["-gU"])).toEqual(await symbols(clangObject, ["-gU"])); expect(await symbols(helperObject, ["-gU"])).toEqual(["0000000000000000 T _main"]); - expect(await symbols(helperObject, ["-u"])).toContain("_scr_runtime_abi_v25"); + expect(await symbols(helperObject, ["-u"])).toContain("_scr_runtime_abi_v26"); const clangExe = join(dir, "clang-program"); const linkDriver = join(dir, "clang-driver.c"); @@ -712,7 +712,7 @@ done: .split("\n"); expect(undefinedSymbols).toContain("_sf_scale"); expect(undefinedSymbols).toContain("_sf_callback_mix"); - expect(undefinedSymbols).toContain("_scr_runtime_abi_v25"); + expect(undefinedSymbols).toContain("_scr_runtime_abi_v26"); }); test("helper and clang object paths retain the same outbound FFI C ABI", async () => { diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7240-objectmode-streams.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7240-objectmode-streams.ts.json new file mode 100644 index 000000000..0b212fb07 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7240-objectmode-streams.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7240-objectmode-streams.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7241-objectmode-streams.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7241-objectmode-streams.mjs.json new file mode 100644 index 000000000..22dc5abc4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7241-objectmode-streams.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7241-objectmode-streams.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7242-objectmode-dynamic.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7242-objectmode-dynamic.cjs.json new file mode 100644 index 000000000..1b932b82b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7242-objectmode-dynamic.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7242-objectmode-dynamic.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7243-for-await-close-order.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7243-for-await-close-order.mjs.json new file mode 100644 index 000000000..ec479cf59 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7243-for-await-close-order.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7243-for-await-close-order.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7244-objectmode-subclasses.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7244-objectmode-subclasses.ts.json new file mode 100644 index 000000000..827bba4c0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7244-objectmode-subclasses.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7244-objectmode-subclasses.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7245-writable-callback-order.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7245-writable-callback-order.mjs.json new file mode 100644 index 000000000..9485562b3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7245-writable-callback-order.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7245-writable-callback-order.mjs" + ], + "diags": [] +} diff --git a/packages/runtime-darwin-arm64/scripts/build.mjs b/packages/runtime-darwin-arm64/scripts/build.mjs index 6cc32d7fa..edfaa7519 100644 --- a/packages/runtime-darwin-arm64/scripts/build.mjs +++ b/packages/runtime-darwin-arm64/scripts/build.mjs @@ -338,7 +338,7 @@ async function build() { package: packageManifest.name, version: packageManifest.version, target: RUNTIME_PACK_MATRIX.target, - runtime_abi: { version: 25, marker: "scr_runtime_abi_v25" }, + runtime_abi: { version: 26, marker: "scr_runtime_abi_v26" }, compiler: { command: compiler, identity: compilerVersion, diff --git a/packages/runtime-pack-common/scripts/build.mjs b/packages/runtime-pack-common/scripts/build.mjs index a2c987b97..542e7d48e 100644 --- a/packages/runtime-pack-common/scripts/build.mjs +++ b/packages/runtime-pack-common/scripts/build.mjs @@ -435,7 +435,7 @@ async function build() { package: packageManifest.name, version: packageManifest.version, target: matrix.target, - runtime_abi: { version: 25, marker: "scr_runtime_abi_v25" }, + runtime_abi: { version: 26, marker: "scr_runtime_abi_v26" }, compiler: { command: compiler, identity: compilerVersion, diff --git a/packages/runtime/src/scr_console.c b/packages/runtime/src/scr_console.c index c8fa40b38..24cd8093b 100644 --- a/packages/runtime/src/scr_console.c +++ b/packages/runtime/src/scr_console.c @@ -148,7 +148,7 @@ static void scr_enable_utf8_console_output(void) { } #endif -void scr_runtime_abi_v25(void) {} +void scr_runtime_abi_v26(void) {} void scr_init(void) { #ifdef SCR_WORKERS diff --git a/packages/runtime/src/scr_core.h b/packages/runtime/src/scr_core.h index 5e5278588..791c600c7 100644 --- a/packages/runtime/src/scr_core.h +++ b/packages/runtime/src/scr_core.h @@ -81,7 +81,7 @@ void scr_init(void); /* Program objects emitted by the bundled LLVM helper reference this symbol. * Its versioned spelling makes a mismatched manual runtime link fail before * the program can start. */ -void scr_runtime_abi_v25(void); +void scr_runtime_abi_v26(void); void scr_runtime_workers_v8(void); /* ── the trap funnel (scr_console.c; scr_library.c under -DSCR_LIB) ────── diff --git a/packages/runtime/src/scr_dyn_builtin_stream.c b/packages/runtime/src/scr_dyn_builtin_stream.c index 209c8c39a..cdd815642 100644 --- a/packages/runtime/src/scr_dyn_builtin_stream.c +++ b/packages/runtime/src/scr_dyn_builtin_stream.c @@ -34,8 +34,7 @@ * receiver without a reference; the hook closures outlive the record. * * Not supported here (each throws the "not supported yet" Error where it - * runs): objectMode and the other options scr_stream.c's dyn option walk - * refuses, `_writev` and `_construct`, symbol event names, listeners() / + * runs): the options scr_stream.c's dyn option walk refuses, `_writev` and `_construct`, symbol event names, listeners() / * rawListeners(), `wrap()`, and pipes into values that are neither runtime * streams nor constructor-function streams. */ #include "scr_runtime.h" @@ -275,11 +274,10 @@ static ScrDyn *bcs_done_call(ScrClosure *closure, ScrDyn *const *args, size_t ar break; } default: { + /* the data is pushed as push(data) pushes it */ ScrDyn *data = bcs_arg(args, argc, 1); - ScrBytes *bytes = data->kind == SCR_DYN_BYTES ? scr_bytes_raw_view(data->v.bytes) : NULL; - ScrStr *text = data->kind == SCR_DYN_STR ? scr_str_retain(data->v.str) : NULL; - if (which == BCS_DONE_TRANSFORM) scr_stream_transform_done(s, err, bytes, text); - else scr_stream_flush_done(s, err, bytes, text); + if (which == BCS_DONE_TRANSFORM) scr_stream_transform_done_value(s, err, data); + else scr_stream_flush_done_value(s, err, data); break; } } @@ -362,13 +360,14 @@ static void bcs_read_inv(ScrClosure *cb, ScrStream *s, double size) { scr_dyn_release(object); } -/* _write(chunk, 'buffer', cb) and _transform(chunk, 'buffer', cb): a - * throw propagates to the write() caller, as in Node. */ +/* _write(chunk, 'buffer', cb) and _transform(chunk, 'buffer', cb), or the + * value and the write's encoding argument on an object-mode writable + * side: a throw propagates to the write() caller, as in Node. */ static void bcs_chunk_call(ScrClosure *cb, ScrStream *s, ScrBytes *chunk, const char *method, int done) { ScrDyn *object = scr_box_get_ref(cb->caps[0]); ScrDyn *args[3]; - args[0] = scr_dyn_new_buffer(chunk); - args[1] = bcs_str("buffer"); + args[0] = scr_stream_chunk_value(s, chunk); + args[1] = scr_stream_chunk_encoding_value(s); args[2] = bcs_done(s, done); ScrDyn *result = bcs_invoke(object, method, args, 3); for (int i = 0; i < 3; i++) scr_dyn_release(args[i]); @@ -488,8 +487,8 @@ static void bcs_listener0(ScrClosure *adapter) { bcs_listener_call(adapter, NULL, 0); } -static void bcs_listener_data(ScrClosure *adapter, ScrBytes *bytes, ScrStr *text) { - ScrDyn *arg = text ? scr_dyn_new_str(text) : scr_dyn_new_buffer(bytes); +static void bcs_listener_data(ScrClosure *adapter, ScrBytes *bytes, ScrStr *text, ScrDyn *value) { + ScrDyn *arg = value ? scr_dyn_retain(value) : text ? scr_dyn_new_str(text) : scr_dyn_new_buffer(bytes); bcs_listener_call(adapter, &arg, 1); scr_dyn_release(arg); } @@ -583,7 +582,7 @@ static bool bcs_add_listener(ScrStream *s, ScrDyn *self, ScrDyn *type, ScrDyn *l break; case 1: chained = scr_emitter_on_dyn(em, name, listener, bcs_adapter(listener, self, (void *)bcs_listener_data), - scr_ee_inv_fixed2, once, prepend); + scr_ee_inv_fixed3, once, prepend); break; case 2: chained = scr_emitter_on_dyn(em, name, listener, bcs_adapter(listener, self, (void *)bcs_listener_error), @@ -625,14 +624,15 @@ static ScrDyn *bcs_emit(ScrStream *s, ScrDyn *const *args, size_t argc) { had = scr_emitter_emit(em, name); break; case 1: + /* 'data' carries the bytes, string and value slots (scr_stream_emit_data) */ if (first->kind == SCR_DYN_BYTES) { ScrBytes *bytes = scr_bytes_raw_view(first->v.bytes); - had = scr_emitter_emit(em, name, bytes, (ScrStr *)NULL); + had = scr_emitter_emit(em, name, bytes, (ScrStr *)NULL, first); scr_bytes_release(bytes); } else if (first->kind == SCR_DYN_STR) { - had = scr_emitter_emit(em, name, (ScrBytes *)NULL, first->v.str); + had = scr_emitter_emit(em, name, (ScrBytes *)NULL, first->v.str, first); } else { - bcs_unsupported("emit('data') with a chunk other than a Buffer or string on a constructor-function stream is not supported yet"); + had = scr_emitter_emit(em, name, (ScrBytes *)NULL, (ScrStr *)NULL, first); } break; case 2: @@ -1037,10 +1037,16 @@ static ScrDyn *bcs_write(ScrStream *s, ScrDyn *self, ScrDyn *const *args, size_t ScrDyn *cb = bcs_arg(args, argc, 2); if (scr_dyn_is_callable(encoding)) { cb = encoding; - encoding = scr_dyn_undefined(); + encoding = scr_stream_writes_values(s) ? scr_dyn_new_null() : scr_dyn_undefined(); + } + bool below; + if (scr_stream_writes_values(s)) { + /* an object-mode side hands the encoding argument to _write */ + below = scr_stream_write_enc(s, chunk, encoding, bcs_callback(cb, self, s)); + } else { + if (chunk->kind == SCR_DYN_STR && !bcs_utf8_only(encoding)) return NULL; + below = scr_stream_write_dyn(s, chunk, bcs_callback(cb, self, s)); } - if (chunk->kind == SCR_DYN_STR && !bcs_utf8_only(encoding)) return NULL; - bool below = scr_stream_write_dyn(s, chunk, bcs_callback(cb, self, s)); if (scr_exc_pending()) return NULL; return scr_dyn_new_bool(below); } @@ -1055,11 +1061,17 @@ static ScrDyn *bcs_end(ScrStream *s, ScrDyn *self, ScrDyn *const *args, size_t a encoding = scr_dyn_undefined(); } else if (scr_dyn_is_callable(encoding)) { cb = encoding; - encoding = scr_dyn_undefined(); + encoding = scr_dyn_new_null(); } - if (chunk->kind == SCR_DYN_STR && !bcs_utf8_only(encoding)) return NULL; ScrStream *chained = NULL; - if (bcs_nullish(chunk)) { + if (!bcs_nullish(chunk) && scr_stream_writes_values(s)) { + /* end(chunk) writes the value with the encoding argument */ + scr_stream_write_enc(s, chunk, encoding, NULL); + if (scr_exc_pending()) return NULL; + chained = scr_stream_end(s, NULL, NULL, bcs_callback(cb, self, s)); + } else if (chunk->kind == SCR_DYN_STR && !bcs_utf8_only(encoding)) { + return NULL; + } else if (bcs_nullish(chunk)) { chained = scr_stream_end(s, NULL, NULL, bcs_callback(cb, self, s)); } else if (chunk->kind == SCR_DYN_STR) { chained = scr_stream_end(s, NULL, chunk->v.str, bcs_callback(cb, self, s)); @@ -1376,8 +1388,6 @@ static ScrDyn *bcs_getter_call(ScrClosure *closure, ScrDyn *const *args, size_t return bcs_flowing(s); case BCS_P_ERRORED: return bcs_errored(s); - case BCS_P_WRITABLE_OBJECT_MODE: - return scr_dyn_new_bool(false); case BCS_P_READABLE_LENGTH: case BCS_P_READABLE_HWM: case BCS_P_WRITABLE_LENGTH: diff --git a/packages/runtime/src/scr_stream.c b/packages/runtime/src/scr_stream.c index 271937f2e..0c17c8840 100644 --- a/packages/runtime/src/scr_stream.c +++ b/packages/runtime/src/scr_stream.c @@ -80,8 +80,11 @@ static ScrBytes *scr_stream_buffer(ScrBytes *b) { /* ── state ────────────────────────────────────────────────────────────── */ typedef struct ScrWEntry { - ScrBytes *chunk; /* owned */ + ScrBytes *chunk; /* owned; a ScrDyn* value on an object-mode writable side */ ScrClosure *cb; /* owned or NULL (the user's write(chunk, cb) callback) */ + ScrDyn *enc; /* owned or NULL = undefined: the encoding argument an + * object-mode write passed (Node hands it to _write + * unchanged; null when the callback took its place) */ } ScrWEntry; struct ScrStreamState { @@ -132,6 +135,14 @@ struct ScrStreamState { bool object_entries; /* An operator output's entry kind is decided by its first push. */ bool object_kind_set; + /* An object-mode buffer that holds a value other than a string or a + * Buffer, or both kinds: every entry is an owned ScrDyn* + * (scr_stream_add_value). Takes precedence over `encoded`. */ + bool dyn_entries; + /* The objectMode or readableObjectMode option made the buffer hold + * object entries (a stream without _read is not a seeded + * Readable.from source). */ + bool object_mode_opt; /* The parked for-await next() promise (at most one — the loop awaits * each chunk before asking again). next_dyn picks the resolution * shape: a dyn boxed by tag (the JS lane), or bytes. */ @@ -146,6 +157,11 @@ struct ScrStreamState { * nextTick and then the resumed `await new Promise(next)` * (next_wake: that tick is queued). */ bool next_parked, next_wake; + /* Node's iterator ends through eos, which waits for 'close' when the + * stream will emit it (willEmitClose, fixed when the iterator starts: + * a readable-only stream with autoDestroy and emitClose, not yet + * closed). next_eof_close: the ended waiter is held for 'close'. */ + bool next_started, next_close_wait, next_eof_close; ScrClosure *read_cb; ScrStreamReadInv read_inv; } r; @@ -157,9 +173,23 @@ struct ScrStreamState { size_t n, cap, head; int corked; bool writing, wsync, need_drain, after_scheduled; + /* Deferred afterWrites Node also defers (a user callback, a 'drain' + * or a destroyed stream): its pendingcb, which holds the finish until + * they ran — afterWrite's finishMaybe then puts 'finish' on a tick + * of its own. */ + size_t after_holds; + /* clearBuffer is running its loop: a write completing inside it + * leaves the next buffered write to the loop (Node's + * kBufferProcessing), so completions keep their order */ + bool buffer_processing; + /* objectMode writable side: queued chunks, and the chunk the write + * and transform steps receive, are ScrDyn* values (in the ScrBytes* + * slots), each counting 1 toward length. */ + bool object_mode; bool ending, finished, prefinished, final_called, finish_scheduled; bool final_pending; /* _final called, its callback not yet run */ ScrClosure *inflight_cb; /* owned or NULL */ + ScrDyn *cur_enc; /* borrowed: the running write's encoding argument */ ScrClosure *write_cb; ScrStreamChunkInv write_inv; ScrClosure *final_cb; @@ -267,31 +297,79 @@ static bool scr_stream_is(const ScrEmitter *em) { scr_vt_within(vt, &scr_passthrough_vt); } -/* Readable-buffer entry accessors: bytes chunks, or strings once an +/* Readable-buffer entry accessors: bytes chunks, strings once an * encoding is set (lengths then count JS string units, Node's encoded - * accounting). */ + * accounting), or checked-dynamic values in an object-mode buffer that + * holds other values. */ +typedef enum { SCR_ENTRY_BYTES, SCR_ENTRY_STR, SCR_ENTRY_DYN } ScrEntryKind; + +static ScrEntryKind scr_stream_rkind(const ScrStreamState *st) { + return st->r.dyn_entries ? SCR_ENTRY_DYN : st->r.encoded ? SCR_ENTRY_STR : SCR_ENTRY_BYTES; +} + static size_t scr_stream_entry_len(const ScrStreamState *st, void *e) { if (st->r.object_entries) return 1; /* objectMode-style accounting */ return st->r.encoded ? (size_t)scr_str_utf16_len((ScrStr *)e) : ((ScrBytes *)e)->len; } -static void scr_stream_entry_release(const ScrStreamState *st, void *e) { - if (st->r.encoded) scr_str_release((ScrStr *)e); +/* Releases an entry by the kind it had when it left the buffer: a 'data' + * listener may call setEncoding() or push another kind of value while the + * entry is out. */ +static void scr_stream_entry_release_kind(void *e, ScrEntryKind kind) { + if (kind == SCR_ENTRY_DYN) scr_dyn_release((ScrDyn *)e); + else if (kind == SCR_ENTRY_STR) scr_str_release((ScrStr *)e); else scr_bytes_release((ScrBytes *)e); } -/* Releases an entry by the kind it had when it left the buffer: a 'data' - * listener may call setEncoding() while the entry is out. */ -static void scr_stream_entry_release_kind(void *e, bool is_str) { - if (is_str) scr_str_release((ScrStr *)e); - else scr_bytes_release((ScrBytes *)e); +static void scr_stream_entry_release(const ScrStreamState *st, void *e) { + scr_stream_entry_release_kind(e, scr_stream_rkind(st)); +} + +/* An entry of the given kind as a dyn value (+1; moves entry). */ +static ScrDyn *scr_stream_entry_box(void *entry, ScrEntryKind kind) { + if (kind == SCR_ENTRY_DYN) return entry; + ScrDyn *d; + if (kind == SCR_ENTRY_STR) { + d = scr_dyn_new_str((ScrStr *)entry); + scr_str_release((ScrStr *)entry); + } else { + ScrBytes *b = entry; + d = b->is_buffer ? scr_dyn_new_buffer(b) : scr_dyn_new_bytes(b); + scr_bytes_release(b); + } + return d; +} + +/* Writable-queue chunks: Buffers, or dyn values on an object-mode side. */ +static size_t scr_stream_wchunk_len(const ScrStreamState *st, ScrBytes *chunk) { + return st->w.object_mode ? 1 : chunk->len; +} + +static ScrBytes *scr_stream_wchunk_retain(const ScrStreamState *st, ScrBytes *chunk) { + if (st->w.object_mode) return (ScrBytes *)scr_dyn_retain((ScrDyn *)chunk); + return scr_bytes_retain(chunk); +} + +static void scr_stream_wchunk_release(const ScrStreamState *st, ScrBytes *chunk) { + if (st->w.object_mode) scr_dyn_release((ScrDyn *)chunk); + else scr_bytes_release(chunk); +} + +/* A dyn entry the collector traces, and so frees itself in a collection + * (the kinds that carry a collector header). */ +static bool scr_stream_dyn_entry_traced(const ScrDyn *d) { + return d->kind > SCR_DYN_STR && d->kind != SCR_DYN_UNDEF; } static void scr_stream_state_drop(ScrStreamState *st, bool gc) { if (!st) return; if (st->errored) scr_error_release(st->errored); if (st->native) st->native_release(st->native); - for (size_t i = 0; i < st->r.n; i++) scr_stream_entry_release(st, st->r.buf[i]); + for (size_t i = 0; i < st->r.n; i++) { + /* The collector frees the dyn entries it traced. */ + if (gc && st->r.dyn_entries && scr_stream_dyn_entry_traced(st->r.buf[i])) continue; + scr_stream_entry_release(st, st->r.buf[i]); + } free(st->r.buf); if (st->r.enc) scr_str_release(st->r.enc); if (st->r.push_enc) scr_str_release(st->r.push_enc); @@ -312,8 +390,11 @@ static void scr_stream_state_drop(ScrStreamState *st, bool gc) { for (size_t i = 0; i < st->drain_srcs.n; i++) scr_stream_release(st->drain_srcs.src[i]); } for (size_t i = st->w.head; i < st->w.n; i++) { - scr_bytes_release(st->w.q[i].chunk); + bool traced = st->w.object_mode && scr_stream_dyn_entry_traced((ScrDyn *)st->w.q[i].chunk); + if (!gc || !traced) scr_stream_wchunk_release(st, st->w.q[i].chunk); if (!gc && st->w.q[i].cb) scr_closure_release(st->w.q[i].cb); + ScrDyn *enc = st->w.q[i].enc; + if (enc && (!gc || !scr_stream_dyn_entry_traced(enc))) scr_dyn_release(enc); } free(st->w.q); free(st->w.end_cbs); @@ -335,6 +416,11 @@ void scr_stream_st_gcfree(ScrStreamState *st) { scr_stream_state_drop(st, true); void scr_stream_st_trace(ScrStreamState *st, ScrTraceVisit visit, void *ctx) { if (!st) return; + if (st->r.dyn_entries) { + for (size_t i = 0; i < st->r.n; i++) { + if (scr_stream_dyn_entry_traced(st->r.buf[i])) visit(st->r.buf[i], ctx); + } + } if (st->r.next_waiter) visit(st->r.next_waiter, ctx); if (st->r.read_cb) visit(st->r.read_cb, ctx); if (st->construct_cb) visit(st->construct_cb, ctx); @@ -348,6 +434,9 @@ void scr_stream_st_trace(ScrStreamState *st, ScrTraceVisit visit, void *ctx) { for (size_t i = 0; i < st->fin.n; i++) visit(st->fin.cb[i], ctx); for (size_t i = st->w.head; i < st->w.n; i++) { if (st->w.q[i].cb) visit(st->w.q[i].cb, ctx); + if (st->w.object_mode && scr_stream_dyn_entry_traced((ScrDyn *)st->w.q[i].chunk)) + visit(st->w.q[i].chunk, ctx); + if (st->w.q[i].enc && scr_stream_dyn_entry_traced(st->w.q[i].enc)) visit(st->w.q[i].enc, ctx); } for (size_t i = 0; i < st->pipes.n; i++) visit(st->pipes.dst[i], ctx); for (size_t i = 0; i < st->drain_srcs.n; i++) visit(st->drain_srcs.src[i], ctx); @@ -425,6 +514,7 @@ typedef struct ScrStreamTick { ScrStreamTickOp op; ScrError *err; /* owned or NULL (SCR_ST_ERROR) */ ScrClosure *cb; /* owned or NULL (SCR_ST_AFTER_WRITE / SCR_ST_WCB_ERR / SCR_ST_WRITE_ERR) */ + bool hold; /* SCR_ST_AFTER_WRITE: counted in w.after_holds */ struct ScrStreamTick *next; } ScrStreamTick; @@ -486,10 +576,20 @@ static ScrError *scr_stream_mkerr(const char *code, const char *msg) { return e; } +/* The pending exception as a stream error (+1): Error values as + * themselves, any other thrown value as an internal assertion. */ +static ScrError *scr_stream_take_error(void) { + ScrCaught *caught = scr_exc_take(); + ScrDyn *value = scr_caught_to_dyn(caught); + scr_caught_release(caught); + ScrError *err = value ? scr_errdyn_err_of(value) : NULL; + if (value) scr_dyn_release(value); + return err ? err : scr_stream_mkerr("ERR_INTERNAL_ASSERTION", "a stream operation threw a value that is not an Error"); +} + /* ── forward decls ────────────────────────────────────────────────────── */ static void scr_stream_flow(ScrStream *s); -static int scr_stream_add_entry(ScrStream *s, void *entry /*moves*/, bool is_str); static void scr_stream_readable_listen(ScrStream *s); static void scr_stream_emit_readable_now(ScrStream *s); static void scr_stream_maybe_read_more(ScrStream *s); @@ -498,7 +598,7 @@ static void scr_stream_clear_buffer(ScrStream *s); static void scr_stream_do_destroy(ScrStream *s, ScrError *err /*borrowed*/); static void scr_stream_notify_finished(ScrStream *s); static void *scr_stream_read_n(ScrStream *s, double size); -static void *scr_stream_read_n_kind(ScrStream *s, double size, bool *is_str); +static void *scr_stream_read_n_kind(ScrStream *s, double size, ScrEntryKind *kind); static void scr_stream_settle_next(ScrStream *s); static ScrStream *scr_stream_alloc(const ScrVt *vt, const char *cls, bool has_r, bool has_w, double rhwm, double whwm, bool auto_destroy, @@ -523,10 +623,10 @@ static void scr_stream_error_or_destroy(ScrStream *s, ScrError *err) { /* ── readable internals ───────────────────────────────────────────────── */ -static void scr_stream_rbuf_push(ScrStreamState *st, void *chunk /*moves*/, bool is_str, +static void scr_stream_rbuf_push(ScrStreamState *st, void *chunk /*moves*/, ScrEntryKind kind, bool front) { - if (is_str != st->r.encoded) { - /* every entry has the buffer's representation (encoded: ScrStr) */ + if (kind != scr_stream_rkind(st)) { + /* every entry has the buffer's representation (scr_stream_rkind) */ fputs("scriptc: internal error: stream buffer entry of the wrong kind\n", stderr); abort(); } @@ -549,7 +649,8 @@ static void scr_stream_rbuf_push(ScrStreamState *st, void *chunk /*moves*/, bool } /* Takes n units (n <= length; bytes, or chars once encoded) off the - * buffer head as one +1 Buffer / string. */ + * buffer head as one +1 Buffer / string. An object-mode buffer always + * takes one whole entry (n is 1). */ static void *scr_stream_rbuf_take(ScrStreamState *st, size_t n) { void *first = st->r.n > 0 ? st->r.buf[0] : NULL; if (first && st->r.head_off == 0 && scr_stream_entry_len(st, first) == n) { @@ -610,17 +711,29 @@ static void *scr_stream_rbuf_take(ScrStreamState *st, size_t n) { return out; } -/* emit('data', chunk) + pipe delivery. Borrows chunk (a Buffer, or a - * string once encoded). The emit ABI carries BOTH payload slots — the - * bytes chunk and the string chunk, exactly one non-NULL — and the - * compiler's stream-data listener thunks dispatch on which (typed - * listeners unwrap their declared side; dyn listeners box by tag). */ -static void scr_stream_emit_data(ScrStream *s, void *chunk) { +/* emit('data', chunk) + pipe delivery. Borrows chunk (a Buffer, a string + * once encoded, or a dyn value, by kind). The emit ABI carries three + * payload slots: the bytes chunk, the string chunk, and the value of a + * dyn entry. A dyn entry that is a Buffer or a string also fills that + * slot, so at most one of the first two is non-NULL; the compiler's + * stream-data listener thunks dispatch on them (typed listeners unwrap + * their declared side; dyn listeners box by tag or take the value). */ +static void scr_stream_emit_data(ScrStream *s, void *chunk, ScrEntryKind kind) { ScrStreamState *st = s->st; - ScrBytes *b = st->r.encoded ? NULL : (ScrBytes *)chunk; - ScrStr *str = st->r.encoded ? (ScrStr *)chunk : NULL; + ScrBytes *b = NULL; + ScrStr *str = NULL; + ScrDyn *value = NULL; + if (kind == SCR_ENTRY_DYN) { + value = chunk; + if (value->kind == SCR_DYN_BYTES) b = value->v.bytes; + else if (value->kind == SCR_DYN_STR) str = value->v.str; + } else if (kind == SCR_ENTRY_STR) { + str = chunk; + } else { + b = chunk; + } ScrStr *n = scr_str_new("data", 4); - scr_emitter_emit((ScrEmitter *)s, n, b, str); + scr_emitter_emit((ScrEmitter *)s, n, b, str, value); scr_str_release(n); if (scr_exc_pending()) return; /* pipe delivery, with backpressure: a full destination pauses us until @@ -637,7 +750,9 @@ static void scr_stream_emit_data(ScrStream *s, void *chunk) { if (scr_exc_pending()) return; continue; /* the pipes array shifted down over i */ } - bool ok = b ? scr_stream_write(dst, b, NULL) : scr_stream_write_str(dst, str, NULL); + bool ok = value ? scr_stream_write_dyn(dst, value, NULL) + : b ? scr_stream_write(dst, b, NULL) + : scr_stream_write_str(dst, str, NULL); if (scr_exc_pending()) return; i++; if (!ok && !dst->st->destroyed) { @@ -681,7 +796,7 @@ static void scr_stream_end_readable(ScrStream *s) { * ERR_METHOD_NOT_IMPLEMENTED, Node's contract. */ static void scr_stream_call_read(ScrStream *s) { ScrStreamState *st = s->st; - if (st->r.read_cb == NULL && st->r.object_entries) { + if (st->r.read_cb == NULL && st->r.object_entries && !st->r.object_mode_opt) { /* Readable.from: fully seeded at construction — _read is a no-op */ st->r.in_read_sync = false; return; @@ -716,8 +831,21 @@ static void scr_stream_call_read(ScrStream *s) { * StringDecoder first (Node decodes at push); an empty decode (a partial * multi-byte tail held pending) adds nothing but still clears the * reading flag. */ +static int scr_stream_add_entry(ScrStream *s, void *entry /*moves*/, ScrEntryKind kind); +static void *scr_stream_entry_convert(ScrStreamState *st, void *entry, ScrEntryKind *kind); + static bool scr_stream_add_chunk(ScrStream *s, ScrBytes *chunk, bool front) { ScrStreamState *st = s->st; + if (st->has_r && st->r.object_entries) { + /* object mode: the Buffer is one whole entry */ + if (!front) return scr_stream_add_entry(s, scr_bytes_retain(chunk), SCR_ENTRY_BYTES) > 0; + ScrEntryKind kind = SCR_ENTRY_BYTES; + void *entry = scr_stream_entry_convert(st, scr_bytes_retain(chunk), &kind); + scr_stream_rbuf_push(st, entry, kind, true); + if (st->r.need_readable) scr_stream_emit_readable_nt(s); + scr_stream_settle_next(s); + return !st->r.ended && (st->r.length < st->r.hwm || st->r.length == 0); + } if (!st->has_r) { ScrError *e = scr_stream_mkerr("ERR_STREAM_PUSH_AFTER_EOF", "push on a Writable (no readable side)"); scr_stream_error_or_destroy(s, e); @@ -753,12 +881,12 @@ static bool scr_stream_add_chunk(ScrStream *s, ScrBytes *chunk, bool front) { (scr_emitter_has((ScrEmitter *)s, "data") || st->pipes.n > 0)) { /* the direct-emit fast path: flowing, empty buffer, async push */ if (st->r.emitted_readable) st->r.emitted_readable = false; - bool is_str = st->r.encoded; - scr_stream_emit_data(s, entry); - scr_stream_entry_release_kind(entry, is_str); + ScrEntryKind kind = scr_stream_rkind(st); + scr_stream_emit_data(s, entry, kind); + scr_stream_entry_release_kind(entry, kind); if (scr_exc_pending()) return false; } else { - scr_stream_rbuf_push(st, entry, st->r.encoded, front); + scr_stream_rbuf_push(st, entry, scr_stream_rkind(st), front); if (st->r.need_readable) scr_stream_emit_readable_nt(s); } if (!front) scr_stream_maybe_read_more(s); @@ -781,8 +909,8 @@ static void scr_stream_maybe_read_more(ScrStream *s) { * Answers a +1 Buffer — or a +1 string once encoded (lengths and the * size argument then count JS string units, Node's encoded accounting). */ static void *scr_stream_read_n(ScrStream *s, double size) { - bool is_str; - return scr_stream_read_n_kind(s, size, &is_str); + ScrEntryKind kind; + return scr_stream_read_n_kind(s, size, &kind); } /* read_n, also answering the chunk's kind as it was taken from the buffer @@ -790,9 +918,9 @@ static void *scr_stream_read_n(ScrStream *s, double size) { * inside the read can change the representation, and a 'data' listener * can call setEncoding() before this returns, so callers that need the * kind read it here rather than from st->r.encoded afterwards. */ -static void *scr_stream_read_n_kind(ScrStream *s, double size, bool *is_str) { +static void *scr_stream_read_n_kind(ScrStream *s, double size, ScrEntryKind *kind) { ScrStreamState *st = s->st; - *is_str = false; + *kind = scr_stream_rkind(st); bool absent = size < 0; size_t n = 0; if (!absent) { @@ -852,7 +980,7 @@ static void *scr_stream_read_n_kind(ScrStream *s, double size, bool *is_str) { } } } - *is_str = st->r.encoded; + *kind = scr_stream_rkind(st); void *ret = want > 0 && want <= st->r.length ? scr_stream_rbuf_take(st, want) : NULL; if (ret == NULL) { st->r.need_readable = st->r.length <= st->r.hwm; @@ -865,9 +993,9 @@ static void *scr_stream_read_n_kind(ScrStream *s, double size, bool *is_str) { if (st->r.ended && absent) scr_stream_end_readable(s); } if (ret != NULL && !st->error_emitted && !st->close_emitted) { - scr_stream_emit_data(s, ret); + scr_stream_emit_data(s, ret, *kind); if (scr_exc_pending()) { - scr_stream_entry_release_kind(ret, *is_str); + scr_stream_entry_release_kind(ret, *kind); return NULL; } } @@ -877,10 +1005,10 @@ static void *scr_stream_read_n_kind(ScrStream *s, double size, bool *is_str) { static void scr_stream_flow(ScrStream *s) { ScrStreamState *st = s->st; while (st->r.flowing == 1 && !scr_exc_pending()) { - bool is_str; - void *b = scr_stream_read_n_kind(s, -1, &is_str); + ScrEntryKind kind; + void *b = scr_stream_read_n_kind(s, -1, &kind); if (b == NULL) break; - scr_stream_entry_release_kind(b, is_str); + scr_stream_entry_release_kind(b, kind); } } @@ -950,43 +1078,33 @@ ScrDyn *scr_stream_done_dyn_d(ScrClosure *clo, ScrDyn *const *args, size_t argc) return scr_stream_done_dyn_ret(); } -static void scr_stream_dyn_data(ScrDyn *const *args, size_t argc, - ScrBytes **data, ScrStr **data_str) { - *data = NULL; - *data_str = NULL; - if (argc < 2) return; - const ScrDyn *a = args[1]; - if (a->kind == SCR_DYN_BYTES) *data = scr_bytes_raw_view(a->v.bytes); - else if (a->kind == SCR_DYN_STR) *data_str = scr_str_retain(a->v.str); -} - +/* callback(err, data) of an untyped transform or flush: data is pushed + * as push(data) pushes it. */ ScrDyn *scr_stream_done_dyn_t(ScrClosure *clo, ScrDyn *const *args, size_t argc) { ScrStream *s = scr_stream_dyn_recv(clo); - ScrBytes *data; - ScrStr *data_str; - scr_stream_dyn_data(args, argc, &data, &data_str); - scr_stream_transform_done(s, scr_stream_dyn_err(args, argc), data, data_str); + scr_stream_transform_done_value(s, scr_stream_dyn_err(args, argc), argc > 1 ? args[1] : NULL); scr_stream_release(s); return scr_stream_done_dyn_ret(); } ScrDyn *scr_stream_done_dyn_l(ScrClosure *clo, ScrDyn *const *args, size_t argc) { ScrStream *s = scr_stream_dyn_recv(clo); - ScrBytes *data; - ScrStr *data_str; - scr_stream_dyn_data(args, argc, &data, &data_str); - scr_stream_flush_done(s, scr_stream_dyn_err(args, argc), data, data_str); + scr_stream_flush_done_value(s, scr_stream_dyn_err(args, argc), argc > 1 ? args[1] : NULL); scr_stream_release(s); return scr_stream_done_dyn_ret(); } /* Checked-dynamic chunks (the JS lane's push/write of any-typed values): * dispatch by dyn tag — bytes copy out, strings convert utf8, null takes - * the null path (EOF for push; ERR_STREAM_NULL_VALUES for write). Any - * other write throws Node's ERR_INVALID_ARG_TYPE; any other push throws - * the null-values TypeError (Node reports ERR_INVALID_ARG_TYPE through - * 'error'). Borrow d. */ + * the null path (EOF for push; ERR_STREAM_NULL_VALUES for write). On an + * object-mode side every other value is one entry. Otherwise any other + * write throws Node's ERR_INVALID_ARG_TYPE, push(undefined) adds nothing, + * and any other push reports ERR_INVALID_ARG_TYPE through 'error', as + * readableAddChunkPushByteMode does. Borrow d. */ bool scr_stream_push_dyn(ScrStream *s, const ScrDyn *d) { + ScrStreamState *st = s->st; + if (d->kind != SCR_DYN_NULL && st->has_r && st->r.object_entries) + return scr_stream_push_object(s, d) > 0; switch (d->kind) { case SCR_DYN_BYTES: { ScrBytes *b = scr_bytes_raw_view(d->v.bytes); @@ -998,15 +1116,26 @@ bool scr_stream_push_dyn(ScrStream *s, const ScrDyn *d) { return scr_stream_push_str(s, d->v.str); case SCR_DYN_NULL: return scr_stream_push_null(s); + case SCR_DYN_UNDEF: + if (!st->has_r) return false; + st->r.reading = false; + scr_stream_maybe_read_more(s); + return !st->r.ended && (st->r.length < st->r.hwm || st->r.length == 0); default: { - static const char msg[] = "May not write null values to stream"; - scr_throw_error_msg_code(SCR_ERR_TYPE, msg, sizeof msg - 1, "ERR_STREAM_NULL_VALUES"); + scr_dyn_arg_type_fail("chunk", "of type string or an instance of Buffer, TypedArray, or DataView", d); + ScrError *e = scr_stream_take_error(); + scr_stream_error_or_destroy(s, e); + scr_error_release(e); return false; } } } +static bool scr_stream_write_value(ScrStream *s, ScrDyn *v, ScrClosure *cb); + bool scr_stream_write_dyn(ScrStream *s, const ScrDyn *d, ScrClosure *cb) { + if (d->kind != SCR_DYN_NULL && s->st->has_w && s->st->w.object_mode) + return scr_stream_write_value(s, (ScrDyn *)d, cb); switch (d->kind) { case SCR_DYN_BYTES: { ScrBytes *b = scr_bytes_raw_view(d->v.bytes); @@ -1051,14 +1180,28 @@ static void scr_stream_next_str_fence(void) { scr_throw_error_msg(SCR_ERR_ERROR, msg, sizeof msg - 1); } -/* Fulfills the parked iterator with a chunk taken from the buffer; is_str - * is its kind as taken. The typed lane's chunk is a Buffer, so a string - * chunk rejects with the encoding fence instead. */ +/* Fulfills the parked iterator with a chunk taken from the buffer; kind + * is its kind as taken. The typed lane's chunk is a Buffer, so another + * chunk rejects with the encoding fence instead. The dyn lane's end is + * the done marker (scr_stream_from_done): an object-mode stream can + * yield undefined. */ static void scr_stream_next_fulfill(ScrStreamState *st, ScrPromise *w /*moves*/, - void *chunk /*moves or NULL=EOF*/, bool is_str) { + void *chunk /*moves or NULL=EOF*/, ScrEntryKind kind) { void *payload; bool dyn = st->r.next_dyn; - if (!dyn && chunk != NULL && is_str) { + if (!dyn && chunk != NULL && kind == SCR_ENTRY_DYN) { + ScrDyn *d = chunk; + if (d->kind == SCR_DYN_BYTES) { + chunk = scr_bytes_raw_view(d->v.bytes); + kind = SCR_ENTRY_BYTES; + scr_dyn_release(d); + } else { + chunk = scr_dyn_string_coerce_js(d); + kind = SCR_ENTRY_STR; + scr_dyn_release(d); + } + } + if (!dyn && chunk != NULL && kind == SCR_ENTRY_STR) { scr_str_release((ScrStr *)chunk); scr_stream_next_str_fence(); scr_promise_reject_pending(w); @@ -1066,17 +1209,7 @@ static void scr_stream_next_fulfill(ScrStreamState *st, ScrPromise *w /*moves*/, return; } if (dyn) { - ScrDyn *d; - if (chunk == NULL) { - d = scr_dyn_retain(scr_dyn_undefined()); /* the EOF sentinel */ - } else if (is_str) { - d = scr_dyn_new_str((ScrStr *)chunk); - scr_str_release((ScrStr *)chunk); - } else { - d = scr_dyn_new_buffer((ScrBytes *)chunk); - scr_bytes_release((ScrBytes *)chunk); - } - payload = d; + payload = chunk == NULL ? scr_stream_from_done() : scr_stream_entry_box(chunk, kind); } else { payload = chunk ? (ScrBytes *)chunk : scr_bytes_new(SCR_BYTES_U8, 0); } @@ -1108,11 +1241,11 @@ static void scr_stream_iter_step(ScrStream *s) { if (!st->r.next_waiter) return; if (!st->destroyed && !st->errored) { st->r.next_reading = true; - bool is_str; - void *chunk = scr_stream_read_n_kind(s, -1, &is_str); + ScrEntryKind kind; + void *chunk = scr_stream_read_n_kind(s, -1, &kind); st->r.next_reading = false; if (scr_exc_pending()) { - if (chunk) scr_stream_entry_release_kind(chunk, is_str); + if (chunk) scr_stream_entry_release_kind(chunk, kind); ScrPromise *w = st->r.next_waiter; st->r.next_waiter = NULL; if (w) { @@ -1124,7 +1257,7 @@ static void scr_stream_iter_step(ScrStream *s) { if (chunk) { ScrPromise *w = st->r.next_waiter; st->r.next_waiter = NULL; - scr_stream_next_fulfill(st, w, chunk, is_str); + scr_stream_next_fulfill(st, w, chunk, kind); return; } } @@ -1175,13 +1308,18 @@ static void scr_stream_settle_next(ScrStream *s) { } ScrPromise *w = st->r.next_waiter; st->r.next_waiter = NULL; - bool is_str = st->r.encoded; + ScrEntryKind kind = scr_stream_rkind(st); void *chunk = scr_stream_rbuf_take(st, st->r.object_entries ? 1 : st->r.length); - scr_stream_next_fulfill(st, w, chunk, is_str); + scr_stream_next_fulfill(st, w, chunk, kind); if (st->r.ended && st->r.length == 0) scr_stream_end_readable(s); return; } if (st->r.ended || st->destroyed) { + if (st->r.ended && st->r.next_close_wait && !st->close_emitted) { + if (!st->r.end_emitted) scr_stream_end_readable(s); + st->r.next_eof_close = true; + return; + } if (st->r.ended && !st->r.end_emitted) { /* Node's iterator completes AFTER 'end' (and its autoDestroy): * queue the sentinel BEHIND the pending 'end' tick, so code after @@ -1192,7 +1330,7 @@ static void scr_stream_settle_next(ScrStream *s) { } ScrPromise *w = st->r.next_waiter; st->r.next_waiter = NULL; - scr_stream_next_fulfill(st, w, NULL, false); + scr_stream_next_fulfill(st, w, NULL, SCR_ENTRY_BYTES); } } @@ -1201,7 +1339,7 @@ static ScrPromise *scr_stream_next_chunk_impl(ScrStream *s, bool dyn) { ScrPromise *p = scr_promise_new(); if (!st->has_r) { st->r.next_dyn = dyn; - scr_stream_next_fulfill(st, scr_promise_retain(p), NULL, false); + scr_stream_next_fulfill(st, scr_promise_retain(p), NULL, SCR_ENTRY_BYTES); return p; } if (st->r.next_waiter) { @@ -1214,6 +1352,11 @@ static ScrPromise *scr_stream_next_chunk_impl(ScrStream *s, bool dyn) { st->r.next_dyn = dyn; st->r.next_waiter = scr_promise_retain(p); st->r.next_parked = false; + if (!st->r.next_started) { + st->r.next_started = true; + st->r.next_close_wait = + !st->has_w && st->auto_destroy && st->emit_close && !st->close_scheduled && !st->close_emitted; + } /* createAsyncIterator starts with stream.on('readable', next) */ scr_stream_readable_listen(s); scr_stream_iter_step(s); @@ -1268,25 +1411,11 @@ static void scr_from_src_release(ScrFromSrc *f) { static void *scr_from_src_retain_v(void *f) { return scr_from_src_retain(f); } static void scr_from_src_release_v(void *f) { scr_from_src_release(f); } -/* A Readable.from source whose values no longer fit the buffer's kind - * (strings beside Buffers): destroyed with the "not supported yet" Error. */ -static void scr_from_destroy_mixed(ScrStream *s) { - static const char m[] = "a Readable.from source that mixes strings and Buffers is not supported yet"; - ScrStr *msg = scr_str_new(m, sizeof m - 1); - ScrError *e = scr_error_new(SCR_ERR_ERROR, msg); - scr_str_release(msg); - scr_stream_release(scr_stream_destroy(s, e)); - scr_error_release(e); -} - /* One typed element into the stream: a whole entry in object mode, a * chunk in byte mode. Moves e. Returns push's answer. */ static bool scr_from_push_typed(ScrStream *s, void *e, bool strings) { - if (s->st->r.object_entries) { - int pushed = scr_stream_add_entry(s, e, strings); - if (pushed < 0) scr_from_destroy_mixed(s); - return pushed > 0; - } + if (s->st->r.object_entries) + return scr_stream_add_entry(s, e, strings ? SCR_ENTRY_STR : SCR_ENTRY_BYTES) > 0; bool more = strings ? scr_stream_push_str(s, e) : scr_stream_push(s, e); if (strings) scr_str_release(e); else scr_bytes_release(e); @@ -1447,10 +1576,10 @@ ScrStream *scr_stream_from_arr(ScrArr *arr, double flags, double hwm) { } /* The JS lane: one checked-dynamic value into the stream. null is - * ERR_STREAM_NULL_VALUES; in object mode, values other than strings and - * Buffers (or a mix of the two) are outside the stream model; byte mode - * rejects them with push()'s ERR_INVALID_ARG_TYPE. Each failure destroys - * the stream and answers -1. Borrows v. */ + * ERR_STREAM_NULL_VALUES; in object mode every other value is an entry; + * byte mode rejects values other than strings and Buffers with push()'s + * ERR_INVALID_ARG_TYPE. Each failure destroys the stream and answers -1. + * Borrows v. */ int scr_stream_from_push(ScrStream *s, const ScrDyn *v) { ScrError *e = NULL; if (v->kind == SCR_DYN_NULL) { @@ -1460,14 +1589,7 @@ int scr_stream_from_push(ScrStream *s, const ScrDyn *v) { scr_str_release(msg); scr_error_set_code(e, "ERR_STREAM_NULL_VALUES"); } else if (s->st->r.object_entries) { - int pushed = scr_stream_push_object(s, v); - if (pushed >= 0) return pushed; - static const char mixed[] = "a Readable.from source that mixes strings and Buffers is not supported yet"; - static const char other[] = "Readable.from over values other than strings and Buffers is not supported yet"; - const char *m = pushed == -2 ? mixed : other; - ScrStr *msg = scr_str_new(m, strlen(m)); - e = scr_error_new(SCR_ERR_ERROR, msg); - scr_str_release(msg); + return scr_stream_push_object(s, v); } else if (v->kind == SCR_DYN_STR || v->kind == SCR_DYN_BYTES) { return scr_stream_push_dyn(s, v) ? 1 : 0; } else { @@ -1598,61 +1720,72 @@ ScrStream *scr_stream_new_object_readable(ScrClosure *read, ScrStreamReadInv rea return s; } -/* An object-mode entry in the buffer's representation: a Buffer on a - * stream with a decoder decodes through it (Node's decoder.write in - * readableAddChunkPushObjectMode); an entry of the other kind otherwise - * mixes strings and Buffers, which the buffer cannot hold. Moves entry; - * +1, or NULL (entry released). */ -static void *scr_stream_entry_convert(ScrStreamState *st, void *entry, bool is_str) { - if (is_str == st->r.encoded) return entry; - if (!is_str && st->r.decoding) { +/* The object-mode buffer starts holding dyn values: every buffered entry + * is boxed. */ +static void scr_stream_rbuf_to_dyn(ScrStreamState *st) { + ScrEntryKind kind = scr_stream_rkind(st); + for (size_t i = 0; i < st->r.n; i++) st->r.buf[i] = scr_stream_entry_box(st->r.buf[i], kind); + st->r.dyn_entries = true; + st->r.object_kind_set = true; +} + +/* An object-mode entry in the buffer's representation (moves entry; +1). + * A Buffer on a stream with a decoder decodes through it (Node's + * decoder.write in readableAddChunkPushObjectMode); an entry of another + * kind turns the buffer into dyn entries. */ +static void *scr_stream_entry_convert(ScrStreamState *st, void *entry, ScrEntryKind *kind) { + ScrEntryKind want = scr_stream_rkind(st); + if (*kind == want) return entry; + if (*kind == SCR_ENTRY_BYTES && want == SCR_ENTRY_STR && st->r.decoding) { ScrBytes *b = entry; ScrStr *dec = scr_strdec_write(st->r.enc, st->r.dec_pending, b); st->r.dec_pending = scr_strdec_next(st->r.enc, st->r.dec_pending, b); scr_bytes_release(b); + *kind = SCR_ENTRY_STR; return dec; } - if (is_str) scr_str_release(entry); - else scr_bytes_release(entry); - return NULL; + if (want != SCR_ENTRY_DYN) scr_stream_rbuf_to_dyn(st); + ScrDyn *d = scr_stream_entry_box(entry, *kind); + *kind = SCR_ENTRY_DYN; + return d; } /* readableAddChunk in object mode: every value is one whole entry, empty - * strings and Buffers included. is_str gives entry's kind. Answers push()'s - * result, or -2 (entry released) when the kinds cannot mix. */ -static int scr_stream_add_entry(ScrStream *s, void *entry /*moves*/, bool is_str) { + * strings and Buffers included. kind gives entry's kind. Answers push()'s + * result. */ +static int scr_stream_add_entry(ScrStream *s, void *entry /*moves*/, ScrEntryKind kind) { ScrStreamState *st = s->st; if (!st->r.object_kind_set && st->r.length == 0) { /* the first entry picks the representation */ st->r.object_kind_set = true; - if (is_str && !st->r.encoded) { + if (kind == SCR_ENTRY_STR && !st->r.encoded) { st->r.encoded = true; if (!st->r.enc) st->r.enc = scr_str_new("utf8", 4); + } else if (kind == SCR_ENTRY_DYN) { + st->r.dyn_entries = true; } } - entry = scr_stream_entry_convert(st, entry, is_str); - if (entry == NULL) return -2; + entry = scr_stream_entry_convert(st, entry, &kind); if (st->r.ended) { - scr_stream_entry_release(st, entry); + scr_stream_entry_release_kind(entry, kind); ScrError *e = scr_stream_mkerr("ERR_STREAM_PUSH_AFTER_EOF", "stream.push() after EOF"); scr_stream_error_or_destroy(s, e); scr_error_release(e); return 0; } if (st->destroyed || st->errored) { - scr_stream_entry_release(st, entry); + scr_stream_entry_release_kind(entry, kind); return 0; } st->r.reading = false; if (st->r.flowing == 1 && st->r.length == 0 && !st->r.in_read_sync && (scr_emitter_has((ScrEmitter *)s, "data") || st->pipes.n > 0)) { if (st->r.emitted_readable) st->r.emitted_readable = false; - bool is_str = st->r.encoded; - scr_stream_emit_data(s, entry); - scr_stream_entry_release_kind(entry, is_str); + scr_stream_emit_data(s, entry, kind); + scr_stream_entry_release_kind(entry, kind); if (scr_exc_pending()) return 0; } else { - scr_stream_rbuf_push(st, entry, st->r.encoded, false); + scr_stream_rbuf_push(st, entry, kind, false); if (st->r.need_readable) scr_stream_emit_readable_nt(s); } scr_stream_maybe_read_more(s); @@ -1660,12 +1793,22 @@ static int scr_stream_add_entry(ScrStream *s, void *entry /*moves*/, bool is_str return !st->r.ended && (st->r.length < st->r.hwm || st->r.length == 0); } +/* push(value) on an object-mode stream: a string or a Buffer keeps its + * kind, any other value is a dyn entry. Borrows v. */ int scr_stream_push_object(ScrStream *s, const ScrDyn *v) { - bool is_str = v->kind == SCR_DYN_STR; - if (!is_str && v->kind != SCR_DYN_BYTES) return -1; - void *entry = is_str ? (void *)scr_str_retain(v->v.str) : (void *)scr_bytes_raw_view(v->v.bytes); - int pushed = scr_stream_add_entry(s, entry, is_str); - return pushed < 0 ? pushed : pushed ? 1 : 0; + void *entry; + ScrEntryKind kind; + if (v->kind == SCR_DYN_STR) { + entry = scr_str_retain(v->v.str); + kind = SCR_ENTRY_STR; + } else if (v->kind == SCR_DYN_BYTES) { + entry = scr_bytes_raw_view(v->v.bytes); + kind = SCR_ENTRY_BYTES; + } else { + entry = scr_dyn_retain((ScrDyn *)v); + kind = SCR_ENTRY_DYN; + } + return scr_stream_add_entry(s, entry, kind) ? 1 : 0; } /* ── the registration hook ('data'/'readable' listeners kick flow) ────── */ @@ -1706,7 +1849,8 @@ static void scr_stream_on_listener(ScrEmitter *em, ScrStr *name) { /* ── writable internals ───────────────────────────────────────────────── */ -static void scr_stream_wq_push(ScrStreamState *st, ScrBytes *chunk /*moves*/, ScrClosure *cb /*moves*/) { +static void scr_stream_wq_push(ScrStreamState *st, ScrBytes *chunk /*moves*/, ScrClosure *cb /*moves*/, + ScrDyn *enc /*moves*/) { if (st->w.n == st->w.cap) { st->w.cap = st->w.cap ? st->w.cap * 2 : 4; st->w.q = realloc(st->w.q, st->w.cap * sizeof *st->w.q); @@ -1714,29 +1858,49 @@ static void scr_stream_wq_push(ScrStreamState *st, ScrBytes *chunk /*moves*/, Sc } st->w.q[st->w.n].chunk = chunk; st->w.q[st->w.n].cb = cb; + st->w.q[st->w.n].enc = enc; st->w.n++; } static void scr_stream_transform_callback(ScrStream *s); -static void scr_stream_do_write(ScrStream *s, ScrBytes *chunk /*moves*/, ScrClosure *cb /*moves*/) { +static void scr_stream_do_write_inner(ScrStream *s, ScrBytes *chunk /*moves*/, ScrClosure *cb /*moves*/); + +/* One write reaching _write/_transform; the callback reads the write's + * encoding argument through w.cur_enc while it runs. */ +static void scr_stream_do_write(ScrStream *s, ScrBytes *chunk /*moves*/, ScrClosure *cb /*moves*/, + ScrDyn *enc /*moves*/) { + ScrStreamState *st = s->st; + if (enc == NULL) { + scr_stream_do_write_inner(s, chunk, cb); + return; + } + ScrDyn *outer = st->w.cur_enc; + st->w.cur_enc = enc; + scr_stream_do_write_inner(s, chunk, cb); + st->w.cur_enc = outer; + scr_dyn_release(enc); +} + +static void scr_stream_do_write_inner(ScrStream *s, ScrBytes *chunk /*moves*/, ScrClosure *cb /*moves*/) { ScrStreamState *st = s->st; st->w.writing = true; st->w.wsync = true; - st->w.inflight_len = chunk->len; + st->w.inflight_len = scr_stream_wchunk_len(st, chunk); st->w.inflight_cb = cb; if (st->is_transform || st->passthrough) st->xf_length = st->r.length; if (st->passthrough && st->transform_cb == NULL) { /* identity: push through, complete synchronously */ - scr_stream_add_chunk(s, chunk, false); - scr_bytes_release(chunk); + if (st->w.object_mode) scr_stream_push_dyn(s, (ScrDyn *)chunk); + else scr_stream_add_chunk(s, chunk, false); + scr_stream_wchunk_release(st, chunk); if (!scr_exc_pending()) scr_stream_transform_callback(s); st->w.wsync = false; return; } if (st->is_transform || st->passthrough) { if (st->transform_cb == NULL) { - scr_bytes_release(chunk); + scr_stream_wchunk_release(st, chunk); ScrError *e = scr_stream_mkerr("ERR_METHOD_NOT_IMPLEMENTED", "The _transform() method is not implemented"); st->w.wsync = false; scr_stream_error_or_destroy(s, e); @@ -1744,12 +1908,12 @@ static void scr_stream_do_write(ScrStream *s, ScrBytes *chunk /*moves*/, ScrClos return; } st->transform_inv(st->transform_cb, s, chunk); - scr_bytes_release(chunk); + scr_stream_wchunk_release(st, chunk); st->w.wsync = false; return; } if (st->w.write_cb == NULL) { - scr_bytes_release(chunk); + scr_stream_wchunk_release(st, chunk); ScrError *e = scr_stream_mkerr("ERR_METHOD_NOT_IMPLEMENTED", "The _write() method is not implemented"); st->w.wsync = false; scr_stream_error_or_destroy(s, e); @@ -1757,7 +1921,7 @@ static void scr_stream_do_write(ScrStream *s, ScrBytes *chunk /*moves*/, ScrClos return; } st->w.write_inv(st->w.write_cb, s, chunk); - scr_bytes_release(chunk); + scr_stream_wchunk_release(st, chunk); st->w.wsync = false; } @@ -1770,8 +1934,9 @@ static void scr_stream_error_buffer(ScrStream *s) { if (st->w.writing) return; while (st->w.head < st->w.n && !scr_exc_pending()) { ScrWEntry e = st->w.q[st->w.head++]; - st->w.length -= e.chunk->len; - scr_bytes_release(e.chunk); + st->w.length -= scr_stream_wchunk_len(st, e.chunk); + scr_stream_wchunk_release(st, e.chunk); + if (e.enc) scr_dyn_release(e.enc); if (e.cb) { ((void (*)(ScrClosure *))e.cb->fn)(e.cb); scr_closure_release(e.cb); @@ -1863,12 +2028,14 @@ static SCR_COLD void scr_stream_writev_buffer(ScrStream *s) { } st->w.head = 0; st->w.n = 0; - scr_stream_do_write(s, all, cbs); + scr_stream_do_write(s, all, cbs, NULL); } /* The buffered writes, one at a time (Node's clearBuffer without _writev). */ static void scr_stream_clear_buffer_each(ScrStream *s) { ScrStreamState *st = s->st; + if (st->w.buffer_processing) return; + st->w.buffer_processing = true; while (!st->w.writing && st->w.head < st->w.n && st->w.corked == 0 && !st->destroyed && !scr_exc_pending()) { ScrWEntry e = st->w.q[st->w.head++]; @@ -1876,8 +2043,9 @@ static void scr_stream_clear_buffer_each(ScrStream *s) { st->w.head = 0; st->w.n = 0; } - scr_stream_do_write(s, e.chunk, e.cb); + scr_stream_do_write(s, e.chunk, e.cb, e.enc); } + st->w.buffer_processing = false; } /* The fs streams' clearBuffer: nothing while constructing, and _writev @@ -1947,6 +2115,11 @@ static void scr_stream_finish_maybe(ScrStream *s) { scr_stream_emit0(s, "prefinish"); if (scr_exc_pending()) return; } + /* prefinish ran; without a _final the deferred afterWrites still hold + * 'finish' (Node's pendingcb), and the last of them comes back here. + * A _final's callback puts 'finish' on a tick at once (callFinal's + * onFinish), and a Transform's _final is its flush. */ + if (st->w.after_holds > 0 && !st->w.final_cb && !st->is_transform && !st->passthrough) return; st->w.finish_scheduled = true; scr_st_tick(s, SCR_ST_FINISH, NULL, NULL); } @@ -2327,10 +2500,10 @@ static void scr_stream_dynopt_read_inv(ScrClosure *cb, ScrStream *s, double size static void scr_stream_dynopt_chunk3(ScrClosure *cb, ScrStream *s, ScrBytes *chunk, ScrDynThunk glue, const char *what) { ScrDyn *args[3]; - args[0] = scr_dyn_new_buffer(chunk); - ScrStr *enc = scr_str_new("buffer", 6); - args[1] = scr_dyn_new_str(enc); - scr_str_release(enc); + /* (chunk, encoding, cb): an object-mode side passes the value and the + * write's encoding argument, as Node's Writable does */ + args[0] = scr_stream_chunk_value(s, chunk); + args[1] = scr_stream_chunk_encoding_value(s); args[2] = scr_stream_dynopt_done(s, glue, 1, "(error)"); ScrDyn *fn = scr_stream_dynopt_target(cb); ScrDyn *r = scr_dyn_call(fn, args, 3, what); @@ -2345,10 +2518,8 @@ static void scr_stream_dynopt_write_inv(ScrClosure *cb, ScrStream *s, ScrBytes * static void scr_stream_dynopt_transform_inv(ScrClosure *cb, ScrStream *s, ScrBytes *chunk) { ScrDyn *args[3]; - args[0] = scr_dyn_new_buffer(chunk); - ScrStr *enc = scr_str_new("buffer", 6); - args[1] = scr_dyn_new_str(enc); - scr_str_release(enc); + args[0] = scr_stream_chunk_value(s, chunk); + args[1] = scr_stream_chunk_encoding_value(s); args[2] = scr_stream_dynopt_done(s, &scr_stream_done_dyn_t, 2, "(error,data)"); ScrDyn *fn = scr_stream_dynopt_target(cb); ScrDyn *r = scr_dyn_call(fn, args, 3, "transform"); @@ -2398,6 +2569,7 @@ typedef struct { double rhwm, whwm; bool auto_destroy, emit_close, allow_half_open; bool readable_side, writable_side; + bool readable_object, writable_object; /* objectMode and the sided keys */ ScrStr *enc; /* owned canonical name, or NULL */ /* BORROWED callable fields (owned by the options record). */ ScrDyn *read, *write, *final_fn, *destroy, *transform, *flush; @@ -2474,17 +2646,17 @@ static bool scr_stream_parse_dyn_opts(const ScrDyn *opts, char base, ScrStreamDy out->readable_side = true; out->writable_side = true; out->enc = NULL; + out->readable_object = out->writable_object = false; out->read = out->write = out->final_fn = out->destroy = out->transform = out->flush = NULL; if (opts == NULL || opts->kind != SCR_DYN_OBJ) return true; /* Node's `if (options)` */ const bool duplexish = base == 'd' || base == 't' || base == 'p'; const bool transformish = base == 't' || base == 'p'; const bool r_sided = base != 'w'; - if (scr_stream_dynopt_truthy(opts, "objectMode", 10) || - scr_stream_dynopt_truthy(opts, "readableObjectMode", 18) || - scr_stream_dynopt_truthy(opts, "writableObjectMode", 18)) { - static const char m[] = "objectMode streams are not supported yet (chunks are Buffers or utf8 strings)"; - return scr_stream_dynopt_unsupported(m, sizeof m - 1); + { + bool object = scr_stream_dynopt_truthy(opts, "objectMode", 10); + out->readable_object = object || (duplexish && scr_stream_dynopt_truthy(opts, "readableObjectMode", 18)); + out->writable_object = object || (duplexish && scr_stream_dynopt_truthy(opts, "writableObjectMode", 18)); } if (scr_stream_dynopt_false(scr_dyn_obj_get((ScrDyn *)opts, "decodeStrings", 13))) { static const char m[] = "decodeStrings: false is not supported yet (chunks always decode to Buffers)"; @@ -2527,7 +2699,7 @@ static bool scr_stream_parse_dyn_opts(const ScrDyn *opts, char base, ScrStreamDy /* highWaterMark wins over the sided keys (Node's getHighWaterMark); * the readable side is checked first, as Duplex's Readable constructor - * runs first. */ + * runs first. An object-mode side defaults to 16 entries. */ if (duplexish) { out->rhwm = scr_stream_dynopt_hwm(opts, "readableHighWaterMark", "options.readableHighWaterMark"); if (out->rhwm == -2) return false; @@ -2538,6 +2710,8 @@ static bool scr_stream_parse_dyn_opts(const ScrDyn *opts, char base, ScrStreamDy if (hwm == -2) return false; out->rhwm = out->whwm = hwm; } + if (out->rhwm == -1 && out->readable_object) out->rhwm = 16; + if (out->whwm == -1 && out->writable_object) out->whwm = 16; out->auto_destroy = !scr_stream_dynopt_false(scr_dyn_obj_get((ScrDyn *)opts, "autoDestroy", 11)); out->emit_close = !scr_stream_dynopt_false(scr_dyn_obj_get((ScrDyn *)opts, "emitClose", 9)); if (duplexish) { @@ -2578,6 +2752,10 @@ static ScrClosure *scr_stream_dynopt_pick(ScrDyn *opt, void *dyn_inv, ScrClosure return fb; } +static void scr_stream_dynopt_apply_object(ScrStream *s, const ScrStreamDynOpts *o) { + if (s != NULL && s->st != NULL) scr_stream_set_object_mode(s, o->readable_object, o->writable_object); +} + static void scr_stream_dynopt_apply_enc(ScrStream *s, ScrStr *enc) { if (enc == NULL) return; ScrStream *chain = scr_stream_set_encoding(s, enc); @@ -2593,6 +2771,7 @@ ScrStream *scr_stream_new_readable_dyn(ScrDyn *opts) { ScrClosure *destroy = scr_stream_dynopt_pick(o.destroy, (void *)&scr_stream_dynopt_destroy_inv, NULL, NULL, &dinv); ScrStream *s = scr_stream_new_readable(o.rhwm, o.auto_destroy, o.emit_close, read, (ScrStreamReadInv)rinv, destroy, (ScrStreamErrInv)dinv); + scr_stream_dynopt_apply_object(s, &o); scr_stream_dynopt_apply_enc(s, o.enc); return s; } @@ -2604,8 +2783,10 @@ ScrStream *scr_stream_new_writable_dyn(ScrDyn *opts) { ScrClosure *write = scr_stream_dynopt_pick(o.write, (void *)&scr_stream_dynopt_write_inv, NULL, NULL, &winv); ScrClosure *final_cb = scr_stream_dynopt_pick(o.final_fn, (void *)&scr_stream_dynopt_final_inv, NULL, NULL, &finv); ScrClosure *destroy = scr_stream_dynopt_pick(o.destroy, (void *)&scr_stream_dynopt_destroy_inv, NULL, NULL, &dinv); - return scr_stream_new_writable(o.whwm, o.auto_destroy, o.emit_close, + ScrStream *s = scr_stream_new_writable(o.whwm, o.auto_destroy, o.emit_close, write, (ScrStreamChunkInv)winv, final_cb, (ScrStreamPlainInv)finv, destroy, (ScrStreamErrInv)dinv); + scr_stream_dynopt_apply_object(s, &o); + return s; } ScrStream *scr_stream_new_duplex_dyn(ScrDyn *opts) { @@ -2620,6 +2801,7 @@ ScrStream *scr_stream_new_duplex_dyn(ScrDyn *opts) { o.allow_half_open, o.readable_side, o.writable_side, read, (ScrStreamReadInv)rinv, write, (ScrStreamChunkInv)winv, final_cb, (ScrStreamPlainInv)finv, destroy, (ScrStreamErrInv)dinv); + scr_stream_dynopt_apply_object(s, &o); scr_stream_dynopt_apply_enc(s, o.enc); return s; } @@ -2640,6 +2822,7 @@ static ScrStream *scr_stream_new_transformish_dyn(ScrDyn *opts, char base) { o.allow_half_open, o.readable_side, o.writable_side, transform, (ScrStreamChunkInv)tinv, flush, (ScrStreamPlainInv)linv, destroy, (ScrStreamErrInv)dinv); + scr_stream_dynopt_apply_object(s, &o); scr_stream_dynopt_apply_enc(s, o.enc); return s; } @@ -2666,6 +2849,7 @@ void scr_stream_init_readable_dyn(ScrStream *s, ScrDyn *opts, ScrClosure *destroy = scr_stream_dynopt_pick(o.destroy, (void *)&scr_stream_dynopt_destroy_inv, destroy_fb, (void *)destroy_fb_inv, &dinv); scr_stream_init_readable(s, o.rhwm, o.auto_destroy, o.emit_close, read, (ScrStreamReadInv)rinv, destroy, (ScrStreamErrInv)dinv); + scr_stream_dynopt_apply_object(s, &o); scr_stream_dynopt_apply_enc(s, o.enc); } @@ -2686,6 +2870,7 @@ void scr_stream_init_writable_dyn(ScrStream *s, ScrDyn *opts, ScrClosure *destroy = scr_stream_dynopt_pick(o.destroy, (void *)&scr_stream_dynopt_destroy_inv, destroy_fb, (void *)destroy_fb_inv, &dinv); scr_stream_init_writable(s, o.whwm, o.auto_destroy, o.emit_close, write, (ScrStreamChunkInv)winv, final_cb, (ScrStreamPlainInv)finv, destroy, (ScrStreamErrInv)dinv); + scr_stream_dynopt_apply_object(s, &o); } void scr_stream_init_duplex_dyn(ScrStream *s, ScrDyn *opts, @@ -2710,6 +2895,7 @@ void scr_stream_init_duplex_dyn(ScrStream *s, ScrDyn *opts, o.allow_half_open, o.readable_side, o.writable_side, read, (ScrStreamReadInv)rinv, write, (ScrStreamChunkInv)winv, final_cb, (ScrStreamPlainInv)finv, destroy, (ScrStreamErrInv)dinv); + scr_stream_dynopt_apply_object(s, &o); scr_stream_dynopt_apply_enc(s, o.enc); } @@ -2739,6 +2925,7 @@ static void scr_stream_init_transformish_dyn(ScrStream *s, ScrDyn *opts, char ba transform, (ScrStreamChunkInv)tinv, flush, (ScrStreamPlainInv)linv, destroy, (ScrStreamErrInv)dinv); } + scr_stream_dynopt_apply_object(s, &o); scr_stream_dynopt_apply_enc(s, o.enc); } @@ -3299,6 +3486,12 @@ static void scr_stream_done_marker_free(void) { scr_stream_done_marker = NULL; } +/* readable.chunkDone: whether a dyn for-await step answered the end (the + * done marker; an object-mode stream can yield undefined). */ +bool scr_stream_chunk_done(const ScrDyn *v) { + return v != NULL && v == scr_stream_done_marker; +} + ScrDyn *scr_stream_from_done(void) { if (!scr_stream_done_marker) { scr_stream_done_marker = scr_dyn_new_obj(); @@ -4067,25 +4260,20 @@ static void scr_compose_read_inv(ScrClosure *cb, ScrStream *s, double size) { } /* tail.on('data'): d.push(chunk), pausing the tail when d is full. The - * chunk is the tail's Buffer, or its string when the tail is encoded. */ -static void scr_compose_data_l(ScrClosure *cb, ScrBytes *bytes, ScrStr *str) { + * chunk is the tail's Buffer, its string when the tail is encoded, or an + * object-mode value. */ +static void scr_compose_data_l(ScrClosure *cb, ScrBytes *bytes, ScrStr *str, ScrDyn *value) { ScrCompose *c = scr_box_get_ref(cb->caps[0]); ScrStream *d = c->d; if (d) { ScrStreamState *dst = d->st; bool more; if (dst->r.object_entries) { - int pushed = scr_stream_add_entry( - d, str ? (void *)scr_str_retain(str) : (void *)scr_bytes_retain(bytes), str != NULL); - if (pushed < 0) { - static const char m[] = "a composed stream whose tail mixes strings and Buffers is not supported yet"; - ScrStr *msg = scr_str_new(m, sizeof m - 1); - ScrError *e = scr_error_new(SCR_ERR_ERROR, msg); - scr_str_release(msg); - scr_stream_release(scr_stream_destroy(d, e)); - scr_error_release(e); - } - more = pushed > 0; + more = value ? scr_stream_push_object(d, value) > 0 + : scr_stream_add_entry(d, str ? (void *)scr_str_retain(str) : (void *)scr_bytes_retain(bytes), + str ? SCR_ENTRY_STR : SCR_ENTRY_BYTES) > 0; + } else if (value && !str && !bytes) { + more = scr_stream_push_dyn(d, value); } else if (str) { more = scr_stream_push_str(d, str); } else { @@ -4206,7 +4394,7 @@ ScrStream *scr_stream_compose(double n_d, ScrStream **streams) { c->tail, scr_compose_closure((void *)&scr_compose_tail_eos, c), &scr_compose_tail_eos)); } if (c->readable) { - scr_compose_on(c->tail, "data", &c->data_l, (void *)&scr_compose_data_l, c, scr_ee_inv_fixed2); + scr_compose_on(c->tail, "data", &c->data_l, (void *)&scr_compose_data_l, c, scr_ee_inv_fixed3); scr_compose_on(c->tail, "end", &c->end_l, (void *)&scr_compose_end_l, c, scr_ee_inv_fixed0); } static SCR_TL bool registered = false; @@ -4379,7 +4567,21 @@ static void scr_sc_settle_ok(ScrClosure *cb, int kind) { /* The 'data' accumulation (the emit ABI's two payload slots — exactly * one non-NULL). */ -static void scr_sc_data(ScrClosure *cb, void *b, void *str) { +/* An object-mode value other than a string or a Buffer reaching a + * runtime consumer that reads text or bytes (stream/consumers, readline). */ +static void scr_stream_value_consumer_fence(const char *consumer) { + char msg[160]; + int n = snprintf(msg, sizeof msg, + "%s over an object-mode stream value that is not a string or Buffer is not supported yet", + consumer); + scr_throw_error_msg_code(SCR_ERR_ERROR, msg, (size_t)n, "SC2020"); +} + +static void scr_sc_data(ScrClosure *cb, void *b, void *str, void *value) { + if (b == NULL && str == NULL && value != NULL) { + scr_stream_value_consumer_fence("stream/consumers"); + return; + } ScrArr *chunks = scr_box_get_ref(cb->caps[1]); /* +1 */ if (b != NULL) { scr_arr_push_ref(chunks, scr_bytes_retain((ScrBytes *)b)); @@ -4452,7 +4654,7 @@ static ScrPromise *scr_sc_consume(ScrStream *s, int kind) { ScrStr *dn = scr_str_new("data", 4); scr_emitter_release(scr_emitter_on((ScrEmitter *)s, dn, scr_sc_closure((void *)&scr_sc_data, p, chunks), - scr_ee_inv_fixed2, false, false)); + scr_ee_inv_fixed3, false, false)); scr_str_release(dn); /* resume() rather than the 'data' hook alone: Node's consumer pulls * through the iterator, which drains a PAUSED stream too. */ @@ -4643,7 +4845,11 @@ static SCR_TL ScrRlHook *scr_rl_hooks = NULL; static double scr_stream_rl_id(ScrClosure *cb) { return scr_box_get_f64(cb->caps[0]); } -static void scr_stream_rl_data(ScrClosure *cb, void *b, void *str) { +static void scr_stream_rl_data(ScrClosure *cb, void *b, void *str, void *value) { + if (b == NULL && str == NULL && value != NULL) { + scr_stream_value_consumer_fence("readline"); + return; + } if (b != NULL) scr_rl_input_bytes(scr_stream_rl_id(cb), (ScrBytes *)b); else if (str != NULL) scr_rl_input_str(scr_stream_rl_id(cb), (ScrStr *)str); } @@ -4797,7 +5003,7 @@ double scr_stream_rl_open(ScrStream *in, ScrStream *out, bool out_stdout, double h->next = scr_rl_hooks; scr_rl_hooks = h; scr_stream_rl_on(in, "error", h->error, scr_ee_inv_fixed1); - scr_stream_rl_on(in, "data", h->data, scr_ee_inv_fixed2); + scr_stream_rl_on(in, "data", h->data, scr_ee_inv_fixed3); scr_stream_rl_on(in, "end", h->end, scr_ee_inv_fixed0); scr_stream_rl_resume(in); return id; @@ -5323,6 +5529,85 @@ void scr_console_bind(ScrDyn *console, double which, ScrStream *stream) { inst->stream_drop = &scr_console_stream_drop; } +/* ── object mode ──────────────────────────────────────────────────────── */ + +/* The objectMode option (both sides) or a Duplex's readableObjectMode and + * writableObjectMode, applied right after construction: the readable + * side's entries are whole values (each counts 1, and the first push picks + * the representation), and the writable side queues values. The caller + * passes the object-mode high-water marks (16 by default). */ +void scr_stream_set_object_mode(ScrStream *s, bool readable, bool writable) { + ScrStreamState *st = s->st; + if (readable && st->has_r) { + st->r.object_entries = true; + st->r.object_mode_opt = true; + } + if (writable && st->has_w) st->w.object_mode = true; +} + +/* stream.objectMode: scr_stream_set_object_mode, answering the receiver + * (+1). */ +ScrStream *scr_stream_object_mode(ScrStream *s, bool readable, bool writable) { + scr_stream_set_object_mode(s, readable, writable); + return scr_stream_retain(s); +} + +/* Whether the write and transform steps receive dyn values (an + * object-mode writable side): the compiler's chunk thunks read the chunk + * by this. */ +bool scr_stream_writes_values(ScrStream *s) { + return s->st->has_w && s->st->w.object_mode; +} + +/* emit('data', value) with a checked-dynamic chunk: the 'data' slots by + * the value's tag (scr_stream_emit_data's ABI). Borrows its arguments. */ +bool scr_stream_emit_value(ScrStream *s, ScrStr *name, ScrDyn *v) { + ScrBytes *b = v->kind == SCR_DYN_BYTES ? v->v.bytes : NULL; + ScrStr *str = v->kind == SCR_DYN_STR ? v->v.str : NULL; + return scr_emitter_emit((ScrEmitter *)s, name, b, str, v); +} + +/* The chunk a compiled write or transform callback receives, by its + * declared type: as a Buffer (+1; on an object-mode side the value must + * be a Buffer, else a TypeError is thrown and NULL answered), as a dyn + * value (+1), and the encoding argument: 'buffer' on a byte-mode side, + * else what the write passed (undefined, null or a name). A parameter + * typed string receives the name, or "" for undefined and null; one typed + * otherwise receives the value (+1 each). */ +ScrBytes *scr_stream_chunk_bytes(ScrStream *s, ScrBytes *chunk) { + if (!scr_stream_writes_values(s)) return scr_bytes_retain(chunk); + ScrDyn *v = (ScrDyn *)chunk; + if (v->kind == SCR_DYN_BYTES) return scr_bytes_raw_view(v->v.bytes); + static const char msg[] = + "a stream callback declaring a Buffer chunk received an object-mode value that is not a Buffer"; + scr_throw_error_msg(SCR_ERR_TYPE, msg, sizeof msg - 1); + return NULL; +} + +ScrDyn *scr_stream_chunk_value(ScrStream *s, ScrBytes *chunk) { + if (scr_stream_writes_values(s)) return scr_dyn_retain((ScrDyn *)chunk); + return scr_dyn_new_buffer(chunk); +} + +ScrStr *scr_stream_chunk_encoding(ScrStream *s) { + if (!scr_stream_writes_values(s)) return scr_str_new("buffer", 6); + ScrDyn *enc = s->st->w.cur_enc; + if (enc && enc->kind == SCR_DYN_STR) return scr_str_retain(enc->v.str); + if (enc == NULL || enc->kind == SCR_DYN_NULL) return scr_str_new("", 0); + return scr_dyn_string_coerce_js(enc); +} + +ScrDyn *scr_stream_chunk_encoding_value(ScrStream *s) { + if (!scr_stream_writes_values(s)) { + ScrStr *name = scr_str_new("buffer", 6); + ScrDyn *d = scr_dyn_new_str(name); + scr_str_release(name); + return d; + } + ScrDyn *enc = s->st->w.cur_enc; + return enc ? scr_dyn_retain(enc) : scr_dyn_undefined(); +} + /* ── the readable surface ─────────────────────────────────────────────── */ bool scr_stream_push(ScrStream *s, ScrBytes *chunk) { @@ -5330,6 +5615,9 @@ bool scr_stream_push(ScrStream *s, ScrBytes *chunk) { } bool scr_stream_push_str(ScrStream *s, ScrStr *str) { + /* object mode: the string is one whole entry, not converted */ + if (s->st->has_r && s->st->r.object_entries) + return scr_stream_add_entry(s, scr_str_retain(str), SCR_ENTRY_STR) > 0; ScrStr *enc = s->st->has_r ? s->st->r.push_enc : NULL; ScrBytes *b; if (enc != NULL) { @@ -5374,11 +5662,11 @@ bool scr_stream_push_null(ScrStream *s) { if (!st->r.ended) { /* onEofChunk flushes the decoder's held partial first (utf8's * replacement chars et al — Node's decoder.end() push). */ - if (st->r.encoded) { + if (st->r.encoded && !st->r.dyn_entries) { ScrStr *tail = scr_strdec_end(st->r.enc, st->r.dec_pending); st->r.dec_pending = 0; if (scr_str_utf16_len(tail) > 0) { - scr_stream_rbuf_push(st, tail, true, false); + scr_stream_rbuf_push(st, tail, SCR_ENTRY_STR, false); if (st->r.need_readable) scr_stream_emit_readable_nt(s); } else { scr_str_release(tail); @@ -5408,7 +5696,7 @@ void scr_stream_unshift(ScrStream *s, ScrBytes *chunk) { if (st->r.head_off > 0) { /* materialize the part-read head so the front slot is whole */ void *rest = scr_stream_rbuf_take(st, scr_stream_entry_len(st, st->r.buf[0]) - st->r.head_off); - scr_stream_rbuf_push(st, rest, st->r.encoded, true); + scr_stream_rbuf_push(st, rest, scr_stream_rkind(st), true); } scr_stream_add_chunk(s, chunk, true); } @@ -5422,6 +5710,46 @@ void scr_stream_unshift_str(ScrStream *s, ScrStr *str) { scr_bytes_release(b); } +/* unshift(value): null is the end of the stream (Node's onEofChunk); an + * object-mode stream takes any other value as one entry at the front; a + * byte-mode stream takes Buffers and strings, ignores undefined and + * reports another value as push does. Borrows d. */ +void scr_stream_unshift_dyn(ScrStream *s, const ScrDyn *d) { + ScrStreamState *st = s->st; + if (d->kind == SCR_DYN_NULL) { + scr_stream_push_null(s); + return; + } + if (st->has_r && st->r.object_entries) { + void *entry; + ScrEntryKind kind; + if (d->kind == SCR_DYN_STR) { + entry = scr_str_retain(d->v.str); + kind = SCR_ENTRY_STR; + } else if (d->kind == SCR_DYN_BYTES) { + entry = scr_bytes_raw_view(d->v.bytes); + kind = SCR_ENTRY_BYTES; + } else { + entry = scr_dyn_retain((ScrDyn *)d); + kind = SCR_ENTRY_DYN; + } + entry = scr_stream_entry_convert(st, entry, &kind); + scr_stream_rbuf_push(st, entry, kind, true); + if (st->r.need_readable) scr_stream_emit_readable_nt(s); + scr_stream_settle_next(s); + return; + } + if (d->kind == SCR_DYN_BYTES) { + ScrBytes *b = scr_bytes_raw_view(d->v.bytes); + scr_stream_unshift(s, b); + scr_bytes_release(b); + } else if (d->kind == SCR_DYN_STR) { + scr_stream_unshift_str(s, d->v.str); + } else { + scr_stream_push_dyn(s, d); + } +} + static void scr_stream_listener_error(ScrClosure *adapter, ScrError *error) { ScrDyn *fn = scr_dyn_listener_fn(adapter); ScrDyn *arg = scr_dyn_from_error(error); @@ -5431,9 +5759,9 @@ static void scr_stream_listener_error(ScrClosure *adapter, ScrError *error) { scr_dyn_release(fn); } -static void scr_stream_listener_data(ScrClosure *adapter, ScrBytes *bytes, ScrStr *string) { +static void scr_stream_listener_data(ScrClosure *adapter, ScrBytes *bytes, ScrStr *string, ScrDyn *value) { ScrDyn *fn = scr_dyn_listener_fn(adapter); - ScrDyn *arg = string ? scr_dyn_new_str(string) : scr_dyn_new_bytes(bytes); + ScrDyn *arg = value ? scr_dyn_retain(value) : string ? scr_dyn_new_str(string) : scr_dyn_new_bytes(bytes); ScrDyn *answer = scr_dyn_call(fn, &arg, 1, "listener"); scr_dyn_release(answer); scr_dyn_release(arg); @@ -5444,7 +5772,7 @@ ScrStream *scr_stream_on_dyn(ScrStream *s, ScrStr *name, ScrDyn *cb, bool once, if (name->len == 4 && !memcmp(name->data, "data", 4)) { return (ScrStream *)scr_emitter_on_dyn((ScrEmitter *)s, name, cb, scr_dyn_listener_closure_fn(cb, (void *)scr_stream_listener_data), - scr_ee_inv_fixed2, once, prepend); + scr_ee_inv_fixed3, once, prepend); } bool error = name->len == 5 && memcmp(name->data, "error", 5) == 0; bool empty = (name->len == 8 && memcmp(name->data, "readable", 8) == 0) || @@ -5468,13 +5796,15 @@ ScrStream *scr_stream_on_dyn(ScrStream *s, ScrStr *name, ScrDyn *cb, bool once, ScrDyn *scr_stream_read_dyn(ScrStream *s, ScrDyn *size) { double n = size && size->kind != SCR_DYN_UNDEF ? scr_dyn_number_coerce(size) : -1; if (scr_exc_pending()) return scr_dyn_undefined(); - bool is_str = false; - void *chunk = s->st->has_r ? scr_stream_read_n_kind(s, n, &is_str) : NULL; + ScrEntryKind kind = SCR_ENTRY_BYTES; + void *chunk = s->st->has_r ? scr_stream_read_n_kind(s, n, &kind) : NULL; if (!chunk) return scr_dyn_new_null(); - ScrDyn *result = is_str ? scr_dyn_new_str(chunk) : scr_dyn_new_buffer(chunk); - if (is_str) scr_str_release(chunk); - else scr_bytes_release(chunk); - return result; + if (kind == SCR_ENTRY_BYTES) { + ScrDyn *result = scr_dyn_new_buffer(chunk); + scr_bytes_release(chunk); + return result; + } + return scr_stream_entry_box(chunk, kind); } /* read() answers STRINGS once encoded: the static result type here is @@ -5491,13 +5821,28 @@ ScrBytes *scr_stream_read(ScrStream *s, double size) { /* a destroyed readable still DRAINS its buffer (Node: destroy leaves * buffered chunks readable; only _read refills are blocked) */ if (!s->st->has_r) return NULL; - if (s->st->r.encoded) { + if (s->st->r.encoded && !s->st->r.dyn_entries) { scr_stream_read_str_fence(); return NULL; } - bool is_str; - void *chunk = scr_stream_read_n_kind(s, size, &is_str); - if (chunk && is_str) { + ScrEntryKind kind; + void *chunk = scr_stream_read_n_kind(s, size, &kind); + if (chunk && kind == SCR_ENTRY_DYN) { + /* an object-mode value: a Buffer is the result, anything else is not */ + ScrDyn *d = chunk; + if (d->kind == SCR_DYN_BYTES) { + ScrBytes *b = scr_bytes_raw_view(d->v.bytes); + scr_dyn_release(d); + return b; + } + scr_dyn_release(d); + static const char msg[] = + "read() of an object-mode stream value that is not a Buffer is not supported yet in typed " + "code (consume 'data' events or for await)"; + scr_throw_error_msg(SCR_ERR_ERROR, msg, sizeof msg - 1); + return NULL; + } + if (chunk && kind == SCR_ENTRY_STR) { /* the read itself made the stream hold strings (a lazy Readable.from * pull's first string, or setEncoding() inside _read): the same * fence, never a string in the Buffer result */ @@ -5515,11 +5860,19 @@ ScrBytes *scr_stream_read(ScrStream *s, double size) { ScrStream *scr_stream_set_encoding(ScrStream *s, ScrStr *enc) { ScrStreamState *st = s->st; if (!st->has_r) return scr_stream_retain(s); + if (st->r.dyn_entries) { + /* an object-mode buffer of values: Buffers pushed later decode */ + if (st->r.enc) scr_str_release(st->r.enc); + st->r.enc = scr_str_retain(enc); + st->r.dec_pending = 0; + st->r.decoding = true; + return scr_stream_retain(s); + } if (st->r.encoded) { /* switching encodings mid-stream: fold the old decoder's pending * tail into the buffer first (rare; Node re-creates the decoder) */ ScrStr *tail = scr_strdec_end(st->r.enc, st->r.dec_pending); - if (scr_str_utf16_len(tail) > 0) scr_stream_rbuf_push(st, tail, true, false); + if (scr_str_utf16_len(tail) > 0) scr_stream_rbuf_push(st, tail, SCR_ENTRY_STR, false); else scr_str_release(tail); scr_str_release(st->r.enc); st->r.enc = scr_str_retain(enc); @@ -5575,7 +5928,7 @@ ScrStream *scr_stream_set_encoding(ScrStream *s, ScrStr *enc) { st->r.decoding = true; st->r.object_kind_set = true; if (content != NULL) { - if (scr_str_utf16_len(content) > 0) scr_stream_rbuf_push(st, content, true, false); + if (scr_str_utf16_len(content) > 0) scr_stream_rbuf_push(st, content, SCR_ENTRY_STR, false); else scr_str_release(content); } return scr_stream_retain(s); @@ -5647,7 +6000,8 @@ ScrStream *scr_stream_unpipe(ScrStream *src, ScrStream *dst) { /* ── the writable surface ─────────────────────────────────────────────── */ -static bool scr_stream_write_chunk(ScrStream *s, ScrBytes *chunk /*borrowed*/, ScrClosure *cb /*moves*/) { +static bool scr_stream_write_chunk_enc(ScrStream *s, ScrBytes *chunk /*borrowed*/, + ScrClosure *cb /*moves*/, ScrDyn *enc /*borrowed*/) { ScrStreamState *st = s->st; if (!st->has_w || st->destroyed || st->w.ending) { ScrError *e = st->has_w && !st->destroyed @@ -5658,12 +6012,12 @@ static bool scr_stream_write_chunk(ScrStream *s, ScrBytes *chunk /*borrowed*/, S scr_error_release(e); return false; } - size_t len = chunk->len; - st->w.length += len; + st->w.length += scr_stream_wchunk_len(st, chunk); + if (enc) enc = scr_dyn_retain(enc); if (st->w.writing || st->w.corked > 0 || st->constructing) { - scr_stream_wq_push(st, scr_bytes_retain(chunk), cb); + scr_stream_wq_push(st, scr_stream_wchunk_retain(st, chunk), cb, enc); } else { - scr_stream_do_write(s, scr_bytes_retain(chunk), cb); + scr_stream_do_write(s, scr_stream_wchunk_retain(st, chunk), cb, enc); } /* Node computes the answer AFTER the (possibly synchronous) write: * a sync completion has already drained its bytes from length. */ @@ -5672,7 +6026,28 @@ static bool scr_stream_write_chunk(ScrStream *s, ScrBytes *chunk /*borrowed*/, S return ret; } +static bool scr_stream_write_chunk(ScrStream *s, ScrBytes *chunk /*borrowed*/, ScrClosure *cb /*moves*/) { + return scr_stream_write_chunk_enc(s, chunk, cb, NULL); +} + +/* The encoding argument of a compiled write(chunk[, cb]) on an object-mode + * side: undefined, or null when the callback took its place (Node's + * write and end shift it there). */ +static ScrDyn *scr_stream_cb_enc(ScrClosure *cb) { return cb ? scr_dyn_new_null() : NULL; } + +/* write(value) on an object-mode writable side: the value is the chunk. + * Borrows v. */ +static bool scr_stream_write_value(ScrStream *s, ScrDyn *v, ScrClosure *cb) { + return scr_stream_write_chunk_enc(s, (ScrBytes *)v, cb, scr_stream_cb_enc(cb)); +} + bool scr_stream_write(ScrStream *s, ScrBytes *chunk, ScrClosure *cb) { + if (s->st->has_w && s->st->w.object_mode) { + ScrDyn *v = chunk->is_buffer ? scr_dyn_new_buffer(chunk) : scr_dyn_new_bytes(chunk); + bool ret = scr_stream_write_value(s, v, cb); + scr_dyn_release(v); + return ret; + } return scr_stream_write_chunk(s, chunk, cb); } @@ -5686,6 +6061,13 @@ bool scr_stream_write_null(ScrStream *s) { } bool scr_stream_write_str(ScrStream *s, ScrStr *str, ScrClosure *cb) { + if (s->st->has_w && s->st->w.object_mode) { + /* object mode: the string itself, not converted */ + ScrDyn *v = scr_dyn_new_str(str); + bool ret = scr_stream_write_value(s, v, cb); + scr_dyn_release(v); + return ret; + } ScrBytes *b = scr_bytes_new(SCR_BYTES_U8, (double)str->len); memcpy(b->data, str->data, str->len); if (!str->ascii) scr_wtf8_to_utf8((char *)b->data, str->len); @@ -5695,10 +6077,65 @@ bool scr_stream_write_str(ScrStream *s, ScrStr *str, ScrClosure *cb) { return ret; } +/* write(chunk, encoding, cb) with the encoding argument as passed (NULL + * or undefined when absent): an object-mode side hands it to _write + * unchanged; a byte-mode side encodes a string chunk with it. Borrows + * chunk and enc. */ +bool scr_stream_write_enc(ScrStream *s, const ScrDyn *chunk, ScrDyn *enc, ScrClosure *cb) { + if (enc && enc->kind == SCR_DYN_UNDEF) enc = NULL; + ScrStreamState *st = s->st; + if (chunk->kind != SCR_DYN_NULL && st->has_w && st->w.object_mode) + return scr_stream_write_chunk_enc(s, (ScrBytes *)chunk, cb, enc); + /* Node's _write: an encoding other than 'buffer' must be a known one + * (ERR_UNKNOWN_ENCODING, thrown), and a string chunk is encoded with + * it; an empty or nullish encoding is the default */ + ScrStr *name = NULL; + if (enc && enc->kind != SCR_DYN_NULL && !(enc->kind == SCR_DYN_STR && enc->v.str->len == 0)) + name = scr_dyn_string_coerce_js(enc); + if (name && !(name->len == 6 && memcmp(name->data, "buffer", 6) == 0)) { + ScrStr *canonical = scr_bytes_normalize_encoding(name); + scr_str_release(name); + if (canonical == NULL) { + if (cb) scr_closure_release(cb); + return false; + } + if (chunk->kind != SCR_DYN_STR) { + scr_str_release(canonical); + return scr_stream_write_dyn(s, chunk, cb); + } + ScrBytes *b = scr_bytes_from_str(chunk->v.str, canonical); + scr_str_release(canonical); + scr_stream_buffer(b); + bool ret = scr_stream_write_chunk(s, b, cb); + scr_bytes_release(b); + return ret; + } + if (name && chunk->kind == SCR_DYN_STR) { + /* Buffer.from(string, 'buffer') */ + scr_str_release(name); + if (cb) scr_closure_release(cb); + static const char msg[] = "Unknown encoding: buffer"; + scr_throw_error_msg_code(SCR_ERR_TYPE, msg, sizeof msg - 1, "ERR_UNKNOWN_ENCODING"); + return false; + } + if (name) scr_str_release(name); + return scr_stream_write_dyn(s, chunk, cb); +} + ScrStream *scr_stream_end(ScrStream *s, ScrBytes *chunk_b, ScrStr *chunk_s, ScrClosure *cb) { ScrStreamState *st = s->st; - if (chunk_b) scr_stream_write(s, chunk_b, NULL); - else if (chunk_s) scr_stream_write_str(s, chunk_s, NULL); + if ((chunk_b || chunk_s) && st->has_w && st->w.object_mode) { + /* end(chunk[, cb]) writes with the encoding Node's end leaves: + * undefined, or null when the callback took its place */ + ScrDyn *v = chunk_s ? scr_dyn_new_str(chunk_s) + : chunk_b->is_buffer ? scr_dyn_new_buffer(chunk_b) : scr_dyn_new_bytes(chunk_b); + scr_stream_write_chunk_enc(s, (ScrBytes *)v, NULL, scr_stream_cb_enc(cb)); + scr_dyn_release(v); + } else if (chunk_b) { + scr_stream_write(s, chunk_b, NULL); + } else if (chunk_s) { + scr_stream_write_str(s, chunk_s, NULL); + } if (!st->has_w || st->destroyed) { if (cb) scr_closure_release(cb); return scr_stream_retain(s); @@ -5778,7 +6215,12 @@ void scr_stream_write_done(ScrStream *s, ScrError *err /*moves*/) { return; } if (was_sync) { + bool hold = ucb != NULL || (st->w.need_drain && st->w.length == 0) || st->destroyed; scr_st_tick(s, SCR_ST_AFTER_WRITE, NULL, ucb); + if (hold) { + scr_st_tail->hold = true; + st->w.after_holds++; + } } else { scr_stream_after_write(s, ucb); } @@ -5837,6 +6279,8 @@ void scr_stream_transform_done(ScrStream *s, ScrError *err /*moves*/, ScrBytes * if (!err) { if (data) { scr_stream_add_chunk(s, data, false); + } else if (data_str && s->st->r.object_entries) { + scr_stream_push_str(s, data_str); /* object mode: the string itself */ } else if (data_str) { ScrBytes *b = scr_bytes_new(SCR_BYTES_U8, (double)data_str->len); memcpy(b->data, data_str->data, data_str->len); @@ -5870,6 +6314,9 @@ void scr_stream_flush_done(ScrStream *s, ScrError *err /*moves*/, ScrBytes *data if (data) { scr_stream_add_chunk(s, data, false); scr_bytes_release(data); + } else if (data_str && st->r.object_entries) { + scr_stream_push_str(s, data_str); /* object mode: the string itself */ + scr_str_release(data_str); } else if (data_str) { ScrBytes *b = scr_bytes_new(SCR_BYTES_U8, (double)data_str->len); memcpy(b->data, data_str->data, data_str->len); @@ -5885,6 +6332,38 @@ void scr_stream_flush_done(ScrStream *s, ScrError *err /*moves*/, ScrBytes *data scr_stream_finish_maybe(s); } +/* The transform and flush completions with a checked-dynamic value (an + * object-mode Transform's data, or an untyped callback's): null and + * undefined push nothing (Transform's `val != null`), and any other value + * is pushed as push(value) pushes it. v borrowed (NULL: absent). */ +static bool scr_stream_done_pushes(const ScrDyn *v) { + return v && v->kind != SCR_DYN_NULL && v->kind != SCR_DYN_UNDEF; +} + +void scr_stream_transform_done_value(ScrStream *s, ScrError *err /*moves*/, ScrDyn *v) { + if (!err && scr_stream_done_pushes(v)) scr_stream_push_dyn(s, v); + if (scr_exc_pending()) { + if (err) scr_error_release(err); + return; + } + if (err) scr_stream_write_done(s, err); + else scr_stream_transform_callback(s); +} + +void scr_stream_flush_done_value(ScrStream *s, ScrError *err /*moves*/, ScrDyn *v) { + s->st->flush_pending = false; + if (err) { + scr_stream_error_or_destroy(s, err); + scr_error_release(err); + return; + } + if (scr_stream_done_pushes(v)) scr_stream_push_dyn(s, v); + if (scr_exc_pending()) return; + scr_stream_push_null(s); + if (scr_exc_pending()) return; + scr_stream_finish_maybe(s); +} + /* ── destroy ──────────────────────────────────────────────────────────── */ /* Node's _destroy step: the destroy hook, or 'error'/'close' on ticks. */ @@ -5970,6 +6449,7 @@ double scr_stream_prop(ScrStream *s, const char *name) { if (strcmp(name, "readableLength") == 0) return (double)st->r.length; if (strcmp(name, "readableHighWaterMark") == 0) return (double)st->r.hwm; if (strcmp(name, "readableObjectMode") == 0) return st->r.object_entries; + if (strcmp(name, "writableObjectMode") == 0) return st->w.object_mode; if (strcmp(name, "writable") == 0) { return st->has_w && !st->destroyed && !st->w.ending && !st->errored; } @@ -6011,7 +6491,7 @@ double scr_stream_prop(ScrStream *s, const char *name) { if (strcmp(p, "destroyed") == 0) return st->destroyed; if (strcmp(p, "errorEmitted") == 0) return st->error_emitted; if (strcmp(p, "needDrain") == 0) return st->w.need_drain; - if (strcmp(p, "objectMode") == 0) return 0; + if (strcmp(p, "objectMode") == 0) return st->w.object_mode; if (strcmp(p, "constructed") == 0) return 1; if (strcmp(p, "closed") == 0) return st->close_emitted; if (strcmp(p, "length") == 0) return (double)st->w.length; @@ -6209,6 +6689,7 @@ static void scr_stream_run_tick(ScrStreamTick *t) { break; case SCR_ST_AFTER_WRITE: { st->w.after_scheduled = false; + if (t->hold) st->w.after_holds--; ScrClosure *cb = t->cb; t->cb = NULL; if (!st->destroyed) { @@ -6272,6 +6753,13 @@ static void scr_stream_run_tick(ScrStreamTick *t) { if (!st->close_emitted) { st->close_emitted = true; if (st->emit_close) scr_stream_emit0(s, "close"); + if (st->r.next_eof_close && !scr_exc_pending()) { + /* the iterator's eos 'close' listener completes the loop */ + st->r.next_eof_close = false; + ScrPromise *w = st->r.next_waiter; + st->r.next_waiter = NULL; + if (w) scr_stream_next_fulfill(st, w, NULL, SCR_ENTRY_BYTES); + } /* eos ordering: the finished()/pipeline watchers fire right after * 'close' (Node's willEmitClose stance). */ scr_stream_notify_finished(s); @@ -6318,9 +6806,9 @@ static void scr_stream_run_tick(ScrStreamTick *t) { } case SCR_ST_READ0: { if (st->has_r) { - bool is_str; - void *chunk = scr_stream_read_n_kind(s, 0, &is_str); - if (chunk) scr_stream_entry_release_kind(chunk, is_str); + ScrEntryKind kind; + void *chunk = scr_stream_read_n_kind(s, 0, &kind); + if (chunk) scr_stream_entry_release_kind(chunk, kind); } break; } @@ -6347,10 +6835,13 @@ static void scr_stream_run_tick(ScrStreamTick *t) { break; } case SCR_ST_NEXT_EOF: { - if (st->r.next_waiter && st->r.length == 0 && (st->r.ended || st->destroyed)) { + if (st->r.next_waiter && st->r.length == 0 && st->r.ended && st->r.next_close_wait && + !st->close_emitted) { + st->r.next_eof_close = true; + } else if (st->r.next_waiter && st->r.length == 0 && (st->r.ended || st->destroyed)) { ScrPromise *w = st->r.next_waiter; st->r.next_waiter = NULL; - scr_stream_next_fulfill(st, w, NULL, false); + scr_stream_next_fulfill(st, w, NULL, SCR_ENTRY_BYTES); } else if (st->r.next_waiter) { scr_stream_settle_next(s); /* content raced in: deliver it */ } @@ -6475,16 +6966,6 @@ static const ScrDynHandleTransform *scr_handle_step_ops(ScrClosure *cb) { return scr_handle_step_handle_ops(cb)->transform; } -/* The pending exception as a stream error (+1). */ -static ScrError *scr_handle_step_caught(void) { - ScrCaught *caught = scr_exc_take(); - ScrDyn *value = scr_caught_to_dyn(caught); - scr_caught_release(caught); - ScrError *err = value ? scr_errdyn_err_of(value) : NULL; - if (value) scr_dyn_release(value); - return err ? err : scr_stream_mkerr("ERR_INTERNAL_ASSERTION", "a Transform handle threw a value that is not an Error"); -} - static void scr_handle_step_transform(ScrClosure *cb, ScrStream *s, ScrBytes *chunk) { /* A throwing update() leaves the exception pending: it throws out of * the write, as Node's _transform does. */ @@ -6494,7 +6975,7 @@ static void scr_handle_step_transform(ScrClosure *cb, ScrStream *s, ScrBytes *ch static void scr_handle_step_flush(ScrClosure *cb, ScrStream *s) { ScrBytes *out = scr_handle_step_ops(cb)->final(scr_handle_step_handle(cb)); - scr_stream_flush_done(s, out ? NULL : scr_handle_step_caught(), out, NULL); + scr_stream_flush_done(s, out ? NULL : scr_stream_take_error(), out, NULL); } static void scr_handle_step_destroy(ScrClosure *cb, ScrStream *s, ScrError *err) { diff --git a/packages/runtime/src/scr_stream.h b/packages/runtime/src/scr_stream.h index 1e5b789e7..8b8a72406 100644 --- a/packages/runtime/src/scr_stream.h +++ b/packages/runtime/src/scr_stream.h @@ -272,6 +272,7 @@ ScrStream *scr_stream_set_push_encoding(ScrStream *s, ScrStr *enc); bool scr_stream_push_null(ScrStream *s); void scr_stream_unshift(ScrStream *s, ScrBytes *chunk); void scr_stream_unshift_str(ScrStream *s, ScrStr *str); +void scr_stream_unshift_dyn(ScrStream *s, const ScrDyn *d); ScrBytes *scr_stream_read(ScrStream *s, double size); ScrStream *scr_stream_on_dyn(ScrStream *s, ScrStr *name, ScrDyn *cb, bool once, bool prepend); ScrDyn *scr_stream_read_dyn(ScrStream *s, ScrDyn *size); /* +1 or NULL; size < 0 = all/first; throws once encoded (the static type is Buffer|null) */ @@ -291,6 +292,8 @@ typedef struct ScrPromise ScrPromise; /* full declaration below (C11 repeat) */ * each chunk before asking again). */ bool scr_stream_push_dyn(ScrStream *s, const ScrDyn *d); /* borrows d; tag dispatch */ bool scr_stream_write_dyn(ScrStream *s, const ScrDyn *d, ScrClosure *cb); /* cb moves */ +/* write(chunk, encoding, cb): enc borrowed, NULL or undefined when absent */ +bool scr_stream_write_enc(ScrStream *s, const ScrDyn *chunk, ScrDyn *enc, ScrClosure *cb); ScrPromise *scr_stream_next_chunk(ScrStream *s); ScrPromise *scr_stream_next_chunk_dyn(ScrStream *s); /* node:stream/promises — the promise forms over the finished/pipeline @@ -475,6 +478,28 @@ void scr_stream_final_done(ScrStream *s, ScrError *err); void scr_stream_destroy_done(ScrStream *s, ScrError *err); void scr_stream_transform_done(ScrStream *s, ScrError *err, ScrBytes *data, ScrStr *data_str); void scr_stream_flush_done(ScrStream *s, ScrError *err, ScrBytes *data, ScrStr *data_str); +/* The same completions with a checked-dynamic data value (borrowed; NULL, + * null and undefined push nothing): an object-mode Transform's data, or an + * untyped callback's. err moves. */ +/* objectMode: scr_stream_set_object_mode applies the option's sides right + * after construction; scr_stream_writes_values answers whether the write + * and transform steps receive dyn values instead of Buffers. */ +void scr_stream_set_object_mode(ScrStream *s, bool readable, bool writable); +ScrStream *scr_stream_object_mode(ScrStream *s, bool readable, bool writable); +bool scr_stream_writes_values(ScrStream *s); +/* A compiled write or transform callback's chunk by its declared type: a + * Buffer (+1, or NULL with a TypeError for another object-mode value), a + * dyn value (+1), and the encoding argument (+1). */ +ScrBytes *scr_stream_chunk_bytes(ScrStream *s, ScrBytes *chunk); +struct ScrDyn *scr_stream_chunk_value(ScrStream *s, ScrBytes *chunk); +ScrStr *scr_stream_chunk_encoding(ScrStream *s); +ScrDyn *scr_stream_chunk_encoding_value(ScrStream *s); +/* emit('data', value) with a checked-dynamic chunk (borrowed). */ +bool scr_stream_emit_value(ScrStream *s, ScrStr *name, struct ScrDyn *v); +/* Whether a dyn for-await step (readable.nextChunkDyn) answered the end. */ +bool scr_stream_chunk_done(const struct ScrDyn *v); +void scr_stream_transform_done_value(ScrStream *s, ScrError *err, struct ScrDyn *v); +void scr_stream_flush_done_value(ScrStream *s, ScrError *err, struct ScrDyn *v); /* Runtime-backed streams (the fs streams in scr_fs_stream.c). * - construct: Node's _construct. The hook runs on a tick after diff --git a/packages/runtime/src/scr_stream_ops.c b/packages/runtime/src/scr_stream_ops.c index d32dd5d67..8fd220168 100644 --- a/packages/runtime/src/scr_stream_ops.c +++ b/packages/runtime/src/scr_stream_ops.c @@ -305,7 +305,7 @@ static ScrPromise *src_next(OpSrc *src) { } static bool src_done(const OpSrc *src, const ScrDyn *v) { - return src->s ? v->kind == SCR_DYN_UNDEF : v == op_k_done; + return src->s ? scr_stream_chunk_done(v) : v == op_k_done; } /* The Readable iterator's return(): the iterator generator resumes at its @@ -1492,16 +1492,6 @@ static void op_from_step_k(void *self, ScrDyn *v) { } int pushed = scr_stream_push_object(out, v); scr_dyn_release(v); - if (pushed == -2) { - op_from_destroy_with(out, op_unsupported( - "a stream operator output that mixes strings and Buffers")); - return; - } - if (pushed < 0) { - op_from_destroy_with(out, op_unsupported( - "a stream operator value that is not a string or Buffer (object-mode streams of other values)")); - return; - } if (pushed) { from_next(f, out); return; diff --git a/tests/corpus/7240-objectmode-streams.ts b/tests/corpus/7240-objectmode-streams.ts new file mode 100644 index 000000000..9316ff480 --- /dev/null +++ b/tests/corpus/7240-objectmode-streams.ts @@ -0,0 +1,130 @@ +// Typed object-mode streams: records through Readable.from, Transform +// and Writable in pipeline(), typed 'data' listeners, a Transform with +// readableObjectMode parsing bytes into records, an object-mode Duplex, +// a PassThrough's object-counted high-water mark, and Readable.from over +// a Map, a Set of records and an array mixing strings and Buffers. +import { Duplex, PassThrough, Readable, Transform, Writable } from "node:stream"; +import { pipeline } from "node:stream/promises"; + +interface Row { + id: number; + name: string; +} + +interface Total { + count: number; + ids: number[]; +} + +async function records(): Promise { + const source = Readable.from([ + { id: 1, name: "ada" }, + { id: 2, name: "bo" }, + { id: 3, name: "cy" }, + ]); + const shout = new Transform({ + objectMode: true, + transform(row: Row, _enc: string, cb: (err: Error | null, out?: Row) => void) { + if (row.id === 2) { + cb(null); + return; + } + cb(null, { id: row.id * 10, name: row.name.toUpperCase() }); + }, + }); + const seen: Row[] = []; + await pipeline( + source, + shout, + new Writable({ + objectMode: true, + write(row: Row, enc: string | null | undefined, cb: () => void) { + seen.push(row); + console.log("write", row.id, enc); + cb(); + }, + }), + ); + console.log(seen.map((r) => `${r.id}:${r.name}`).join(" ")); +} + +function counters(): void { + const counter = new Readable({ objectMode: true, read() {} }); + console.log("hwm", counter.readableHighWaterMark, counter.readableObjectMode); + counter.on("data", (n: number) => console.log("data", n + 1)); + counter.on("end", () => console.log("counter end")); + counter.push(1); + counter.push(0); + counter.push(41); + counter.push(null); +} + +function sided(): void { + // bytes in, records out + const parse = new Transform({ + readableObjectMode: true, + transform(chunk: Buffer, _enc: string, cb: (err: Error | null, out?: Total) => void) { + const ids = chunk.toString().split(",").map((s) => Number(s)); + cb(null, { count: ids.length, ids }); + }, + }); + console.log( + "sided", + parse.readableObjectMode, + parse.writableObjectMode, + parse.readableHighWaterMark, + parse.writableHighWaterMark, + ); + parse.on("data", (t: Total) => console.log("total", t.count, t.ids.join("+"))); + parse.write("1,2,3"); + parse.end("4"); +} + +function duplex(): void { + const echo = new Duplex({ + objectMode: true, + read() {}, + write(chunk: Row, _enc: string, cb: () => void) { + this.push({ id: chunk.id + 1, name: chunk.name }); + cb(); + }, + final(cb: () => void) { + this.push(null); + cb(); + }, + }); + echo.on("data", (r: Row) => console.log("echo", r.id, r.name)); + echo.write({ id: 1, name: "x" }); + echo.end({ id: 5, name: "y" }); +} + +function passthrough(): void { + const pt = new PassThrough({ objectMode: true, highWaterMark: 2 }); + const ok1 = pt.write({ id: 1, name: "a" }); + const ok2 = pt.write({ id: 2, name: "b" }); + console.log("backpressure", ok1, ok2, pt.writableLength, pt.readableLength); + pt.on("data", (r: Row) => console.log("pt", r.name)); + pt.end(); +} + +async function collections(): Promise { + const prices = new Map([ + ["tea", 3], + ["cake", 5], + ]); + for await (const entry of Readable.from(prices)) console.log("entry", JSON.stringify(entry)); + const mixed: (string | Buffer)[] = ["text", Buffer.from("bytes")]; + for await (const chunk of Readable.from(mixed)) console.log("mixed", typeof chunk, String(chunk)); + const tags = new Set([{ tag: "a" }, { tag: "b" }]); + for await (const t of Readable.from(tags)) console.log("set", JSON.stringify(t)); +} + +async function main(): Promise { + await records(); + await collections(); + counters(); + sided(); + duplex(); + passthrough(); +} +main(); diff --git a/tests/corpus/7241-objectmode-streams.mjs b/tests/corpus/7241-objectmode-streams.mjs new file mode 100644 index 000000000..334273c00 --- /dev/null +++ b/tests/corpus/7241-objectmode-streams.mjs @@ -0,0 +1,148 @@ +// Object-mode streams in JavaScript: any value as a chunk through +// Readable, Writable, Duplex, Transform and PassThrough, pipe() and +// pipeline() between them, unshift(), the per-side modes and +// their high-water marks, and the encoding argument write() and end() +// hand to _write and _transform. +import { Duplex, PassThrough, Readable, Transform, Writable } from "node:stream"; +import { pipeline } from "node:stream/promises"; + +const show = (v) => (typeof v === "object" ? JSON.stringify(v) : `${typeof v}:${String(v)}`); + +async function values() { + const seen = []; + await pipeline( + Readable.from([1, "two", { three: 3 }, [4], true, 0, ""]), + new Transform({ + objectMode: true, + transform(chunk, enc, cb) { + cb(null, { wrapped: chunk }); + }, + }), + new Writable({ + objectMode: true, + write(chunk, enc, cb) { + seen.push(show(chunk.wrapped)); + cb(); + }, + }), + ); + console.log("values:", seen.join(" ")); +} + +function lines() { + let rest = ""; + const split = new Transform({ + readableObjectMode: true, + transform(chunk, enc, cb) { + const parts = (rest + chunk.toString()).split("\n"); + rest = parts.pop(); + for (const p of parts) this.push({ line: p, length: p.length }); + cb(); + }, + flush(cb) { + if (rest) this.push({ line: rest, length: rest.length }); + cb(); + }, + }); + console.log("split modes:", split.readableObjectMode, split.writableObjectMode); + split.on("data", (row) => console.log("line:", row.line, row.length)); + split.on("end", () => console.log("split end")); + split.write("alpha\nbe"); + split.write("ta\ngamma"); + split.end(); +} + +function encodings() { + const w = new Writable({ + objectMode: true, + write(chunk, enc, cb) { + console.log("write enc:", show(chunk), enc); + cb(); + }, + }); + w.write(1, () => console.log("write cb")); + w.write(2, null); + w.write(3, "utf8"); + w.write("four", "latin1"); + w.write(5, "anything"); + w.end(6, () => console.log("end cb")); + const t = new Transform({ + objectMode: true, + transform(chunk, enc, cb) { + console.log("transform enc:", show(chunk), enc); + cb(); + }, + }); + t.write(7); + t.end(8, "hex"); + const bytes = new Writable({ + write(chunk, enc, cb) { + console.log("byte write:", chunk.toString("hex"), enc); + cb(); + }, + }); + bytes.write("hi", "latin1"); + bytes.write("6869", "hex"); + try { + bytes.write("x", "bogus"); + } catch (e) { + console.log("byte encoding:", e.code); + } + bytes.end(); +} + +function unshiftFront() { + const r = new Readable({ objectMode: true, read() {} }); + r.push({ id: 1 }); + r.push({ id: 2 }); + r.push(null); + console.log("length:", r.readableLength, "hwm:", r.readableHighWaterMark); + r.unshift({ id: 0 }); + r.on("data", (v) => console.log("after unshift:", show(v))); + r.on("end", () => console.log("read end")); +} + +function piped() { + const src = new PassThrough({ objectMode: true }); + const echo = new Duplex({ + objectMode: true, + read() {}, + write(chunk, enc, cb) { + this.push({ echoed: chunk }); + cb(); + }, + final(cb) { + this.push(null); + cb(); + }, + }); + src.pipe(echo).on("data", (v) => console.log("piped:", show(v))); + src.write({ n: 1 }); + src.write([2, 3]); + src.end("last"); +} + +function byteModeValues() { + const r = new Readable({ read() {} }); + r.on("error", (e) => console.log("byte push:", e.code)); + r.push(undefined); + r.push(42); +} + +async function forAwait() { + const pt = new PassThrough({ objectMode: true, highWaterMark: 2 }); + const ok = [pt.write(1), pt.write(2), pt.write(3)]; + console.log("backpressure:", ok.join(" "), pt.writableLength); + pt.end({ done: true }); + const got = []; + for await (const v of pt) got.push(show(v)); + console.log("for await:", got.join(" ")); +} + +await values(); +lines(); +encodings(); +unshiftFront(); +piped(); +byteModeValues(); +await forAwait(); diff --git a/tests/corpus/7242-objectmode-dynamic.cjs b/tests/corpus/7242-objectmode-dynamic.cjs new file mode 100644 index 000000000..fad06ad98 --- /dev/null +++ b/tests/corpus/7242-objectmode-dynamic.cjs @@ -0,0 +1,93 @@ +// Object-mode streams through dynamic values: options objects held in +// variables, constructor functions with util.inherits (Transform.call +// and Writable.call with objectMode), streams passed around as plain +// values, and Readable.from over values of mixed types. +const stream = require("stream"); +const util = require("util"); + +const show = (v) => (v !== null && typeof v === "object" ? JSON.stringify(v) : `${typeof v}:${String(v)}`); + +function Tagger(tag) { + stream.Transform.call(this, { objectMode: true }); + this.tag = tag; +} +util.inherits(Tagger, stream.Transform); +Tagger.prototype._transform = function (chunk, enc, cb) { + console.log("tagger enc:", enc); + if (chunk === 3) return cb(); + cb(null, { tag: this.tag, value: chunk }); +}; +Tagger.prototype._flush = function (cb) { + this.push({ tag: this.tag, value: "flushed" }); + cb(); +}; + +function Collector() { + stream.Writable.call(this, { objectMode: true, highWaterMark: 2 }); + this.items = []; +} +util.inherits(Collector, stream.Writable); +Collector.prototype._write = function (chunk, enc, cb) { + this.items.push(show(chunk)); + cb(); +}; + +function viaConstructors(next) { + const t = new Tagger("x"); + const c = new Collector(); + console.log("modes:", t.readableObjectMode, t.writableObjectMode, c.writableObjectMode, c.writableHighWaterMark); + t.pipe(c); + c.on("finish", () => { + console.log("collected:", c.items.join(" ")); + next(); + }); + t.write(1); + t.write("two", () => console.log("write cb")); + t.write(3); + t.end({ four: 4 }); +} + +function viaOptionObjects(next) { + const readableOpts = { objectMode: true, read() {} }; + const r = new stream.Readable(readableOpts); + const transformOpts = { + objectMode: true, + transform(chunk, enc, cb) { + cb(null, Array.isArray(chunk) ? chunk.length : chunk); + }, + }; + const t = new stream.Transform(transformOpts); + const seen = []; + const writableOpts = { + objectMode: true, + write(chunk, enc, cb) { + seen.push(show(chunk) + "/" + enc); + cb(); + }, + }; + const w = new stream.Writable(writableOpts); + stream.pipeline(r, t, w, (err) => { + console.log("option objects:", err === undefined ? "ok" : err, seen.join(" ")); + next(); + }); + r.push([1, 2, 3]); + r.push(false); + r.push({ k: "v" }); + r.push(null); +} + +async function viaFrom() { + const values = [0, "s", undefined, [1], { a: { b: 2 } }, 1.5]; + const out = []; + for await (const v of stream.Readable.from(values)) out.push(show(v)); + console.log("from:", out.join(" ")); + const pt = new stream.PassThrough({ objectMode: true }); + const passAlong = (s, v) => s.write(v); + passAlong(pt, { through: true }); + passAlong(pt, 7); + pt.end(); + pt.on("data", (v) => console.log("passed:", show(v))); + await new Promise((resolve) => pt.on("end", resolve)); +} + +viaConstructors(() => viaOptionObjects(() => viaFrom())); diff --git a/tests/corpus/7243-for-await-close-order.mjs b/tests/corpus/7243-for-await-close-order.mjs new file mode 100644 index 000000000..b3cc700be --- /dev/null +++ b/tests/corpus/7243-for-await-close-order.mjs @@ -0,0 +1,58 @@ +// for await over a stream completes through eos: a readable-only stream +// that will emit 'close' (autoDestroy and emitClose) ends the loop after +// 'close', a duplex after 'end', interleaved with other loops' ticks. +import { PassThrough, Readable } from "node:stream"; + +async function interleaved(objectMode) { + const log = []; + let on = true; + (async () => { + for (let i = 0; on && i < 30; i++) { + log.push("t" + i); + await null; + } + })(); + const nums = objectMode ? new PassThrough({ objectMode: true }) : new PassThrough({ highWaterMark: 4 }); + for (let k = 0; k < 6; k++) nums.write(objectMode ? k : "n" + k); + nums.end(); + nums.on("end", () => log.push("N-END")); + nums.on("close", () => log.push("N-CLOSE")); + nums.on("finish", () => log.push("N-FINISH")); + const fr = Readable.from(["a", "b", "c"]); + fr.on("end", () => log.push("F-END")); + fr.on("close", () => log.push("F-CLOSE")); + const a = (async () => { + for await (const n of nums) log.push("n" + String(n).length); + log.push("n-done"); + })(); + const b = (async () => { + for await (const v of fr) log.push("f" + v); + log.push("f-done"); + })(); + await Promise.all([a, b]); + on = false; + console.log(objectMode ? "object:" : "bytes:", log.join(" ")); +} + +async function closeBeforeDone() { + const log = []; + const r = new Readable({ objectMode: true, read() {} }); + r.on("end", () => log.push("end")); + r.on("close", () => log.push("close")); + r.push({ v: 1 }); + r.push(null); + for await (const v of r) log.push("v" + v.v); + log.push("done " + r.destroyed); + const keep = new Readable({ objectMode: true, autoDestroy: false, read() {} }); + keep.on("end", () => log.push("keep end")); + keep.on("close", () => log.push("keep close")); + keep.push(1); + keep.push(null); + for await (const v of keep) log.push("k" + v); + log.push("keep done " + keep.destroyed); + console.log("close order:", log.join(" ")); +} + +await interleaved(true); +await interleaved(false); +await closeBeforeDone(); diff --git a/tests/corpus/7244-objectmode-subclasses.ts b/tests/corpus/7244-objectmode-subclasses.ts new file mode 100644 index 000000000..5fcb05a24 --- /dev/null +++ b/tests/corpus/7244-objectmode-subclasses.ts @@ -0,0 +1,79 @@ +// Typed object-mode stream subclasses: Transform, Writable and Readable +// classes that pass objectMode to super(), _transform/_write/_read with +// record chunks, encoding parameters typed string | null | undefined, and +// push() of records and other values. +import { Readable, Transform, Writable } from "node:stream"; +import { pipeline } from "node:stream/promises"; + +interface Order { + id: number; + items: string[]; +} + +interface Summary { + id: number; + count: number; +} + +class Orders extends Readable { + private next = 1; + constructor() { + super({ objectMode: true }); + } + _read(): void { + if (this.next > 3) { + this.push(null); + return; + } + const id = this.next++; + this.push({ id, items: Array.from({ length: id }, (_, i) => `item${i}`) }); + } +} + +class Summarize extends Transform { + constructor() { + super({ objectMode: true }); + } + _transform( + order: Order, + encoding: string | null | undefined, + cb: (err: Error | null, data?: Summary) => void, + ): void { + console.log("summarize", order.id, encoding); + cb(null, { id: order.id, count: order.items.length }); + } +} + +class Report extends Writable { + lines: string[] = []; + constructor() { + super({ objectMode: true, highWaterMark: 1 }); + } + _write(s: Summary, _encoding: string, cb: (err?: Error | null) => void): void { + this.lines.push(`#${s.id}=${s.count}`); + cb(); + } +} + +async function main(): Promise { + const report = new Report(); + console.log("report", report.writableObjectMode, report.writableHighWaterMark); + await pipeline(new Orders(), new Summarize(), report); + console.log("lines", report.lines.join(" ")); + + const direct = new Summarize(); + direct.on("data", (s: Summary) => console.log("direct", s.id, s.count)); + direct.write({ id: 9, items: ["a"] }, "utf8"); + direct.write({ id: 10, items: [] }, () => console.log("written")); + direct.end(); + + const values = new Readable({ objectMode: true, read() {} }); + values.push(1.5); + values.push("text"); + values.push([1, 2]); + values.push(null); + const seen: string[] = []; + for await (const v of values) seen.push(JSON.stringify(v)); + console.log("values", seen.join(" ")); +} +main(); diff --git a/tests/corpus/7245-writable-callback-order.mjs b/tests/corpus/7245-writable-callback-order.mjs new file mode 100644 index 000000000..454e67fe0 --- /dev/null +++ b/tests/corpus/7245-writable-callback-order.mjs @@ -0,0 +1,71 @@ +// Writable callback and 'finish' timing: buffered writes completing +// inside clearBuffer keep their callback order, a deferred afterWrite +// with a user callback holds 'finish' for its own tick, a _final +// callback schedules 'finish' at once, and cork()/uncork() with +// callbacks. +import { PassThrough, Transform, Writable } from "node:stream"; + +function ticks(log, count) { + let n = 0; + const tick = () => { + log.push("t" + n); + if (++n < count) process.nextTick(tick); + }; + process.nextTick(tick); +} + +async function bufferedCallbacks() { + const log = []; + const nums = new PassThrough({ highWaterMark: 4 }); + for (let k = 0; k < 6; k++) log.push("w" + nums.write("n" + k, () => log.push("cb" + k))); + nums.end(() => log.push("end-cb")); + nums.on("finish", () => log.push("finish")); + nums.on("end", () => log.push("end")); + for await (const chunk of nums) log.push("r" + chunk.length); + log.push("done"); + console.log("buffered:", log.join(" ")); +} + +function finishTiming() { + return new Promise((resolve) => { + const log = []; + ticks(log, 10); + const plain = new Writable({ write(c, e, cb) { log.push("pw" + c); cb(); } }); + plain.write("1", () => log.push("pcb1")); + plain.write("2"); + plain.end("3", () => log.push("pend")); + plain.on("finish", () => log.push("pfinish")); + const withFinal = new Writable({ + write(c, e, cb) { log.push("fw" + c); cb(); }, + final(cb) { log.push("final"); cb(); }, + }); + withFinal.write("1", () => log.push("fcb1")); + withFinal.end(() => log.push("fend")); + withFinal.on("finish", () => log.push("ffinish")); + const corked = new Writable({ write(c, e, cb) { log.push("cw" + c); cb(); } }); + corked.cork(); + corked.write("a", () => log.push("ccb-a")); + corked.write("b", () => log.push("ccb-b")); + process.nextTick(() => { + corked.uncork(); + corked.end(() => log.push("cend")); + }); + corked.on("finish", () => log.push("cfinish")); + const t = new Transform({ + transform(c, e, cb) { cb(null, c); }, + flush(cb) { log.push("flush"); cb(); }, + }); + t.resume(); + t.write("q", () => log.push("tcb")); + t.end(() => log.push("tend")); + t.on("finish", () => log.push("tfinish")); + t.on("end", () => log.push("tread-end")); + setTimeout(() => { + console.log("timing:", log.join(" ")); + resolve(undefined); + }, 10); + }); +} + +await bufferedCallbacks(); +await finishTiming(); diff --git a/tests/harness/corpus-costs/7240-objectmode-streams.ts.json b/tests/harness/corpus-costs/7240-objectmode-streams.ts.json new file mode 100644 index 000000000..2695df1a4 --- /dev/null +++ b/tests/harness/corpus-costs/7240-objectmode-streams.ts.json @@ -0,0 +1 @@ +{ "plain": 2084, "san": 2980 } diff --git a/tests/harness/corpus-costs/7241-objectmode-streams.mjs.json b/tests/harness/corpus-costs/7241-objectmode-streams.mjs.json new file mode 100644 index 000000000..bd04ea049 --- /dev/null +++ b/tests/harness/corpus-costs/7241-objectmode-streams.mjs.json @@ -0,0 +1 @@ +{ "plain": 2190, "san": 3093 } diff --git a/tests/harness/corpus-costs/7242-objectmode-dynamic.cjs.json b/tests/harness/corpus-costs/7242-objectmode-dynamic.cjs.json new file mode 100644 index 000000000..3bc4d9211 --- /dev/null +++ b/tests/harness/corpus-costs/7242-objectmode-dynamic.cjs.json @@ -0,0 +1 @@ +{ "plain": 2430, "san": 3287 } diff --git a/tests/harness/corpus-costs/7243-for-await-close-order.mjs.json b/tests/harness/corpus-costs/7243-for-await-close-order.mjs.json new file mode 100644 index 000000000..e5826334d --- /dev/null +++ b/tests/harness/corpus-costs/7243-for-await-close-order.mjs.json @@ -0,0 +1 @@ +{ "plain": 2402, "san": 3174 } diff --git a/tests/harness/corpus-costs/7244-objectmode-subclasses.ts.json b/tests/harness/corpus-costs/7244-objectmode-subclasses.ts.json new file mode 100644 index 000000000..d555a94ab --- /dev/null +++ b/tests/harness/corpus-costs/7244-objectmode-subclasses.ts.json @@ -0,0 +1 @@ +{ "plain": 1917, "san": 2782 } diff --git a/tests/harness/corpus-costs/7245-writable-callback-order.mjs.json b/tests/harness/corpus-costs/7245-writable-callback-order.mjs.json new file mode 100644 index 000000000..0226cbb35 --- /dev/null +++ b/tests/harness/corpus-costs/7245-writable-callback-order.mjs.json @@ -0,0 +1 @@ +{ "plain": 2144, "san": 2747 } diff --git a/tests/harness/self-hosting-native-toolchain.test.ts b/tests/harness/self-hosting-native-toolchain.test.ts index c01b52595..d7187c50b 100644 --- a/tests/harness/self-hosting-native-toolchain.test.ts +++ b/tests/harness/self-hosting-native-toolchain.test.ts @@ -105,7 +105,7 @@ for (const backend of ["llvm"] as const) { object_format: target.objectFormat, minimum_os: target.minimumOs, }, - runtime_abi: { version: 25, marker: "scr_runtime_abi_v25" }, + runtime_abi: { version: 26, marker: "scr_runtime_abi_v26" }, compiler: { command: "fixture", identity: "fixture", target: target.llvmTriple }, macros: { executable: [], excluded: [], sanitizer: "external-toolchain-required" }, flavors: { From c47a0e90aee3d3a7e75c8b6c1cb16b9b3c570f4b Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 04:27:35 -0500 Subject: [PATCH 052/102] Compile JSX with the classic runtime Fixes #889 Co-authored-by: papack <33105506+papack@users.noreply.github.com> --- .oxlintrc.jsonc | 1 + docs/content/docs/limitations.mdx | 2 + .../limitations/language-features/jsx.mdx | 5 + .../compiler/src/frontend/jsx-entities.ts | 258 ++++++ .../compiler/src/frontend/jsx-source.test.ts | 244 +++++ packages/compiler/src/frontend/jsx-source.ts | 856 ++++++++++++++++++ packages/compiler/src/frontend/program.ts | 124 ++- .../src/frontend/ts7/enums.generated.ts | 22 + packages/compiler/src/frontend/ts7/enums.ts | 21 + .../compiler/src/frontend/ts7/program-host.ts | 4 + packages/compiler/src/frontend/tsc-codes.ts | 7 + .../6822-jsx-classic-runtime/main.ts.json | 11 + .../6824-jsx-automatic-runtime/main.ts.json | 12 + .../main.ts.json | 8 + .../jsx-factory-mismatch/main.ts.json | 17 + .../diagnostics/jsx-preserve/main.ts.json | 18 + .../diagnostics/jsx-type-errors/main.ts.json | 26 + scripts/generate-ts7-ast-schema.mjs | 2 + .../6822-jsx-classic-runtime/factory.ts | 7 + tests/corpus/6822-jsx-classic-runtime/html.ts | 45 + .../corpus/6822-jsx-classic-runtime/list.jsx | 22 + tests/corpus/6822-jsx-classic-runtime/main.ts | 15 + .../corpus/6822-jsx-classic-runtime/page.tsx | 40 + .../6822-jsx-classic-runtime/pragma.tsx | 11 + .../6822-jsx-classic-runtime/tsconfig.json | 9 + .../corpus/6824-jsx-automatic-runtime/alt.tsx | 3 + .../alt/jsx-runtime.ts | 17 + .../corpus/6824-jsx-automatic-runtime/main.ts | 10 + .../6824-jsx-automatic-runtime/package.json | 8 + .../6824-jsx-automatic-runtime/page.tsx | 33 + .../6824-jsx-automatic-runtime/render.ts | 15 + .../runtime/index.ts | 12 + .../runtime/jsx-runtime.ts | 33 + .../6824-jsx-automatic-runtime/tsconfig.json | 8 + .../6825-jsx-automatic-development/main.ts | 5 + .../package.json | 6 + .../runtime/jsx-dev-runtime.ts | 31 + .../tsconfig.json | 8 + .../6825-jsx-automatic-development/view.tsx | 21 + .../diagnostics/jsx-factory-mismatch/main.ts | 3 + .../jsx-factory-mismatch/tsconfig.json | 1 + .../diagnostics/jsx-factory-mismatch/view.tsx | 13 + tests/diagnostics/jsx-preserve/main.ts | 3 + tests/diagnostics/jsx-preserve/tsconfig.json | 1 + tests/diagnostics/jsx-preserve/view.tsx | 9 + tests/diagnostics/jsx-type-errors/main.ts | 3 + .../diagnostics/jsx-type-errors/tsconfig.json | 1 + tests/diagnostics/jsx-type-errors/view.tsx | 15 + .../jsx-factory-mismatch/main.ts.txt | 6 + .../__snapshots__/jsx-preserve/main.ts.txt | 8 + .../__snapshots__/jsx-type-errors/main.ts.txt | 13 + .../6822-jsx-classic-runtime/main.ts.json | 1 + .../6824-jsx-automatic-runtime/main.ts.json | 1 + .../main.ts.json | 1 + tests/harness/differential.test.ts | 4 +- tests/harness/jsx-oracle.ts | 120 +++ tests/harness/linux-differential.test.ts | 4 +- tests/harness/llvm-differential.test.ts | 4 +- tests/harness/windows-differential.test.ts | 23 +- 59 files changed, 2216 insertions(+), 15 deletions(-) create mode 100644 docs/content/limitations/language-features/jsx.mdx create mode 100644 packages/compiler/src/frontend/jsx-entities.ts create mode 100644 packages/compiler/src/frontend/jsx-source.test.ts create mode 100644 packages/compiler/src/frontend/jsx-source.ts create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6822-jsx-classic-runtime/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6824-jsx-automatic-runtime/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6825-jsx-automatic-development/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/jsx-factory-mismatch/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/jsx-preserve/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/jsx-type-errors/main.ts.json create mode 100644 tests/corpus/6822-jsx-classic-runtime/factory.ts create mode 100644 tests/corpus/6822-jsx-classic-runtime/html.ts create mode 100644 tests/corpus/6822-jsx-classic-runtime/list.jsx create mode 100644 tests/corpus/6822-jsx-classic-runtime/main.ts create mode 100644 tests/corpus/6822-jsx-classic-runtime/page.tsx create mode 100644 tests/corpus/6822-jsx-classic-runtime/pragma.tsx create mode 100644 tests/corpus/6822-jsx-classic-runtime/tsconfig.json create mode 100644 tests/corpus/6824-jsx-automatic-runtime/alt.tsx create mode 100644 tests/corpus/6824-jsx-automatic-runtime/alt/jsx-runtime.ts create mode 100644 tests/corpus/6824-jsx-automatic-runtime/main.ts create mode 100644 tests/corpus/6824-jsx-automatic-runtime/package.json create mode 100644 tests/corpus/6824-jsx-automatic-runtime/page.tsx create mode 100644 tests/corpus/6824-jsx-automatic-runtime/render.ts create mode 100644 tests/corpus/6824-jsx-automatic-runtime/runtime/index.ts create mode 100644 tests/corpus/6824-jsx-automatic-runtime/runtime/jsx-runtime.ts create mode 100644 tests/corpus/6824-jsx-automatic-runtime/tsconfig.json create mode 100644 tests/corpus/6825-jsx-automatic-development/main.ts create mode 100644 tests/corpus/6825-jsx-automatic-development/package.json create mode 100644 tests/corpus/6825-jsx-automatic-development/runtime/jsx-dev-runtime.ts create mode 100644 tests/corpus/6825-jsx-automatic-development/tsconfig.json create mode 100644 tests/corpus/6825-jsx-automatic-development/view.tsx create mode 100644 tests/diagnostics/jsx-factory-mismatch/main.ts create mode 100644 tests/diagnostics/jsx-factory-mismatch/tsconfig.json create mode 100644 tests/diagnostics/jsx-factory-mismatch/view.tsx create mode 100644 tests/diagnostics/jsx-preserve/main.ts create mode 100644 tests/diagnostics/jsx-preserve/tsconfig.json create mode 100644 tests/diagnostics/jsx-preserve/view.tsx create mode 100644 tests/diagnostics/jsx-type-errors/main.ts create mode 100644 tests/diagnostics/jsx-type-errors/tsconfig.json create mode 100644 tests/diagnostics/jsx-type-errors/view.tsx create mode 100644 tests/harness/__snapshots__/jsx-factory-mismatch/main.ts.txt create mode 100644 tests/harness/__snapshots__/jsx-preserve/main.ts.txt create mode 100644 tests/harness/__snapshots__/jsx-type-errors/main.ts.txt create mode 100644 tests/harness/corpus-costs/6822-jsx-classic-runtime/main.ts.json create mode 100644 tests/harness/corpus-costs/6824-jsx-automatic-runtime/main.ts.json create mode 100644 tests/harness/corpus-costs/6825-jsx-automatic-development/main.ts.json create mode 100644 tests/harness/jsx-oracle.ts diff --git a/.oxlintrc.jsonc b/.oxlintrc.jsonc index 0c5cad25f..b0acea28a 100644 --- a/.oxlintrc.jsonc +++ b/.oxlintrc.jsonc @@ -241,6 +241,7 @@ "packages/compiler/src/frontend/comptime-node.ts", "packages/compiler/src/frontend/ts7/world-check.ts", "packages/compiler/src/frontend/ts7/source-parser.test.ts", + "packages/compiler/src/frontend/jsx-source.test.ts", "packages/compiler/src/frontend/npm-static-rewrite.ts", "packages/compiler/src/frontend/npm-static-bundled-cjs.ts", "packages/compiler/src/library/semantic-source.ts", diff --git a/docs/content/docs/limitations.mdx b/docs/content/docs/limitations.mdx index 5be38a924..e132f27da 100644 --- a/docs/content/docs/limitations.mdx +++ b/docs/content/docs/limitations.mdx @@ -34,6 +34,8 @@ title: "Limitations" ../limitations/language-features/commonjs-require.mdx +../limitations/language-features/jsx.mdx + ### Types and class definitions ../limitations/types-and-class-definitions/bigint.mdx diff --git a/docs/content/limitations/language-features/jsx.mdx b/docs/content/limitations/language-features/jsx.mdx new file mode 100644 index 000000000..a491dc995 --- /dev/null +++ b/docs/content/limitations/language-features/jsx.mdx @@ -0,0 +1,5 @@ +- **JSX:** JSX in `.tsx`, `.jsx` and JavaScript files compiles with the project's `jsx` setting: `"react"` with `jsxFactory`, `jsxFragmentFactory` or `reactNamespace`, and `"react-jsx"` or `"react-jsxdev"` with `jsxImportSource`, as well as the `@jsx`, `@jsxFrag`, `@jsxImportSource` and `@jsxRuntime` pragmas. + The checker types JSX with these settings, and each element becomes the call TypeScript emits for it, importing the automatic runtime's functions from `/jsx-runtime` or `jsx-dev-runtime`. + `"jsx": "preserve"` and `"react-native"`, which keep JSX in the output, are refused. + The call an element becomes must type-check: a factory or runtime function whose parameters do not accept what an element passes is reported at the element. + With `"react-jsxdev"`, `jsxDEV` receives `undefined` as `self` where `this` has no declared type (in a function that is not a method), which is the value such a function observes when called without a receiver. diff --git a/packages/compiler/src/frontend/jsx-entities.ts b/packages/compiler/src/frontend/jsx-entities.ts new file mode 100644 index 000000000..b9b0070de --- /dev/null +++ b/packages/compiler/src/frontend/jsx-entities.ts @@ -0,0 +1,258 @@ +/** The HTML entity names JSX text and attribute strings decode (HTML 4's + * 253 named character references, the set TypeScript's JSX emit decodes), + * by name. */ +export const JSX_ENTITIES: ReadonlyMap = new Map([ + ["quot", 34], + ["amp", 38], + ["apos", 39], + ["lt", 60], + ["gt", 62], + ["nbsp", 160], + ["iexcl", 161], + ["cent", 162], + ["pound", 163], + ["curren", 164], + ["yen", 165], + ["brvbar", 166], + ["sect", 167], + ["uml", 168], + ["copy", 169], + ["ordf", 170], + ["laquo", 171], + ["not", 172], + ["shy", 173], + ["reg", 174], + ["macr", 175], + ["deg", 176], + ["plusmn", 177], + ["sup2", 178], + ["sup3", 179], + ["acute", 180], + ["micro", 181], + ["para", 182], + ["middot", 183], + ["cedil", 184], + ["sup1", 185], + ["ordm", 186], + ["raquo", 187], + ["frac14", 188], + ["frac12", 189], + ["frac34", 190], + ["iquest", 191], + ["Agrave", 192], + ["Aacute", 193], + ["Acirc", 194], + ["Atilde", 195], + ["Auml", 196], + ["Aring", 197], + ["AElig", 198], + ["Ccedil", 199], + ["Egrave", 200], + ["Eacute", 201], + ["Ecirc", 202], + ["Euml", 203], + ["Igrave", 204], + ["Iacute", 205], + ["Icirc", 206], + ["Iuml", 207], + ["ETH", 208], + ["Ntilde", 209], + ["Ograve", 210], + ["Oacute", 211], + ["Ocirc", 212], + ["Otilde", 213], + ["Ouml", 214], + ["times", 215], + ["Oslash", 216], + ["Ugrave", 217], + ["Uacute", 218], + ["Ucirc", 219], + ["Uuml", 220], + ["Yacute", 221], + ["THORN", 222], + ["szlig", 223], + ["agrave", 224], + ["aacute", 225], + ["acirc", 226], + ["atilde", 227], + ["auml", 228], + ["aring", 229], + ["aelig", 230], + ["ccedil", 231], + ["egrave", 232], + ["eacute", 233], + ["ecirc", 234], + ["euml", 235], + ["igrave", 236], + ["iacute", 237], + ["icirc", 238], + ["iuml", 239], + ["eth", 240], + ["ntilde", 241], + ["ograve", 242], + ["oacute", 243], + ["ocirc", 244], + ["otilde", 245], + ["ouml", 246], + ["divide", 247], + ["oslash", 248], + ["ugrave", 249], + ["uacute", 250], + ["ucirc", 251], + ["uuml", 252], + ["yacute", 253], + ["thorn", 254], + ["yuml", 255], + ["OElig", 338], + ["oelig", 339], + ["Scaron", 352], + ["scaron", 353], + ["Yuml", 376], + ["fnof", 402], + ["circ", 710], + ["tilde", 732], + ["Alpha", 913], + ["Beta", 914], + ["Gamma", 915], + ["Delta", 916], + ["Epsilon", 917], + ["Zeta", 918], + ["Eta", 919], + ["Theta", 920], + ["Iota", 921], + ["Kappa", 922], + ["Lambda", 923], + ["Mu", 924], + ["Nu", 925], + ["Xi", 926], + ["Omicron", 927], + ["Pi", 928], + ["Rho", 929], + ["Sigma", 931], + ["Tau", 932], + ["Upsilon", 933], + ["Phi", 934], + ["Chi", 935], + ["Psi", 936], + ["Omega", 937], + ["alpha", 945], + ["beta", 946], + ["gamma", 947], + ["delta", 948], + ["epsilon", 949], + ["zeta", 950], + ["eta", 951], + ["theta", 952], + ["iota", 953], + ["kappa", 954], + ["lambda", 955], + ["mu", 956], + ["nu", 957], + ["xi", 958], + ["omicron", 959], + ["pi", 960], + ["rho", 961], + ["sigmaf", 962], + ["sigma", 963], + ["tau", 964], + ["upsilon", 965], + ["phi", 966], + ["chi", 967], + ["psi", 968], + ["omega", 969], + ["thetasym", 977], + ["upsih", 978], + ["piv", 982], + ["ensp", 8194], + ["emsp", 8195], + ["thinsp", 8201], + ["zwnj", 8204], + ["zwj", 8205], + ["lrm", 8206], + ["rlm", 8207], + ["ndash", 8211], + ["mdash", 8212], + ["lsquo", 8216], + ["rsquo", 8217], + ["sbquo", 8218], + ["ldquo", 8220], + ["rdquo", 8221], + ["bdquo", 8222], + ["dagger", 8224], + ["Dagger", 8225], + ["bull", 8226], + ["hellip", 8230], + ["permil", 8240], + ["prime", 8242], + ["Prime", 8243], + ["lsaquo", 8249], + ["rsaquo", 8250], + ["oline", 8254], + ["frasl", 8260], + ["euro", 8364], + ["image", 8465], + ["weierp", 8472], + ["real", 8476], + ["trade", 8482], + ["alefsym", 8501], + ["larr", 8592], + ["uarr", 8593], + ["rarr", 8594], + ["darr", 8595], + ["harr", 8596], + ["crarr", 8629], + ["lArr", 8656], + ["uArr", 8657], + ["rArr", 8658], + ["dArr", 8659], + ["hArr", 8660], + ["forall", 8704], + ["part", 8706], + ["exist", 8707], + ["empty", 8709], + ["nabla", 8711], + ["isin", 8712], + ["notin", 8713], + ["ni", 8715], + ["prod", 8719], + ["sum", 8721], + ["minus", 8722], + ["lowast", 8727], + ["radic", 8730], + ["prop", 8733], + ["infin", 8734], + ["ang", 8736], + ["and", 8743], + ["or", 8744], + ["cap", 8745], + ["cup", 8746], + ["int", 8747], + ["there4", 8756], + ["sim", 8764], + ["cong", 8773], + ["asymp", 8776], + ["ne", 8800], + ["equiv", 8801], + ["le", 8804], + ["ge", 8805], + ["sub", 8834], + ["sup", 8835], + ["nsub", 8836], + ["sube", 8838], + ["supe", 8839], + ["oplus", 8853], + ["otimes", 8855], + ["perp", 8869], + ["sdot", 8901], + ["lceil", 8968], + ["rceil", 8969], + ["lfloor", 8970], + ["rfloor", 8971], + ["lang", 9001], + ["rang", 9002], + ["loz", 9674], + ["spades", 9824], + ["clubs", 9827], + ["hearts", 9829], + ["diams", 9830], +]); diff --git a/packages/compiler/src/frontend/jsx-source.test.ts b/packages/compiler/src/frontend/jsx-source.test.ts new file mode 100644 index 000000000..564a61d98 --- /dev/null +++ b/packages/compiler/src/frontend/jsx-source.test.ts @@ -0,0 +1,244 @@ +import ts5 from "typescript5"; +import { afterAll, describe, expect, it } from "vitest"; +import { jsxEmitPlan, decodeEntities, jsxPragmas, jsxTextValue, lowerJsx } from "./jsx-source.js"; +import { closeSourceParser, parseSourceFile } from "./ts7/source-parser-node.js"; + +afterAll(() => closeSourceParser()); + +/** Evaluates a program whose last statement is `result = ...`, with `h` and + * `Fragment` recording the calls the JSX makes. */ +function evaluate(code: string): unknown { + const run = new Function( + "h", + "Fragment", + "React", + `"use strict"; let result; ${code}; return result;`, + ) as (...args: unknown[]) => unknown; + const h = (tag: unknown, props: unknown, ...children: unknown[]): unknown => ({ + tag: typeof tag === "function" ? `fn:${tag.name}` : tag === Fragment ? "#fragment" : tag, + props, + children, + }); + const Fragment = { fragment: true }; + return run(h, Fragment, { createElement: h, Fragment }); +} + +/** TypeScript's own classic-runtime emit of the snippet. */ +function typescriptEmit(source: string, factory?: string): string { + return ts5.transpileModule(source, { + fileName: "case.tsx", + compilerOptions: { + target: ts5.ScriptTarget.ES2022, + module: ts5.ModuleKind.ESNext, + jsx: ts5.JsxEmit.React, + ...(factory === undefined ? {} : { jsxFactory: factory, jsxFragmentFactory: "Fragment" }), + }, + }).outputText; +} + +function rewrite(source: string, factory?: string): string { + const sf = parseSourceFile("/case.tsx", source, "tsx"); + const plan = jsxEmitPlan( + { + jsx: "react", + ...(factory === undefined ? {} : { jsxFactory: factory, jsxFragmentFactory: "Fragment" }), + }, + jsxPragmas(source), + ); + return lowerJsx(sf, plan).text; +} + +const cases: Record = { + "attributes and text": `const name = "w"; const p = { id: 1 }; +result =
Hello {name} & A © + second line + {/* comment */} + {name}{" "}bold +
;`, + fragments: `function Foo() {} Foo.Bar = function Bar() {}; +result = <>;`, + namespaced: `result = ;`, + "keys and nested maps": `const p = { id: 1 }; +result =
{[1, 2].map((n) => {n})}
;`, + "white space only": `result = [
,
+
,
a {"b"} c
];`, + "spreads": `const p = { id: 1 }; const kids = [1, 2]; +result = [
,
,
{...kids}
,
,
];`, + "attribute strings": `result =
;`, + "attribute values": `result =
c={{1}} d={[

]} />;`, + "member and this tags": `class X { Tag = function Tag() {}; render() { return ; } } +result = new X().render();`, + "dashed and capitalized names": `function Comp() {} +result = [, ];`, + "nested JSX in expressions": `const items = ["a", "b"]; +result =

    + {items.length > 1 ?
  • {items[0]}
    • : null} + {items.map((item) => +
  • + {item} +
    • )} +
;`, +}; + +describe("lowerJsx", () => { + for (const [name, source] of Object.entries(cases)) { + it(`matches TypeScript's emit: ${name}`, () => { + const lowered = rewrite(source); + expect(evaluate(lowered)).toEqual(evaluate(typescriptEmit(source))); + expect(lowered.split("\n").length).toBe(source.split("\n").length); + }); + } + + it("uses jsxFactory and the pragmas", () => { + const source = `result = <>;`; + expect(evaluate(rewrite(source, "h"))).toEqual(evaluate(typescriptEmit(source, "h"))); + const pragma = `/** @jsx h */\n/** @jsxFrag Fragment */\nresult = <>;`; + expect(rewrite(pragma)).toContain(`h(Fragment, null`); + expect(evaluate(rewrite(pragma))).toEqual(evaluate(typescriptEmit(pragma))); + }); + + it("keeps every byte outside JSX", () => { + const source = `const a = 1; // \nconst b = "
";\nresult = [a, b, ];\n`; + const lowered = rewrite(source); + expect( + lowered.startsWith(`const a = 1; // \nconst b = "
";\nresult = [a, b, `), + ).toBe(true); + }); + + it("maps rewritten positions back to the source", () => { + const source = `const x = 1;\nresult =
{x}
;\nconst y = 2;\n`; + const sf = parseSourceFile("/case.tsx", source, "tsx"); + const lowered = lowerJsx(sf, { runtime: "classic", factory: "h", fragment: "Fragment" }); + const after = lowered.text.indexOf("const y"); + expect(lowered.originalPosition(after)).toBe(source.indexOf("const y")); + const copied = lowered.text.indexOf("{ a: x }") + "{ a: ".length; + expect(lowered.originalPosition(copied)).toBe(source.indexOf("{x}>") + 1); + expect(lowered.originalPosition(lowered.text.indexOf("h("))).toBe(source.indexOf(" + list + .split(",") + .map((item) => { + const [name, local] = item.trim().split(/\s+as\s+/); + return `const ${local} = runtime.${name};`; + }) + .join(" "), + ) + .replace(/(^|\s)export /gm, "$1"); + const record = + (kind: string) => + (...args: unknown[]): unknown => ({ kind, args: args.map(named) }); + const runtime = { + jsx: record("jsx"), + jsxs: record("jsxs"), + jsxDEV: record("jsxDEV"), + createElement: record("createElement"), + Fragment: "#fragment", + }; + const run = new Function("runtime", `"use strict"; let result; ${body}; return result;`) as ( + runtime: unknown, + ) => unknown; + return run(runtime); +} + +/** Functions compare by name: each evaluation declares its own. */ +function named(value: unknown): unknown { + if (typeof value === "function") return `fn:${value.name}`; + if (Array.isArray(value)) return value.map(named); + if (value !== null && typeof value === "object") + return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, named(item)])); + return value; +} + +function typescriptAutomatic(source: string, development: boolean): string { + return ts5.transpileModule(source, { + fileName: "/case.tsx", + compilerOptions: { + target: ts5.ScriptTarget.ES2022, + module: ts5.ModuleKind.ESNext, + jsx: development ? ts5.JsxEmit.ReactJSXDev : ts5.JsxEmit.ReactJSX, + }, + }).outputText; +} + +function rewriteAutomatic(source: string, development: boolean): string { + const sf = parseSourceFile("/case.tsx", source, "tsx"); + const plan = jsxEmitPlan({ jsx: development ? "react-jsxdev" : "react-jsx" }, jsxPragmas(source)); + return lowerJsx(sf, plan).text; +} + +const automaticCases: Record = { + ...cases, + "keys": `const p = { id: 1 }; +result = [
  • x
    • ,
  • ,
  • ,
  • ,
  • ];`, + "children shapes": `const kids = [1, 2]; +result = [

    ,

    {}

    ,

    +

    ,

    one

    ,

    {1}{2}

    ,

    {...kids}

    ,

    , <>, <>];`, + "names in use": `const _jsx = "taken"; const _jsxs = 1; +result = [

    {_jsx}

    ,

    {_jsxs}{_jsx}

    ];`, +}; + +describe("lowerJsx with the automatic runtime", () => { + for (const [name, source] of Object.entries(automaticCases)) { + for (const development of [false, true]) { + it(`matches TypeScript's ${development ? "react-jsxdev" : "react-jsx"} emit: ${name}`, () => { + const lowered = rewriteAutomatic(`export {};\n${source}`, development); + const expected = typescriptAutomatic(`export {};\n${source}`, development); + expect(evaluateAutomatic(lowered)).toEqual(evaluateAutomatic(expected)); + expect(lowered.split("\n").length).toBe(source.split("\n").length + 1); + }); + } + } + + it("imports the runtime functions on the first statement's line", () => { + const lowered = rewriteAutomatic( + `"use strict";\nexport const a = <>;\n`, + false, + ); + expect(lowered).toBe( + `"use strict";import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime"; \nexport const a = _jsx(_Fragment, { children: _jsx("b", {}, "k") });\n`, + ); + }); + + it("reads @jsxImportSource and @jsxRuntime", () => { + const pragma = `/** @jsxImportSource preact */\nexport const a = ;\n`; + expect(rewriteAutomatic(pragma, false)).toContain(`from "preact/jsx-runtime"`); + const classic = `/** @jsxRuntime classic */\n/** @jsx h */\nexport const a = ;\n`; + expect(rewriteAutomatic(classic, false)).toContain(`h("b", null)`); + }); +}); + +describe("JSX text", () => { + it("trims lines as TypeScript does", () => { + expect(jsxTextValue(" a \n b \n ")).toBe(" a b"); + expect(jsxTextValue("\n \n")).toBeUndefined(); + expect(jsxTextValue(" ")).toBe(" "); + }); + + it("decodes entities", () => { + expect(decodeEntities("<>& AB&bogus;�")).toBe( + "<>& AB&bogus;�", + ); + }); +}); + +describe("jsxPragmas", () => { + it("reads leading multi-line comments, first @jsx and last @jsxImportSource", () => { + expect( + jsxPragmas( + "#!/usr/bin/env node\n/** @jsx h\n * @jsx g */\n// @jsxFrag F\n/* @jsxImportSource a */ /* @jsxImportSource b */\nconst x = 1; /** @jsx late */", + ), + ).toEqual({ jsx: "h", jsxImportSource: "b" }); + }); +}); diff --git a/packages/compiler/src/frontend/jsx-source.ts b/packages/compiler/src/frontend/jsx-source.ts new file mode 100644 index 000000000..915a5d16f --- /dev/null +++ b/packages/compiler/src/frontend/jsx-source.ts @@ -0,0 +1,856 @@ +/* JSX lowering at the source level, before IR lowering. + * + * A program that contains JSX is checked as written: the checker types JSX + * with the project's jsx settings and reports the errors tsc reports. Each + * file that contains JSX is then rewritten with every JSX expression + * replaced by the calls TypeScript emits for it, and the rewritten program is + * what the lowering compiles, through the same import, call and object + * literal lowering as ordinary code. + * + * The rewrite copies every byte outside JSX expressions, and copies the + * expressions inside them (attribute values, children, spreads) with their + * own JSX rewritten. It keeps every line break of a JSX expression, between + * the arguments it emits, so a position keeps its line in the rewritten + * text. */ + +import * as ts from "./ts7/adapter.js"; +import { jsxOptionName } from "./ts7/enums.js"; +import { JSX_ENTITIES } from "./jsx-entities.js"; + +/** The project's jsx compiler options, as the tsconfig spells them. */ +export interface JsxOptions { + jsx?: string | number | undefined; + jsxFactory?: string | undefined; + jsxFragmentFactory?: string | undefined; + jsxImportSource?: string | undefined; + reactNamespace?: string | undefined; +} + +/** The tsconfig name of a `jsx` option value (TS7 options carry JsxEmit + * numbers, parsed tsconfigs may carry the name). */ +export function jsxEmitName(value: string | number | undefined): string | undefined { + if (typeof value === "number") return jsxOptionName(value); + return value?.toLowerCase(); +} + +/** The `@jsx`, `@jsxFrag`, `@jsxImportSource` and `@jsxRuntime` pragmas of + * a file's leading comments, as TypeScript reads them: multi-line comments + * only, the first `@jsx` and `@jsxFrag` and the last `@jsxImportSource` and + * `@jsxRuntime`. */ +export interface JsxPragmas { + jsx?: string; + jsxFrag?: string; + jsxImportSource?: string; + jsxRuntime?: string; +} + +export function jsxPragmas(text: string): JsxPragmas { + const pragmas: JsxPragmas = {}; + for (const comment of leadingMultiLineComments(text)) { + const pattern = /@(\S+)(\s+(?:\S.*)?)?$/gm; + for (let match = pattern.exec(comment); match !== null; match = pattern.exec(comment)) { + const argument = match[2]?.trim().split(/\s+/)[0]; + if (!argument) continue; + switch (match[1]!.toLowerCase()) { + case "jsx": + pragmas.jsx ??= argument; + break; + case "jsxfrag": + pragmas.jsxFrag ??= argument; + break; + case "jsximportsource": + pragmas.jsxImportSource = argument; + break; + case "jsxruntime": + pragmas.jsxRuntime = argument; + break; + } + } + } + return pragmas; +} + +/** The `/* ... *\/` comments before a file's first token (after a shebang). */ +function leadingMultiLineComments(text: string): string[] { + const comments: string[] = []; + let i = text.startsWith("#!") ? text.indexOf("\n") : 0; + if (i < 0) return comments; + while (i < text.length) { + const ch = text.charCodeAt(i); + if (isLineBreak(ch) || isWhiteSpaceSingleLine(ch)) { + i++; + } else if (text.startsWith("//", i)) { + while (i < text.length && !isLineBreak(text.charCodeAt(i))) i++; + } else if (text.startsWith("/*", i)) { + const end = text.indexOf("*/", i + 2); + const close = end < 0 ? text.length : end + 2; + comments.push(text.slice(i, close)); + i = close; + } else { + break; + } + } + return comments; +} + +function isLineBreak(ch: number): boolean { + return ch === 10 || ch === 13 || ch === 0x2028 || ch === 0x2029; +} + +function isWhiteSpaceSingleLine(ch: number): boolean { + return ( + ch === 32 || + ch === 9 || + ch === 11 || + ch === 12 || + ch === 160 || + ch === 133 || + ch === 5760 || + (ch >= 8192 && ch <= 8203) || + ch === 8239 || + ch === 8287 || + ch === 12288 || + ch === 65279 + ); +} + +/** How a file's JSX is emitted, after its pragmas. */ +export type JsxEmitPlan = + | { + runtime: "classic"; + /** The factory call (`h`, `React.createElement`). */ + factory: string; + /** The fragment tag (`Fragment`, `React.Fragment`). */ + fragment: string; + } + | { + runtime: "automatic"; + /** The module `jsx-runtime` (or `jsx-dev-runtime`) is under, and that + * a `createElement` fallback imports from (`react`). */ + importSource: string; + /** jsx: react-jsxdev: `jsxDEV` calls with source locations. */ + development: boolean; + }; + +/** The plan of a file: the automatic runtime with jsx: react-jsx or + * react-jsxdev, an import source or an `@jsxRuntime automatic` pragma (an + * `@jsxRuntime classic` pragma overrides all of them), the classic runtime + * otherwise. */ +export function jsxEmitPlan(options: JsxOptions, pragmas: JsxPragmas): JsxEmitPlan { + const mode = jsxEmitName(options.jsx); + const automatic = + pragmas.jsxRuntime !== "classic" && + (mode === "react-jsx" || + mode === "react-jsxdev" || + options.jsxImportSource !== undefined || + pragmas.jsxImportSource !== undefined || + pragmas.jsxRuntime === "automatic"); + if (automatic) { + return { + runtime: "automatic", + importSource: pragmas.jsxImportSource ?? options.jsxImportSource ?? "react", + development: mode === "react-jsxdev", + }; + } + const namespace = options.reactNamespace ?? "React"; + return { + runtime: "classic", + factory: pragmas.jsx ?? options.jsxFactory ?? `${namespace}.createElement`, + fragment: pragmas.jsxFrag ?? options.jsxFragmentFactory ?? `${namespace}.Fragment`, + }; +} + +/** True when the file contains a JSX expression. */ +export function containsJsx(sf: ts.SourceFile): boolean { + let found = false; + const visit = (node: ts.Node): void => { + if (found) return; + if (isJsxExpressionRoot(node)) { + found = true; + return; + } + ts.forEachChild(node, visit); + }; + visit(sf); + return found; +} + +/** The first JSX expression of the file (for diagnostics), or null. */ +export function firstJsx(sf: ts.SourceFile): ts.Node | null { + let found: ts.Node | null = null; + const visit = (node: ts.Node): void => { + if (found !== null) return; + if (isJsxExpressionRoot(node)) { + found = node; + return; + } + ts.forEachChild(node, visit); + }; + visit(sf); + return found; +} + +type JsxRoot = ts.JsxElement | ts.JsxSelfClosingElement | ts.JsxFragment; + +function isJsxExpressionRoot(node: ts.Node): node is JsxRoot { + return ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node) || ts.isJsxFragment(node); +} + +/** A file's text with its JSX lowered, and the way back from a position of + * that text to the source position it stands for. */ +export interface LoweredJsx { + text: string; + /** A rewritten-text offset as an offset of the original text: copied text + * keeps its offset; emitted call text maps to the JSX it stands for. */ + originalPosition(pos: number): number; + /** An original-text offset in the rewritten text: copied text keeps its + * offset; a position inside replaced JSX maps to the call text emitted + * for the JSX at or before it (its end, for the `end` of a span). */ + rewrittenPosition(pos: number, end: boolean): number; +} + +/** The file's text with its JSX replaced by the calls TypeScript emits for + * the plan, and for the automatic runtime the imports of the runtime + * functions those calls use. */ +export function lowerJsx(sf: ts.SourceFile, plan: JsxEmitPlan): LoweredJsx { + return new JsxRewriter(sf, plan).file(); +} + +/** A run of rewritten text: `copied` text starts at `original`; emitted + * text stands for the source position `original`. */ +interface Segment { + rewritten: number; + original: number; + /** The copied length, 0 for emitted text. */ + copied: number; +} + +class JsxRewriter { + private readonly text: string; + /** Output pieces; `cursor` is the source position whose line breaks the + * output has reached. */ + private readonly pieces: string[] = []; + private readonly segments: Segment[] = []; + private length = 0; + private cursor = 0; + + constructor( + private readonly sf: ts.SourceFile, + private readonly plan: JsxEmitPlan, + ) { + this.text = sf.text; + } + + file(): LoweredJsx { + const insertAt = this.plan.runtime === "automatic" ? this.prologueEnd() : -1; + this.copy(0, this.text.length); + if (insertAt >= 0) this.insertImports(insertAt); + const segments = this.segments; + const total = this.length; + return { + text: this.pieces.join(""), + originalPosition: (pos: number): number => { + let low = 0; + let high = segments.length - 1; + while (low < high) { + const mid = (low + high + 1) >> 1; + if (segments[mid]!.rewritten <= pos) low = mid; + else high = mid - 1; + } + const segment = segments[low]; + if (segment === undefined) return pos; + return segment.copied > 0 + ? segment.original + Math.min(pos - segment.rewritten, segment.copied) + : segment.original; + }, + rewrittenPosition: (pos: number, end: boolean): number => { + // Segments are in source order: the last one starting at or before + // `pos` holds it, or is the emitted text for the JSX holding it. + let low = 0; + let high = segments.length - 1; + while (low < high) { + const mid = (low + high + 1) >> 1; + if (segments[mid]!.original <= pos) low = mid; + else high = mid - 1; + } + const segment = segments[low]; + if (segment === undefined) return pos; + if (segment.copied > 0) + return segment.rewritten + Math.min(pos - segment.original, segment.copied); + return end ? (segments[low + 1]?.rewritten ?? total) : segment.rewritten; + }, + }; + } + + /** Local names of the automatic runtime's functions, by module and + * export, in the order of first use (TypeScript's implicit imports). */ + private readonly imports = new Map>(); + private names: Set | null = null; + private fileNameLocal: string | null = null; + + /** The local name bound to `name` of `module`: `_name`, or `_name_1`, + * `_name_2`, ... past an identifier the file already uses. */ + private importName(name: string, module: string): string { + let names = this.imports.get(module); + if (names === undefined) { + names = new Map(); + this.imports.set(module, names); + } + let local = names.get(name); + if (local === undefined) { + local = this.uniqueName(`_${name}`); + names.set(name, local); + } + return local; + } + + private uniqueName(base: string): string { + if (this.names === null) { + const names = new Set(); + const visit = (node: ts.Node): void => { + if (ts.isIdentifier(node)) names.add(node.text); + ts.forEachChild(node, visit); + }; + visit(this.sf); + this.names = names; + } + let name = base; + for (let i = 1; this.names.has(name); i++) name = `${base}_${i}`; + this.names.add(name); + return name; + } + + /** Where the runtime imports go: after the leading "use strict"-style + * directives, else before the first statement, so the inserted text + * shares that statement's line. */ + private prologueEnd(): number { + const statements = this.sf.statements.nodes; + let end = -1; + for (const statement of statements) { + if (!ts.isExpressionStatement(statement) || !ts.isStringLiteral(statement.expression)) break; + end = statement.end; + } + if (end >= 0) return end; + const first = statements[0]; + return first === undefined ? this.text.length : first.getStart(this.sf); + } + + /** Inserts the imports (or, in a CommonJS file, the requires) of the + * runtime functions the file's JSX used, and react-jsxdev's file name + * constant, at `at`: imports in the reverse order of their modules' first + * use, as TypeScript inserts each after the prologue. */ + private insertImports(at: number): void { + if (this.imports.size === 0 && this.fileNameLocal === null) return; + const esm = ts.isExternalModule(this.sf); + const parts: string[] = []; + for (const [module, names] of [...this.imports].reverse()) { + const specifier = JSON.stringify(module); + if (esm) { + const list = [...names].map(([name, local]) => `${name} as ${local}`).join(", "); + parts.push(`import { ${list} } from ${specifier};`); + } else if (/\.[cm]?jsx?$/.test(this.sf.fileName)) { + const list = [...names].map(([name, local]) => `${name}: ${local}`).join(", "); + parts.push(`const { ${list} } = require(${specifier});`); + } + } + if (this.fileNameLocal !== null) + parts.push(`const ${this.fileNameLocal} = ${JSON.stringify(this.sf.fileName)};`); + if (parts.length === 0) return; + const text = `${parts.join(" ")} `; + let index = 0; + let rewritten = 0; + for (; index < this.segments.length; index++) { + const segment = this.segments[index]!; + if (segment.copied > 0 && segment.original <= at && at <= segment.original + segment.copied) { + rewritten = segment.rewritten + (at - segment.original); + break; + } + } + // Split the copied segment holding `at` and shift what follows. + const holder = this.segments[index]; + const joined = this.pieces.join(""); + this.pieces.length = 0; + this.pieces.push(joined.slice(0, rewritten), text, joined.slice(rewritten)); + const following: Segment[] = [{ rewritten, original: at, copied: 0 }]; + if (holder !== undefined && holder.copied > 0) { + const head = at - holder.original; + const tail = holder.copied - head; + holder.copied = head; + if (tail > 0) + following.push({ rewritten: rewritten + text.length, original: at, copied: tail }); + } + for (let i = index + 1; i < this.segments.length; i++) + this.segments[i]!.rewritten += text.length; + this.segments.splice(index + 1, 0, ...following); + if (holder !== undefined && holder.copied === 0) this.segments.splice(index, 1); + this.length += text.length; + } + + /** Emits source text [start, end) unchanged. */ + private copied(start: number, end: number): void { + if (end <= start) return; + this.segments.push({ rewritten: this.length, original: start, copied: end - start }); + this.pieces.push(this.text.slice(start, end)); + this.length += end - start; + } + + /** Emits call text standing for the source position the cursor reached. */ + private emit(...texts: string[]): void { + for (const text of texts) { + if (text.length === 0) continue; + const last = this.segments[this.segments.length - 1]; + if (last === undefined || last.copied > 0 || last.original !== this.cursor) + this.segments.push({ rewritten: this.length, original: this.cursor, copied: 0 }); + this.pieces.push(text); + this.length += text.length; + } + } + + /** Copies the source range [start, end), with its JSX expressions + * replaced. */ + private copy(start: number, end: number): void { + let at = start; + const visit = (node: ts.Node): void => { + if (node.end <= at || (node !== this.sf && node.getStart(this.sf) >= end)) return; + if (isJsxExpressionRoot(node)) { + const nodeStart = node.getStart(this.sf); + this.copied(at, nodeStart); + if (nodeStart > this.cursor) this.cursor = nodeStart; + this.element(node); + this.sync(node.end); + at = node.end; + return; + } + ts.forEachChild(node, visit); + }; + // The cursor never moves back: a range copied after source that follows + // it (jsx()'s key argument, after the children) emits no line break + // twice. + if (start > this.cursor) this.cursor = start; + visit(this.enclosing(start, end)); + this.copied(at, end); + if (end > this.cursor) this.cursor = end; + } + + /** The smallest node around [start, end) whose children cover it. */ + private enclosing(start: number, end: number): ts.Node { + let node: ts.Node = this.sf; + for (;;) { + let next: ts.Node | undefined; + ts.forEachChild(node, (child) => { + if (next === undefined && child.pos <= start && child.end >= end) next = child; + }); + if (next === undefined || next === node) return node; + node = next; + } + } + + /** Emits the line breaks of the source between the cursor and `pos`. */ + private sync(pos: number): void { + for (let i = this.cursor; i < pos; i++) { + const ch = this.text.charCodeAt(i); + if (ch === 13 && this.text.charCodeAt(i + 1) === 10) { + this.cursor = i; + this.emit("\r\n"); + i++; + } else if (isLineBreak(ch)) { + this.cursor = i; + this.emit(this.text[i]!); + } + } + if (pos > this.cursor) this.cursor = pos; + } + + /** Copies an expression in a JSX expression's place. */ + private expression(node: ts.Node): void { + const start = node.getStart(this.sf); + this.sync(start); + this.copy(start, node.end); + } + + private element(node: JsxRoot): void { + const plan = this.plan; + if (plan.runtime === "classic") { + this.createElement(node, plan.factory, plan.fragment); + return; + } + const opening = ts.isJsxFragment(node) + ? null + : ts.isJsxElement(node) + ? node.openingElement + : node; + if (opening !== null && hasKeyAfterPropsSpread(opening.attributes)) { + // A key after a spread of props is not jsx()'s key argument: the + // element is the import source's createElement call. + this.createElement(node, this.importName("createElement", plan.importSource), ""); + return; + } + this.automaticElement(node, opening, plan.importSource, plan.development); + } + + /** The classic-runtime call: `factory(tag, props or null, ...children)`. */ + private createElement(node: JsxRoot, factory: string, fragment: string): void { + const children = ts.isJsxSelfClosingElement(node) ? [] : node.children.nodes; + if (ts.isJsxFragment(node)) { + this.emit(`${factory}(${fragment}, null`); + } else { + const opening = ts.isJsxElement(node) ? node.openingElement : node; + this.emit(`${factory}(`); + this.tagName(opening.tagName); + this.emit(", "); + this.attributes(opening.attributes.properties.nodes, null); + } + for (const child of children) { + if (ts.isJsxText(child)) { + const value = jsxTextValue(child.text); + if (value === undefined) continue; + this.emit(", "); + this.sync(child.getStart(this.sf)); + this.emit(JSON.stringify(value)); + } else if (ts.isJsxExpression(child)) { + if (child.expression === undefined) continue; + this.emit(", "); + if (child.dotDotDotToken !== undefined) this.emit("..."); + this.expression(child.expression); + } else if (isJsxExpressionRoot(child)) { + this.emit(", "); + this.sync(child.getStart(this.sf)); + this.element(child); + } + this.sync(child.end); + } + this.sync(node.end); + this.emit(")"); + } + + /** The automatic-runtime call: `jsx(tag, props[, key])` with the + * children in props, `jsxs` for more than one child or a spread child, and + * react-jsxdev's `jsxDEV(tag, props, key, isStatic, source, self)`. */ + private automaticElement( + node: JsxRoot, + opening: ts.JsxOpeningElement | ts.JsxSelfClosingElement | null, + importSource: string, + development: boolean, + ): void { + const children: readonly ts.JsxChild[] = ts.isJsxSelfClosingElement(node) + ? [] + : node.children.nodes; + const semantic = children.filter(isSemanticJsxChild); + const first = semantic[0]; + const isStatic = + semantic.length > 1 || + (first !== undefined && ts.isJsxExpression(first) && first.dotDotDotToken !== undefined); + const module = `${importSource}/${development ? "jsx-dev-runtime" : "jsx-runtime"}`; + this.emit(`${this.importName(development ? "jsxDEV" : isStatic ? "jsxs" : "jsx", module)}(`); + // TypeScript's children prop: the one semantic child itself, else an + // array of every child that emits a value. + const single = semantic.length === 1 && !isStatic ? first! : null; + const listed = single === null ? children.filter((child) => jsxChildEmits(child)) : []; + const childrenProp = + children.length > 0 && (single !== null ? jsxChildEmits(single) : listed.length > 0) + ? (): void => { + this.emit("children: "); + if (single !== null) { + this.child(single); + } else { + this.emit("["); + listed.forEach((child, index) => { + if (index > 0) this.emit(", "); + this.child(child); + this.sync(child.end); + }); + this.emit("]"); + } + } + : null; + let key: ts.JsxAttribute | undefined; + if (opening === null) { + this.emit(this.importName("Fragment", module), ", "); + if (childrenProp === null) this.emit("{}"); + else this.attributes([], childrenProp); + } else { + this.tagName(opening.tagName); + this.emit(", "); + const properties = opening.attributes.properties.nodes; + key = properties.find( + (property): property is ts.JsxAttribute => + ts.isJsxAttribute(property) && + ts.isIdentifier(property.name) && + property.name.text === "key", + ); + const attributes = properties.filter((property) => property !== key); + if (attributes.length === 0 && childrenProp === null) this.emit("{}"); + else this.attributes(attributes, childrenProp); + } + if (key !== undefined) { + this.emit(", "); + this.attributeValue(key.initializer); + } + if (development) { + if (key === undefined) this.emit(", void 0"); + const { line, column } = lineAndColumn(this.text, node.pos); + this.fileNameLocal ??= this.uniqueName("_jsxFileName"); + this.emit( + `, ${isStatic}, { fileName: ${this.fileNameLocal}, lineNumber: ${line}, columnNumber: ${column} }, `, + jsxSelf(node), + ); + } + this.sync(node.end); + this.emit(")"); + } + + /** A child's value in the children prop (it emits one: jsxChildEmits). */ + private child(child: ts.JsxChild): void { + if (ts.isJsxText(child)) { + this.sync(child.getStart(this.sf)); + this.emit(JSON.stringify(jsxTextValue(child.text)!)); + } else if (ts.isJsxExpression(child)) { + if (child.dotDotDotToken !== undefined) this.emit("..."); + this.expression(child.expression!); + } else { + this.sync(child.getStart(this.sf)); + this.element(child as JsxRoot); + } + } + + private tagName(tag: ts.JsxTagNameExpression): void { + this.sync(tag.getStart(this.sf)); + if (ts.isIdentifier(tag) && isIntrinsicJsxName(tag.text)) { + this.emit(JSON.stringify(tag.text)); + } else if (ts.isJsxNamespacedName(tag)) { + this.emit(JSON.stringify(`${tag.namespace.text}:${tag.name.text}`)); + } else { + this.emit(this.text.slice(tag.getStart(this.sf), tag.end)); + } + this.cursor = tag.end; + } + + /** The props object of `properties`, then `children` (the automatic + * runtime's children prop), or `null` for no properties and no children + * prop. */ + private attributes( + properties: readonly ts.JsxAttributeLike[], + children: (() => void) | null, + ): void { + if (properties.length === 0 && children === null) { + this.emit("null"); + return; + } + if (properties.length === 0) { + this.emit("{ "); + children!(); + this.emit(" }"); + return; + } + this.emit("{ "); + let first = true; + const separate = (): void => { + if (!first) this.emit(", "); + first = false; + }; + for (const attribute of properties) { + if (ts.isJsxSpreadAttribute(attribute)) { + const value = attribute.expression; + if (ts.isObjectLiteralExpression(value) && !hasProtoProperty(value)) { + // TypeScript inlines the properties of a spread object literal. + for (const property of value.properties.nodes) { + separate(); + this.expression(property); + } + } else { + separate(); + this.emit("..."); + this.expression(value); + } + } else { + separate(); + this.sync(attribute.getStart(this.sf)); + this.emit(attributeName(attribute.name), ": "); + this.attributeValue(attribute.initializer); + } + this.sync(attribute.end); + } + if (children !== null) { + this.emit(", "); + children(); + } + this.emit(" }"); + } + + private attributeValue(value: ts.JsxAttributeValue | undefined): void { + if (value === undefined) { + this.emit("true"); + } else if (ts.isStringLiteral(value)) { + this.sync(value.getStart(this.sf)); + this.emit(JSON.stringify(decodeEntities(value.text))); + } else if (ts.isJsxExpression(value)) { + if (value.expression === undefined) this.emit("true"); + else this.expression(value.expression); + } else { + this.sync(value.getStart(this.sf)); + this.element(value as JsxRoot); + } + } +} + +/** A child TypeScript counts: an expression container with an expression, + * text that is not only white space spanning lines, or an element. */ +function isSemanticJsxChild(child: ts.JsxChild): boolean { + if (ts.isJsxExpression(child)) return child.expression !== undefined; + if (ts.isJsxText(child)) return !child.containsOnlyTriviaWhiteSpaces; + return true; +} + +/** True when the child emits a value (text that trims to nothing and empty + * expression containers emit none). */ +function jsxChildEmits(child: ts.JsxChild): boolean { + if (ts.isJsxText(child)) return jsxTextValue(child.text) !== undefined; + if (ts.isJsxExpression(child)) return child.expression !== undefined; + return true; +} + +/** A `key` attribute after a spread that is not an object literal free of + * spreads: TypeScript emits createElement for such an element. */ +function hasKeyAfterPropsSpread(attributes: ts.JsxAttributes): boolean { + let spread = false; + for (const property of attributes.properties.nodes) { + if ( + ts.isJsxSpreadAttribute(property) && + (!ts.isObjectLiteralExpression(property.expression) || + property.expression.properties.nodes.some((p: ts.ObjectLiteralElementLike) => + ts.isSpreadAssignment(p), + )) + ) { + spread = true; + } else if ( + spread && + ts.isJsxAttribute(property) && + ts.isIdentifier(property.name) && + property.name.text === "key" + ) { + return true; + } + } + return false; +} + +/** The 1-based line and column of `pos`, counting the line breaks + * TypeScript counts (\r\n, \n, \r, U+2028, U+2029) and UTF-16 units. */ +function lineAndColumn(text: string, pos: number): { line: number; column: number } { + let line = 1; + let start = 0; + for (let i = 0; i < pos; i++) { + const ch = text.charCodeAt(i); + if (ch === 13 && text.charCodeAt(i + 1) === 10) continue; + if (isLineBreak(ch)) { + line++; + start = i + 1; + } + } + return { line, column: pos - start + 1 }; +} + +/** react-jsxdev's `self` argument. TypeScript passes `this`; where `this` + * has no declared type (the top level of an ES module and a function that is + * not a method and declares no `this` parameter) the argument is the + * `undefined` such code observes when called without a receiver, since an + * untyped `this` does not type-check under noImplicitThis. */ +function jsxSelf(node: ts.Node): string { + for (let at = node.parent; at !== undefined; at = at.parent) { + if (ts.isArrowFunction(at)) continue; + if ( + ts.isMethodDeclaration(at) || + ts.isConstructorDeclaration(at) || + ts.isGetAccessorDeclaration(at) || + ts.isSetAccessorDeclaration(at) || + ts.isPropertyDeclaration(at) || + ts.isClassStaticBlockDeclaration(at) + ) + return "this"; + if (ts.isFunctionDeclaration(at) || ts.isFunctionExpression(at)) { + const declaresThis = at.parameters.nodes.some( + (parameter: ts.ParameterDeclaration) => + ts.isIdentifier(parameter.name) && parameter.name.text === "this", + ); + const objectMethod = + ts.isFunctionExpression(at) && + at.parent !== undefined && + ts.isPropertyAssignment(at.parent); + return declaresThis || objectMethod ? "this" : "undefined"; + } + if (ts.isSourceFile(at)) return ts.isExternalModule(at) ? "undefined" : "this"; + } + return "undefined"; +} + +/** TypeScript's intrinsic-element test: a lowercase first letter or a dash. */ +function isIntrinsicJsxName(name: string): boolean { + const ch = name.charCodeAt(0); + return (ch >= 97 && ch <= 122) || name.includes("-"); +} + +function attributeName(name: ts.JsxAttributeName): string { + if (ts.isJsxNamespacedName(name)) + return JSON.stringify(`${name.namespace.text}:${name.name.text}`); + return /^[A-Z_]\w*$/i.test(name.text) ? name.text : JSON.stringify(name.text); +} + +function hasProtoProperty(object: ts.ObjectLiteralExpression): boolean { + return object.properties.nodes.some( + (property: ts.ObjectLiteralElementLike) => + ts.isPropertyAssignment(property) && + ((ts.isIdentifier(property.name) && property.name.text === "__proto__") || + (ts.isStringLiteral(property.name) && property.name.text === "__proto__")), + ); +} + +/** A JSX text child's string value: each line trimmed (the first line keeps + * its leading and the last line its trailing white space), lines without + * text dropped, the rest joined with one space and entities decoded. + * Undefined when nothing remains. */ +export function jsxTextValue(text: string): string | undefined { + let value: string | undefined; + let firstNonWhitespace = 0; + let lastNonWhitespace = -1; + const add = (line: string): void => { + const decoded = decodeEntities(line); + value = value === undefined ? decoded : `${value} ${decoded}`; + }; + for (let i = 0; i < text.length; i++) { + const ch = text.charCodeAt(i); + if (isLineBreak(ch)) { + if (firstNonWhitespace !== -1 && lastNonWhitespace !== -1) + add(text.slice(firstNonWhitespace, lastNonWhitespace + 1)); + firstNonWhitespace = -1; + } else if (!isWhiteSpaceSingleLine(ch)) { + lastNonWhitespace = i; + if (firstNonWhitespace === -1) firstNonWhitespace = i; + } + } + if (firstNonWhitespace !== -1) add(text.slice(firstNonWhitespace)); + return value; +} + +/** Decodes `&name;`, `&#ddd;` and `&#xhh;` references. Unknown names and + * numbers past U+10FFFF stay as written. */ +export function decodeEntities(text: string): string { + return text.replace( + /&((#((\d+)|x([\da-fA-F]+)))|(\w+));/g, + ( + match: string, + _all: string | undefined, + _number: string | undefined, + _digits: string | undefined, + decimal: string | undefined, + hex: string | undefined, + word: string | undefined, + ) => { + const code = decimal + ? parseInt(decimal, 10) + : hex + ? parseInt(hex, 16) + : JSX_ENTITIES.get(word!); + return code === undefined || code > 0x10ffff ? match : String.fromCodePoint(code); + }, + ); +} diff --git a/packages/compiler/src/frontend/program.ts b/packages/compiler/src/frontend/program.ts index e398e59df..507d3392d 100644 --- a/packages/compiler/src/frontend/program.ts +++ b/packages/compiler/src/frontend/program.ts @@ -140,6 +140,15 @@ import { } from "./type-only-imports.js"; import { moduleSourceCandidates } from "./module-source-candidates.js"; import { inferredJsDiagnosticSuppressed } from "./inferred-js-diagnostics.js"; +import { + containsJsx, + firstJsx, + jsxEmitName, + jsxEmitPlan, + jsxPragmas, + lowerJsx, + type LoweredJsx, +} from "./jsx-source.js"; const BASE_OPTIONS: ts.Ts7CompilerOptions = { strict: true, @@ -377,6 +386,18 @@ export interface LoadResult { * checkPreflight. */ startupCrash?: StartupCrash | null; configDiags: ScrDiagnostic[]; + /** The files whose JSX the program lowers (jsx-source.ts), by file name. + * The program holds their rewritten text; positions in diagnostics refer + * to it. */ + jsxSources?: ReadonlyMap; + /** With JSX sources: the program over the original text, whose TypeScript + * errors are the program's, and its project world when it has errors. */ + tscWorld?: { + program: ts.Program; + /** The program's pre-emit diagnostics, computed once. */ + diagnostics: readonly ts.Diagnostic[]; + projectWorld: ts.Program | null; + }; /** How scriptc's type world differs from the project's own tsc setup — * used only to label the TypeScript errors those differences cause. */ typeWorld?: TypeWorldDifferences; @@ -778,6 +799,47 @@ function moduleSpecifierKind7(specifier: ts.StringLiteralLike): "import" | "requ : "import"; } +/** The program's files with JSX, lowered with the project's jsx settings + * and each file's pragmas, or the refusal of a setting that emits no calls. + * TypeScript files (.ts, .mts, .cts) cannot hold JSX; without a jsx setting + * the checker already rejects any JSX (TS17004). */ +function lowerProgramJsx7( + program: ts.Program, + options: ts.Ts7CompilerOptions, +): { sources: Map; refusal: ScrDiagnostic | null } { + const sources = new Map(); + const mode = jsxEmitName(options.jsx as string | number | undefined); + if (mode === undefined) return { sources, refusal: null }; + for (const sf of program.getImplementationSourceFiles()) { + if (sf.isDeclarationFile || /\.[mc]?ts$/.test(sf.fileName) || !containsJsx(sf)) continue; + const at = firstJsx(sf)!; + const loc = { file: sf.fileName, start: ts.tokenStartOfNode(at), end: at.end }; + if (mode === "preserve" || mode === "react-native") { + return { + sources, + refusal: { + code: "SC1090", + message: `JSX with "jsx": "${mode}" is not supported: that setting keeps JSX in the output instead of lowering it to calls`, + loc, + hint: 'set "jsx" to "react", "react-jsx" or "react-jsxdev" in the project tsconfig', + }, + }; + } + const plan = jsxEmitPlan( + { + jsx: mode, + jsxFactory: options.jsxFactory as string | undefined, + jsxFragmentFactory: options.jsxFragmentFactory as string | undefined, + jsxImportSource: options.jsxImportSource as string | undefined, + reactNamespace: options.reactNamespace as string | undefined, + }, + jsxPragmas(sf.text), + ); + sources.set(sf.fileName, lowerJsx(sf, plan)); + } + return { sources, refusal: null }; +} + function loadProgram7( host: ts.Ts7Host, entryPath: string, @@ -859,6 +921,26 @@ function loadProgram7( }; program = host.createProgram([...programRoots, overridesDtsPath()], options); } + // JSX: the program above checks the files as written; the program the + // lowering compiles holds them with their JSX lowered. + const jsx = lowerProgramJsx7(program, options); + let tscWorld: LoadResult["tscWorld"]; + if (jsx.refusal !== null) { + config.diags.push(jsx.refusal); + } else if (jsx.sources.size > 0) { + const original = program; + // The project world must read the original text too, so it is built + // before the rewritten files are served, and only when it is needed. + const diagnostics = ts.getPreEmitDiagnostics(original); + const errors = diagnostics.some((d) => d.category === ts.DiagnosticCategory.Error); + tscWorld = { + program: original, + diagnostics, + projectWorld: errors ? host.createProgram(programRoots, options) : null, + }; + for (const [file, lowered] of jsx.sources) host.addVirtualFile(file, lowered.text); + program = host.createProgram([...programRoots, overridesDtsPath()], options); + } const entry = program.getSourceFile(entryPath); if (!entry) throw new Error(`could not load ${entryPath}`); const externalTypeSpecifiersByFile = externalTypeFileClosure7(program, externalTypes); @@ -876,10 +958,14 @@ function loadProgram7( }, externalTypes, externalTypeSpecifiersByFile, + ...(tscWorld === undefined ? {} : { jsxSources: jsx.sources }), + ...(tscWorld === undefined ? {} : { tscWorld }), projectWorld: () => (projectWorld ??= host.createProgram(programRoots, options)), disposeAll: () => { try { projectWorld?.dispose(); + tscWorld?.projectWorld?.dispose(); + tscWorld?.program.dispose(); } finally { program.dispose(); } @@ -4665,8 +4751,8 @@ function preflight7(load: LoadResult): { const sf = p.getSourceFile(d.fileName); return sf !== undefined && isCheckedJsSourceFile(sf, projectCheckJs); }; - const errorsOf = (p: ts.Program): ts.Diagnostic[] => { - const all = ts.getPreEmitDiagnostics(p); + const errorsOf = (p: ts.Program): ts.Diagnostic[] => keptErrors(p, ts.getPreEmitDiagnostics(p)); + const keptErrors = (p: ts.Program, all: readonly ts.Diagnostic[]): ts.Diagnostic[] => { // First pass: every comment-side 2300's (file, name) — the partners // the second pass forgives. const commentDup = new Set(); @@ -4706,9 +4792,39 @@ function preflight7(load: LoadResult): { // instead (the SC1100 checked-cast family). Dirty there → the project- // world errors are the ones reported: they are reproducible with the // project's own tsc, which is what "fix type errors first" asks for. - const tscErrors = errorsOf(program); + // With JSX sources, the program over the original text answers the tsc + // gate; its positions move into the rewritten text the program holds. + // Errors only the rewritten text has come from the calls the JSX lowers + // to (a factory whose signature does not accept them). + const tscWorld = load.tscWorld; + const tscErrors = + tscWorld === undefined ? errorsOf(program) : keptErrors(tscWorld.program, tscWorld.diagnostics); if (tscErrors.length > 0) { - for (const d of errorsOf(load.projectWorld())) diags.push(toPassthrough(d)); + const world = + tscWorld === undefined ? load.projectWorld() : (tscWorld.projectWorld ?? tscWorld.program); + for (const d of errorsOf(world)) { + const diag = toPassthrough(d); + const lowered = tscWorld === undefined ? undefined : load.jsxSources?.get(diag.loc.file); + if (lowered !== undefined) { + diag.loc = { + ...diag.loc, + start: lowered.rewrittenPosition(diag.loc.start, false), + end: lowered.rewrittenPosition(diag.loc.end, true), + }; + } + diags.push(diag); + } + } else if (load.jsxSources !== undefined) { + for (const file of load.jsxSources.keys()) { + const sf = program.getSourceFile(file); + if (sf === undefined) continue; + const own = [...program.getSyntacticDiagnostics(sf), ...program.getSemanticDiagnostics(sf)]; + for (const d of keptErrors(program, own)) { + const diag = toPassthrough(d); + diag.message = `${diag.message} (in the call this JSX lowers to)`; + diags.push(diag); + } + } } // Preflight and lowering share this CheckerFacade. Claim executable diff --git a/packages/compiler/src/frontend/ts7/enums.generated.ts b/packages/compiler/src/frontend/ts7/enums.generated.ts index f21134bb6..4551ab428 100644 --- a/packages/compiler/src/frontend/ts7/enums.generated.ts +++ b/packages/compiler/src/frontend/ts7/enums.generated.ts @@ -1315,3 +1315,25 @@ export enum LanguageVariant { Standard = 0, JSX = 1 } + +export enum JsxEmit { + None = 0, + Preserve = 1, + ReactNative = 2, + React = 3, + ReactJSX = 4, + ReactJSXDev = 5 +} + +/** Numeric lookup with the SDK's aliases and undefined for unknown values. */ +export function jsxEmitName(value: number): string | undefined { + switch (value) { + case 0: return "None"; + case 1: return "Preserve"; + case 2: return "ReactNative"; + case 3: return "React"; + case 4: return "ReactJSX"; + case 5: return "ReactJSXDev"; + default: return undefined; + } +} diff --git a/packages/compiler/src/frontend/ts7/enums.ts b/packages/compiler/src/frontend/ts7/enums.ts index 6eba358f2..844643e80 100644 --- a/packages/compiler/src/frontend/ts7/enums.ts +++ b/packages/compiler/src/frontend/ts7/enums.ts @@ -1,4 +1,25 @@ /** Runtime enums generated from the pinned TypeScript 7 declarations. * Their nominal names and values match the SDK; TypeScript 5 remains a * separate world. No package loader runs on the compiler's native path. */ +import { jsxEmitName } from "./enums.generated.js"; + export * from "./enums.generated.js"; + +/** The tsconfig spelling of a `jsx` option value: "preserve", "react-native", + * "react", "react-jsx" or "react-jsxdev". */ +export function jsxOptionName(value: number): string | undefined { + switch (jsxEmitName(value)) { + case "Preserve": + return "preserve"; + case "ReactNative": + return "react-native"; + case "React": + return "react"; + case "ReactJSX": + return "react-jsx"; + case "ReactJSXDev": + return "react-jsxdev"; + default: + return undefined; + } +} diff --git a/packages/compiler/src/frontend/ts7/program-host.ts b/packages/compiler/src/frontend/ts7/program-host.ts index cc867d208..c87da0bfe 100644 --- a/packages/compiler/src/frontend/ts7/program-host.ts +++ b/packages/compiler/src/frontend/ts7/program-host.ts @@ -30,6 +30,7 @@ import type { } from "./session.js"; import { CheckerFacade } from "./checker.js"; import { + jsxOptionName, moduleDetectionKindName, moduleKindName, moduleResolutionKindName, @@ -82,6 +83,9 @@ function serializeOptions(options: Ts7CompilerOptions): Record case "moduleDetection": out[key] = moduleDetectionKindName(value as number)?.toLowerCase() ?? value; break; + case "jsx": + out[key] = typeof value === "number" ? (jsxOptionName(value) ?? value) : value; + break; case "lib": // 5.9.3 spells lib entries "lib.es2025.d.ts"; tsconfig wants "es2025". out[key] = (value as string[]).map((lib) => diff --git a/packages/compiler/src/frontend/tsc-codes.ts b/packages/compiler/src/frontend/tsc-codes.ts index fe48c8855..e6c0be7cd 100644 --- a/packages/compiler/src/frontend/tsc-codes.ts +++ b/packages/compiler/src/frontend/tsc-codes.ts @@ -27,6 +27,13 @@ export const ADOPTED_OPTIONS = [ // SC1012 "not supported yet" beats a raw TS1259 at the same site. "esModuleInterop", "allowSyntheticDefaultImports", + // JSX: the checker types JSX as the project's tsc does, and the JSX + // lowering (jsx-source.ts) emits the calls that setting selects. + "jsx", + "jsxFactory", + "jsxFragmentFactory", + "jsxImportSource", + "reactNamespace", ] as const; export const JS_RELAXED_TSC_CODES: ReadonlySet = new Set([ diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6822-jsx-classic-runtime/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6822-jsx-classic-runtime/main.ts.json new file mode 100644 index 000000000..9d97dc765 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6822-jsx-classic-runtime/main.ts.json @@ -0,0 +1,11 @@ +{ + "order": [ + "/tests/corpus/6822-jsx-classic-runtime/html.ts", + "/tests/corpus/6822-jsx-classic-runtime/list.jsx", + "/tests/corpus/6822-jsx-classic-runtime/page.tsx", + "/tests/corpus/6822-jsx-classic-runtime/factory.ts", + "/tests/corpus/6822-jsx-classic-runtime/pragma.tsx", + "/tests/corpus/6822-jsx-classic-runtime/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6824-jsx-automatic-runtime/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6824-jsx-automatic-runtime/main.ts.json new file mode 100644 index 000000000..95ba5cd15 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6824-jsx-automatic-runtime/main.ts.json @@ -0,0 +1,12 @@ +{ + "order": [ + "/tests/corpus/6824-jsx-automatic-runtime/runtime/jsx-runtime.ts", + "/tests/corpus/6824-jsx-automatic-runtime/alt/jsx-runtime.ts", + "/tests/corpus/6824-jsx-automatic-runtime/alt.tsx", + "/tests/corpus/6824-jsx-automatic-runtime/runtime/index.ts", + "/tests/corpus/6824-jsx-automatic-runtime/page.tsx", + "/tests/corpus/6824-jsx-automatic-runtime/render.ts", + "/tests/corpus/6824-jsx-automatic-runtime/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6825-jsx-automatic-development/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6825-jsx-automatic-development/main.ts.json new file mode 100644 index 000000000..649f0bdff --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6825-jsx-automatic-development/main.ts.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/6825-jsx-automatic-development/runtime/jsx-dev-runtime.ts", + "/tests/corpus/6825-jsx-automatic-development/view.tsx", + "/tests/corpus/6825-jsx-automatic-development/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/jsx-factory-mismatch/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/jsx-factory-mismatch/main.ts.json new file mode 100644 index 000000000..9552906dd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/jsx-factory-mismatch/main.ts.json @@ -0,0 +1,17 @@ +{ + "order": [ + "/tests/diagnostics/jsx-factory-mismatch/view.tsx", + "/tests/diagnostics/jsx-factory-mismatch/main.ts" + ], + "diags": [ + { + "code": "SC0001", + "message": "Argument of type 'number' is not assignable to parameter of type 'string'. (in the call this JSX lowers to)", + "loc": { + "file": "/tests/diagnostics/jsx-factory-mismatch/view.tsx", + "start": 337, + "end": 342 + } + } + ] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/jsx-preserve/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/jsx-preserve/main.ts.json new file mode 100644 index 000000000..eb5e492f4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/jsx-preserve/main.ts.json @@ -0,0 +1,18 @@ +{ + "order": [ + "/tests/diagnostics/jsx-preserve/view.tsx", + "/tests/diagnostics/jsx-preserve/main.ts" + ], + "diags": [ + { + "code": "SC1090", + "message": "JSX with \"jsx\": \"preserve\" is not supported: that setting keeps JSX in the output instead of lowering it to calls", + "loc": { + "file": "/tests/diagnostics/jsx-preserve/view.tsx", + "start": 158, + "end": 176 + }, + "hint": "set \"jsx\" to \"react\", \"react-jsx\" or \"react-jsxdev\" in the project tsconfig" + } + ] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/jsx-type-errors/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/jsx-type-errors/main.ts.json new file mode 100644 index 000000000..62a162ee2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/jsx-type-errors/main.ts.json @@ -0,0 +1,26 @@ +{ + "order": [ + "/tests/diagnostics/jsx-type-errors/view.tsx", + "/tests/diagnostics/jsx-type-errors/main.ts" + ], + "diags": [ + { + "code": "SC0001", + "message": "Type 'number' is not assignable to type 'string'.", + "loc": { + "file": "/tests/diagnostics/jsx-type-errors/view.tsx", + "start": 488, + "end": 495 + } + }, + { + "code": "SC0001", + "message": "Type 'string' is not assignable to type 'number'.", + "loc": { + "file": "/tests/diagnostics/jsx-type-errors/view.tsx", + "start": 520, + "end": 527 + } + } + ] +} diff --git a/scripts/generate-ts7-ast-schema.mjs b/scripts/generate-ts7-ast-schema.mjs index a1bc80117..07af474de 100644 --- a/scripts/generate-ts7-ast-schema.mjs +++ b/scripts/generate-ts7-ast-schema.mjs @@ -44,6 +44,7 @@ const enumNames = [ "ModuleDetectionKind", "OuterExpressionKinds", "LanguageVariant", + "JsxEmit", ]; const enumLines = [ "/* eslint-disable @typescript-eslint/no-duplicate-enum-values -- TypeScript aliases are part of the protocol. */", @@ -67,6 +68,7 @@ for (const name of enumNames) { "ModuleKind", "ModuleResolutionKind", "ModuleDetectionKind", + "JsxEmit", ].includes(name) ) { const values = require(join(packageRoot, "dist/enums", `${basename}.js`))[name]; diff --git a/tests/corpus/6822-jsx-classic-runtime/factory.ts b/tests/corpus/6822-jsx-classic-runtime/factory.ts new file mode 100644 index 000000000..df09c6dde --- /dev/null +++ b/tests/corpus/6822-jsx-classic-runtime/factory.ts @@ -0,0 +1,7 @@ +// A React-shaped factory for the pragma file: createElement and Fragment. +export const Fragment = "frag"; + +export function createElement(tag: string, props: object | null, ...children: unknown[]): string { + const inner = children.map((child) => String(child)).join(","); + return `${tag}${props === null ? "" : JSON.stringify(props)}(${inner})`; +} diff --git a/tests/corpus/6822-jsx-classic-runtime/html.ts b/tests/corpus/6822-jsx-classic-runtime/html.ts new file mode 100644 index 000000000..2e4beb5cc --- /dev/null +++ b/tests/corpus/6822-jsx-classic-runtime/html.ts @@ -0,0 +1,45 @@ +// A small server-side JSX runtime: h builds elements, render writes HTML. +export type Leaf = string | number | boolean | null | undefined | Element; +export type Child = Leaf | Leaf[]; +export type Props = { [name: string]: unknown }; +export type Component = (props: Props, children: Child[]) => Element; +export interface Element { + tag: string; + props: Props | null; + children: Child[]; +} + +export const Fragment = "#fragment"; + +export function h(tag: string | Component, props: Props | null, ...children: Child[]): Element { + if (typeof tag === "function") return tag(props ?? {}, children); + return { tag, props, children }; +} + +function escape(text: string): string { + return text.replace(/&/g, "&").replace(/${inner}`; +} + +declare global { + namespace JSX { + type Element = import("./html.js").Element; + interface IntrinsicElements { + [name: string]: object; + } + } +} diff --git a/tests/corpus/6822-jsx-classic-runtime/list.jsx b/tests/corpus/6822-jsx-classic-runtime/list.jsx new file mode 100644 index 000000000..d5aa3aee1 --- /dev/null +++ b/tests/corpus/6822-jsx-classic-runtime/list.jsx @@ -0,0 +1,22 @@ +/** @jsx tag */ +// JSX in a JavaScript module, with a JavaScript factory that builds strings. +function tag(name, props, ...children) { + const attributes = Object.entries(props ?? {}) + .map(([key, value]) => ` ${key}=${JSON.stringify(value)}`) + .join(""); + return `<${name}${attributes}>${children.flat().join("")}`; +} + +const names = ["a", "b"]; + +export function List() { + return ( +
      + {names.map((name, index) => ( +
    1. + {name.toUpperCase()} +
      2. + ))} +
    + ); +} diff --git a/tests/corpus/6822-jsx-classic-runtime/main.ts b/tests/corpus/6822-jsx-classic-runtime/main.ts new file mode 100644 index 000000000..4378557a0 --- /dev/null +++ b/tests/corpus/6822-jsx-classic-runtime/main.ts @@ -0,0 +1,15 @@ +// @tsc-jsx +// JSX in .tsx modules with the classic runtime: jsxFactory, jsxFragmentFactory and per-file pragmas. +import { render } from "./html.js"; +import { List } from "./list.js"; +import { Page } from "./page.js"; +import { viaPragma } from "./pragma.js"; + +const items = [ + { id: 1, name: "write ", done: true }, + { id: 2, name: "ship", done: false }, +]; +console.log(render(Page("Today", items))); +console.log(render(Page("Empty", []))); +console.log(viaPragma); +console.log(List()); diff --git a/tests/corpus/6822-jsx-classic-runtime/page.tsx b/tests/corpus/6822-jsx-classic-runtime/page.tsx new file mode 100644 index 000000000..c3fa6a03c --- /dev/null +++ b/tests/corpus/6822-jsx-classic-runtime/page.tsx @@ -0,0 +1,40 @@ +import { Fragment, h, type Child, type Props } from "./html.js"; + +const Ui = { + Badge(props: Props, children: Child[]) { + return {...children}; + }, +}; + +function Row(props: Props) { + const name = typeof props.name === "string" ? props.name : "?"; + const done = props.done === true; + return ( +
    • + ); +} + +export function Page(title: string, items: { id: number; name: string; done: boolean }[]) { + const extra = { lang: "en", dir: "ltr" }; + return ( + <> +

    {title}

    +
      + {items.map((item) => ( + + ))} +
    +

    + {items.filter((item) => item.done).length} of {items.length} done + multi word + badge +

    + + + <>nested {"fragment"} + + ); +} diff --git a/tests/corpus/6822-jsx-classic-runtime/pragma.tsx b/tests/corpus/6822-jsx-classic-runtime/pragma.tsx new file mode 100644 index 000000000..3aea8c330 --- /dev/null +++ b/tests/corpus/6822-jsx-classic-runtime/pragma.tsx @@ -0,0 +1,11 @@ +/** @jsx React.createElement */ +/** @jsxFrag React.Fragment */ +// The per-file pragmas select another factory than the tsconfig's. +import * as React from "./factory.js"; + +export const viaPragma = ( +
    + <>{1} + text +
    +); diff --git a/tests/corpus/6822-jsx-classic-runtime/tsconfig.json b/tests/corpus/6822-jsx-classic-runtime/tsconfig.json new file mode 100644 index 000000000..6ca523cf2 --- /dev/null +++ b/tests/corpus/6822-jsx-classic-runtime/tsconfig.json @@ -0,0 +1,9 @@ +{ + "compilerOptions": { + "strict": true, + "allowJs": true, + "jsx": "react", + "jsxFactory": "h", + "jsxFragmentFactory": "Fragment" + } +} diff --git a/tests/corpus/6824-jsx-automatic-runtime/alt.tsx b/tests/corpus/6824-jsx-automatic-runtime/alt.tsx new file mode 100644 index 000000000..a76d0ca72 --- /dev/null +++ b/tests/corpus/6824-jsx-automatic-runtime/alt.tsx @@ -0,0 +1,3 @@ +/** @jsxImportSource #alt */ +// This file's JSX uses the runtime the pragma names. +export const viaPragma = [one, {1}{2}, <>frag]; diff --git a/tests/corpus/6824-jsx-automatic-runtime/alt/jsx-runtime.ts b/tests/corpus/6824-jsx-automatic-runtime/alt/jsx-runtime.ts new file mode 100644 index 000000000..89b942ed2 --- /dev/null +++ b/tests/corpus/6824-jsx-automatic-runtime/alt/jsx-runtime.ts @@ -0,0 +1,17 @@ +// A second runtime, selected per file with @jsxImportSource. +export const Fragment = "alt-fragment"; + +export function jsx(type: string, props: { children?: unknown }): string { + return `${type}(${JSON.stringify(props.children ?? null)})`; +} + +export function jsxs(type: string, props: { children: unknown[] }): string { + return `${type}[${props.children.map((child) => JSON.stringify(child)).join(",")}]`; +} + +export namespace JSX { + export type Element = string; + export interface IntrinsicElements { + [name: string]: object; + } +} diff --git a/tests/corpus/6824-jsx-automatic-runtime/main.ts b/tests/corpus/6824-jsx-automatic-runtime/main.ts new file mode 100644 index 000000000..b25a4bc09 --- /dev/null +++ b/tests/corpus/6824-jsx-automatic-runtime/main.ts @@ -0,0 +1,10 @@ +// @tsc-jsx +// JSX with the automatic runtime: jsx/jsxs imports from jsxImportSource, keys, and per-file @jsxImportSource. +import { calls } from "#jsx/jsx-runtime"; +import { viaPragma } from "./alt.js"; +import { page } from "./page.js"; +import { render } from "./render.js"; + +console.log(render(page(["ada", "lin"]))); +console.log(calls.join(" ")); +console.log(viaPragma.join(" | ")); diff --git a/tests/corpus/6824-jsx-automatic-runtime/package.json b/tests/corpus/6824-jsx-automatic-runtime/package.json new file mode 100644 index 000000000..53f44dc61 --- /dev/null +++ b/tests/corpus/6824-jsx-automatic-runtime/package.json @@ -0,0 +1,8 @@ +{ + "type": "module", + "imports": { + "#jsx": "./runtime/index.ts", + "#jsx/jsx-runtime": "./runtime/jsx-runtime.ts", + "#alt/jsx-runtime": "./alt/jsx-runtime.ts" + } +} diff --git a/tests/corpus/6824-jsx-automatic-runtime/page.tsx b/tests/corpus/6824-jsx-automatic-runtime/page.tsx new file mode 100644 index 000000000..fe7fd8c0c --- /dev/null +++ b/tests/corpus/6824-jsx-automatic-runtime/page.tsx @@ -0,0 +1,33 @@ +import type { Props } from "#jsx/jsx-runtime"; + +function Card(props: Props) { + return ( +
    +

    {typeof props.title === "string" ? props.title : "?"}

    + {props.children} +
    + ); +} + +export function page(names: string[]) { + const extra = { id: "list", role: "list" }; + return ( + <> + +
      + {names.map((name, index) => ( +
    • + {name} +
      • + ))} +
    +     +

    fallback

    +

    + two {"children"} +

    +
    {...names}
    +
    + + ); +} diff --git a/tests/corpus/6824-jsx-automatic-runtime/render.ts b/tests/corpus/6824-jsx-automatic-runtime/render.ts new file mode 100644 index 000000000..6f5f1e3c9 --- /dev/null +++ b/tests/corpus/6824-jsx-automatic-runtime/render.ts @@ -0,0 +1,15 @@ +// Renders elements to HTML-like text. +import type { Element } from "#jsx/jsx-runtime"; + +export function render(value: unknown): string { + if (value === null || value === undefined || typeof value === "boolean") return ""; + if (typeof value === "string" || typeof value === "number") return String(value); + if (Array.isArray(value)) return value.map(render).join(""); + const element = value as Element; + const { children, ...rest } = element.props; + const inner = render(children); + if (element.type === "#fragment") return inner; + let attributes = element.key === undefined ? "" : ` key="${element.key}"`; + for (const [name, item] of Object.entries(rest)) attributes += ` ${name}=${JSON.stringify(item)}`; + return `<${element.type}${attributes}>${inner}`; +} diff --git a/tests/corpus/6824-jsx-automatic-runtime/runtime/index.ts b/tests/corpus/6824-jsx-automatic-runtime/runtime/index.ts new file mode 100644 index 000000000..c7809cdc0 --- /dev/null +++ b/tests/corpus/6824-jsx-automatic-runtime/runtime/index.ts @@ -0,0 +1,12 @@ +// The import source's createElement: TypeScript calls it for an element +// whose key follows a spread of props. +import { calls, type Element, type Props } from "./jsx-runtime.js"; + +export function createElement(type: string, props: Props | null, ...children: unknown[]): Element { + calls.push(`createElement:${type}`); + const all: Props = { ...props }; + if (children.length > 0) all["children"] = children.length === 1 ? children[0] : children; + const key = all["key"]; + delete all["key"]; + return { type, props: all, key: key === undefined ? undefined : String(key) }; +} diff --git a/tests/corpus/6824-jsx-automatic-runtime/runtime/jsx-runtime.ts b/tests/corpus/6824-jsx-automatic-runtime/runtime/jsx-runtime.ts new file mode 100644 index 000000000..185aafbd7 --- /dev/null +++ b/tests/corpus/6824-jsx-automatic-runtime/runtime/jsx-runtime.ts @@ -0,0 +1,33 @@ +// The automatic runtime: jsx, jsxs and Fragment, with children in props. +export type Props = { [name: string]: unknown }; +export interface Element { + type: string; + props: Props; + key: string | undefined; +} +export type Component = (props: Props) => Element; + +export const Fragment = "#fragment"; +export const calls: string[] = []; + +function element(kind: string, type: string | Component, props: Props, key?: unknown): Element { + const name = typeof type === "function" ? "component" : type; + calls.push(`${kind}:${name}${key === undefined ? "" : `#${String(key)}`}`); + if (typeof type === "function") return type(props); + return { type, props, key: key === undefined ? undefined : String(key) }; +} + +export function jsx(type: string | Component, props: Props, key?: unknown): Element { + return element("jsx", type, props, key); +} + +export function jsxs(type: string | Component, props: Props, key?: unknown): Element { + return element("jsxs", type, props, key); +} + +export namespace JSX { + export type Element = import("./jsx-runtime.js").Element; + export interface IntrinsicElements { + [name: string]: object; + } +} diff --git a/tests/corpus/6824-jsx-automatic-runtime/tsconfig.json b/tests/corpus/6824-jsx-automatic-runtime/tsconfig.json new file mode 100644 index 000000000..2e5b6aee7 --- /dev/null +++ b/tests/corpus/6824-jsx-automatic-runtime/tsconfig.json @@ -0,0 +1,8 @@ +{ + "compilerOptions": { + "strict": true, + "module": "nodenext", + "jsx": "react-jsx", + "jsxImportSource": "#jsx" + } +} diff --git a/tests/corpus/6825-jsx-automatic-development/main.ts b/tests/corpus/6825-jsx-automatic-development/main.ts new file mode 100644 index 000000000..9ff046128 --- /dev/null +++ b/tests/corpus/6825-jsx-automatic-development/main.ts @@ -0,0 +1,5 @@ +// @tsc-jsx +// JSX with react-jsxdev: jsxDEV gets the key, static children, the source position and `this`. +import { views } from "./view.js"; + +for (const view of views()) console.log(view); diff --git a/tests/corpus/6825-jsx-automatic-development/package.json b/tests/corpus/6825-jsx-automatic-development/package.json new file mode 100644 index 000000000..cbd76bd4f --- /dev/null +++ b/tests/corpus/6825-jsx-automatic-development/package.json @@ -0,0 +1,6 @@ +{ + "type": "module", + "imports": { + "#dev/jsx-dev-runtime": "./runtime/jsx-dev-runtime.ts" + } +} diff --git a/tests/corpus/6825-jsx-automatic-development/runtime/jsx-dev-runtime.ts b/tests/corpus/6825-jsx-automatic-development/runtime/jsx-dev-runtime.ts new file mode 100644 index 000000000..f4e3aea4b --- /dev/null +++ b/tests/corpus/6825-jsx-automatic-development/runtime/jsx-dev-runtime.ts @@ -0,0 +1,31 @@ +// The development runtime: jsxDEV receives the key, whether the children +// are static, the element's source position and the calling `this`. +export const Fragment = "#fragment"; + +interface Source { + fileName: string; + lineNumber: number; + columnNumber: number; +} + +export function jsxDEV( + type: string | ((props: { [name: string]: unknown }) => string), + props: { [name: string]: unknown }, + key: unknown, + isStatic: boolean, + source: Source, + self: unknown, +): string { + const file = source.fileName.slice(source.fileName.lastIndexOf("/") + 1); + const where = `${file}:${source.lineNumber}:${source.columnNumber}`; + const owner = self === undefined ? "none" : typeof self; + const name = typeof type === "function" ? type(props) : type; + return `${name}{key=${String(key)} static=${isStatic} at=${where} self=${owner}}`; +} + +export namespace JSX { + export type Element = string; + export interface IntrinsicElements { + [name: string]: object; + } +} diff --git a/tests/corpus/6825-jsx-automatic-development/tsconfig.json b/tests/corpus/6825-jsx-automatic-development/tsconfig.json new file mode 100644 index 000000000..e1e88d270 --- /dev/null +++ b/tests/corpus/6825-jsx-automatic-development/tsconfig.json @@ -0,0 +1,8 @@ +{ + "compilerOptions": { + "strict": true, + "module": "nodenext", + "jsx": "react-jsxdev", + "jsxImportSource": "#dev" + } +} diff --git a/tests/corpus/6825-jsx-automatic-development/view.tsx b/tests/corpus/6825-jsx-automatic-development/view.tsx new file mode 100644 index 000000000..05fdc7b32 --- /dev/null +++ b/tests/corpus/6825-jsx-automatic-development/view.tsx @@ -0,0 +1,21 @@ +function Leaf() { + return "leaf"; +} + +export class Panel { + title = "panel"; + render() { + return
    {1}{2}
    ; + } +} + +export function views(): string[] { + return [ +

    one

    , + , + <> + + , + new Panel().render(), + ]; +} diff --git a/tests/diagnostics/jsx-factory-mismatch/main.ts b/tests/diagnostics/jsx-factory-mismatch/main.ts new file mode 100644 index 000000000..47f9ff433 --- /dev/null +++ b/tests/diagnostics/jsx-factory-mismatch/main.ts @@ -0,0 +1,3 @@ +// The factory call a JSX element lowers to must type-check: h takes string children. +import { view } from "./view.js"; +console.log(view); diff --git a/tests/diagnostics/jsx-factory-mismatch/tsconfig.json b/tests/diagnostics/jsx-factory-mismatch/tsconfig.json new file mode 100644 index 000000000..4fcab4d21 --- /dev/null +++ b/tests/diagnostics/jsx-factory-mismatch/tsconfig.json @@ -0,0 +1 @@ +{ "compilerOptions": { "strict": true, "jsx": "react", "jsxFactory": "h" } } diff --git a/tests/diagnostics/jsx-factory-mismatch/view.tsx b/tests/diagnostics/jsx-factory-mismatch/view.tsx new file mode 100644 index 000000000..02bc0a95b --- /dev/null +++ b/tests/diagnostics/jsx-factory-mismatch/view.tsx @@ -0,0 +1,13 @@ +export function h(tag: string, props: object | null, ...children: string[]): string { + return `<${tag}>${children.join("")}`; +} +declare global { + namespace JSX { + type Element = string; + interface IntrinsicElements { + [name: string]: object; + } + } +} +const count = 3; +export const view =

    count: {count}

    ; diff --git a/tests/diagnostics/jsx-preserve/main.ts b/tests/diagnostics/jsx-preserve/main.ts new file mode 100644 index 000000000..1a5a8a0bc --- /dev/null +++ b/tests/diagnostics/jsx-preserve/main.ts @@ -0,0 +1,3 @@ +// "jsx": "preserve" emits JSX unchanged, so there is no call to compile. +import { view } from "./view.js"; +console.log(view); diff --git a/tests/diagnostics/jsx-preserve/tsconfig.json b/tests/diagnostics/jsx-preserve/tsconfig.json new file mode 100644 index 000000000..8bef9f7f4 --- /dev/null +++ b/tests/diagnostics/jsx-preserve/tsconfig.json @@ -0,0 +1 @@ +{ "compilerOptions": { "strict": true, "jsx": "preserve" } } diff --git a/tests/diagnostics/jsx-preserve/view.tsx b/tests/diagnostics/jsx-preserve/view.tsx new file mode 100644 index 000000000..48ce38147 --- /dev/null +++ b/tests/diagnostics/jsx-preserve/view.tsx @@ -0,0 +1,9 @@ +declare global { + namespace JSX { + type Element = string; + interface IntrinsicElements { + [name: string]: object; + } + } +} +export const view =

    kept as JSX

    ; diff --git a/tests/diagnostics/jsx-type-errors/main.ts b/tests/diagnostics/jsx-type-errors/main.ts new file mode 100644 index 000000000..00c4da53b --- /dev/null +++ b/tests/diagnostics/jsx-type-errors/main.ts @@ -0,0 +1,3 @@ +// TypeScript errors in JSX are reported with the positions of the file the program compiles. +import { view } from "./view.js"; +console.log(view); diff --git a/tests/diagnostics/jsx-type-errors/tsconfig.json b/tests/diagnostics/jsx-type-errors/tsconfig.json new file mode 100644 index 000000000..4fcab4d21 --- /dev/null +++ b/tests/diagnostics/jsx-type-errors/tsconfig.json @@ -0,0 +1 @@ +{ "compilerOptions": { "strict": true, "jsx": "react", "jsxFactory": "h" } } diff --git a/tests/diagnostics/jsx-type-errors/view.tsx b/tests/diagnostics/jsx-type-errors/view.tsx new file mode 100644 index 000000000..8a9be99ba --- /dev/null +++ b/tests/diagnostics/jsx-type-errors/view.tsx @@ -0,0 +1,15 @@ +export function h(tag: string | ((props: { count: number }) => string), props: object | null, ...children: string[]): string { + return typeof tag === "string" ? `<${tag}>${children.join("")}` : tag(props as { count: number }); +} +declare global { + namespace JSX { + type Element = string; + interface IntrinsicElements { + p: { title?: string }; + } + } +} +function Count(props: { count: number }): string { + return String(props.count); +} +export const view =

    text

    ; diff --git a/tests/harness/__snapshots__/jsx-factory-mismatch/main.ts.txt b/tests/harness/__snapshots__/jsx-factory-mismatch/main.ts.txt new file mode 100644 index 000000000..e0a19b654 --- /dev/null +++ b/tests/harness/__snapshots__/jsx-factory-mismatch/main.ts.txt @@ -0,0 +1,6 @@ +jsx-factory-mismatch/view.tsx:13:45 - error SC0001: Argument of type 'number' is not assignable to parameter of type 'string'. (in the call this JSX lowers to) + + 12 | const count = 3; + 13 | export const view = h("p", null, "count: ", count); + | ^~~~~ + 14 | \ No newline at end of file diff --git a/tests/harness/__snapshots__/jsx-preserve/main.ts.txt b/tests/harness/__snapshots__/jsx-preserve/main.ts.txt new file mode 100644 index 000000000..9e0239088 --- /dev/null +++ b/tests/harness/__snapshots__/jsx-preserve/main.ts.txt @@ -0,0 +1,8 @@ +jsx-preserve/view.tsx:9:21 - error SC1090: JSX with "jsx": "preserve" is not supported: that setting keeps JSX in the output instead of lowering it to calls + + 8 | } + 9 | export const view =

    kept as JSX

    ; + | ^~~~~~~~~~~~~~~~~~ + 10 | + + hint: set "jsx" to "react", "react-jsx" or "react-jsxdev" in the project tsconfig \ No newline at end of file diff --git a/tests/harness/__snapshots__/jsx-type-errors/main.ts.txt b/tests/harness/__snapshots__/jsx-type-errors/main.ts.txt new file mode 100644 index 000000000..c87c719a8 --- /dev/null +++ b/tests/harness/__snapshots__/jsx-type-errors/main.ts.txt @@ -0,0 +1,13 @@ +jsx-type-errors/view.tsx:15:30 - error SC0001: Type 'number' is not assignable to type 'string'. + + 14 | } + 15 | export const view = h("p", { title: 1 }, "text ", h(Count, { count: "two" })); + | ^~~~~~~ + 16 | + +jsx-type-errors/view.tsx:15:62 - error SC0001: Type 'string' is not assignable to type 'number'. + + 14 | } + 15 | export const view = h("p", { title: 1 }, "text ", h(Count, { count: "two" })); + | ^~~~~~~ + 16 | \ No newline at end of file diff --git a/tests/harness/corpus-costs/6822-jsx-classic-runtime/main.ts.json b/tests/harness/corpus-costs/6822-jsx-classic-runtime/main.ts.json new file mode 100644 index 000000000..dbc0fa779 --- /dev/null +++ b/tests/harness/corpus-costs/6822-jsx-classic-runtime/main.ts.json @@ -0,0 +1 @@ +{ "plain": 3400, "san": 2900 } diff --git a/tests/harness/corpus-costs/6824-jsx-automatic-runtime/main.ts.json b/tests/harness/corpus-costs/6824-jsx-automatic-runtime/main.ts.json new file mode 100644 index 000000000..2a685047e --- /dev/null +++ b/tests/harness/corpus-costs/6824-jsx-automatic-runtime/main.ts.json @@ -0,0 +1 @@ +{ "plain": 3600, "san": 3000 } diff --git a/tests/harness/corpus-costs/6825-jsx-automatic-development/main.ts.json b/tests/harness/corpus-costs/6825-jsx-automatic-development/main.ts.json new file mode 100644 index 000000000..79e32d960 --- /dev/null +++ b/tests/harness/corpus-costs/6825-jsx-automatic-development/main.ts.json @@ -0,0 +1 @@ +{ "plain": 3000, "san": 2500 } diff --git a/tests/harness/differential.test.ts b/tests/harness/differential.test.ts index b70e59c86..905f648dd 100644 --- a/tests/harness/differential.test.ts +++ b/tests/harness/differential.test.ts @@ -23,6 +23,7 @@ import ts5 from "typescript"; import { compile } from "@scriptc/compiler"; import { corpusSelect, shardSuffix } from "./shard.js"; import { oracleEnvKey } from "./oracle-env.js"; +import { tscJsxOracleEntry, wantsTscJsx } from "./jsx-oracle.js"; const execFileAsync = promisify(execFile); const repoRoot = join(import.meta.dirname, "../.."); @@ -122,6 +123,7 @@ function wantsTscDecorators(file: string): boolean { * test cache — a pure function of the program bytes and the typescript * version (both in the oracle cache key). */ function nodeOracleFile(file: string): string { + if (wantsTscJsx(directiveHead(file))) return tscJsxOracleEntry(file, cacheDir); if (!wantsTscDecorators(file)) return file; const src = readFileSync(file, "utf8"); const out = ts5.transpileModule(src, { @@ -241,7 +243,7 @@ const comptimeShim = pathToFileURL(join(import.meta.dirname, "comptime-shim.mjs" function programInputs(file: string): string[] { if (!/\/main\.(ts|js|mjs|cjs)$/.test(file)) return [file]; return [ - ...ENTRY_EXTS.flatMap((ext) => globSync(join(file, `../**/*.${ext}`))), + ...[...ENTRY_EXTS, "tsx", "jsx"].flatMap((ext) => globSync(join(file, `../**/*.${ext}`))), ...globSync(join(file, "../**/tsconfig.json")), ...globSync(join(file, "../**/package.json")), ].sort(); diff --git a/tests/harness/jsx-oracle.ts b/tests/harness/jsx-oracle.ts new file mode 100644 index 000000000..ba7a49946 --- /dev/null +++ b/tests/harness/jsx-oracle.ts @@ -0,0 +1,120 @@ +import { createHash } from "node:crypto"; +import { + copyFileSync, + existsSync, + mkdirSync, + readFileSync, + readdirSync, + renameSync, + rmSync, + writeFileSync, +} from "node:fs"; +import { dirname, join, relative } from "node:path"; +import ts5 from "typescript"; + +/** `// @tsc-jsx` in a directory program's main.ts head: Node cannot run + * .tsx or .jsx modules, so the oracle runs TypeScript's own emit of the + * program. Every .ts, .tsx, .js and .jsx file of the directory is transpiled + * (target ES2022, ES modules) with the jsx options of the directory's + * tsconfig.json, .ts, .tsx and .jsx files becoming .js, and package.json import + * and export targets renamed alike; other files are copied. + * The result lives in a directory under the test cache keyed by the program + * bytes and the typescript version. */ +export function wantsTscJsx(head: readonly string[]): boolean { + return head.some((line) => /^\/\/ @tsc-jsx\s*$/.test(line)); +} + +/** The oracle entry (`main.js` of the transpiled program) for `file`. */ +export function tscJsxOracleEntry(file: string, cacheDir: string): string { + const root = dirname(file); + const files = listFiles(root); + const hash = createHash("sha256").update(ts5.version); + for (const path of files) + hash.update("\0").update(relative(root, path)).update("\0").update(readFileSync(path)); + const dir = join(cacheDir, `jsx-oracle-${hash.digest("hex").slice(0, 16)}`); + const entry = join(dir, "main.js"); + if (existsSync(entry)) return entry; + const configPath = join(root, "tsconfig.json"); + const config = existsSync(configPath) + ? ts5.parseJsonConfigFileContent( + ts5.readConfigFile(configPath, ts5.sys.readFile).config ?? {}, + ts5.sys, + root, + ).options + : {}; + const compilerOptions: ts5.CompilerOptions = { + target: ts5.ScriptTarget.ES2022, + module: ts5.ModuleKind.ESNext, + jsx: config.jsx, + jsxFactory: config.jsxFactory, + jsxFragmentFactory: config.jsxFragmentFactory, + jsxImportSource: config.jsxImportSource, + reactNamespace: config.reactNamespace, + }; + // Atomic publish: build beside the final directory, then rename it into + // place; a concurrent suite that wins the rename leaves the same content. + const staging = `${dir}.${process.pid}.tmp`; + rmSync(staging, { recursive: true, force: true }); + for (const path of files) { + const target = join(staging, relative(root, path)); + mkdirSync(dirname(target), { recursive: true }); + if (/\.(?:[cm]?ts|tsx|jsx?|[cm]js)$/.test(path) && !/\.d\.[cm]?ts$/.test(path)) { + const output = ts5.transpileModule(readFileSync(path, "utf8"), { + compilerOptions, + fileName: path, + }).outputText; + writeFileSync( + target + .replace(/\.(?:ts|tsx|jsx)$/, ".js") + .replace(/\.mts$/, ".mjs") + .replace(/\.cts$/, ".cjs"), + output, + ); + } else if (/(^|\/)package\.json$/.test(path)) { + // Import and export targets follow their files: .ts, .tsx and .jsx + // become .js. + const renamed = (value: unknown): unknown => + typeof value === "string" + ? /\.d\.[cm]?ts$/.test(value) + ? value + : value + .replace(/\.(?:ts|tsx|jsx)$/, ".js") + .replace(/\.mts$/, ".mjs") + .replace(/\.cts$/, ".cjs") + : Array.isArray(value) + ? value.map(renamed) + : value !== null && typeof value === "object" + ? Object.fromEntries(Object.entries(value).map(([key, item]) => [key, renamed(item)])) + : value; + writeFileSync( + target, + `${JSON.stringify(renamed(JSON.parse(readFileSync(path, "utf8"))), null, 2)}\n`, + ); + } else { + copyFileSync(path, target); + } + } + if (!existsSync(join(staging, "package.json"))) + writeFileSync(join(staging, "package.json"), '{ "type": "module" }\n'); + try { + renameSync(staging, dir); + } catch { + rmSync(staging, { recursive: true, force: true }); + } + return entry; +} + +function listFiles(root: string): string[] { + const out: string[] = []; + const visit = (dir: string): void => { + for (const entry of readdirSync(dir, { withFileTypes: true }).sort((a, b) => + a.name < b.name ? -1 : a.name > b.name ? 1 : 0, + )) { + const path = join(dir, entry.name); + if (entry.isDirectory()) visit(path); + else if (entry.isFile()) out.push(path); + } + }; + visit(root); + return out; +} diff --git a/tests/harness/linux-differential.test.ts b/tests/harness/linux-differential.test.ts index 9730623cd..9da5199d3 100644 --- a/tests/harness/linux-differential.test.ts +++ b/tests/harness/linux-differential.test.ts @@ -9,6 +9,7 @@ import { compile } from "@scriptc/compiler"; import { npmCases } from "./npm-cases.js"; import { normalizeNodeTestOutput } from "./node-test-normalize.js"; import { eventLoopCases, type StdinScript } from "./event-loop-cases.js"; +import { tscJsxOracleEntry, wantsTscJsx } from "./jsx-oracle.js"; const execFileAsync = promisify(execFile); const enabled = process.env["SCRIPTC_LINUX"] === "1"; @@ -55,6 +56,7 @@ function wantsTscDecorators(file: string): boolean { * programs) its deterministic ES2022 downlevel — differential.test.ts's * nodeOracleFile, with the identical transform and cache key. */ function nodeOracleFile(file: string): string { + if (wantsTscJsx(directiveHead(file))) return tscJsxOracleEntry(file, cacheDir); if (!wantsTscDecorators(file)) return file; const src = readFileSync(file, "utf8"); const out = ts5.transpileModule(src, { @@ -212,7 +214,7 @@ async function runLinuxNode(file: string): Promise { function programInputs(file: string): string[] { if (!/\/main\.(ts|js|mjs|cjs)$/.test(file)) return [file]; return [ - ...ENTRY_EXTS.flatMap((ext) => globSync(join(file, `../**/*.${ext}`))), + ...[...ENTRY_EXTS, "tsx", "jsx"].flatMap((ext) => globSync(join(file, `../**/*.${ext}`))), ...globSync(join(file, "../**/tsconfig.json")), ...globSync(join(file, "../**/package.json")), ].sort(); diff --git a/tests/harness/llvm-differential.test.ts b/tests/harness/llvm-differential.test.ts index 792fdb1d2..15b7e7c0e 100644 --- a/tests/harness/llvm-differential.test.ts +++ b/tests/harness/llvm-differential.test.ts @@ -11,6 +11,7 @@ import { describe, expect, test } from "vitest"; import ts5 from "typescript"; import { compile } from "@scriptc/compiler"; import { corpusSelect, shardSuffix } from "./shard.js"; +import { tscJsxOracleEntry, wantsTscJsx } from "./jsx-oracle.js"; const execFileAsync = promisify(execFile); const repoRoot = join(import.meta.dirname, "../.."); @@ -120,6 +121,7 @@ function wantsTscDecorators(file: string): boolean { } function nodeOracleFile(file: string): string { + if (wantsTscJsx(directiveHead(file))) return tscJsxOracleEntry(file, cacheDir); if (!wantsTscDecorators(file)) return file; const src = readFileSync(file, "utf8"); const out = ts5.transpileModule(src, { @@ -165,7 +167,7 @@ function nodeOracleArgs(file: string): string[] { function programInputs(file: string): string[] { if (!/\/main\.(ts|js|mjs|cjs)$/.test(file)) return [file]; return [ - ...ENTRY_EXTS.flatMap((ext) => globSync(join(file, `../**/*.${ext}`))), + ...[...ENTRY_EXTS, "tsx", "jsx"].flatMap((ext) => globSync(join(file, `../**/*.${ext}`))), ...globSync(join(file, "../**/tsconfig.json")), ...globSync(join(file, "../**/package.json")), ].sort(); diff --git a/tests/harness/windows-differential.test.ts b/tests/harness/windows-differential.test.ts index 366820420..8d25d9b07 100644 --- a/tests/harness/windows-differential.test.ts +++ b/tests/harness/windows-differential.test.ts @@ -47,11 +47,12 @@ import { writeFileSync, } from "node:fs"; import { tmpdir } from "node:os"; -import { basename, join } from "node:path"; +import { basename, dirname, join } from "node:path"; import { promisify } from "node:util"; import { afterAll, beforeAll, describe, expect, test } from "vitest"; import ts5 from "typescript"; import { compile } from "@scriptc/compiler"; +import { tscJsxOracleEntry, wantsTscJsx } from "./jsx-oracle.js"; const execFileAsync = promisify(execFile); const enabled = process.env["SCRIPTC_WIN"] === "1"; @@ -343,11 +344,13 @@ async function scpToLane(paths: string[]): Promise { * type-strips .ts natively (same pinned version as the macOS lanes). */ async function runWindowsNode(file: string): Promise { const name = laneName(file); - const entry = wantsTscDecorators(file) - ? decOracleName(file) - : name === basename(file) - ? name - : `${name}\\${basename(file)}`; + const entry = wantsTscJsx(directiveHead(file)) + ? `${basename(dirname(tscJsxOracleEntry(file, cacheDir)))}\\main.js` + : wantsTscDecorators(file) + ? decOracleName(file) + : name === basename(file) + ? name + : `${name}\\${basename(file)}`; const transform = wantsTransformTypes(file) ? "--experimental-transform-types --disable-warning=ExperimentalWarning " : ""; @@ -366,7 +369,7 @@ async function runWindowsNode(file: string): Promise { function programInputs(file: string): string[] { if (!/\/main\.(ts|js|mjs|cjs)$/.test(file)) return [file]; return [ - ...ENTRY_EXTS.flatMap((ext) => globSync(join(file, `../**/*.${ext}`))), + ...[...ENTRY_EXTS, "tsx", "jsx"].flatMap((ext) => globSync(join(file, `../**/*.${ext}`))), ...globSync(join(file, "../**/tsconfig.json")), ...globSync(join(file, "../**/package.json")), ].sort(); @@ -403,7 +406,11 @@ async function shipProgram(file: string): Promise { const programRoot = /\/main\.(ts|js|mjs|cjs)$/.test(file) ? join(file, "..") : file; // Decorator programs additionally ship the tsc downlevel the oracle // executes (the compiler still eats the real source above). - const oracleExtra = wantsTscDecorators(file) ? [decOraclePath(file)] : []; + const oracleExtra = wantsTscJsx(directiveHead(file)) + ? [dirname(tscJsxOracleEntry(file, cacheDir))] + : wantsTscDecorators(file) + ? [decOraclePath(file)] + : []; await scpToLane([binary, programRoot, ...oracleExtra]); } From cab2db4f96f3205f35326e069a68bfc6df589953 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 04:27:50 -0500 Subject: [PATCH 053/102] Drop the Cipheriv stream fence from the node-types fixture --- tests/fixtures/node-types/fenced.ts | 4 -- .../__snapshots__/node-types-fenced.txt | 41 ++++++++----------- 2 files changed, 16 insertions(+), 29 deletions(-) diff --git a/tests/fixtures/node-types/fenced.ts b/tests/fixtures/node-types/fenced.ts index dfd07d446..274d57272 100644 --- a/tests/fixtures/node-types/fenced.ts +++ b/tests/fixtures/node-types/fenced.ts @@ -93,10 +93,6 @@ void inspectReadableStream; import { callbackify } from "node:util"; const callbackified = callbackify(async (n: number) => n); void callbackified; -/* Cipheriv values support update(), final(), setAAD(), setAutoPadding(), - * getAuthTag(), and setAuthTag(); the stream.Transform members are fenced. */ -const cipherStream = createCipheriv("aes-128-cbc", Buffer.alloc(16), Buffer.alloc(16)); -cipherStream.on("data", () => {}); /* ECDH on a curve Node knows but the runtime does not implement, and * computeSecret(view, encoding), which answers a Buffer where @types/node * declares a string. */ diff --git a/tests/harness/__snapshots__/node-types-fenced.txt b/tests/harness/__snapshots__/node-types-fenced.txt index 2f1f8cb2e..3198db366 100644 --- a/tests/harness/__snapshots__/node-types-fenced.txt +++ b/tests/harness/__snapshots__/node-types-fenced.txt @@ -205,47 +205,38 @@ fenced.ts:94:23 - error SC2020: 'util.callbackify into a callback whose error pa hint: Node calls back with a null error on success; type the binding's callback as (err: NodeJS.ErrnoException | null, ...) => void -fenced.ts:99:1 - error SC2020: 'Cipheriv/Decipheriv.on' is part of the standard library types but has no scriptc lowering yet +fenced.ts:100:12 - error SC2020: 'crypto.createECDH with curve 'sect163k1'' is part of the standard library types but has no scriptc lowering yet - 98 | const cipherStream = createCipheriv("aes-128-cbc", Buffer.alloc(16), Buffer.alloc(16)); - 99 | cipherStream.on("data", () => {}); - | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - 100 | /* ECDH on a curve Node knows but the runtime does not implement, and - - hint: update(), final(), setAAD(), setAutoPadding(), getAuthTag(), and setAuthTag() are supported; cipher streams are not - -fenced.ts:104:12 - error SC2020: 'crypto.createECDH with curve 'sect163k1'' is part of the standard library types but has no scriptc lowering yet - - 103 | import { createECDH } from "node:crypto"; - 104 | createECDH("sect163k1"); + 99 | import { createECDH } from "node:crypto"; + 100 | createECDH("sect163k1"); | ^~~~~~~~~~~ - 105 | createECDH("prime256v1").computeSecret(Buffer.alloc(65), "hex"); + 101 | createECDH("prime256v1").computeSecret(Buffer.alloc(65), "hex"); hint: the supported curves are prime192v1, secp224r1, prime256v1, secp384r1, secp521r1, secp192k1, secp224k1, secp256k1, brainpoolP256r1, brainpoolP384r1, and brainpoolP512r1 -fenced.ts:105:1 - error SC2020: 'ECDH.computeSecret(key, encoding) with a Buffer or view key' is part of the standard library types but has no scriptc lowering yet +fenced.ts:101:1 - error SC2020: 'ECDH.computeSecret(key, encoding) with a Buffer or view key' is part of the standard library types but has no scriptc lowering yet - 104 | createECDH("sect163k1"); - 105 | createECDH("prime256v1").computeSecret(Buffer.alloc(65), "hex"); + 100 | createECDH("sect163k1"); + 101 | createECDH("prime256v1").computeSecret(Buffer.alloc(65), "hex"); | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - 106 | /* WebCrypto beyond the secret-key slice: @types/node declares the whole + 102 | /* WebCrypto beyond the secret-key slice: @types/node declares the whole hint: Node reads the second argument as the key's input encoding and answers a Buffer; pass the output encoding third: computeSecret(key, undefined, encoding) -fenced.ts:110:9 - error SC2020: 'crypto.subtle.wrapKey' is part of the standard library types but has no scriptc lowering yet +fenced.ts:106:9 - error SC2020: 'crypto.subtle.wrapKey' is part of the standard library types but has no scriptc lowering yet - 109 | async function wrapWithWebCrypto(key: import("node:crypto").webcrypto.CryptoKey): Promise { - 110 | await crypto.subtle.wrapKey("raw", key, key, "AES-KW"); + 105 | async function wrapWithWebCrypto(key: import("node:crypto").webcrypto.CryptoKey): Promise { + 106 | await crypto.subtle.wrapKey("raw", key, key, "AES-KW"); | ^~~~~~~~~~~~~~~~~~~~~ - 111 | } + 107 | } hint: the native WebCrypto surface is crypto.subtle's importKey, generateKey and exportKey for HMAC and AES keys (importKey also for PBKDF2 and HKDF keys), encrypt and decrypt with AES-GCM, AES-CBC or AES-CTR, deriveBits and deriveKey with PBKDF2 or HKDF, sign and verify with HMAC, and digest with SHA-1, SHA-256, SHA-384 or SHA-512, each called directly on crypto.subtle -fenced.ts:115:15 - error SC2020: 'navigator.hardwareConcurrency' is typed by @types/node but has no scriptc lowering yet +fenced.ts:111:15 - error SC2020: 'navigator.hardwareConcurrency' is typed by @types/node but has no scriptc lowering yet - 114 | * compile; the other members fence by name. */ - 115 | const cores = navigator.hardwareConcurrency; + 110 | * compile; the other members fence by name. */ + 111 | const cores = navigator.hardwareConcurrency; | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - 116 | void cores; + 112 | void cores; hint: of Node's navigator global only typeof navigator and navigator.userAgent compile \ No newline at end of file From b03e965bf99716c4f353053526fa6ab67182ceda Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 04:35:27 -0500 Subject: [PATCH 054/102] Resolve 7058's promises with undefined so both checkers agree --- tests/corpus/7058-pipeline-function-stages.mjs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/corpus/7058-pipeline-function-stages.mjs b/tests/corpus/7058-pipeline-function-stages.mjs index f0a61e7c2..f75abac39 100644 --- a/tests/corpus/7058-pipeline-function-stages.mjs +++ b/tests/corpus/7058-pipeline-function-stages.mjs @@ -60,7 +60,7 @@ await new Promise((resolve) => { }, (err, value) => { console.log("array source:", err ?? null, value); - resolve(); + resolve(undefined); }, ); }); @@ -114,7 +114,7 @@ function ticker(log) { await new Promise((resolve) => pipeline(["a", "b"], new PassThrough(), sink(log), () => { stop(); - resolve(); + resolve(undefined); }), ); console.log("array ticks:", log.join(" ")); @@ -134,7 +134,7 @@ function ticker(log) { sink(log), () => { stop(); - resolve(); + resolve(undefined); }, ), ); From feec4bf4df9734d23aa0c919429e5de42d902802 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 04:44:34 -0500 Subject: [PATCH 055/102] Call typed-array callbacks directly and visit on an integer counter The helpers of the typed-array callback methods (forEach, map, filter, some, every, find, findIndex, findLast, findLastIndex, reduce, reduceRight) called their callback through the closure's code pointer on every element, and one helper served every call with the same signature, so the callback was never inlined. A literal callback now gets a helper of its own, as for the array methods, and the constant-callback census accepts the typed-array helpers, so the helper calls that function directly. The visit is now a loop on its own counter, `for (let i = 0; i < a.length; i++)` or down from the last index, instead of a loop on a counter declared before it, so the counter is an integer and element reads need no index test. reduce and reduceRight without an initial value read their seed at the first visited index and start one past it. Adds reduce, some and map callbacks to the typed-array-kernels workload. --- benchmarks/runtime/README.md | 2 +- .../runtime/workloads/typed-array-kernels.ts | 11 +++ .../backend/llvm/constant-callbacks.test.ts | 23 +++-- .../src/backend/llvm/constant-callbacks.ts | 12 ++- .../lowering/containers/array-callbacks.ts | 2 +- .../src/frontend/lowering/containers/bytes.ts | 84 +++++++++++++---- .../test/bytes-callback-helpers.test.ts | 68 ++++++++++++++ .../6999-typed-array-callback-loops.ts.json | 6 ++ .../corpus/6999-typed-array-callback-loops.ts | 93 +++++++++++++++++++ .../6999-typed-array-callback-loops.ts.json | 1 + 10 files changed, 269 insertions(+), 33 deletions(-) create mode 100644 packages/compiler/test/bytes-callback-helpers.test.ts create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6999-typed-array-callback-loops.ts.json create mode 100644 tests/corpus/6999-typed-array-callback-loops.ts create mode 100644 tests/harness/corpus-costs/6999-typed-array-callback-loops.ts.json diff --git a/benchmarks/runtime/README.md b/benchmarks/runtime/README.md index cbf47675a..34baccf5b 100644 --- a/benchmarks/runtime/README.md +++ b/benchmarks/runtime/README.md @@ -26,7 +26,7 @@ Application-shaped workloads for measuring the speed of compiled executables. Ea | `region-builds` | cpu | a watch-mode build loop over `LifetimeRegion`: each build binds a program in a new region and releases the previous one, which a cache keeps referenced for two builds | | `template-render` | cpu | template literals, escaping, `map`/`join` | | `thread-slots`, `thread-slots-cache` | cpu | worker threads reading one published type graph from an `InternTable` and keeping per-thread state for each type they visit: a `ThreadSlots` family, or a direct-mapped cache by id in front of a `Map` by id (the `-cache` entry); under Node.js both are per thread | -| `typed-array-kernels` | cpu | element-wise loops that run to one typed array's length and index others at the same position: `Float64Array` axpy, `Float32Array` blend, `Uint8Array` mask, wrapping `Int32Array` add, `Uint8ClampedArray` brighten, RGBA to gray | +| `typed-array-kernels` | cpu | element-wise loops that run to one typed array's length and index others at the same position: `Float64Array` axpy, `Float32Array` blend, `Uint8Array` mask, wrapping `Int32Array` add, `Uint8ClampedArray` brighten, RGBA to gray, and `reduce`/`some`/`map` callbacks | | `typed-array-scan`, `typed-array-scan-workers` | cpu | element-by-element scan loops over `Uint8Array`, `Uint16Array`, `Int32Array` and `Float64Array`; the second entry is a worker-enabled executable (it can start a worker), so each access also checks for shared storage | | `unicode-lexer` | cpu | a hand-written lexer over a 2.7M-unit bundled module whose comments and strings are in several languages: `charCodeAt` scans, line starts | | `validate-errors` | cpu | throw/catch on a fraction of inputs, small call chains | diff --git a/benchmarks/runtime/workloads/typed-array-kernels.ts b/benchmarks/runtime/workloads/typed-array-kernels.ts index ba68f7241..d865ec914 100644 --- a/benchmarks/runtime/workloads/typed-array-kernels.ts +++ b/benchmarks/runtime/workloads/typed-array-kernels.ts @@ -21,6 +21,14 @@ function brighten(src: Uint8ClampedArray, gain: number, out: Uint8ClampedArray): for (let i = 0; i < out.length; i++) out[i] = src[i]! * gain + 8; } +// Callback methods over a whole typed array. +function callbacks(samples: Float32Array, limit: number, data: Uint8Array): number { + const energy = samples.reduce((sum, v) => sum + v * v, 0); + const loud = samples.some((v) => v > limit) ? 1 : 0; + const halved = data.map((v) => v >> 1); + return energy / samples.length + loud + halved[halved.length >> 1]!; +} + function gray(rgba: Uint8Array, out: Uint8Array): void { for (let i = 0; i < out.length; i++) { const j = i * 4; @@ -73,6 +81,7 @@ let byteSum = 0; let intSum = 0; let brightSum = 0; let lumaSum = 0; +let callbackSum = 0; for (let r = 0; r < rounds; r++) { // Change one input element per round so no round repeats the last. const at = (r * 7919) & (n - 1); @@ -88,6 +97,7 @@ for (let r = 0; r < rounds; r++) { addWrap(ia, ib, io); brighten(pixels, 0.75 + (r & 7) / 8, bright); gray(rgba, luma); + if ((r & 3) === 0) callbackSum += callbacks(fo, 140 + (r & 12), masked); const probe = (r * 104729) & (n - 1); f64Sum += d[probe]!; f32Sum += fo[probe]!; @@ -102,3 +112,4 @@ console.log(`uint8 ${byteSum}`); console.log(`int32 ${intSum}`); console.log(`clamped ${brightSum}`); console.log(`gray ${lumaSum}`); +console.log(`callbacks ${callbackSum.toFixed(3)}`); diff --git a/packages/compiler/src/backend/llvm/constant-callbacks.test.ts b/packages/compiler/src/backend/llvm/constant-callbacks.test.ts index aa491c711..e8ca5571f 100644 --- a/packages/compiler/src/backend/llvm/constant-callbacks.test.ts +++ b/packages/compiler/src/backend/llvm/constant-callbacks.test.ts @@ -314,16 +314,19 @@ test("virtual calls admit every same-named method", () => { expect(new AmbientReceiverReaders(functions).ignores(caller)).toBe(false); }); -test("synthetic array HOF helpers are constant-callback consumers", () => { - const mod = fixture(); - const consumer = mod.functions[1]!; - const entry = mod.functions[2]!; - delete consumer.ownsPrototype; - consumer.name = "%arr.some.0"; - const call = entry.body[0]!; - if (call.kind === "exprStmt" && call.expr.kind === "call") call.expr.callee = "%arr.some.0"; - expect(facts(mod).get("%arr.some.0")?.get("test")).toBe("predicate"); -}); +test.each(["%arr.some.0", "%bytes.some.0"])( + "synthetic array and typed-array HOF helpers are constant-callback consumers (%s)", + (name) => { + const mod = fixture(); + const consumer = mod.functions[1]!; + const entry = mod.functions[2]!; + delete consumer.ownsPrototype; + consumer.name = name; + const call = entry.body[0]!; + if (call.kind === "exprStmt" && call.expr.kind === "call") call.expr.callee = name; + expect(facts(mod).get(name)?.get("test")).toBe("predicate"); + }, +); function factory(name: string, returns: IrExpr[]): IrFunction { return { diff --git a/packages/compiler/src/backend/llvm/constant-callbacks.ts b/packages/compiler/src/backend/llvm/constant-callbacks.ts index 6e6155460..8a898d6a0 100644 --- a/packages/compiler/src/backend/llvm/constant-callbacks.ts +++ b/packages/compiler/src/backend/llvm/constant-callbacks.ts @@ -29,12 +29,16 @@ export function findConstantCallbacks( mod.functions .filter( (fn) => - // Authored declarations, plus the frontend's synthetic array - // HOF loops (`%arr..`): those are plain direct-call - // functions, and a literal callback gets a helper of its own. + // Authored declarations, plus the frontend's synthetic array and + // typed-array HOF loops (`%arr..`, `%bytes..`): + // those are plain direct-call functions, and a literal callback + // gets a helper of its own. // Generator declarations are entered through their spawn wrapper, // which moves the same arguments into the generator's frame. - (fn.ownsPrototype || fn.name.startsWith("%arr.") || fn.generator !== undefined) && + (fn.ownsPrototype || + fn.name.startsWith("%arr.") || + fn.name.startsWith("%bytes.") || + fn.generator !== undefined) && (!fn.async || fn.generator !== undefined) && !fn.captures && !fn.classCaptures && diff --git a/packages/compiler/src/frontend/lowering/containers/array-callbacks.ts b/packages/compiler/src/frontend/lowering/containers/array-callbacks.ts index 7ca69d9ba..612c47ea0 100644 --- a/packages/compiler/src/frontend/lowering/containers/array-callbacks.ts +++ b/packages/compiler/src/frontend/lowering/containers/array-callbacks.ts @@ -452,7 +452,7 @@ function withFastCallback(fn: IrFunction, fastT: CallbackType | null, elem: IrTy * constant-callback census then calls it directly and LLVM can inline the * callback into the loop (TurboFan's builtin+callback inlining). Callback * values keep the shared, type-interned helper. */ -function callbackSite(fnArg: IrExpr): string { +export function callbackSite(fnArg: IrExpr): string { return fnArg.kind === "closure" ? `@${fnArg.fnName}` : ""; } diff --git a/packages/compiler/src/frontend/lowering/containers/bytes.ts b/packages/compiler/src/frontend/lowering/containers/bytes.ts index 8a4364754..fd4420b69 100644 --- a/packages/compiler/src/frontend/lowering/containers/bytes.ts +++ b/packages/compiler/src/frontend/lowering/containers/bytes.ts @@ -43,7 +43,7 @@ import { lowerArraySpreadItems, lowerCheckedArrayFrom } from "./array-constructi import { lowerToNumberArgument } from "../lower-exprs.js"; import { lowerBytesIteratorValue } from "../iterator-adapters.js"; import { lowerArrayCallback } from "./callback-arguments.js"; -import { findPredicateOk, predicateToBoolean } from "./array-callbacks.js"; +import { callbackSite, findPredicateOk, predicateToBoolean } from "./array-callbacks.js"; import { typeKey } from "../../type-mapper.js"; /** TypedArray.prototype.sort and toSorted. The receiver and comparator @@ -251,13 +251,28 @@ function lowerBytesCallbackCall( : method === "findIndex" || method === "findLastIndex" ? F64 : lowerer.irTypeOf(call)); - const helper = bytesCallbackHelper(lowerer, method, bytesT, resultT, fnRet, arity, hasInit, loc); + const helper = bytesCallbackHelper( + lowerer, + method, + bytesT, + resultT, + fnRet, + arity, + hasInit, + loc, + callbackSite(fnArg), + ); const args: IrExpr[] = [receiver, fnArg]; if (hasInit) args.push(lowerer.lowerExprExpecting(call.arguments.nodes[1]!, resultT)); return { kind: "call", callee: helper, args, type: resultT, loc }; } -/** The interned helper of one typed-array callback method shape. */ +/** The interned helper of one typed-array callback method shape. A literal + * callback gets a helper of its own (`site`), which the backend then calls + * directly, as for the array methods. The visit is a loop on its own + * counter (`for (let i = 0; i < a.length; i++)`, or down from the last + * index), so the counter is an integer and the element reads need no + * index test. */ function bytesCallbackHelper( lowerer: Lowerer, method: BytesCallbackMethod, @@ -267,8 +282,9 @@ function bytesCallbackHelper( arity: number, hasInit: boolean, loc: SrcLoc, + site: string, ): string { - const key = `bytes.${method}:${bytesT.elem}:${typeKey(resultT)}:${typeKey(fnRet)}:${arity}:${hasInit ? "init" : ""}`; + const key = `bytes.${method}:${bytesT.elem}:${typeKey(resultT)}:${typeKey(fnRet)}:${arity}:${hasInit ? "init" : ""}${site}`; const existing = lowerer.arrHofHelpers.get(key); if (existing) return existing; const name = keyedHelperName(lowerer, `%bytes.${method}`, key); @@ -300,10 +316,20 @@ function bytesCallbackHelper( type: fnRet, loc, }); + // The forward bound is the receiver's length itself (fixed for a typed + // array, and equal to `n`), which the emitter's typed-array loops use. + const length = (): IrExpr => ({ + kind: "bytesIntrinsic", + method: "length", + receiver: a(), + args: [], + type: F64, + loc, + }); const inRange = (): IrExpr => backward ? { kind: "bin", op: ">=", left: i(), right: numLit(0, loc), type: BOOL, loc } - : { kind: "bin", op: "<", left: i(), right: n(), type: BOOL, loc }; + : { kind: "bin", op: "<", left: i(), right: length(), type: BOOL, loc }; const advance = (): IrStmt => ({ kind: "assign", localId: "i.0", @@ -344,6 +370,7 @@ function bytesCallbackHelper( ...(hasInit ? [{ localId: "z.0", name: "z", type: resultT }] : []), ]; const visit: IrStmt[] = [{ kind: "assign", localId: "v.0", value: at(i()), loc }]; + let seeded = false; const prologue: IrStmt[] = []; let epilogue: IrStmt[]; switch (method) { @@ -459,10 +486,12 @@ function bytesCallbackHelper( loc, }); } else { + // The seed is the first visited element; the loop starts past it. + seeded = true; prologue.push( { kind: "if", - cond: { kind: "unary", op: "!", operand: inRange(), type: BOOL, loc }, + cond: { kind: "bin", op: "===", left: n(), right: numLit(0, loc), type: BOOL, loc }, then: [ { kind: "throw", @@ -486,8 +515,16 @@ function bytesCallbackHelper( else_: null, loc, }, - { kind: "varDecl", localId: "acc.0", init: at(i()), loc }, - advance(), + { + kind: "varDecl", + localId: "acc.0", + init: at( + backward + ? { kind: "bin", op: "-", left: n(), right: numLit(1, loc), type: F64, loc } + : numLit(0, loc), + ), + loc, + }, ); } visit.push({ @@ -506,17 +543,30 @@ function bytesCallbackHelper( init: { kind: "bytesIntrinsic", method: "length", receiver: a(), args: [], type: F64, loc }, loc, }, - { - kind: "varDecl", - localId: "i.0", - init: backward - ? { kind: "bin", op: "-", left: n(), right: numLit(1, loc), type: F64, loc } - : numLit(0, loc), - loc, - }, { kind: "varDecl", localId: "v.0", init: numLit(0, loc), loc }, ...prologue, - { kind: "for", init: null, cond: inRange(), update: advance(), body: visit, loc }, + { + kind: "for", + init: { + kind: "varDecl", + localId: "i.0", + init: backward + ? { + kind: "bin", + op: "-", + left: n(), + right: numLit(seeded ? 2 : 1, loc), + type: F64, + loc, + } + : numLit(seeded ? 1 : 0, loc), + loc, + }, + cond: inRange(), + update: advance(), + body: visit, + loc, + }, ...epilogue, ]; lowerer.liftedFns.push({ name, params, returnType: resultT, locals, body, loc }); diff --git a/packages/compiler/test/bytes-callback-helpers.test.ts b/packages/compiler/test/bytes-callback-helpers.test.ts new file mode 100644 index 000000000..c47d106c4 --- /dev/null +++ b/packages/compiler/test/bytes-callback-helpers.test.ts @@ -0,0 +1,68 @@ +import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { expect, test } from "vitest"; +import { compile, deserializeModule, validateModule } from "../src/index.js"; +import type { IrFunction, IrModule, IrStmt } from "../src/ir/ir.js"; + +async function lower(source: string): Promise { + const dir = await mkdtemp(join(tmpdir(), "scriptc-bytes-callbacks-")); + try { + const entry = join(dir, "main.ts"); + const outPath = join(dir, "main.ir.json"); + await writeFile(entry, source); + const result = await compile(entry, { outDir: dir, outPath, outputKind: "ir" }); + if (!result.ok) + throw new Error(result.diagnostics.map((d) => `${d.code}: ${d.message}`).join("\n")); + const mod = deserializeModule(await readFile(outPath, "utf8")); + expect(validateModule(mod)).toEqual([]); + return mod; + } finally { + await rm(dir, { recursive: true, force: true }); + } +} + +const helpers = (mod: IrModule, method: string): IrFunction[] => + mod.functions.filter((f) => f.name.startsWith(`%bytes.${method}.`)); + +const visitLoop = (fn: IrFunction): IrStmt & { kind: "for" } => { + const loop = fn.body.find((s): s is IrStmt & { kind: "for" } => s.kind === "for"); + if (!loop) throw new Error(`no loop in ${fn.name}`); + return loop; +}; + +test("literal callbacks get helpers of their own; function values share one", async () => { + const mod = await lower(` + const a = new Int32Array([1, 2, 3]); + const double = (v: number): number => v * 2; + console.log(a.map((v) => v + 1).join(","), a.map((v) => v - 1).join(",")); + console.log(a.map(double).join(","), new Int32Array([4]).map(double).join(",")); + `); + expect(helpers(mod, "map")).toHaveLength(3); +}); + +test("typed-array callback loops run on their own counter", async () => { + const mod = await lower(` + const a = new Float64Array([1.5, 2.5, 3.5]); + console.log(a.some((v) => v > 2), a.reduce((s, v) => s + v)); + console.log(a.reduceRight((s, v) => s - v), a.findLastIndex((v) => v < 3)); + `); + for (const method of ["some", "reduce"]) { + const loop = visitLoop(helpers(mod, method)[0]!); + // for (let i = <0 or 1 past reduce's seed>; i < a.length; i = i + 1) + expect(loop.init).toMatchObject({ kind: "varDecl", localId: "i.0", init: { kind: "numLit" } }); + expect(loop.cond).toMatchObject({ + kind: "bin", + op: "<", + right: { kind: "bytesIntrinsic", method: "length" }, + }); + } + expect(visitLoop(helpers(mod, "reduce")[0]!).init).toMatchObject({ init: { value: 1 } }); + // Backward: from n - 2 past reduceRight's seed, and from n - 1. + expect(visitLoop(helpers(mod, "reduceRight")[0]!).init).toMatchObject({ + init: { kind: "bin", op: "-", right: { value: 2 } }, + }); + expect(visitLoop(helpers(mod, "findLastIndex")[0]!).init).toMatchObject({ + init: { kind: "bin", op: "-", right: { value: 1 } }, + }); +}); diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6999-typed-array-callback-loops.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6999-typed-array-callback-loops.ts.json new file mode 100644 index 000000000..de7ab0a69 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6999-typed-array-callback-loops.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6999-typed-array-callback-loops.ts" + ], + "diags": [] +} diff --git a/tests/corpus/6999-typed-array-callback-loops.ts b/tests/corpus/6999-typed-array-callback-loops.ts new file mode 100644 index 000000000..84adfd995 --- /dev/null +++ b/tests/corpus/6999-typed-array-callback-loops.ts @@ -0,0 +1,93 @@ +// Typed-array callback methods with literal callbacks, function values shared +// by several calls, and callbacks chosen at run time: visit order and +// arguments, writes during the visit, early exits, reduce seeds and the +// empty-array TypeError, map conversions, Buffer results, throwing +// callbacks, empty arrays and subarray receivers. + +const ints = new Int32Array([5, -3, 8, 0, 12, -7, 4]); +const floats = new Float32Array([0.1, 2.5, -1.25, 3.75, 9.5]); + +const visits: string[] = []; +ints.forEach((v, i, a) => { + visits.push(`${i}:${v}:${a === ints}`); +}); +console.log("forEach", visits.join(" ")); + +const writes = new Uint8Array([1, 2, 3, 4, 5, 6]); +writes.forEach((v, i, a) => { + if (i + 1 < a.length) a[i + 1] = a[i + 1]! + v; +}); +console.log("forEach writes ahead", writes.join(",")); + +let calls = 0; +const counted = (v: number): boolean => { + calls++; + return v > 7; +}; +console.log("some", ints.some(counted), calls); +calls = 0; +console.log("every", ints.every((v) => (calls++, v < 10)), calls); +calls = 0; +console.log("find", ints.find(counted), calls, ints.find((v) => v > 100)); +calls = 0; +console.log("findIndex", ints.findIndex(counted), calls, ints.findIndex((v) => v > 100)); + +const order: number[] = []; +console.log( + "findLast", + ints.findLast((v, i) => (order.push(i), v < 0)), + ints.findLastIndex((v) => v > 100), + order.join(","), +); + +console.log("reduce", ints.reduce((acc, v) => acc + v), ints.reduce((acc, v, i) => acc + v * i, 100)); +const right: number[] = []; +console.log( + "reduceRight", + floats.reduceRight((acc, v, i) => (right.push(i), acc - v)), + right.join(","), + floats.reduceRight((acc, v) => acc + v, -1), +); +console.log("single", new Int8Array([42]).reduce(() => -1), new Int8Array([42]).reduceRight(() => -1)); +function tryReduce(label: string, run: () => number): void { + try { + console.log(label, run()); + } catch (error) { + console.log(label, (error as Error).name, (error as Error).message); + } +} +const emptyU16 = new Uint16Array(0); +const emptyF64 = new Float64Array(0); +tryReduce("empty u16 reduce", () => emptyU16.reduce((a, b) => a + b)); +tryReduce("empty f64 reduceRight", () => emptyF64.reduceRight((a, b) => a + b)); +tryReduce("empty with init", () => emptyU16.reduce((a, b) => a + b, 7) + emptyF64.reduceRight((a, b) => a + b, 1)); +console.log("empty", emptyU16.some(() => true), emptyF64.every(() => false), emptyU16.map((v) => v).length); + +console.log("map u8", new Uint8Array([250, 3, 128]).map((v) => v * 3).join(",")); +console.log("map clamped", new Uint8ClampedArray([250, 3, 128]).map((v) => v * 1.5 - 10).join(",")); +console.log("map i16", new Int16Array([30000, -30000, 7]).map((v, i) => v + i * 10000).join(",")); +console.log("map f32", floats.map((v) => v / 3).join(",")); +console.log("filter", ints.filter((v, i) => v > 0 && i % 2 === 0).join(","), floats.filter((v) => v > 1).join(",")); + +const buf = Buffer.from("scriptc"); +const upper = buf.map((c) => c - 32); +console.log("buffer map", Buffer.isBuffer(upper), upper.join(","), Buffer.isBuffer(buf.filter((c) => c > 112))); + +// One function value at several calls, and callbacks chosen at run time. +const double = (v: number): number => v * 2; +console.log("shared", new Int32Array([1, 2, 3]).map(double).join(","), new Int32Array([4, 5]).map(double).join(",")); +const pick = (k: number): ((v: number) => boolean) => (k > 0 ? (v) => v > k : (v) => v < k); +console.log("chosen", ints.filter(pick(4)).join(","), ints.filter(pick(-4)).join(",")); + +try { + let seen = 0; + floats.forEach((v) => { + seen++; + if (v < 0) throw new RangeError(`negative ${v} after ${seen}`); + }); +} catch (error) { + console.log("throw", (error as Error).name, (error as Error).message); +} + +const view = ints.subarray(2, 5); +console.log("subarray", view.map((v) => v + 1).join(","), view.reduce((a, v) => a * 10 + v, 0), view.findLastIndex((v) => v === 8)); diff --git a/tests/harness/corpus-costs/6999-typed-array-callback-loops.ts.json b/tests/harness/corpus-costs/6999-typed-array-callback-loops.ts.json new file mode 100644 index 000000000..63d9448b4 --- /dev/null +++ b/tests/harness/corpus-costs/6999-typed-array-callback-loops.ts.json @@ -0,0 +1 @@ +{ "plain": 4400, "san": 5000 } From 883f22ddd62005a26bb0fff3e9b83991e3cf6b7e Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 04:50:13 -0500 Subject: [PATCH 056/102] Run two-counter for loops on integer counters `for (let lo = a, hi = b; lo < hi; lo++, hi--)` kept both counters as doubles: the counted-loop match takes a single counter, so every `a[lo]`/`a[hi]` converted and tested its index. A loop whose two counters close in on each other by positive literal steps, are not written by the body and index something now stores both as i64: on every body entry both lie between the first start and the second. A start without a proven integer range is tested at run time on a versioned loop, as a counted loop's is. --- .../src/backend/llvm/counted-loops.ts | 81 ++++++++----- .../src/backend/llvm/emit-statements.ts | 58 ++++++++- .../compiler/src/ir/integer-loops.test.ts | 73 ++++++++++- packages/compiler/src/ir/integer-loops.ts | 114 ++++++++++++++++++ .../corpus/7140-paired-loop-counters.ts.json | 6 + tests/corpus/7140-paired-loop-counters.ts | 81 +++++++++++++ .../7140-paired-loop-counters.ts.json | 1 + 7 files changed, 377 insertions(+), 37 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7140-paired-loop-counters.ts.json create mode 100644 tests/corpus/7140-paired-loop-counters.ts create mode 100644 tests/harness/corpus-costs/7140-paired-loop-counters.ts.json diff --git a/packages/compiler/src/backend/llvm/counted-loops.ts b/packages/compiler/src/backend/llvm/counted-loops.ts index 36fc63e1f..02943b852 100644 --- a/packages/compiler/src/backend/llvm/counted-loops.ts +++ b/packages/compiler/src/backend/llvm/counted-loops.ts @@ -1,4 +1,5 @@ -import type { IntegerCountedForLoop } from "../../ir/integer-loops.js"; +import type { IntegerCountedForLoop, IntegerPairedForLoop } from "../../ir/integer-loops.js"; +import type { IrExpr } from "../../ir/ir.js"; import type { LlvmEmitterContext } from "./expr-context.js"; import { f64Lit } from "./common.js"; @@ -59,37 +60,51 @@ export function emitCountedLoopSafety( `${safe} = fcmp ${loop.step > 0 ? "ole" : "oge"} double ${bound.name}, ${f64Lit(loop.guardLimit)}`, ); } - if (loop.startGuarded) { - // An exact integer of at most 2^53 - 1 in magnitude, and not -0 - // (the bit patterns of the value and its round trip agree). - // NaN and infinities fail the ordered range tests. - const start = host.emitExpr(loop.start); - const low = B.tmp(), - high = B.tmp(), - raw = B.tmp(), - wide = B.tmp(), - back = B.tmp(), - bits = B.tmp(), - backBits = B.tmp(), - exact = B.tmp(), - inRange = B.tmp(), - ok = B.tmp(); - B.line(`${low} = fcmp oge double ${start.name}, ${f64Lit(-Number.MAX_SAFE_INTEGER)}`); - B.line(`${high} = fcmp ole double ${start.name}, ${f64Lit(Number.MAX_SAFE_INTEGER)}`); - B.line(`${inRange} = and i1 ${low}, ${high}`); - B.line(`${raw} = fptosi double ${start.name} to i64`); - B.line(`${wide} = freeze i64 ${raw}`); - B.line(`${back} = sitofp i64 ${wide} to double`); - B.line(`${bits} = bitcast double ${start.name} 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}`); - if (safe === "true") safe = ok; - else { - const both = B.tmp(); - B.line(`${both} = and i1 ${safe}, ${ok}`); - safe = both; - } - } + if (loop.startGuarded) safe = andSafe(host, safe, emitExactStart(host, loop.start)); return safe; } + +/** The run-time test of a guarded paired loop: each unproven start is an + * exact safe integer. */ +export function emitPairedLoopSafety(host: LlvmEmitterContext, loop: IntegerPairedForLoop): string { + let safe = "true"; + for (const counter of [loop.low, loop.high]) + if (counter.startGuarded) safe = andSafe(host, safe, emitExactStart(host, counter.start)); + return safe; +} + +function andSafe(host: LlvmEmitterContext, safe: string, ok: string): string { + if (safe === "true") return ok; + const both = host.B.tmp(); + host.B.line(`${both} = and i1 ${safe}, ${ok}`); + return both; +} + +/** An exact integer of at most 2^53 - 1 in magnitude, and not -0 (the bit + * patterns of the value and its round trip agree). NaN and infinities fail + * the ordered range tests. */ +function emitExactStart(host: LlvmEmitterContext, expr: IrExpr): string { + const B = host.B; + const start = host.emitExpr(expr); + const low = B.tmp(), + high = B.tmp(), + raw = B.tmp(), + wide = B.tmp(), + back = B.tmp(), + bits = B.tmp(), + backBits = B.tmp(), + exact = B.tmp(), + inRange = B.tmp(), + ok = B.tmp(); + B.line(`${low} = fcmp oge double ${start.name}, ${f64Lit(-Number.MAX_SAFE_INTEGER)}`); + B.line(`${high} = fcmp ole double ${start.name}, ${f64Lit(Number.MAX_SAFE_INTEGER)}`); + B.line(`${inRange} = and i1 ${low}, ${high}`); + B.line(`${raw} = fptosi double ${start.name} to i64`); + B.line(`${wide} = freeze i64 ${raw}`); + B.line(`${back} = sitofp i64 ${wide} to double`); + B.line(`${bits} = bitcast double ${start.name} 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; +} diff --git a/packages/compiler/src/backend/llvm/emit-statements.ts b/packages/compiler/src/backend/llvm/emit-statements.ts index 7f189c066..7239db7d8 100644 --- a/packages/compiler/src/backend/llvm/emit-statements.ts +++ b/packages/compiler/src/backend/llvm/emit-statements.ts @@ -42,10 +42,15 @@ import { matchIntegerArrayForLoop, matchIntegerBytesForLoop, matchIntegerCountedForLoop, + matchIntegerPairedForLoop, } from "../../ir/integer-loops.js"; import { emitByteWindowGuard, matchByteWindow } from "./byte-windows.js"; import { countedDenseShape, emitDenseLoopGuard, matchDenseArrayLoop } from "./dense-array-loops.js"; -import { emitCountedLoopLimit, emitCountedLoopSafety } from "./counted-loops.js"; +import { + emitCountedLoopLimit, + emitCountedLoopSafety, + emitPairedLoopSafety, +} from "./counted-loops.js"; import { emitBytesLoopVersionGuard } from "./bytes-loop-versions.js"; import { mangleLocal } from "../mangle.js"; import { LlvmUnsupportedError } from "./unsupported.js"; @@ -868,6 +873,12 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { emitter.unaliasedArrays, ) : null; + // Two counters closing in on each other (`lo++, hi--`) take the same + // integer storage as a counted loop's one. + const pairedLoop = + !integerLoop && !countedLoop && emitter.countedLoopsEnabled + ? matchIntegerPairedForLoop(s, emitter.numericLocals, emitter.integerRanges) + : null; const window = countedLoop && emitter.byteWindowsEnabled ? matchByteWindow( @@ -1000,8 +1011,10 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { break; } let countedJoin: string | null = null; - if (countedLoop?.guarded && !emitter.provenCountedGuards.has(s)) { - const safe = emitCountedLoopSafety(emitter, countedLoop); + if ((countedLoop?.guarded && !emitter.provenCountedGuards.has(s)) || pairedLoop?.guarded) { + const safe = countedLoop + ? emitCountedLoopSafety(emitter, countedLoop) + : emitPairedLoopSafety(emitter, pairedLoop!); const fast = B.newLabel("counted.fast"); const slow = B.newLabel("counted.slow"); countedJoin = B.newLabel("counted.done"); @@ -1016,6 +1029,7 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { emitter.scopes.push([]); let integerSlot: string | null = null; let countedLimit: string | null = null; + const pairedSlots: string[] = []; if (integerLoop) { integerSlot = B.slot(); B.entryAllocas.push( @@ -1060,6 +1074,24 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { : countedLoop.range, }); countedLimit = emitCountedLoopLimit(emitter, countedLoop); + } else if (pairedLoop) { + for (const counter of [pairedLoop.low, pairedLoop.high]) { + const slot = B.slot(); + B.entryAllocas.push( + `${slot} = alloca i64 ; integer induction ${emitter.currentLocals.get(counter.localId)!.name}`, + ); + const value = emitter.emitExpr(counter.start); + const start = B.tmp(); + B.line(`${start} = fptosi double ${value.name} to i64`); + B.line(`store i64 ${start}, ptr ${slot}`); + pairedSlots.push(slot); + emitter.integerLoopBindings.set(counter.localId, { + slot, + type: "i64", + signed: true, + range: pairedLoop.range, + }); + } } else if (s.init) { // A multi-declarator head shares the loop's scope. Emitting its // IR block as an ordinary block would release captured/ref locals @@ -1141,6 +1173,14 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { `${inBounds} = icmp ${countedLoop.step > 0 ? "slt" : "sgt"} i64 ${index}, ${countedLimit}`, ); B.condBr(inBounds, lb, exit); + } else if (pairedLoop) { + const low = B.tmp(), + high = B.tmp(), + open = B.tmp(); + B.line(`${low} = load i64, ptr ${pairedSlots[0]}`); + B.line(`${high} = load i64, ptr ${pairedSlots[1]}`); + B.line(`${open} = icmp ${pairedLoop.inclusive ? "sle" : "slt"} i64 ${low}, ${high}`); + B.condBr(open, lb, exit); } else if (s.cond) B.condBr(emitter.emitCondition(s.cond), lb, exit); else B.br(lb); B.startBlock(lb); @@ -1172,6 +1212,14 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { B.line(`${old} = load i64, ptr ${integerSlot}`); B.line(`${next} = add nsw i64 ${old}, ${countedLoop.step}`); B.line(`store i64 ${next}, ptr ${integerSlot}`); + } else if (pairedLoop) { + [pairedLoop.low, pairedLoop.high].forEach((counter, i) => { + const old = B.tmp(); + const next = B.tmp(); + B.line(`${old} = load i64, ptr ${pairedSlots[i]}`); + B.line(`${next} = add nsw i64 ${old}, ${counter.step}`); + B.line(`store i64 ${next}, ptr ${pairedSlots[i]}`); + }); } else if (s.update) emitter.emitStmt(s.update); B.br(lc); } @@ -1180,6 +1228,10 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { emitter.releaseScope(emitter.scopes.pop()!); if (integerLoop) emitter.integerLoopBindings.delete(integerLoop.localId); if (countedLoop) emitter.integerLoopBindings.delete(countedLoop.localId); + if (pairedLoop) { + emitter.integerLoopBindings.delete(pairedLoop.low.localId); + emitter.integerLoopBindings.delete(pairedLoop.high.localId); + } if (integerArrayLoop) emitter.integerArrayBindings.delete(integerArrayLoop.localId); if (countedJoin) { B.br(countedJoin); diff --git a/packages/compiler/src/ir/integer-loops.test.ts b/packages/compiler/src/ir/integer-loops.test.ts index aada3b053..24bbf5be0 100644 --- a/packages/compiler/src/ir/integer-loops.test.ts +++ b/packages/compiler/src/ir/integer-loops.test.ts @@ -1,6 +1,10 @@ import { expect, test } from "vitest"; import { BOOL, F64, STRING, arrayOf, type IrExpr, type IrLocal, type IrStmt } from "./ir.js"; -import { matchIntegerArrayForLoop, matchIntegerCountedForLoop } from "./integer-loops.js"; +import { + matchIntegerArrayForLoop, + matchIntegerCountedForLoop, + matchIntegerPairedForLoop, +} from "./integer-loops.js"; const loc = { file: "integer-array-loop.ts", start: 0, end: 0 }; const number = (value: number): IrExpr => ({ kind: "numLit", value, type: F64, loc }); @@ -355,3 +359,70 @@ test("a descending loop from an array's last index takes an integer counter for range: { min: 0, max: 4294967294 }, }); }); + +test("paired counters closing in on each other run as integers", () => { + const vars = new Map(locals); + for (const id of ["lo", "hi", "head"]) vars.set(id, { id, name: id, type: F64, mutable: true }); + const step = (id: string, op: "+" | "-", value = 1): IrStmt => ({ + kind: "assign", + localId: id, + value: { kind: "bin", op, left: ref(id), right: number(value), type: F64, loc }, + loc, + }); + const element = (index: IrExpr): IrExpr => ({ + kind: "arrayGet", + arr: { kind: "varRef", localId: "a", type: arrayOf(F64), loc }, + index, + type: F64, + loc, + }); + const paired = ( + lowStart: IrExpr, + highStart: IrExpr, + update = [step("lo", "+"), step("hi", "-")], + ) => + ({ + kind: "for", + loc, + init: { + kind: "block", + body: [ + { kind: "varDecl", localId: "lo", init: lowStart, loc }, + { kind: "varDecl", localId: "hi", init: highStart, loc }, + ], + loc, + }, + cond: { kind: "bin", op: "<", left: ref("lo"), right: ref("hi"), type: BOOL, loc }, + update: { kind: "block", body: update, loc }, + body: [{ kind: "exprStmt", expr: element(ref("hi")), loc }], + }) as IrStmt & { kind: "for" }; + expect(matchIntegerPairedForLoop(paired(number(0), number(9)), vars)).toMatchObject({ + low: { localId: "lo", step: 1, startGuarded: false }, + high: { localId: "hi", step: -1, startGuarded: false }, + guarded: false, + range: { min: 0, max: 9 }, + }); + // A start without a known range is tested at run time. + expect(matchIntegerPairedForLoop(paired(number(0), ref("head")), vars)).toMatchObject({ + high: { startGuarded: true }, + guarded: true, + }); + // Counters moving the same way, written by the body, captured, started + // from each other, or never used as an index are refused. + expect( + matchIntegerPairedForLoop( + paired(number(0), number(9), [step("lo", "+"), step("hi", "+")]), + vars, + ), + ).toBeNull(); + const writing = paired(number(0), number(9)); + writing.body.push(step("hi", "-", 2)); + expect(matchIntegerPairedForLoop(writing, vars)).toBeNull(); + const boxed = new Map(vars); + boxed.set("hi", { ...vars.get("hi")!, boxed: true }); + expect(matchIntegerPairedForLoop(paired(number(0), number(9)), boxed)).toBeNull(); + expect(matchIntegerPairedForLoop(paired(number(0), ref("lo")), vars)).toBeNull(); + const unused = paired(number(0), number(9)); + unused.body = []; + expect(matchIntegerPairedForLoop(unused, vars)).toBeNull(); +}); diff --git a/packages/compiler/src/ir/integer-loops.ts b/packages/compiler/src/ir/integer-loops.ts index 9b4675685..e80680d6e 100644 --- a/packages/compiler/src/ir/integer-loops.ts +++ b/packages/compiler/src/ir/integer-loops.ts @@ -281,6 +281,120 @@ export function matchIntegerCountedForLoop( }; } +/** A for loop whose two counters close in on each other: + * + * for (let lo = a, hi = b; lo < hi; lo++, hi--) { ... } + * + * The first counter only grows and the second only shrinks, by positive + * literal steps, the body writes neither, and the loop runs while the first + * is below (or at most) the second. Every body entry therefore holds both + * between the first start and the second start: exact integers when the + * starts are. A start without a proven integer range is tested at run time + * on a versioned loop, as a counted loop's is. */ +export interface IntegerPairedCounter { + localId: string; + start: IrExpr; + /** The signed step of each update. */ + step: number; + startGuarded: boolean; +} +export interface IntegerPairedForLoop { + low: IntegerPairedCounter; + high: IntegerPairedCounter; + inclusive: boolean; + guarded: boolean; + /** Both counters' values on every body entry. */ + range: IntegerRange; +} + +export function matchIntegerPairedForLoop( + stmt: IrStmt & { kind: "for" }, + locals: ReadonlyMap, + ranges: IntegerRanges = new Map(), +): IntegerPairedForLoop | null { + const init = stmt.init, + update = stmt.update, + cond = stmt.cond; + if (init?.kind !== "block" || init.body.length !== 2) return null; + if (update?.kind !== "block" || update.body.length !== 2) return null; + if (cond?.kind !== "bin" || (cond.op !== "<" && cond.op !== "<=")) return null; + if (cond.left.kind !== "varRef" || cond.right.kind !== "varRef") return null; + const lowId = cond.left.localId, + highId = cond.right.localId; + if (lowId === highId) return null; + const counter = (id: string): IntegerPairedCounter | null => { + const decl = init.body.find((d) => d.kind === "varDecl" && d.localId === id); + if (decl?.kind !== "varDecl" || !decl.init) return null; + const local = locals.get(id); + if (local?.type.kind !== "f64" || !local.mutable || local.boxed || local.tdz) return null; + const start = decl.init; + // Each start is evaluated once in the head and again on a fallback path. + if ( + !stableLoopValue(start, locals, stmt.body, false, lowId) || + !stableLoopValue(start, locals, stmt.body, false, highId) + ) + return null; + const steps = update.body.map((u) => constantStep(u, id)).filter((v) => v !== null); + if (steps.length !== 1 || writesLocal(stmt.body, id)) return null; + const known = + start.kind === "numLit" && Number.isSafeInteger(start.value) && !Object.is(start.value, -0) + ? { min: start.value, max: start.value } + : ranges.get(start); + const startGuarded = !known && start.kind !== "numLit" && start.type.kind === "f64"; + if (!known && !startGuarded) return null; + if (known && (known.min < -Number.MAX_SAFE_INTEGER || known.max > Number.MAX_SAFE_INTEGER)) + return null; + return { localId: id, start, step: steps[0]!, startGuarded }; + }; + const low = counter(lowId), + high = counter(highId); + if (!low || !high || low.step <= 0 || high.step >= 0) return null; + const startRange = (c: IntegerPairedCounter): IntegerRange => + c.startGuarded + ? { min: -Number.MAX_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER } + : c.start.kind === "numLit" + ? { min: c.start.value, max: c.start.value } + : ranges.get(c.start)!; + const guarded = low.startGuarded || high.startGuarded; + // Only a loop whose counters index something gains from integer storage. + let useful = false, + cost = 0; + const isCounter = (e: IrExpr): boolean => + (e.kind === "varRef" && (e.localId === lowId || e.localId === highId)) || + (e.kind === "bin" && + (e.op === "+" || e.op === "-") && + (isCounter(e.left) || isCounter(e.right))); + const expr = (e: IrExpr): boolean => { + if (e.kind === "arrayGet" && isCounter(e.index)) useful = true; + if (e.kind === "strIntrinsic" && e.method === "charCodeAt" && e.args[0] && isCounter(e.args[0])) + useful = true; + if (e.kind === "bytesIntrinsic" && e.method === "get" && e.args[0] && isCounter(e.args[0])) + useful = true; + return (!guarded || ++cost <= 80) && everyExprChild(e, expr, bodyStmt); + }; + const bodyStmt = (s: IrStmt): boolean => { + if ((s.kind === "arraySet" || s.kind === "bytesSet") && isCounter(s.index)) useful = true; + if ( + guarded && + (s.kind === "for" || s.kind === "forOf" || s.kind === "while" || s.kind === "doWhile") + ) + return false; + return (!guarded || ++cost <= 80) && everyStmtChild(s, expr, bodyStmt); + }; + if (!stmt.body.every(bodyStmt) || !useful) return null; + return { + low, + high, + inclusive: cond.op === "<=", + guarded, + // A loop whose starts already fail the condition never enters the body. + range: { + min: startRange(low).min, + max: Math.max(startRange(low).min, startRange(high).max), + }, + }; +} + /** True when a lowered subtree writes `localId`. Local ids are unique per * function, so typed traversal includes writes * nested in expressions, branches, nested loops, and try/finally bodies. */ diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7140-paired-loop-counters.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7140-paired-loop-counters.ts.json new file mode 100644 index 000000000..122d64bb6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7140-paired-loop-counters.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7140-paired-loop-counters.ts" + ], + "diags": [] +} diff --git a/tests/corpus/7140-paired-loop-counters.ts b/tests/corpus/7140-paired-loop-counters.ts new file mode 100644 index 000000000..ec1610d1a --- /dev/null +++ b/tests/corpus/7140-paired-loop-counters.ts @@ -0,0 +1,81 @@ +// For loops with two counters closing in on each other (`lo++, hi--`): +// in-place reversals, inclusive bounds, larger steps, early exits, starts +// that are fractions, negative zero, NaN, huge or already crossed, nested +// reversals, and counters a closure captures or the body writes. +function reverse(a: number[], from: number, to: number): number[] { + for (let lo = from, hi = to; lo < hi; lo++, hi--) { + const t = a[lo]!; + a[lo] = a[hi]!; + a[hi] = t; + } + return a; +} +const base = (): number[] => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; +console.log(reverse(base(), 0, 9).join(",")); +console.log(reverse(base(), 2, 6).join(",")); +console.log(reverse(base(), 6, 2).join(",")); +console.log(reverse(base(), 3, 3).join(",")); +// Unproven starts: fractions, negative zero, NaN and huge values keep JS +// semantics (charCodeAt truncates its index; out-of-range reads are NaN). +function codes(s: string, from: number, to: number): string { + const out: number[] = []; + for (let lo = from, hi = to; lo < hi; lo++, hi--) out.push(s.charCodeAt(lo), s.charCodeAt(hi), lo, hi); + return out.join(","); +} +const word = "abcdefgh"; +console.log(codes(word, 0.5, 4.5)); +console.log(codes(word, -0, 3), Object.is(-0 + 0, 0)); +console.log(codes(word, NaN, 4), "|", codes(word, 0, NaN)); +console.log(codes(word, 2 ** 53 - 3, 2 ** 53)); +console.log(codes(word, -3, 2)); + +function pairs(n: number): string { + const out: string[] = []; + for (let i = 0, j = n; i <= j; i += 2, j -= 3) out.push(`${i}:${j}`); + return out.join(" "); +} +console.log(pairs(20), "|", pairs(0), "|", pairs(-1)); + +function firstGap(a: number[]): number { + let found = -1; + for (let lo = 0, hi = a.length - 1; lo < hi; lo++, hi--) { + if (a[lo] === a[hi]) continue; + found = lo; + break; + } + return found; +} +console.log(firstGap([1, 2, 3, 2, 1]), firstGap([1, 2, 3, 4, 2, 1]), firstGap([])); + +// The flip loop of a permutation puzzle: the next index comes from the array. +function flips(perm: number[]): number { + const work = perm.slice(); + let count = 0; + let head = work[0]!; + while (head !== 0) { + for (let lo = 0, hi = head; lo < hi; lo++, hi--) { + const t = work[lo]!; + work[lo] = work[hi]!; + work[hi] = t; + } + count++; + head = work[0]!; + } + return count; +} +console.log(flips([3, 1, 0, 2]), flips([4, 3, 2, 1, 0]), flips([0, 1, 2])); + +// Counters a closure reads, or the body writes, stay ordinary bindings. +const readers: (() => number)[] = []; +for (let lo = 0, hi = 4; lo < hi; lo++, hi--) readers.push(() => lo * 10 + hi); +console.log(readers.map((f) => f()).join(",")); +const seen: number[] = []; +for (let lo = 0, hi = 10; lo < hi; lo++, hi--) { + seen.push(lo, hi); + if (lo === 2) hi -= 3; +} +console.log(seen.join(",")); +const text = "abcdefgh"; +let mirrored = ""; +for (let lo = 0, hi = text.length - 1; lo <= hi; lo++, hi--) mirrored += text.charAt(hi) + text.charCodeAt(lo); +console.log(mirrored); diff --git a/tests/harness/corpus-costs/7140-paired-loop-counters.ts.json b/tests/harness/corpus-costs/7140-paired-loop-counters.ts.json new file mode 100644 index 000000000..549fd6a4a --- /dev/null +++ b/tests/harness/corpus-costs/7140-paired-loop-counters.ts.json @@ -0,0 +1 @@ +{ "plain": 3880, "san": 6000 } From 13608301496f6a1980b63bb08f6ac3391d6d957e Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 04:52:44 -0500 Subject: [PATCH 057/102] Support new tls.TLSSocket and tls.connect({ socket }) --- .../src/generated/node-v24-compatibility.json | 12 +- .../generated/node-v24-internal.json | 23 +- internal/compatibility/static-support.json | 1 + .../ambient/scriptc-node-fallback.d.ts | 63 +++- packages/compiler/src/backend/llvm/lib-tls.ts | 7 + .../src/frontend/lowering/lower-classes.ts | 8 +- .../src/frontend/lowering/lower-server.ts | 162 ++++++++- packages/compiler/src/ir/builtin-effects.ts | 2 + .../compiler/src/ir/builtin-signatures.ts | 14 + .../tests/corpus/7087-tls-socket-wrap.ts.json | 6 + .../7088-tls-socket-connect-tunnel.ts.json | 6 + .../7089-http-host-header-tunnels.ts.json | 6 + .../diagnostics/tls-socket-fences.ts.json | 6 + .../node-types/tls-socket-wrap.ts.json | 6 + packages/runtime/src/scr_http.c | 39 ++- packages/runtime/src/scr_net.c | 313 ++++++++++++++---- packages/runtime/src/scr_net.h | 24 ++ packages/runtime/src/scr_tls.c | 282 +++++++++++++++- packages/runtime/src/scr_tls.h | 9 + tests/corpus/7087-tls-socket-wrap.ts | 104 ++++++ .../corpus/7088-tls-socket-connect-tunnel.ts | 64 ++++ tests/corpus/7089-http-host-header-tunnels.ts | 31 ++ tests/diagnostics/tls-socket-fences.ts | 20 ++ tests/fixtures/node-types/tls-socket-wrap.ts | 31 ++ .../__snapshots__/tls-socket-fences.ts.txt | 26 ++ .../corpus-costs/7087-tls-socket-wrap.ts.json | 1 + .../7088-tls-socket-connect-tunnel.ts.json | 1 + .../7089-http-host-header-tunnels.ts.json | 1 + tests/harness/errors.test.ts | 50 +++ tests/harness/project-config.test.ts | 18 + 30 files changed, 1223 insertions(+), 113 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7087-tls-socket-wrap.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7088-tls-socket-connect-tunnel.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7089-http-host-header-tunnels.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/tls-socket-fences.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/tls-socket-wrap.ts.json create mode 100644 tests/corpus/7087-tls-socket-wrap.ts create mode 100644 tests/corpus/7088-tls-socket-connect-tunnel.ts create mode 100644 tests/corpus/7089-http-host-header-tunnels.ts create mode 100644 tests/diagnostics/tls-socket-fences.ts create mode 100644 tests/fixtures/node-types/tls-socket-wrap.ts create mode 100644 tests/harness/__snapshots__/tls-socket-fences.ts.txt create mode 100644 tests/harness/corpus-costs/7087-tls-socket-wrap.ts.json create mode 100644 tests/harness/corpus-costs/7088-tls-socket-connect-tunnel.ts.json create mode 100644 tests/harness/corpus-costs/7089-http-host-header-tunnels.ts.json diff --git a/docs/src/generated/node-v24-compatibility.json b/docs/src/generated/node-v24-compatibility.json index 682e68f99..1d9190afe 100644 --- a/docs/src/generated/node-v24-compatibility.json +++ b/docs/src/generated/node-v24-compatibility.json @@ -67806,9 +67806,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" } }, { @@ -68565,9 +68565,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" } }, { diff --git a/internal/compatibility/generated/node-v24-internal.json b/internal/compatibility/generated/node-v24-internal.json index a86967ff3..58deb8944 100644 --- a/internal/compatibility/generated/node-v24-internal.json +++ b/internal/compatibility/generated/node-v24-internal.json @@ -95421,7 +95421,10 @@ "tests/corpus/2557-tls-ca-store.ts", "tests/corpus/2596-net-arg-ladders.cjs", "tests/corpus/6721-tls-alpn-protocols.ts", - "tests/corpus/6722-tls-min-max-version.ts" + "tests/corpus/6722-tls-min-max-version.ts", + "tests/corpus/7087-tls-socket-wrap.ts", + "tests/corpus/7088-tls-socket-connect-tunnel.ts", + "tests/fixtures/node-types/tls-socket-wrap.ts" ] }, "anchorSource": "chapter" @@ -96123,8 +96126,13 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:tls" + "status": "partial", + "evidence": "compiler-feature:tls.tls.TLSSocket", + "tests": [ + "tests/corpus/7087-tls-socket-wrap.ts", + "tests/corpus/7088-tls-socket-connect-tunnel.ts", + "tests/fixtures/node-types/tls-socket-wrap.ts" + ] }, "anchorSource": "exact" }, @@ -96911,8 +96919,13 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:tls" + "status": "partial", + "evidence": "compiler-feature:tls.'secure'", + "tests": [ + "tests/corpus/7087-tls-socket-wrap.ts", + "tests/corpus/7088-tls-socket-connect-tunnel.ts", + "tests/fixtures/node-types/tls-socket-wrap.ts" + ] }, "anchorSource": "exact" }, diff --git a/internal/compatibility/static-support.json b/internal/compatibility/static-support.json index 6b3eaab4c..6a9a1dbad 100644 --- a/internal/compatibility/static-support.json +++ b/internal/compatibility/static-support.json @@ -369,6 +369,7 @@ { "chapter": "console", "signatures": ["Class: `Console`"], "status": "partial", "evidence": ["tests/corpus/4900-console-instances.ts", "tests/corpus/4901-console-instance-errors.ts"] }, { "chapter": "tls", "signatures": ["`alpnProtocol` Type: {string|boolean|null}"], "status": "partial", "evidence": ["tests/corpus/6721-tls-alpn-protocols.ts"] }, { "chapter": "tls", "signatures": ["`tlsSocket.getProtocol()`"], "status": "partial", "evidence": ["tests/corpus/6722-tls-min-max-version.ts"] }, + { "chapter": "tls", "signatures": ["Class: `tls.TLSSocket`", "Event: `'secure'`"], "status": "partial", "evidence": ["tests/corpus/7087-tls-socket-wrap.ts", "tests/corpus/7088-tls-socket-connect-tunnel.ts", "tests/fixtures/node-types/tls-socket-wrap.ts"] }, { "chapter": "webstreams", "signatures": ["`readableStream.values([options])`"], "status": "partial", "evidence": ["tests/corpus/2862-web-readable-async-iteration.ts"] }, { "chapter": "webstreams", "signatures": ["`streamConsumers.text(stream)`", "`streamConsumers.json(stream)`", "`streamConsumers.buffer(stream)`"], "status": "partial", "evidence": ["tests/corpus/2629-stream-consumers.ts", "tests/corpus/2630-stream-consumers-errors.ts"] }, { "chapter": "webstreams", "signatures": ["`streamConsumers.arrayBuffer(stream)`"], "status": "partial", "evidence": ["tests/corpus/4875-stream-consumers-array-buffer.ts"] }, diff --git a/packages/compiler/ambient/scriptc-node-fallback.d.ts b/packages/compiler/ambient/scriptc-node-fallback.d.ts index 936283d40..4e8fbde15 100644 --- a/packages/compiler/ambient/scriptc-node-fallback.d.ts +++ b/packages/compiler/ambient/scriptc-node-fallback.d.ts @@ -4858,8 +4858,8 @@ declare module "net" { * unshift — read answers exactly n buffered bytes or null. */ read(size?: number): Buffer | null; unshift(chunk: Uint8Array): void; - /* secureConnect/session are TLS-socket events declared on the shared - * socket surface (the lowering collapses TLSSocket onto this kind): + /* secureConnect/secure/session are TLS-socket events declared on the + * shared socket surface (the lowering collapses TLSSocket onto this kind): * the runtime gates on the transport, so a plain socket's * registration never fires — Node's exact split. 'session' fires * once with the serialized session (the received-ticket event). */ @@ -4867,7 +4867,15 @@ declare module "net" { /* After setEncoding the chunk is a string. */ on(event: "data", listener: (chunk: string) => void): void; on( - event: "end" | "connect" | "ready" | "timeout" | "readable" | "finish" | "secureConnect", + event: + | "end" + | "connect" + | "ready" + | "timeout" + | "readable" + | "finish" + | "secureConnect" + | "secure", listener: () => void, ): void; on(event: "close", listener: (hadError: boolean) => void): void; @@ -4883,7 +4891,15 @@ declare module "net" { /* After setEncoding the chunk is a string. */ addListener(event: "data", listener: (chunk: string) => void): void; addListener( - event: "end" | "connect" | "ready" | "timeout" | "readable" | "finish" | "secureConnect", + event: + | "end" + | "connect" + | "ready" + | "timeout" + | "readable" + | "finish" + | "secureConnect" + | "secure", listener: () => void, ): void; addListener(event: "close", listener: (hadError: boolean) => void): void; @@ -4898,7 +4914,15 @@ declare module "net" { /* After setEncoding the chunk is a string. */ once(event: "data", listener: (chunk: string) => void): void; once( - event: "end" | "connect" | "ready" | "timeout" | "readable" | "finish" | "secureConnect", + event: + | "end" + | "connect" + | "ready" + | "timeout" + | "readable" + | "finish" + | "secureConnect" + | "secure", listener: () => void, ): void; once(event: "close", listener: (hadError: boolean) => void): void; @@ -4949,9 +4973,10 @@ declare module "net" { on(event: "timeout", listener: (socket: Socket) => void): void; on(event: "error", listener: (err: Error) => void): void; /* The WebSocket handover: fires INSTEAD of 'request' for - * Connection: upgrade requests, with the raw socket + head bytes. */ + * Connection: upgrade requests, with the raw socket + head bytes; + * 'connect' is its twin for CONNECT requests (HTTP tunneling). */ on( - event: "upgrade", + event: "upgrade" | "connect", listener: (req: import("http").IncomingMessage, socket: Socket, head: Buffer) => void, ): void; /* http.createServer(handler)'s event twin (a no-parser net server @@ -4967,7 +4992,7 @@ declare module "net" { addListener(event: "timeout", listener: (socket: Socket) => void): void; addListener(event: "error", listener: (err: Error) => void): void; addListener( - event: "upgrade", + event: "upgrade" | "connect", listener: (req: import("http").IncomingMessage, socket: Socket, head: Buffer) => void, ): void; addListener( @@ -4980,7 +5005,7 @@ declare module "net" { once(event: "timeout", listener: (socket: Socket) => void): void; once(event: "error", listener: (err: Error) => void): void; once( - event: "upgrade", + event: "upgrade" | "connect", listener: (req: import("http").IncomingMessage, socket: Socket, head: Buffer) => void, ): void; once( @@ -5451,6 +5476,7 @@ declare module "tls" { * split — authorizationError is the verify-failure CODE STRING * (DEPTH_ZERO_SELF_SIGNED_CERT, ...), or null. */ export interface TLSSocket extends Socket { + readonly encrypted: true; authorized: boolean; authorizationError: string | null; /* null before the handshake, then the negotiated protocol or false */ @@ -5462,6 +5488,21 @@ declare module "tls" { /* whether the handshake resumed a cached session */ isSessionReused(): boolean; } + /** new tls.TLSSocket(socket, options): the server-mode wrap of an open + * socket (a server connection or an http CONNECT socket). The options + * record reads at runtime; isServer, cert, key, secureContext, + * ALPNProtocols, minVersion and maxVersion are implemented. */ + export interface TLSSocketOptions { + isServer?: boolean; + cert?: string | Uint8Array; + key?: string | Uint8Array; + secureContext?: SecureContext; + ALPNProtocols?: string[] | Uint8Array; + minVersion?: string; + maxVersion?: string; + [option: string]: unknown; + } + export const TLSSocket: new (socket: Socket, options: TLSSocketOptions) => TLSSocket; export interface CipherNameAndProtocol { name: string; standardName: string; @@ -5470,12 +5511,14 @@ declare module "tls" { export const DEFAULT_MIN_VERSION: string; export const DEFAULT_MAX_VERSION: string; /** tls.connect options — the RUNTIME options record (members read at - * runtime; port/host/rejectUnauthorized/ca/servername are the + * runtime; port/host/socket/rejectUnauthorized/ca/servername are the * honestly-implemented set, every other documented member throws the * runtime fence — the options-record stance's divergence-66 shape). */ export interface ConnectionOptions { port?: number; host?: string; + /* an open socket to run the client handshake over */ + socket?: Socket; rejectUnauthorized?: boolean; ca?: string | Uint8Array | ReadonlyArray; servername?: string; diff --git a/packages/compiler/src/backend/llvm/lib-tls.ts b/packages/compiler/src/backend/llvm/lib-tls.ts index c5c77d3a6..1d1cf659c 100644 --- a/packages/compiler/src/backend/llvm/lib-tls.ts +++ b/packages/compiler/src/backend/llvm/lib-tls.ts @@ -121,6 +121,13 @@ export function emitTlsLibCall(host: LlvmEmitterContext, e: LibCallExpr): LlValu case "tls.sockOnSecureConnect": host.toHeap(args[1]!); return finishRuntimeCall(host, e, "scr_tls_sock_on_secure_connect", a); + case "tls.sockOnSecure": + host.toHeap(args[1]!); + return finishRuntimeCall(host, e, "scr_tls_sock_on_secure", a); + case "tls.wrapSocket": + return finishRuntimeCall(host, e, "scr_tls_wrap_socket", [a[0]!, a[1]!, ptr()]); + case "tls.wrapSocketCtx": + return finishRuntimeCall(host, e, "scr_tls_wrap_socket", a); case "tls.sockOnSession": { const cb = args[1]!, type = callbackType(cb); diff --git a/packages/compiler/src/frontend/lowering/lower-classes.ts b/packages/compiler/src/frontend/lowering/lower-classes.ts index 2a772ae25..d8ccc15b7 100644 --- a/packages/compiler/src/frontend/lowering/lower-classes.ts +++ b/packages/compiler/src/frontend/lowering/lower-classes.ts @@ -158,7 +158,7 @@ import { classSymbolKeyOfSymbol, symbolFieldDisplayName, } from "./symbol-fields.js"; -import { lowerHttpAgentNew, lowerHttpServerNew } from "./lower-server.js"; +import { lowerHttpAgentNew, lowerHttpServerNew, lowerTlsSocketNew } from "./lower-server.js"; import { ambientNsRootOf, ambientUndefReadType, @@ -9836,6 +9836,12 @@ export function lowerNew(lowerer: Lowerer, expr: ts.NewExpression): IrExpr { const httpServer = lowerHttpServerNew(lowerer, expr); if (httpServer) return httpServer; } + // `new tls.TLSSocket(socket, options)` — the server-mode wrap of an open + // socket (lower-server). + { + const tlsSocket = lowerTlsSocketNew(lowerer, expr); + if (tlsSocket) return tlsSocket; + } // `new http.Agent(opts?)` / `new https.Agent(opts?)` — the Agent // handle (lower-server): getName/destroy/counters through the dyn // handle ops, requests thread it via the agent option. diff --git a/packages/compiler/src/frontend/lowering/lower-server.ts b/packages/compiler/src/frontend/lowering/lower-server.ts index 94d49d8b3..d9746e1f6 100644 --- a/packages/compiler/src/frontend/lowering/lower-server.ts +++ b/packages/compiler/src/frontend/lowering/lower-server.ts @@ -2939,6 +2939,26 @@ function lowerNetSocketMethodCall( loc, }; } + if (event === "secure") { + // The handshake's completion on a TLS socket (after secureConnect on + // a client); plain sockets never fire it. + const { cb } = lowerCallbackArg( + lowerer, + args[1]!, + "secure listeners", + 0, + () => false, + "use ()", + [], + ); + return { + kind: "libCall", + fn: "tls.sockOnSecure", + args: [receiver, cb, once], + type: VOID, + loc, + }; + } if (event === "session") { // The received-ticket event: fires once per TLS client socket with // the serialized session (a Buffer); plain sockets never fire it. @@ -2962,7 +2982,7 @@ function lowerNetSocketMethodCall( lowerer.noLowering( `socket.${name}(${event === null ? "non-literal event" : `"${event}"`}, ...)`, args[0]!, - '"data", "end", "close", "error", "connect", "lookup", "ready", "timeout", "readable", "secureConnect", and "session" are the supported socket events (as literals)', + '"data", "end", "close", "error", "connect", "lookup", "ready", "timeout", "readable", "secureConnect", "secure", and "session" are the supported socket events (as literals)', ); } lowerer.noLowering( @@ -4676,6 +4696,125 @@ export function lowerHttpServerNew(lowerer: Lowerer, expr: ts.NewExpression): Ir return lowerHttpCreateServerForms(lowerer, expr, "new http.Server", locOf(expr)); } +/** `new tls.TLSSocket(socket, options)` in server mode: a new TLS socket + * takes over the socket's connection and runs the server handshake + * (scr_tls_wrap_socket). The options record reads at runtime, the + * tls.connect precedent. A literal's secureContext member is a + * SecureContext handle, which the checked-dynamic record cannot hold, so + * it passes as its own argument; members after it must be free of side + * effects, because it is read after them. Node never starts the handshake + * of a client-mode TLSSocket, so a literal without isServer: true fences + * here. */ +export function lowerTlsSocketNew(lowerer: Lowerer, expr: ts.NewExpression): IrExpr | null { + const callee = expr.expression; + const isTlsSocket = + (ts.isPropertyAccessExpression(callee) && + callee.name.text === "TLSSocket" && + lowerer.builtinMemberOf(callee)?.module === "tls") || + (ts.isIdentifier(callee) && + lowerer.builtinImportOf(callee)?.module === "tls" && + lowerer.builtinImportOf(callee)?.member === "TLSSocket"); + if (!isTlsSocket) return null; + const loc = locOf(expr); + const HINT = + "the supported forms are new tls.TLSSocket(socket, { isServer: true, cert, key }) and new tls.TLSSocket(socket, { isServer: true, secureContext })"; + const args = expr.arguments?.nodes ?? []; + if (args.length !== 2 || args.some(ts.isSpreadElement)) { + lowerer.noLowering(`new tls.TLSSocket with ${args.length} argument(s)`, expr, HINT); + } + const socket = lowerer.lowerExpr(args[0]!); + if (socket.type.kind !== "netSocket") { + lowerer.noLowering( + `new tls.TLSSocket over a '${lowerer.fmt(socket.type)}' value`, + args[0]!, + "the wrapped value must be a net.Socket (a server connection or an http CONNECT socket)", + ); + } + let optsNode: ts.Expression = args[1]!; + while (ts.isParenthesizedExpression(optsNode)) optsNode = optsNode.expression; + if (!ts.isObjectLiteralExpression(optsNode)) { + const o = lowerer.lowerExpr(optsNode); + const opts: IrExpr = + o.type.kind === "dyn" + ? o + : canConvertToDyn( + o.type, + (id) => lowerer.shapes.get(id), + (id) => lowerer.unions.get(id), + ) + ? { kind: "dynFrom", value: o, type: DYN, loc } + : lowerer.noLowering( + `new tls.TLSSocket with a '${lowerer.fmt(o.type)}' options record`, + optsNode, + `${HINT} — a secureContext member lowers in an options object literal`, + ); + return { kind: "libCall", fn: "tls.wrapSocket", args: [socket, opts], type: NETSOCKET_T, loc }; + } + const props = optsNode.properties.nodes; + const nameOf = (p: ts.ObjectLiteralElementLike): string | null => + (ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) && + (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name)) + ? p.name.text + : null; + const isServer = props.find((p) => nameOf(p) === "isServer"); + if ( + isServer === undefined || + (ts.isPropertyAssignment(isServer) && isServer.initializer.kind === ts.SyntaxKind.FalseKeyword) + ) { + lowerer.noLowering( + "new tls.TLSSocket in client mode", + optsNode, + "Node starts no handshake for a client-mode TLSSocket — pass isServer: true for the server side; tls.connect makes client sockets", + ); + } + const ctxIndex = props.findIndex((p) => nameOf(p) === "secureContext"); + if (ctxIndex < 0) { + const opts = lowerDynObjectLiteral(lowerer, optsNode); + return { kind: "libCall", fn: "tls.wrapSocket", args: [socket, opts], type: NETSOCKET_T, loc }; + } + const ctxProp = props[ctxIndex]!; + const ctxNode = ts.isShorthandPropertyAssignment(ctxProp) + ? ctxProp.name + : (ctxProp as ts.PropertyAssignment).initializer; + for (const p of props.slice(ctxIndex + 1)) { + const pure = + ts.isShorthandPropertyAssignment(p) || + (ts.isPropertyAssignment(p) && sideEffectFreeOptionValue(p.initializer)); + if (!pure) { + lowerer.noLowering( + "a new tls.TLSSocket options literal with side effects after secureContext", + p, + "secureContext is read after the other members — move it to the end of the object", + ); + } + } + let ctx: IrExpr | null = null; + const opts = lowerDynObjectLiteral(lowerer, optsNode, (node, value) => { + if (node !== ctxNode) return lowerer.coerceToExpected(value, DYN); + if (value.type.kind !== "secureCtx") { + lowerer.noLowering( + `a '${lowerer.fmt(value.type)}' secureContext`, + node, + "pass a tls.createSecureContext({ cert, key }) result", + ); + } + ctx = value; + return { + kind: "dynFrom", + value: { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc }, + type: DYN, + loc, + }; + }); + return { + kind: "libCall", + fn: "tls.wrapSocketCtx", + args: [socket, opts, ctx!], + type: NETSOCKET_T, + loc, + }; +} + /** Module-function calls on http import bindings: createServer([options][, * handler]) and the call-form Server (Node's constructor works without * `new` — test/parallel's http.Server(fn) spelling). The handler takes @@ -4985,14 +5124,14 @@ function lowerTlsServerOptionsOrDyn( * connect(options[, cb]) and connect(port[, host][, options][, cb]) with * a RUNTIME options record (the checked-dynamic JS lane's shape — a dyn * value, or a record that converts): the runtime walk implements - * port/host/rejectUnauthorized/ca/servername/ALPNProtocols/minVersion/maxVersion/timeout and throws the catchable + * port/host/socket/rejectUnauthorized/ca/servername/ALPNProtocols/minVersion/maxVersion/timeout and throws the catchable * fence for other documented members (the divergence-66 stance). The * callback (and 'secureConnect'/'connect' listeners) fires * post-handshake — Node's secureConnect timing. */ function lowerTlsConnectCall(lowerer: Lowerer, expr: ts.CallExpression, loc: SrcLoc): IrExpr { const args = expr.arguments.nodes; const FORMS_HINT = - "the supported forms are connect(options[, cb]) and connect(port[, host][, options][, cb]) — options implement port/host/rejectUnauthorized/ca/servername/ALPNProtocols/minVersion/maxVersion/timeout"; + "the supported forms are connect(options[, cb]) and connect(port[, host][, options][, cb]) — options implement port/host/socket/rejectUnauthorized/ca/servername/ALPNProtocols/minVersion/maxVersion/timeout"; if (args.length < 1 || args.length > 4 || args.some(ts.isSpreadElement)) { lowerer.noLowering(`tls.connect with ${args.length} arguments`, expr, FORMS_HINT); } @@ -5043,7 +5182,22 @@ function lowerTlsConnectCall(lowerer: Lowerer, expr: ts.CallExpression, loc: Src // The options value rides whole to the runtime walk: dyn passes // directly; a typed record that converts boxes into the checked-dynamic tree. let opts: IrExpr; - if (optsNode !== null) { + let literal: ts.Expression | null = optsNode; + while (literal !== null && ts.isParenthesizedExpression(literal)) literal = literal.expression; + if ( + literal !== null && + ts.isObjectLiteralExpression(literal) && + literal.properties.nodes.some( + (p) => + (ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) && + ts.isIdentifier(p.name) && + p.name.text === "socket", + ) + ) { + // A socket member is a handle the record form cannot box: the literal + // builds the checked-dynamic object member by member. + opts = lowerDynObjectLiteral(lowerer, literal); + } else if (optsNode !== null) { const o = lowerer.lowerExpr(optsNode); if (o.type.kind === "dyn") { opts = o; diff --git a/packages/compiler/src/ir/builtin-effects.ts b/packages/compiler/src/ir/builtin-effects.ts index dd82d06c2..9f604e408 100644 --- a/packages/compiler/src/ir/builtin-effects.ts +++ b/packages/compiler/src/ir/builtin-effects.ts @@ -230,6 +230,8 @@ export const MAY_THROW_LIB_FNS: ReadonlySet = new Set([ "http2.createSecureServerDynCb", "tls.connect", "tls.connectCb", + "tls.wrapSocket", + "tls.wrapSocketCtx", // The CA-store surface: an unknown getCACertificates type throws // Node's ERR_INVALID_ARG_VALUE TypeError; setDefaultCACertificates // throws Node's ERR_CRYPTO_OPERATION_FAILED on a certificate-free diff --git a/packages/compiler/src/ir/builtin-signatures.ts b/packages/compiler/src/ir/builtin-signatures.ts index 8f5928d12..bcf467111 100644 --- a/packages/compiler/src/ir/builtin-signatures.ts +++ b/packages/compiler/src/ir/builtin-signatures.ts @@ -2182,6 +2182,20 @@ export const LIB_FN_SIGS = defineLibFnSignatures({ result: VOID, }, "tls.sockOnSession": { argTypes: [NETSOCKET_T, null, BOOL], result: VOID }, + /** The 'secure' event: the handshake completed (after secureConnect on + * a client). Plain sockets never fire it. */ + "tls.sockOnSecure": { + argTypes: [NETSOCKET_T, { kind: "func", params: [], ret: VOID }, BOOL], + result: VOID, + }, + /** new tls.TLSSocket(socket, options) in server mode: a new TLS socket + * takes over the socket's connection (wrapSocketCtx passes a literal's + * secureContext member apart from the runtime options record). The + * record reads at runtime: isServer, cert, key, ALPNProtocols, + * minVersion and maxVersion are implemented, the client mode and other + * documented members throw the runtime fence. MAY THROW. */ + "tls.wrapSocket": { argTypes: [NETSOCKET_T, DYN], result: NETSOCKET_T }, + "tls.wrapSocketCtx": { argTypes: [NETSOCKET_T, DYN, SECURECTX_T], result: NETSOCKET_T }, // createSecureContext({ cert, key }) mints the opaque SNI-answer handle. /** tls.createSecureContext({ cert, key }) — parses the PEM pair into an * opaque SecureContext handle (secureCtx kind) for SNI callbacks to diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7087-tls-socket-wrap.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7087-tls-socket-wrap.ts.json new file mode 100644 index 000000000..37009eaea --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7087-tls-socket-wrap.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7087-tls-socket-wrap.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7088-tls-socket-connect-tunnel.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7088-tls-socket-connect-tunnel.ts.json new file mode 100644 index 000000000..71947ecdd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7088-tls-socket-connect-tunnel.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7088-tls-socket-connect-tunnel.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7089-http-host-header-tunnels.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7089-http-host-header-tunnels.ts.json new file mode 100644 index 000000000..9b3002173 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7089-http-host-header-tunnels.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7089-http-host-header-tunnels.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/tls-socket-fences.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/tls-socket-fences.ts.json new file mode 100644 index 000000000..409766067 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/tls-socket-fences.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/tls-socket-fences.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/tls-socket-wrap.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/tls-socket-wrap.ts.json new file mode 100644 index 000000000..68346a115 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/tls-socket-wrap.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/node-types/tls-socket-wrap.ts" + ], + "diags": [] +} diff --git a/packages/runtime/src/scr_http.c b/packages/runtime/src/scr_http.c index d9876c30b..a5847e59b 100644 --- a/packages/runtime/src/scr_http.c +++ b/packages/runtime/src/scr_http.c @@ -2918,22 +2918,6 @@ static bool scr_http_conn_parse_head(ScrHttpConn *conn, size_t head_len, bool *o conn->trailer_bytes = 0; conn->trailer_fields = 0; - if (!http10 && conn->srv->require_host_header) { - bool has_host = false; - for (size_t i = 0; i < req->nheaders; i++) { - const ScrStr *name = req->hnames[i]; - if (name->len == 4 && memcmp(name->data, "host", 4) == 0) { - has_host = true; - break; - } - } - if (!has_host) { - scr_http_req_release(req); - scr_http_conn_missing_host(conn); - return true; - } - } - /* framing: chunked wins over Content-Length (RFC 9112) */ bool chunked = false; long long content_length = 0; @@ -2958,12 +2942,33 @@ static bool scr_http_conn_parse_head(ScrHttpConn *conn, size_t head_len, bool *o } } + /* HTTP/1.1 requires Host (requireHostHeader). CONNECT requests, and + * upgrade requests an 'upgrade' listener takes, leave the parser before + * Node's check. */ + bool is_connect = req->method->len == 7 && memcmp(req->method->data, "CONNECT", 7) == 0; + bool takes_upgrade = has_upgrade_hdr && conn_upgrade_token && conn->srv->upgrade_ls.n > 0; + if (!http10 && conn->srv->require_host_header && !is_connect && !takes_upgrade) { + bool has_host = false; + for (size_t i = 0; i < req->nheaders; i++) { + const ScrStr *name = req->hnames[i]; + if (name->len == 4 && memcmp(name->data, "host", 4) == 0) { + has_host = true; + break; + } + } + if (!has_host) { + scr_http_req_release(req); + scr_http_conn_missing_host(conn); + return true; + } + } + /* A CONNECT request: 'connect' fires INSTEAD of 'request' — the * upgrade machinery's exact shape ((req, socket, head); the parser * steps aside; no listener destroys the socket, Node's default). The * h2 compat server's HTTP/1.1 arm lands here too; its HTTP/2 arm is * dispatched separately with the compatibility response handle. */ - if (req->method->len == 7 && memcmp(req->method->data, "CONNECT", 7) == 0) { + if (is_connect) { memmove(conn->buf, conn->buf + head_len, conn->len - head_len); conn->len -= head_len; if (!scr_net_ls_has_live(&conn->srv->connect_ls)) { diff --git a/packages/runtime/src/scr_net.c b/packages/runtime/src/scr_net.c index f091daede..8f9a68424 100644 --- a/packages/runtime/src/scr_net.c +++ b/packages/runtime/src/scr_net.c @@ -517,6 +517,9 @@ struct ScrNetSocket { int remote_port_cache; bool remote_v6_cache; ScrStr *pending_err; /* deferred connect failure */ + /* pending_err's code when its message does not name one (static + * storage; NULL = the code the message maps to) */ + const char *pending_code; /* the caller-lookup dial (net.connect with a lookup option): true while * the lookup decides; dial_ips holds its answered addresses (+1 each), * dialed in order — a connect failure closes the fd and tries @@ -531,6 +534,9 @@ struct ScrNetSocket { size_t dial_n, dial_i; /* a host name the dial resolves first (+1; NULL for IP literals) */ ScrStr *dial_host; + /* the host a client dial was given, Node's socket._host (+1; NULL on + * server sockets): tls.connect({ socket }) verifies against it */ + ScrStr *host_name; /* the in-flight dial chain's LAST failure — surfaced (moved into * pending_err) only when the list exhausts; a later success drops it */ ScrStr *dial_err; @@ -607,6 +613,12 @@ struct ScrNetSocket { * until the proxy answers 200: writes buffer and the transport * handshake waits until the tunnel is up */ struct ScrNetTunnel *tunnel; + /* new tls.TLSSocket(socket) and tls.connect({ socket }): on the wrapped + * socket, the socket that took over its connection (+1; end() and + * destroy() act on it); on that socket, the one it took over (+1; its + * 'close' fires just before this socket's, as in Node) */ + struct ScrNetSocket *adopted_by; + struct ScrNetSocket *adopted_from; }; /* The CONNECT head still being sent from out_off, and the proxy's @@ -616,6 +628,9 @@ typedef struct ScrNetTunnel { size_t out_len, out_off; char *in; size_t in_len; + /* bytes a wrapped socket left unsent, which go out before the + * transport's own; no response head is read */ + bool send_only; } ScrNetTunnel; /* The 'lookup' event's half of the runtime, installed by the first @@ -712,6 +727,7 @@ void scr_net_sock_release(ScrNetSocket *s) { free(s->dial_ips); scr_str_release(s->dial_err); scr_str_release(s->dial_host); + scr_str_release(s->host_name); scr_str_release(s->unix_path); scr_net_ls_drop(&s->lookup_ls); if (s->lookup_evs != NULL) scr_net_lookup_ops->free(s); @@ -721,6 +737,8 @@ void scr_net_sock_release(ScrNetSocket *s) { if (s->pipe_dst) scr_net_sock_release(s->pipe_dst); if (s->conn_pending) scr_net_server_release(s->conn_pending); if (s->server) scr_net_server_release(s->server); + if (s->adopted_by) scr_net_sock_release(s->adopted_by); + if (s->adopted_from) scr_net_sock_release(s->adopted_from); if (s->fd >= 0) scr_net_close_fd_raw(s->fd); #ifdef SCR_RC_AUDIT scr_net_live--; @@ -962,7 +980,7 @@ static ScrNetSocket *scr_net_sock_new(void) { static void scr_net_sock_update_read(ScrNetSocket *s) { bool want = s->fd >= 0 && !s->connecting && !s->rd_eof && !s->user_paused && (s->data_ls.n > 0 || s->pipe_dst != NULL || s->native_data != NULL || - s->tunnel != NULL /* the proxy's CONNECT answer */ || + (s->tunnel != NULL && !s->tunnel->send_only) /* the proxy's CONNECT answer */ || s->flowing /* resume(): flow (and discard sans listeners) */ || s->readable_ls.n > 0 /* paused-mode consumer: bytes buffer */ || s->tops != NULL /* a transport is ALWAYS a consumer: the TLS @@ -977,7 +995,8 @@ static void scr_net_sock_update_read(ScrNetSocket *s) { * finished socket the same way */ || (!s->eof_pending && s->rlen - s->rhead < SCR_NET_READ_AHEAD) /* no consumer yet: read ahead into the buffer, as Node's - * stream does up to its high-water mark */); + * stream does up to its high-water mark */) && + !(s->tunnel != NULL && s->tunnel->send_only); if (want && !s->read_armed) { scr_net_watch_read(s->fd, s, true); s->read_armed = true; @@ -1056,6 +1075,23 @@ static void scr_net_sock_buffer(ScrNetSocket *s, const char *data, size_t len) { * dead or ended write half (Node fires 'error' there; this slice drops — * SEMANTICS.md documents the bound). */ static void scr_net_sock_write_raw(ScrNetSocket *s, const char *data, size_t len) { + if (s->adopted_by != NULL) { + /* Node writes these bytes to the wire as they are, between the TLS + * records of the socket that took over (the peer then fails the + * session). Bytes the kernel cannot take now end that socket. */ + ScrNetSocket *t = s->adopted_by; + while (len > 0 && t->fd >= 0) { + ssize_t sent = scr_net_send(t->fd, data, len); + if (sent < 0 && errno == EINTR) continue; + if (sent <= 0) { + scr_net_sock_destroy(t); + break; + } + data += sent; + len -= (size_t)sent; + } + return; + } /* A socket whose dial hasn't STARTED yet (the agent's deferred dial, * the caller-lookup wait) has no fd but is logically connecting — * bytes buffer and flush at establishment like any mid-connect write. */ @@ -1490,6 +1526,12 @@ static void scr_net_sock_tunnel_pump(ScrNetSocket *s) { } scr_net_sock_update_write(s); if (s->fd < 0 || t->out_off < t->out_len) return; + if (t->send_only) { + scr_net_tunnel_free(t); + s->tunnel = NULL; + scr_net_sock_connected(s); + return; + } for (;;) { char buf[4096]; ssize_t n = read(s->fd, buf, sizeof buf); @@ -1592,6 +1634,10 @@ static void scr_net_sock_transport_pump(ScrNetSocket *s) { if (scr_exc_pending()) return; scr_net_fire0_this(&s->ready_ls, s, SCR_DYNH_NET_SOCKET); if (scr_exc_pending()) return; + if (s->tops->after_established) { + s->tops->after_established(s->tctx); + if (scr_exc_pending()) return; + } scr_net_sock_flush(s); scr_net_sock_update_read(s); scr_net_sock_update_write(s); @@ -2250,6 +2296,8 @@ ScrStr *scr_net_blocking_lookup(ScrStr *host /*borrowed*/) { * autoselect), and any other name is resolved when the dial starts. */ static void scr_net_sock_set_peer(ScrNetSocket *s, ScrStr *host /*borrowed, nullable*/) { const char *h = host && host->len > 0 ? host->data : "localhost"; + scr_str_release(s->host_name); + s->host_name = scr_str_new(h, strlen(h)); if (strcmp(h, "localhost") == 0) { h = "127.0.0.1"; if (scr_net_lookup_ops != NULL) scr_net_lookup_ops->record(s, "localhost", 9, h, 4, NULL); @@ -3024,6 +3072,10 @@ void scr_net_sock_write_bytes(ScrNetSocket *s, ScrBytes *data /*borrowed*/) { } void scr_net_sock_end(ScrNetSocket *s) { + if (s->adopted_by != NULL) { + scr_net_sock_end(s->adopted_by); + return; + } if (s->fd < 0 || s->wr_ending) return; s->wr_ending = true; scr_net_sock_maybe_finish_write(s); @@ -3136,7 +3188,10 @@ void scr_net_sock_on_write_flush(ScrNetSocket *s, ScrClosure *cb /*moves*/) { double scr_net_sock_bytes_written(ScrNetSocket *s) { return (double)s->bytes_written; } /* socket.readable: true until the read half is done (peer FIN / destroy). */ -bool scr_net_sock_readable(ScrNetSocket *s) { return s->fd >= 0 && !s->rd_eof; } +bool scr_net_sock_readable(ScrNetSocket *s) { + if (s->adopted_by != NULL) return scr_net_sock_readable(s->adopted_by); + return s->fd >= 0 && !s->rd_eof; +} /* socket.setTimeout(ms): ms > 0 arms the idle timer NOW (Node starts the * clock at the call — connecting time counts), ms <= 0 disables. */ @@ -3206,6 +3261,7 @@ ScrStr *scr_net_sock_remote_family(ScrNetSocket *s) { /* socket.localAddress / localPort / localFamily: read from the open * socket (undefined while connecting and after close, as in Node). */ static bool scr_net_sock_local(ScrNetSocket *s, char *addr, size_t cap, int *port, bool *v6) { + if (s->adopted_by != NULL) return scr_net_sock_local(s->adopted_by, addr, cap, port, v6); if (s->fd < 0 || s->connecting || s->dial_deferred || s->lookup_wait) return false; struct sockaddr_storage ss; socklen_t len = sizeof ss; @@ -4652,6 +4708,10 @@ bool scr_net_is_ipv4(const ScrDyn *input) { return scr_net_is_ip(input) == 4; } bool scr_net_is_ipv6(const ScrDyn *input) { return scr_net_is_ip(input) == 6; } void scr_net_sock_destroy(ScrNetSocket *s) { + if (s->adopted_by != NULL) { + scr_net_sock_destroy(s->adopted_by); + return; + } if (s->fd < 0 && !s->in_registry) return; s->rd_eof = true; s->wr_done = true; @@ -4833,7 +4893,8 @@ void scr_net_sock_on_error(ScrNetSocket *s, ScrClosure *cb /*moves*/, ScrChildEr } void scr_net_sock_on_connect(ScrNetSocket *s, ScrClosure *cb /*moves*/, bool once) { - if (s->close_emitted || (!s->connecting && s->fd < 0)) { + /* a socket that took over another's connection never emits 'connect' */ + if (s->close_emitted || (!s->connecting && s->fd < 0) || s->adopted_from != NULL) { scr_closure_release(cb); return; } @@ -4939,12 +5000,15 @@ void scr_net_sock_clear_native_reader(ScrNetSocket *s) { /* socket.destroyed — true once the fd is gone (destroy() or full close), * Node's flag for "this stream is done". */ -bool scr_net_sock_destroyed(ScrNetSocket *s) { return s->fd < 0; } +bool scr_net_sock_destroyed(ScrNetSocket *s) { + return s->adopted_by != NULL ? scr_net_sock_destroyed(s->adopted_by) : s->fd < 0; +} /* socket.writable — Node's stream flag: the write half is open (no end() * yet, no FIN sent, fd alive). Connecting sockets answer true — writes * queue, exactly Node. */ bool scr_net_sock_writable(ScrNetSocket *s) { + if (s->adopted_by != NULL) return scr_net_sock_writable(s->adopted_by); return s->fd >= 0 && !s->wr_ending && !s->wr_done; } @@ -4996,8 +5060,78 @@ void scr_net_sock_set_transport(ScrNetSocket *s, const ScrNetTransportOps *ops, scr_net_sock_update_write(s); } +/* A fresh socket takes over raw's open connection: the fd, the bytes it + * buffered either way and the peer identity. raw keeps its listeners and + * its server's accounting but does no I/O of its own; end() and destroy() + * on it act on the new socket, and its 'close' fires just before the new + * socket's. Bytes raw had not sent yet go out first. +1; the caller sets + * the transport, then starts it with scr_net_sock_adopt_start. NULL when + * raw has no open, idle connection to give (connecting, closed, already + * wrapped, or carrying a transport). */ +ScrNetSocket *scr_net_sock_adopt(ScrNetSocket *raw) { + if (raw->fd < 0 || scr_net_sock_connecting(raw) || raw->adopted_by != NULL || raw->tops != NULL) + return NULL; + ScrNetSocket *t = scr_net_sock_new(); + scr_str_release(scr_net_sock_remote_address(raw)); /* cache the peer while the fd is raw's */ + if (raw->remote_cache) { + t->remote_cache = scr_str_retain(raw->remote_cache); + t->remote_port_cache = raw->remote_port_cache; + t->remote_v6_cache = raw->remote_v6_cache; + } + memcpy(t->peer_ip, raw->peer_ip, sizeof t->peer_ip); + t->peer_port = raw->peer_port; + t->unrefd = raw->unrefd; + t->rd_eof = raw->rd_eof; + scr_net_sock_timer_cancel(raw); + if (raw->read_armed) scr_net_watch_read(raw->fd, raw, false); + if (raw->write_armed) scr_net_watch_write(raw->fd, raw, false); + raw->read_armed = raw->write_armed = false; + t->fd = raw->fd; + raw->fd = -1; + if (raw->rlen > raw->rhead) scr_net_sock_append_rbuf(t, raw->rbuf + raw->rhead, raw->rlen - raw->rhead); + raw->rhead = raw->rlen = 0; + while (raw->wlen > raw->whead) { + ssize_t sent = scr_net_send(t->fd, raw->wbuf + raw->whead, raw->wlen - raw->whead); + if (sent < 0 && errno == EINTR) continue; + if (sent <= 0) break; /* EAGAIN, or an error the transport will meet */ + raw->whead += (size_t)sent; + } + if (raw->wlen > raw->whead) { + ScrNetTunnel *tun = calloc(1, sizeof *tun); + if (!tun) scr_net_oom(); + tun->out_len = raw->wlen - raw->whead; + tun->out = malloc(tun->out_len); + if (!tun->out) scr_net_oom(); + memcpy(tun->out, raw->wbuf + raw->whead, tun->out_len); + tun->send_only = true; + t->tunnel = tun; + } + raw->whead = raw->wlen = 0; + raw->adopted_by = scr_net_sock_retain(t); + t->adopted_from = scr_net_sock_retain(raw); + scr_net_sock_register(t); + return t; +} + +/* Starts an adopted socket once its transport is set: the unsent bytes + * drain first, then the handshake runs (over any bytes raw had already + * read). */ +void scr_net_sock_adopt_start(ScrNetSocket *t) { + if (t->tunnel != NULL) { + scr_net_sock_update_write(t); + return; + } + /* the handshake starts from the poller (the socket is writable), never + * the constructing stack — Node's start is asynchronous too */ + scr_net_sock_transport_want_write(t); +} + int scr_net_sock_fd(ScrNetSocket *s) { return s->fd; } +/* The host a client socket was told to dial (Node's socket._host). +1; + * NULL on server sockets. */ +ScrStr *scr_net_sock_dial_name(ScrNetSocket *s) { return scr_str_retain(s->host_name); } + /* Drain up to n bytes of the receive buffer (peeked/unshifted bytes) — * consumers call this BEFORE the fd so re-queued bytes keep their * position in the stream. */ @@ -5050,6 +5184,32 @@ void scr_net_sock_replay(ScrNetSocket *s, const char *data, size_t len) { s->rcap = total; } +/* The peer closed before the handshake finished, on a socket whose + * stream the program already holds (new tls.TLSSocket): 'end', then + * 'close' without an error, as Node reports it. */ +void scr_net_sock_transport_eof(ScrNetSocket *s) { + scr_net_sock_eof(s); + if (s->fd >= 0) scr_net_sock_close_fd(s); +} + +/* A listener for the handshake's completion once TCP is up (a socket + * tls.connect({ socket }) took over is up from the start): it registers + * until the transport establishes. */ +void scr_net_sock_on_established(ScrNetSocket *s, ScrClosure *cb /*moves*/, bool once) { + if (s->close_emitted || s->fd < 0 || s->tops == NULL || s->t_est) { + scr_closure_release(cb); + return; + } + scr_net_ls_add(&s->conn_ls, cb, NULL, once); +} + +/* scr_net_sock_transport_error with the error's code given (static + * storage), for messages whose text does not name it. */ +void scr_net_sock_transport_error_code(ScrNetSocket *s, const char *msg, const char *code) { + if (!s->pending_err) s->pending_code = code; + scr_net_sock_transport_error(s, msg); +} + void scr_net_sock_transport_error(ScrNetSocket *s, const char *msg) { if (msg != NULL) { if (!s->pending_err) s->pending_err = scr_str_new(msg, strlen(msg)); @@ -5141,6 +5301,71 @@ static void scr_net_server_settle(ScrNetServer *srv) { scr_net_server_unregister(srv); } +/* Fires a closed socket's 'close' and settles it: its server's count + * drains, the protocol layer hears it, listeners drop and it leaves the + * registry. A socket that took over another's connection settles that one + * first, so the wrapped socket's 'close' comes just before its own. False + * with an exception pending. */ +static bool scr_net_sock_settle(ScrNetSocket *sock) { + ScrNetSocket *raw = sock->adopted_from; + if (raw != NULL) { + sock->adopted_from = NULL; + if (raw->adopted_by == sock) { + raw->adopted_by = NULL; + scr_net_sock_release(sock); + } + bool ok = raw->close_emitted || scr_net_sock_settle(raw); + scr_net_sock_release(raw); + if (!ok) return false; + } + sock->close_emitted = true; + sock->emit_close = false; + /* The owning server's count drains FIRST, and a now-drained closing + * server settles before this socket's own 'close' fires — Node's + * observed order (differential: the net-echo fixture). */ + if (sock->server) { + ScrNetServer *srv = sock->server; + sock->server = NULL; + srv->nconns--; + if (srv->closing && srv->nconns == 0 && !srv->close_emitted) { + scr_net_server_settle(srv); + } + scr_net_server_release(srv); + if (scr_exc_pending()) return false; + } + if (sock->native_closed) { + sock->native_closed(sock->native_ctx); + if (scr_exc_pending()) return false; + } + { + ScrDyn *had_error = scr_dyn_new_bool(sock->had_error); + scr_net_fire_arg_this(&sock->close_ls, had_error, sock, SCR_DYNH_NET_SOCKET); + scr_dyn_release(had_error); + } + /* settle: listeners drop (cycle story) */ + scr_net_ls_drop(&sock->data_ls); + scr_net_ls_drop(&sock->end_ls); + scr_net_ls_drop(&sock->close_ls); + scr_net_ls_drop(&sock->err_ls); + scr_net_ls_drop(&sock->conn_ls); + scr_net_ls_drop(&sock->timeout_ls); + scr_net_ls_drop(&sock->readable_ls); + scr_net_ls_drop(&sock->finish_ls); + scr_net_ls_drop(&sock->wcb_ls); + scr_net_ls_drop(&sock->ready_ls); + scr_net_ls_drop(&sock->lookup_ls); + if (sock->pipe_dst) { + scr_net_sock_release(sock->pipe_dst); + sock->pipe_dst = NULL; + } + if (sock->conn_pending) { + scr_net_server_release(sock->conn_pending); + sock->conn_pending = NULL; + } + scr_net_sock_unregister(sock); + return !scr_exc_pending(); +} + /* Sockets first (a dying connection may drain its server), servers after. * Every fire checks for a pending exception and bails — the loop surfaces * it as an uncaught throw. */ @@ -5200,7 +5425,19 @@ static void scr_net_sweep(void) { * listeners — and the unhandled-'error' exit */ bool consumed = false; if (sock->native_err) consumed = sock->native_err(sock->native_ctx, msg); - if (!consumed && !scr_exc_pending()) scr_net_fire_err_this(&sock->err_ls, msg, sock, SCR_DYNH_NET_SOCKET); + if (!consumed && !scr_exc_pending()) { + ScrError *coded = NULL; + ScrError *saved = scr_event_error_payload; + if (sock->pending_code != NULL) { + coded = scr_error_new(SCR_ERR_ERROR, msg); + coded->code = scr_str_new(sock->pending_code, strlen(sock->pending_code)); + scr_event_error_payload = coded; + } + scr_net_fire_err_this(&sock->err_ls, msg, sock, SCR_DYNH_NET_SOCKET); + scr_event_error_payload = saved; + if (coded != NULL) scr_error_release(coded); + } + sock->pending_code = NULL; scr_str_release(msg); if (scr_exc_pending()) { scr_net_sock_release(sock); @@ -5208,58 +5445,7 @@ static void scr_net_sweep(void) { } } if (sock->emit_close && !sock->close_emitted && sock->fd < 0) { - sock->close_emitted = true; - sock->emit_close = false; - /* The owning server's count drains FIRST, and a now-drained closing - * server settles before this socket's own 'close' fires — Node's - * observed order (differential: the net-echo fixture). */ - if (sock->server) { - ScrNetServer *srv = sock->server; - sock->server = NULL; - srv->nconns--; - if (srv->closing && srv->nconns == 0 && !srv->close_emitted) { - scr_net_server_settle(srv); - } - scr_net_server_release(srv); - if (scr_exc_pending()) { - scr_net_sock_release(sock); - return; - } - } - if (sock->native_closed) { - sock->native_closed(sock->native_ctx); - if (scr_exc_pending()) { - scr_net_sock_release(sock); - return; - } - } - { - ScrDyn *had_error = scr_dyn_new_bool(sock->had_error); - scr_net_fire_arg_this(&sock->close_ls, had_error, sock, SCR_DYNH_NET_SOCKET); - scr_dyn_release(had_error); - } - /* settle: listeners drop (cycle story) */ - scr_net_ls_drop(&sock->data_ls); - scr_net_ls_drop(&sock->end_ls); - scr_net_ls_drop(&sock->close_ls); - scr_net_ls_drop(&sock->err_ls); - scr_net_ls_drop(&sock->conn_ls); - scr_net_ls_drop(&sock->timeout_ls); - scr_net_ls_drop(&sock->readable_ls); - scr_net_ls_drop(&sock->finish_ls); - scr_net_ls_drop(&sock->wcb_ls); - scr_net_ls_drop(&sock->ready_ls); - scr_net_ls_drop(&sock->lookup_ls); - if (sock->pipe_dst) { - scr_net_sock_release(sock->pipe_dst); - sock->pipe_dst = NULL; - } - if (sock->conn_pending) { - scr_net_server_release(sock->conn_pending); - sock->conn_pending = NULL; - } - scr_net_sock_unregister(sock); - if (scr_exc_pending()) { + if (!scr_net_sock_settle(sock)) { scr_net_sock_release(sock); return; } @@ -5504,6 +5690,17 @@ static void scr_net_cleanup_atexit(void) { scr_net_server_release(s->server); s->server = NULL; } + /* a wrapped socket and the socket that took it over hold each other */ + if (s->adopted_by) { + ScrNetSocket *t = s->adopted_by; + s->adopted_by = NULL; + scr_net_sock_release(t); + } + if (s->adopted_from) { + ScrNetSocket *raw = s->adopted_from; + s->adopted_from = NULL; + scr_net_sock_release(raw); + } scr_net_sock_unregister(s); } while (scr_net_servers) { diff --git a/packages/runtime/src/scr_net.h b/packages/runtime/src/scr_net.h index 33638f699..8f26bbf4d 100644 --- a/packages/runtime/src/scr_net.h +++ b/packages/runtime/src/scr_net.h @@ -351,8 +351,19 @@ typedef struct ScrNetTransportOps { bool (*pending)(void *tctx); void (*shutdown_write)(void *tctx); void (*free)(void *tctx); + /* nullable: runs after the established socket's 'connect' listeners + * (the TLS 'secure' event, which Node emits after secureConnect) */ + void (*after_established)(void *tctx); } ScrNetTransportOps; void scr_net_sock_set_transport(ScrNetSocket *s, const ScrNetTransportOps *ops, void *tctx); +/* new tls.TLSSocket(socket) and tls.connect({ socket }): a fresh socket + * takes over an open connection (fd, buffered bytes, peer identity); the + * old socket stays open without I/O, forwards end() and destroy(), and + * fires 'close' just before the new one. +1, or NULL when the socket has + * no open, idle connection to give. Set the transport on the result, then + * call scr_net_sock_adopt_start. */ +ScrNetSocket *scr_net_sock_adopt(ScrNetSocket *raw); +void scr_net_sock_adopt_start(ScrNetSocket *t); /* Routes a client socket through an HTTP CONNECT proxy. Call it right * after the dial (scr_net_connect to the proxy) and before any transport * is set: once TCP is up, `request` (the CONNECT head, copied) is sent @@ -366,6 +377,9 @@ void scr_net_sock_set_tunnel(ScrNetSocket *s, const char *request, size_t len); int scr_net_tunnel_status(const char *head, size_t len); void scr_net_tunnel_failure(int status, char *msg, size_t cap); int scr_net_sock_fd(ScrNetSocket *s); +/* The host a client socket was told to dial (Node's socket._host). +1; + * NULL on server sockets. */ +ScrStr *scr_net_sock_dial_name(ScrNetSocket *s); /* Drain up to n bytes of the socket's receive buffer (peeked/unshifted * bytes — the demux path); consumers call it before the fd. */ size_t scr_net_sock_take_buffered(ScrNetSocket *s, char *buf, size_t n); @@ -385,6 +399,16 @@ void scr_net_sock_replay(ScrNetSocket *s, const char *data, size_t len); * 'error' + teardown to the sweep; NULL tears down without an 'error' * event, Node's default for an unhandled server-side handshake failure. */ void scr_net_sock_transport_error(ScrNetSocket *s, const char *msg); +/* The same with the error's code given (static storage), for messages + * whose text does not name it. */ +void scr_net_sock_transport_error_code(ScrNetSocket *s, const char *msg, const char *code); +/* The peer closed before the handshake finished on a wrapped socket: + * 'end', then 'close' without an error. */ +void scr_net_sock_transport_eof(ScrNetSocket *s); +/* Registers a listener that fires when the transport establishes, once + * TCP is up (a socket that took over an open connection is up from the + * start). */ +void scr_net_sock_on_established(ScrNetSocket *s, ScrClosure *cb /*moves*/, bool once); /* Defer the server's 'connection' listeners to handshake completion — * tls.createServer's handler is the 'secureConnection' event, fired with * the socket only once the TLS layer stands (Node's timing). */ diff --git a/packages/runtime/src/scr_tls.c b/packages/runtime/src/scr_tls.c index b4d125cb2..6fa1f169d 100644 --- a/packages/runtime/src/scr_tls.c +++ b/packages/runtime/src/scr_tls.c @@ -368,6 +368,10 @@ typedef struct ScrTlsSrv { /* maxVersion TLSv1.2: the ClientHello is pre-parsed so a hello that * offers only later versions gets OpenSSL's protocol_version alert. */ bool max_tls12; + /* new tls.TLSSocket(socket, { secureContext }): the context whose + * certificate and key this config serves (+1; NULL when cert/key are the + * config's own) */ + ScrSecureCtx *ctx; } ScrTlsSrv; /* The ALPN answers (static storage — mbedTLS keeps the pointers). Plain @@ -405,6 +409,28 @@ static ScrTlsSrv *scr_tls_srv_new(const char *cert, size_t cert_len, const char return s; } +/* A server config that serves a SecureContext's certificate and key. */ +static ScrTlsSrv *scr_tls_srv_from_ctx(ScrSecureCtx *ctx /*borrowed*/) { + scr_tls_rng_init(); + ScrTlsSrv *s = calloc(1, sizeof *s); + if (!s) scr_tls_oom(); + s->rc = 1; + mbedtls_x509_crt_init(&s->cert); + mbedtls_pk_init(&s->pk); + mbedtls_ssl_config_init(&s->conf); + if (mbedtls_ssl_config_defaults(&s->conf, MBEDTLS_SSL_IS_SERVER, MBEDTLS_SSL_TRANSPORT_STREAM, + MBEDTLS_SSL_PRESET_DEFAULT) != 0) { + scr_tls_oom(); + } + mbedtls_ssl_conf_rng(&s->conf, mbedtls_ctr_drbg_random, &scr_tls_drbg); + mbedtls_ssl_conf_authmode(&s->conf, MBEDTLS_SSL_VERIFY_NONE); + s->ctx = scr_secure_ctx_retain(ctx); + if (mbedtls_ssl_conf_own_cert(&s->conf, &ctx->cert, &ctx->pk) != 0) { + scr_tls_bad_material("certificate/key pair", 0); + } + return s; +} + static ScrTlsSrv *scr_tls_srv_retain(ScrTlsSrv *s) { s->rc++; return s; @@ -419,6 +445,7 @@ static void scr_tls_srv_release(ScrTlsSrv *s) { mbedtls_x509_crt_free(&s->cert); mbedtls_pk_free(&s->pk); scr_tls_alpn_free(s->alpn); + scr_secure_ctx_release(s->ctx); free(s); } @@ -629,6 +656,14 @@ typedef struct ScrTlsSock { unsigned char *hello; /* the raw ClientHello flight, replayed at DONE */ size_t hello_len, hello_cap; ScrSecureCtx *sni_ctx; /* owned; the answer (NULL = default cert) */ + /* new tls.TLSSocket(socket, { isServer: true }): the program holds this + * socket before the handshake, so a failed handshake is its 'error' + * (tls.createServer's sockets fail without one) */ + bool wrapped; + unsigned char head[5]; /* the first bytes the peer sent (the error's wording) */ + size_t head_len; + /* the 'secure' event's listeners */ + ScrNetLs secure_ls; } ScrTlsSock; /* checkServerIdentity for an IP literal: the address must be one of the @@ -703,6 +738,16 @@ static int scr_tls_bio_send(void *ctx, const unsigned char *buf, size_t len) { return MBEDTLS_ERR_NET_SEND_FAILED; } +/* Keeps the first bytes a wrapped socket's peer sends: a handshake that + * fails on them reports what they looked like, as OpenSSL does. */ +static void scr_tls_note_head(ScrTlsSock *t, const unsigned char *buf, size_t n) { + if (!t->wrapped || t->head_len == sizeof t->head) return; + size_t take = sizeof t->head - t->head_len; + if (take > n) take = n; + memcpy(t->head + t->head_len, buf, take); + t->head_len += take; +} + static int scr_tls_bio_recv(void *ctx, unsigned char *buf, size_t len) { ScrTlsSock *t = (ScrTlsSock *)ctx; int fd = scr_net_sock_fd(t->sock); @@ -710,8 +755,12 @@ static int scr_tls_bio_recv(void *ctx, unsigned char *buf, size_t len) { /* bytes a consumer peeked and unshifted (the demux path) re-enter the * stream here, ahead of the kernel's */ size_t took = scr_net_sock_take_buffered(t->sock, (char *)buf, len); - if (took > 0) return (int)took; + if (took > 0) { + scr_tls_note_head(t, buf, took); + return (int)took; + } ssize_t n = read(fd, buf, len); + if (n > 0) scr_tls_note_head(t, buf, (size_t)n); if (n >= 0) return (int)n; /* 0 = EOF; mbedTLS maps it to CONN_EOF */ if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR) { return MBEDTLS_ERR_SSL_WANT_READ; @@ -1026,6 +1075,43 @@ void scr_tls_sni_answer(ScrClosure *self, bool has_err, ScrSecureCtx *ctx /*move scr_net_sock_release(sock); } +/* A wrapped server socket's failed handshake, reported as Node reports it + * on the TLSSocket: a peer that closed first ends the stream, a reset is + * ECONNRESET, and bytes that are not a TLS record name what they were + * (OpenSSL's reasons without the per-process prefix and source location, + * SEMANTICS.md divergence 55). */ +static void scr_tls_wrapped_failure(ScrTlsSock *t, int r) { + if (r == MBEDTLS_ERR_SSL_CONN_EOF) { + scr_net_sock_transport_eof(t->sock); + return; + } + if (r == MBEDTLS_ERR_NET_CONN_RESET) { + scr_net_sock_transport_error(t->sock, "read ECONNRESET"); + return; + } + const unsigned char *h = t->head; + bool record = t->head_len >= 3 && h[0] >= 20 && h[0] <= 23 && h[1] == 3; + if (t->head_len >= 5 && !record) { + static const char *const http[] = { "GET ", "POST ", "HEAD ", "PATCH", "OPTIO", + "DELET", "TRACE", "PUT ", NULL }; + const char *reason = "error:0A00010B:SSL routines:tls_validate_record_header:wrong version number"; + const char *code = "ERR_SSL_WRONG_VERSION_NUMBER"; + for (size_t i = 0; http[i] != NULL; i++) { + if (memcmp(h, http[i], strlen(http[i])) == 0) { + reason = "error:0A00009C:SSL routines:tls_validate_record_header:http request"; + code = "ERR_SSL_HTTP_REQUEST"; + } + } + if (memcmp(h, "CONNE", 5) == 0) { + reason = "error:0A00009B:SSL routines:tls_validate_record_header:https proxy request"; + code = "ERR_SSL_HTTPS_PROXY_REQUEST"; + } + scr_net_sock_transport_error_code(t->sock, reason, code); + return; + } + scr_net_sock_transport_error(t->sock, "server TLS handshake failed"); +} + static int scr_tls_handshake(void *tctx) { ScrTlsSock *t = (ScrTlsSock *)tctx; if (t->cli != NULL && t->cli->no_protocols) { @@ -1046,6 +1132,10 @@ static int scr_tls_handshake(void *tctx) { scr_tls_current = NULL; if (r == 0) return 1; if (r == MBEDTLS_ERR_SSL_WANT_READ || r == MBEDTLS_ERR_SSL_WANT_WRITE) return 0; + if (t->srv != NULL && t->wrapped) { + scr_tls_wrapped_failure(t, r); + return -1; + } if (t->srv != NULL) { /* Node's server default: 'tlsClientError' with no listener destroys * the socket without an error event — exactly what portless (no @@ -1133,11 +1223,20 @@ static void scr_tls_free(void *tctx) { if (t->srv) scr_tls_srv_release(t->srv); if (t->cli) scr_tls_cli_free(t->cli); scr_net_ls_drop(&t->session_ls); + scr_net_ls_drop(&t->secure_ls); free(t->hello); scr_secure_ctx_release(t->sni_ctx); free(t); } +/* The 'secure' event: after a client's secureConnect listeners, as Node + * emits it. */ +static void scr_tls_after_established(void *tctx) { + ScrTlsSock *t = (ScrTlsSock *)tctx; + scr_net_fire0_this(&t->secure_ls, t->sock, SCR_DYNH_NET_SOCKET); + scr_net_ls_drop(&t->secure_ls); +} + static const ScrNetTransportOps SCR_TLS_OPS = { .xread = scr_tls_xread, .xwrite = scr_tls_xwrite, @@ -1146,6 +1245,7 @@ static const ScrNetTransportOps SCR_TLS_OPS = { .pending = scr_tls_pending, .shutdown_write = scr_tls_shutdown_write, .free = scr_tls_free, + .after_established = scr_tls_after_established, }; /* ── the server surface ──────────────────────────────────────────────── */ @@ -2088,6 +2188,101 @@ ScrNetServer *scr_https_create_server_dyn(const ScrDyn *opts /*borrowed*/, return s; } +/* ── new tls.TLSSocket(socket, options) ───────────────────────────────── */ + +/* The server-mode wrap: a fresh TLS socket takes over raw's connection + * (scr_net_sock_adopt) and runs the server handshake over it. It serves + * `ctx` (options.secureContext, which the lowering passes apart from the + * record; borrowed, nullable) or the record's cert and key. The record + * reads at runtime like tls.createServer's: ALPNProtocols, minVersion and + * maxVersion apply, and options without a lowering throw the fence. Node + * never starts the handshake of a client-mode TLSSocket (no isServer), so + * that form throws the fence too. +1, or NULL with the exception pending. */ +static const char *const SCR_TLS_WRAP_FENCED_OPTIONS[] = { + "server", "session", "requestOCSP", "pskCallback", "enableTrace", NULL, +}; + +ScrNetSocket *scr_tls_wrap_socket(ScrNetSocket *raw, const ScrDyn *opts /*borrowed*/, + ScrSecureCtx *ctx /*borrowed, nullable*/) { + static const char api[] = "new tls.TLSSocket"; + bool is_server = false; + const ScrDyn *record = opts != NULL && opts->kind == SCR_DYN_OBJ ? opts : NULL; + for (size_t i = 0; record != NULL && i < record->v.obj.len; i++) { + const ScrDynEntry *e = &record->v.obj.entries[i]; + if (e->value->kind == SCR_DYN_UNDEF) continue; + if (strcmp(e->key, "isServer") == 0) { + is_server = scr_tls_dyn_truthy(e->value); + continue; + } + if (strcmp(e->key, "secureContext") == 0) { + scr_tls_opt_fence(api, "secureContext", + "secureContext lowers as a member of an options object literal"); + return NULL; + } + for (size_t k = 0; SCR_TLS_WRAP_FENCED_OPTIONS[k] != NULL; k++) { + if (strcmp(e->key, SCR_TLS_WRAP_FENCED_OPTIONS[k]) == 0) { + scr_tls_opt_fence(api, e->key, + "isServer, cert, key, secureContext, ALPNProtocols, minVersion and maxVersion are the implemented members"); + return NULL; + } + } + } + if (!is_server) { + scr_tls_opt_fence(api, "isServer", + "Node starts no handshake for a client-mode TLSSocket; tls.connect({ socket }) runs the client handshake over an open socket"); + return NULL; + } + /* Node serves a secureContext as it is: the record's cert, key and + * other context options are not read then */ + int min_version = 12, max_version = 13; + ScrBytes *cert = NULL, *key = NULL; + if (ctx == NULL) { + if (!scr_tls_versions_dyn(record, &min_version, &max_version)) return NULL; + if (!scr_tls_srv_opts_walk_ex(record, api, &cert, &key, true)) return NULL; + } + char **alpn = NULL; + const ScrDyn *protocols = record != NULL ? scr_dyn_obj_get(record, "ALPNProtocols", 13) : NULL; + if (protocols != NULL && protocols->kind != SCR_DYN_UNDEF && !scr_tls_alpn_dyn(protocols, &alpn)) { + scr_bytes_release(cert); + scr_bytes_release(key); + return NULL; + } + ScrTlsSrv *srv = ctx != NULL ? scr_tls_srv_from_ctx(ctx) + : scr_tls_srv_new((const char *)cert->data, cert->len, + (const char *)key->data, key->len, false); + scr_bytes_release(cert); + scr_bytes_release(key); + srv->alpn = alpn; /* moves */ + if (alpn != NULL) mbedtls_ssl_conf_alpn_protocols(&srv->conf, (const char **)srv->alpn); + if (!scr_tls_conf_versions(&srv->conf, min_version, max_version)) { + scr_tls_srv_release(srv); + scr_tls_opt_fence(api, "maxVersion", + "a version range with neither TLSv1.2 nor TLSv1.3 has no lowering"); + return NULL; + } + srv->max_tls12 = max_version == 12; + ScrNetSocket *t = scr_net_sock_adopt(raw); + if (t == NULL) { + scr_tls_srv_release(srv); + static const char msg[] = + "new tls.TLSSocket over a socket that is not connected, or is already wrapped, is not supported yet"; + scr_throw_error_msg(SCR_ERR_ERROR, msg, sizeof msg - 1); + return NULL; + } + ScrTlsSock *ts = calloc(1, sizeof *ts); + if (!ts) scr_tls_oom(); + mbedtls_ssl_init(&ts->ssl); + if (mbedtls_ssl_setup(&ts->ssl, &srv->conf) != 0) scr_tls_oom(); + ts->sock = t; + ts->srv = srv; /* moves */ + ts->wrapped = true; + if (srv->max_tls12) ts->sni_state = SCR_SNI_COLLECT; /* pre-parse the hello */ + mbedtls_ssl_set_bio(&ts->ssl, ts, scr_tls_bio_send, scr_tls_bio_recv, NULL); + scr_net_sock_set_transport(t, &SCR_TLS_OPS, ts); + scr_net_sock_adopt_start(t); + return t; +} + /* ── tls.connect (the TLS client socket) ──────────────────────────────── */ /* Node's inspect of a Buffer inside ERR_INVALID_ARG_VALUE's message: @@ -2239,7 +2434,7 @@ static const char *const SCR_TLS_CONNECT_FENCED_OPTIONS[] = { "localAddress", "localPort", "lookup", "minDHSize", "noDelay", "onread", "passphrase", "path", "pfx", "privateKeyEngine", "privateKeyIdentifier", "pskCallback", "readable", "secureContext", "secureOptions", "secureProtocol", "session", - "sessionIdContext", "sigalgs", "signal", "socket", "ticketKeys", + "sessionIdContext", "sigalgs", "signal", "ticketKeys", "writable", NULL, }; @@ -2255,6 +2450,7 @@ ScrNetSocket *scr_tls_connect_dyn(double port, ScrStr *host /*borrowed, nullable const ScrDyn *alpn_value = NULL; const ScrDyn *timeout_value = NULL; int min_version = 12, max_version = 13; + ScrNetSocket *wrap = NULL; /* options.socket: the open socket to take over */ bool ok = true; if (opts != NULL && opts->kind != SCR_DYN_UNDEF && opts->kind != SCR_DYN_NULL) { if (opts->kind != SCR_DYN_OBJ) { @@ -2322,6 +2518,15 @@ ScrNetSocket *scr_tls_connect_dyn(double port, ScrStr *host /*borrowed, nullable timeout_value = scr_tls_dyn_truthy(v) ? v : NULL; continue; } + if (strcmp(e->key, "socket") == 0) { + if (v->kind == SCR_DYN_HANDLE && v->v.handle.tag == SCR_DYNH_NET_SOCKET) { + wrap = (ScrNetSocket *)v->v.handle.ptr; + } else { + scr_tls_opt_fence("tls.connect", "socket", "a net.Socket is the implemented socket value"); + ok = false; + } + continue; + } if (strcmp(e->key, "servername") == 0) { if (v->kind == SCR_DYN_STR) servername = v->v.str; else { @@ -2333,7 +2538,7 @@ ScrNetSocket *scr_tls_connect_dyn(double port, ScrStr *host /*borrowed, nullable for (size_t k = 0; SCR_TLS_CONNECT_FENCED_OPTIONS[k] != NULL; k++) { if (strcmp(e->key, SCR_TLS_CONNECT_FENCED_OPTIONS[k]) == 0) { scr_tls_opt_fence("tls.connect", e->key, - "port/host/rejectUnauthorized/ca/servername/ALPNProtocols/minVersion/maxVersion/timeout are the implemented members of a runtime options record"); + "port/host/socket/rejectUnauthorized/ca/servername/ALPNProtocols/minVersion/maxVersion/timeout are the implemented members of a runtime options record"); ok = false; break; } @@ -2361,7 +2566,7 @@ ScrNetSocket *scr_tls_connect_dyn(double port, ScrStr *host /*borrowed, nullable timeout_ms = timeout_value->v.num; } } - if (ok && port < 0) { + if (ok && port < 0 && wrap == NULL) { scr_dyn_arg_type_fail("options.port", "of type number", scr_dyn_undefined()); ok = false; } @@ -2377,6 +2582,9 @@ ScrNetSocket *scr_tls_connect_dyn(double port, ScrStr *host /*borrowed, nullable * name otherwise (Node's servername default); "" sends no SNI. */ ScrStr *verify_host = dial_host; ScrStr *localhost_fallback = NULL; + /* over options.socket, the host that socket dialed (Node's socket._host) */ + ScrStr *socket_host = verify_host == NULL && wrap != NULL ? scr_net_sock_dial_name(wrap) : NULL; + if (socket_host != NULL) verify_host = socket_host; if (verify_host == NULL) { localhost_fallback = scr_str_new("localhost", 9); verify_host = localhost_fallback; @@ -2384,9 +2592,25 @@ ScrNetSocket *scr_tls_connect_dyn(double port, ScrStr *host /*borrowed, nullable /* Resolve for the dial only (the http client's rule): verify_host above * already holds the NAME, which is what SNI and certificate verification * must see. A null dial_host stays null — scr_net_connect's own arm. */ - ScrStr *dial_addr = dial_host != NULL ? scr_net_blocking_lookup(dial_host) : NULL; - ScrNetSocket *s = scr_net_connect(port, dial_addr, cb); /* cb fires post-handshake — secureConnect */ - if (dial_addr) scr_str_release(dial_addr); + ScrNetSocket *s; + if (wrap != NULL) { + s = scr_net_sock_adopt(wrap); + if (s == NULL) { + scr_tls_alpn_free(alpn); + scr_bytes_release(ca); + scr_closure_release(cb); + scr_str_release(localhost_fallback); + scr_str_release(socket_host); + static const char msg[] = + "tls.connect over a socket that is not connected, or is already wrapped, is not supported yet"; + scr_throw_error_msg(SCR_ERR_ERROR, msg, sizeof msg - 1); + return NULL; + } + } else { + ScrStr *dial_addr = dial_host != NULL ? scr_net_blocking_lookup(dial_host) : NULL; + s = scr_net_connect(port, dial_addr, cb); /* cb fires post-handshake — secureConnect */ + if (dial_addr) scr_str_release(dial_addr); + } ScrTlsCli *cli = scr_tls_cli_new2(verify_host, reject, ca != NULL ? (const char *)ca->data : NULL, ca != NULL ? ca->len : 0, !reject); @@ -2397,8 +2621,13 @@ ScrNetSocket *scr_tls_connect_dyn(double port, ScrStr *host /*borrowed, nullable } cli->no_protocols = !scr_tls_conf_versions(&cli->conf, min_version, max_version); scr_tls_cli_wrap(s, cli); + if (wrap != NULL) { + if (cb != NULL) scr_net_sock_on_established(s, cb, true); /* secureConnect */ + scr_net_sock_adopt_start(s); + } if (timeout_ms > 0) scr_net_sock_set_timeout(s, timeout_ms); scr_str_release(localhost_fallback); + scr_str_release(socket_host); scr_bytes_release(ca); return s; } @@ -2610,12 +2839,39 @@ ScrDyn *scr_tls_sock_alpn_protocol(ScrNetSocket *s) { return d; } +/* secureConnect: a client socket's 'connect' list fires at establishment + * (scr_net.c's transport pump), Node's secureConnect timing. Once TCP is up + * (a socket tls.connect({ socket }) took over is up from the start) the + * listener waits for the handshake instead. Server-side sockets never emit + * it. */ +static void scr_tls_add_secure_connect(ScrNetSocket *s, ScrTlsSock *t, ScrClosure *cb, bool once) { + if (t->srv != NULL) { + scr_closure_release(cb); + return; + } + if (scr_net_sock_connecting(s)) scr_net_sock_on_connect(s, cb, once); + else scr_net_sock_on_established(s, cb, once); +} + void scr_tls_sock_on_secure_connect(ScrNetSocket *s, ScrClosure *cb /*moves*/, bool once) { - if (scr_tls_sock_of(s) == NULL) { + ScrTlsSock *t = scr_tls_sock_of(s); + if (t == NULL) { scr_closure_release(cb); /* a plain socket never fires it, like Node */ return; } - scr_net_sock_on_connect(s, cb, once); /* fires at establishment — secureConnect timing */ + scr_tls_add_secure_connect(s, t, cb, once); +} + +/* The 'secure' event: the handshake completed (after secureConnect on a + * client). A plain socket never emits it, and a registration after the + * handshake comes too late, as in Node. */ +void scr_tls_sock_on_secure(ScrNetSocket *s, ScrClosure *cb /*moves*/, bool once) { + ScrTlsSock *t = scr_tls_sock_of(s); + if (t == NULL || t->established) { + scr_closure_release(cb); + return; + } + scr_net_ls_add(&t->secure_ls, cb, NULL, once); } void scr_tls_sock_on_session(ScrNetSocket *s, ScrClosure *cb /*moves*/, void *fn, bool once) { @@ -2660,9 +2916,11 @@ static bool scr_tls_dynh_on(ScrNetSocket *s, const char *event, const ScrDyn *cb ScrTlsSock *t = scr_tls_sock_of(s); if (t == NULL) return false; if (strcmp(event, "secureConnect") == 0) { - /* a TLS socket's 'connect' list fires at establishment — exactly - * Node's secureConnect timing (scr_net.c's transport pump) */ - scr_net_sock_on_connect(s, scr_dyn_listener_closure0(cb), once); + scr_tls_add_secure_connect(s, t, scr_dyn_listener_closure0(cb), once); + return true; + } + if (strcmp(event, "secure") == 0) { + scr_tls_sock_on_secure(s, scr_dyn_listener_closure0(cb), once); return true; } if (strcmp(event, "session") == 0) { diff --git a/packages/runtime/src/scr_tls.h b/packages/runtime/src/scr_tls.h index fcb221b42..cc8e3336e 100644 --- a/packages/runtime/src/scr_tls.h +++ b/packages/runtime/src/scr_tls.h @@ -62,6 +62,10 @@ ScrDyn *scr_tls_sock_get_cipher(ScrNetSocket *s); /* +1: object, undefined or ScrDyn *scr_tls_sock_alpn_protocol(ScrNetSocket *s); /* +1: string, false or null */ void scr_tls_sock_on_secure_connect(ScrNetSocket *s, ScrClosure *cb /*moves*/, bool once); void scr_tls_sock_on_session(ScrNetSocket *s, ScrClosure *cb /*moves*/, void *fn, bool once); +/* The 'secure' event: fires when the handshake completes (after the + * secureConnect listeners on a client); released unread on a plain socket + * or after the handshake. */ +void scr_tls_sock_on_secure(ScrNetSocket *s, ScrClosure *cb /*moves*/, bool once); /* ── h2 over TLS (scr_tls.c ↔ scr_http2.c): the ALPN=h2 server wrap and * the https-authority client wrap. scr_http2.c calls both directly — @@ -93,6 +97,11 @@ ScrSecureCtx *scr_tls_create_secure_context(const char *cert, size_t cert_len, c * validations first, then the pem walk (+1, or NULL with the exception * pending). Borrowed. */ ScrSecureCtx *scr_tls_create_secure_context_dyn(const ScrDyn *opts); +/* new tls.TLSSocket(socket, options) in server mode: a fresh TLS socket + * takes over socket's connection and runs the server handshake, serving + * ctx (options.secureContext; borrowed, nullable) or the options record's + * cert and key. +1, or NULL with the exception pending. */ +ScrNetSocket *scr_tls_wrap_socket(ScrNetSocket *raw, const ScrDyn *opts /*borrowed*/, ScrSecureCtx *ctx /*borrowed, nullable*/); /* tls.getCACertificates(type): validateString + the documented name set, * then the compiler-rendered fence — always leaves an exception pending. */ void scr_tls_ca_certs_chk(const ScrDyn *type, const ScrStr *fence); diff --git a/tests/corpus/7087-tls-socket-wrap.ts b/tests/corpus/7087-tls-socket-wrap.ts new file mode 100644 index 000000000..d1357a98e --- /dev/null +++ b/tests/corpus/7087-tls-socket-wrap.ts @@ -0,0 +1,104 @@ +// new tls.TLSSocket(socket, { isServer: true, ... }) over a net server's +// connection: the wrap is a new socket that runs the server handshake, with +// cert/key or a secureContext and ALPNProtocols. The wrapped socket stays +// open without I/O, destroy() on it closes both, and its 'close' fires just +// before the TLS socket's. A peer that closes, resets or sends bytes that +// are not TLS fails the handshake with Node's events and codes. +import { readFileSync } from "node:fs"; +import * as net from "node:net"; +import * as tls from "node:tls"; + +const certs = "tests/fixtures/server/certs"; +const ca = readFileSync(`${certs}/ca.pem`); +const cert = readFileSync(`${certs}/localhost.pem`); +const key = readFileSync(`${certs}/localhost-key.pem`); +const context = tls.createSecureContext({ cert, key }); + +// cert/key and ALPN: the events, the state of both sockets, and the data. +function certKey(next: () => void): void { + const server = net.createServer((raw) => { + raw.on("close", (hadError: boolean) => console.log("raw close", hadError, raw.destroyed)); + const s = new tls.TLSSocket(raw, { isServer: true, cert, key, ALPNProtocols: ["h2", "http/1.1"] }); + console.log("after wrap", raw.destroyed, raw.readyState, raw.writable, s === raw); + console.log("before handshake", s.destroyed, s.encrypted, s.alpnProtocol); + console.log("same peer", s.remoteAddress === raw.remoteAddress, s.remotePort === raw.remotePort); + s.on("connect", () => console.log("never: connect")); + s.on("secureConnect", () => console.log("never: secureConnect")); + s.on("secure", () => { + console.log("secure", s.getProtocol(), s.alpnProtocol, s.authorized, s.authorizationError); + }); + s.on("data", (chunk: Buffer) => { + console.log("server data", chunk.toString()); + s.end("pong"); + }); + s.on("end", () => console.log("server end")); + s.on("close", (hadError: boolean) => { + console.log("tls close", hadError, raw.destroyed, s.destroyed); + server.close(next); + }); + }); + server.listen(0, () => { + const port = (server.address() as net.AddressInfo).port; + const c = tls.connect({ port, host: "localhost", ca, ALPNProtocols: ["http/1.1"] }, () => { + console.log("client secureConnect", c.authorized, c.alpnProtocol); + c.write("ping"); + }); + c.on("secure", () => console.log("client secure")); + c.on("data", (chunk: Buffer) => console.log("client data", chunk.toString())); + c.on("close", () => console.log("client close")); + }); +} + +// secureContext, and destroy() on the wrapped socket. +function secureContext(next: () => void): void { + const server = net.createServer((raw) => { + raw.on("close", (hadError: boolean) => console.log("raw close", hadError)); + const s = new tls.TLSSocket(raw, { isServer: true, secureContext: context }); + s.on("secure", () => { + console.log("context secure", s.alpnProtocol); + raw.destroy(); + }); + s.on("close", (hadError: boolean) => { + console.log("tls close", hadError, s.destroyed); + server.close(next); + }); + }); + server.listen(0, () => { + const port = (server.address() as net.AddressInfo).port; + const c = tls.connect({ port, host: "localhost", ca }, () => console.log("client secureConnect")); + c.on("error", (err: Error & { code?: string }) => console.log("client error", err.code)); + c.on("close", () => console.log("client close")); + }); +} + +// Handshakes the peer fails. +function failure(mode: string, next: () => void): void { + const server = net.createServer((raw) => { + const s = new tls.TLSSocket(raw, { isServer: true, cert, key }); + s.on("secure", () => console.log("never: secure")); + s.on("error", (err: Error & { code?: string }) => console.log(mode, "error", err.code)); + s.on("end", () => console.log(mode, "end")); + s.on("close", (hadError: boolean) => { + console.log(mode, "close", hadError); + server.close(next); + }); + }); + server.listen(0, () => { + const port = (server.address() as net.AddressInfo).port; + const c = net.connect(port, "localhost", () => { + if (mode === "close") c.end(); + else if (mode === "garbage") c.end("hello there, this is not tls\r\n"); + else if (mode === "http") c.end("GET / HTTP/1.1\r\nHost: localhost\r\n\r\n"); + else c.resetAndDestroy(); + }); + c.on("error", () => {}); + }); +} + +certKey(() => + secureContext(() => + failure("close", () => + failure("garbage", () => failure("http", () => failure("reset", () => console.log("done")))), + ), + ), +); diff --git a/tests/corpus/7088-tls-socket-connect-tunnel.ts b/tests/corpus/7088-tls-socket-connect-tunnel.ts new file mode 100644 index 000000000..806575ddb --- /dev/null +++ b/tests/corpus/7088-tls-socket-connect-tunnel.ts @@ -0,0 +1,64 @@ +// An HTTPS-intercepting proxy: the http server answers CONNECT, then runs +// the TLS server side on the tunnel socket with new tls.TLSSocket and a +// secureContext; the client runs its handshake inside the tunnel with +// tls.connect({ socket }). Without a servername the client verifies against +// the host the tunnel socket dialed. +import { readFileSync } from "node:fs"; +import * as http from "node:http"; +import * as net from "node:net"; +import * as tls from "node:tls"; + +const certs = "tests/fixtures/server/certs"; +const ca = readFileSync(`${certs}/ca.pem`); +const context = tls.createSecureContext({ + cert: readFileSync(`${certs}/localhost.pem`), + key: readFileSync(`${certs}/localhost-key.pem`), +}); + +let tunnels = 0; +const proxy = http.createServer((_req, res) => { + res.end("plain"); +}); +proxy.on("connect", (req: http.IncomingMessage, socket: net.Socket, head: Buffer) => { + const id = ++tunnels; + console.log(id, "proxy connect", req.method, req.url, head.length); + socket.write("HTTP/1.1 200 Connection Established\r\n\r\n"); + const secure = new tls.TLSSocket(socket, { isServer: true, secureContext: context }); + secure.on("secure", () => console.log(id, "proxy secure", secure.getProtocol())); + secure.on("data", (chunk: Buffer) => { + console.log(id, "proxy got", chunk.toString()); + secure.end(`intercepted ${chunk.toString()}`); + }); + secure.on("close", () => { + console.log(id, "proxy tls close"); + if (id === 2) proxy.close(); + }); + socket.on("close", () => console.log(id, "tunnel close")); +}); + +function tunnel(port: number, servername: string | undefined, next: () => void): void { + const raw = net.connect(port, "localhost", () => { + raw.write("CONNECT example.test:443 HTTP/1.1\r\nHost: example.test:443\r\n\r\n"); + }); + raw.once("data", (chunk: Buffer) => { + console.log("client got", chunk.toString().split("\r\n")[0]); + const onSecure = (): void => { + console.log("client secureConnect", client.authorized); + client.write(servername ?? "no servername"); + }; + const client = + servername === undefined + ? tls.connect({ socket: raw, ca }, onSecure) + : tls.connect({ socket: raw, ca, servername }, onSecure); + client.on("data", (data: Buffer) => console.log("client data", data.toString())); + client.on("close", () => { + console.log("client close"); + next(); + }); + }); +} + +proxy.listen(0, () => { + const port = (proxy.address() as net.AddressInfo).port; + tunnel(port, "localhost", () => tunnel(port, undefined, () => console.log("done"))); +}); diff --git a/tests/corpus/7089-http-host-header-tunnels.ts b/tests/corpus/7089-http-host-header-tunnels.ts new file mode 100644 index 000000000..bc982b2d1 --- /dev/null +++ b/tests/corpus/7089-http-host-header-tunnels.ts @@ -0,0 +1,31 @@ +// An HTTP/1.1 request without a Host header gets 400 Bad Request, except +// the requests that leave the parser first: an upgrade an 'upgrade' +// listener takes, and a CONNECT (destroyed here, with no 'connect' +// listener). +import * as http from "node:http"; +import * as net from "node:net"; + +const server = http.createServer((_req, res) => res.end("request")); +server.on("upgrade", (req: http.IncomingMessage, socket: net.Socket) => { + console.log("upgrade", req.url, req.headers.host); + socket.end("HTTP/1.1 101 Switching Protocols\r\n\r\n"); +}); +function probe(head: string, next: () => void): void { + const port = (server.address() as net.AddressInfo).port; + const raw = net.connect(port, "127.0.0.1", () => raw.write(head)); + let got = ""; + raw.on("data", (d: Buffer) => { + got += d.toString(); + }); + raw.on("close", () => { + console.log("got", JSON.stringify(got.split("\r\n")[0])); + next(); + }); +} +server.listen(0, "127.0.0.1", () => { + probe("GET /ws HTTP/1.1\r\nConnection: upgrade\r\nUpgrade: websocket\r\n\r\n", () => + probe("CONNECT a:1 HTTP/1.1\r\n\r\n", () => + probe("GET / HTTP/1.1\r\nConnection: close\r\n\r\n", () => server.close()), + ), + ); +}); diff --git a/tests/diagnostics/tls-socket-fences.ts b/tests/diagnostics/tls-socket-fences.ts new file mode 100644 index 000000000..948a8312a --- /dev/null +++ b/tests/diagnostics/tls-socket-fences.ts @@ -0,0 +1,20 @@ +// new tls.TLSSocket forms that have no lowering. +import { readFileSync } from "node:fs"; +import * as net from "node:net"; +import * as tls from "node:tls"; + +const cert = readFileSync("cert.pem"); +const key = readFileSync("key.pem"); +const context = tls.createSecureContext({ cert, key }); +function alpn(): string[] { + return ["h2"]; +} + +net.createServer((socket) => { + // The client mode: Node starts no handshake for it. + new tls.TLSSocket(socket, { cert, key }); + // A member after secureContext with side effects. + new tls.TLSSocket(socket, { isServer: true, secureContext: context, ALPNProtocols: alpn() }); + // A secureContext that is not a SecureContext. + new tls.TLSSocket(socket, { isServer: true, secureContext: { cert, key } }); +}); diff --git a/tests/fixtures/node-types/tls-socket-wrap.ts b/tests/fixtures/node-types/tls-socket-wrap.ts new file mode 100644 index 000000000..4f1272b33 --- /dev/null +++ b/tests/fixtures/node-types/tls-socket-wrap.ts @@ -0,0 +1,31 @@ +// Under @types/node: an http CONNECT handler terminates TLS on the tunnel +// socket with new tls.TLSSocket, and the client runs its handshake inside +// the tunnel with tls.connect({ socket }). +import { readFileSync } from "node:fs"; +import * as http from "node:http"; +import * as net from "node:net"; +import * as tls from "node:tls"; + +const ca = readFileSync("tests/fixtures/server/certs/ca.pem"); +const cert = readFileSync("tests/fixtures/server/certs/localhost.pem"); +const key = readFileSync("tests/fixtures/server/certs/localhost-key.pem"); + +const proxy = http.createServer(); +proxy.on("connect", (req: http.IncomingMessage, socket: net.Socket) => { + socket.write("HTTP/1.1 200 Connection Established\r\n\r\n"); + const secure = new tls.TLSSocket(socket, { isServer: true, cert, key, ALPNProtocols: ["http/1.1"] }); + secure.on("secure", () => console.log("proxy secure", req.url, secure.alpnProtocol)); + secure.on("data", (chunk: Buffer) => secure.end(`intercepted ${chunk.toString()}`)); + secure.on("close", () => proxy.close()); +}); +proxy.listen(0, "127.0.0.1", () => { + const port = (proxy.address() as net.AddressInfo).port; + const raw = net.connect(port, "127.0.0.1", () => raw.write("CONNECT example.test:443 HTTP/1.1\r\n\r\n")); + raw.once("data", () => { + const client = tls.connect({ socket: raw, ca, servername: "localhost", ALPNProtocols: ["http/1.1"] }, () => { + console.log("client secureConnect", client.authorized, client.alpnProtocol); + client.write("hello"); + }); + client.on("data", (data: Buffer) => console.log("client data", data.toString())); + }); +}); diff --git a/tests/harness/__snapshots__/tls-socket-fences.ts.txt b/tests/harness/__snapshots__/tls-socket-fences.ts.txt new file mode 100644 index 000000000..e912b7649 --- /dev/null +++ b/tests/harness/__snapshots__/tls-socket-fences.ts.txt @@ -0,0 +1,26 @@ +tls-socket-fences.ts:15:29 - error SC2020: 'new tls.TLSSocket in client mode' is part of the standard library types but has no scriptc lowering yet + + 14 | // The client mode: Node starts no handshake for it. + 15 | new tls.TLSSocket(socket, { cert, key }); + | ^~~~~~~~~~~~~ + 16 | // A member after secureContext with side effects. + + hint: Node starts no handshake for a client-mode TLSSocket — pass isServer: true for the server side; tls.connect makes client sockets + +tls-socket-fences.ts:17:71 - error SC2020: 'a new tls.TLSSocket options literal with side effects after secureContext' is part of the standard library types but has no scriptc lowering yet + + 16 | // A member after secureContext with side effects. + 17 | new tls.TLSSocket(socket, { isServer: true, secureContext: context, ALPNProtocols: alpn() }); + | ^~~~~~~~~~~~~~~~~~~~~ + 18 | // A secureContext that is not a SecureContext. + + hint: secureContext is read after the other members — move it to the end of the object + +tls-socket-fences.ts:19:62 - error SC2020: 'a '{ cert: Uint8Array; key: Uint8Array }' secureContext' is part of the standard library types but has no scriptc lowering yet + + 18 | // A secureContext that is not a SecureContext. + 19 | new tls.TLSSocket(socket, { isServer: true, secureContext: { cert, key } }); + | ^~~~~~~~~~~~~ + 20 | }); + + hint: pass a tls.createSecureContext({ cert, key }) result \ No newline at end of file diff --git a/tests/harness/corpus-costs/7087-tls-socket-wrap.ts.json b/tests/harness/corpus-costs/7087-tls-socket-wrap.ts.json new file mode 100644 index 000000000..b4372e38c --- /dev/null +++ b/tests/harness/corpus-costs/7087-tls-socket-wrap.ts.json @@ -0,0 +1 @@ +{ "plain": 4491, "san": 82505 } diff --git a/tests/harness/corpus-costs/7088-tls-socket-connect-tunnel.ts.json b/tests/harness/corpus-costs/7088-tls-socket-connect-tunnel.ts.json new file mode 100644 index 000000000..8e6e4a3d0 --- /dev/null +++ b/tests/harness/corpus-costs/7088-tls-socket-connect-tunnel.ts.json @@ -0,0 +1 @@ +{ "plain": 4100, "san": 56643 } diff --git a/tests/harness/corpus-costs/7089-http-host-header-tunnels.ts.json b/tests/harness/corpus-costs/7089-http-host-header-tunnels.ts.json new file mode 100644 index 000000000..349a68037 --- /dev/null +++ b/tests/harness/corpus-costs/7089-http-host-header-tunnels.ts.json @@ -0,0 +1 @@ +{ "plain": 3401, "san": 48875 } diff --git a/tests/harness/errors.test.ts b/tests/harness/errors.test.ts index 00ee40043..96949201d 100644 --- a/tests/harness/errors.test.ts +++ b/tests/harness/errors.test.ts @@ -855,6 +855,56 @@ try { }); }); +// new tls.TLSSocket reads a runtime options record: the client mode, whose +// handshake Node never starts, and members without a lowering throw the +// fence, as do sockets it cannot take over (a second wrap, and +// tls.connect({ socket }) over a socket that is still dialing). +describe("tls.TLSSocket runtime fences", () => { + test("client mode, unlowered members and sockets that cannot be taken over throw", async () => { + const r = await compileAndRun( + "tls-socket-fences", + `import { readFileSync } from "node:fs"; +import * as net from "node:net"; +import * as tls from "node:tls"; +const certs = "tests/fixtures/server/certs"; +const cert = readFileSync(\`\${certs}/localhost.pem\`); +const key = readFileSync(\`\${certs}/localhost-key.pem\`); +function report(label: string, run: () => void): void { + try { + run(); + console.log(label, "no error"); + } catch (error) { + console.log(label, (error as Error).message); + } +} +const client: Record = { cert, key }; +const session: Record = { isServer: true, cert, key, session: Buffer.alloc(1) }; +const server: Record = { isServer: true, cert, key }; +const listener = net.createServer((raw) => { + report("client mode", () => new tls.TLSSocket(raw, client)); + report("session", () => new tls.TLSSocket(raw, session)); + const wrapped = new tls.TLSSocket(raw, server); + report("twice", () => new tls.TLSSocket(raw, server)); + wrapped.destroy(); + listener.close(); +}); +listener.listen(0, () => { + const c = net.connect((listener.address() as net.AddressInfo).port, "localhost"); + report("dialing", () => tls.connect({ socket: c })); + c.on("error", () => {}); +}); +`, + ); + expect(r.stderr).toBe(""); + expect(r.stdout).toBe( + "dialing tls.connect over a socket that is not connected, or is already wrapped, is not supported yet\n" + + "client mode new tls.TLSSocket option 'isServer' has no static lowering — Node starts no handshake for a client-mode TLSSocket; tls.connect({ socket }) runs the client handshake over an open socket\n" + + "session new tls.TLSSocket option 'session' has no static lowering — isServer, cert, key, secureContext, ALPNProtocols, minVersion and maxVersion are the implemented members\n" + + "twice new tls.TLSSocket over a socket that is not connected, or is already wrapped, is not supported yet\n", + ); + }); +}); + // A curve Node lists in crypto.getCurves() but the runtime does not // implement throws a coded SC2020 error naming the curve when the name is // computed; literal names are refused at compile time (node-types-fenced). diff --git a/tests/harness/project-config.test.ts b/tests/harness/project-config.test.ts index 8532ad6e9..7a916b4dd 100644 --- a/tests/harness/project-config.test.ts +++ b/tests/harness/project-config.test.ts @@ -307,6 +307,24 @@ test("node-types: TLSSocket.isSessionReused and keyed ??= timings under @types/n expect(comparableStderr(native.stderr)).toBe(node.stderr); }); +test("node-types: new tls.TLSSocket and tls.connect({ socket }) under @types/node", async () => { + const outDir = outDirFor("tls-socket-wrap"); + const entry = join(nodeTypesDir, "tls-socket-wrap.ts"); + const result = await compile(entry, { + outPath: join(outDir, process.platform === "win32" ? "tls-socket-wrap.exe" : "tls-socket-wrap"), + outDir, + sanitize, + }); + expect(result.ok, !result.ok ? JSON.stringify(result.diagnostics, null, 2) : "").toBe(true); + if (!result.ok) return; + const [native, node] = await Promise.all([ + execFileAsync(result.binaryPath), + execFileAsync(process.execPath, ["--disable-warning=MODULE_TYPELESS_PACKAGE_JSON", entry]), + ]); + expect(native.stdout).toBe(node.stdout); + expect(comparableStderr(native.stderr)).toBe(node.stderr); +}); + test("node-types: net.SocketAddress and net.BlockList under @types/node", async () => { const outDir = outDirFor("net-blocklist"); const entry = join(nodeTypesDir, "net-blocklist.ts"); From c09801c06402160567da0632419460a038ae1546 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 05:08:24 -0500 Subject: [PATCH 058/102] Map a JS binding's declared type only for a nullish write --- packages/compiler/src/frontend/lowering/lower-stmts.ts | 10 ++++++---- packages/compiler/src/frontend/lowering/lowerer.ts | 2 +- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/packages/compiler/src/frontend/lowering/lower-stmts.ts b/packages/compiler/src/frontend/lowering/lower-stmts.ts index 2840b0b45..687420baf 100644 --- a/packages/compiler/src/frontend/lowering/lower-stmts.ts +++ b/packages/compiler/src/frontend/lowering/lower-stmts.ts @@ -6119,14 +6119,16 @@ export function jsBindingHasOpenWrites(lowerer: Lowerer, decl: ts.VariableDeclar // types as a primitive (`offset = match[3] || null`): JavaScript files // are checked without strict null checks, so the declared type does not // admit them. - const primitive = lowerer.mapTypeOf(lowerer.typeOf(decl.name)); + // The declared type is mapped only when such a write exists. if ( - (primitive?.kind === "string" || primitive?.kind === "f64" || primitive?.kind === "bool") && candidates.some( (node) => node.operatorToken.kind === ts.SyntaxKind.EqualsToken && mayBeNullish(node.right), ) - ) - return true; + ) { + const primitive = lowerer.mapTypeOf(lowerer.typeOf(decl.name)); + if (primitive?.kind === "string" || primitive?.kind === "f64" || primitive?.kind === "bool") + return true; + } // A plain JavaScript write of a value the declared type cannot hold (the // checker does not report it): buffer-crc32 replaces its number[] table // with `new Int32Array(table)`. Only a different representation counts; diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts index f3ab173f8..edf0a694b 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -3596,7 +3596,7 @@ export class Lowerer { this.genericClassInstanceType(decl, ref, mapArgument), runtimeClassValue: (type) => runtimeClassValueOfType(this, type), localClassValue: (type) => - this.instanceResultClass?.declared === type.id + this.instanceResultClass !== null && this.instanceResultClass.declared === type.id ? this.instanceResultClass.value : (this.localClassValueTypes.get(type.id) ?? null), mixinClassInstance: (decl) => From 1917d1aa003b40808bc5fe2001e8174f2356f62a Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 05:25:02 -0500 Subject: [PATCH 059/102] Test an array read's hole-free prefix before its capacity The dense path of an element read that may be undefined (the `%arr.idxOr` reads behind `a[i]` as `T | undefined`, the store `a[x] = a[y]!`, and the element reads of the lowered array methods) tested the index against the capacity, then against the hole-free prefix (`filled`), and only above the prefix against the length and the slot's state. `filled` is at most the length and the capacity (scr_array.h), so an index below it needs no other test: the read now tests `filled` first and takes the value path on that test alone. Above the prefix it tests the capacity, the length and the state as before. A double index first branches to the runtime lookup when it is not an exact integer, then takes the same tests on its i64 value, which a 32-bit target compares before truncating it. --- .../backend/llvm/local-array-reads.test.ts | 15 +++ .../src/backend/llvm/local-array-reads.ts | 115 +++++++++--------- .../7142-array-read-filled-prefix.ts.json | 6 + tests/corpus/7142-array-read-filled-prefix.ts | 72 +++++++++++ .../7142-array-read-filled-prefix.ts.json | 1 + 5 files changed, 153 insertions(+), 56 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7142-array-read-filled-prefix.ts.json create mode 100644 tests/corpus/7142-array-read-filled-prefix.ts create mode 100644 tests/harness/corpus-costs/7142-array-read-filled-prefix.ts.json diff --git a/packages/compiler/src/backend/llvm/local-array-reads.test.ts b/packages/compiler/src/backend/llvm/local-array-reads.test.ts index 96221942f..b09029865 100644 --- a/packages/compiler/src/backend/llvm/local-array-reads.test.ts +++ b/packages/compiler/src/backend/llvm/local-array-reads.test.ts @@ -925,3 +925,18 @@ test.each([ if (consumer !== "local") expect(ir).toContain("local.array.dense"); } }); + +test("a dense read tests the hole-free prefix before the capacity", () => { + const module = immediateFixture(); + for (const bits of [32, 64] as const) { + const ir = workBody(module, bits); + // Field 6 is `filled` and field 2 `cap`: the first branch takes the value + // path below the prefix, and only the range block reads the capacity. + const firstFilled = ir.search(/getelementptr inbounds %ScrArr, ptr %[^,]+, i32 0, i32 6\b/); + const firstCap = ir.search(/getelementptr inbounds %ScrArr, ptr %[^,]+, i32 0, i32 2\b/); + expect(firstFilled).toBeGreaterThan(0); + expect(firstCap).toBeGreaterThan(firstFilled); + expect(ir.slice(firstFilled, firstCap)).toMatch(/br i1 [^,]+, label %local\.array\.value/); + expect(ir.lastIndexOf("local.array.range", firstCap)).toBeGreaterThan(firstFilled); + } +}); diff --git a/packages/compiler/src/backend/llvm/local-array-reads.ts b/packages/compiler/src/backend/llvm/local-array-reads.ts index b9fd0f54b..45d046e1f 100644 --- a/packages/compiler/src/backend/llvm/local-array-reads.ts +++ b/packages/compiler/src/backend/llvm/local-array-reads.ts @@ -12,7 +12,7 @@ import { everyStmtList } from "../../ir/traverse.js"; import { analyzeCallLifetimes, type CallLifetimes } from "./call-lifetimes.js"; import type { LlValue, LlvmEmitterContext } from "./expr-context.js"; import { ReferenceEffects } from "./reference-effects.js"; -import { SCR_ARR_FIELD, exactIndexLines, loadArrCount, scrArrStateAt } from "./common.js"; +import { SCR_ARR_FIELD, loadArrCount, scrArrStateAt } from "./common.js"; import { exactInteger, widenInteger } from "./integer-values.js"; import { READ_FALLBACK } from "./dense-array-access.js"; @@ -472,78 +472,81 @@ function emitDenseReferenceArrayRead( loadType: "ptr" | "i64" | "i8" = "ptr", ): void { const B = host.B; - const range = B.newLabel("local.array.range"), - dense = B.newLabel("local.array.dense"); - // The dense path uses the existing ScrArr ABI. Sparse indices and - // noncanonical numeric properties retain the runtime lookup semantics. - const capPtr = B.tmp(), - cap = B.tmp(); - B.line( - `${capPtr} = getelementptr inbounds %ScrArr, ptr ${array.name}, i32 0, i32 ${SCR_ARR_FIELD.cap}`, - ); - host.markMemoryPointer(capPtr, "array:header"); - loadArrCount(host, cap, capPtr, host.fieldAliasAttachment(capPtr)); - let offset: string, inRange: string; + const header = (field: number): string => { + const ptr = B.tmp(); + B.line(`${ptr} = getelementptr inbounds %ScrArr, ptr ${array.name}, i32 0, i32 ${field}`); + host.markMemoryPointer(ptr, "array:header"); + return ptr; + }; + const valueLabel = B.newLabel("local.array.value"); + // `key` is the index compared with the array's counts and `offset` the + // index that addresses its slots. A double index that is not an exact + // integer, like a sparse or noncanonical one, keeps the runtime lookup + // semantics; an exact one compares as i64, which a 32-bit target does + // before truncating it. + let key: string, keyType: string, offset: string; if (integerIndex) { - offset = integerIndex; - inRange = B.tmp(); - B.line(`${inRange} = icmp ult ${host.sizeType} ${integerIndex}, ${cap}`); + key = offset = integerIndex; + keyType = host.sizeType; } else { - // Capacity bounds the dense slots; the length check below still decides presence. - const exact = exactIndexLines(index.name, cap, host.sizeType, () => B.tmp()); - for (const line of exact.lines) B.line(line); - inRange = exact.ok; - offset = exact.wide; + const raw = B.tmp(), + back = B.tmp(), + integral = B.tmp(), + exact = B.newLabel("local.array.exact"); + key = B.tmp(); + keyType = "i64"; + B.line(`${raw} = fptosi double ${index.name} to i64`); + B.line(`${key} = freeze i64 ${raw}`); + B.line(`${back} = sitofp i64 ${key} to double`); + B.line(`${integral} = fcmp oeq double ${back}, ${index.name}`); + B.condBr(integral, exact, slow); + B.startBlock(exact); + offset = key; if (host.sizeType !== "i64") { offset = B.tmp(); - B.line(`${offset} = trunc i64 ${exact.wide} to ${host.sizeType}`); + B.line(`${offset} = trunc i64 ${key} to ${host.sizeType}`); } } - B.condBr(inRange, range, slow); - B.startBlock(range); - B.br(dense); - B.startBlock(dense); - // The state and value paths below both index from `data`: one load here - // serves both. - const dataPtr = B.tmp(), + const widen = (count: string, type: string): string => { + if (type === keyType) return count; + const wide = B.tmp(); + B.line(`${wide} = zext ${type} ${count} to ${keyType}`); + return wide; + }; + // The state and value paths both index from `data`: one load serves both. + const dataPtr = header(SCR_ARR_FIELD.data), data = B.tmp(); - 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)}`); - // Below the hole-free prefix bound every state is a present value. - const filledPtr = B.tmp(), + // Below the hole-free prefix every state is a present value, and the + // prefix is at most the length and the capacity, so an index below it needs + // no other test before the value load. + const filledPtr = header(SCR_ARR_FIELD.filled), filled = B.tmp(), - belowFilled = B.tmp(), - lenLabel = B.newLabel("local.array.len"); - B.line( - `${filledPtr} = getelementptr inbounds %ScrArr, ptr ${array.name}, i32 0, i32 ${SCR_ARR_FIELD.filled}`, - ); - host.markMemoryPointer(filledPtr, "array:header"); + prefix = B.tmp(); B.line(`${filled} = load i32, ptr ${filledPtr}${host.fieldAliasAttachment(filledPtr)}`); - let filledSized = filled; - if (host.sizeType !== "i32") { - filledSized = B.tmp(); - B.line(`${filledSized} = zext i32 ${filled} to ${host.sizeType}`); - } - B.line(`${belowFilled} = icmp ult ${host.sizeType} ${offset}, ${filledSized}`); - const valueLabel = B.newLabel("local.array.value"); + B.line(`${prefix} = icmp ult ${keyType} ${key}, ${widen(filled, "i32")}`); if (induction) { // The state of slot i is at data + cap * (width + 1) - 1 - i, and an // inline state check makes LLVM keep -1 - i as a second induction // variable in the loop; above the prefix the runtime reads the slot. - B.condBr(belowFilled, valueLabel, slow); + B.condBr(prefix, valueLabel, slow); } else { - B.condBr(belowFilled, valueLabel, lenLabel); - B.startBlock(lenLabel); - const lenPtr = B.tmp(), + const range = B.newLabel("local.array.range"), + dense = B.newLabel("local.array.dense"); + B.condBr(prefix, valueLabel, range); + B.startBlock(range); + const capPtr = header(SCR_ARR_FIELD.cap), + cap = B.tmp(), + inRange = B.tmp(); + loadArrCount(host, cap, capPtr, host.fieldAliasAttachment(capPtr)); + B.line(`${inRange} = icmp ult ${keyType} ${key}, ${widen(cap, host.sizeType)}`); + B.condBr(inRange, dense, slow); + // Within the capacity and above the prefix, a slot below the length is + // present when its state is. + B.startBlock(dense); + const lenPtr = header(SCR_ARR_FIELD.len), len = B.tmp(), belowLen = B.tmp(); - B.line( - `${lenPtr} = getelementptr inbounds %ScrArr, ptr ${array.name}, i32 0, i32 ${SCR_ARR_FIELD.len}`, - ); - host.markMemoryPointer(lenPtr, "array:header"); loadArrCount(host, len, lenPtr, host.fieldAliasAttachment(lenPtr)); B.line(`${belowLen} = icmp ult ${host.sizeType} ${offset}, ${len}`); const stateLabel = B.newLabel("local.array.state"); diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7142-array-read-filled-prefix.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7142-array-read-filled-prefix.ts.json new file mode 100644 index 000000000..188cd12d4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7142-array-read-filled-prefix.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7142-array-read-filled-prefix.ts" + ], + "diags": [] +} diff --git a/tests/corpus/7142-array-read-filled-prefix.ts b/tests/corpus/7142-array-read-filled-prefix.ts new file mode 100644 index 000000000..11cf2f675 --- /dev/null +++ b/tests/corpus/7142-array-read-filled-prefix.ts @@ -0,0 +1,72 @@ +// Element reads that may be undefined (`a[i]` as `T | undefined`, and the +// stores `a[x] = a[y]!` read through) on arrays whose hole-free prefix +// changes: holes from writes past the end and from a longer length, present +// undefined, shrinking and regrowing, shift and unshift, out-of-range and +// negative indices, and reads at a loop counter and at a computed index. +function show(a: (number | undefined)[]): string { + const out: string[] = []; + for (let i = -1; i <= a.length; i++) { + const v = a[i]; + out.push(v === undefined ? (i in a ? "u" : "_") : String(v)); + } + return out.join(","); +} +const a: (number | undefined)[] = [10, 11, 12, 13, 14, 15]; +console.log(show(a)); +a[8] = 18; +console.log(show(a), 7 in a); +a.length = 9; +console.log(show(a)); +a[7] = 17; +console.log(show(a)); +a.length = 3; +console.log(show(a)); +a.push(30, 31); +console.log(show(a)); +a.unshift(1); +console.log(show(a)); +a.shift(); +a.shift(); +console.log(show(a)); +const withUndefined: (number | undefined)[] = [1, undefined, 3]; +console.log(show(withUndefined)); + +// Copies through the read: a hole stores undefined, which `in` then sees. +function rotate(p: number[], r: number): void { + const first = p[0]!; + for (let i = 0; i < r; i++) p[i] = p[i + 1]!; + p[r] = first; +} +const p: number[] = [0, 1, 2, 3, 4]; +rotate(p, 4); +console.log(p.join(",")); +const holes: number[] = new Array(4); +holes[0] = 0; +holes[1] = 1; +holes[3] = 3; +rotate(holes, 3); +console.log(holes.length, 1 in holes, holes[1] === undefined, holes.join(",")); + +// Reads at a computed index and at an index beyond the capacity. +function pick(src: number[], idx: number[]): string { + const out: string[] = []; + for (const k of idx) { + const v = src[k * 2]; + out.push(v === undefined ? "-" : String(v)); + } + return out.join(","); +} +const big: number[] = []; +for (let k = 0; k < 40; k++) big.push(k * k); +console.log(pick(big, [0, 1, 5, 19, 20, 1000, -1, 2 ** 31])); +big.length = 10; +console.log(pick(big, [0, 4, 5, 6])); + +// Swaps at two counters, then reads of the swapped array. +const q: number[] = [5, 4, 3, 2, 1, 0]; +for (let lo = 0, hi = q.length - 1; lo < hi; lo++, hi--) { + const t = q[lo]!; + q[lo] = q[hi]!; + q[hi] = t; +} +console.log(q.join(","), show(q)); diff --git a/tests/harness/corpus-costs/7142-array-read-filled-prefix.ts.json b/tests/harness/corpus-costs/7142-array-read-filled-prefix.ts.json new file mode 100644 index 000000000..c7b8ddd23 --- /dev/null +++ b/tests/harness/corpus-costs/7142-array-read-filled-prefix.ts.json @@ -0,0 +1 @@ +{ "plain": 3600, "san": 5600 } From 9893630810a26ae8f5ed817108027153a8d74ca3 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 05:26:43 -0500 Subject: [PATCH 060/102] Skip declaration files when looking for writes to a narrowed binding Narrowing stability looked for writes to a binding by walking the whole file that declares it. For globals such as `console` and `JSON` that file is a declaration file (scriptc-node-fallback.d.ts, lib.es5.d.ts), so every build that read one of them materialized about 46,000 AST nodes and kept them until the end of the build. A declaration file holds no code that runs, so none of its writes happen: the walk now returns no writes for it. --- .../compiler/src/frontend/lowering/narrowing-stability.ts | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/packages/compiler/src/frontend/lowering/narrowing-stability.ts b/packages/compiler/src/frontend/lowering/narrowing-stability.ts index 1c991c6ea..63e503221 100644 --- a/packages/compiler/src/frontend/lowering/narrowing-stability.ts +++ b/packages/compiler/src/frontend/lowering/narrowing-stability.ts @@ -454,6 +454,10 @@ export class NarrowingStability { const found = new Map(); writes = found; this.identifierWrites.set(file, found); + // A declaration file holds no code that runs, so none of its writes + // happen. Its bindings (`console`, `JSON`) are read in most programs, + // and the walk would read every node of the file. + if (file.isDeclarationFile) return writes; const add = (target: ts.Node): void => { forEachWriteTarget(target, (t) => { if (!ts.isIdentifier(t)) return; From 999fef551e00eb746f3b1a84745ccafb89e0aaf9 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 05:27:07 -0500 Subject: [PATCH 061/102] Resolve repeated checker objects from their ids without decoding them Checker replies name every type, symbol and signature they reach in full, and most of them are objects the client already holds: building tsc-ts, 96% of the types, 79% of the symbols and 80% of the signatures in replies are cached by id. Object replies are now read as bytes, each element's extent is found by a scan that skips strings, and an element whose leading "id" is cached resolves to the cached object without its text being decoded. The other elements are parsed as before. --- .../compiler/src/frontend/ts7/checker.test.ts | 15 +- .../src/frontend/ts7/semantic-checker.ts | 33 ++-- .../src/frontend/ts7/semantic-json.test.ts | 79 ++++++++- .../src/frontend/ts7/semantic-json.ts | 153 ++++++++++++++++++ .../src/frontend/ts7/semantic-model.test.ts | 5 +- .../src/frontend/ts7/semantic-model.ts | 90 ++++++++--- 6 files changed, 326 insertions(+), 49 deletions(-) diff --git a/packages/compiler/src/frontend/ts7/checker.test.ts b/packages/compiler/src/frontend/ts7/checker.test.ts index ac062b283..cb4a2e5fb 100644 --- a/packages/compiler/src/frontend/ts7/checker.test.ts +++ b/packages/compiler/src/frontend/ts7/checker.test.ts @@ -283,8 +283,9 @@ test("negative assignability answers remain independent in both directions", () requests.push(query); return JSON.stringify(query.source === 1 && query.target === 2); }, - binary: () => { - throw new Error("unexpected binary request"); + // Object replies are read as bytes; they carry the same JSON. + binary(method, payload) { + return Buffer.from(this.text(method, payload), "utf8"); }, }); const project = snapshot.addProject("project", () => undefined); @@ -324,8 +325,9 @@ test("property lookup caches hits and misses by type and name within each projec checkFlags: 0, }); }, - binary: () => { - throw new Error("unexpected binary request"); + // Object replies are read as bytes; they carry the same JSON. + binary(method, payload) { + return Buffer.from(this.text(method, payload), "utf8"); }, }); const first = snapshot.addProject("first", () => undefined); @@ -397,8 +399,9 @@ test("member type batches are bounded, reuse warm entries, and isolate absent or if (ids.includes(7)) throw new Error("checker panic"); return JSON.stringify(ids.map((id) => (id === 11 ? null : { id, flags: TypeFlags.Number }))); }, - binary: () => { - throw new Error("unexpected binary query"); + // Object replies are read as bytes; they carry the same JSON. + binary(method, payload) { + return Buffer.from(this.text(method, payload), "utf8"); }, }); const project = snapshot.addProject("members", () => undefined); diff --git a/packages/compiler/src/frontend/ts7/semantic-checker.ts b/packages/compiler/src/frontend/ts7/semantic-checker.ts index 92aa77333..5e7f8339a 100644 --- a/packages/compiler/src/frontend/ts7/semantic-checker.ts +++ b/packages/compiler/src/frontend/ts7/semantic-checker.ts @@ -1,9 +1,7 @@ import type { SemanticIndexInfoData as IndexInfoResponse, - SemanticSignatureData as SignatureResponse, SemanticSymbolData as SymbolResponse, SemanticTypePredicateData as TypePredicateResponse, - SemanticTypeData as TypeResponse, } from "./semantic-schema.generated.js"; import { AstFile, AstNode } from "./ast-node.js"; import { @@ -14,6 +12,7 @@ import { SemanticType, type SemanticDocument, type SemanticQuery, + present, } from "./semantic-model.js"; import { SemanticSymbolFlags } from "./semantic-schema.generated.js"; import type { TypePredicateKind } from "./enums.generated.js"; @@ -106,32 +105,25 @@ export class SemanticChecker { constructor(readonly project: SemanticProject) {} private type(method: string, query: SemanticQuery): SemanticType | undefined { - const data = this.project.request(method, query); - return data === null ? undefined : this.project.type(data); + return this.project.requestType(method, query); } private symbol(method: string, query: SemanticQuery): SemanticSymbol | undefined { - const data = this.project.request(method, query); - return data === null ? undefined : this.project.symbol(data); + return this.project.requestSymbol(method, query); } private signature(method: string, query: SemanticQuery): SemanticSignature | undefined { - const data = this.project.request(method, query); - return data === null ? undefined : this.project.signature(data); + return this.project.requestSignature(method, query); } private types(method: string, query: SemanticQuery): SemanticType[] { - const data = this.project.request(method, query); - return (data ?? []).map((item) => this.project.type(item)); + return present(this.project.requestTypes(method, query), method); } private symbols(method: string, query: SemanticQuery): SemanticSymbol[] { - const data = this.project.request(method, query); - return (data ?? []).map((item) => this.project.symbol(item)); + return present(this.project.requestSymbols(method, query), method); } private optionalTypes(method: string, query: SemanticQuery): (SemanticType | undefined)[] { - const data = this.project.request<(TypeResponse | null)[]>(method, query); - return data.map((item) => (item === null ? undefined : this.project.type(item))); + return this.project.requestTypes(method, query); } private optionalSymbols(method: string, query: SemanticQuery): (SemanticSymbol | undefined)[] { - const data = this.project.request<(SymbolResponse | null)[]>(method, query); - return data.map((item) => (item === null ? undefined : this.project.symbol(item))); + return this.project.requestSymbols(method, query); } getTypeAtLocation(node: AstNode): SemanticType | undefined; @@ -375,11 +367,10 @@ export class SemanticChecker { ); } getSignaturesOfType(type: SemanticType, kind: number): SemanticSignature[] { - const data = this.project.request("getSignaturesOfType", { - type: type.id, - kind, - }); - return data.map((item) => this.project.signature(item)); + return present( + this.project.requestSignatures("getSignaturesOfType", { type: type.id, kind }), + "getSignaturesOfType", + ); } getTypePredicateOfSignature(signature: SemanticSignature): SemanticTypePredicate | undefined { const data = this.project.request("getTypePredicateOfSignature", { diff --git a/packages/compiler/src/frontend/ts7/semantic-json.test.ts b/packages/compiler/src/frontend/ts7/semantic-json.test.ts index d3b8c4ae3..95bf220f2 100644 --- a/packages/compiler/src/frontend/ts7/semantic-json.test.ts +++ b/packages/compiler/src/frontend/ts7/semantic-json.test.ts @@ -1,5 +1,10 @@ import { expect, test } from "vitest"; -import { checkSemanticJsonStrings, parseSemanticJson } from "./semantic-json.js"; +import { + checkSemanticJsonStrings, + decodeSemanticObject, + decodeSemanticObjects, + parseSemanticJson, +} from "./semantic-json.js"; test("semantic JSON preserves ordinary strings, escaped slashes, quotes, pairs and nulls", () => { const values = [ @@ -57,3 +62,75 @@ test("malformed JSON remains a parse error rather than an accepted response", () expect(() => parseSemanticJson(json)).toThrow(SyntaxError); } }); + +const replyBytes = (json: string): Uint8Array => Buffer.from(json, "utf8"); + +test("semantic object replies resolve held ids without decoding them and decode the rest", () => { + const held = new Map([[7, { from: "held", id: 7 }]]); + const built: unknown[] = []; + const build = (data: { id: number }) => { + built.push(data); + return { from: "built", id: data.id }; + }; + const reply = JSON.stringify([ + { id: 7, name: "held {not} [read]", declarations: ["1.2./a.ts"] }, + null, + { id: 8, name: 'a "quoted" \\ name ]}', nested: { id: 1, list: [1, { x: "}" }] } }, + { name: "id last", id: 9 }, + ]); + expect(decodeSemanticObjects(replyBytes(reply), (id) => held.get(id), build)).toEqual([ + { from: "held", id: 7 }, + null, + { from: "built", id: 8 }, + { from: "built", id: 9 }, + ]); + expect(built).toEqual([JSON.parse(reply)[2], JSON.parse(reply)[3]]); + // The text of a held object is not decoded. + expect( + decodeSemanticObjects( + replyBytes('[{"id":7,"bad":\\ud800}, {"id":7}]'), + (id) => held.get(id), + build, + ), + ).toEqual([ + { from: "held", id: 7 }, + { from: "held", id: 7 }, + ]); +}); + +test("semantic object replies accept null, empty and single replies", () => { + const build = (data: { id: number }) => data.id; + const none = (): number | undefined => undefined; + expect(decodeSemanticObjects(replyBytes(""), none, build)).toBeNull(); + expect(decodeSemanticObjects(replyBytes("null"), none, build)).toBeNull(); + expect(decodeSemanticObjects(replyBytes(" [ ] "), none, build)).toEqual([]); + expect(decodeSemanticObjects(replyBytes('[{"id":3},\n{"id":4}]'), none, build)).toEqual([3, 4]); + expect(decodeSemanticObject(replyBytes(""), none, build)).toBeNull(); + expect(decodeSemanticObject(replyBytes("null"), none, build)).toBeNull(); + expect(decodeSemanticObject(replyBytes('{"id":12,"name":"x"}'), none, build)).toBe(12); + expect(decodeSemanticObject(replyBytes('{"id":12}'), (id) => id * 2, build)).toBe(24); + // Non-ASCII text in a decoded object round-trips. + expect( + decodeSemanticObject( + replyBytes(JSON.stringify({ id: 5, name: "héllo 🌍" })), + (): string | undefined => undefined, + (data: { id: number; name: string }) => data.name, + ), + ).toBe("héllo 🌍"); +}); + +test("semantic object replies reject malformed JSON", () => { + const build = (data: { id: number }) => data.id; + const none = (): number | undefined => undefined; + for (const json of [ + '[{"id":1}', + '[{"id":1},]', + '{"id":1} {"id":2}', + '[{"id":1} {"id":2}]', + '"open', + "nul", + ]) + expect(() => decodeSemanticObjects(replyBytes(json), none, build)).toThrow(); + for (const json of ['{"id":1', '{"id":1}}', "nul"]) + expect(() => decodeSemanticObject(replyBytes(json), none, build)).toThrow(); +}); diff --git a/packages/compiler/src/frontend/ts7/semantic-json.ts b/packages/compiler/src/frontend/ts7/semantic-json.ts index 32456c95a..3a04c741f 100644 --- a/packages/compiler/src/frontend/ts7/semantic-json.ts +++ b/packages/compiler/src/frontend/ts7/semantic-json.ts @@ -49,3 +49,156 @@ export function parseSemanticJson(json: string): T { checkSemanticJsonStrings(json, preservesJsonSurrogates); return JSON.parse(json) as T; } + +const OPEN_BRACE = 0x7b; +const CLOSE_BRACE = 0x7d; +const OPEN_BRACKET = 0x5b; +const CLOSE_BRACKET = 0x5d; +const QUOTE = 0x22; +const BACKSLASH = 0x5c; +const COMMA = 0x2c; +const LOWER_N = 0x6e; +/** `{"id":`, the start of every object reply the checker sends. */ +const ID_PREFIX = [OPEN_BRACE, QUOTE, 0x69, 0x64, QUOTE, 0x3a]; + +function isJsonSpace(byte: number): boolean { + return byte === 0x20 || byte === 0x0a || byte === 0x0d || byte === 0x09; +} + +function skipJsonSpace(bytes: Uint8Array, index: number): number { + while (index < bytes.length && isJsonSpace(bytes[index]!)) index++; + return index; +} + +function malformedReply(): never { + throw new Error("TypeScript semantic response: malformed JSON"); +} + +/** The index after the JSON value that starts at `start`: an object, an + * array, a string or a bare literal. Strings are skipped with their escapes, + * so brackets inside them do not count. */ +function jsonValueEnd(bytes: Uint8Array, start: number): number { + let depth = 0; + let index = start; + while (index < bytes.length) { + const byte = bytes[index]!; + if (byte === QUOTE) { + index++; + while (index < bytes.length && bytes[index] !== QUOTE) + index += bytes[index] === BACKSLASH ? 2 : 1; + if (index >= bytes.length) malformedReply(); + index++; + if (depth === 0) return index; + continue; + } + if (byte === OPEN_BRACE || byte === OPEN_BRACKET) depth++; + else if (byte === CLOSE_BRACE || byte === CLOSE_BRACKET) { + if (depth === 0) return index; + depth--; + if (depth === 0) return index + 1; + } else if (depth === 0 && (byte === COMMA || isJsonSpace(byte))) return index; + index++; + } + if (depth !== 0) malformedReply(); + return index; +} + +/** The id an object reply starts with (`{"id":N`), or -1 when it starts + * otherwise. */ +function leadingId(bytes: Uint8Array, start: number, end: number): number { + if (end - start < ID_PREFIX.length + 1) return -1; + for (let k = 0; k < ID_PREFIX.length; k++) if (bytes[start + k] !== ID_PREFIX[k]) return -1; + let index = start + ID_PREFIX.length; + let id = 0; + let digits = 0; + while (index < end && bytes[index]! >= 0x30 && bytes[index]! <= 0x39) { + id = id * 10 + (bytes[index]! - 0x30); + index++; + digits++; + } + if (digits === 0 || digits > 15 || (bytes[index] !== COMMA && bytes[index] !== CLOSE_BRACE)) + return -1; + return id; +} + +function parseJsonSlice(bytes: Uint8Array, start: number, end: number): T { + const text = Buffer.from(bytes.buffer, bytes.byteOffset + start, end - start).toString("utf8"); + return parseSemanticJson(text); +} + +/** One element of a reply: null, or the object with leading id `id`. Objects + * the caller already holds under that id are not decoded. */ +function replyElement( + bytes: Uint8Array, + start: number, + end: number, + cached: (id: number) => R | undefined, + build: (data: T) => R, +): R | null { + if (bytes[start] === LOWER_N) { + if (parseJsonSlice(bytes, start, end) !== null) malformedReply(); + return null; + } + const id = leadingId(bytes, start, end); + if (id >= 0) { + const known = cached(id); + if (known !== undefined) return known; + } + return build(parseJsonSlice(bytes, start, end)); +} + +/** A checker reply that is one object (with a numeric `id`) or null. An empty + * reply is null. Objects the caller already holds under their id, which a + * reply repeats whenever it names them, are returned from `cached` without + * decoding their text; the rest are decoded and handed to `build`. */ +export function decodeSemanticObject( + bytes: Uint8Array, + cached: (id: number) => R | undefined, + build: (data: T) => R, +): R | null { + const start = skipJsonSpace(bytes, 0); + if (start === bytes.length) return null; + const end = jsonValueEnd(bytes, start); + if (skipJsonSpace(bytes, end) !== bytes.length) malformedReply(); + return replyElement(bytes, start, end, cached, build); +} + +/** A checker reply that is an array of objects (each with a numeric `id`) and + * nulls, or null. An empty reply is null. Elements are resolved as in + * decodeSemanticObject. */ +export function decodeSemanticObjects( + bytes: Uint8Array, + cached: (id: number) => R | undefined, + build: (data: T) => R, +): (R | null)[] | null { + let index = skipJsonSpace(bytes, 0); + if (index === bytes.length) return null; + if (bytes[index] !== OPEN_BRACKET) { + const end = jsonValueEnd(bytes, index); + if ( + skipJsonSpace(bytes, end) !== bytes.length || + parseJsonSlice(bytes, index, end) !== null + ) + malformedReply(); + return null; + } + const result: (R | null)[] = []; + index = skipJsonSpace(bytes, index + 1); + if (bytes[index] === CLOSE_BRACKET) { + if (skipJsonSpace(bytes, index + 1) !== bytes.length) malformedReply(); + return result; + } + for (;;) { + const end = jsonValueEnd(bytes, index); + if (end === index) malformedReply(); + result.push(replyElement(bytes, index, end, cached, build)); + index = skipJsonSpace(bytes, end); + if (bytes[index] === COMMA) { + index = skipJsonSpace(bytes, index + 1); + continue; + } + if (bytes[index] !== CLOSE_BRACKET || skipJsonSpace(bytes, index + 1) !== bytes.length) + malformedReply(); + return result; + } +} diff --git a/packages/compiler/src/frontend/ts7/semantic-model.test.ts b/packages/compiler/src/frontend/ts7/semantic-model.test.ts index 36a445bc8..9d0f61a4e 100644 --- a/packages/compiler/src/frontend/ts7/semantic-model.test.ts +++ b/packages/compiler/src/frontend/ts7/semantic-model.test.ts @@ -45,8 +45,9 @@ function harness() { if (!answers.has(method)) throw new Error(`Unexpected request ${method}`); return JSON.stringify(answers.get(method)); }, - binary() { - throw new Error("Unexpected binary request"); + // Object replies are read as bytes; they carry the same JSON. + binary(method, payload) { + return Buffer.from(this.text(method, payload), "utf8"); }, }); const first = snapshot.addProject("/first.json", () => undefined); diff --git a/packages/compiler/src/frontend/ts7/semantic-model.ts b/packages/compiler/src/frontend/ts7/semantic-model.ts index 125e324c7..d3d5fe61a 100644 --- a/packages/compiler/src/frontend/ts7/semantic-model.ts +++ b/packages/compiler/src/frontend/ts7/semantic-model.ts @@ -8,7 +8,7 @@ import type { __String } from "./ast-types.js"; import type * as enums from "./enums.generated.js"; import { parseAstNodeHandle } from "./ast-wire.js"; import type { SemanticChecker, SemanticJsDocTag } from "./semantic-checker.js"; -import { parseSemanticJson } from "./semantic-json.js"; +import { decodeSemanticObject, decodeSemanticObjects, parseSemanticJson } from "./semantic-json.js"; import { SemanticObjectFlags as ObjectFlags, SemanticSignatureFlags as SignatureFlags, @@ -17,6 +17,14 @@ import { /** JSON and binary operations stay at the transport boundary. The concrete * semantic objects below need neither the SDK nor a JavaScript engine. */ +/** The elements of a reply that has no nulls: a null element fails as it + * would when read as an object. */ +export function present(items: (T | undefined)[], method: string): T[] { + for (const item of items) + if (item === undefined) throw new TypeError(`${method} returned a null element`); + return items as T[]; +} + export interface SemanticTransport { text: (method: string, payload: string) => string; binary: (method: string, payload: string) => Uint8Array; @@ -154,6 +162,54 @@ export class SemanticProject { return this.snapshot.transport.binary(method, JSON.stringify(query)); } + /** A reply of one type, or undefined for null. */ + requestType(method: string, query: SemanticQuery): SemanticType | undefined { + const bytes = this.requestBinary(method, query); + const cached = (id: number): SemanticType | undefined => this.types.get(id); + const build = (data: TypeResponse): SemanticType => this.type(data); + return decodeSemanticObject(bytes, cached, build) ?? undefined; + } + + /** A reply of types and nulls (undefined here), or [] for null. */ + requestTypes(method: string, query: SemanticQuery): (SemanticType | undefined)[] { + const bytes = this.requestBinary(method, query); + const cached = (id: number): SemanticType | undefined => this.types.get(id); + const build = (data: TypeResponse): SemanticType => this.type(data); + return (decodeSemanticObjects(bytes, cached, build) ?? []).map((item) => item ?? undefined); + } + + /** A reply of one symbol, or undefined for null. */ + requestSymbol(method: string, query: SemanticQuery): SemanticSymbol | undefined { + const bytes = this.requestBinary(method, query); + const cached = (id: number): SemanticSymbol | undefined => this.snapshot.cachedSymbol(id); + const build = (data: SymbolResponse): SemanticSymbol => this.symbol(data); + return decodeSemanticObject(bytes, cached, build) ?? undefined; + } + + /** A reply of symbols and nulls (undefined here), or [] for null. */ + requestSymbols(method: string, query: SemanticQuery): (SemanticSymbol | undefined)[] { + const bytes = this.requestBinary(method, query); + const cached = (id: number): SemanticSymbol | undefined => this.snapshot.cachedSymbol(id); + const build = (data: SymbolResponse): SemanticSymbol => this.symbol(data); + return (decodeSemanticObjects(bytes, cached, build) ?? []).map((item) => item ?? undefined); + } + + /** A reply of one signature, or undefined for null. */ + requestSignature(method: string, query: SemanticQuery): SemanticSignature | undefined { + const bytes = this.requestBinary(method, query); + const cached = (id: number): SemanticSignature | undefined => this.signatures.get(id); + const build = (data: SignatureResponse): SemanticSignature => this.signature(data); + return decodeSemanticObject(bytes, cached, build) ?? undefined; + } + + /** A reply of signatures and nulls (undefined here), or [] for null. */ + requestSignatures(method: string, query: SemanticQuery): (SemanticSignature | undefined)[] { + const bytes = this.requestBinary(method, query); + const cached = (id: number): SemanticSignature | undefined => this.signatures.get(id); + const build = (data: SignatureResponse): SemanticSignature => this.signature(data); + return (decodeSemanticObjects(bytes, cached, build) ?? []).map((item) => item ?? undefined); + } + type(data: TypeResponse): SemanticType { this.ensureActive(); let type = this.types.get(data.id); @@ -190,9 +246,9 @@ export class SemanticProject { const cached = this.types.get(handle); if (cached !== undefined) return cached; } - const data = this.request(method, { objectId: source }); - if (data === null) throw new Error(`${method} returned null type for ${source}`); - return this.type(data); + const type = this.requestType(method, { objectId: source }); + if (type === undefined) throw new Error(`${method} returned null type for ${source}`); + return type; } fetchSymbol( @@ -204,9 +260,9 @@ export class SemanticProject { if (handle === undefined || handle === 0) return undefined; const cached = this.snapshot.cachedSymbol(handle); if (cached !== undefined) return cached; - const data = this.request(method, { objectId: source }); - if (data === null) throw new Error(`${method} returned null symbol for ${source}`); - return this.symbol(data); + const symbol = this.requestSymbol(method, { objectId: source }); + if (symbol === undefined) throw new Error(`${method} returned null symbol for ${source}`); + return symbol; } fetchSignature( @@ -218,9 +274,9 @@ export class SemanticProject { if (handle === undefined || handle === 0) return undefined; const cached = this.signatures.get(handle); if (cached !== undefined) return cached; - const data = this.request(method, { objectId: source }); - if (data === null) throw new Error(`${method} returned null signature for ${source}`); - return this.signature(data); + const signature = this.requestSignature(method, { objectId: source }); + if (signature === undefined) throw new Error(`${method} returned null signature for ${source}`); + return signature; } fetchTypes(source: number, method: string, handles?: readonly number[]): SemanticType[] { @@ -234,8 +290,7 @@ export class SemanticProject { } if (cached.length === handles.length) return cached; } - const data = this.request(method, { objectId: source }); - return (data ?? []).map((item) => this.type(item)); + return present(this.requestTypes(method, { objectId: source }), method); } fetchSymbols(source: number, method: string, handles?: readonly number[]): SemanticSymbol[] { @@ -249,8 +304,7 @@ export class SemanticProject { } if (cached.length === handles.length) return cached; } - const data = this.request(method, { objectId: source }); - return (data ?? []).map((item) => this.symbol(item)); + return present(this.requestSymbols(method, { objectId: source }), method); } dispose(): void { @@ -577,9 +631,8 @@ export class SemanticType { * changes nothing or its members are unreadable too. */ private widenedConstituents(): SemanticType[] | undefined { try { - const data = this.project.request("getWidenedType", { type: this.id }); - if (data === null || data.id === this.id) return undefined; - const widened = this.project.type(data); + const widened = this.project.requestType("getWidenedType", { type: this.id }); + if (widened === undefined || widened.id === this.id) return undefined; if ((widened.flags & TypeFlags.Union) === 0) return [widened]; return this.project.fetchTypes(widened.id, "getTypesOfType"); } catch (e) { @@ -594,8 +647,7 @@ export class SemanticType { getBaseTypes(): SemanticType[] | undefined { this.project.ensureActive(); if (!this.isClassOrInterface()) return undefined; - const data = this.project.request("getBaseTypes", { type: this.id }); - return (data ?? []).map((item) => this.project.type(item)); + return present(this.project.requestTypes("getBaseTypes", { type: this.id }), "getBaseTypes"); } getTrueType(): SemanticType { const result = this.project.fetchType(this.id, "getTrueTypeOfConditionalType", this.trueType); From 6bf3b7d9df9b0a9c506392570f2fb8bece333ffb Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 05:44:28 -0500 Subject: [PATCH 062/102] Install driver-built translation units before the native build The private copy of the LLVM text had no extension. Builds that compile it with the C driver (sanitize builds, targets without the LLVM helper) passed it to clang directly when the native cache was off, and clang read it as a linker input, so the build failed. The copy is now named with `.ll`. Those builds also record the output directory in their native cache proof. Renaming the private copies to the shared names after the native build changed that directory, so every unchanged repeat missed the proof and relinked the executable. The shared names are now installed before the native build, which compiles and caches copies in a private directory outside the output directory. --- packages/cli/test/executable-cache.test.ts | 56 +++++++++++++- .../src/executable/executable-cache.test.ts | 2 +- .../src/executable/executable-cache.ts | 3 +- packages/compiler/src/index.ts | 77 +++++++++++++++++-- 4 files changed, 127 insertions(+), 11 deletions(-) diff --git a/packages/cli/test/executable-cache.test.ts b/packages/cli/test/executable-cache.test.ts index a0131f14f..ee8027765 100644 --- a/packages/cli/test/executable-cache.test.ts +++ b/packages/cli/test/executable-cache.test.ts @@ -1,12 +1,13 @@ import { execFile } from "node:child_process"; import { createRequire } from "node:module"; -import { chmod, mkdir, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises"; +import { chmod, mkdir, mkdtemp, readdir, readFile, rm, stat, writeFile } from "node:fs/promises"; import { tmpdir } from "node:os"; import { delimiter, dirname, join } from "node:path"; import { promisify } from "node:util"; import { expect, test } from "vitest"; import { precompiledRuntimePackTarget } from "../../compiler/src/startup-cache.js"; import { platformLinkerSupportsPersistentCache } from "../../compiler/src/backend/linker.js"; +import { toolchainEnvironmentCachePolicy } from "../../compiler/src/backend/toolchain-environment.js"; const execFileAsync = promisify(execFile); const require = createRequire(import.meta.url); @@ -102,6 +103,59 @@ test("exact executable repeats skip lowering while edits and damaged outputs sta } }, 120_000); +// Sanitize builds compile the LLVM text with the C driver rather than linking a precompiled +// runtime pack, and that route's native cache proof records the output directory. +test.skipIf(process.platform === "win32")( + "sanitize builds compile uncached and keep the executable on unchanged repeats", + async () => { + const dir = await mkdtemp(join(tmpdir(), "scriptc-cli-executable-sanitize-")); + const cacheRoot = join(dir, "cache"); + const entry = join(dir, "main.ts"); + const outPath = join(dir, "program"); + const build = async (env: NodeJS.ProcessEnv = {}): Promise<{ stderr: string }> => { + const { stderr } = await execFileAsync( + process.execPath, + ["--import", tsxLoader, cliEntry, "build", entry, "--sanitize", "-o", outPath], + { + env: { ...process.env, SCRIPTC_CACHE_DIR: cacheRoot, SCRIPTC_TIMING: "1", ...env }, + maxBuffer: 4 * 1024 * 1024, + }, + ); + return { stderr }; + }; + const run = async (): Promise => + (await execFileAsync(outPath, [], { maxBuffer: 1024 * 1024 })).stdout; + try { + await mkdir(cacheRoot, { mode: 0o700 }); + await writeFile(entry, 'console.log("sanitized");\n'); + + // With the native cache off, clang compiles the build's private copy of the LLVM text. + await build({ SCRIPTC_NO_CACHE: "1" }); + expect(await run()).toBe("sanitized\n"); + + expect((await build()).stderr).toContain("scriptc lowering"); + expect(await run()).toBe("sanitized\n"); + const built = await stat(outPath); + const tuTime = (await stat(join(dir, "main.ll"))).mtimeMs; + + // The output directory does not change after the native cache proof is recorded, so an + // unchanged repeat keeps the executable instead of linking it again. + expect((await build()).stderr).not.toContain("scriptc lowering"); + if (toolchainEnvironmentCachePolicy(process.env).completeArtifacts) { + const repeated = await stat(outPath); + expect(repeated.ino).toBe(built.ino); + expect(repeated.mtimeMs).toBe(built.mtimeMs); + } + expect(await run()).toBe("sanitized\n"); + expect((await stat(join(dir, "main.ll"))).mtimeMs).toBe(tuTime); + expect((await readdir(dir)).sort()).toEqual(["cache", "main.ll", "main.ts", "program"]); + } finally { + await rm(dir, { recursive: true, force: true }); + } + }, + 240_000, +); + test.skipIf(process.platform === "win32")( "an executable appearing earlier on unchanged PATH invalidates the early binary", async () => { diff --git a/packages/compiler/src/executable/executable-cache.test.ts b/packages/compiler/src/executable/executable-cache.test.ts index e7c57d1b0..2de688531 100644 --- a/packages/compiler/src/executable/executable-cache.test.ts +++ b/packages/compiler/src/executable/executable-cache.test.ts @@ -137,7 +137,7 @@ test("early executable cache restores the emitted TU, IR, and native feature gat // them there when it is done. expect(hit?.llvmPath).toBe(f.llvmPath); expect(hit?.irPath).toBe(f.irPath); - expect(hit?.llvmSourcePath).toMatch(/[/\\]\.scriptc-llvm-/); + expect(hit?.llvmSourcePath).toMatch(/[/\\]\.scriptc-llvm-[^/\\]*\.ll$/); expect(hit?.irSourcePath).toMatch(/[/\\]\.scriptc-ir-/); expect(await readFile(hit!.llvmSourcePath!, "utf8")).toBe("; generated llvm\n"); expect(await readFile(hit!.irSourcePath!, "utf8")).toContain("irVersion"); diff --git a/packages/compiler/src/executable/executable-cache.ts b/packages/compiler/src/executable/executable-cache.ts index 941a7acdc..be94efb0b 100644 --- a/packages/compiler/src/executable/executable-cache.ts +++ b/packages/compiler/src/executable/executable-cache.ts @@ -615,7 +615,8 @@ async function readExecutableCache( ) await installBytes(ir, paths.irPath); } else { - llvmSourcePath = privateSiblingPath(paths.llvmPath, "llvm"); + // The extension keeps clang reading the copy as LLVM IR rather than as a linker input. + llvmSourcePath = `${privateSiblingPath(paths.llvmPath, "llvm")}.ll`; await installBytes(translationUnit, llvmSourcePath); llvmPathCurrent = await fileMatches(paths.llvmPath, stamp.files.translationUnit.digest); if (ir !== null && stamp.files.ir !== null) { diff --git a/packages/compiler/src/index.ts b/packages/compiler/src/index.ts index db1b0b3e3..7d6ab9b6d 100644 --- a/packages/compiler/src/index.ts +++ b/packages/compiler/src/index.ts @@ -49,7 +49,8 @@ import { frontendProcessExecArgv } from "./frontend-process-args.js"; import { type ChildProcess, spawn } from "node:child_process"; import { createHash } from "node:crypto"; import { existsSync } from "node:fs"; -import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises"; +import { copyFile, mkdir, mkdtemp, readFile, rename, rm, writeFile } from "node:fs/promises"; +import { tmpdir } from "node:os"; import { basename, dirname, join, resolve } from "node:path"; import { fileURLToPath } from "node:url"; import { @@ -850,7 +851,8 @@ async function prepareExecutableInput( await mkdir(opts.outDir, { recursive: true }); const llvmPath = defaultSourcePaths.llvm; - const llvmSourcePath = privateSiblingPath(llvmPath, "llvm"); + // The extension keeps clang reading the copy as LLVM IR rather than as a linker input. + const llvmSourcePath = `${privateSiblingPath(llvmPath, "llvm")}.ll`; const backend = "llvm" as const; const useRuntimePack = opts.nativeProgramObject === true || usesPrecompiledRuntimePack(opts, backend); @@ -912,6 +914,8 @@ async function prepareExecutableInput( * build therefore writes, compiles and caches private copies (privateSiblingPath) and moves them to * the shared names only when it is done (rename replaces a file in one step): a concurrent build of * another program cannot replace the text a build compiles or the translation unit it caches. + * Builds that compile with the C driver install them before the native build instead + * (stageDriverBuildSources). */ interface BuildSources { llvmPath: string; @@ -941,6 +945,40 @@ async function installBuildSources(sources: BuildSources): Promise { ]); } +/** + * A build that compiles the LLVM text with the C driver (no precompiled runtime pack) records the + * output directory in its native cache proofs, so that directory has to be in its final state before + * the native build starts. The build therefore installs the shared names first and compiles and + * caches copies in a private directory outside the output directory. Returns that directory and the + * copies. + */ +async function stageDriverBuildSources( + sources: BuildSources, +): Promise<{ dir: string; sources: BuildSources }> { + const dir = await mkdtemp(join(tmpdir(), "scriptc-program-")); + const llvmSourcePath = join(dir, basename(sources.llvmPath)); + const irSourcePath = + sources.irPath === undefined || sources.irSourcePath === undefined + ? undefined + : join(dir, basename(sources.irPath)); + try { + await Promise.all([ + copyFile(sources.llvmSourcePath, llvmSourcePath), + irSourcePath === undefined || sources.irSourcePath === undefined + ? undefined + : copyFile(sources.irSourcePath, irSourcePath), + ]); + } catch (err) { + await rm(dir, { recursive: true, force: true }); + throw err; + } + await installBuildSources(sources); + return { + dir, + sources: { llvmPath: sources.llvmPath, llvmSourcePath, irPath: sources.irPath, irSourcePath }, + }; +} + /** * The child process that prepares an executable build's input: frontend, lowering and LLVM emission * (`runFrontendProcess`). Node's heap keeps the pages a build's frontend used for the life of the @@ -1515,6 +1553,9 @@ async function compileTracked( llvmPathCurrent: earlyHit.llvmPathCurrent, irPathCurrent: earlyHit.irPathCurrent, }; + // What the native build compiles and the cache publishes: hitSources, or their staged copies. + let nativeSources = hitSources; + let stagedDir: string | null = null; let nativeInputPath = hitSources.llvmSourcePath; let nativeProgramObject: NativeProgramObject | null = null; const useRuntimePack = @@ -1545,6 +1586,11 @@ async function compileTracked( sourceTexts: new Map(), }; } + } else { + const staged = await stageDriverBuildSources(hitSources); + stagedDir = staged.dir; + nativeSources = staged.sources; + nativeInputPath = nativeSources.llvmSourcePath; } await compileExecutableNative( earlyHit.native, @@ -1561,10 +1607,10 @@ async function compileTracked( : async ({ dependencies }) => { await publishEarlyExecutableCache(cacheRoot, executableCacheOptions, { ...earlyHit, - llvmPath: hitSources.llvmSourcePath, - ...(hitSources.irSourcePath === undefined + llvmPath: nativeSources.llvmSourcePath, + ...(nativeSources.irSourcePath === undefined ? {} - : { irPath: hitSources.irSourcePath }), + : { irPath: nativeSources.irSourcePath }), executableRestored: true, nativeDependencies: dependencies, frontend: earlyHit.frontend, @@ -1602,7 +1648,8 @@ async function compileTracked( nativeProgramObject.partitionPaths, ); } - await installBuildSources(hitSources); + if (stagedDir === null) await installBuildSources(hitSources); + else await rm(stagedDir, { recursive: true, force: true }); } await pruneBuildCache(cacheRoot); return { @@ -1635,8 +1682,17 @@ async function compileTracked( ) : await prepareExecutableInput(entryPath, opts, ffi, buildPlatform, timing, warningSink); if ("ok" in prepared) return prepared; - const { llvmSource, llvmPath, llvmSourcePath, irPath, irSourcePath } = prepared; + const buildSources: BuildSources = { + llvmPath: prepared.llvmPath, + llvmSourcePath: prepared.llvmSourcePath, + irPath: prepared.irPath, + irSourcePath: prepared.irSourcePath, + }; + const { llvmSource, llvmPath, irPath } = prepared; const { nativeFeatures, programSplit, sourceTexts } = prepared; + // What the native build compiles and the cache publishes: buildSources, or their staged copies. + let { llvmSourcePath, irSourcePath } = buildSources; + let stagedDir: string | null = null; const backend = "llvm" as const; await mkdir(dirname(opts.outPath), { recursive: true }); if (earlyCacheOptions === null) { @@ -1668,6 +1724,10 @@ async function compileTracked( sourceTexts, }; } + } else { + const staged = await stageDriverBuildSources(buildSources); + stagedDir = staged.dir; + ({ llvmSourcePath, irSourcePath } = staged.sources); } await compileExecutableNative( nativeFeatures, @@ -1732,7 +1792,8 @@ async function compileTracked( nativeProgramObject.partitionPaths, ); } - await installBuildSources({ llvmPath, llvmSourcePath, irPath, irSourcePath }); + if (stagedDir === null) await installBuildSources(buildSources); + else await rm(stagedDir, { recursive: true, force: true }); } await pruneBuildCache(cacheRoot); timing("complete"); From 6f11afa09e85010c6b15c3e515b93d160d3379a5 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 05:46:53 -0500 Subject: [PATCH 063/102] Size crypto error messages to their whole text The key and signature errors formatted into fixed stack buffers and passed snprintf's return value on as the message length. A message longer than the buffer, such as "Invalid digest: " with a long algorithm name from crypto.sign or crypto.verify, then copied bytes past the end of the buffer into the error. The messages are now sized to their whole text, so a long name appears in full, as in Node. The received values in these messages also follow Node: strings as util.inspect quotes them, cut at 128 characters, and large integers with ERR_OUT_OF_RANGE's separators. A fractional, NaN or infinite modulusLength reports "It must be an integer", as validateUint32 does. --- packages/runtime/src/scr_pki.c | 98 +++++++++++++++--------- packages/runtime/src/scr_pki.h | 4 + packages/runtime/src/scr_webcrypto_pki.c | 10 +-- tests/corpus/7083-crypto-sign-verify.ts | 3 + tests/corpus/7084-crypto-key-pairs.cjs | 14 ++++ 5 files changed, 86 insertions(+), 43 deletions(-) diff --git a/packages/runtime/src/scr_pki.c b/packages/runtime/src/scr_pki.c index 1b102fd22..54aadc06b 100644 --- a/packages/runtime/src/scr_pki.c +++ b/packages/runtime/src/scr_pki.c @@ -12,6 +12,8 @@ * All arguments are borrowed. */ #include "scr_runtime.h" +#include +#include #include #include #include @@ -37,14 +39,41 @@ static void sp_throw(int kind, const char *code, const char *message) { scr_throw_error_msg_code(kind, message, strlen(message), code); } +void scr_pki_throw_fmt(int kind, const char *code, const char *fmt, ...) { + va_list ap, sized; + va_start(ap, fmt); + va_copy(sized, ap); + int n = vsnprintf(NULL, 0, fmt, sized); + va_end(sized); + if (n < 0) n = 0; + char *message = malloc((size_t)n + 1); + if (!message) scr_trap("scriptc: out of memory\n"); + vsnprintf(message, (size_t)n + 1, fmt, ap); + va_end(ap); + if (code) scr_throw_error_msg_code(kind, message, (size_t)n, code); + else scr_throw_error_msg(kind, message, (size_t)n); + free(message); +} + +/* The "Received" text of Node's ERR_INVALID_ARG_VALUE and ERR_OUT_OF_RANGE + * messages: a string as util.inspect quotes it (cut at 128 UTF-16 units + * plus "..."), a number as ERR_OUT_OF_RANGE prints it when `range`, any + * other value as its sketch. +1. */ +static ScrStr *sp_received(const ScrDyn *got, bool range) { + if (got->kind == SCR_DYN_STR) return scr_str_inspect_quoted(got->v.str, true); + char text[96]; + if (range && got->kind == SCR_DYN_NUM) return scr_str_new(text, scr_num_received(got->v.num, text)); + const char *lite = scr_dyn_inspect_lite(got, text, sizeof text); + return scr_str_new(lite, strlen(lite)); +} + /* ERR_INVALID_ARG_VALUE for an option ("The property 'options.type' is * invalid. Received 'spki'"). */ static void sp_property_invalid(const char *name, const ScrDyn *got) { - char lite[96]; - char message[256]; - int n = snprintf(message, sizeof message, "The property '%s' is invalid. Received %s", name, - scr_dyn_inspect_lite(got, lite, sizeof lite)); - scr_throw_error_msg_code(SCR_ERR_TYPE, message, (size_t)n, "ERR_INVALID_ARG_VALUE"); + ScrStr *received = sp_received(got, false); + scr_pki_throw_fmt(SCR_ERR_TYPE, "ERR_INVALID_ARG_VALUE", "The property '%s' is invalid. Received %.*s", name, + (int)received->len, received->data); + scr_str_release(received); } static void sp_unsupported_input(void) { @@ -53,10 +82,8 @@ static void sp_unsupported_input(void) { /* The coded refusal for a form this runtime does not implement. */ static void sp_not_supported(const char *what) { - char message[256]; - int n = snprintf(message, sizeof message, - "'%s' is part of the standard library types but has no scriptc lowering yet", what); - scr_throw_error_msg_code(SCR_ERR_ERROR, message, (size_t)n, "SC2020"); + scr_pki_throw_fmt(SCR_ERR_ERROR, "SC2020", "'%s' is part of the standard library types but has no scriptc lowering yet", + what); } static int sp_random(void *state, unsigned char *out, size_t len) { @@ -1066,9 +1093,7 @@ static ScrDyn *sp_key_invoke(void *h, ScrDyn *self, const char *method, ScrDyn * sp_not_supported("KeyObject.toCryptoKey"); return NULL; } - char message[160]; - int n = snprintf(message, sizeof message, "%s is not a function", what); - scr_throw_error_msg(SCR_ERR_TYPE, message, (size_t)n); + scr_pki_throw_fmt(SCR_ERR_TYPE, NULL, "%s is not a function", what); return NULL; } @@ -1093,10 +1118,8 @@ static bool sp_key_set(void *h, const char *name, size_t len, const ScrDyn *valu ? "AsymmetricKeyObject" : NULL; if (!holder) return false; - char message[160]; - int n = snprintf(message, sizeof message, "Cannot set property %.*s of #<%s> which has only a getter", - (int)len, name, holder); - scr_throw_error_msg(SCR_ERR_TYPE, message, (size_t)n); + scr_pki_throw_fmt(SCR_ERR_TYPE, NULL, "Cannot set property %.*s of #<%s> which has only a getter", (int)len, name, + holder); return true; } @@ -1210,12 +1233,11 @@ static SpKey *sp_generate(const ScrDyn *type, const ScrDyn *options) { bool other = false; for (size_t i = 0; i < sizeof known / sizeof known[0]; i++) other = other || sp_is_str(type, known[i]); if (!rsa && !ec && !ed && !other) { - char lite[96]; - char message[200]; - int n = snprintf(message, sizeof message, - "The argument 'type' must be a supported key type. Received %s", - scr_dyn_inspect_lite(type, lite, sizeof lite)); - scr_throw_error_msg_code(SCR_ERR_TYPE, message, (size_t)n, "ERR_INVALID_ARG_VALUE"); + ScrStr *received = sp_received(type, false); + scr_pki_throw_fmt(SCR_ERR_TYPE, "ERR_INVALID_ARG_VALUE", + "The argument 'type' must be a supported key type. Received %.*s", (int)received->len, + received->data); + scr_str_release(received); return NULL; } /* The ed25519 options are optional. */ @@ -1252,14 +1274,15 @@ static SpKey *sp_generate(const ScrDyn *type, const ScrDyn *options) { return NULL; } double b = bits->v.num; - if (b != b || b < 0 || b > 4294967295.0 || b != (double)(uint64_t)b) { + /* validateUint32: an integer first, then the range. */ + bool integer = isfinite(b) && trunc(b) == b; + if (!integer || b < 0 || b > 4294967295.0) { sp_key_release(k); - char message[160]; - char lite[64]; - int n = snprintf(message, sizeof message, - "The value of \"options.modulusLength\" is out of range. It must be >= 0 && <= 4294967295. Received %s", - scr_dyn_inspect_lite(bits, lite, sizeof lite)); - scr_throw_error_msg_code(SCR_ERR_RANGE, message, (size_t)n, "ERR_OUT_OF_RANGE"); + ScrStr *received = sp_received(bits, true); + scr_pki_throw_fmt(SCR_ERR_RANGE, "ERR_OUT_OF_RANGE", + "The value of \"options.modulusLength\" is out of range. It must be %s. Received %.*s", + integer ? ">= 0 && <= 4294967295" : "an integer", (int)received->len, received->data); + scr_str_release(received); return NULL; } const ScrDyn *exp = sp_opt(options, "publicExponent"); @@ -1404,10 +1427,15 @@ static bool sp_algorithm(const ScrDyn *alg, mbedtls_md_type_t *md) { return false; } if (!sp_digest_of(alg->v.str, md)) { - char message[160]; - int n = snprintf(message, sizeof message, "Invalid digest: %.*s", (int)alg->v.str->len, - alg->v.str->data); - scr_throw_error_msg_code(SCR_ERR_TYPE, message, (size_t)n, "ERR_CRYPTO_INVALID_DIGEST"); + /* The whole name, at any length and with any bytes, as in Node. */ + static const char prefix[] = "Invalid digest: "; + size_t len = sizeof prefix - 1 + alg->v.str->len; + char *message = malloc(len); + if (!message) scr_trap("scriptc: out of memory\n"); + memcpy(message, prefix, sizeof prefix - 1); + memcpy(message + sizeof prefix - 1, alg->v.str->data, alg->v.str->len); + scr_throw_error_msg_code(SCR_ERR_TYPE, message, len, "ERR_CRYPTO_INVALID_DIGEST"); + free(message); return false; } return true; @@ -1799,9 +1827,7 @@ static ScrDyn *sp_signer_invoke(void *h, ScrDyn *self, const char *method, ScrDy sp_key_release(k.key); return scr_dyn_new_bool(ok); } - char message[160]; - int n = snprintf(message, sizeof message, "%s is not a function", what); - scr_throw_error_msg(SCR_ERR_TYPE, message, (size_t)n); + scr_pki_throw_fmt(SCR_ERR_TYPE, NULL, "%s is not a function", what); return NULL; } diff --git a/packages/runtime/src/scr_pki.h b/packages/runtime/src/scr_pki.h index e299806f7..71be3c1df 100644 --- a/packages/runtime/src/scr_pki.h +++ b/packages/runtime/src/scr_pki.h @@ -12,6 +12,10 @@ typedef struct SpKey ScrPkiKey; +/* Throws an error of `kind` (with `code`, or none for NULL) whose message + * is the printf format's whole output, at any length. */ +void scr_pki_throw_fmt(int kind, const char *code, const char *fmt, ...) __attribute__((format(printf, 3, 4))); + /* The Ed25519 arithmetic (scr_ed25519.c), installed at startup in * programs that name Ed25519; NULL otherwise. Keys are the 32-byte seed * and the 32-byte encoded public point. */ diff --git a/packages/runtime/src/scr_webcrypto_pki.c b/packages/runtime/src/scr_webcrypto_pki.c index e913b1dc6..7439a12db 100644 --- a/packages/runtime/src/scr_webcrypto_pki.c +++ b/packages/runtime/src/scr_webcrypto_pki.c @@ -115,10 +115,8 @@ static bool sw_key_set(void *h, const char *name, size_t len, const ScrDyn *valu if (!sw_name_is(name, len, "type") && !sw_name_is(name, len, "extractable") && !sw_name_is(name, len, "algorithm") && !sw_name_is(name, len, "usages")) return false; - char message[128]; - int n = snprintf(message, sizeof message, "Cannot set property %.*s of # which has only a getter", - (int)len, name); - scr_throw_error_msg(SCR_ERR_TYPE, message, (size_t)n); + scr_pki_throw_fmt(SCR_ERR_TYPE, NULL, "Cannot set property %.*s of # which has only a getter", (int)len, + name); return true; } @@ -129,9 +127,7 @@ static ScrDyn *sw_key_invoke(void *h, ScrDyn *self, const char *method, ScrDyn * (void)args; (void)argc; if (strcmp(method, "toString") == 0) return scr_wc_cstr("[object CryptoKey]"); - char message[160]; - int n = snprintf(message, sizeof message, "%s is not a function", what); - scr_throw_error_msg(SCR_ERR_TYPE, message, (size_t)n); + scr_pki_throw_fmt(SCR_ERR_TYPE, NULL, "%s is not a function", what); return NULL; } diff --git a/tests/corpus/7083-crypto-sign-verify.ts b/tests/corpus/7083-crypto-sign-verify.ts index 437dc1640..4f6b86e72 100644 --- a/tests/corpus/7083-crypto-sign-verify.ts +++ b/tests/corpus/7083-crypto-sign-verify.ts @@ -80,6 +80,9 @@ const ecSignature = ecSigner.sign({ key: ec, dsaEncoding: "ieee-p1363" }); attempt("chained", () => crypto.createVerify("sha512").update("chained").verify({ key: ecPublic, dsaEncoding: "ieee-p1363" }, ecSignature)); attempt("invalid digest", () => crypto.sign("nope", data, rsa)); +const longDigest = "unknown-digest-".repeat(40); +attempt("long digest", () => crypto.sign(longDigest, data, rsa)); +attempt("long verify digest", () => crypto.verify(longDigest, data, rsaPublic, Buffer.alloc(64))); attempt("public key signs", () => crypto.sign("sha256", data, rsaPublic)); attempt("invalid createSign", () => crypto.createSign("nope")); attempt("invalid dsaEncoding", () => crypto.sign("sha256", data, { key: ec, dsaEncoding: "x" as "der" })); diff --git a/tests/corpus/7084-crypto-key-pairs.cjs b/tests/corpus/7084-crypto-key-pairs.cjs index ed4db0310..ca267d89f 100644 --- a/tests/corpus/7084-crypto-key-pairs.cjs +++ b/tests/corpus/7084-crypto-key-pairs.cjs @@ -50,6 +50,20 @@ attempt("unknown curve", () => crypto.generateKeyPairSync("ec", { namedCurve: "n attempt("bad encoding format", () => crypto.generateKeyPairSync("ec", { namedCurve: "P-256", publicKeyEncoding: { type: "spki", format: "xml" } })); attempt("bad encoding type", () => crypto.generateKeyPairSync("ec", { namedCurve: "P-256", privateKeyEncoding: { type: "spki", format: "pem" } })); attempt("encoding not object", () => crypto.generateKeyPairSync("ec", { namedCurve: "P-256", publicKeyEncoding: "pem" })); +// Error messages hold the whole text at any length, and received values +// render as Node's validators print them. +attempt("long type", () => crypto.generateKeyPairSync("unknown-type-".repeat(20), {})); +attempt("long encoding type", () => crypto.generateKeyPairSync("ec", { namedCurve: "P-256", publicKeyEncoding: { type: "z".repeat(300), format: "pem" } })); +attempt("quoted encoding type", () => crypto.generateKeyPairSync("ec", { namedCurve: "P-256", publicKeyEncoding: { type: "it's\n", format: "pem" } })); +attempt("huge modulusLength", () => crypto.generateKeyPairSync("rsa", { modulusLength: 2 ** 40 })); +attempt("fractional modulusLength", () => crypto.generateKeyPairSync("rsa", { modulusLength: 1.5 })); +attempt("NaN modulusLength", () => crypto.generateKeyPairSync("rsa", { modulusLength: NaN })); +const key = rsa.privateKey; +attempt("long method", () => key.aMethodNameLongEnoughThatTheWholeMessageRunsPastOneHundredAndSixtyBytesOnceTheReceiverTextAndTheSuffixAreIncluded()); +attempt("getter", () => { + "use strict"; + key.asymmetricKeyType = "ec"; +}); let returned = false; crypto.generateKeyPair("ec", { namedCurve: "P-384" }, (err, publicKey, privateKey) => { From 01a467060b1ee76dac71a6fc0e77bc599150ecc3 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 05:48:30 -0500 Subject: [PATCH 064/102] Support WebCrypto wrapKey and unwrapKey crypto.subtle.wrapKey exports a secret key (raw, raw-secret or jwk) and encrypts it, and unwrapKey decrypts and imports one, as Node's webcrypto.js does: the wrap algorithm normalizes through the wrapKey registry (AES-KW) and then the encrypt registry (AES-GCM, AES-CBC and AES-CTR with their dictionaries), the wrapping key's algorithm and usages are checked, and a JWK payload is its JSON text, padded with spaces to a multiple of 8 bytes for AES-KW. A wrapped JWK that is not UTF-8 JSON with a kty member rejects with Node's DataError. AES-KW is RFC 3394 key wrap over the vendored mbedTLS block cipher, in scr_webcrypto_aes.c beside the other AES modes: wrapping takes a multiple of 8 bytes and at least 16, unwrapping a multiple of 8 and at least 24, and the integrity check value is compared in constant time. The cipher's failures, and unwrapKey's import errors, reject on a later loop turn as Node's job promises do. This completes jose's symmetric key management: 7132 runs the real jose 6.2.12 PBES2-HS256+A128KW, PBES2-HS384+A192KW, PBES2-HS512+A256KW, A128KW and A256KW paths (EncryptJWT and jwtDecrypt) against Node. getPublicKey replaces wrapKey as the refused method in the fenced fixture and the JavaScript refusal test. --- .../limitations/builtin-apis/crypto.mdx | 2 +- .../src/generated/node-v24-compatibility.json | 12 +- .../generated/node-v24-internal.json | 77 +- internal/compatibility/static-support.json | 4 +- .../ambient/scriptc-node-fallback.d.ts | 18 +- .../compiler/src/backend/llvm/lib-shared.ts | 4 + .../src/backend/target-diagnostics.ts | 9 +- .../frontend/lowering/builtins/webcrypto.ts | 8 +- .../src/frontend/lowering/surfaces.ts | 4 +- .../compiler/src/ir/builtin-signatures.ts | 2 + packages/compiler/src/ir/runtime-features.ts | 18 +- packages/compiler/surface-manifest.json | 2 +- .../corpus/7130-webcrypto-wrap-key.ts.json | 6 + .../7131-webcrypto-wrap-key-errors.mjs.json | 6 + .../corpus/7132-jose-pbes2/main.mjs.json | 6 + packages/runtime/src/scr_crypto.h | 7 + packages/runtime/src/scr_webcrypto.c | 317 ++++++-- packages/runtime/src/scr_webcrypto_aes.c | 67 ++ tests/corpus/7130-webcrypto-wrap-key.ts | 69 ++ .../corpus/7131-webcrypto-wrap-key-errors.mjs | 65 ++ tests/corpus/7132-jose-pbes2/main.mjs | 50 ++ .../node_modules/jose/LICENSE.md | 21 + .../jose/dist/types/jwt/decrypt.d.ts | 34 + .../jose/dist/types/jwt/encrypt.d.ts | 57 ++ .../node_modules/jose/dist/types/types.d.ts | 736 ++++++++++++++++++ .../jose/dist/types/util/errors.d.ts | 182 +++++ .../jose/dist/webapi/jwt/decrypt.js | 13 + .../jose/dist/webapi/jwt/encrypt.js | 45 ++ .../jose/dist/webapi/lib/buffer_utils.js | 75 ++ .../dist/webapi/lib/content_encryption.js | 90 +++ .../jose/dist/webapi/lib/deflate.js | 40 + .../jose/dist/webapi/lib/jwe_algorithms.js | 116 +++ .../jose/dist/webapi/lib/jwe_decrypt.js | 187 +++++ .../jose/dist/webapi/lib/jwe_encrypt.js | 75 ++ .../jose/dist/webapi/lib/jwt_claims_set.js | 146 ++++ .../node_modules/jose/dist/webapi/lib/key.js | 155 ++++ .../jose/dist/webapi/lib/key_descriptor.js | 9 + .../jose/dist/webapi/lib/key_management.js | 196 +++++ .../jose/dist/webapi/lib/validate.js | 122 +++ .../jose/dist/webapi/util/base64url.js | 16 + .../jose/dist/webapi/util/errors.js | 109 +++ .../node_modules/jose/package.json | 17 + tests/fixtures/node-types/fenced.ts | 8 +- .../__snapshots__/node-types-fenced.txt | 10 +- .../__snapshots__/webcrypto-refusals.ts.txt | 4 +- .../7130-webcrypto-wrap-key.ts.json | 1 + .../7131-webcrypto-wrap-key-errors.mjs.json | 1 + .../7132-jose-pbes2/main.mjs.json | 1 + tests/harness/errors.test.ts | 12 +- 49 files changed, 3139 insertions(+), 92 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7130-webcrypto-wrap-key.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7131-webcrypto-wrap-key-errors.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7132-jose-pbes2/main.mjs.json create mode 100644 tests/corpus/7130-webcrypto-wrap-key.ts create mode 100644 tests/corpus/7131-webcrypto-wrap-key-errors.mjs create mode 100644 tests/corpus/7132-jose-pbes2/main.mjs create mode 100644 tests/corpus/7132-jose-pbes2/node_modules/jose/LICENSE.md create mode 100644 tests/corpus/7132-jose-pbes2/node_modules/jose/dist/types/jwt/decrypt.d.ts create mode 100644 tests/corpus/7132-jose-pbes2/node_modules/jose/dist/types/jwt/encrypt.d.ts create mode 100644 tests/corpus/7132-jose-pbes2/node_modules/jose/dist/types/types.d.ts create mode 100644 tests/corpus/7132-jose-pbes2/node_modules/jose/dist/types/util/errors.d.ts create mode 100644 tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/jwt/decrypt.js create mode 100644 tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/jwt/encrypt.js create mode 100644 tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/buffer_utils.js create mode 100644 tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/content_encryption.js create mode 100644 tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/deflate.js create mode 100644 tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/jwe_algorithms.js create mode 100644 tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/jwe_decrypt.js create mode 100644 tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/jwe_encrypt.js create mode 100644 tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/jwt_claims_set.js create mode 100644 tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/key.js create mode 100644 tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/key_descriptor.js create mode 100644 tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/key_management.js create mode 100644 tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/validate.js create mode 100644 tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/util/base64url.js create mode 100644 tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/util/errors.js create mode 100644 tests/corpus/7132-jose-pbes2/node_modules/jose/package.json create mode 100644 tests/harness/corpus-costs/7130-webcrypto-wrap-key.ts.json create mode 100644 tests/harness/corpus-costs/7131-webcrypto-wrap-key-errors.mjs.json create mode 100644 tests/harness/corpus-costs/7132-jose-pbes2/main.mjs.json diff --git a/docs/content/limitations/builtin-apis/crypto.mdx b/docs/content/limitations/builtin-apis/crypto.mdx index 641d0d8f9..2cb0db5f0 100644 --- a/docs/content/limitations/builtin-apis/crypto.mdx +++ b/docs/content/limitations/builtin-apis/crypto.mdx @@ -20,6 +20,6 @@ ECDH property reads and writes throw a coded SC2020 error. Other public-key operations remain unsupported. The WebCrypto `crypto` global, which node:crypto also exports as `webcrypto`, supports `randomUUID()` and `getRandomValues()`, also read as values from untyped JavaScript. - Its `subtle` object, also node:crypto's `subtle` export, supports `generateKey()` and `exportKey()` for HMAC and AES keys, `importKey()` for HMAC, AES, PBKDF2, and HKDF keys, `encrypt()` and `decrypt()` with AES-GCM, AES-CBC, and AES-CTR on native targets, `deriveBits()` and `deriveKey()` with PBKDF2 and HKDF, HMAC `sign()` and `verify()`, and SHA-1 and SHA-2 `digest()`. + Its `subtle` object, also node:crypto's `subtle` export, supports `generateKey()` and `exportKey()` for HMAC and AES keys, `importKey()` for HMAC, AES, PBKDF2, and HKDF keys, `encrypt()` and `decrypt()` with AES-GCM, AES-CBC, and AES-CTR and `wrapKey()` and `unwrapKey()` with AES-KW or those ciphers on native targets, `deriveBits()` and `deriveKey()` with PBKDF2 and HKDF, HMAC `sign()` and `verify()`, and SHA-1 and SHA-2 `digest()`. Secret keys import and export in the `raw`, `raw-secret`, and `jwk` formats; other SubtleCrypto methods, algorithms, and key formats are refused. Native derivations finish before their deferred callbacks, so computation blocks the caller. diff --git a/docs/src/generated/node-v24-compatibility.json b/docs/src/generated/node-v24-compatibility.json index 682e68f99..628c267be 100644 --- a/docs/src/generated/node-v24-compatibility.json +++ b/docs/src/generated/node-v24-compatibility.json @@ -80277,9 +80277,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" } }, { @@ -80323,9 +80323,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" } }, { diff --git a/internal/compatibility/generated/node-v24-internal.json b/internal/compatibility/generated/node-v24-internal.json index a86967ff3..83b4c5691 100644 --- a/internal/compatibility/generated/node-v24-internal.json +++ b/internal/compatibility/generated/node-v24-internal.json @@ -106677,6 +106677,9 @@ "tests/corpus/7127-webcrypto-aes-errors.mjs", "tests/corpus/7128-webcrypto-derive.ts", "tests/corpus/7129-webcrypto-derive-errors.mjs", + "tests/corpus/7130-webcrypto-wrap-key.ts", + "tests/corpus/7131-webcrypto-wrap-key-errors.mjs", + "tests/corpus/7132-jose-pbes2/main.mjs", "tests/corpus/node24-crypto-kdf-errors.ts", "tests/corpus/node24-crypto-kdf-options.ts", "tests/corpus/node24-crypto-kdf.ts", @@ -110549,6 +110552,9 @@ "status": "partial", "evidence": "compiler-feature:webcrypto.subtle.decrypt", "tests": [ + "tests/corpus/7130-webcrypto-wrap-key.ts", + "tests/corpus/7131-webcrypto-wrap-key-errors.mjs", + "tests/corpus/7132-jose-pbes2/main.mjs", "tests/corpus/7128-webcrypto-derive.ts", "tests/corpus/7129-webcrypto-derive-errors.mjs", "tests/corpus/7126-webcrypto-aes.ts", @@ -110587,6 +110593,9 @@ "status": "partial", "evidence": "compiler-feature:webcrypto.subtle.deriveBits", "tests": [ + "tests/corpus/7130-webcrypto-wrap-key.ts", + "tests/corpus/7131-webcrypto-wrap-key-errors.mjs", + "tests/corpus/7132-jose-pbes2/main.mjs", "tests/corpus/7128-webcrypto-derive.ts", "tests/corpus/7129-webcrypto-derive-errors.mjs", "tests/corpus/7126-webcrypto-aes.ts", @@ -110625,6 +110634,9 @@ "status": "partial", "evidence": "compiler-feature:webcrypto.subtle.deriveKey", "tests": [ + "tests/corpus/7130-webcrypto-wrap-key.ts", + "tests/corpus/7131-webcrypto-wrap-key-errors.mjs", + "tests/corpus/7132-jose-pbes2/main.mjs", "tests/corpus/7128-webcrypto-derive.ts", "tests/corpus/7129-webcrypto-derive-errors.mjs", "tests/corpus/7126-webcrypto-aes.ts", @@ -110663,6 +110675,9 @@ "status": "partial", "evidence": "compiler-feature:webcrypto.subtle.digest", "tests": [ + "tests/corpus/7130-webcrypto-wrap-key.ts", + "tests/corpus/7131-webcrypto-wrap-key-errors.mjs", + "tests/corpus/7132-jose-pbes2/main.mjs", "tests/corpus/7128-webcrypto-derive.ts", "tests/corpus/7129-webcrypto-derive-errors.mjs", "tests/corpus/7126-webcrypto-aes.ts", @@ -110747,6 +110762,9 @@ "status": "partial", "evidence": "compiler-feature:webcrypto.subtle.encrypt", "tests": [ + "tests/corpus/7130-webcrypto-wrap-key.ts", + "tests/corpus/7131-webcrypto-wrap-key-errors.mjs", + "tests/corpus/7132-jose-pbes2/main.mjs", "tests/corpus/7128-webcrypto-derive.ts", "tests/corpus/7129-webcrypto-derive-errors.mjs", "tests/corpus/7126-webcrypto-aes.ts", @@ -110785,6 +110803,9 @@ "status": "partial", "evidence": "compiler-feature:webcrypto.subtle.exportKey", "tests": [ + "tests/corpus/7130-webcrypto-wrap-key.ts", + "tests/corpus/7131-webcrypto-wrap-key-errors.mjs", + "tests/corpus/7132-jose-pbes2/main.mjs", "tests/corpus/7128-webcrypto-derive.ts", "tests/corpus/7129-webcrypto-derive-errors.mjs", "tests/corpus/7126-webcrypto-aes.ts", @@ -110846,6 +110867,9 @@ "status": "partial", "evidence": "compiler-feature:webcrypto.subtle.generateKey", "tests": [ + "tests/corpus/7130-webcrypto-wrap-key.ts", + "tests/corpus/7131-webcrypto-wrap-key-errors.mjs", + "tests/corpus/7132-jose-pbes2/main.mjs", "tests/corpus/7128-webcrypto-derive.ts", "tests/corpus/7129-webcrypto-derive-errors.mjs", "tests/corpus/7126-webcrypto-aes.ts", @@ -110884,6 +110908,9 @@ "status": "partial", "evidence": "compiler-feature:webcrypto.subtle.importKey", "tests": [ + "tests/corpus/7130-webcrypto-wrap-key.ts", + "tests/corpus/7131-webcrypto-wrap-key-errors.mjs", + "tests/corpus/7132-jose-pbes2/main.mjs", "tests/corpus/7128-webcrypto-derive.ts", "tests/corpus/7129-webcrypto-derive-errors.mjs", "tests/corpus/7126-webcrypto-aes.ts", @@ -110922,6 +110949,9 @@ "status": "partial", "evidence": "compiler-feature:webcrypto.subtle.sign", "tests": [ + "tests/corpus/7130-webcrypto-wrap-key.ts", + "tests/corpus/7131-webcrypto-wrap-key-errors.mjs", + "tests/corpus/7132-jose-pbes2/main.mjs", "tests/corpus/7128-webcrypto-derive.ts", "tests/corpus/7129-webcrypto-derive-errors.mjs", "tests/corpus/7126-webcrypto-aes.ts", @@ -110957,8 +110987,26 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:webcrypto" + "status": "partial", + "evidence": "compiler-feature:webcrypto.subtle.unwrapKey", + "tests": [ + "tests/corpus/7130-webcrypto-wrap-key.ts", + "tests/corpus/7131-webcrypto-wrap-key-errors.mjs", + "tests/corpus/7132-jose-pbes2/main.mjs", + "tests/corpus/7128-webcrypto-derive.ts", + "tests/corpus/7129-webcrypto-derive-errors.mjs", + "tests/corpus/7126-webcrypto-aes.ts", + "tests/corpus/7127-webcrypto-aes-errors.mjs", + "tests/corpus/7124-webcrypto-secret-keys.ts", + "tests/corpus/7125-webcrypto-key-errors.mjs", + "tests/fixtures/node-types/webcrypto-keys.ts", + "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", + "tests/corpus/6292-webcrypto-hmac-errors.ts", + "tests/corpus/6293-webcrypto-digest.ts", + "tests/corpus/6294-webcrypto-js-values.mjs", + "tests/corpus/6295-jose-hs256/main.mjs", + "tests/fixtures/node-types/webcrypto-hmac.ts" + ] }, "anchorSource": "exact" }, @@ -110983,6 +111031,9 @@ "status": "partial", "evidence": "compiler-feature:webcrypto.subtle.verify", "tests": [ + "tests/corpus/7130-webcrypto-wrap-key.ts", + "tests/corpus/7131-webcrypto-wrap-key-errors.mjs", + "tests/corpus/7132-jose-pbes2/main.mjs", "tests/corpus/7128-webcrypto-derive.ts", "tests/corpus/7129-webcrypto-derive-errors.mjs", "tests/corpus/7126-webcrypto-aes.ts", @@ -111018,8 +111069,26 @@ "inherited": true }, "static": { - "status": "not-implemented", - "evidence": "compiler-unmatched:webcrypto" + "status": "partial", + "evidence": "compiler-feature:webcrypto.subtle.wrapKey", + "tests": [ + "tests/corpus/7130-webcrypto-wrap-key.ts", + "tests/corpus/7131-webcrypto-wrap-key-errors.mjs", + "tests/corpus/7132-jose-pbes2/main.mjs", + "tests/corpus/7128-webcrypto-derive.ts", + "tests/corpus/7129-webcrypto-derive-errors.mjs", + "tests/corpus/7126-webcrypto-aes.ts", + "tests/corpus/7127-webcrypto-aes-errors.mjs", + "tests/corpus/7124-webcrypto-secret-keys.ts", + "tests/corpus/7125-webcrypto-key-errors.mjs", + "tests/fixtures/node-types/webcrypto-keys.ts", + "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", + "tests/corpus/6292-webcrypto-hmac-errors.ts", + "tests/corpus/6293-webcrypto-digest.ts", + "tests/corpus/6294-webcrypto-js-values.mjs", + "tests/corpus/6295-jose-hs256/main.mjs", + "tests/fixtures/node-types/webcrypto-hmac.ts" + ] }, "anchorSource": "exact" }, diff --git a/internal/compatibility/static-support.json b/internal/compatibility/static-support.json index 6b3eaab4c..568dbbf0d 100644 --- a/internal/compatibility/static-support.json +++ b/internal/compatibility/static-support.json @@ -187,14 +187,14 @@ "stdlib.set": ["tests/corpus/typed-collection-iterators.ts", "tests/corpus/typed-collection-iterator-references.ts", "tests/corpus/checked-collection-iterators.ts"], "stdlib.headers": ["tests/harness/fetch-conformance.test.ts"], "stdlib.request": ["tests/harness/fetch-conformance.test.ts"], - "stdlib.webcrypto.subtle": ["tests/corpus/7128-webcrypto-derive.ts", "tests/corpus/7129-webcrypto-derive-errors.mjs", "tests/corpus/7126-webcrypto-aes.ts", "tests/corpus/7127-webcrypto-aes-errors.mjs", "tests/corpus/7124-webcrypto-secret-keys.ts", "tests/corpus/7125-webcrypto-key-errors.mjs", "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6292-webcrypto-hmac-errors.ts", "tests/corpus/6293-webcrypto-digest.ts", "tests/corpus/6294-webcrypto-js-values.mjs", "tests/corpus/6295-jose-hs256/main.mjs"], + "stdlib.webcrypto.subtle": ["tests/corpus/7130-webcrypto-wrap-key.ts", "tests/corpus/7131-webcrypto-wrap-key-errors.mjs", "tests/corpus/7132-jose-pbes2/main.mjs", "tests/corpus/7128-webcrypto-derive.ts", "tests/corpus/7129-webcrypto-derive-errors.mjs", "tests/corpus/7126-webcrypto-aes.ts", "tests/corpus/7127-webcrypto-aes-errors.mjs", "tests/corpus/7124-webcrypto-secret-keys.ts", "tests/corpus/7125-webcrypto-key-errors.mjs", "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6292-webcrypto-hmac-errors.ts", "tests/corpus/6293-webcrypto-digest.ts", "tests/corpus/6294-webcrypto-js-values.mjs", "tests/corpus/6295-jose-hs256/main.mjs"], "stdlib.webcrypto.CryptoKey": ["tests/corpus/7124-webcrypto-secret-keys.ts", "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6294-webcrypto-js-values.mjs", "tests/corpus/6295-jose-hs256/main.mjs"], "stdlib.response": ["tests/harness/fetch-conformance.test.ts"], "stdlib.readable-stream": ["tests/harness/fetch-conformance.test.ts"], "stdlib.abort": ["tests/harness/fetch-conformance.test.ts"] }, "features": [ - { "chapter": "webcrypto", "symbols": ["subtle.importKey", "subtle.generateKey", "subtle.exportKey", "subtle.encrypt", "subtle.decrypt", "subtle.deriveBits", "subtle.deriveKey", "subtle.sign", "subtle.verify", "subtle.digest"], "status": "partial", "evidence": ["tests/corpus/7128-webcrypto-derive.ts", "tests/corpus/7129-webcrypto-derive-errors.mjs", "tests/corpus/7126-webcrypto-aes.ts", "tests/corpus/7127-webcrypto-aes-errors.mjs", "tests/corpus/7124-webcrypto-secret-keys.ts", "tests/corpus/7125-webcrypto-key-errors.mjs", "tests/fixtures/node-types/webcrypto-keys.ts", "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6292-webcrypto-hmac-errors.ts", "tests/corpus/6293-webcrypto-digest.ts", "tests/corpus/6294-webcrypto-js-values.mjs", "tests/corpus/6295-jose-hs256/main.mjs", "tests/fixtures/node-types/webcrypto-hmac.ts"] }, + { "chapter": "webcrypto", "symbols": ["subtle.importKey", "subtle.generateKey", "subtle.exportKey", "subtle.encrypt", "subtle.decrypt", "subtle.wrapKey", "subtle.unwrapKey", "subtle.deriveBits", "subtle.deriveKey", "subtle.sign", "subtle.verify", "subtle.digest"], "status": "partial", "evidence": ["tests/corpus/7130-webcrypto-wrap-key.ts", "tests/corpus/7131-webcrypto-wrap-key-errors.mjs", "tests/corpus/7132-jose-pbes2/main.mjs", "tests/corpus/7128-webcrypto-derive.ts", "tests/corpus/7129-webcrypto-derive-errors.mjs", "tests/corpus/7126-webcrypto-aes.ts", "tests/corpus/7127-webcrypto-aes-errors.mjs", "tests/corpus/7124-webcrypto-secret-keys.ts", "tests/corpus/7125-webcrypto-key-errors.mjs", "tests/fixtures/node-types/webcrypto-keys.ts", "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6292-webcrypto-hmac-errors.ts", "tests/corpus/6293-webcrypto-digest.ts", "tests/corpus/6294-webcrypto-js-values.mjs", "tests/corpus/6295-jose-hs256/main.mjs", "tests/fixtures/node-types/webcrypto-hmac.ts"] }, { "chapter": "webcrypto", "signatures": ["Class: `SubtleCrypto`", "`subtle` Type: {SubtleCrypto}"], "status": "partial", "evidence": ["tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6292-webcrypto-hmac-errors.ts", "tests/corpus/6293-webcrypto-digest.ts", "tests/corpus/6294-webcrypto-js-values.mjs", "tests/corpus/6295-jose-hs256/main.mjs"] }, { "chapter": "webcrypto", "signatures": ["Class: `CryptoKey`", "`cryptoKey.algorithm`", "`extractable` Type: {boolean}", "`type` Type: {string} One of `'secret'`, `'private'`, or `'public'`.", "`usages` Type: {string\\[]}"], "status": "partial", "evidence": ["tests/corpus/7124-webcrypto-secret-keys.ts", "tests/corpus/6291-webcrypto-hmac-sign-verify.ts", "tests/corpus/6294-webcrypto-js-values.mjs", "tests/corpus/6295-jose-hs256/main.mjs"] }, { "chapter": "webcrypto", "signatures": ["Class: `Crypto`"], "status": "partial", "evidence": ["tests/corpus/7120-webcrypto-random-uuid.ts", "tests/corpus/7121-webcrypto-crypto-object.mjs", "tests/corpus/6293-webcrypto-digest.ts"] }, diff --git a/packages/compiler/ambient/scriptc-node-fallback.d.ts b/packages/compiler/ambient/scriptc-node-fallback.d.ts index 936283d40..1e40b6f6f 100644 --- a/packages/compiler/ambient/scriptc-node-fallback.d.ts +++ b/packages/compiler/ambient/scriptc-node-fallback.d.ts @@ -547,7 +547,8 @@ declare var DOMException: { /* WebCrypto's secret-key slice (scr_webcrypto.c): crypto.subtle's * importKey, generateKey and exportKey for HMAC and AES keys (importKey * also for PBKDF2 and HKDF keys), AES-GCM/CBC/CTR encrypt and decrypt, - * PBKDF2 and HKDF deriveBits and deriveKey, HMAC sign/verify and the SHA-1/SHA-2 digests, typed as + * wrapKey and unwrapKey (AES-KW or those ciphers), PBKDF2 and HKDF + * deriveBits and deriveKey, HMAC sign/verify and the SHA-1/SHA-2 digests, typed as * exactly that surface (the declarations mirror @types/node's webcrypto * shapes), plus the global's randomUUID and getRandomValues. Every other * SubtleCrypto method and crypto member is absent, so a use is an honest @@ -707,12 +708,27 @@ interface SubtleCrypto { keyUsages: readonly KeyUsage[], ): Promise; sign(algorithm: AlgorithmIdentifier, key: CryptoKey, data: BufferSource): Promise; + unwrapKey( + format: KeyFormat, + wrappedKey: BufferSource, + unwrappingKey: CryptoKey, + unwrapAlgorithm: AlgorithmIdentifier | AesGcmParams | AesCbcParams | AesCtrParams, + unwrappedKeyAlgorithm: AlgorithmIdentifier | HmacImportParams, + extractable: boolean, + keyUsages: readonly KeyUsage[], + ): Promise; verify( algorithm: AlgorithmIdentifier, key: CryptoKey, signature: BufferSource, data: BufferSource, ): Promise; + wrapKey( + format: KeyFormat, + key: CryptoKey, + wrappingKey: CryptoKey, + wrapAlgorithm: AlgorithmIdentifier | AesGcmParams | AesCbcParams | AesCtrParams, + ): Promise; } interface Crypto { readonly subtle: SubtleCrypto; diff --git a/packages/compiler/src/backend/llvm/lib-shared.ts b/packages/compiler/src/backend/llvm/lib-shared.ts index c08d7b720..8805d7e0c 100644 --- a/packages/compiler/src/backend/llvm/lib-shared.ts +++ b/packages/compiler/src/backend/llvm/lib-shared.ts @@ -620,6 +620,8 @@ export const LIB_FN_SYMS: Record = { "webcrypto.exportKey": "scr_webcrypto_export_key", "webcrypto.encrypt": "scr_webcrypto_encrypt", "webcrypto.decrypt": "scr_webcrypto_decrypt", + "webcrypto.wrapKey": "scr_webcrypto_wrap_key", + "webcrypto.unwrapKey": "scr_webcrypto_unwrap_key", "webcrypto.deriveBits": "scr_webcrypto_derive_bits", "webcrypto.deriveKey": "scr_webcrypto_derive_key", "webcrypto.sign": "scr_webcrypto_sign", @@ -1595,6 +1597,8 @@ export const USES_TIMERS_LIB_FNS = new Set([ "webcrypto.generateKey", "webcrypto.encrypt", "webcrypto.decrypt", + "webcrypto.wrapKey", + "webcrypto.unwrapKey", "webcrypto.deriveBits", "webcrypto.deriveKey", "webcrypto.sign", diff --git a/packages/compiler/src/backend/target-diagnostics.ts b/packages/compiler/src/backend/target-diagnostics.ts index eb70a0d2c..bd901341e 100644 --- a/packages/compiler/src/backend/target-diagnostics.ts +++ b/packages/compiler/src/backend/target-diagnostics.ts @@ -208,10 +208,15 @@ export function moduleWasiUnavailableSurface( }; return false; } - if (node.fn === "webcrypto.encrypt" || node.fn === "webcrypto.decrypt") { + if ( + node.fn === "webcrypto.encrypt" || + node.fn === "webcrypto.decrypt" || + node.fn === "webcrypto.wrapKey" || + node.fn === "webcrypto.unwrapKey" + ) { found = { surface: - "WebCrypto encrypt and decrypt (the wasm32-wasi runtime does not include the mbedTLS library)", + "WebCrypto encrypt, decrypt, wrapKey and unwrapKey (the wasm32-wasi runtime does not include the mbedTLS library)", loc, }; return false; diff --git a/packages/compiler/src/frontend/lowering/builtins/webcrypto.ts b/packages/compiler/src/frontend/lowering/builtins/webcrypto.ts index fe310294c..e4f1f0955 100644 --- a/packages/compiler/src/frontend/lowering/builtins/webcrypto.ts +++ b/packages/compiler/src/frontend/lowering/builtins/webcrypto.ts @@ -9,8 +9,8 @@ import { isWebCryptoReceiver } from "./crypto.js"; /* WebCrypto's secret-key slice (scr_webcrypto.c, with encrypt and * decrypt in scr_webcrypto_aes.c): `crypto.subtle`'s `importKey`, - * `generateKey`, `exportKey`, `encrypt`, `decrypt`, `deriveBits`, - * `deriveKey`, `sign`, `verify` and `digest` + * `generateKey`, `exportKey`, `encrypt`, `decrypt`, `wrapKey`, + * `unwrapKey`, `deriveBits`, `deriveKey`, `sign`, `verify` and `digest` * called on the crypto global (also through * globalThis, node:crypto's webcrypto and node:crypto's subtle) lower to * runtime entry points that take the argument vector as one dyn array and @@ -25,6 +25,8 @@ const SUBTLE_LOWERED: ReadonlyMap = new Map([ ["exportKey", "webcrypto.exportKey"], ["encrypt", "webcrypto.encrypt"], ["decrypt", "webcrypto.decrypt"], + ["wrapKey", "webcrypto.wrapKey"], + ["unwrapKey", "webcrypto.unwrapKey"], ["deriveBits", "webcrypto.deriveBits"], ["deriveKey", "webcrypto.deriveKey"], ["sign", "webcrypto.sign"], @@ -33,7 +35,7 @@ const SUBTLE_LOWERED: ReadonlyMap = new Map([ ]); const SUBTLE_HINT = - "the native WebCrypto surface is crypto.subtle's importKey, generateKey and exportKey for HMAC and AES keys (importKey also for PBKDF2 and HKDF keys), encrypt and decrypt with AES-GCM, AES-CBC or AES-CTR, deriveBits and deriveKey with PBKDF2 or HKDF, sign and verify with HMAC, and digest with SHA-1, SHA-256, SHA-384 or SHA-512, each called directly on crypto.subtle"; + "the native WebCrypto surface is crypto.subtle's importKey, generateKey and exportKey for HMAC and AES keys (importKey also for PBKDF2 and HKDF keys), encrypt and decrypt with AES-GCM, AES-CBC or AES-CTR, wrapKey and unwrapKey with AES-KW or those ciphers, deriveBits and deriveKey with PBKDF2 or HKDF, sign and verify with HMAC, and digest with SHA-1, SHA-256, SHA-384 or SHA-512, each called directly on crypto.subtle"; /** Whether `node` is a SubtleCrypto object: `subtle` on a WebCrypto * Crypto object (the global, globalThis.crypto or node:crypto's diff --git a/packages/compiler/src/frontend/lowering/surfaces.ts b/packages/compiler/src/frontend/lowering/surfaces.ts index bb9a6c062..6179f8c78 100644 --- a/packages/compiler/src/frontend/lowering/surfaces.ts +++ b/packages/compiler/src/frontend/lowering/surfaces.ts @@ -2216,13 +2216,15 @@ export const AMBIENT_SURFACE_FNS: readonly AmbientSurfaceRow[] = [ "webcrypto.exportKey", "webcrypto.encrypt", "webcrypto.decrypt", + "webcrypto.wrapKey", + "webcrypto.unwrapKey", "webcrypto.deriveBits", "webcrypto.deriveKey", "webcrypto.sign", "webcrypto.verify", "webcrypto.digest", ], - note: "importKey, generateKey and exportKey (raw and jwk) for HMAC and AES keys, importKey for PBKDF2 and HKDF keys, AES-GCM, AES-CBC and AES-CTR encrypt and decrypt, PBKDF2 and HKDF deriveBits and deriveKey, HMAC sign and verify, and SHA-1/SHA-2 digest; other methods, algorithms and key formats are refused", + note: "importKey, generateKey and exportKey (raw and jwk) for HMAC and AES keys, importKey for PBKDF2 and HKDF keys, AES-GCM, AES-CBC and AES-CTR encrypt and decrypt, wrapKey and unwrapKey with AES-KW or those ciphers, PBKDF2 and HKDF deriveBits and deriveKey, HMAC sign and verify, and SHA-1/SHA-2 digest; other methods, algorithms and key formats are refused", }, { id: "stdlib.webcrypto.CryptoKey", diff --git a/packages/compiler/src/ir/builtin-signatures.ts b/packages/compiler/src/ir/builtin-signatures.ts index 8f5928d12..380c7cb7c 100644 --- a/packages/compiler/src/ir/builtin-signatures.ts +++ b/packages/compiler/src/ir/builtin-signatures.ts @@ -2862,6 +2862,8 @@ export const LIB_FN_SIGS = defineLibFnSignatures({ "webcrypto.exportKey": { argTypes: [DYN], result: { kind: "promise", inner: DYN } }, "webcrypto.encrypt": { argTypes: [DYN], result: { kind: "promise", inner: DYN } }, "webcrypto.decrypt": { argTypes: [DYN], result: { kind: "promise", inner: DYN } }, + "webcrypto.wrapKey": { argTypes: [DYN], result: { kind: "promise", inner: DYN } }, + "webcrypto.unwrapKey": { argTypes: [DYN], result: { kind: "promise", inner: DYN } }, "webcrypto.deriveBits": { argTypes: [DYN], result: { kind: "promise", inner: DYN } }, "webcrypto.deriveKey": { argTypes: [DYN], result: { kind: "promise", inner: DYN } }, "webcrypto.sign": { argTypes: [DYN], result: { kind: "promise", inner: DYN } }, diff --git a/packages/compiler/src/ir/runtime-features.ts b/packages/compiler/src/ir/runtime-features.ts index 9531d7845..5c60eb54f 100644 --- a/packages/compiler/src/ir/runtime-features.ts +++ b/packages/compiler/src/ir/runtime-features.ts @@ -650,9 +650,17 @@ const RUNTIME_FEATURE_RULES = { }), /** scr_cipher.c over the mbedTLS archive; DEP0182 reports through the * process-warning unit, and unknown output encodings render through the - * inspect unit. WebCrypto's encrypt and decrypt (scr_webcrypto_aes.c) - * link the same archive. */ - cipher: rule({ fns: ["crypto.cipherNew", "webcrypto.encrypt", "webcrypto.decrypt"] }), + * inspect unit. WebCrypto's encrypt, decrypt, wrapKey and unwrapKey + * (scr_webcrypto_aes.c) link the same archive. */ + cipher: rule({ + fns: [ + "crypto.cipherNew", + "webcrypto.encrypt", + "webcrypto.decrypt", + "webcrypto.wrapKey", + "webcrypto.unwrapKey", + ], + }), copying: rule({ expr: (node, _tables) => (node.kind === "arrIntrinsic" && COPYING_ARR_METHODS.has(node.method)) || @@ -688,6 +696,8 @@ const RUNTIME_FEATURE_RULES = { "crypto.cipherNew", "webcrypto.encrypt", "webcrypto.decrypt", + "webcrypto.wrapKey", + "webcrypto.unwrapKey", "crypto.ecdhNew", ], prefixes: [...READABLE_DYN_ASYNC_PREFIXES, "wasm."], @@ -796,6 +806,8 @@ const RUNTIME_FEATURE_RULES = { "crypto.cipherNew", "webcrypto.encrypt", "webcrypto.decrypt", + "webcrypto.wrapKey", + "webcrypto.unwrapKey", "crypto.ecdhNew", "crypto.ecdhConvertKey", ...BUILTIN_CLASS_LIB_FNS, diff --git a/packages/compiler/surface-manifest.json b/packages/compiler/surface-manifest.json index 3e8b9df73..02b1181b5 100644 --- a/packages/compiler/surface-manifest.json +++ b/packages/compiler/surface-manifest.json @@ -5718,7 +5718,7 @@ "kind": "stdlib", "name": "globalThis.crypto.subtle", "status": "static", - "note": "importKey, generateKey and exportKey (raw and jwk) for HMAC and AES keys, importKey for PBKDF2 and HKDF keys, AES-GCM, AES-CBC and AES-CTR encrypt and decrypt, PBKDF2 and HKDF deriveBits and deriveKey, HMAC sign and verify, and SHA-1/SHA-2 digest; other methods, algorithms and key formats are refused" + "note": "importKey, generateKey and exportKey (raw and jwk) for HMAC and AES keys, importKey for PBKDF2 and HKDF keys, AES-GCM, AES-CBC and AES-CTR encrypt and decrypt, wrapKey and unwrapKey with AES-KW or those ciphers, PBKDF2 and HKDF deriveBits and deriveKey, HMAC sign and verify, and SHA-1/SHA-2 digest; other methods, algorithms and key formats are refused" }, { "id": "syntax.async-generators", diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7130-webcrypto-wrap-key.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7130-webcrypto-wrap-key.ts.json new file mode 100644 index 000000000..fa5b5529f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7130-webcrypto-wrap-key.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7130-webcrypto-wrap-key.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7131-webcrypto-wrap-key-errors.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7131-webcrypto-wrap-key-errors.mjs.json new file mode 100644 index 000000000..275ffa418 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7131-webcrypto-wrap-key-errors.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7131-webcrypto-wrap-key-errors.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7132-jose-pbes2/main.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7132-jose-pbes2/main.mjs.json new file mode 100644 index 000000000..9fbd24555 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7132-jose-pbes2/main.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7132-jose-pbes2/main.mjs" + ], + "diags": [] +} diff --git a/packages/runtime/src/scr_crypto.h b/packages/runtime/src/scr_crypto.h index ddc306598..99d8b85bc 100644 --- a/packages/runtime/src/scr_crypto.h +++ b/packages/runtime/src/scr_crypto.h @@ -241,6 +241,13 @@ typedef ScrBytes *(*ScrWebCryptoAesFn)(const char *name, bool decrypt, const uns ScrPromise *scr_webcrypto_cipher(ScrDyn *args, bool decrypt, ScrWebCryptoAesFn aes); ScrPromise *scr_webcrypto_encrypt(ScrDyn *args); ScrPromise *scr_webcrypto_decrypt(ScrDyn *args); +/* wrapKey and unwrapKey run the same way (AES-KW wrapping, or the AES + * ciphers): wrapKey fulfills with an ArrayBuffer and unwrapKey with a + * CryptoKey on a later loop turn. */ +ScrPromise *scr_webcrypto_wrap(ScrDyn *args, ScrWebCryptoAesFn aes); +ScrPromise *scr_webcrypto_unwrap(ScrDyn *args, ScrWebCryptoAesFn aes); +ScrPromise *scr_webcrypto_wrap_key(ScrDyn *args); +ScrPromise *scr_webcrypto_unwrap_key(ScrDyn *args); /* deriveBits and deriveKey (PBKDF2 and HKDF) over node:crypto's KDF core: * deriveBits fulfills with an ArrayBuffer (at once for a zero length) and * deriveKey with a CryptoKey of the derived key type, on a later loop diff --git a/packages/runtime/src/scr_webcrypto.c b/packages/runtime/src/scr_webcrypto.c index 4d2c27be4..fc6941e36 100644 --- a/packages/runtime/src/scr_webcrypto.c +++ b/packages/runtime/src/scr_webcrypto.c @@ -104,7 +104,7 @@ static const char *scr_wc_native_hash(const char *name) { /* ── errors ────────────────────────────────────────────────────────── */ -static const char *const scr_wc_ordinals[] = {"1st", "2nd", "3rd", "4th", "5th"}; +static const char *const scr_wc_ordinals[] = {"1st", "2nd", "3rd", "4th", "5th", "6th", "7th"}; static void scr_wc_type_error(const char *code, const char *fmt, ...) __attribute__((format(printf, 2, 3))); @@ -1151,6 +1151,47 @@ done: return scr_wc_deferred(key); } +/* exportKeySync's checks for a secret key: false with Node's error + * pending. raw, raw-secret and jwk are the formats a secret key exports. */ +static bool scr_wc_exportable(const char *format, const ScrCryptoKey *key) { + if (scr_wc_is_kdf(key->name)) { + char message[64]; + snprintf(message, sizeof message, "%s key export is not supported", key->name); + scr_throw_domex("NotSupportedError", message); + return false; + } + if (!key->extractable) { + scr_throw_domex("InvalidAccessError", "key is not extractable"); + return false; + } + if (strcmp(format, "raw") != 0 && strcmp(format, "raw-secret") != 0 && + strcmp(format, "jwk") != 0) { + char message[96]; + snprintf(message, sizeof message, "Unable to export %s secret key using %s format", key->name, + format); + scr_throw_domex("NotSupportedError", message); + return false; + } + return true; +} + +/* The key bytes as a fresh u8 view (+1). */ +static ScrBytes *scr_wc_key_bytes(const ScrCryptoKey *key) { + ScrBytes *bytes = scr_bytes_new(SCR_BYTES_U8, (double)key->len); + if (key->len) memcpy(bytes->data, key->data, key->len); + return bytes; +} + +/* A JWK's k: the key bytes in unpadded base64url (+1). */ +static ScrStr *scr_wc_jwk_k(const ScrCryptoKey *key) { + ScrBytes *bytes = scr_wc_key_bytes(key); + ScrStr *encoding = scr_str_new("base64url", 9); + ScrStr *k = scr_bytes_to_str(bytes, encoding); + scr_str_release(encoding); + scr_bytes_release(bytes); + return k; +} + /* exportKeySync for secret keys: raw and raw-secret answer an ArrayBuffer * of the key bytes, jwk an object { key_ops, ext, alg, kty, k }. */ static ScrDyn *scr_wc_export(const ScrDyn *args) { @@ -1166,30 +1207,11 @@ static ScrDyn *scr_wc_export(const ScrDyn *args) { scr_wc_type_error("ERR_INVALID_ARG_TYPE", "%s: 2nd argument is not of type CryptoKey.", prefix); goto done; } - if (scr_wc_is_kdf(key->name)) { - char message[64]; - snprintf(message, sizeof message, "%s key export is not supported", key->name); - scr_throw_domex("NotSupportedError", message); - goto done; - } - if (!key->extractable) { - scr_throw_domex("InvalidAccessError", "key is not extractable"); - goto done; - } - if (strcmp(format, "raw") == 0 || strcmp(format, "raw-secret") == 0) { - ScrBytes *bytes = scr_bytes_new(SCR_BYTES_U8, (double)key->len); - if (key->len) memcpy(bytes->data, key->data, key->len); - result = scr_array_buffer_from_bytes(bytes); - scr_bytes_release(bytes); - } else if (strcmp(format, "jwk") == 0) { + if (!scr_wc_exportable(format, key)) goto done; + if (strcmp(format, "jwk") == 0) { char buf[16]; const char *alg = scr_wc_jwk_alg(key->name, key->hash, key->length, buf, sizeof buf); - ScrBytes *bytes = scr_bytes_new(SCR_BYTES_U8, (double)key->len); - if (key->len) memcpy(bytes->data, key->data, key->len); - ScrStr *encoding = scr_str_new("base64url", 9); - ScrStr *k = scr_bytes_to_str(bytes, encoding); - scr_str_release(encoding); - scr_bytes_release(bytes); + ScrStr *k = scr_wc_jwk_k(key); result = scr_dyn_new_obj(); scr_dyn_obj_set(result, "key_ops", 7, scr_wc_usage_array(key->usages)); scr_dyn_obj_set(result, "ext", 3, scr_dyn_new_bool(key->extractable)); @@ -1198,10 +1220,9 @@ static ScrDyn *scr_wc_export(const ScrDyn *args) { scr_dyn_obj_set(result, "k", 1, scr_dyn_new_str(k)); scr_str_release(k); } else { - char message[96]; - snprintf(message, sizeof message, "Unable to export %s secret key using %s format", key->name, - format); - scr_throw_domex("NotSupportedError", message); + ScrBytes *bytes = scr_wc_key_bytes(key); + result = scr_array_buffer_from_bytes(bytes); + scr_bytes_release(bytes); } done: scr_wc_args_drop(&a, 2); @@ -1548,6 +1569,43 @@ static ScrPromise *scr_wc_deferred_buffer(ScrBytes *bytes) { return p; } +/* The cipher over `data` (cipherOrWrap's job): +1 output bytes, or NULL + * with Node's OperationError pending. */ +static ScrBytes *scr_wc_cipher_bytes(ScrWebCryptoAesFn aes, const char *name, bool decrypt, + const ScrCryptoKey *key, ScrWcCipherParams *params, + ScrBytes *data) { + if (!params->iv) params->iv = scr_bytes_new(SCR_BYTES_U8, 0); + if (!params->aad) params->aad = scr_bytes_new(SCR_BYTES_U8, 0); + ScrBytes *view = data; + SCR_BYTES_SNAPSHOT(view); + ScrBytes *iv = params->iv; + SCR_BYTES_SNAPSHOT(iv); + ScrBytes *aad = params->aad; + SCR_BYTES_SNAPSHOT(aad); + ScrWebCryptoAesParams run = { + .iv = iv->data, + .iv_len = (size_t)scr_bytes_byte_len(iv), + .aad = aad->data, + .aad_len = (size_t)scr_bytes_byte_len(aad), + .tag_len = (size_t)(params->tag_bits / 8), + .counter_bits = (unsigned)params->counter_bits, + }; + ScrBytes *out = + aes(name, decrypt, key->data, key->len, &run, view->data, (size_t)scr_bytes_byte_len(view)); + if (!out) + scr_throw_domex("OperationError", "The operation failed for an operation-specific reason"); + return out; +} + +/* The cipher's promise: an ArrayBuffer of the output, or the job's + * OperationError, on a later loop turn. */ +static ScrPromise *scr_wc_run_cipher(ScrWebCryptoAesFn aes, const char *name, bool decrypt, + const ScrCryptoKey *key, ScrWcCipherParams *params, + ScrBytes *data) { + ScrBytes *out = scr_wc_cipher_bytes(aes, name, decrypt, key, params, data); + return out ? scr_wc_deferred_buffer(out) : scr_wc_deferred_rejection(); +} + ScrPromise *scr_webcrypto_cipher(ScrDyn *args, bool decrypt, ScrWebCryptoAesFn aes) { const char *method = decrypt ? "decrypt" : "encrypt"; const char *prefix = decrypt ? "Failed to execute 'decrypt' on 'SubtleCrypto'" @@ -1580,31 +1638,7 @@ ScrPromise *scr_webcrypto_cipher(ScrDyn *args, bool decrypt, ScrWebCryptoAesFn a goto done; } if (!scr_wc_max_length(data, "data")) goto done; - { - ScrBytes *view = data; - SCR_BYTES_SNAPSHOT(view); - ScrBytes *iv = params.iv; - SCR_BYTES_SNAPSHOT(iv); - if (!params.aad) params.aad = scr_bytes_new(SCR_BYTES_U8, 0); - ScrBytes *aad = params.aad; - SCR_BYTES_SNAPSHOT(aad); - ScrWebCryptoAesParams run = { - .iv = iv->data, - .iv_len = (size_t)scr_bytes_byte_len(iv), - .aad = aad->data, - .aad_len = (size_t)scr_bytes_byte_len(aad), - .tag_len = (size_t)(params.tag_bits / 8), - .counter_bits = (unsigned)params.counter_bits, - }; - ScrBytes *out = aes(name, decrypt, key->data, key->len, &run, view->data, - (size_t)scr_bytes_byte_len(view)); - if (out) { - result = scr_wc_deferred_buffer(out); - } else { - scr_throw_domex("OperationError", "The operation failed for an operation-specific reason"); - result = scr_wc_deferred_rejection(); - } - } + result = scr_wc_run_cipher(aes, name, decrypt, key, ¶ms, data); done: if (data) scr_bytes_release(data); scr_wc_cipher_params_drop(¶ms); @@ -1612,6 +1646,185 @@ done: return result ? result : scr_wc_rejected(); } +/* ── wrapKey and unwrapKey ──────────────────────────────────────────── + * wrapKey is exportKey followed by encrypt (or AES-KW's wrap), and + * unwrapKey is decrypt (or AES-KW's unwrap) followed by importKey, as in + * Node's webcrypto.js. The cipher runs in scr_webcrypto_aes.c. */ + +/* normalizeAlgorithm(algorithm, 'wrapKey' / 'unwrapKey'), falling back to + * the 'encrypt' / 'decrypt' registry as Node does: AES-KW (no + * parameters), or the AES ciphers with their dictionaries. */ +static const char *scr_wc_normalize_wrap(ScrDyn *identifier, const char *method, + ScrWcCipherParams *params) { + memset(params, 0, sizeof *params); + ScrStr *name = scr_wc_algorithm_name(identifier, "Algorithm"); + if (!name) return NULL; + bool kw = scr_wc_ascii_ieq(name, "AES-KW"); + scr_str_release(name); + if (kw) return "AES-KW"; + return scr_wc_normalize_cipher(identifier, method, params); +} + +/* The bytes wrapKey encrypts (+1): the raw key, or the JWK's JSON text, + * padded with spaces to a multiple of 8 bytes for AES-KW. */ +static ScrBytes *scr_wc_wrap_payload(const char *format, const ScrCryptoKey *key, bool kw) { + if (strcmp(format, "jwk") != 0) return scr_wc_key_bytes(key); + char buf[16]; + const char *alg = scr_wc_jwk_alg(key->name, key->hash, key->length, buf, sizeof buf); + ScrStr *k = scr_wc_jwk_k(key); + ScrJsonBuf b; + scr_jb_init(&b); + scr_jb_puts(&b, "{\"key_ops\":["); + bool first = true; + for (size_t i = 0; i < SCR_WC_COUNT(scr_wc_usages); i++) { + if (!(key->usages & (1u << i))) continue; + if (!first) scr_jb_puts(&b, ","); + first = false; + scr_jb_puts(&b, "\""); + scr_jb_puts(&b, scr_wc_usages[i]); + scr_jb_puts(&b, "\""); + } + scr_jb_puts(&b, key->extractable ? "],\"ext\":true" : "],\"ext\":false"); + if (alg) { + scr_jb_puts(&b, ",\"alg\":\""); + scr_jb_puts(&b, alg); + scr_jb_puts(&b, "\""); + } + scr_jb_puts(&b, ",\"kty\":\"oct\",\"k\":\""); + ScrStr *json_prefix = scr_jb_finish(&b); + size_t len = json_prefix->len + k->len + 2; + size_t padded = kw && len % 8 ? len + 8 - len % 8 : len; + ScrBytes *out = scr_bytes_new(SCR_BYTES_U8, (double)padded); + memcpy(out->data, json_prefix->data, json_prefix->len); + memcpy(out->data + json_prefix->len, k->data, k->len); + memcpy(out->data + json_prefix->len + k->len, "\"}", 2); + memset(out->data + len, ' ', padded - len); + scr_str_release(json_prefix); + scr_str_release(k); + return out; +} + +/* wrapKey(format, key, wrappingKey, wrapAlgorithm). */ +ScrPromise *scr_webcrypto_wrap(ScrDyn *args, ScrWebCryptoAesFn aes) { + static const char prefix[] = "Failed to execute 'wrapKey' on 'SubtleCrypto'"; + if (!scr_wc_required(prefix, args, 4)) return scr_wc_rejected(); + ScrWcArgs a; + scr_wc_args_take(&a, args, 4); + ScrWcCipherParams params; + memset(¶ms, 0, sizeof params); + ScrBytes *payload = NULL; + ScrPromise *result = NULL; + const char *format = scr_wc_key_format(prefix, a.v[0]); + if (!format) goto done; + ScrCryptoKey *key = scr_crypto_key_of(a.v[1]); + if (!key) { + scr_wc_type_error("ERR_INVALID_ARG_TYPE", "%s: 2nd argument is not of type CryptoKey.", prefix); + goto done; + } + ScrCryptoKey *wrapping = scr_crypto_key_of(a.v[2]); + if (!wrapping) { + scr_wc_type_error("ERR_INVALID_ARG_TYPE", "%s: 3rd argument is not of type CryptoKey.", prefix); + goto done; + } + if (!scr_wc_algorithm_identifier(a.v[3])) goto done; + const char *name = scr_wc_normalize_wrap(a.v[3], "wrapKey", ¶ms); + if (!name) goto done; + if (strcmp(wrapping->name, name) != 0) { + scr_throw_domex("InvalidAccessError", "Key algorithm mismatch"); + goto done; + } + if (!(wrapping->usages & SCR_WC_USAGE_WRAP_KEY)) { + scr_throw_domex("InvalidAccessError", "Unable to use this key to wrapKey"); + goto done; + } + if (!scr_wc_exportable(format, key)) goto done; + payload = scr_wc_wrap_payload(format, key, strcmp(name, "AES-KW") == 0); + result = scr_wc_run_cipher(aes, name, false, wrapping, ¶ms, payload); +done: + if (payload) scr_bytes_release(payload); + scr_wc_cipher_params_drop(¶ms); + scr_wc_args_drop(&a, 4); + return result ? result : scr_wc_rejected(); +} + +/* parseJwk: the unwrapped bytes as UTF-8 JSON converted to a JsonWebKey + * with a kty member, or DataError "Invalid wrapped JWK key". */ +static bool scr_wc_parse_wrapped_jwk(ScrBytes *bytes, ScrWcJwk *jwk) { + static const char prefix[] = "Failed to execute 'unwrapKey' on 'SubtleCrypto'"; + ScrStr *text = scr_text_decode_options(bytes, true, false); + ScrDyn *parsed = text ? scr_json_parse(text) : NULL; + if (text) scr_str_release(text); + bool ok = parsed && scr_wc_is_object(parsed) && scr_wc_jwk_convert(prefix, parsed, jwk) && jwk->kty; + if (parsed) scr_dyn_release(parsed); + if (!ok) { + if (scr_exc_pending()) scr_caught_release(scr_exc_take()); + scr_wc_jwk_drop(jwk); + scr_throw_domex("DataError", "Invalid wrapped JWK key"); + } + return ok; +} + +/* unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgorithm, + * unwrappedKeyAlgorithm, extractable, keyUsages): argument and key errors + * reject at once; the cipher's failure and the import's errors reject on + * a later loop turn, after Node's job. */ +ScrPromise *scr_webcrypto_unwrap(ScrDyn *args, ScrWebCryptoAesFn aes) { + static const char prefix[] = "Failed to execute 'unwrapKey' on 'SubtleCrypto'"; + if (!scr_wc_required(prefix, args, 7)) return scr_wc_rejected(); + ScrDyn *v[7]; + for (size_t i = 0; i < 7; i++) v[i] = scr_dyn_arr_at(args, (double)i); + ScrWcCipherParams params; + memset(¶ms, 0, sizeof params); + ScrBytes *wrapped = NULL; + ScrPromise *result = NULL; + const char *format = scr_wc_key_format(prefix, v[0]); + if (!format) goto done; + wrapped = scr_wc_buffer_source(prefix, 1, v[1]); + if (!wrapped) goto done; + ScrCryptoKey *unwrapping = scr_crypto_key_of(v[2]); + if (!unwrapping) { + scr_wc_type_error("ERR_INVALID_ARG_TYPE", "%s: 3rd argument is not of type CryptoKey.", prefix); + goto done; + } + if (!scr_wc_algorithm_identifier(v[3]) || !scr_wc_algorithm_identifier(v[4])) goto done; + bool extractable = scr_dyn_truthy(v[5]); + long usages = scr_wc_key_usages(prefix, 6, v[6]); + if (usages < 0) goto done; + const char *name = scr_wc_normalize_wrap(v[3], "unwrapKey", ¶ms); + if (!name) goto done; + ScrWcAlgorithm imported; + if (!scr_wc_normalize(v[4], scr_wc_import_names, SCR_WC_COUNT(scr_wc_import_names), + SCR_WC_OP_IMPORT, &imported)) + goto done; + if (strcmp(unwrapping->name, name) != 0) { + scr_throw_domex("InvalidAccessError", "Key algorithm mismatch"); + goto done; + } + if (!(unwrapping->usages & SCR_WC_USAGE_UNWRAP_KEY)) { + scr_throw_domex("InvalidAccessError", "Unable to use this key to unwrapKey"); + goto done; + } + if (!scr_wc_max_length(wrapped, "data")) goto done; + ScrBytes *bytes = scr_wc_cipher_bytes(aes, name, true, unwrapping, ¶ms, wrapped); + if (!bytes) { + result = scr_wc_deferred_rejection(); + goto done; + } + ScrWcJwk jwk; + memset(&jwk, 0, sizeof jwk); + ScrDyn *key = NULL; + if (strcmp(format, "jwk") != 0 || scr_wc_parse_wrapped_jwk(bytes, &jwk)) + key = scr_wc_import_key_sync(format, bytes, &jwk, &imported, extractable, usages); + scr_wc_jwk_drop(&jwk); + scr_bytes_release(bytes); + result = key ? scr_wc_deferred(key) : scr_wc_deferred_rejection(); +done: + if (wrapped) scr_bytes_release(wrapped); + scr_wc_cipher_params_drop(¶ms); + for (size_t i = 0; i < 7; i++) scr_dyn_release(v[i]); + return result ? result : scr_wc_rejected(); +} + /* ── deriveBits and deriveKey ───────────────────────────────────────── * PBKDF2 and HKDF over node:crypto's KDF core (scr_crypto_pbkdf2 and * scr_crypto_hkdf_bytes in scr_lib.c), with Node's Pbkdf2Params and diff --git a/packages/runtime/src/scr_webcrypto_aes.c b/packages/runtime/src/scr_webcrypto_aes.c index 7cb63f561..016ac57af 100644 --- a/packages/runtime/src/scr_webcrypto_aes.c +++ b/packages/runtime/src/scr_webcrypto_aes.c @@ -122,11 +122,74 @@ static ScrBytes *scr_wc_aes_ctr(const unsigned char *key, size_t key_len, return out; } +/* RFC 3394 AES key wrap with the default IV: wrapping takes a multiple of + * 8 bytes, at least 16; unwrapping a multiple of 8, at least 24, and fails + * when the integrity check value does not match (compared in constant + * time). */ +static ScrBytes *scr_wc_aes_kw(bool unwrap, const unsigned char *key, size_t key_len, + const unsigned char *in, size_t len) { + static const unsigned char iv[8] = {0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6}; + if (len % 8 != 0 || len < (unwrap ? 24u : 16u)) return NULL; + size_t n = unwrap ? len / 8 - 1 : len / 8; + mbedtls_aes_context aes; + mbedtls_aes_init(&aes); + int rc = unwrap ? mbedtls_aes_setkey_dec(&aes, key, (unsigned)(key_len * 8)) + : mbedtls_aes_setkey_enc(&aes, key, (unsigned)(key_len * 8)); + if (rc != 0) { + mbedtls_aes_free(&aes); + return NULL; + } + ScrBytes *out = scr_bytes_new(SCR_BYTES_U8, (double)(unwrap ? len - 8 : len + 8)); + unsigned char a[8], block[16]; + unsigned char *r = unwrap ? out->data : out->data + 8; + if (unwrap) { + memcpy(a, in, 8); + memcpy(r, in + 8, len - 8); + for (int j = 5; j >= 0; j--) { + for (size_t i = n; i >= 1; i--) { + uint64_t t = (uint64_t)n * (uint64_t)j + i; + for (int k = 0; k < 8; k++) block[k] = (unsigned char)(a[k] ^ (t >> (56 - 8 * k))); + memcpy(block + 8, r + 8 * (i - 1), 8); + mbedtls_aes_crypt_ecb(&aes, MBEDTLS_AES_DECRYPT, block, block); + memcpy(a, block, 8); + memcpy(r + 8 * (i - 1), block + 8, 8); + } + } + } else { + memcpy(a, iv, 8); + memcpy(r, in, len); + for (int j = 0; j <= 5; j++) { + for (size_t i = 1; i <= n; i++) { + memcpy(block, a, 8); + memcpy(block + 8, r + 8 * (i - 1), 8); + mbedtls_aes_crypt_ecb(&aes, MBEDTLS_AES_ENCRYPT, block, block); + uint64_t t = (uint64_t)n * (uint64_t)j + i; + for (int k = 0; k < 8; k++) a[k] = (unsigned char)(block[k] ^ (t >> (56 - 8 * k))); + memcpy(r + 8 * (i - 1), block + 8, 8); + } + } + memcpy(out->data, a, 8); + } + mbedtls_platform_zeroize(block, sizeof block); + mbedtls_aes_free(&aes); + if (unwrap) { + unsigned char diff = 0; + for (int k = 0; k < 8; k++) diff |= (unsigned char)(a[k] ^ iv[k]); + if (diff) { + mbedtls_platform_zeroize(out->data, len - 8); + scr_bytes_release(out); + return NULL; + } + } + return out; +} + /* The cipher scr_webcrypto_cipher runs: +1 output bytes, or NULL when the * operation fails (Node's OperationError). */ static ScrBytes *scr_wc_aes(const char *name, bool decrypt, const unsigned char *key, size_t key_len, const ScrWebCryptoAesParams *p, const unsigned char *in, size_t len) { + if (strcmp(name, "AES-KW") == 0) return scr_wc_aes_kw(decrypt, key, key_len, in, len); if (strcmp(name, "AES-GCM") == 0) return scr_wc_aes_gcm(decrypt, key, key_len, p, in, len); if (strcmp(name, "AES-CBC") == 0) return scr_wc_aes_cbc(decrypt, key, key_len, p, in, len); return scr_wc_aes_ctr(key, key_len, p, in, len); @@ -135,3 +198,7 @@ static ScrBytes *scr_wc_aes(const char *name, bool decrypt, const unsigned char ScrPromise *scr_webcrypto_encrypt(ScrDyn *args) { return scr_webcrypto_cipher(args, false, scr_wc_aes); } ScrPromise *scr_webcrypto_decrypt(ScrDyn *args) { return scr_webcrypto_cipher(args, true, scr_wc_aes); } + +ScrPromise *scr_webcrypto_wrap_key(ScrDyn *args) { return scr_webcrypto_wrap(args, scr_wc_aes); } + +ScrPromise *scr_webcrypto_unwrap_key(ScrDyn *args) { return scr_webcrypto_unwrap(args, scr_wc_aes); } diff --git a/tests/corpus/7130-webcrypto-wrap-key.ts b/tests/corpus/7130-webcrypto-wrap-key.ts new file mode 100644 index 000000000..8cf51fab4 --- /dev/null +++ b/tests/corpus/7130-webcrypto-wrap-key.ts @@ -0,0 +1,69 @@ +// crypto.subtle.wrapKey and unwrapKey: AES-KW wrapping matches RFC 3394's +// test vectors, raw and JSON Web Key payloads round-trip (AES-KW pads the +// JWK's JSON with spaces to a multiple of 8 bytes), and AES-GCM, AES-CBC +// and AES-CTR wrap keys the way encrypt does. jose's A128KW and +// PBES2-HS256+A128KW content-key wrapping is the shape used here. +const encoder = new TextEncoder(); + +function hex(buffer: ArrayBuffer): string { + return Buffer.from(buffer).toString("hex"); +} + +type Key = Awaited>; + +function describe(key: Key): string { + return JSON.stringify({ algorithm: key.algorithm, usages: key.usages, extractable: key.extractable }); +} + +// RFC 3394 section 4: 128-, 192- and 256-bit key data under each KEK size. +const vectors: [string, string, string][] = [ + ["000102030405060708090A0B0C0D0E0F", "00112233445566778899AABBCCDDEEFF", "1fa68b0a8112b447aef34bd8fb5a7b829d3e862371d2cfe5"], + ["000102030405060708090A0B0C0D0E0F1011121314151617", "00112233445566778899AABBCCDDEEFF", "96778b25ae6ca435f92b5b97c050aed2468ab8a17ad84e5d"], + ["000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F", "00112233445566778899AABBCCDDEEFF", "64e8c3f9ce0f5ba263e9777905818a2a93c8191e7d6e8ae7"], + ["000102030405060708090A0B0C0D0E0F1011121314151617", "00112233445566778899AABBCCDDEEFF0001020304050607", "031d33264e15d33268f24ec260743edce1c6c7ddee725a936ba814915c6762d2"], + ["000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F", "00112233445566778899AABBCCDDEEFF000102030405060708090A0B0C0D0E0F", "28c9f404c4b810f4cbccb35cfb87f8263f5786e2d80ed326cbc7f0e71a99f43bfb988b9b7a02dd21"], +]; +for (const [kekHex, dataHex, expected] of vectors) { + const kek = await crypto.subtle.importKey("raw", Buffer.from(kekHex, "hex"), "AES-KW", false, ["wrapKey", "unwrapKey"]); + const data = await crypto.subtle.importKey("raw", Buffer.from(dataHex, "hex"), "AES-CBC", true, ["encrypt"]); + const wrapped = await crypto.subtle.wrapKey("raw", data, kek, "AES-KW"); + console.log(hex(wrapped) === expected, hex(wrapped)); + const unwrapped = await crypto.subtle.unwrapKey("raw", wrapped, kek, { name: "aes-kw" }, "AES-CBC", true, ["decrypt"]); + console.log(describe(unwrapped), hex(await crypto.subtle.exportKey("raw", unwrapped))); +} + +// jose's content-key wrap: an HMAC key wrapped raw, then unwrapped and exported. +const kek = await crypto.subtle.importKey("raw", new Uint8Array(16).fill(7), "AES-KW", true, ["wrapKey", "unwrapKey"]); +const cek = await crypto.subtle.importKey("raw", new Uint8Array(32).fill(9), { name: "HMAC", hash: "SHA-256" }, true, ["sign"]); +const wrappedCek = await crypto.subtle.wrapKey("raw", cek, kek, "AES-KW"); +console.log(hex(wrappedCek)); +const back = await crypto.subtle.unwrapKey("raw", wrappedCek, kek, "AES-KW", { hash: "SHA-256", name: "HMAC" }, true, ["sign"]); +console.log(describe(back), hex(await crypto.subtle.exportKey("raw", back))); + +// JSON Web Key payloads, padded for AES-KW. +const wrappedJwk = await crypto.subtle.wrapKey("jwk", cek, kek, "AES-KW"); +console.log(wrappedJwk.byteLength, hex(wrappedJwk)); +const fromJwk = await crypto.subtle.unwrapKey("jwk", wrappedJwk, kek, "AES-KW", { name: "HMAC", hash: "SHA-256" }, false, ["sign"]); +console.log(describe(fromJwk)); +const asRaw = await crypto.subtle.unwrapKey("raw", wrappedJwk, kek, "AES-KW", { name: "HMAC", hash: "SHA-256" }, true, ["sign"]); +const padded = new TextDecoder().decode(await crypto.subtle.exportKey("raw", asRaw)); +console.log(JSON.stringify(padded), padded.length); + +// The AES ciphers as wrapping algorithms. +const gcmKey = await crypto.subtle.importKey("raw", new Uint8Array(16).fill(3), "AES-GCM", false, ["wrapKey", "unwrapKey"]); +const iv = new Uint8Array(12).fill(1); +const gcmWrapped = await crypto.subtle.wrapKey("jwk", cek, gcmKey, { name: "AES-GCM", iv }); +console.log(gcmWrapped.byteLength, hex(gcmWrapped).slice(0, 64)); +console.log(describe(await crypto.subtle.unwrapKey("jwk", gcmWrapped, gcmKey, { name: "AES-GCM", iv }, { name: "HMAC", hash: "SHA-256" }, true, ["sign"]))); +const cbcKey = await crypto.subtle.importKey("raw", new Uint8Array(32).fill(4), "AES-CBC", false, ["wrapKey", "unwrapKey"]); +const cbcWrapped = await crypto.subtle.wrapKey("raw", cek, cbcKey, { name: "AES-CBC", iv: new Uint8Array(16) }); +console.log(hex(cbcWrapped)); +console.log(describe(await crypto.subtle.unwrapKey("raw", cbcWrapped, cbcKey, { name: "AES-CBC", iv: new Uint8Array(16) }, "AES-GCM", false, ["encrypt"]))); +const ctrKey = await crypto.subtle.importKey("raw", new Uint8Array(24).fill(5), "AES-CTR", false, ["wrapKey", "unwrapKey"]); +const ctr = { name: "AES-CTR", counter: new Uint8Array(16), length: 64 }; +const ctrWrapped = await crypto.subtle.wrapKey("raw", cek, ctrKey, ctr); +console.log(hex(ctrWrapped)); +const fromCtr = await crypto.subtle.unwrapKey("raw", ctrWrapped, ctrKey, ctr, { name: "HMAC", hash: "SHA-1" }, true, ["verify"]); +console.log(describe(fromCtr)); +const signature = await crypto.subtle.sign("HMAC", back, encoder.encode("message")); +console.log(hex(signature).slice(0, 32)); diff --git a/tests/corpus/7131-webcrypto-wrap-key-errors.mjs b/tests/corpus/7131-webcrypto-wrap-key-errors.mjs new file mode 100644 index 000000000..23cb3e10d --- /dev/null +++ b/tests/corpus/7131-webcrypto-wrap-key-errors.mjs @@ -0,0 +1,65 @@ +// Rejections of crypto.crypto.subtle.wrapKey and unwrapKey in Node's order: +// argument conversion, wrap algorithm normalization (AES-KW, then the +// encrypt registry), the wrapping key's algorithm and usages, the export +// or import of the wrapped key, and the cipher's OperationErrors (AES-KW's +// length rules and integrity check), which reject on a later turn. + +async function attempt(label, run) { + try { + const value = await run(); + const shown = value instanceof ArrayBuffer ? `ArrayBuffer(${value.byteLength})` : value instanceof CryptoKey ? JSON.stringify([value.algorithm, value.usages]) : value; + console.log(label, "resolves", shown); + } catch (e) { + console.log(label, e.name, e.code, e.message); + } +} + +const kek = await crypto.subtle.importKey("raw", new Uint8Array(16).fill(1), "AES-KW", true, ["wrapKey", "unwrapKey"]); +const unwrapOnly = await crypto.subtle.importKey("raw", new Uint8Array(16).fill(1), "AES-KW", true, ["unwrapKey"]); +const gcm = await crypto.subtle.importKey("raw", new Uint8Array(16), "AES-GCM", true, ["wrapKey", "unwrapKey"]); +const hmac20 = await crypto.subtle.importKey("raw", new Uint8Array(20).fill(2), { name: "HMAC", hash: "SHA-256" }, true, ["sign"]); +const hmac32 = await crypto.subtle.importKey("raw", new Uint8Array(32).fill(2), { name: "HMAC", hash: "SHA-256" }, true, ["sign"]); +const locked = await crypto.subtle.importKey("raw", new Uint8Array(16), "AES-CBC", false, ["encrypt"]); +const password = await crypto.subtle.importKey("raw", new Uint8Array(4), "PBKDF2", false, ["deriveBits"]); +const hs256 = { name: "HMAC", hash: "SHA-256" }; + +await attempt("wrap too few", () => crypto.subtle.wrapKey("raw", hmac32, kek)); +await attempt("wrap bad format", () => crypto.subtle.wrapKey("pem", hmac32, kek, "AES-KW")); +await attempt("wrap key not a key", () => crypto.subtle.wrapKey("raw", JSON.parse("{}"), kek, "AES-KW")); +await attempt("wrap wrapping key not a key", () => crypto.subtle.wrapKey("raw", hmac32, JSON.parse("{}"), "AES-KW")); +await attempt("wrap unknown algorithm", () => crypto.subtle.wrapKey("raw", hmac32, kek, "AES-XTS")); +await attempt("wrap no name", () => crypto.subtle.wrapKey("raw", hmac32, kek, {})); +await attempt("wrap gcm without iv", () => crypto.subtle.wrapKey("raw", hmac32, gcm, "AES-GCM")); +await attempt("wrap mismatch", () => crypto.subtle.wrapKey("raw", hmac32, gcm, "AES-KW")); +await attempt("wrap ctr on gcm key", () => crypto.subtle.wrapKey("raw", hmac32, gcm, { name: "AES-CTR", counter: new Uint8Array(16), length: 64 })); +await attempt("wrap missing usage", () => crypto.subtle.wrapKey("raw", hmac32, unwrapOnly, "AES-KW")); +await attempt("wrap pbkdf2 key", () => crypto.subtle.wrapKey("raw", password, kek, "AES-KW")); +await attempt("wrap non-extractable", () => crypto.subtle.wrapKey("raw", locked, kek, "AES-KW")); +await attempt("wrap spki", () => crypto.subtle.wrapKey("spki", hmac32, kek, "AES-KW")); +await attempt("wrap 20 bytes with AES-KW", () => crypto.subtle.wrapKey("raw", hmac20, kek, "AES-KW")); +await attempt("wrap 20 bytes with AES-GCM", () => crypto.subtle.wrapKey("raw", hmac20, gcm, { name: "AES-GCM", iv: new Uint8Array(12) })); + +const wrapped = new Uint8Array(await crypto.subtle.wrapKey("raw", hmac32, kek, "AES-KW")); +const tampered = wrapped.slice(); +tampered[3] ^= 1; +const notJson = await crypto.subtle.wrapKey("raw", hmac32, kek, "AES-KW"); +await attempt("unwrap too few", () => crypto.subtle.unwrapKey("raw", wrapped, kek, "AES-KW", hs256, true)); +await attempt("unwrap data string", () => crypto.subtle.unwrapKey("raw", "x", kek, "AES-KW", hs256, true, ["sign"])); +await attempt("unwrap not a key", () => crypto.subtle.unwrapKey("raw", wrapped, JSON.parse("{}"), "AES-KW", hs256, true, ["sign"])); +await attempt("unwrap bad usage name", () => crypto.subtle.unwrapKey("raw", wrapped, kek, "AES-KW", hs256, true, ["fly"])); +await attempt("unwrap hmac without hash", () => crypto.subtle.unwrapKey("raw", wrapped, kek, "AES-KW", { name: "HMAC" }, true, ["sign"])); +await attempt("unwrap unknown key algorithm", () => crypto.subtle.unwrapKey("raw", wrapped, kek, "AES-KW", "TWOFISH", true, ["sign"])); +await attempt("unwrap mismatch", () => crypto.subtle.unwrapKey("raw", wrapped, gcm, "AES-KW", hs256, true, ["sign"])); +await attempt("unwrap missing usage", async () => crypto.subtle.unwrapKey("raw", wrapped, await crypto.subtle.importKey("raw", new Uint8Array(16).fill(1), "AES-KW", true, ["wrapKey"]), "AES-KW", hs256, true, ["sign"])); +await attempt("unwrap tampered", () => crypto.subtle.unwrapKey("raw", tampered, kek, "AES-KW", hs256, true, ["sign"])); +await attempt("unwrap 16 bytes", () => crypto.subtle.unwrapKey("raw", new Uint8Array(16), kek, "AES-KW", hs256, true, ["sign"])); +await attempt("unwrap 28 bytes", () => crypto.subtle.unwrapKey("raw", new Uint8Array(28), kek, "AES-KW", hs256, true, ["sign"])); +await attempt("unwrap bad key usage", () => crypto.subtle.unwrapKey("raw", wrapped, kek, "AES-KW", hs256, true, ["encrypt"])); +await attempt("unwrap empty usages", () => crypto.subtle.unwrapKey("raw", wrapped, kek, "AES-KW", hs256, true, [])); +await attempt("unwrap as pbkdf2", () => crypto.subtle.unwrapKey("raw", wrapped, kek, "AES-KW", "PBKDF2", false, ["deriveBits"])); +await attempt("unwrap as extractable pbkdf2", () => crypto.subtle.unwrapKey("raw", wrapped, kek, "AES-KW", "PBKDF2", true, ["deriveBits"])); +await attempt("unwrap raw bytes as jwk", () => crypto.subtle.unwrapKey("jwk", notJson, kek, "AES-KW", hs256, true, ["sign"])); +const jwkWrapped = await crypto.subtle.wrapKey("jwk", hmac32, kek, "AES-KW"); +await attempt("unwrap jwk with other usages", () => crypto.subtle.unwrapKey("jwk", jwkWrapped, kek, "AES-KW", hs256, true, ["sign", "verify"])); +await attempt("unwrap jwk as AES", () => crypto.subtle.unwrapKey("jwk", jwkWrapped, kek, "AES-KW", "AES-GCM", true, ["encrypt"])); +await attempt("unwrap jwk ok", () => crypto.subtle.unwrapKey("jwk", jwkWrapped, kek, "AES-KW", hs256, false, ["sign"])); diff --git a/tests/corpus/7132-jose-pbes2/main.mjs b/tests/corpus/7132-jose-pbes2/main.mjs new file mode 100644 index 000000000..1c0f1df13 --- /dev/null +++ b/tests/corpus/7132-jose-pbes2/main.mjs @@ -0,0 +1,50 @@ +// The real jose@6.2.12 PBES2 and AES key-wrap paths: EncryptJWT and +// jwtDecrypt from jose's public jose/jwt/encrypt, jose/jwt/decrypt and +// jose/errors entry points, over crypto.subtle importKey, deriveBits, +// wrapKey, unwrapKey, exportKey, encrypt and decrypt. node_modules/jose +// vendors the dist/webapi files those entry points load and their +// declarations, unmodified (MIT, LICENSE.md), with a package.json that +// exports only those entry points. Content keys and IVs are random, so +// tokens are checked by shape and by what they decrypt to. +import { EncryptJWT } from "jose/jwt/encrypt"; +import { jwtDecrypt } from "jose/jwt/decrypt"; +import * as errors from "jose/errors"; + +const encoder = new TextEncoder(); +const password = encoder.encode("correct horse battery staple"); +const kek = new Uint8Array(32); +for (let i = 0; i < kek.length; i++) kek[i] = i * 13 + 5; + +async function roundTrip(label, alg, enc, key, header = {}) { + const token = await new EncryptJWT({ sub: "alice", scope: "read", n: 1 }) + .setProtectedHeader({ alg, enc, ...header }) + .setIssuedAt(1_799_999_000) + .encrypt(key); + const parts = token.split("."); + const { payload, protectedHeader } = await jwtDecrypt(token, key, { + keyManagementAlgorithms: [alg], + currentDate: new Date(1_800_000_000_000), + }); + console.log(label, parts.length, parts[1].length > 0, payload.sub, payload.scope, payload.iat); + console.log(label, protectedHeader.alg, protectedHeader.enc, protectedHeader.p2c ?? "-"); + return token; +} + +const pbes = await roundTrip("pbes2 256", "PBES2-HS256+A128KW", "A256GCM", password); +await roundTrip("pbes2 384", "PBES2-HS384+A192KW", "A128CBC-HS256", password); +await roundTrip("pbes2 512", "PBES2-HS512+A256KW", "A256CBC-HS512", password); +await roundTrip("a128kw", "A128KW", "A128GCM", kek.subarray(0, 16)); +await roundTrip("a256kw", "A256KW", "A256CBC-HS512", kek); + +try { + await jwtDecrypt(pbes, encoder.encode("wrong password"), { keyManagementAlgorithms: ["PBES2-HS256+A128KW"] }); + console.log("wrong password accepted"); +} catch (e) { + console.log("wrong password", e instanceof errors.JWEDecryptionFailed, e.code); +} +try { + await jwtDecrypt(pbes, password); + console.log("unlisted algorithm accepted"); +} catch (e) { + console.log("unlisted algorithm", e instanceof errors.JOSEAlgNotAllowed, e.code); +} diff --git a/tests/corpus/7132-jose-pbes2/node_modules/jose/LICENSE.md b/tests/corpus/7132-jose-pbes2/node_modules/jose/LICENSE.md new file mode 100644 index 000000000..d0ec038a8 --- /dev/null +++ b/tests/corpus/7132-jose-pbes2/node_modules/jose/LICENSE.md @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2018 Filip Skokan + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/types/jwt/decrypt.d.ts b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/types/jwt/decrypt.d.ts new file mode 100644 index 000000000..cdf6a372a --- /dev/null +++ b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/types/jwt/decrypt.d.ts @@ -0,0 +1,34 @@ +import type * as t from '../types.d.ts'; +/** JWE decryption and JWT Claims Set validation options. */ +export interface JWTDecryptOptions extends t.DecryptOptions, t.JWTClaimVerificationOptions { +} +/** + * Resolves a JWT decryption key. No token components have been authenticated when this function is + * called. + */ +export interface JWTDecryptGetKey extends t.GetKeyFunction { +} +/** + * Decrypts a Compact JWE-formatted JWT and validates its Claims Set. + * + * @param key Private key or shared secret to decrypt and verify the JWT with. See + * {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}. + */ +export declare function jwtDecrypt(jwt: string | Uint8Array, key: t.KeyInput, options?: JWTDecryptOptions): Promise>; +/** + * Decrypts a JWT and validates its claims, returning the dynamically + * {@link t.ResolvedKey.key resolved key}. + * + * @param getKey Function resolving a private key or shared secret to decrypt and verify the JWT + * with. See {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}. + */ +export declare function jwtDecrypt(jwt: string | Uint8Array, getKey: JWTDecryptGetKey, options?: JWTDecryptOptions): Promise & t.ResolvedKey>; +/** + * Accepts a key or key resolver. Use this overload when forwarding either form; the result includes + * `key` only when a resolver was used. + * + * @param key Private key or shared secret, or a function resolving one, to decrypt and verify the + * JWT with. See + * {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}. + */ +export declare function jwtDecrypt(jwt: string | Uint8Array, key: t.KeyInput | JWTDecryptGetKey, options?: JWTDecryptOptions): Promise & Partial>; diff --git a/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/types/jwt/encrypt.d.ts b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/types/jwt/encrypt.d.ts new file mode 100644 index 000000000..c39e4c994 --- /dev/null +++ b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/types/jwt/encrypt.d.ts @@ -0,0 +1,57 @@ +import type * as t from '../types.d.ts'; +/** @param payload Initial JWT Claims Set. Defaults to an empty object. */ +declare const EncryptJWT_base: new (payload?: t.JWTPayload) => t.ProduceJWT; +/** Builds and encrypts Compact JWE-formatted JSON Web Tokens. */ +export declare class EncryptJWT extends EncryptJWT_base { + #private; + /** + * Sets the JWE Protected Header. May only be called once. + * + * @param protectedHeader JWE Protected Header. Must contain an "alg" (JWE Algorithm) and "enc" + * (JWE Encryption Algorithm) properties. + */ + setProtectedHeader(protectedHeader: t.CompactJWEHeaderParameters): this; + /** + * Sets JWE Key Management parameters, such as ECDH-ES "apu" and "apv" or PBES2 "p2c", and adds + * them to the appropriate JOSE Header. Use this instead of the header setters for algorithm + * inputs. May only be called once. + */ + setKeyManagementParameters(parameters: t.JWEKeyManagementHeaderParameters): this; + /** + * Sets the content encryption key. By default, a suitable random key is generated for the JWE + * "enc" (Encryption Algorithm). May only be called once. + * + * @deprecated For testing and vector validation only; allow random generation in production. + */ + setContentEncryptionKey(cek: Uint8Array): this; + /** + * Sets the Initialization Vector for content encryption. By default, a suitable random IV is + * generated for the JWE "enc" (Encryption Algorithm). May only be called once. + * + * @deprecated For testing and vector validation only; allow random generation in production. + */ + setInitializationVector(iv: Uint8Array): this; + /** + * Replicates the "iss" (Issuer) Claim in the JWE Protected Header, exposing it without + * decryption. + */ + replicateIssuerAsHeader(): this; + /** + * Replicates the "sub" (Subject) Claim in the JWE Protected Header, exposing it without + * decryption. + */ + replicateSubjectAsHeader(): this; + /** + * Replicates the "aud" (Audience) Claim in the JWE Protected Header, exposing it without + * decryption. + */ + replicateAudienceAsHeader(): this; + /** + * Encrypts and returns the JWT. + * + * @param key Public key or shared secret to encrypt the JWT with. See + * {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}. + */ + encrypt(key: t.KeyInput, options?: t.EncryptOptions): Promise; +} +export {}; diff --git a/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/types/types.d.ts b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/types/types.d.ts new file mode 100644 index 000000000..9815c018d --- /dev/null +++ b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/types/types.d.ts @@ -0,0 +1,736 @@ +/** Supported JWS "alg" (Algorithm) Header Parameter values. Availability depends on the runtime. */ +export type JWSAlgorithm = + | 'HS256' + | 'HS384' + | 'HS512' + | 'RS256' + | 'RS384' + | 'RS512' + | 'PS256' + | 'PS384' + | 'PS512' + | 'ES256' + | 'ES384' + | 'ES512' + | 'EdDSA' + | 'Ed25519' + | 'ML-DSA-44' + | 'ML-DSA-65' + | 'ML-DSA-87' + | (string & {}) + +/** Supported JWE "alg" (Algorithm) Header Parameter values. Availability depends on the runtime. */ +export type JWEKeyManagementAlgorithm = + | 'dir' + | 'A128KW' + | 'A192KW' + | 'A256KW' + | 'A128GCMKW' + | 'A192GCMKW' + | 'A256GCMKW' + | 'ECDH-ES' + | 'ECDH-ES+A128KW' + | 'ECDH-ES+A192KW' + | 'ECDH-ES+A256KW' + | 'RSA-OAEP' + | 'RSA-OAEP-256' + | 'RSA-OAEP-384' + | 'RSA-OAEP-512' + | 'PBES2-HS256+A128KW' + | 'PBES2-HS384+A192KW' + | 'PBES2-HS512+A256KW' + | (string & {}) + +/** + * Supported JWE "enc" (Encryption Algorithm) Header Parameter values. Availability depends on the + * runtime. + */ +export type JWEContentEncryptionAlgorithm = + | 'A128CBC-HS256' + | 'A192CBC-HS384' + | 'A256CBC-HS512' + | 'A128GCM' + | 'A192GCM' + | 'A256GCM' + | (string & {}) + +/** JWK "kty" (Key Type) Parameter values supported by this module. */ +export type JWKKeyType = 'EC' | 'RSA' | 'OKP' | 'AKP' | 'oct' | (string & {}) + +/** + * Generic JSON Web Key Parameters. + * + * > Note: This is declared as a type alias rather than an interface so that it satisfies the implicit index + * > signature of the `JsonWebKey` types shipped by `@types/node` and `lib.dom`. + */ +export type JWKParameters = { + /** JWK "kty" (Key Type) Parameter */ + kty?: JWKKeyType + /** JWK "alg" (Algorithm) Parameter */ + alg?: JWSAlgorithm | JWEKeyManagementAlgorithm | JWEContentEncryptionAlgorithm + /** Permitted key operations. */ + key_ops?: string[] + /** Whether the key may be exported. */ + ext?: boolean + + /** JWK "use" (Public Key Use) Parameter */ + use?: 'sig' | 'enc' | (string & {}) + /** X.509 certificate chain. */ + x5c?: string[] + /** X.509 certificate SHA-1 thumbprint. */ + x5t?: string + /** X.509 certificate SHA-256 thumbprint. */ + 'x5t#S256'?: string + /** X.509 certificate URL. */ + x5u?: string + + /** JWK "kid" (Key ID) Parameter */ + kid?: string +} + +/** Convenience interface for public OKP JSON Web Keys. */ +export interface JWK_OKP_Public extends JWKParameters { + /** Key pair subtype. */ + crv: string + /** Public key. */ + x: string +} + +/** Convenience interface for private OKP JSON Web Keys. */ +export interface JWK_OKP_Private extends JWK_OKP_Public { + /** Private key. */ + d: string +} + +/** Convenience interface for public AKP JSON Web Keys. */ +export interface JWK_AKP_Public extends JWKParameters { + /** JWK "alg" (Algorithm) Parameter */ + alg: string + + /** AKP JWK "pub" (The Public key) Parameter */ + pub: string +} + +/** Convenience interface for private AKP JSON Web Keys. */ +export interface JWK_AKP_Private extends JWK_AKP_Public { + /** AKP JWK "priv" (The Private Key) Parameter */ + priv: string +} + +/** Convenience interface for public EC JSON Web Keys. */ +export interface JWK_EC_Public extends JWKParameters { + /** Curve. */ + crv: string + /** Public key X coordinate. */ + x: string + /** Public key Y coordinate. */ + y: string +} + +/** Convenience interface for private EC JSON Web Keys. */ +export interface JWK_EC_Private extends JWK_EC_Public { + /** Private key. */ + d: string +} + +/** Convenience interface for public RSA JSON Web Keys. */ +export interface JWK_RSA_Public extends JWKParameters { + /** Public exponent. */ + e: string + /** Modulus. */ + n: string +} + +/** Convenience interface for private RSA JSON Web Keys. */ +export interface JWK_RSA_Private extends JWK_RSA_Public { + /** Private exponent. */ + d: string + /** First factor CRT exponent. */ + dp: string + /** Second factor CRT exponent. */ + dq: string + /** First prime factor. */ + p: string + /** Second prime factor. */ + q: string + /** First CRT coefficient. */ + qi: string +} + +/** Convenience interface for "oct" JSON Web Keys. */ +export interface JWK_oct extends JWKParameters { + /** Symmetric key value. */ + k: string +} + +/** + * JSON Web Key ({@link https://www.rfc-editor.org/info/rfc7517/ JWK}). "RSA", "EC", "OKP", "AKP", + * and "oct" key types are supported. + * + * > Note: This is declared as a type alias rather than an interface so that it satisfies the implicit index + * > signature of the `JsonWebKey` types shipped by `@types/node` and `lib.dom`. It spells out the + * > {@link JWKParameters} members rather than intersecting them so that every JWK member is documented + * > in one place. + */ +export type JWK = { + /** JWK "kty" (Key Type) Parameter */ + kty?: JWKKeyType + /** JWK "alg" (Algorithm) Parameter */ + alg?: JWSAlgorithm | JWEKeyManagementAlgorithm | JWEContentEncryptionAlgorithm + /** Permitted key operations. */ + key_ops?: string[] + /** Whether the key may be exported. */ + ext?: boolean + + /** JWK "use" (Public Key Use) Parameter */ + use?: 'sig' | 'enc' | (string & {}) + /** X.509 certificate chain. */ + x5c?: string[] + /** X.509 certificate SHA-1 thumbprint. */ + x5t?: string + /** X.509 certificate SHA-256 thumbprint. */ + 'x5t#S256'?: string + /** X.509 certificate URL. */ + x5u?: string + + /** JWK "kid" (Key ID) Parameter */ + kid?: string + /** EC curve or OKP key pair subtype. */ + crv?: string + /** Private RSA exponent, EC key, or OKP key. */ + d?: string + /** RSA first factor CRT exponent. */ + dp?: string + /** RSA second factor CRT exponent. */ + dq?: string + /** RSA public exponent. */ + e?: string + /** Symmetric key value. */ + k?: string + /** RSA modulus. */ + n?: string + /** RSA first prime factor. */ + p?: string + /** RSA second prime factor. */ + q?: string + /** RSA first CRT coefficient. */ + qi?: string + /** EC public key X coordinate or OKP public key. */ + x?: string + /** EC public key Y coordinate. */ + y?: string + + /** AKP JWK "pub" (Public Key) Parameter */ + pub?: string + + /** AKP JWK "priv" (Private key) Parameter */ + priv?: string + /** Additional RSA prime factors. */ + oth?: Array<{ + /** Factor CRT exponent. */ + d?: string + /** Prime factor. */ + r?: string + /** Factor CRT coefficient. */ + t?: string + }> +} + +/** Discriminated union of supported JSON Web Key shapes, narrowed by the "kty" (Key Type) Parameter. */ +// Intersect "kty" into each member separately: typedoc omits the parentheses in `X & (A | B)`. +export type AnyJWK = + | (JWK_EC_Private & { kty: 'EC' }) + | (JWK_EC_Public & { kty: 'EC' }) + | (JWK_RSA_Private & { kty: 'RSA' }) + | (JWK_RSA_Public & { kty: 'RSA' }) + | (JWK_OKP_Private & { kty: 'OKP' }) + | (JWK_OKP_Public & { kty: 'OKP' }) + | (JWK_AKP_Private & { kty: 'AKP' }) + | (JWK_AKP_Public & { kty: 'AKP' }) + | (JWK_oct & { kty: 'oct' }) + +/** Key or secret input accepted by all sign, verify, encrypt, and decrypt operations. */ +export type KeyInput = CryptoKey | KeyObject | JWK | Uint8Array + +/** Dynamic key resolver for consuming operations. */ +export interface GetKeyFunction { + /** + * Resolves a key for an unverified token. Throw if no suitable key can be resolved. + * + * @param token The consumed JWE or JWS token; none of its components have been verified. + */ + (protectedHeader: IProtectedHeader, token: IToken): Promise | KeyTypes +} + +/** Flattened JWS verification input. */ +export interface FlattenedJWSInput { + /** JWS Unprotected Header as a JSON object. Not integrity protected; omit when empty. */ + header?: JWSHeaderParameters + + /** Base64url-encoded payload; with `b64: false`, supply an unencoded string or Uint8Array. */ + payload: string | Uint8Array + + /** Base64url-encoded UTF-8 JWS Protected Header. Integrity protected; omit when empty. */ + protected?: string + + /** Base64url-encoded signature or MAC. */ + signature: string +} + +/** General JWS verification input. */ +export interface GeneralJWSInput { + /** Base64url-encoded payload; with `b64: false`, supply an unencoded string or Uint8Array. */ + payload: string | Uint8Array + + /** + * The "signatures" member value MUST be an array of JSON objects. Each object represents a + * signature or MAC over the JWS Payload and the JWS Protected Header. + */ + signatures: Omit[] +} + +/** + * Flattened JWS JSON Serialization token. The payload is an empty string when the + * {@link https://www.rfc-editor.org/info/rfc7797/ unencoded payload option} is used. + */ +export interface FlattenedJWS extends Partial { + payload: string + signature: string +} + +/** + * General JWS JSON Serialization token. The payload is an empty string when the + * {@link https://www.rfc-editor.org/info/rfc7797/ unencoded payload option} is used. + */ +export interface GeneralJWS { + payload: string + signatures: Omit[] +} + +/** Header Parameters common to JWE and JWS. */ +export interface JoseHeaderParameters { + /** "kid" (Key ID) Header Parameter */ + kid?: string + + /** X.509 certificate SHA-1 thumbprint. */ + x5t?: string + + /** X.509 certificate chain. */ + x5c?: string[] + + /** X.509 certificate URL. */ + x5u?: string + + /** JWK Set URL. */ + jku?: string + + /** Public JWK only; private and symmetric key parameters are not permitted. */ + jwk?: Omit + + /** "typ" (Type) Header Parameter */ + typ?: string + + /** Content type. */ + cty?: string +} + +/** Recognized JWS Header Parameters; additional members may also be present. */ +export interface JWSHeaderParameters extends JoseHeaderParameters { + /** JWS "alg" (Algorithm) Header Parameter */ + alg?: JWSAlgorithm + + /** + * Controls payload encoding and the JWS signing input as defined by + * {@link https://www.rfc-editor.org/info/rfc7797/ RFC7797}. Set to `false` and list `b64` in + * `crit` to use an unencoded payload. + */ + b64?: boolean + + /** Extension parameters that must be recognized. */ + crit?: string[] + + /** Any other JWS Header member. */ + [propName: string]: unknown +} + +/** Recognized JWE Key Management-related Header Parameters. */ +export interface JWEKeyManagementHeaderParameters { + /** ECDH-ES Agreement PartyUInfo bytes, used in ConcatKDF and added to the JOSE header. */ + apu?: Uint8Array + + /** ECDH-ES Agreement PartyVInfo bytes, used in ConcatKDF and added to the JOSE header. */ + apv?: Uint8Array + + /** PBES2 PBKDF2 iteration count, added to the JOSE header. */ + p2c?: number + + /** @deprecated For testing and vector validation only. */ + p2s?: Uint8Array + /** @deprecated For testing and vector validation only. */ + iv?: Uint8Array + /** @deprecated For testing and vector validation only. */ + epk?: CryptoKey | KeyObject +} + +/** Flattened JWE JSON Serialization token. */ +export interface FlattenedJWE { + /** + * Base64url-encoded additional authenticated data; integrity protected but not encrypted. Omit + * when empty. + */ + aad?: string + + /** Base64url-encoded ciphertext. */ + ciphertext: string + + /** Base64url-encoded encrypted key. Omit when empty. */ + encrypted_key?: string + + /** + * JWE Per-Recipient Unprotected Header as a JSON object. Not integrity protected; omit when + * empty. + */ + header?: JWEHeaderParameters + + /** Base64url-encoded initialization vector. Omit when empty. */ + iv?: string + + /** Base64url-encoded UTF-8 JWE Protected Header. Integrity protected; omit when empty. */ + protected?: string + + /** Base64url-encoded authentication tag. Omit when empty. */ + tag?: string + + /** JWE Shared Unprotected Header as a JSON object. Not integrity protected; omit when empty. */ + unprotected?: JWEHeaderParameters +} + +/** General JWE JSON Serialization token. */ +export interface GeneralJWE extends Omit { + recipients: Pick[] +} + +/** Recognized JWE Header Parameters; additional members may also be present. */ +export interface JWEHeaderParameters extends JoseHeaderParameters { + /** JWE "alg" (Algorithm) Header Parameter */ + alg?: JWEKeyManagementAlgorithm + + /** JWE "enc" (Encryption Algorithm) Header Parameter */ + enc?: JWEContentEncryptionAlgorithm + + /** Extension parameters that must be recognized. */ + crit?: string[] + + /** + * JWE compression algorithm. Only `"DEF"` (DEFLATE) is supported, requiring the runtime's + * `CompressionStream` / `DecompressionStream` APIs. + */ + zip?: 'DEF' | (string & {}) + + /** Any other JWE Header member. */ + [propName: string]: unknown +} + +/** Shared "crit" option for signing, verification, encryption, and decryption. */ +export interface CritOption { + /** + * Recognized "crit" (Critical) Header Parameter names. Set each value to `true` to require + * integrity protection, or `false` when protection is optional. The JWS `b64` extension is always + * recognized and processed. + * + * > Warning: Other extensions are only checked for syntax and optional integrity protection. Their presence + * > is not required by this option. You must check their presence and process them according to the + * > profile's validation steps after the operation succeeds. + */ + crit?: { + [propName: string]: boolean + } +} + +/** JWE Decryption options. */ +export interface DecryptOptions extends CritOption { + /** + * Accepted JWE "alg" (Algorithm) Header Parameter values. Defaults to all algorithms applicable + * to the key or secret except PBES2, which must be explicitly allowed. + */ + keyManagementAlgorithms?: JWEKeyManagementAlgorithm[] + + /** + * Accepted JWE "enc" (Encryption Algorithm) Header Parameter values. Defaults to all algorithms + * applicable to the key or secret. + */ + contentEncryptionAlgorithms?: JWEContentEncryptionAlgorithm[] + + /** + * Maximum "p2c" (PBES2 Count) Header Parameter value, limiting PBKDF2 iterations and their + * computational expense. Defaults to 10000; must be a positive safe integer or `Infinity` to + * disable the limit. + */ + maxPBES2Count?: number + + /** + * Maximum decompressed plaintext size in bytes. Defaults to 250000; `0` rejects compressed JWEs, + * and `Infinity` disables the limit. Other values must be positive safe integers. + */ + maxDecompressedLength?: number +} + +/** JWE Encryption options. */ +export interface EncryptOptions extends CritOption {} + +/** JWT Claims Set verification options. */ +export interface JWTClaimVerificationOptions { + /** Expected JWT "aud" (Audience) Claim value(s). Requires the claim to be present. */ + audience?: string | string[] + + /** + * Clock skew tolerance in seconds or a duration string (e.g. "5 seconds"). Applies to the "nbf" + * (Not Before) and "exp" (Expiration Time) claims, and to "iat" (Issued At) when + * {@link maxTokenAge} is set. + */ + clockTolerance?: string | number + + /** Expected JWT "iss" (Issuer) Claim value(s). Requires the claim to be present. */ + issuer?: string | string[] + + /** + * Maximum time since the JWT "iat" (Issued At) Claim, in seconds or a duration string (e.g. "2 + * hours"). Requires the claim to be present. + */ + maxTokenAge?: string | number + + /** Expected JWT "sub" (Subject) Claim value. Requires the claim to be present. */ + subject?: string + + /** Expected JWT "typ" (Type) Header Parameter value. Requires the parameter to be present. */ + typ?: string + + /** Date for NumericDate comparisons. Defaults to `new Date()`. */ + currentDate?: Date + + /** + * Additional claim names required in the JWT Claims Set. The {@link issuer}, {@link audience}, + * {@link subject}, and {@link maxTokenAge} options independently require "iss", "aud", "sub", and + * "iat", respectively. + */ + requiredClaims?: string[] +} + +/** JWS Verification options. */ +export interface VerifyOptions extends CritOption { + /** + * Accepted JWS "alg" (Algorithm) Header Parameter values. Defaults to all algorithms applicable + * to the key or secret. Unsecured JWTs (`alg: "none"`) are never accepted. + */ + algorithms?: JWSAlgorithm[] +} + +/** JWS Signing options. */ +export interface SignOptions extends CritOption {} + +/** Recognized JWT Claims Set members; additional members may also be present. */ +export interface JWTPayload { + /** JWT Issuer */ + iss?: string + + /** JWT Subject */ + sub?: string + + /** JWT Audience */ + aud?: string | string[] + + /** JWT ID */ + jti?: string + + /** Not valid before this Unix timestamp in seconds. */ + nbf?: number + + /** Expiration Unix timestamp in seconds. */ + exp?: number + + /** Issued-at Unix timestamp in seconds. */ + iat?: number + + /** Any other JWT Claim Set member. */ + [propName: string]: unknown +} + +/** Flattened JWE JSON Serialization decryption result. */ +export interface FlattenedDecryptResult { + /** JWE Additional Authenticated Data, integrity protected but not encrypted. */ + additionalAuthenticatedData?: Uint8Array + + /** Plaintext. */ + plaintext: Uint8Array + + /** JWE Protected Header. */ + protectedHeader?: JWEHeaderParameters + + /** JWE Shared Unprotected Header. Not integrity protected. */ + sharedUnprotectedHeader?: JWEHeaderParameters + + /** JWE Per-Recipient Unprotected Header. Not integrity protected. */ + unprotectedHeader?: JWEHeaderParameters +} + +/** General JWE JSON Serialization decryption result. */ +export interface GeneralDecryptResult extends FlattenedDecryptResult {} + +/** Compact JWE decryption result. */ +export interface CompactDecryptResult { + /** Plaintext. */ + plaintext: Uint8Array + + /** JWE Protected Header. */ + protectedHeader: CompactJWEHeaderParameters +} + +/** Flattened JWS JSON Serialization verification result. */ +export interface FlattenedVerifyResult { + /** JWS Payload. */ + payload: Uint8Array + + /** JWS Protected Header. */ + protectedHeader?: JWSHeaderParameters + + /** JWS Unprotected Header. Not integrity protected. */ + unprotectedHeader?: JWSHeaderParameters +} + +/** General JWS JSON Serialization verification result. */ +export interface GeneralVerifyResult extends FlattenedVerifyResult {} + +/** Compact JWS verification result. */ +export interface CompactVerifyResult { + /** JWS Payload. */ + payload: Uint8Array + + /** JWS Protected Header. */ + protectedHeader: CompactJWSHeaderParameters +} + +/** Signed JSON Web Token (JWT) verification result. */ +export interface JWTVerifyResult { + /** JWT Claims Set. */ + payload: PayloadType & + JWTPayload & + ([PayloadType] extends [object] ? unknown : unknown extends PayloadType ? unknown : never) + + /** JWS Protected Header. */ + protectedHeader: JWTHeaderParameters +} + +/** Encrypted JSON Web Token (JWT) decryption result. */ +export interface JWTDecryptResult { + /** JWT Claims Set. */ + payload: PayloadType & + JWTPayload & + ([PayloadType] extends [object] ? unknown : unknown extends PayloadType ? unknown : never) + + /** JWE Protected Header. */ + protectedHeader: CompactJWEHeaderParameters +} + +/** Key resolver result metadata. */ +export interface ResolvedKey { + /** The resolved key, present only when a key resolver is used. */ + key: KeyType +} + +/** Recognized Compact JWS Header Parameters; additional members may also be present. */ +export interface CompactJWSHeaderParameters extends JWSHeaderParameters { + alg: JWSAlgorithm +} + +/** Recognized signed JWT Header Parameters; additional members may also be present. */ +export interface JWTHeaderParameters extends CompactJWSHeaderParameters { + b64?: boolean +} + +/** Recognized Compact JWE Header Parameters; additional members may also be present. */ +export interface CompactJWEHeaderParameters extends JWEHeaderParameters { + alg: JWEKeyManagementAlgorithm + enc: JWEContentEncryptionAlgorithm +} + +/** JSON Web Key Set. */ +export interface JSONWebKeySet { + keys: JWK[] +} + +/** Node.js {@link !KeyObject} representation accepted as key input. */ +export interface KeyObject { + type: string +} + +/** The runtime's Web Crypto {@link !CryptoKey} representation accepted as key input. */ +export type CryptoKey = typeof globalThis extends { + crypto: { subtle: { generateKey(...args: any[]): Promise } } +} + ? Extract + : CryptoKeyStructuralFallback + +/** Structural fallback used when the host {@link !CryptoKey} type cannot be inferred. */ +export interface CryptoKeyStructuralFallback { + readonly algorithm: { name: string } + readonly extractable: boolean + readonly type: string + readonly usages: string[] +} + +/** Shared fluent API for JWT-producing classes. */ +export interface ProduceJWT { + /** + * Set the "iss" (Issuer) Claim. + * + * @param issuer "Issuer" Claim value to set on the JWT Claims Set. + */ + setIssuer(issuer: string): this + + /** + * Set the "sub" (Subject) Claim. + * + * @param subject "sub" (Subject) Claim value to set on the JWT Claims Set. + */ + setSubject(subject: string): this + + /** + * Set the "aud" (Audience) Claim. + * + * @param audience "aud" (Audience) Claim value to set on the JWT Claims Set. + */ + setAudience(audience: string | string[]): this + + /** + * Set the "jti" (JWT ID) Claim. + * + * @param jwtId "jti" (JWT ID) Claim value to set on the JWT Claims Set. + */ + setJti(jwtId: string): this + + /** + * Set the "nbf" (Not Before) Claim. Numbers are Unix timestamps in seconds; Dates are converted + * to seconds. Strings are relative to now, using seconds, minutes, hours, days, weeks, or years + * (365.25 days; no months). Prefix `-` or suffix `ago` subtracts the duration. + * + * @param input "nbf" (Not Before) Claim value as a timestamp, Date, or relative duration. + */ + setNotBefore(input: number | string | Date): this + + /** + * Set the "exp" (Expiration Time) Claim. Accepts a Unix timestamp in seconds, a Date, or a + * duration relative to now using the same formats as {@link setNotBefore}. + * + * @param input "exp" (Expiration Time) Claim value as a timestamp, Date, or relative duration. + */ + setExpirationTime(input: number | string | Date): this + + /** + * Set the "iat" (Issued At) Claim. Defaults to the current Unix timestamp in seconds. Accepts a + * Unix timestamp in seconds, a Date, or a duration relative to now using the same formats as + * {@link setNotBefore}. + * + * @param input "iat" (Issued At) Claim value as a timestamp, Date, or relative duration. + */ + setIssuedAt(input?: number | string | Date): this +} diff --git a/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/types/util/errors.d.ts b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/types/util/errors.d.ts new file mode 100644 index 000000000..930a29b9f --- /dev/null +++ b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/types/util/errors.d.ts @@ -0,0 +1,182 @@ +import type * as t from '../types.d.ts'; +/** Stable error codes used by this module. */ +export type JOSEErrorCode = 'ERR_JOSE_ALG_NOT_ALLOWED' | 'ERR_JOSE_GENERIC' | 'ERR_JOSE_NOT_SUPPORTED' | 'ERR_JWE_DECRYPTION_FAILED' | 'ERR_JWE_INVALID' | 'ERR_JWK_INVALID' | 'ERR_JWKS_INVALID' | 'ERR_JWKS_MULTIPLE_MATCHING_KEYS' | 'ERR_JWKS_NO_MATCHING_KEY' | 'ERR_JWKS_TIMEOUT' | 'ERR_JWS_INVALID' | 'ERR_JWS_SIGNATURE_VERIFICATION_FAILED' | 'ERR_JWT_CLAIM_VALIDATION_FAILED' | 'ERR_JWT_EXPIRED' | 'ERR_JWT_INVALID'; +/** Shared details of JWT claim or header validation failures. */ +export interface JWTClaimValidationFailure { + /** Claim or header that failed validation. */ + claim: string; + /** Reason code for the validation failure. */ + reason: JWTClaimValidationReason; + /** The parsed JWT Claims Set; validation of other claims may be incomplete. */ + payload: t.JWTPayload; +} +/** Reason codes produced by JWT Claims Set validation. */ +export type JWTClaimValidationReason = 'check_failed' | 'invalid' | 'mismatch' | 'missing' | 'unspecified' | (string & {}); +/** Base class for JOSE errors. */ +export declare class JOSEError extends Error { + /** Stable code identifying the error class. */ + static code: JOSEErrorCode | (string & {}); + /** Stable code identifying the error class. Use {@link AnyJOSEError} to narrow subclasses by code. */ + code: JOSEErrorCode | (string & {}); + constructor(message?: string, options?: { + cause?: unknown; + }); +} +/** + * Thrown when JWT claim or header validation fails. Expiration is reported separately as + * {@link JWTExpired}. + */ +export declare class JWTClaimValidationFailed extends JOSEError implements JWTClaimValidationFailure { + static code: JOSEErrorCode | (string & {}); + code: JOSEErrorCode | (string & {}); + /** The {@link JWTClaimValidationFailure} details carried by this error. */ + cause: JWTClaimValidationFailure; + /** Claim or header that failed validation. */ + claim: string; + /** Reason code for the validation failure. */ + reason: JWTClaimValidationReason; + /** + * The parsed JWT Claims Set; validation of other claims may be incomplete. With + * {@link jwt/verify.jwtVerify jwtVerify} and {@link jwt/decrypt.jwtDecrypt jwtDecrypt}, token + * authentication precedes claim validation. {@link jwt/unsecured.UnsecuredJWT.decode} does not + * authenticate tokens. + */ + payload: t.JWTPayload; + constructor(message: string, payload: t.JWTPayload, claim?: string, reason?: JWTClaimValidationReason); +} +/** Thrown when a JWT has expired or exceeds the configured maximum token age. */ +export declare class JWTExpired extends JOSEError implements JWTClaimValidationFailure { + static code: JOSEErrorCode | (string & {}); + code: JOSEErrorCode | (string & {}); + /** The {@link JWTClaimValidationFailure} details carried by this error. */ + cause: JWTClaimValidationFailure; + /** Claim or header that failed validation. */ + claim: string; + /** Reason code for the validation failure. */ + reason: JWTClaimValidationReason; + /** + * The parsed JWT Claims Set; validation of other claims may be incomplete. With + * {@link jwt/verify.jwtVerify jwtVerify} and {@link jwt/decrypt.jwtDecrypt jwtDecrypt}, token + * authentication precedes claim validation. {@link jwt/unsecured.UnsecuredJWT.decode} does not + * authenticate tokens. + */ + payload: t.JWTPayload; + constructor(message: string, payload: t.JWTPayload, claim?: string, reason?: JWTClaimValidationReason); +} +/** Thrown when an algorithm is disallowed by configuration. */ +export declare class JOSEAlgNotAllowed extends JOSEError { + static code: JOSEErrorCode | (string & {}); + code: JOSEErrorCode | (string & {}); +} +/** Thrown when a feature or algorithm is unsupported. */ +export declare class JOSENotSupported extends JOSEError { + static code: JOSEErrorCode | (string & {}); + code: JOSEErrorCode | (string & {}); +} +/** Thrown when JWE ciphertext decryption or authentication fails. */ +export declare class JWEDecryptionFailed extends JOSEError { + static code: JOSEErrorCode | (string & {}); + code: JOSEErrorCode | (string & {}); + constructor(message?: string, options?: { + cause?: unknown; + }); +} +/** Thrown when a JWE is invalid. */ +export declare class JWEInvalid extends JOSEError { + static code: JOSEErrorCode | (string & {}); + code: JOSEErrorCode | (string & {}); +} +/** Thrown when a JWS is invalid. */ +export declare class JWSInvalid extends JOSEError { + static code: JOSEErrorCode | (string & {}); + code: JOSEErrorCode | (string & {}); +} +/** Thrown when a JWT is invalid. */ +export declare class JWTInvalid extends JOSEError { + static code: JOSEErrorCode | (string & {}); + code: JOSEErrorCode | (string & {}); +} +/** Thrown when a JWK is invalid. */ +export declare class JWKInvalid extends JOSEError { + static code: JOSEErrorCode | (string & {}); + code: JOSEErrorCode | (string & {}); +} +/** Thrown when a JWKS is invalid. */ +export declare class JWKSInvalid extends JOSEError { + static code: JOSEErrorCode | (string & {}); + code: JOSEErrorCode | (string & {}); +} +/** Thrown when no keys match in a JWKS. */ +export declare class JWKSNoMatchingKey extends JOSEError { + static code: JOSEErrorCode | (string & {}); + code: JOSEErrorCode | (string & {}); + constructor(message?: string, options?: { + cause?: unknown; + }); +} +/** Thrown when multiple keys match in a JWKS. */ +export declare class JWKSMultipleMatchingKeys extends JOSEError { + /** + * Yields public keys matching the JWS Header so verification can be attempted with each. See the + * {@link jwks/remote.createRemoteJWKSet createRemoteJWKSet} and + * {@link jwks/local.createLocalJWKSet createLocalJWKSet} examples. Empty on manually constructed + * errors. + */ + [Symbol.asyncIterator]: () => AsyncIterableIterator; + static code: JOSEErrorCode | (string & {}); + code: JOSEErrorCode | (string & {}); + constructor(message?: string, options?: { + cause?: unknown; + }); +} +/** Thrown when fetching a remote JWKS times out. */ +export declare class JWKSTimeout extends JOSEError { + static code: JOSEErrorCode | (string & {}); + code: JOSEErrorCode | (string & {}); + constructor(message?: string, options?: { + cause?: unknown; + }); +} +/** Thrown when JWS signature verification fails. */ +export declare class JWSSignatureVerificationFailed extends JOSEError { + static code: JOSEErrorCode | (string & {}); + code: JOSEErrorCode | (string & {}); + constructor(message?: string, options?: { + cause?: unknown; + }); +} +/** Errors thrown during JWT Claims Set validation. */ +export type JWTClaimValidationError = JWTClaimValidationFailed | JWTExpired; +/** + * Discriminated union of specific {@link JOSEError} subclasses, narrowed by `code`. Excludes base + * {@link JOSEError} instances; use `instanceof JOSEError` to catch all module errors. + */ +export type AnyJOSEError = (JOSEAlgNotAllowed & { + code: 'ERR_JOSE_ALG_NOT_ALLOWED'; +}) | (JOSENotSupported & { + code: 'ERR_JOSE_NOT_SUPPORTED'; +}) | (JWEDecryptionFailed & { + code: 'ERR_JWE_DECRYPTION_FAILED'; +}) | (JWEInvalid & { + code: 'ERR_JWE_INVALID'; +}) | (JWKInvalid & { + code: 'ERR_JWK_INVALID'; +}) | (JWKSInvalid & { + code: 'ERR_JWKS_INVALID'; +}) | (JWKSMultipleMatchingKeys & { + code: 'ERR_JWKS_MULTIPLE_MATCHING_KEYS'; +}) | (JWKSNoMatchingKey & { + code: 'ERR_JWKS_NO_MATCHING_KEY'; +}) | (JWKSTimeout & { + code: 'ERR_JWKS_TIMEOUT'; +}) | (JWSInvalid & { + code: 'ERR_JWS_INVALID'; +}) | (JWSSignatureVerificationFailed & { + code: 'ERR_JWS_SIGNATURE_VERIFICATION_FAILED'; +}) | (JWTClaimValidationFailed & { + code: 'ERR_JWT_CLAIM_VALIDATION_FAILED'; +}) | (JWTExpired & { + code: 'ERR_JWT_EXPIRED'; +}) | (JWTInvalid & { + code: 'ERR_JWT_INVALID'; +}); diff --git a/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/jwt/decrypt.js b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/jwt/decrypt.js new file mode 100644 index 000000000..cfbe4730c --- /dev/null +++ b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/jwt/decrypt.js @@ -0,0 +1,13 @@ +import { prepareDecrypt, decryptCompact } from "../lib/jwe_decrypt.js"; +import { validateClaimsSet } from "../lib/jwt_claims_set.js"; +import { JWTClaimValidationFailed } from "../util/errors.js"; +async function jwtDecrypt(jwt, key, options) { + const { plaintext, ...result } = await decryptCompact(jwt, prepareDecrypt(options), key), { protectedHeader } = result, payload = validateClaimsSet(protectedHeader, plaintext, options); + for (const claim of ["iss", "sub", "aud"]) + if (protectedHeader[claim] !== void 0 && (claim === "aud" ? JSON.stringify(protectedHeader.aud) !== JSON.stringify(payload.aud) : protectedHeader[claim] !== payload[claim])) + throw new JWTClaimValidationFailed(`replicated "${claim}" claim header parameter mismatch`, payload, claim, "mismatch"); + return { payload, ...result }; +} +export { + jwtDecrypt +}; diff --git a/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/jwt/encrypt.js b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/jwt/encrypt.js new file mode 100644 index 000000000..c26908857 --- /dev/null +++ b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/jwt/encrypt.js @@ -0,0 +1,45 @@ +import { compactJWE, createJWE } from "../lib/jwe_encrypt.js"; +import { JWTClaimsBuilder, jwtClaim, jwtData } from "../lib/jwt_claims_set.js"; +import { assertNotSet } from "../lib/validate.js"; +const EncryptJWT_base = JWTClaimsBuilder; +class EncryptJWT extends EncryptJWT_base { + #input = [void 0]; + #replicateIssuerAsHeader; + #replicateSubjectAsHeader; + #replicateAudienceAsHeader; + setProtectedHeader(protectedHeader) { + return assertNotSet(this.#input[1], "setProtectedHeader"), this.#input[1] = protectedHeader, this; + } + setKeyManagementParameters(parameters) { + return assertNotSet(this.#input[7], "setKeyManagementParameters"), this.#input[7] = parameters, this; + } + setContentEncryptionKey(cek) { + return assertNotSet(this.#input[5], "setContentEncryptionKey"), this.#input[5] = cek, this; + } + setInitializationVector(iv) { + return assertNotSet(this.#input[6], "setInitializationVector"), this.#input[6] = iv, this; + } + replicateIssuerAsHeader() { + return this.#replicateIssuerAsHeader = !0, this; + } + replicateSubjectAsHeader() { + return this.#replicateSubjectAsHeader = !0, this; + } + replicateAudienceAsHeader() { + return this.#replicateAudienceAsHeader = !0, this; + } + async encrypt(key, options) { + const plaintext = jwtData(this); + this.#input[1] && (this.#replicateIssuerAsHeader || this.#replicateSubjectAsHeader || this.#replicateAudienceAsHeader) && (this.#input[1] = { + ...this.#input[1], + iss: this.#replicateIssuerAsHeader ? jwtClaim(this, "iss") : void 0, + sub: this.#replicateSubjectAsHeader ? jwtClaim(this, "sub") : void 0, + aud: this.#replicateAudienceAsHeader ? jwtClaim(this, "aud") : void 0 + }); + const input = [...this.#input]; + return input[0] = plaintext, compactJWE(await createJWE(input, key, options)); + } +} +export { + EncryptJWT +}; diff --git a/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/buffer_utils.js b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/buffer_utils.js new file mode 100644 index 000000000..b3cad85a9 --- /dev/null +++ b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/buffer_utils.js @@ -0,0 +1,75 @@ +const encoder = new TextEncoder(), decoder = new TextDecoder(), strictDecoder = new TextDecoder("utf-8", { fatal: !0 }), MAX_INT32 = 2 ** 32; +function concat(...buffers) { + const size = buffers.reduce((acc, { length }) => acc + length, 0), buf = new Uint8Array(size); + let i = 0; + for (const buffer of buffers) + buf.set(buffer, i), i += buffer.length; + return buf; +} +function writeUInt32BE(buf, value, offset) { + if (value < 0 || value >= MAX_INT32) + throw new RangeError(`value must be >= 0 and <= ${MAX_INT32 - 1}. Received ${value}`); + buf.set([value >>> 24, value >>> 16, value >>> 8, value & 255], offset); +} +function uint64be(value) { + const high = Math.floor(value / MAX_INT32), low = value % MAX_INT32, buf = new Uint8Array(8); + return writeUInt32BE(buf, high, 0), writeUInt32BE(buf, low, 4), buf; +} +function uint32be(value) { + const buf = new Uint8Array(4); + return writeUInt32BE(buf, value), buf; +} +const NON_ASCII = /[^\x00-\x7f]/; +function encode(string) { + if (typeof string == "string" && string.length >= 128) { + if (NON_ASCII.test(string)) + throw new TypeError("non-ASCII string encountered in encode()"); + return encoder.encode(string); + } + const bytes = new Uint8Array(string.length); + for (let i = 0; i < string.length; i++) { + const code = string.charCodeAt(i); + if (code > 127) + throw new TypeError("non-ASCII string encountered in encode()"); + bytes[i] = code; + } + return bytes; +} +function encodeBase64(input, url = !1) { + if (Uint8Array.prototype.toBase64) + return input.toBase64({ alphabet: url ? "base64url" : "base64", omitPadding: url }); + const CHUNK_SIZE = 32768, arr = []; + for (let i = 0; i < input.length; i += CHUNK_SIZE) + arr.push(String.fromCharCode.apply(null, input.subarray(i, i + CHUNK_SIZE))); + const encoded = btoa(arr.join("")); + return url ? encoded.replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_") : encoded; +} +function decodeBase64(encoded, url = !1) { + if (Uint8Array.fromBase64) + return Uint8Array.fromBase64(encoded, { alphabet: url ? "base64url" : "base64" }); + if (url) { + if (encoded.includes("+") || encoded.includes("/")) + throw new TypeError("Invalid base64url"); + encoded = encoded.replace(/-/g, "+").replace(/_/g, "/"); + } + const binary = atob(encoded), bytes = new Uint8Array(binary.length); + for (let i = 0; i < binary.length; i++) + bytes[i] = binary.charCodeAt(i); + return bytes; +} +async function digest(algorithm, data) { + const subtleDigest = `SHA-${algorithm.slice(-3)}`; + return new Uint8Array(await crypto.subtle.digest(subtleDigest, data)); +} +export { + concat, + decodeBase64, + decoder, + digest, + encode, + encodeBase64, + encoder, + strictDecoder, + uint32be, + uint64be +}; diff --git a/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/content_encryption.js b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/content_encryption.js new file mode 100644 index 000000000..1ea355e91 --- /dev/null +++ b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/content_encryption.js @@ -0,0 +1,90 @@ +import { concat, uint64be } from "./buffer_utils.js"; +import { rawKey, invalidKeyInput, isCryptoKey } from "./key.js"; +import { JWEDecryptionFailed, JWEInvalid } from "../util/errors.js"; +const generateCek = (enc) => crypto.getRandomValues(new Uint8Array(enc.cekBits >> 3)); +function checkCekLength(cek, expected) { + const actual = cek.byteLength << 3; + if (actual !== expected) + throw new JWEInvalid(`Invalid Content Encryption Key length. Expected ${expected} bits, got ${actual} bits`); +} +const generateIv = (enc) => crypto.getRandomValues(new Uint8Array(enc.ivBits >> 3)); +function checkIvLength(enc, iv) { + if (iv.length << 3 !== enc.ivBits) + throw new JWEInvalid("Invalid Initialization Vector length"); +} +async function cbcKeySetup(enc, cek, usage) { + if (!(cek instanceof Uint8Array)) + throw new TypeError(invalidKeyInput(cek, "Uint8Array")); + const keySize = enc.cekBits >> 1, encKey = await crypto.subtle.importKey("raw", cek.subarray(keySize >> 3), "AES-CBC", !1, [usage]), macKey = await crypto.subtle.importKey("raw", cek.subarray(0, keySize >> 3), { + hash: `SHA-${keySize << 1}`, + name: "HMAC" + }, !1, ["sign"]); + return [encKey, macKey, keySize]; +} +async function cbcHmacTag(macKey, macData, keySize) { + return new Uint8Array((await crypto.subtle.sign("HMAC", macKey, macData)).slice(0, keySize >> 3)); +} +async function cbcEncrypt(enc, plaintext, cek, iv, aad) { + const [encKey, macKey, keySize] = await cbcKeySetup(enc, cek, "encrypt"), ciphertext = new Uint8Array(await crypto.subtle.encrypt({ + iv, + name: "AES-CBC" + }, encKey, plaintext)), macData = concat(aad, iv, ciphertext, uint64be(aad.length * 8)), tag = await cbcHmacTag(macKey, macData, keySize); + return { ciphertext, tag, iv }; +} +async function timingSafeEqual(a, b) { + const algorithm = { name: "HMAC", hash: "SHA-256" }, key = await crypto.subtle.generateKey(algorithm, !1, ["sign", "verify"]), aHmac = await crypto.subtle.sign(algorithm, key, a); + return crypto.subtle.verify(algorithm, key, aHmac, b); +} +async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) { + const [encKey, macKey, keySize] = await cbcKeySetup(enc, cek, "decrypt"), macData = concat(aad, iv, ciphertext, uint64be(aad.length * 8)), expectedTag = await cbcHmacTag(macKey, macData, keySize); + try { + if (await timingSafeEqual(tag, expectedTag)) + return new Uint8Array(await crypto.subtle.decrypt({ iv, name: "AES-CBC" }, encKey, ciphertext)); + } catch { + } + throw new JWEDecryptionFailed(); +} +async function encrypt(enc, plaintext, cek, iv, aad) { + if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) + throw new TypeError(invalidKeyInput(cek, "CryptoKey", "KeyObject", "Uint8Array", "JSON Web Key")); + if (iv ? checkIvLength(enc, iv) : iv = generateIv(enc), cek instanceof Uint8Array && checkCekLength(cek, enc.cekBits), enc.cbc) + return cbcEncrypt(enc, plaintext, cek, iv, aad); + const encKey = await rawKey(cek, enc.subtle, "encrypt"), encrypted = new Uint8Array(await crypto.subtle.encrypt({ + additionalData: aad, + iv, + name: "AES-GCM", + tagLength: 128 + }, encKey, plaintext)); + return { ciphertext: encrypted.subarray(0, -16), tag: encrypted.subarray(-16), iv }; +} +async function decrypt(enc, cek, ciphertext, iv, tag, aad) { + if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) + throw new TypeError(invalidKeyInput(cek, "CryptoKey", "KeyObject", "Uint8Array", "JSON Web Key")); + if (!iv) + throw new JWEInvalid("JWE Initialization Vector missing"); + if (!tag) + throw new JWEInvalid("JWE Authentication Tag missing"); + if (!enc.cbc && tag.length !== 16) + throw new JWEInvalid("Invalid Authentication Tag length"); + if (checkIvLength(enc, iv), cek instanceof Uint8Array && checkCekLength(cek, enc.cekBits), enc.cbc) + return cbcDecrypt(enc, cek, ciphertext, iv, tag, aad); + const encKey = await rawKey(cek, enc.subtle, "decrypt"); + try { + return new Uint8Array(await crypto.subtle.decrypt({ + additionalData: aad, + iv, + name: "AES-GCM", + tagLength: 128 + }, encKey, concat(ciphertext, tag))); + } catch { + throw new JWEDecryptionFailed(); + } +} +export { + checkCekLength, + checkIvLength, + decrypt, + encrypt, + generateCek, + generateIv +}; diff --git a/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/deflate.js b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/deflate.js new file mode 100644 index 000000000..27ffba278 --- /dev/null +++ b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/deflate.js @@ -0,0 +1,40 @@ +import { JOSENotSupported, JWEInvalid } from "../util/errors.js"; +import { concat } from "./buffer_utils.js"; +function validateZip(joseHeader, protectedHeader) { + if (joseHeader.zip !== void 0 && joseHeader.zip !== "DEF") + throw new JOSENotSupported('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value.'); + if (joseHeader.zip !== void 0 && !protectedHeader?.zip) + throw new JWEInvalid('JWE "zip" (Compression Algorithm) Header Parameter MUST be in a protected header.'); +} +function supported(name) { + if (typeof globalThis[name] > "u") + throw new JOSENotSupported(`JWE "zip" (Compression Algorithm) Header Parameter requires the ${name} API.`); +} +async function transform(stream, input, maxLength = 1 / 0) { + const writer = stream.writable.getWriter(); + writer.write(input).catch(() => { + }), writer.close().catch(() => { + }); + const chunks = []; + let length = 0; + const reader = stream.readable.getReader(); + for (; ; ) { + const { value, done } = await reader.read(); + if (done) + break; + if (chunks.push(value), length += value.byteLength, maxLength !== 1 / 0 && length > maxLength) + throw new JWEInvalid("Decompressed plaintext exceeded the configured limit"); + } + return concat(...chunks); +} +async function compress(input) { + return supported("CompressionStream"), transform(new CompressionStream("deflate-raw"), input); +} +async function decompress(input, maxLength) { + return supported("DecompressionStream"), transform(new DecompressionStream("deflate-raw"), input, maxLength); +} +export { + compress, + decompress, + validateZip +}; diff --git a/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/jwe_algorithms.js b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/jwe_algorithms.js new file mode 100644 index 000000000..a87af4eb5 --- /dev/null +++ b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/jwe_algorithms.js @@ -0,0 +1,116 @@ +import { JOSENotSupported } from "../util/errors.js"; +import { table } from "./key_descriptor.js"; +const wrap = [ + ["encrypt", "wrapKey"], + ["decrypt", "unwrapKey"] +], derive = [[], ["deriveBits"]], none = [[], []]; +function rsaes(bits) { + return { + kty: ["RSA"], + mode: "key-encryption", + subtle: { name: "RSA-OAEP", hash: `SHA-${bits}` }, + usages: wrap, + ops: ["wrapKey", "unwrapKey"] + }; +} +function ecdh(mode) { + return { + kty: ["EC", "OKP"], + mode, + subtle: { name: "ECDH" }, + resolve: ({ kty, crv, asymmetricKeyType }) => { + if (crv === "X25519" || asymmetricKeyType === "x25519") + return { name: "X25519" }; + if (kty === "OKP") + throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value'); + return { name: "ECDH", namedCurve: crv }; + }, + usages: derive, + ops: [void 0, "deriveBits"] + }; +} +function aeskw(bits, gcm = !1) { + return { + kty: ["oct"], + mode: "key-wrapping", + secret: !0, + subtle: { name: gcm ? "AES-GCM" : "AES-KW", length: bits }, + usages: none, + ops: gcm ? ["encrypt", "decrypt"] : ["wrapKey", "unwrapKey"] + }; +} +function pbes2() { + return { + kty: ["oct"], + mode: "key-wrapping", + secret: !0, + subtle: { name: "PBKDF2" }, + usages: none, + ops: ["deriveBits", "deriveBits"] + }; +} +const JWE = table({ + dir: { + kty: ["oct"], + mode: "direct-encryption", + secret: !0, + subtle: { name: "AES-GCM" }, + usages: none, + ops: ["encrypt", "decrypt"] + }, + "RSA-OAEP": rsaes(1), + "RSA-OAEP-256": rsaes(256), + "RSA-OAEP-384": rsaes(384), + "RSA-OAEP-512": rsaes(512), + "ECDH-ES": ecdh("direct-key-agreement"), + "ECDH-ES+A128KW": ecdh("key-agreement-with-key-wrapping"), + "ECDH-ES+A192KW": ecdh("key-agreement-with-key-wrapping"), + "ECDH-ES+A256KW": ecdh("key-agreement-with-key-wrapping"), + A128KW: aeskw(128), + A192KW: aeskw(192), + A256KW: aeskw(256), + A128GCMKW: aeskw(128, !0), + A192GCMKW: aeskw(192, !0), + A256GCMKW: aeskw(256, !0), + "PBES2-HS256+A128KW": pbes2(), + "PBES2-HS384+A192KW": pbes2(), + "PBES2-HS512+A256KW": pbes2() +}), contentOps = ["encrypt", "decrypt"]; +function contentEncryption(bits, cbc = !1) { + return { + kty: ["oct"], + secret: !0, + subtle: { name: cbc ? "AES-CBC" : "AES-GCM", length: bits }, + usages: none, + ops: contentOps, + cekBits: bits, + ivBits: cbc ? 128 : 96, + cbc + }; +} +const ENC = table({ + A128GCM: contentEncryption(128), + A192GCM: contentEncryption(192), + A256GCM: contentEncryption(256), + "A128CBC-HS256": contentEncryption(256, !0), + "A192CBC-HS384": contentEncryption(384, !0), + "A256CBC-HS512": contentEncryption(512, !0) +}); +function unsupported(parameter, name) { + throw new JOSENotSupported(`Invalid or unsupported "${parameter}" (JWE ${name}) header value`); +} +function jweAlgorithm(alg) { + return (typeof alg == "string" ? JWE[alg] : void 0) ?? unsupported("alg", "Algorithm"); +} +function isJWECEKTransport(algorithm) { + return algorithm.mode === "key-wrapping" || algorithm.mode === "key-encryption" || algorithm.mode === "key-agreement-with-key-wrapping"; +} +function jweEncryption(enc) { + return (typeof enc == "string" ? ENC[enc] : void 0) ?? unsupported("enc", "Encryption Algorithm"); +} +export { + JWE, + isJWECEKTransport, + jweAlgorithm, + jweEncryption +}; diff --git a/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/jwe_decrypt.js b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/jwe_decrypt.js new file mode 100644 index 000000000..e5453b9ba --- /dev/null +++ b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/jwe_decrypt.js @@ -0,0 +1,187 @@ +import { decrypt, generateCek } from "./content_encryption.js"; +import { decodeBase64url, encodeBase64url, parseJoseHeader, isDisjoint, isObject, validateCrit, validateAlgorithms, JWE_RECOGNIZED } from "./validate.js"; +import { JOSEAlgNotAllowed, JOSENotSupported, JWEInvalid } from "../util/errors.js"; +import { decryptKeyManagement } from "./key_management.js"; +import { decoder } from "./buffer_utils.js"; +import { prepareKey } from "./key.js"; +import { JWE, isJWECEKTransport, jweAlgorithm, jweEncryption } from "./jwe_algorithms.js"; +import { decompress, validateZip } from "./deflate.js"; +function snapshotSharedJWE(jwe) { + const { aad, ciphertext, iv, protected: encodedProtected, tag, unprotected } = jwe; + if (iv !== void 0 && (typeof iv != "string" || !iv)) + throw new JWEInvalid("JWE Initialization Vector incorrect type"); + if (typeof ciphertext != "string") + throw new JWEInvalid("JWE Ciphertext missing or incorrect type"); + if (tag !== void 0 && (typeof tag != "string" || !tag)) + throw new JWEInvalid("JWE Authentication Tag incorrect type"); + if (encodedProtected !== void 0 && typeof encodedProtected != "string") + throw new JWEInvalid("JWE Protected Header incorrect type"); + if (aad !== void 0 && (typeof aad != "string" || !aad)) + throw new JWEInvalid("JWE AAD incorrect type"); + if (unprotected !== void 0 && !isObject(unprotected)) + throw new JWEInvalid("JWE Shared Unprotected Header incorrect type"); + return { + aad, + ciphertext, + iv, + protected: encodedProtected, + tag, + unprotected: unprotected === void 0 ? void 0 : { ...unprotected } + }; +} +function snapshotRecipientJWE(recipient) { + let header, headerAlg; + try { + const { header: inputHeader } = recipient; + if (isObject(inputHeader)) { + headerAlg = inputHeader.alg; + const parameters = Object.keys(inputHeader); + parameters.includes("alg") || (headerAlg = void 0), header = Object.fromEntries(parameters.map((parameter) => [ + parameter, + parameter === "alg" ? headerAlg : inputHeader[parameter] + ])); + } else + header = inputHeader; + const { encrypted_key: encryptedKey } = recipient; + return [{ encrypted_key: encryptedKey, header }, headerAlg]; + } catch (error) { + return [void 0, headerAlg, error]; + } +} +function checkRecipient(jwe) { + const { encrypted_key: encryptedKey, header } = jwe; + if (encryptedKey !== void 0 && typeof encryptedKey != "string") + throw new JWEInvalid("JWE Encrypted Key incorrect type"); + if (header !== void 0 && !isObject(header)) + throw new JWEInvalid("JWE Per-Recipient Unprotected Header incorrect type"); + if (jwe.protected === void 0 && header === void 0 && jwe.unprotected === void 0) + throw new JWEInvalid("JOSE Header missing"); +} +function shareJWE(jwe) { + const { protected: encodedProtected, ciphertext, iv, tag, aad } = jwe; + let parsedProt; + return encodedProtected !== void 0 && (parsedProt = parseJoseHeader(encodedProtected, JWEInvalid, "JWE Protected Header is invalid")), [ + parsedProt, + decodeBase64url(ciphertext, "ciphertext", JWEInvalid), + iv !== void 0 ? decodeBase64url(iv, "iv", JWEInvalid) : void 0, + tag !== void 0 ? decodeBase64url(tag, "tag", JWEInvalid) : void 0, + encodeBase64url((encodedProtected ?? "") + (aad !== void 0 ? `.${aad}` : ""), "aad", JWEInvalid) + ]; +} +function prepareDecrypt(options) { + return [ + options && validateAlgorithms("keyManagementAlgorithms", options.keyManagementAlgorithms), + options && validateAlgorithms("contentEncryptionAlgorithms", options.contentEncryptionAlgorithms), + options?.crit, + options?.maxPBES2Count, + options?.maxDecompressedLength + ]; +} +async function decryptJWE(jwe, shared, key, token = shareJWE(jwe)) { + const [parsedProt, ciphertext, iv, tag, additionalData] = token, { header, unprotected, aad } = jwe; + let joseHeader; + if (header !== void 0 || unprotected !== void 0) { + if (!isDisjoint(parsedProt, header, unprotected)) + throw new JWEInvalid("JWE Protected, JWE Unprotected Header, and JWE Per-Recipient Unprotected Header Parameter names must be disjoint"); + joseHeader = { ...parsedProt, ...header, ...unprotected }; + } else + joseHeader = parsedProt ?? {}; + const [keyManagementAlgorithms, contentEncryptionAlgorithms, crit, maxPBES2Count, maxDecompressedLength] = shared, { encrypted_key: encodedKey } = jwe; + validateCrit(JWEInvalid, JWE_RECOGNIZED, crit, parsedProt, joseHeader), validateZip(joseHeader, parsedProt); + const { alg, enc } = joseHeader; + if (typeof alg != "string" || !alg) + throw new JWEInvalid("missing JWE Algorithm (alg) in JWE Header"); + const selected = JWE[alg]; + if (encodedKey === "" && (!selected || !isJWECEKTransport(selected))) + throw new JWEInvalid("JWE Encrypted Key incorrect type"); + const integrated = selected?.mode === "integrated-encryption"; + if (!integrated && (typeof enc != "string" || !enc)) + throw new JWEInvalid("missing JWE Encryption Algorithm (enc) in JWE Header"); + if (keyManagementAlgorithms && !keyManagementAlgorithms.has(alg) || !keyManagementAlgorithms && alg.startsWith("PBES2")) + throw new JOSEAlgNotAllowed('"alg" (Algorithm) Header Parameter value not allowed'); + let encEntry; + if (integrated) { + if (enc !== void 0) + throw new JWEInvalid('JWE "enc" (Encryption Algorithm) Header Parameter must not be present for integrated encryption'); + if (iv?.byteLength) + throw new JWEInvalid("JWE Initialization Vector must be empty for integrated encryption"); + if (tag?.byteLength) + throw new JWEInvalid("JWE Authentication Tag must be empty for integrated encryption"); + } else { + if (contentEncryptionAlgorithms && !contentEncryptionAlgorithms.has(enc)) + throw new JOSEAlgNotAllowed('"enc" (Encryption Algorithm) Header Parameter value not allowed'); + encEntry = jweEncryption(enc); + } + let encryptedKey; + if (encodedKey !== void 0) + try { + encryptedKey = decodeBase64url(encodedKey, "encrypted_key", JWEInvalid); + } catch (error) { + if (!selected || !isJWECEKTransport(selected)) + throw error; + encryptedKey = new Uint8Array(); + } + let resolvedKey = !1; + typeof key == "function" && (key = await key(parsedProt, jwe), resolvedKey = !0); + const algEntry = selected ?? jweAlgorithm(alg); + isJWECEKTransport(algEntry) && encryptedKey === void 0 && (encryptedKey = new Uint8Array()); + const k = await prepareKey(algEntry.mode === "direct-encryption" ? encEntry : algEntry, key, "decrypt"); + let plaintext; + if (algEntry.mode === "integrated-encryption") + plaintext = await algEntry.decrypt(k, encryptedKey, ciphertext, additionalData, parsedProt, joseHeader); + else { + const encryption = encEntry; + let cek; + try { + cek = await decryptKeyManagement(algEntry, encryption, k, encryptedKey, joseHeader, maxPBES2Count), isJWECEKTransport(algEntry) && cek instanceof Uint8Array && cek.byteLength << 3 !== encryption.cekBits && (cek = generateCek(encryption)); + } catch (err) { + if (err instanceof TypeError || err instanceof JWEInvalid || err instanceof JOSENotSupported) + throw err; + cek = generateCek(encryption); + } + plaintext = await decrypt(encryption, cek, ciphertext, iv, tag, additionalData); + } + if (joseHeader.zip === "DEF") { + const decompressionLimit = maxDecompressedLength ?? 25e4; + if (decompressionLimit === 0) + throw new JOSENotSupported('JWE "zip" (Compression Algorithm) Header Parameter is not supported.'); + if (decompressionLimit !== 1 / 0 && (!Number.isSafeInteger(decompressionLimit) || decompressionLimit < 1)) + throw new TypeError("maxDecompressedLength must be 0, a positive safe integer, or Infinity"); + plaintext = await decompress(plaintext, decompressionLimit).catch((cause) => { + throw cause instanceof JWEInvalid ? cause : new JWEInvalid("Failed to decompress plaintext", { cause }); + }); + } + return { + plaintext, + ...parsedProt && { protectedHeader: parsedProt }, + ...aad !== void 0 && { + additionalAuthenticatedData: decodeBase64url(aad, "aad", JWEInvalid) + }, + ...unprotected && { sharedUnprotectedHeader: unprotected }, + ...header && { unprotectedHeader: header }, + ...resolvedKey && { key: k } + }; +} +async function decryptCompact(jwe, shared, key) { + if (jwe instanceof Uint8Array && (jwe = decoder.decode(jwe)), typeof jwe != "string") + throw new JWEInvalid("Compact JWE must be a string or Uint8Array"); + const { 0: protectedHeader, 1: encryptedKey, 2: iv, 3: ciphertext, 4: tag, length } = jwe.split("."); + if (length !== 5) + throw new JWEInvalid("Invalid Compact JWE"); + return decryptJWE({ + ciphertext, + iv: iv || void 0, + protected: protectedHeader, + tag: tag || void 0, + encrypted_key: encryptedKey || void 0 + }, shared, key); +} +export { + checkRecipient, + decryptCompact, + decryptJWE, + prepareDecrypt, + shareJWE, + snapshotRecipientJWE, + snapshotSharedJWE +}; diff --git a/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/jwe_encrypt.js b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/jwe_encrypt.js new file mode 100644 index 000000000..5ab33766b --- /dev/null +++ b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/jwe_encrypt.js @@ -0,0 +1,75 @@ +import { encode as b64u } from "../util/base64url.js"; +import { encrypt } from "./content_encryption.js"; +import { encryptKeyManagement } from "./key_management.js"; +import { JWEInvalid } from "../util/errors.js"; +import { assertUint8Array, isDisjoint, isObject, serializeJoseHeader, validateCrit, validateCritDuplicates, JWE_RECOGNIZED } from "./validate.js"; +import { encode } from "./buffer_utils.js"; +import { prepareKey } from "./key.js"; +import { JWE, jweAlgorithm, jweEncryption } from "./jwe_algorithms.js"; +import { compress, validateZip } from "./deflate.js"; +function checkDisjoint(protectedHeader, unprotectedHeader, sharedUnprotectedHeader) { + if (!isDisjoint(protectedHeader, unprotectedHeader, sharedUnprotectedHeader)) + throw new JWEInvalid("JWE Protected, JWE Shared Unprotected and JWE Per-Recipient Header Parameter names must be disjoint"); +} +function checkEncryptHeaders(input, options, sharedHeadersNormalized = !1) { + if (!input[1] && !input[2] && !input[3]) + throw new JWEInvalid("either setProtectedHeader, setUnprotectedHeader, or sharedUnprotectedHeader must be called before #encrypt()"); + options !== void 0 && (input[8] = options?.crit); + let [, protectedHeader, unprotectedHeader, sharedUnprotectedHeader, aad, cek, iv, keyManagementParameters, crit] = input; + if (aad !== void 0 && assertUint8Array(aad, "JWE Additional Authenticated Data"), cek !== void 0 && assertUint8Array(cek, "JWE Content Encryption Key"), iv !== void 0 && assertUint8Array(iv, "JWE Initialization Vector"), !sharedHeadersNormalized && protectedHeader !== void 0 && (protectedHeader = serializeJoseHeader(JWEInvalid, protectedHeader)[0], input[1] = protectedHeader), unprotectedHeader !== void 0 && (unprotectedHeader = serializeJoseHeader(JWEInvalid, unprotectedHeader)[0], input[2] = unprotectedHeader), !sharedHeadersNormalized && sharedUnprotectedHeader !== void 0 && (sharedUnprotectedHeader = serializeJoseHeader(JWEInvalid, sharedUnprotectedHeader)[0], input[3] = sharedUnprotectedHeader), keyManagementParameters !== void 0 && !isObject(keyManagementParameters)) + throw new TypeError("JWE Key Management Parameters must be an object"); + checkDisjoint(protectedHeader, unprotectedHeader, sharedUnprotectedHeader); + const joseHeader = { + ...protectedHeader, + ...unprotectedHeader, + ...sharedUnprotectedHeader + }; + validateCritDuplicates(JWEInvalid, protectedHeader), validateCrit(JWEInvalid, JWE_RECOGNIZED, crit, protectedHeader, joseHeader), validateZip(joseHeader, protectedHeader); + const { alg, enc } = joseHeader; + if (typeof alg != "string" || !alg) + throw new JWEInvalid('JWE "alg" (Algorithm) Header Parameter missing or invalid'); + const algEntry = JWE[alg]; + if (algEntry?.mode === "integrated-encryption") { + if (enc !== void 0) + throw new JWEInvalid('JWE "enc" (Encryption Algorithm) Header Parameter must not be present for integrated encryption'); + if (cek !== void 0) + throw new TypeError(`setContentEncryptionKey cannot be called with JWE "alg" (Algorithm) Header ${alg}`); + if (iv !== void 0) + throw new TypeError(`setInitializationVector cannot be called with JWE "alg" (Algorithm) Header ${alg}`); + return [joseHeader, void 0, algEntry]; + } + if (typeof enc != "string" || !enc) + throw new JWEInvalid('JWE "enc" (Encryption Algorithm) Header Parameter missing or invalid'); + return [joseHeader, jweEncryption(enc), algEntry]; +} +async function encryptJWE(input, checked, key) { + const [joseHeader, encEntry, selected] = checked, [inputPlaintext, inputProtectedHeader, inputUnprotectedHeader, sharedUnprotectedHeader, aad, providedCek, inputIv, keyManagementParameters, , unprotectedParameters] = input; + let protectedHeader = inputProtectedHeader, unprotectedHeader = inputUnprotectedHeader; + const algEntry = selected ?? jweAlgorithm(joseHeader.alg); + let encryptedKey, parameters, cek; + algEntry.mode === "integrated-encryption" ? cek = await prepareKey(algEntry, key, "encrypt") : [cek, encryptedKey, parameters] = await encryptKeyManagement(algEntry, encEntry, key, joseHeader, providedCek, keyManagementParameters), parameters && (unprotectedParameters ? unprotectedHeader = unprotectedHeader ? { ...unprotectedHeader, ...parameters } : parameters : protectedHeader = protectedHeader ? { ...protectedHeader, ...parameters } : parameters, checkDisjoint(protectedHeader, unprotectedHeader, sharedUnprotectedHeader)); + const protectedHeaderS = protectedHeader ? b64u(JSON.stringify(protectedHeader)) : "", aadMember = aad?.byteLength ? b64u(aad) : void 0, additionalData = encode(aadMember ? `${protectedHeaderS}.${aadMember}` : protectedHeaderS); + let plaintext = inputPlaintext; + joseHeader.zip === "DEF" && (plaintext = await compress(plaintext).catch((cause) => { + throw new JWEInvalid("Failed to compress plaintext", { cause }); + })); + let ciphertext, tag, iv; + algEntry.mode === "integrated-encryption" ? [encryptedKey, ciphertext] = await algEntry.encrypt(cek, plaintext, additionalData, protectedHeader, joseHeader, keyManagementParameters) : { ciphertext, tag, iv } = await encrypt(encEntry, plaintext, cek, inputIv, additionalData); + const jwe = { + ciphertext: b64u(ciphertext) + }; + return iv && (jwe.iv = b64u(iv)), tag && (jwe.tag = b64u(tag)), encryptedKey?.byteLength && (jwe.encrypted_key = b64u(encryptedKey)), aadMember && (jwe.aad = aadMember), protectedHeader && (jwe.protected = protectedHeaderS), sharedUnprotectedHeader && (jwe.unprotected = sharedUnprotectedHeader), unprotectedHeader && (jwe.header = unprotectedHeader), jwe; +} +async function createJWE(input, key, options) { + return encryptJWE(input, checkEncryptHeaders(input, options), key); +} +function compactJWE(jwe) { + return [jwe.protected, jwe.encrypted_key, jwe.iv, jwe.ciphertext, jwe.tag].join("."); +} +export { + checkDisjoint, + checkEncryptHeaders, + compactJWE, + createJWE, + encryptJWE +}; diff --git a/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/jwt_claims_set.js b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/jwt_claims_set.js new file mode 100644 index 000000000..b99943f9c --- /dev/null +++ b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/jwt_claims_set.js @@ -0,0 +1,146 @@ +import { JWTClaimValidationFailed, JWTExpired, JWTInvalid } from "../util/errors.js"; +import { encoder, strictDecoder } from "./buffer_utils.js"; +import { isObject } from "./validate.js"; +const epoch = (date) => Math.floor(date.getTime() / 1e3), multipliers = { + s: 1, + m: 60, + h: 3600, + d: 86400, + w: 604800, + y: 31557600 +}, REGEX = /^(\+|\-)? ?(\d+|\d+\.\d+) ?(seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)(?: (ago|from now))?$/i, checkFailed = "check_failed"; +function invalidDuration() { + throw new TypeError("Invalid time period format"); +} +function secs(str) { + typeof str != "string" && invalidDuration(); + const matched = REGEX.exec(str); + (!matched || matched[4] && matched[1]) && invalidDuration(); + const value = parseFloat(matched[2]), numericDate2 = Math.round(value * multipliers[matched[3][0].toLowerCase()]); + return Number.isFinite(numericDate2) || invalidDuration(), matched[1] === "-" || matched[4] === "ago" ? -numericDate2 : numericDate2; +} +function validateInput(label, input) { + if (!Number.isFinite(input)) + throw new TypeError(`Invalid ${label} input`); + return input; +} +function validateStringClaim(claim, value) { + if (typeof value != "string") + throw new TypeError(`"${claim}" claim must be a string`); +} +function validateAudienceClaim(value) { + if (typeof value != "string" && (!Array.isArray(value) || Array.from(value).some((member) => typeof member != "string"))) + throw new TypeError('"aud" claim must be a string or an array of strings'); +} +function numericDate(value, label) { + return typeof value == "number" ? validateInput(label, value) : value instanceof Date ? validateInput(label, epoch(value)) : epoch(/* @__PURE__ */ new Date()) + secs(value); +} +const normalizeTyp = (value) => { + const normalized = value.toLowerCase(); + return value.includes("/") ? normalized : `application/${normalized}`; +}, checkAudiencePresence = (audPayload, audOption) => typeof audPayload == "string" ? audOption.includes(audPayload) : Array.isArray(audPayload) ? audOption.some((aud) => audPayload.includes(aud)) : !1; +function validateNumericDate(payload, claim, required = !1) { + const value = payload[claim]; + if (!(value === void 0 && !required)) { + if (typeof value != "number") + throw new JWTClaimValidationFailed(`"${claim}" claim must be a number`, payload, claim, "invalid"); + return value; + } +} +function unexpectedClaim(payload, claim) { + throw new JWTClaimValidationFailed(`unexpected "${claim}" claim value`, payload, claim, checkFailed); +} +function validateClaimsSet(protectedHeader, encodedPayload, options = {}) { + let payload; + try { + payload = JSON.parse(strictDecoder.decode(encodedPayload)); + } catch { + } + if (!isObject(payload)) + throw new JWTInvalid("JWT Claims Set must be a top-level JSON object"); + const { typ } = options; + if (typ !== void 0 && (typeof protectedHeader.typ != "string" || normalizeTyp(protectedHeader.typ) !== normalizeTyp(typ))) + throw new JWTClaimValidationFailed('unexpected "typ" JWT header value', payload, "typ", checkFailed); + const { requiredClaims = [], issuer, subject, audience, maxTokenAge } = options, presenceCheck = [...requiredClaims]; + maxTokenAge !== void 0 && presenceCheck.push("iat"), audience !== void 0 && presenceCheck.push("aud"), subject !== void 0 && presenceCheck.push("sub"), issuer !== void 0 && presenceCheck.push("iss"); + for (const claim of new Set(presenceCheck.reverse())) + if (!Object.hasOwn(payload, claim)) + throw new JWTClaimValidationFailed(`missing required "${claim}" claim`, payload, claim, "missing"); + issuer !== void 0 && !(Array.isArray(issuer) ? issuer : [issuer]).includes(payload.iss) && unexpectedClaim(payload, "iss"), subject !== void 0 && payload.sub !== subject && unexpectedClaim(payload, "sub"), audience !== void 0 && !checkAudiencePresence(payload.aud, typeof audience == "string" ? [audience] : audience) && unexpectedClaim(payload, "aud"); + const { clockTolerance } = options; + let tolerance = 0; + if (typeof clockTolerance == "string") + tolerance = secs(clockTolerance); + else if (clockTolerance !== void 0) { + if (typeof clockTolerance != "number") + throw new TypeError("Invalid clockTolerance option type"); + tolerance = clockTolerance; + } + validateInput("clockTolerance option", tolerance); + const { currentDate } = options, now = validateInput("currentDate option", epoch(currentDate === void 0 ? /* @__PURE__ */ new Date() : currentDate)), iat = validateNumericDate(payload, "iat", maxTokenAge !== void 0), nbf = validateNumericDate(payload, "nbf"); + if (nbf !== void 0 && nbf > now + tolerance) + throw new JWTClaimValidationFailed('"nbf" claim timestamp check failed', payload, "nbf", checkFailed); + const exp = validateNumericDate(payload, "exp"); + if (exp !== void 0 && exp <= now - tolerance) + throw new JWTExpired('"exp" claim timestamp check failed', payload, "exp", checkFailed); + if (maxTokenAge !== void 0) { + const age = now - iat, max = validateInput("maxTokenAge option", typeof maxTokenAge == "number" ? maxTokenAge : secs(maxTokenAge)); + if (age - tolerance > max) + throw new JWTExpired('"iat" claim timestamp check failed (too far in the past)', payload, "iat", checkFailed); + if (age < -tolerance) + throw new JWTClaimValidationFailed('"iat" claim timestamp check failed (it should be in the past)', payload, "iat", checkFailed); + } + return payload; +} +let producerPayloads; +function producerPayload(producer) { + return producerPayloads.get(producer); +} +function jwtData(producer) { + const payload = producerPayload(producer); + for (const claim of ["iat", "nbf", "exp"]) { + const value = payload[claim]; + if (typeof value == "number" && !Number.isFinite(value)) + throw new TypeError(`"${claim}" claim must be a finite number`); + } + return encoder.encode(JSON.stringify(payload)); +} +function jwtClaim(producer, claim) { + return producerPayload(producer)[claim]; +} +class JWTClaimsBuilder { + constructor(payload = {}) { + if (!isObject(payload)) + throw new TypeError("JWT Claims Set MUST be an object"); + (producerPayloads ||= /* @__PURE__ */ new WeakMap()).set(this, structuredClone(payload)); + } + setIssuer(value) { + return validateStringClaim("iss", value), producerPayload(this).iss = value, this; + } + setSubject(value) { + return validateStringClaim("sub", value), producerPayload(this).sub = value, this; + } + setAudience(value) { + return validateAudienceClaim(value), producerPayload(this).aud = value, this; + } + setJti(value) { + return validateStringClaim("jti", value), producerPayload(this).jti = value, this; + } + setNotBefore(value) { + return producerPayload(this).nbf = numericDate(value, "setNotBefore"), this; + } + setExpirationTime(value) { + return producerPayload(this).exp = numericDate(value, "setExpirationTime"), this; + } + setIssuedAt(value) { + const payload = producerPayload(this); + return value === void 0 ? payload.iat = epoch(/* @__PURE__ */ new Date()) : typeof value == "string" ? payload.iat = validateInput("setIssuedAt", epoch(/* @__PURE__ */ new Date()) + secs(value)) : payload.iat = numericDate(value, "setIssuedAt"), this; + } +} +export { + JWTClaimsBuilder, + jwtClaim, + jwtData, + secs, + validateClaimsSet +}; diff --git a/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/key.js b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/key.js new file mode 100644 index 000000000..7dc5602f1 --- /dev/null +++ b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/key.js @@ -0,0 +1,155 @@ +import { isObject } from "./validate.js"; +import { decode } from "../util/base64url.js"; +import { JOSENotSupported } from "../util/errors.js"; +const tag = (key) => key[Symbol.toStringTag], jwkMatchesOp = (entry, key, usage) => { + const { alg } = entry; + if (key.use !== void 0) { + const expected = usage === "sign" || usage === "verify" ? "sig" : "enc"; + if (key.use !== expected) + throw new TypeError(`Invalid key for this operation, its "use" must be "${expected}" when present`); + } + if (key.alg !== void 0 && key.alg !== alg) + throw new TypeError(`Invalid key for this operation, its "alg" must be "${alg}" when present`); + if (Array.isArray(key.key_ops)) { + const expectedKeyOp = usage === "encrypt" || usage === "decrypt" ? entry.ops?.[usage === "encrypt" ? 0 : 1] : usage; + if (expectedKeyOp && !key.key_ops.includes(expectedKeyOp)) + throw new TypeError(`Invalid key for this operation, its "key_ops" must include "${expectedKeyOp}" when present`); + } +}; +async function prepareKey(entry, key, usage) { + const { alg, secret } = entry, privateKey = usage === "decrypt" || usage === "sign"; + if (secret && key instanceof Uint8Array) + return key; + let normalized, keyObject; + if (isObject(key)) { + if (normalized = normalizeJwk(key), typeof normalized.kty != "string") + throw invalidKeyType(alg, key, secret); + if (!(secret ? normalized.kty === "oct" && typeof normalized.k == "string" : normalized.kty !== "oct" && (privateKey ? normalized.kty === "AKP" && typeof normalized.priv == "string" || typeof normalized.d == "string" : normalized.d === void 0 && normalized.priv === void 0))) + throw new TypeError(secret ? 'JSON Web Key for symmetric algorithms must have JWK "kty" (Key Type) equal to "oct" and the JWK "k" (Key Value) present' : `JSON Web Key for this operation must be a ${privateKey ? "private" : "public"} JWK`); + if (jwkMatchesOp(entry, normalized, usage), normalized.kty === "oct") + return decode(normalized.k); + if (!Object.isFrozen(key)) { + const { key_ops } = key; + Array.isArray(key_ops) && Object.freeze(key_ops), Object.freeze(key); + } + } else { + if (!isKeyLike(key)) + throw invalidKeyType(alg, key, secret); + const expectedType = secret ? "secret" : privateKey ? "private" : "public"; + if (key.type !== expectedType && (secret || ["secret", "public", "private"].includes(key.type))) + throw new TypeError(`${tag(key)} instances must be of type "${expectedType}" for the ${alg} algorithm`); + if (isCryptoKey(key)) + return key; + if (keyObject = key, keyObject.type === "secret") + return keyObject.export(); + } + cache ||= /* @__PURE__ */ new WeakMap(); + const cacheKey = key; + let cached = cache.get(cacheKey); + if (cached?.[alg]) + return cached[alg]; + if (cached || cache.set(cacheKey, cached = {}), keyObject && typeof keyObject.toCryptoKey == "function") { + const isPublic = keyObject.type === "public", crv = nist[keyObject.asymmetricKeyDetails?.namedCurve], params = entry.resolve?.({ crv, asymmetricKeyType: keyObject.asymmetricKeyType }) ?? entry.subtle; + return cached[alg] = keyObject.toCryptoKey(params, isPublic, entry.usages[isPublic ? 0 : 1]); + } + return normalized ??= keyObject.export({ format: "jwk" }), normalized.alg = alg, cached[alg] = await jwkToKey(entry, normalized); +} +let cache; +const nist = { + __proto__: null, + prime256v1: "P-256", + secp384r1: "P-384", + secp521r1: "P-521" +}; +function assertCryptoKey(key) { + if (!isCryptoKey(key)) + throw new Error("CryptoKey instance expected"); +} +const isCryptoKey = (key) => { + if (key?.[Symbol.toStringTag] === "CryptoKey") + return !0; + try { + return key instanceof CryptoKey; + } catch { + return !1; + } +}, isKeyObject = (key) => key?.[Symbol.toStringTag] === "KeyObject", isKeyLike = (key) => isCryptoKey(key) || isKeyObject(key); +function message(msg, actual, ...types) { + if (types.length > 2) { + const last = types.pop(); + msg += `one of type ${types.join(", ")}, or ${last}.`; + } else types.length === 2 ? msg += `one of type ${types[0]} or ${types[1]}.` : msg += `of type ${types[0]}.`; + return actual == null ? msg += ` Received ${actual}` : typeof actual == "function" && actual.name ? msg += ` Received function ${actual.name}` : typeof actual == "object" && actual != null && actual.constructor?.name && (msg += ` Received an instance of ${actual.constructor.name}`), msg; +} +const invalidKeyInput = (actual, ...types) => message("Key must be ", actual, ...types); +function invalidKeyType(alg, actual, secret) { + const types = ["CryptoKey", "KeyObject", "JSON Web Key"]; + return secret && types.push("Uint8Array"), new TypeError(message(`Key for the ${alg} algorithm must be `, actual, ...types)); +} +const unusable = (name, prop = "algorithm.name") => new TypeError(`CryptoKey does not support this operation, its ${prop} must be ${name}`); +function checkUsage(key, usage) { + if (usage && !key.usages.includes(usage)) + throw new TypeError(`CryptoKey does not support this operation, its usages must include ${usage}.`); +} +function checkModulusLength(alg, key) { + const { modulusLength } = key.algorithm; + if (typeof modulusLength != "number" || modulusLength < 2048) + throw new TypeError(`${alg} requires key modulusLength to be 2048 bits or larger`); +} +function checkCryptoKey(key, expected, usage) { + const algorithm = key.algorithm; + if (algorithm.name !== expected.name) + throw unusable(expected.name); + if (expected.hash && algorithm.hash?.name !== expected.hash) + throw unusable(expected.hash, "algorithm.hash"); + if (expected.namedCurve && algorithm.namedCurve !== expected.namedCurve) + throw unusable(expected.namedCurve, "algorithm.namedCurve"); + if (expected.length !== void 0 && algorithm.length !== expected.length) + throw unusable(expected.length, "algorithm.length"); + checkUsage(key, usage); +} +function snapshotJwk(jwk) { + return { __proto__: null, ...jwk }; +} +function normalizeJwk(jwk) { + const normalized = snapshotJwk(jwk); + if (normalized.ext !== void 0 && typeof normalized.ext != "boolean") + throw new TypeError('"ext" (Extractable) Parameter must be a boolean'); + if (normalized.key_ops !== void 0) { + const value = normalized.key_ops, keyOps = Array.isArray(value) ? [...value] : void 0; + if (!keyOps || keyOps.some((operation) => typeof operation != "string") || new Set(keyOps).size !== keyOps.length) + throw new TypeError('"key_ops" (Key Operations) Parameter must be an array of unique strings'); + normalized.key_ops = keyOps; + } + return normalized; +} +function validateExtractableOption(extractable) { + if (extractable !== void 0 && typeof extractable != "boolean") + throw new TypeError('"extractable" option must be a boolean'); + return extractable; +} +async function jwkToKey(entry, jwk, extractable) { + if (!entry.kty.includes(jwk.kty)) + throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value'); + const algorithm = entry.resolve?.({ kty: jwk.kty, crv: jwk.crv }) ?? entry.subtle, isPrivate = !!(jwk.d || jwk.priv), keyData = { ...jwk, ext: extractable ?? jwk.ext }; + return keyData.kty !== "AKP" && delete keyData.alg, delete keyData.use, crypto.subtle.importKey("jwk", keyData, algorithm, keyData.ext ?? !isPrivate, jwk.key_ops ?? entry.usages[isPrivate ? 1 : 0]); +} +async function rawKey(key, expected, usage, extractable = !1) { + return key instanceof Uint8Array && (key = await crypto.subtle.importKey("raw", key, expected, extractable, [usage])), checkCryptoKey(key, expected, usage), key; +} +export { + assertCryptoKey, + checkCryptoKey, + checkModulusLength, + checkUsage, + invalidKeyInput, + isCryptoKey, + isKeyLike, + isKeyObject, + jwkToKey, + normalizeJwk, + prepareKey, + rawKey, + snapshotJwk, + validateExtractableOption +}; diff --git a/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/key_descriptor.js b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/key_descriptor.js new file mode 100644 index 000000000..cf0afbd90 --- /dev/null +++ b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/key_descriptor.js @@ -0,0 +1,9 @@ +function table(entries) { + const out = { __proto__: null }; + for (const alg in entries) + out[alg] = { ...entries[alg], alg }; + return out; +} +export { + table +}; diff --git a/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/key_management.js b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/key_management.js new file mode 100644 index 000000000..7b7533b70 --- /dev/null +++ b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/key_management.js @@ -0,0 +1,196 @@ +import { encode as b64u } from "../util/base64url.js"; +import { prepareKey, rawKey, jwkToKey, checkCryptoKey, checkModulusLength, checkUsage, assertCryptoKey } from "./key.js"; +import { jweAlgorithm, jweEncryption, isJWECEKTransport } from "./jwe_algorithms.js"; +import { JOSENotSupported, JWEInvalid } from "../util/errors.js"; +import { decodeBase64url, assertUint8Array, isObject } from "./validate.js"; +import { digest, concat, encode, uint32be } from "./buffer_utils.js"; +import { checkCekLength, generateCek, encrypt, decrypt } from "./content_encryption.js"; +function checkEcdhCryptoKey(key, usage) { + if (key.algorithm.name !== "ECDH" && key.algorithm.name !== "X25519") + throw new TypeError("CryptoKey does not support this operation, its algorithm.name must be ECDH or X25519"); + checkUsage(key, usage); +} +async function aeskwWrap(alg, key, cek) { + const cryptoKey = await rawKey(key, jweAlgorithm(alg).subtle, "wrapKey", !0), cryptoKeyCek = await crypto.subtle.importKey("raw", cek, { hash: "SHA-256", name: "HMAC" }, !0, ["sign"]); + return new Uint8Array(await crypto.subtle.wrapKey("raw", cryptoKeyCek, cryptoKey, "AES-KW")); +} +async function aeskwUnwrap(alg, key, encryptedKey) { + const cryptoKey = await rawKey(key, jweAlgorithm(alg).subtle, "unwrapKey", !0), cryptoKeyCek = await crypto.subtle.unwrapKey("raw", encryptedKey, cryptoKey, "AES-KW", { hash: "SHA-256", name: "HMAC" }, !0, ["sign"]); + return new Uint8Array(await crypto.subtle.exportKey("raw", cryptoKeyCek)); +} +function checkRsaKey(alg, key, usage) { + checkCryptoKey(key, jweAlgorithm(alg).subtle, usage), checkModulusLength(alg, key); +} +async function deriveKey(p2s, alg, p2c, key) { + if (!(p2s instanceof Uint8Array) || p2s.length < 8) + throw new JWEInvalid("PBES2 Salt Input must be 8 or more octets"); + if (!Number.isSafeInteger(p2c) || Math.sign(p2c) !== 1) + throw new JWEInvalid("PBES2 Count Input must be a positive integer"); + const salt = concat(encode(alg), Uint8Array.of(0), p2s), keylen = parseInt(alg.slice(13, 16), 10), subtleAlg = { + hash: `SHA-${alg.slice(8, 11)}`, + iterations: p2c, + name: "PBKDF2", + salt + }, cryptoKey = await rawKey(key, jweAlgorithm(alg).subtle, "deriveBits"); + return new Uint8Array(await crypto.subtle.deriveBits(subtleAlg, cryptoKey, keylen)); +} +function lengthAndInput(input) { + return concat(uint32be(input.length), input); +} +async function concatKdf(Z, L, OtherInfo) { + const dkLen = L >> 3, hashLen = 32, reps = Math.ceil(dkLen / hashLen), dk = new Uint8Array(reps * hashLen); + for (let i = 1; i <= reps; i++) { + const hashResult = await digest("sha256", concat(uint32be(i), Z, OtherInfo)); + dk.set(hashResult, (i - 1) * hashLen); + } + return dk.slice(0, dkLen); +} +async function ecdhesDeriveKey(publicKey, privateKey, algorithm, keyLength, apu = new Uint8Array(), apv = new Uint8Array()) { + checkEcdhCryptoKey(publicKey), checkEcdhCryptoKey(privateKey, "deriveBits"); + const otherInfo = concat(lengthAndInput(encode(algorithm)), lengthAndInput(apu), lengthAndInput(apv), uint32be(keyLength)), Z = new Uint8Array(await crypto.subtle.deriveBits({ + name: publicKey.algorithm.name, + public: publicKey + }, privateKey, publicKey.algorithm.name === "X25519" ? 256 : Math.ceil(parseInt(publicKey.algorithm.namedCurve.slice(-3), 10) / 8) << 3)); + return concatKdf(Z, keyLength, otherInfo); +} +function assertEcdhKey(key) { + assertCryptoKey(key); + const curve = key.algorithm.namedCurve; + if (curve !== "P-256" && curve !== "P-384" && curve !== "P-521" && key.algorithm.name !== "X25519") + throw new JOSENotSupported("ECDH with the provided key is not allowed or not supported by your javascript runtime"); +} +function partyInfo(joseHeader, name) { + const value = joseHeader[name]; + if (value !== void 0) { + if (typeof value != "string") + throw new JWEInvalid(`JOSE Header "${name}" (Agreement Party${name === "apu" ? "U" : "V"}Info) invalid`); + return decodeBase64url(value, name, JWEInvalid); + } +} +function checkPartyInfo(apu, apv) { + if (!(apu === void 0 || apv === void 0 || apu.byteLength !== apv.byteLength)) { + for (let i = 0; i < apu.byteLength; i++) + if (apu[i] !== apv[i]) + return; + throw new JWEInvalid('JOSE Header "apu" and "apv" values must be distinct'); + } +} +function assertEncryptedKey(encryptedKey) { + if (encryptedKey === void 0) + throw new JWEInvalid("JWE Encrypted Key missing"); +} +function assertNoEncryptedKey(encryptedKey) { + if (encryptedKey !== void 0) + throw new JWEInvalid("Encountered unexpected JWE Encrypted Key"); +} +function validateMaxPBES2Count(value) { + if (value !== void 0 && value !== 1 / 0 && (!Number.isSafeInteger(value) || value < 1)) + throw new TypeError("maxPBES2Count must be a positive safe integer or Infinity"); +} +async function decryptKeyManagement(entry, enc, key, encryptedKey, joseHeader, maxPBES2Count) { + const { alg } = entry, mode = entry.mode; + if (mode === "direct-encryption") + return assertNoEncryptedKey(encryptedKey), key; + const direct = mode === "direct-key-agreement"; + switch (direct ? assertNoEncryptedKey(encryptedKey) : assertEncryptedKey(encryptedKey), entry.subtle.name) { + case "ECDH": { + const { epk } = joseHeader; + if (!isObject(epk) || ["d", "k", "p", "q", "dp", "dq", "qi", "oth", "priv"].some((parameter) => Object.hasOwn(epk, parameter))) + throw new JWEInvalid('JOSE Header "epk" (Ephemeral Public Key) missing or invalid'); + assertEcdhKey(key); + const ephemeralPublicKey = await jwkToKey(entry, epk), partyUInfo = partyInfo(joseHeader, "apu"), partyVInfo = partyInfo(joseHeader, "apv"); + checkPartyInfo(partyUInfo, partyVInfo); + const sharedSecret = await ecdhesDeriveKey(ephemeralPublicKey, key, direct ? enc.alg : alg, direct ? enc.cekBits : parseInt(alg.slice(-5, -2), 10), partyUInfo, partyVInfo); + if (direct) + return sharedSecret; + key = sharedSecret; + break; + } + case "RSA-OAEP": + return assertCryptoKey(key), checkRsaKey(alg, key, "decrypt"), new Uint8Array(await crypto.subtle.decrypt("RSA-OAEP", key, encryptedKey)); + case "PBKDF2": { + if (typeof joseHeader.p2c != "number") + throw new JWEInvalid('JOSE Header "p2c" (PBES2 Count) missing or invalid'); + validateMaxPBES2Count(maxPBES2Count); + const p2cLimit = maxPBES2Count ?? 1e4; + if (joseHeader.p2c > p2cLimit) + throw new JWEInvalid('JOSE Header "p2c" (PBES2 Count) out is of acceptable bounds'); + if (typeof joseHeader.p2s != "string") + throw new JWEInvalid('JOSE Header "p2s" (PBES2 Salt) missing or invalid'); + const p2s = decodeBase64url(joseHeader.p2s, "p2s", JWEInvalid); + key = await deriveKey(p2s, alg, joseHeader.p2c, key); + break; + } + case "AES-GCM": { + if (typeof joseHeader.iv != "string") + throw new JWEInvalid('JOSE Header "iv" (Initialization Vector) missing or invalid'); + if (typeof joseHeader.tag != "string") + throw new JWEInvalid('JOSE Header "tag" (Authentication Tag) missing or invalid'); + const iv = decodeBase64url(joseHeader.iv, "iv", JWEInvalid), tag = decodeBase64url(joseHeader.tag, "tag", JWEInvalid); + if (iv.byteLength !== 12) + throw new JWEInvalid("Invalid Initialization Vector length"); + if (tag.byteLength !== 16) + throw new JWEInvalid("Invalid Authentication Tag length"); + return decrypt(jweEncryption(alg.slice(0, -2)), key, encryptedKey, iv, tag, new Uint8Array()); + } + } + return aeskwUnwrap(alg.slice(-6), key, encryptedKey); +} +async function encryptKeyManagement(entry, enc, inputKey, joseHeader, providedCek, providedParameters = {}) { + const { alg, mode } = entry, transport = isJWECEKTransport(entry); + if (providedCek !== void 0 && !transport) + throw new TypeError(`setContentEncryptionKey cannot be called with JWE "alg" (Algorithm) Header ${alg}`); + let key = await prepareKey(mode === "direct-encryption" ? enc : entry, inputKey, "encrypt"); + if (mode === "direct-encryption") + return [key, void 0, void 0]; + const cek = transport ? providedCek ?? generateCek(enc) : void 0; + cek && checkCekLength(cek, enc.cekBits); + let encryptedKey, parameters; + switch (entry.subtle.name) { + case "ECDH": { + assertEcdhKey(key); + const { apu: providedApu, apv: providedApv } = providedParameters; + providedApu !== void 0 && assertUint8Array(providedApu, '"apu"'), providedApv !== void 0 && assertUint8Array(providedApv, '"apv"'); + const apu = providedApu ?? partyInfo(joseHeader, "apu"), apv = providedApv ?? partyInfo(joseHeader, "apv"); + checkPartyInfo(apu, apv); + let ephemeralKey; + providedParameters.epk !== void 0 ? ephemeralKey = await prepareKey(entry, providedParameters.epk, "decrypt") : ephemeralKey = (await crypto.subtle.generateKey(key.algorithm, !0, ["deriveBits"])).privateKey; + const subtle = crypto.subtle; + let exportableEpk = ephemeralKey; + if (!exportableEpk.extractable) { + if (typeof subtle.getPublicKey != "function") + throw new TypeError('CryptoKey for "epk" must be extractable'); + exportableEpk = await subtle.getPublicKey(ephemeralKey, []); + } + const { x, y, crv, kty } = await subtle.exportKey("jwk", exportableEpk), direct = mode === "direct-key-agreement", sharedSecret = await ecdhesDeriveKey(key, ephemeralKey, direct ? enc.alg : alg, direct ? enc.cekBits : parseInt(alg.slice(-5, -2), 10), apu, apv), epk = { x, crv, kty }; + if (kty === "EC" && (epk.y = y), parameters = { epk }, providedApu !== void 0 && (parameters.apu = b64u(providedApu)), providedApv !== void 0 && (parameters.apv = b64u(providedApv)), direct) + return [sharedSecret, void 0, parameters]; + key = sharedSecret; + break; + } + case "RSA-OAEP": { + assertCryptoKey(key), checkRsaKey(alg, key, "encrypt"), encryptedKey = new Uint8Array(await crypto.subtle.encrypt("RSA-OAEP", key, cek)); + break; + } + case "PBKDF2": { + const { p2c = 2048, p2s = crypto.getRandomValues(new Uint8Array(16)) } = providedParameters; + key = await deriveKey(p2s, alg, p2c, key), parameters = { p2c, p2s: b64u(p2s) }; + break; + } + case "AES-GCM": { + const iv = providedParameters.iv === void 0 ? crypto.getRandomValues(new Uint8Array(12)) : providedParameters.iv; + if (!(iv instanceof Uint8Array)) + throw new TypeError('"iv" must be an instance of Uint8Array'); + const wrapped = await encrypt(jweEncryption(alg.slice(0, -2)), cek, key, iv, new Uint8Array()); + encryptedKey = wrapped.ciphertext, parameters = { iv: b64u(wrapped.iv), tag: b64u(wrapped.tag) }; + } + } + if (encryptedKey ??= await aeskwWrap(alg.slice(-6), key, cek), !(encryptedKey instanceof Uint8Array) || !encryptedKey.byteLength) + throw new TypeError("JWE key management algorithm did not produce an Encrypted Key"); + return [cek, encryptedKey, parameters]; +} +export { + decryptKeyManagement, + encryptKeyManagement, + validateMaxPBES2Count +}; diff --git a/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/validate.js b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/validate.js new file mode 100644 index 000000000..51b7dfe89 --- /dev/null +++ b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/lib/validate.js @@ -0,0 +1,122 @@ +import { JOSENotSupported, JWSInvalid } from "../util/errors.js"; +import { decode } from "../util/base64url.js"; +import { encode, strictDecoder } from "./buffer_utils.js"; +function assertUint8Array(input, label) { + if (!(input instanceof Uint8Array)) + throw new TypeError(`${label} must be an instance of Uint8Array`); +} +function isObject(input) { + if (typeof input != "object" || input === null || Object.prototype.toString.call(input) !== "[object Object]") + return !1; + const prototype = Object.getPrototypeOf(input); + return prototype === null || Object.getPrototypeOf(prototype) === null; +} +function isJwkSet(input) { + return isObject(input) && Array.isArray(input.keys) && Array.from(input.keys).every(isObject); +} +function isDisjoint(...headers) { + const parameters = /* @__PURE__ */ new Set(); + for (const header of headers) + if (header) + for (const parameter of Object.keys(header)) { + if (parameters.has(parameter)) + return !1; + parameters.add(parameter); + } + return !0; +} +function assertNotSet(value, name) { + if (value !== void 0) + throw new TypeError(`${name} can only be called once`); +} +function decodeBase64url(value, label, ErrorClass) { + try { + return decode(value); + } catch { + throw new ErrorClass(`Failed to base64url decode the ${label}`); + } +} +function encodeBase64url(value, label, ErrorClass) { + try { + return encode(value); + } catch { + throw new ErrorClass(`The ${label} is not a valid base64url string`); + } +} +function parseJoseHeader(b64, ErrorClass, message) { + let parsed; + try { + parsed = JSON.parse(strictDecoder.decode(decode(b64))); + } catch { + throw new ErrorClass(message); + } + if (!isObject(parsed)) + throw new ErrorClass(message); + return parsed; +} +const JWS_RECOGNIZED = { __proto__: null, b64: !0 }, JWE_RECOGNIZED = { __proto__: null }; +function validateAlgorithms(option, algorithms) { + if (algorithms !== void 0 && (!Array.isArray(algorithms) || algorithms.some((s) => typeof s != "string"))) + throw new TypeError(`"${option}" option must be an array of strings`); + return algorithms === void 0 ? void 0 : new Set(algorithms); +} +function validateCritDuplicates(Err, protectedHeader) { + const { crit } = protectedHeader ?? {}; + if (Array.isArray(crit) && new Set(crit).size !== crit.length) + throw new Err('"crit" (Critical) Header Parameter MUST NOT contain duplicate values'); +} +function validateCrit(Err, recognizedDefault, recognizedOption, protectedHeader, joseHeader) { + if (joseHeader.crit !== void 0 && protectedHeader?.crit === void 0) + throw new Err('"crit" (Critical) Header Parameter MUST be integrity protected'); + if (!protectedHeader || protectedHeader.crit === void 0) + return []; + if (!Array.isArray(protectedHeader.crit) || protectedHeader.crit.length === 0 || protectedHeader.crit.some((input) => typeof input != "string" || input.length === 0)) + throw new Err('"crit" (Critical) Header Parameter MUST be an array of non-empty strings when present'); + const recognized = recognizedOption === void 0 ? recognizedDefault : { __proto__: null, ...recognizedOption, ...recognizedDefault }; + for (const parameter of protectedHeader.crit) { + if (!(parameter in recognized)) + throw new JOSENotSupported(`Extension Header Parameter "${parameter}" is not recognized`); + if (!Object.hasOwn(joseHeader, parameter) || joseHeader[parameter] === void 0) + throw new Err(`Extension Header Parameter "${parameter}" is missing`); + if (recognized[parameter] && (!Object.hasOwn(protectedHeader, parameter) || protectedHeader[parameter] === void 0)) + throw new Err(`Extension Header Parameter "${parameter}" MUST be integrity protected`); + } + return protectedHeader.crit; +} +function validateB64(protectedHeader, extensions) { + if (extensions.includes("b64")) { + const b64 = protectedHeader.b64; + if (typeof b64 != "boolean") + throw new JWSInvalid('The "b64" (base64url-encode payload) Header Parameter must be a boolean'); + return b64; + } + return !0; +} +function serializeJoseHeader(Err, header) { + let serialized, parsed; + try { + serialized = JSON.stringify(header), parsed = JSON.parse(serialized); + } catch (cause) { + throw new Err("JOSE Header is not valid JSON", { cause }); + } + if (!isObject(parsed)) + throw new Err("JOSE Header is not a JSON object"); + return [parsed, serialized]; +} +export { + JWE_RECOGNIZED, + JWS_RECOGNIZED, + assertNotSet, + assertUint8Array, + decodeBase64url, + encodeBase64url, + isDisjoint, + isJwkSet, + isObject, + parseJoseHeader, + serializeJoseHeader, + validateAlgorithms, + validateB64, + validateCrit, + validateCritDuplicates +}; diff --git a/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/util/base64url.js b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/util/base64url.js new file mode 100644 index 000000000..4447baa6d --- /dev/null +++ b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/util/base64url.js @@ -0,0 +1,16 @@ +import { encoder, decoder, encodeBase64, decodeBase64 } from "../lib/buffer_utils.js"; +const invalid = "The input to be decoded is not correctly encoded."; +function decode(input) { + try { + return decodeBase64(typeof input == "string" ? input : decoder.decode(input), !0); + } catch (cause) { + throw new TypeError(invalid, { cause }); + } +} +function encode(input) { + return encodeBase64(typeof input == "string" ? encoder.encode(input) : input, !0); +} +export { + decode, + encode +}; diff --git a/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/util/errors.js b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/util/errors.js new file mode 100644 index 000000000..b7d579f51 --- /dev/null +++ b/tests/corpus/7132-jose-pbes2/node_modules/jose/dist/webapi/util/errors.js @@ -0,0 +1,109 @@ +class JOSEError extends Error { + static code = "ERR_JOSE_GENERIC"; + code = "ERR_JOSE_GENERIC"; + constructor(message, options) { + super(message, options), this.name = this.constructor.name, Error.captureStackTrace?.(this, this.constructor); + } +} +class JWTClaimValidationFailed extends JOSEError { + static code = "ERR_JWT_CLAIM_VALIDATION_FAILED"; + code = "ERR_JWT_CLAIM_VALIDATION_FAILED"; + claim; + reason; + payload; + constructor(message, payload, claim = "unspecified", reason = "unspecified") { + super(message, { cause: { claim, reason, payload } }), this.claim = claim, this.reason = reason, this.payload = payload; + } +} +class JWTExpired extends JOSEError { + static code = "ERR_JWT_EXPIRED"; + code = "ERR_JWT_EXPIRED"; + claim; + reason; + payload; + constructor(message, payload, claim = "unspecified", reason = "unspecified") { + super(message, { cause: { claim, reason, payload } }), this.claim = claim, this.reason = reason, this.payload = payload; + } +} +class JOSEAlgNotAllowed extends JOSEError { + static code = "ERR_JOSE_ALG_NOT_ALLOWED"; + code = "ERR_JOSE_ALG_NOT_ALLOWED"; +} +class JOSENotSupported extends JOSEError { + static code = "ERR_JOSE_NOT_SUPPORTED"; + code = "ERR_JOSE_NOT_SUPPORTED"; +} +class JWEDecryptionFailed extends JOSEError { + static code = "ERR_JWE_DECRYPTION_FAILED"; + code = "ERR_JWE_DECRYPTION_FAILED"; + constructor(message = "decryption operation failed", options) { + super(message, options); + } +} +class JWEInvalid extends JOSEError { + static code = "ERR_JWE_INVALID"; + code = "ERR_JWE_INVALID"; +} +class JWSInvalid extends JOSEError { + static code = "ERR_JWS_INVALID"; + code = "ERR_JWS_INVALID"; +} +class JWTInvalid extends JOSEError { + static code = "ERR_JWT_INVALID"; + code = "ERR_JWT_INVALID"; +} +class JWKInvalid extends JOSEError { + static code = "ERR_JWK_INVALID"; + code = "ERR_JWK_INVALID"; +} +class JWKSInvalid extends JOSEError { + static code = "ERR_JWKS_INVALID"; + code = "ERR_JWKS_INVALID"; +} +class JWKSNoMatchingKey extends JOSEError { + static code = "ERR_JWKS_NO_MATCHING_KEY"; + code = "ERR_JWKS_NO_MATCHING_KEY"; + constructor(message = "no applicable key found in the JSON Web Key Set", options) { + super(message, options); + } +} +class JWKSMultipleMatchingKeys extends JOSEError { + [Symbol.asyncIterator] = async function* () { + }; + static code = "ERR_JWKS_MULTIPLE_MATCHING_KEYS"; + code = "ERR_JWKS_MULTIPLE_MATCHING_KEYS"; + constructor(message = "multiple matching keys found in the JSON Web Key Set", options) { + super(message, options); + } +} +class JWKSTimeout extends JOSEError { + static code = "ERR_JWKS_TIMEOUT"; + code = "ERR_JWKS_TIMEOUT"; + constructor(message = "request timed out", options) { + super(message, options); + } +} +class JWSSignatureVerificationFailed extends JOSEError { + static code = "ERR_JWS_SIGNATURE_VERIFICATION_FAILED"; + code = "ERR_JWS_SIGNATURE_VERIFICATION_FAILED"; + constructor(message = "signature verification failed", options) { + super(message, options); + } +} +export { + JOSEAlgNotAllowed, + JOSEError, + JOSENotSupported, + JWEDecryptionFailed, + JWEInvalid, + JWKInvalid, + JWKSInvalid, + JWKSMultipleMatchingKeys, + JWKSNoMatchingKey, + JWKSTimeout, + JWSInvalid, + JWSSignatureVerificationFailed, + JWTClaimValidationFailed, + JWTExpired, + JWTInvalid +}; diff --git a/tests/corpus/7132-jose-pbes2/node_modules/jose/package.json b/tests/corpus/7132-jose-pbes2/node_modules/jose/package.json new file mode 100644 index 000000000..bcb353430 --- /dev/null +++ b/tests/corpus/7132-jose-pbes2/node_modules/jose/package.json @@ -0,0 +1,17 @@ +{ + "name": "jose", + "version": "6.2.12", + "license": "MIT", + "type": "module", + "sideEffects": false, + "exports": { + "./jwt/*": { + "types": "./dist/types/jwt/*.d.ts", + "default": "./dist/webapi/jwt/*.js" + }, + "./errors": { + "types": "./dist/types/util/errors.d.ts", + "default": "./dist/webapi/util/errors.js" + } + } +} diff --git a/tests/fixtures/node-types/fenced.ts b/tests/fixtures/node-types/fenced.ts index 274d57272..27c212daa 100644 --- a/tests/fixtures/node-types/fenced.ts +++ b/tests/fixtures/node-types/fenced.ts @@ -101,11 +101,11 @@ createECDH("sect163k1"); createECDH("prime256v1").computeSecret(Buffer.alloc(65), "hex"); /* WebCrypto beyond the secret-key slice: @types/node declares the whole * SubtleCrypto surface, and the methods outside the slice, such as - * wrapKey, fence by name. */ -async function wrapWithWebCrypto(key: import("node:crypto").webcrypto.CryptoKey): Promise { - await crypto.subtle.wrapKey("raw", key, key, "AES-KW"); + * getPublicKey, fence by name. */ +async function publicKeyWithWebCrypto(key: import("node:crypto").webcrypto.CryptoKey): Promise { + await crypto.subtle.getPublicKey(key, ["verify"]); } -void wrapWithWebCrypto; +void publicKeyWithWebCrypto; /* Node's navigator global: typeof navigator and navigator.userAgent * compile; the other members fence by name. */ const cores = navigator.hardwareConcurrency; diff --git a/tests/harness/__snapshots__/node-types-fenced.txt b/tests/harness/__snapshots__/node-types-fenced.txt index 3198db366..ce43c5085 100644 --- a/tests/harness/__snapshots__/node-types-fenced.txt +++ b/tests/harness/__snapshots__/node-types-fenced.txt @@ -223,14 +223,14 @@ fenced.ts:101:1 - error SC2020: 'ECDH.computeSecret(key, encoding) with a Buffer hint: Node reads the second argument as the key's input encoding and answers a Buffer; pass the output encoding third: computeSecret(key, undefined, encoding) -fenced.ts:106:9 - error SC2020: 'crypto.subtle.wrapKey' is part of the standard library types but has no scriptc lowering yet +fenced.ts:106:9 - error SC2020: 'crypto.subtle.getPublicKey' is part of the standard library types but has no scriptc lowering yet - 105 | async function wrapWithWebCrypto(key: import("node:crypto").webcrypto.CryptoKey): Promise { - 106 | await crypto.subtle.wrapKey("raw", key, key, "AES-KW"); - | ^~~~~~~~~~~~~~~~~~~~~ + 105 | async function publicKeyWithWebCrypto(key: import("node:crypto").webcrypto.CryptoKey): Promise { + 106 | await crypto.subtle.getPublicKey(key, ["verify"]); + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ 107 | } - hint: the native WebCrypto surface is crypto.subtle's importKey, generateKey and exportKey for HMAC and AES keys (importKey also for PBKDF2 and HKDF keys), encrypt and decrypt with AES-GCM, AES-CBC or AES-CTR, deriveBits and deriveKey with PBKDF2 or HKDF, sign and verify with HMAC, and digest with SHA-1, SHA-256, SHA-384 or SHA-512, each called directly on crypto.subtle + hint: the native WebCrypto surface is crypto.subtle's importKey, generateKey and exportKey for HMAC and AES keys (importKey also for PBKDF2 and HKDF keys), encrypt and decrypt with AES-GCM, AES-CBC or AES-CTR, wrapKey and unwrapKey with AES-KW or those ciphers, deriveBits and deriveKey with PBKDF2 or HKDF, sign and verify with HMAC, and digest with SHA-1, SHA-256, SHA-384 or SHA-512, each called directly on crypto.subtle fenced.ts:111:15 - error SC2020: 'navigator.hardwareConcurrency' is typed by @types/node but has no scriptc lowering yet diff --git a/tests/harness/__snapshots__/webcrypto-refusals.ts.txt b/tests/harness/__snapshots__/webcrypto-refusals.ts.txt index e46099f69..147afb0d3 100644 --- a/tests/harness/__snapshots__/webcrypto-refusals.ts.txt +++ b/tests/harness/__snapshots__/webcrypto-refusals.ts.txt @@ -5,7 +5,7 @@ webcrypto-refusals.ts:6:16 - error SC2020: 'crypto.subtle as a value' is part of | ^~~~~~~~~~~~~ 7 | console.log(typeof subtle); - hint: the native WebCrypto surface is crypto.subtle's importKey, generateKey and exportKey for HMAC and AES keys (importKey also for PBKDF2 and HKDF keys), encrypt and decrypt with AES-GCM, AES-CBC or AES-CTR, deriveBits and deriveKey with PBKDF2 or HKDF, sign and verify with HMAC, and digest with SHA-1, SHA-256, SHA-384 or SHA-512, each called directly on crypto.subtle + hint: the native WebCrypto surface is crypto.subtle's importKey, generateKey and exportKey for HMAC and AES keys (importKey also for PBKDF2 and HKDF keys), encrypt and decrypt with AES-GCM, AES-CBC or AES-CTR, wrapKey and unwrapKey with AES-KW or those ciphers, deriveBits and deriveKey with PBKDF2 or HKDF, sign and verify with HMAC, and digest with SHA-1, SHA-256, SHA-384 or SHA-512, each called directly on crypto.subtle webcrypto-refusals.ts:9:20 - error SC2020: 'crypto.subtle.sign as a value' is part of the standard library types but has no scriptc lowering yet @@ -14,4 +14,4 @@ webcrypto-refusals.ts:9:20 - error SC2020: 'crypto.subtle.sign as a value' is pa | ^~~~~~~~~~~~~~~~~~ 10 | - hint: the native WebCrypto surface is crypto.subtle's importKey, generateKey and exportKey for HMAC and AES keys (importKey also for PBKDF2 and HKDF keys), encrypt and decrypt with AES-GCM, AES-CBC or AES-CTR, deriveBits and deriveKey with PBKDF2 or HKDF, sign and verify with HMAC, and digest with SHA-1, SHA-256, SHA-384 or SHA-512, each called directly on crypto.subtle \ No newline at end of file + hint: the native WebCrypto surface is crypto.subtle's importKey, generateKey and exportKey for HMAC and AES keys (importKey also for PBKDF2 and HKDF keys), encrypt and decrypt with AES-GCM, AES-CBC or AES-CTR, wrapKey and unwrapKey with AES-KW or those ciphers, deriveBits and deriveKey with PBKDF2 or HKDF, sign and verify with HMAC, and digest with SHA-1, SHA-256, SHA-384 or SHA-512, each called directly on crypto.subtle \ No newline at end of file diff --git a/tests/harness/corpus-costs/7130-webcrypto-wrap-key.ts.json b/tests/harness/corpus-costs/7130-webcrypto-wrap-key.ts.json new file mode 100644 index 000000000..56b3458ca --- /dev/null +++ b/tests/harness/corpus-costs/7130-webcrypto-wrap-key.ts.json @@ -0,0 +1 @@ +{ "plain": 5334, "san": 8182 } diff --git a/tests/harness/corpus-costs/7131-webcrypto-wrap-key-errors.mjs.json b/tests/harness/corpus-costs/7131-webcrypto-wrap-key-errors.mjs.json new file mode 100644 index 000000000..5cb958a53 --- /dev/null +++ b/tests/harness/corpus-costs/7131-webcrypto-wrap-key-errors.mjs.json @@ -0,0 +1 @@ +{ "plain": 5838, "san": 8032 } diff --git a/tests/harness/corpus-costs/7132-jose-pbes2/main.mjs.json b/tests/harness/corpus-costs/7132-jose-pbes2/main.mjs.json new file mode 100644 index 000000000..3ad38d83d --- /dev/null +++ b/tests/harness/corpus-costs/7132-jose-pbes2/main.mjs.json @@ -0,0 +1 @@ +{ "plain": 30866, "san": 122276 } diff --git a/tests/harness/errors.test.ts b/tests/harness/errors.test.ts index 00ee40043..d321b9a00 100644 --- a/tests/harness/errors.test.ts +++ b/tests/harness/errors.test.ts @@ -1666,6 +1666,7 @@ await attempt("ed25519 key", () => crypto.subtle.generateKey({ name: "Ed25519" } const aes = await crypto.subtle.generateKey({ name: "AES-GCM", length: 128 }, false, ["encrypt"]); await attempt("aes-ocb", () => crypto.subtle.encrypt({ name: "AES-OCB", iv: new Uint8Array(12) }, aes, bytes)); await attempt("ecdh bits", () => crypto.subtle.deriveBits({ name: "ECDH" }, key, 256)); +await attempt("rsa-oaep wrap", () => crypto.subtle.wrapKey("raw", key, key, { name: "RSA-OAEP" })); `, "mjs", ); @@ -1678,23 +1679,24 @@ await attempt("ecdh bits", () => crypto.subtle.deriveBits({ name: "ECDH" }, key, "sha3 hmac Error SC2020 crypto.subtle.importKey with the SHA3-256 algorithm is not supported yet\n" + "ed25519 key Error SC2020 crypto.subtle.generateKey with the Ed25519 algorithm is not supported yet\n" + "aes-ocb Error SC2020 crypto.subtle.encrypt with the AES-OCB algorithm is not supported yet\n" + - "ecdh bits Error SC2020 crypto.subtle.deriveBits with the ECDH algorithm is not supported yet\n", + "ecdh bits Error SC2020 crypto.subtle.deriveBits with the ECDH algorithm is not supported yet\n" + + "rsa-oaep wrap Error SC2020 crypto.subtle.wrapKey with the RSA-OAEP algorithm is not supported yet\n", ); }); test("a method outside the slice is a named fence where it runs", async () => { const r = await compileAndRun( - "webcrypto-wrap-key", + "webcrypto-get-public-key", `console.log("before"); -const key = await crypto.subtle.generateKey({ name: "AES-KW", length: 128 }, true, ["wrapKey"]); -await crypto.subtle.wrapKey("raw", key, key, "AES-KW"); +const key = await crypto.subtle.generateKey({ name: "HMAC", hash: "SHA-256" }, true, ["sign"]); +await crypto.subtle.getPublicKey(key, ["verify"]); `, "mjs", ); expect(r.exitCode).toBe(1); expect(r.stdout).toBe("before\n"); expect(r.stderr).toMatch( - /^Uncaught Error: 'crypto\.subtle\.wrapKey' is part of the standard library types but has no scriptc lowering yet.*\n$/, + /^Uncaught Error: 'crypto\.subtle\.getPublicKey' is part of the standard library types but has no scriptc lowering yet.*\n$/, ); }); }); From c14e2607c55bafdc05e3ff7f961fb8a57778ad20 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 05:52:31 -0500 Subject: [PATCH 065/102] Address #1785 review: Buffer|string data adapter and objectMode chunk handling --- .../src/backend/llvm/expr-stream-callbacks.ts | 12 ++++++++++++ packages/runtime/src/scr_stream.c | 9 +++++++++ tests/corpus/7241-objectmode-streams.mjs | 7 +++++++ 3 files changed, 28 insertions(+) diff --git a/packages/compiler/src/backend/llvm/expr-stream-callbacks.ts b/packages/compiler/src/backend/llvm/expr-stream-callbacks.ts index 17507e128..0570d0ea7 100644 --- a/packages/compiler/src/backend/llvm/expr-stream-callbacks.ts +++ b/packages/compiler/src/backend/llvm/expr-stream-callbacks.ts @@ -126,6 +126,9 @@ export function streamDataAdapter( host.declare(`declare void @scr_bytes_release_v(ptr)`); host.declare(`declare ptr @scr_str_retain_v(ptr)`); host.declare(`declare void @scr_str_release_v(ptr)`); + host.declare(`declare void @scr_throw_error_msg(i32, ptr, ${host.sizeType})`); + const unionMsg = + "a 'data' listener declaring a Buffer | string chunk received an object-mode value that is neither (declare the chunk's type)"; d.push( ` %uslot = alloca ptr`, ` %isb = icmp ne ptr %a0, null`, @@ -136,6 +139,15 @@ export function streamDataAdapter( ` store ptr %ub, ptr %uslot`, ` br label %go`, `str:`, + // an object-mode value that is neither: the catchable error the + // one-type adapters throw + ` %nos = icmp eq ptr %a1, null`, + ` br i1 %nos, label %bad, label %strok`, + `bad:`, + ` call void @scr_throw_error_msg(i32 1, ptr ${host.cstr(unionMsg)}, ${host.sizeType} ${Buffer.byteLength(unionMsg, "utf8")})`, + ` call void @scr_closure_release(ptr %orig)`, + ` ret void`, + `strok:`, ` %rs = call ptr @scr_str_retain_v(ptr %a1)`, ` %us = call ptr @scr_union_new_ref(i32 ${strTag}, ptr %rs, ptr @scr_str_retain_v, ptr @scr_str_release_v, ptr null)`, ` store ptr %us, ptr %uslot`, diff --git a/packages/runtime/src/scr_stream.c b/packages/runtime/src/scr_stream.c index 0c17c8840..be5ccb910 100644 --- a/packages/runtime/src/scr_stream.c +++ b/packages/runtime/src/scr_stream.c @@ -5637,6 +5637,8 @@ bool scr_stream_push_str(ScrStream *s, ScrStr *str) { /* push(chunk, encoding) with an explicit non-utf8 literal: the per-call * encoding overrides the stream's default. Borrows both strings. */ bool scr_stream_push_str_enc(ScrStream *s, ScrStr *str, ScrStr *enc) { + /* object mode: the string is the chunk and the encoding is not used */ + if (s->st->has_r && s->st->r.object_entries) return scr_stream_push_str(s, str); ScrBytes *b = scr_stream_buffer(scr_bytes_from_str(str, enc)); bool ret = scr_stream_add_chunk(s, b, false); scr_bytes_release(b); @@ -5702,6 +5704,13 @@ void scr_stream_unshift(ScrStream *s, ScrBytes *chunk) { } void scr_stream_unshift_str(ScrStream *s, ScrStr *str) { + if (s->st->has_r && s->st->r.object_entries) { + /* object mode: the string itself goes to the front */ + ScrDyn *v = scr_dyn_new_str(str); + scr_stream_unshift_dyn(s, v); + scr_dyn_release(v); + return; + } ScrBytes *b = scr_bytes_new(SCR_BYTES_U8, (double)str->len); memcpy(b->data, str->data, str->len); if (!str->ascii) scr_wtf8_to_utf8((char *)b->data, str->len); diff --git a/tests/corpus/7241-objectmode-streams.mjs b/tests/corpus/7241-objectmode-streams.mjs index 334273c00..6101930df 100644 --- a/tests/corpus/7241-objectmode-streams.mjs +++ b/tests/corpus/7241-objectmode-streams.mjs @@ -100,6 +100,13 @@ function unshiftFront() { r.unshift({ id: 0 }); r.on("data", (v) => console.log("after unshift:", show(v))); r.on("end", () => console.log("read end")); + // strings stay strings on an object-mode side, whatever the encoding + const strings = new Readable({ objectMode: true, read() {} }); + strings.push("b"); + strings.unshift("a"); + strings.push("6869", "hex"); + strings.push(null); + strings.on("data", (v) => console.log("string entry:", show(v))); } function piped() { From 3cefd421a132f1d1502e45405bf7e11981fb4286 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 05:58:32 -0500 Subject: [PATCH 066/102] Fence requestCert beside a secureContext and free failed TLSSockets new tls.TLSSocket(socket, { isServer: true, secureContext, requestCert: true }) skipped the options walk that refuses requestCert, so the server asked for no client certificate and accepted every client, even with rejectUnauthorized: true. With a secureContext, Node still reads the socket's own options, so a truthy requestCert, SNICallback and ALPNCallback now throw the fence there too. A TLS socket's transport kept its 'secure' and 'session' listeners until the socket was freed. A handshake that fails never fires 'secure', so a listener that captures the socket kept the socket and its TLS state alive after it closed. The transport now drops those listeners when the socket settles, and ignores listeners added after that. --- .../7094-tls-socket-failed-handshakes.ts.json | 6 ++ packages/runtime/src/scr_net.c | 1 + packages/runtime/src/scr_net.h | 3 + packages/runtime/src/scr_tls.c | 49 ++++++++++++- .../7094-tls-socket-failed-handshakes.ts | 49 +++++++++++++ .../7094-tls-socket-failed-handshakes.ts.json | 1 + tests/harness/errors.test.ts | 45 ++++++++++++ tests/harness/tls-socket-leaks.test.ts | 68 +++++++++++++++++++ 8 files changed, 220 insertions(+), 2 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7094-tls-socket-failed-handshakes.ts.json create mode 100644 tests/corpus/7094-tls-socket-failed-handshakes.ts create mode 100644 tests/harness/corpus-costs/7094-tls-socket-failed-handshakes.ts.json create mode 100644 tests/harness/tls-socket-leaks.test.ts diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7094-tls-socket-failed-handshakes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7094-tls-socket-failed-handshakes.ts.json new file mode 100644 index 000000000..8fa524155 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7094-tls-socket-failed-handshakes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7094-tls-socket-failed-handshakes.ts" + ], + "diags": [] +} diff --git a/packages/runtime/src/scr_net.c b/packages/runtime/src/scr_net.c index 8f9a68424..29a4af393 100644 --- a/packages/runtime/src/scr_net.c +++ b/packages/runtime/src/scr_net.c @@ -5354,6 +5354,7 @@ static bool scr_net_sock_settle(ScrNetSocket *sock) { scr_net_ls_drop(&sock->wcb_ls); scr_net_ls_drop(&sock->ready_ls); scr_net_ls_drop(&sock->lookup_ls); + if (sock->tops && sock->tops->settle) sock->tops->settle(sock->tctx); if (sock->pipe_dst) { scr_net_sock_release(sock->pipe_dst); sock->pipe_dst = NULL; diff --git a/packages/runtime/src/scr_net.h b/packages/runtime/src/scr_net.h index 8f26bbf4d..ffa9b2f72 100644 --- a/packages/runtime/src/scr_net.h +++ b/packages/runtime/src/scr_net.h @@ -354,6 +354,9 @@ typedef struct ScrNetTransportOps { /* nullable: runs after the established socket's 'connect' listeners * (the TLS 'secure' event, which Node emits after secureConnect) */ void (*after_established)(void *tctx); + /* nullable: runs when the closed socket settles, after its own + * listeners drop; the transport drops the listeners it holds */ + void (*settle)(void *tctx); } ScrNetTransportOps; void scr_net_sock_set_transport(ScrNetSocket *s, const ScrNetTransportOps *ops, void *tctx); /* new tls.TLSSocket(socket) and tls.connect({ socket }): a fresh socket diff --git a/packages/runtime/src/scr_tls.c b/packages/runtime/src/scr_tls.c index 6fa1f169d..e7436ab69 100644 --- a/packages/runtime/src/scr_tls.c +++ b/packages/runtime/src/scr_tls.c @@ -664,6 +664,7 @@ typedef struct ScrTlsSock { size_t head_len; /* the 'secure' event's listeners */ ScrNetLs secure_ls; + bool settled; /* the socket closed: listeners added later never fire */ } ScrTlsSock; /* checkServerIdentity for an IP literal: the address must be one of the @@ -1237,6 +1238,17 @@ static void scr_tls_after_established(void *tctx) { scr_net_ls_drop(&t->secure_ls); } +/* The closed socket settles: its 'secure' and 'session' listeners can no + * longer fire, and a listener that captures the socket would otherwise + * keep it, and this transport, alive (a handshake that fails never fires + * 'secure'). */ +static void scr_tls_settle(void *tctx) { + ScrTlsSock *t = (ScrTlsSock *)tctx; + t->settled = true; + scr_net_ls_drop(&t->secure_ls); + scr_net_ls_drop(&t->session_ls); +} + static const ScrNetTransportOps SCR_TLS_OPS = { .xread = scr_tls_xread, .xwrite = scr_tls_xwrite, @@ -1245,6 +1257,7 @@ static const ScrNetTransportOps SCR_TLS_OPS = { .pending = scr_tls_pending, .shutdown_write = scr_tls_shutdown_write, .free = scr_tls_free, + .settle = scr_tls_settle, .after_established = scr_tls_after_established, }; @@ -2202,6 +2215,29 @@ static const char *const SCR_TLS_WRAP_FENCED_OPTIONS[] = { "server", "session", "requestOCSP", "pskCallback", "enableTrace", NULL, }; +/* The socket-level options of a wrap that serves a secureContext, which + * the server-options walk would otherwise check: requestCert (client + * certificates are not modeled), SNICallback and ALPNCallback fence. + * False with the exception pending. */ +static bool scr_tls_wrap_socket_opts_check(const ScrDyn *record, const char *api) { + for (size_t i = 0; record != NULL && i < record->v.obj.len; i++) { + const ScrDynEntry *e = &record->v.obj.entries[i]; + if (e->value->kind == SCR_DYN_UNDEF) continue; + if (strcmp(e->key, "requestCert") == 0) { + if (!scr_tls_dyn_truthy(e->value)) continue; + scr_tls_opt_fence(api, "requestCert", + "client-certificate handshakes are not modeled (SEMANTICS.md divergence 55) — requestCert stays at Node's false default"); + return false; + } + if (strcmp(e->key, "SNICallback") == 0 || strcmp(e->key, "ALPNCallback") == 0) { + scr_tls_opt_fence(api, e->key, + "isServer, cert, key, secureContext, ALPNProtocols, minVersion and maxVersion are the implemented members"); + return false; + } + } + return true; +} + ScrNetSocket *scr_tls_wrap_socket(ScrNetSocket *raw, const ScrDyn *opts /*borrowed*/, ScrSecureCtx *ctx /*borrowed, nullable*/) { static const char api[] = "new tls.TLSSocket"; @@ -2233,12 +2269,17 @@ ScrNetSocket *scr_tls_wrap_socket(ScrNetSocket *raw, const ScrDyn *opts /*borrow return NULL; } /* Node serves a secureContext as it is: the record's cert, key and - * other context options are not read then */ + * other context options are not read then. The socket's own options + * still apply, so the ones without a lowering fence either way: + * requestCert asks for a client certificate this runtime cannot + * verify. */ int min_version = 12, max_version = 13; ScrBytes *cert = NULL, *key = NULL; if (ctx == NULL) { if (!scr_tls_versions_dyn(record, &min_version, &max_version)) return NULL; if (!scr_tls_srv_opts_walk_ex(record, api, &cert, &key, true)) return NULL; + } else if (!scr_tls_wrap_socket_opts_check(record, api)) { + return NULL; } char **alpn = NULL; const ScrDyn *protocols = record != NULL ? scr_dyn_obj_get(record, "ALPNProtocols", 13) : NULL; @@ -2867,7 +2908,7 @@ void scr_tls_sock_on_secure_connect(ScrNetSocket *s, ScrClosure *cb /*moves*/, b * handshake comes too late, as in Node. */ void scr_tls_sock_on_secure(ScrNetSocket *s, ScrClosure *cb /*moves*/, bool once) { ScrTlsSock *t = scr_tls_sock_of(s); - if (t == NULL || t->established) { + if (t == NULL || t->established || t->settled) { scr_closure_release(cb); return; } @@ -2880,6 +2921,10 @@ void scr_tls_sock_on_session(ScrNetSocket *s, ScrClosure *cb /*moves*/, void *fn scr_closure_release(cb); /* a plain socket never fires it, like Node */ return; } + if (t->settled) { + scr_closure_release(cb); + return; + } scr_net_ls_add(&t->session_ls, cb, fn, once); if (t->established) scr_tls_fire_session(t); /* the ticket already arrived */ } diff --git a/tests/corpus/7094-tls-socket-failed-handshakes.ts b/tests/corpus/7094-tls-socket-failed-handshakes.ts new file mode 100644 index 000000000..daad49a4e --- /dev/null +++ b/tests/corpus/7094-tls-socket-failed-handshakes.ts @@ -0,0 +1,49 @@ +// A TLSSocket whose handshake never completes still closes and releases +// its listeners, including a 'secure' listener that holds the socket: one +// peer closes before sending anything and the next sends a plain HTTP +// request. +import { readFileSync } from "node:fs"; +import * as net from "node:net"; +import * as tls from "node:tls"; + +const certs = "tests/fixtures/server/certs"; +const cert = readFileSync(`${certs}/localhost.pem`); +const key = readFileSync(`${certs}/localhost-key.pem`); +const context = tls.createSecureContext({ cert, key }); + +const peers: ((port: number) => void)[] = [ + (port) => { + const quiet = net.connect(port, "127.0.0.1", () => quiet.end()); + }, + (port) => { + const plain = net.connect(port, "127.0.0.1", () => plain.write("GET / HTTP/1.1\r\nHost: x\r\n\r\n")); + plain.on("error", () => {}); + plain.resume(); + }, + (port) => { + const quiet = net.connect(port, "127.0.0.1", () => quiet.destroy()); + }, +]; +let served = 0; +const server = net.createServer((raw) => { + served++; + const secure = + served === 3 + ? new tls.TLSSocket(raw, { isServer: true, secureContext: context }) + : new tls.TLSSocket(raw, { isServer: true, cert, key }); + secure.on("secure", () => console.log("secure", served, secure.alpnProtocol)); + secure.on("error", (err: NodeJS.ErrnoException) => console.log("error", served, err.code)); + secure.on("close", (hadError: boolean) => { + console.log("close", served, hadError); + next(); + }); +}); +function next(): void { + const peer = peers.shift(); + if (peer === undefined) { + server.close(() => console.log("server closed")); + return; + } + peer((server.address() as net.AddressInfo).port); +} +server.listen(0, "127.0.0.1", next); diff --git a/tests/harness/corpus-costs/7094-tls-socket-failed-handshakes.ts.json b/tests/harness/corpus-costs/7094-tls-socket-failed-handshakes.ts.json new file mode 100644 index 000000000..ec5193be7 --- /dev/null +++ b/tests/harness/corpus-costs/7094-tls-socket-failed-handshakes.ts.json @@ -0,0 +1 @@ +{ "plain": 2618, "san": 3905 } diff --git a/tests/harness/errors.test.ts b/tests/harness/errors.test.ts index 96949201d..31f2b6fd9 100644 --- a/tests/harness/errors.test.ts +++ b/tests/harness/errors.test.ts @@ -905,6 +905,51 @@ listener.listen(0, () => { }); }); +// With a secureContext, the TLSSocket's own options still apply: a truthy +// requestCert, which asks for client certificates this runtime does not +// verify, and SNICallback throw the fence instead of being dropped. +describe("tls.TLSSocket socket options beside a secureContext", () => { + test("requestCert and SNICallback throw the fence", async () => { + const r = await compileAndRun( + "tls-socket-context-fences", + `import { readFileSync } from "node:fs"; +import * as net from "node:net"; +import * as tls from "node:tls"; +const certs = "tests/fixtures/server/certs"; +const cert = readFileSync(\`\${certs}/localhost.pem\`); +const key = readFileSync(\`\${certs}/localhost-key.pem\`); +const context = tls.createSecureContext({ cert, key }); +function report(label: string, run: () => void): void { + try { + run(); + console.log(label, "no error"); + } catch (error) { + console.log(label, (error as Error).message); + } +} +const listener = net.createServer((raw) => { + report("requestCert", () => new tls.TLSSocket(raw, { isServer: true, secureContext: context, requestCert: true, rejectUnauthorized: true })); + report("SNICallback", () => new tls.TLSSocket(raw, { isServer: true, secureContext: context, SNICallback: (name: string, cb: (err: Error | null, ctx?: tls.SecureContext) => void) => cb(null, context) })); + report("requestCert false", () => new tls.TLSSocket(raw, { isServer: true, secureContext: context, requestCert: false, rejectUnauthorized: true }).destroy()); + listener.close(); +}); +listener.listen(0, () => { + const c = net.connect((listener.address() as net.AddressInfo).port, "localhost"); + c.on("error", () => {}); + c.on("close", () => console.log("client closed")); +}); +`, + ); + expect(r.stderr).toBe(""); + expect(r.stdout).toBe( + "requestCert new tls.TLSSocket option 'requestCert' has no static lowering — client-certificate handshakes are not modeled (SEMANTICS.md divergence 55) — requestCert stays at Node's false default\n" + + "SNICallback new tls.TLSSocket option 'SNICallback' has no static lowering — isServer, cert, key, secureContext, ALPNProtocols, minVersion and maxVersion are the implemented members\n" + + "requestCert false no error\n" + + "client closed\n", + ); + }); +}); + // A curve Node lists in crypto.getCurves() but the runtime does not // implement throws a coded SC2020 error naming the curve when the name is // computed; literal names are refused at compile time (node-types-fenced). diff --git a/tests/harness/tls-socket-leaks.test.ts b/tests/harness/tls-socket-leaks.test.ts new file mode 100644 index 000000000..64edfac25 --- /dev/null +++ b/tests/harness/tls-socket-leaks.test.ts @@ -0,0 +1,68 @@ +/* new tls.TLSSocket under LeakSanitizer. A TLS socket's transport holds + * its 'secure' and 'session' listeners, which often capture the socket; + * every socket that closes, including one whose handshake fails, must drop + * them. The sanitized lanes otherwise run with detect_leaks=0, so this runs + * the TLSSocket programs with LeakSanitizer explicitly on. 7094's + * handshakes all fail. Linux only (Apple's ASan has no LeakSanitizer); + * runs in the SCRIPTC_SAN=1 lane. */ +import { execFile } from "node:child_process"; +import { createHash } from "node:crypto"; +import { mkdirSync, readFileSync } from "node:fs"; +import { join } from "node:path"; +import { promisify } from "node:util"; +import { describe, expect, test } from "vitest"; +import { compile } from "@scriptc/compiler"; + +const execFileAsync = promisify(execFile); +const repoRoot = join(import.meta.dirname, "../.."); +const cacheDir = join(repoRoot, "node_modules/.cache/scriptc-tests"); +const sanitize = process.env["SCRIPTC_SAN"] === "1"; + +const programs = [ + "tests/corpus/7087-tls-socket-wrap.ts", + "tests/corpus/7088-tls-socket-connect-tunnel.ts", + "tests/corpus/7094-tls-socket-failed-handshakes.ts", +]; + +describe.skipIf(!sanitize || process.platform !== "linux")( + "tls.TLSSocket under LeakSanitizer", + () => { + test.each(programs)("%s reports no leaks", { timeout: 300_000 }, async (program) => { + const file = join(repoRoot, program); + const key = createHash("sha256") + .update(file) + .update(readFileSync(file)) + .update("san") + .digest("hex") + .slice(0, 16); + const outDir = join(cacheDir, `tls-socket-leaks-${key}`); + mkdirSync(outDir, { recursive: true }); + const result = await compile(file, { + outPath: join(outDir, "program"), + outDir, + sanitize: true, + backend: "llvm", + }); + if (!result.ok) { + throw new Error( + "program failed to compile:\n" + + result.diagnostics.map((d) => `${d.code}: ${d.message}`).join("\n"), + ); + } + const run = await execFileAsync(result.binaryPath, [], { + env: { ...process.env, ASAN_OPTIONS: "detect_leaks=1" }, + maxBuffer: 16 * 1024 * 1024, + }).catch((error: { code?: number; stdout?: string; stderr?: string }) => error); + expect(run.stderr).toBe(""); + expect("code" in run ? run.code : 0).toBe(0); + const expected = await execFileAsync( + process.execPath, + ["--no-warnings", "--experimental-strip-types", file], + { + maxBuffer: 16 * 1024 * 1024, + }, + ); + expect(run.stdout).toBe(expected.stdout); + }); + }, +); From 4e834f8eed49b694be5fb5c1b14ba4f827342a68 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 06:00:28 -0500 Subject: [PATCH 067/102] Read error constructors as values and destructure workerData in JavaScript (reland) --- .../lowering/expressions/object-literals.ts | 25 +++++- .../lowering/expressions/property-access.ts | 34 +++++++- .../src/frontend/lowering/lower-calls.ts | 29 +++++++ .../src/frontend/lowering/lower-stmts.ts | 3 + .../6870-error-constructor-values.js.json | 6 ++ .../6871-worker-data-destructuring.cjs.json | 6 ++ packages/runtime/src/scr_dyn.h | 3 + packages/runtime/src/scr_dyn_invoke.c | 2 + packages/runtime/src/scr_json.c | 79 ++++++++++++++++--- tests/corpus/6870-error-constructor-values.js | 65 +++++++++++++++ .../corpus/6871-worker-data-destructuring.cjs | 30 +++++++ .../6870-error-constructor-values.js.json | 1 + .../6871-worker-data-destructuring.cjs.json | 1 + 13 files changed, 267 insertions(+), 17 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6870-error-constructor-values.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6871-worker-data-destructuring.cjs.json create mode 100644 tests/corpus/6870-error-constructor-values.js create mode 100644 tests/corpus/6871-worker-data-destructuring.cjs create mode 100644 tests/harness/corpus-costs/6870-error-constructor-values.js.json create mode 100644 tests/harness/corpus-costs/6871-worker-data-destructuring.cjs.json diff --git a/packages/compiler/src/frontend/lowering/expressions/object-literals.ts b/packages/compiler/src/frontend/lowering/expressions/object-literals.ts index 015be7914..678b375fe 100644 --- a/packages/compiler/src/frontend/lowering/expressions/object-literals.ts +++ b/packages/compiler/src/frontend/lowering/expressions/object-literals.ts @@ -36,6 +36,7 @@ import { tryLowerExpression } from "./try-lower-expression.js"; import { fenceSymbolFieldCopy } from "../symbol-fields.js"; import { planUnionRetag } from "../union-retag.js"; import { jsHoldsDynObject, runtimeOptionalStorageOperand } from "../lower-exprs.js"; +import { builtinGlobalValue } from "./property-access.js"; /** `{ a: 1, b: "x" }` → recordLit. The record type comes from the * contextual type when tsc has one (annotated declarations, arguments, @@ -394,9 +395,11 @@ export function lowerDynObjectLiteral( const lowerValue = (): IrExpr => ts.isMethodDeclaration(prop) ? lowerer.lowerLambda(prop, true) - : !boxValue && ts.isObjectLiteralExpression(valueExpr) - ? lowerer.lowerExprExpecting(valueExpr, DYN) - : lowerer.lowerExpr(valueExpr as ts.Expression); + : ts.isShorthandPropertyAssignment(prop) && shorthandBuiltinValue(lowerer, prop) + ? shorthandBuiltinValue(lowerer, prop)! + : !boxValue && ts.isObjectLiteralExpression(valueExpr) + ? lowerer.lowerExprExpecting(valueExpr, DYN) + : lowerer.lowerExpr(valueExpr as ts.Expression); raw = fenceClosureProbe(lowerer, valueExpr, undefined, lowerValue) ?? lowerValue(); } catch (err) { // A PURE member read a JS file cannot lower (a namespace object @@ -3157,6 +3160,20 @@ function lowerDeclaredSpreadMerge( /** The value of a shorthand property (`{ x }`): the binding `x` refers to. * The property name's own symbol is the PROPERTY, so resolution goes * through getShorthandAssignmentValueSymbol. */ +/** `{ TypeError }`: a stdlib global in shorthand position reads as the value + * its name reads as elsewhere (the interned constructor or function value), + * or null when the global has no such value. The shorthand's name carries + * the property's symbol, so the identifier path cannot resolve it. */ +function shorthandBuiltinValue( + lowerer: Lowerer, + prop: ts.ShorthandPropertyAssignment, +): IrExpr | null { + const symbol = lowerer.checker.getShorthandAssignmentValueSymbol(prop); + if (!symbol || !lowerer.isStdlibSymbol(symbol)) return null; + const js = isJsSourceFile(ts.getSourceFileOfNode(prop)); + return builtinGlobalValue(ts.symbolName(symbol), locOf(prop.name), js); +} + export function lowerShorthandValue( lowerer: Lowerer, prop: ts.ShorthandPropertyAssignment, @@ -3173,6 +3190,8 @@ export function lowerShorthandValue( const callable = lowerer.lowerBuiltinCallableValue(builtin, loc); if (callable) return callable; } + const builtinValue = shorthandBuiltinValue(lowerer, prop); + if (builtinValue) return builtinValue; if (symbol) { if (lowerer.ctx.selfSymbol === symbol) { return { kind: "selfRef", type: lowerer.ctx.selfType!, loc }; diff --git a/packages/compiler/src/frontend/lowering/expressions/property-access.ts b/packages/compiler/src/frontend/lowering/expressions/property-access.ts index 957dd1ddf..7f3910c15 100644 --- a/packages/compiler/src/frontend/lowering/expressions/property-access.ts +++ b/packages/compiler/src/frontend/lowering/expressions/property-access.ts @@ -4090,10 +4090,26 @@ function lowerStreamObjectProperty( return lowerStreamProperty(lowerer, expr, info); } +/** The error constructors among GLOBAL_CONSTRUCTOR_VALUES. Their statics + * (`Error.stackTraceLimit`, `Error.captureStackTrace`) keep their own + * lowerings, so fenceBuiltinConstructorStaticRead leaves them alone. */ +const ERROR_CONSTRUCTOR_VALUES: ReadonlySet = new Set([ + "Error", + "TypeError", + "RangeError", + "SyntaxError", + "ReferenceError", + "EvalError", + "URIError", + "AggregateError", +]); + /** The builtin constructors JavaScript sources read as real function * values rather than identity tokens: the runtime interns one function per * constructor, and dynamic values answer `.constructor` with the same one, - * so `o.constructor === Object` is an exact identity test. */ + * so `o.constructor === Object` and `err.constructor === TypeError` are + * exact identity tests, and `err.constructor.name` is the constructor's + * name. */ const GLOBAL_CONSTRUCTOR_VALUES: ReadonlySet = new Set([ "Object", "Function", @@ -4104,6 +4120,7 @@ const GLOBAL_CONSTRUCTOR_VALUES: ReadonlySet = new Set([ "Promise", "WeakMap", "WeakSet", + ...ERROR_CONSTRUCTOR_VALUES, ]); /** The builtin global functions JavaScript sources read as interned @@ -4154,8 +4171,18 @@ export function builtinGlobalValue(canonical: string, loc: SrcLoc, js = false): const BUILTIN_VALUE_MEMBERS: ReadonlySet = new Set(["name", "length", "constructor"]); /** The Object statics whose answers for an interned builtin function value - * match Node's (identity, and the empty enumerable own-key lists). */ -const BUILTIN_VALUE_REFLECTION: ReadonlySet = new Set(["is", "keys", "values", "entries"]); + * match Node's (identity, the empty enumerable own-key lists, and + * extensibility: freezing, sealing and preventExtensions are fenced, so the + * values stay extensible). */ +const BUILTIN_VALUE_REFLECTION: ReadonlySet = new Set([ + "is", + "keys", + "values", + "entries", + "isExtensible", + "isFrozen", + "isSealed", +]); /** The value `builtinGlobalValue` gives the stdlib global `expr` read at its * use site: null when the use reads the global's members (they keep their @@ -4246,6 +4273,7 @@ function fenceBuiltinConstructorStaticRead( symbol !== undefined && ts.symbolName(symbol).endsWith("Constructor") && GLOBAL_CONSTRUCTOR_VALUES.has(ts.symbolName(symbol).slice(0, -"Constructor".length)) && + !ERROR_CONSTRUCTOR_VALUES.has(ts.symbolName(symbol).slice(0, -"Constructor".length)) && lowerer.isStdlibSymbol(symbol) ) lowerer.stdlibMemberFence(access); diff --git a/packages/compiler/src/frontend/lowering/lower-calls.ts b/packages/compiler/src/frontend/lowering/lower-calls.ts index bd5068d05..39b7207c0 100644 --- a/packages/compiler/src/frontend/lowering/lower-calls.ts +++ b/packages/compiler/src/frontend/lowering/lower-calls.ts @@ -7439,6 +7439,35 @@ function lowerObjectStaticCall( if (call.questionDotToken || access.questionDotToken) return null; if (!lowerer.isStdlibGlobal(access.expression, "Object")) return null; const member = access.name.text; + // `Object.getOwnPropertyDescriptor(Error, "stackTraceLimit")` (Effect's + // isStackTraceLimitWritable): Error's own writable, enumerable, + // configurable data property holding the current limit. The interned + // Error value models no other statics (builtinGlobalValueAt). + const [first, second] = call.arguments.nodes; + if ( + member === "getOwnPropertyDescriptor" && + call.arguments.nodes.length === 2 && + lowerer.isStdlibGlobal(first!, "Error") && + ts.isStringLiteralLike(second!) && + second.text === "stackTraceLimit" + ) { + const loc = locOf(call); + const dyn = (value: IrExpr): IrExpr => ({ kind: "dynFrom", value, type: DYN, loc }); + const yes = dyn({ kind: "boolLit", value: true, type: BOOL, loc }); + const limit: IrExpr = { kind: "libCall", fn: "error.stackLimitGet", args: [], type: F64, loc }; + return { + kind: "dynObjLit", + fields: [ + { key: { kind: "strLit", value: "value", type: STRING, loc }, value: dyn(limit) }, + ...["writable", "enumerable", "configurable"].map((key) => ({ + key: { kind: "strLit" as const, value: key, type: STRING, loc }, + value: yes, + })), + ], + type: DYN, + loc, + }; + } if ( (member === "getOwnPropertyNames" || member === "getOwnPropertySymbols" || diff --git a/packages/compiler/src/frontend/lowering/lower-stmts.ts b/packages/compiler/src/frontend/lowering/lower-stmts.ts index 687420baf..7c0b4f7ff 100644 --- a/packages/compiler/src/frontend/lowering/lower-stmts.ts +++ b/packages/compiler/src/frontend/lowering/lower-stmts.ts @@ -3889,6 +3889,9 @@ function stdlibGlobalTokenDestructure( if (decl.initializer === undefined || !isJsSourceFile(ts.getSourceFileOfNode(decl))) return null; const globalName = stdlibGlobalNameOf(lowerer, decl.initializer); if (globalName === null) return null; + // `workerData` is a value (the data the worker was started with), not an + // API surface: its members destructure as any untyped value's do. + if (globalName === "workerData") return null; if (!ts.isObjectBindingPattern(decl.name)) { lowerer.unsupported( "SC1031", diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6870-error-constructor-values.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6870-error-constructor-values.js.json new file mode 100644 index 000000000..a2f0e02ea --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6870-error-constructor-values.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6870-error-constructor-values.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6871-worker-data-destructuring.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6871-worker-data-destructuring.cjs.json new file mode 100644 index 000000000..b610a5878 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6871-worker-data-destructuring.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6871-worker-data-destructuring.cjs" + ], + "diags": [] +} diff --git a/packages/runtime/src/scr_dyn.h b/packages/runtime/src/scr_dyn.h index 9220dd843..facf9f2ff 100644 --- a/packages/runtime/src/scr_dyn.h +++ b/packages/runtime/src/scr_dyn.h @@ -764,6 +764,9 @@ ScrDyn *scr_dyn_array_constructor(void); /* The interned builtin constructor `name` (Object, Date, RegExp, Map, Set, * Promise, WeakMap, WeakSet) as a dynamic function value: +1. */ ScrDyn *scr_dyn_global_constructor(const ScrStr *name); +/* The interned function value of an error constructor ("TypeError"), or + * NULL for other names. */ +ScrDyn *scr_dyn_error_constructor(const char *name); /* A builtin global function (setTimeout, setImmediate, process.nextTick, ...) * as an interned dynamic function value: +1. */ ScrDyn *scr_dyn_builtin_function(const ScrStr *name); diff --git a/packages/runtime/src/scr_dyn_invoke.c b/packages/runtime/src/scr_dyn_invoke.c index ec49dd383..80e01b08c 100644 --- a/packages/runtime/src/scr_dyn_invoke.c +++ b/packages/runtime/src/scr_dyn_invoke.c @@ -1923,6 +1923,8 @@ static ScrDyn *dyn_function_constructor(void) { ScrDyn *scr_dyn_global_constructor(const ScrStr *name) { if (strcmp(name->data, dyn_s20) == 0) return dyn_function_constructor(); + ScrDyn *error = scr_dyn_error_constructor(name->data); + if (error) return error; ScrDyn *ctor = dyn_global_ctor(name->data); if (!ctor) scr_trap(dyn_s3); return ctor; diff --git a/packages/runtime/src/scr_json.c b/packages/runtime/src/scr_json.c index 4e21fa397..f610ffdbb 100644 --- a/packages/runtime/src/scr_json.c +++ b/packages/runtime/src/scr_json.c @@ -1814,6 +1814,55 @@ static void scr_builtin_object_prototype_cleanup(void) { scr_dyn_release(prototype); } +/* The error constructors as values (an error's `constructor`, and the + * globals in JavaScript): one interned function per constructor and thread, + * indexed like scr_error_vts, with the constructor's name and length. + * Calling one through the value is not supported yet, as for the other + * interned constructors (scr_dyn_global_constructor). */ +static const char *const scr_error_ctor_names[] = { + "Error", "TypeError", "RangeError", "SyntaxError", NULL, + "ReferenceError", "EvalError", "URIError", "AggregateError", +}; +#define SCR_ERROR_CTORS (sizeof scr_error_ctor_names / sizeof scr_error_ctor_names[0]) +static SCR_TL ScrDyn *scr_error_ctor_values[SCR_ERROR_CTORS]; +static SCR_TL bool scr_error_ctors_registered; + +static void scr_error_ctors_cleanup(void) { + for (size_t i = 0; i < SCR_ERROR_CTORS; i++) { + scr_dyn_release(scr_error_ctor_values[i]); + scr_error_ctor_values[i] = NULL; + } +} + +static ScrDyn *scr_error_ctor_call(ScrClosure *closure, ScrDyn *const *args, size_t argc) { + (void)args; + (void)argc; + char message[128]; + int length = snprintf(message, sizeof message, + "calling the %s constructor through a stored value is not supported yet", + (const char *)closure->fn); + scr_throw_error_msg_code(SCR_ERR_ERROR, message, (size_t)length, "SC2020"); + return NULL; +} + +ScrDyn *scr_dyn_error_constructor(const char *name) { + for (size_t i = 0; i < SCR_ERROR_CTORS; i++) { + if (!scr_error_ctor_names[i] || strcmp(scr_error_ctor_names[i], name) != 0) continue; + if (!scr_error_ctors_registered) { + scr_error_ctors_registered = true; + scr_atexit(scr_error_ctors_cleanup); + } + if (!scr_error_ctor_values[i]) { + uint32_t length = strcmp(name, "AggregateError") == 0 ? 2 : 1; + scr_error_ctor_values[i] = + scr_dyn_new_func(scr_closure_new((void *)scr_error_ctor_names[i], 0), scr_error_ctor_call, length, + "native:constructor", scr_error_ctor_names[i]); + } + return scr_dyn_retain(scr_error_ctor_values[i]); + } + return NULL; +} + ScrDyn *scr_dyn_object_prototype(void) { if (!scr_builtin_object_prototype) { scr_builtin_object_prototype = scr_dyn_alloc(SCR_DYN_OBJ); @@ -7951,6 +8000,17 @@ ScrStr *scr_dyn_to_string(const ScrDyn *d, const ScrStr *enc) { return out; } case SCR_DYN_FUNC: { + /* The interned builtin constructors print with their names, as in Node + * (function Map() { [native code] }); other functions without a source + * text print the anonymous native form. */ + if (d->v.fn.sig && strcmp(d->v.fn.sig, "native:constructor") == 0 && d->v.fn.name) { + ScrJsonBuf b; + scr_jb_init(&b); + scr_jb_puts(&b, "function "); + scr_jb_puts(&b, d->v.fn.name); + scr_jb_puts(&b, "() { [native code] }"); + return scr_jb_finish(&b); + } static const char f[] = "function () { [native code] }"; return scr_str_new(f, sizeof f - 1); } @@ -11943,21 +12003,18 @@ static ScrDyn *scr_dyn_obj_read_receiver(const ScrDyn *d, const char *key, size_ ScrDyn *own = scr_dyn_obj_get(d, key, key_len); if (own) return scr_dyn_retain(own); if (key_len == 11 && memcmp(key, "constructor", 11) == 0) { - static const char *const tokens[] = { - "[builtin Error]", "[builtin TypeError]", - "[builtin RangeError]", "[builtin SyntaxError]", - NULL, "[builtin ReferenceError]", "[builtin EvalError]", "[builtin URIError]", - "[builtin AggregateError]", + /* An error's constructor: the interned function value its global + * reads as (scr_dyn_error_constructor). */ + static const char *const names[] = { + "Error", "TypeError", "RangeError", "SyntaxError", NULL, + "ReferenceError", "EvalError", "URIError", "AggregateError", }; size_t hit = scr_errdyn_find(d, false); const ScrVt *vt = hit == SIZE_MAX ? NULL : scr_errdyn_cache[hit].err->vt; - for (size_t kind = 0; vt && kind < sizeof tokens / sizeof tokens[0]; kind++) { - if (!tokens[kind]) continue; + for (size_t kind = 0; vt && kind < sizeof names / sizeof names[0]; kind++) { + if (!names[kind]) continue; if (vt != &scr_error_vts[kind]) continue; - ScrStr *token = scr_str_new(tokens[kind], strlen(tokens[kind])); - ScrDyn *result = scr_dyn_new_str(token); - scr_str_release(token); - return result; + return scr_dyn_error_constructor(names[kind]); } } return scr_dyn_retain(scr_dyn_undefined()); diff --git a/tests/corpus/6870-error-constructor-values.js b/tests/corpus/6870-error-constructor-values.js new file mode 100644 index 000000000..79c970914 --- /dev/null +++ b/tests/corpus/6870-error-constructor-values.js @@ -0,0 +1,65 @@ +// The error constructors as values in JavaScript: an error's `constructor` +// is the same function the global names, whose name, length, typeof and +// String() are Node's, for errors the program throws, errors the runtime +// throws, and errors read back from catch bindings and containers. +function describe(label, error) { + const ctor = error.constructor; + console.log(label, error.name, error.constructor.name, typeof ctor, ctor.length, String(ctor)); +} + +describe('Error', new Error('e')); +describe('TypeError', new TypeError('t')); +describe('RangeError', new RangeError('r')); +describe('SyntaxError', new SyntaxError('s')); +describe('ReferenceError', new ReferenceError('f')); +describe('EvalError', new EvalError('v')); +describe('URIError', new URIError('u')); +describe('AggregateError', new AggregateError([], 'a')); + +const thrown = [ + () => JSON.parse('{'), + () => { + const holder = JSON.parse('{"value":null}'); + return holder.value.missing; + }, + () => new Array(-1), + () => decodeURIComponent('%'), + () => { + throw new TypeError('own'); + }, +]; +const constructors = { SyntaxError, TypeError, RangeError, URIError }; +const caught = []; +for (const run of thrown) { + try { + run(); + } catch (error) { + caught.push(error); + console.log('caught', error.constructor.name, error.constructor === constructors[error.name]); + } +} + +const byName = new Map(); +for (const error of caught) byName.set(error.constructor.name, (byName.get(error.constructor.name) ?? 0) + 1); +console.log('kinds', JSON.stringify([...byName])); + +console.log('identity', new TypeError('x').constructor === TypeError, new RangeError('x').constructor === TypeError); +console.log('globals', Error.name, TypeError.length, AggregateError.length, typeof RangeError, String(SyntaxError)); + +const renamed = new TypeError('x'); +renamed.name = 'Custom'; +console.log('renamed', renamed.name, renamed.constructor.name); + +class ParseFailure extends SyntaxError {} +const failure = new ParseFailure('p'); +console.log('subclass', failure.name, failure.constructor.name, failure instanceof SyntaxError); + +// Effect's isStackTraceLimitWritable reflects on Error as a value. +const limit = Object.getOwnPropertyDescriptor(Error, 'stackTraceLimit'); +console.log('stackTraceLimit', JSON.stringify(limit), Object.hasOwn(limit, 'writable') ? limit.writable === true : limit.set !== undefined); +Error.stackTraceLimit = 4; +console.log('stackTraceLimit now', Object.getOwnPropertyDescriptor(Error, 'stackTraceLimit').value); +Error.stackTraceLimit = 10; +for (const ctor of [Error, TypeError, AggregateError, Object, Map]) { + console.log('extensible', ctor.name, Object.isExtensible(ctor), Object.isFrozen(ctor), Object.isSealed(ctor)); +} diff --git a/tests/corpus/6871-worker-data-destructuring.cjs b/tests/corpus/6871-worker-data-destructuring.cjs new file mode 100644 index 000000000..63ae789bd --- /dev/null +++ b/tests/corpus/6871-worker-data-destructuring.cjs @@ -0,0 +1,30 @@ +// Destructuring the members of a worker's workerData in JavaScript: plain, +// renamed, defaulted, nested and rest bindings read the data the worker was +// started with, as reading `workerData.` does. +'use strict'; +const { Worker, isMainThread, parentPort, workerData } = require('node:worker_threads'); + +if (isMainThread) { + const sab = new SharedArrayBuffer(8); + const data = { name: 'job-7', size: 3, options: { verbose: true, tags: ['a', 'b'] }, counters: new Int32Array(sab), extra: 1, more: 'x' }; + const worker = new Worker(__filename, { workerData: data }); + worker.on('message', (lines) => { + for (const line of lines) console.log(line); + console.log('main sees', new Int32Array(sab)[0]); + }); +} else { + const lines = []; + const { name, size } = workerData; + lines.push(`plain ${name} ${size}`); + const { name: jobName, missing = 'fallback', size: count = 10 } = workerData; + lines.push(`renamed ${jobName} ${missing} ${count}`); + const { + options: { verbose, tags: [firstTag, ...otherTags] }, + } = workerData; + lines.push(`nested ${verbose} ${firstTag} ${JSON.stringify(otherTags)}`); + const { name: ignored, size: alsoIgnored, options, counters, ...rest } = workerData; + lines.push(`rest ${JSON.stringify(rest)} ${typeof options} ${ignored === name && alsoIgnored === size}`); + counters[0] = 41; + counters[0] += 1; + parentPort.postMessage(lines); +} diff --git a/tests/harness/corpus-costs/6870-error-constructor-values.js.json b/tests/harness/corpus-costs/6870-error-constructor-values.js.json new file mode 100644 index 000000000..c608ce33a --- /dev/null +++ b/tests/harness/corpus-costs/6870-error-constructor-values.js.json @@ -0,0 +1 @@ +{ "plain": 1200, "san": 3400 } diff --git a/tests/harness/corpus-costs/6871-worker-data-destructuring.cjs.json b/tests/harness/corpus-costs/6871-worker-data-destructuring.cjs.json new file mode 100644 index 000000000..d6c0cb9ee --- /dev/null +++ b/tests/harness/corpus-costs/6871-worker-data-destructuring.cjs.json @@ -0,0 +1 @@ +{ "plain": 1300, "san": 3490 } From fb403d5755dfb737815419cd02960755ab4018a4 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 06:06:45 -0500 Subject: [PATCH 068/102] Clear a store that an async prefix enters in a loop callback When an event-loop callback calls an async function or steps a generator that enters a store before its first await, the store becomes the callback's at the end of the prefix. On the main slot it now ends with that callback, as an enterWith there does: the copy schedules the tick that clears the main slot, so the store does not reach later callbacks. --- packages/runtime/src/scr_async.c | 47 +++++++++++--------- tests/corpus/7106-async-prefix-enter-with.ts | 33 +++++++++++++- 2 files changed, 59 insertions(+), 21 deletions(-) diff --git a/packages/runtime/src/scr_async.c b/packages/runtime/src/scr_async.c index 9d3a25469..9e3365fbe 100644 --- a/packages/runtime/src/scr_async.c +++ b/packages/runtime/src/scr_async.c @@ -674,6 +674,32 @@ void scr_als_ctx_release(ScrAlsCtx *c) { free(c); } +/* enterWith on the main stack lasts until that code returns to the loop, + * so the store does not reach callbacks scheduled without it: the loop + * clears the main slot when the main module's body returns, and an + * enterWith inside a callback the loop runs puts a tick that clears it at + * the front of the tick queue, so it runs as soon as that callback + * returns. A store that an async callee's prefix or a generator step + * enters becomes the caller's at scr_als_prefix_end and is cleared the + * same way. */ +static SCR_TL bool scr_loop_started = false; + +static void scr_als_main_clear(void) { + scr_als_ctx_release(scr_als_main_slot); + scr_als_main_slot = NULL; +} + +static void scr_next_tick_raw_first(void (*fn)(void)); + +/* A new store on the main slot: one a loop callback enters ends with it. */ +static void scr_als_main_entered(void) { + if (scr_loop_started) scr_next_tick_raw_first(scr_als_main_clear); +} + +void scr_als_entered_with(void) { + if (SCR_ALS_SLOT() == &scr_als_main_slot) scr_als_main_entered(); +} + /* The end of an async body's synchronous prefix: its first await, or its * end. Node runs that prefix inside the caller's execution, so a store it * entered (enterWith) is still the caller's store after the call; the body @@ -685,6 +711,7 @@ static void scr_als_prefix_end(ScrFiber *f) { if (*slot != f->als) { scr_als_ctx_release(*slot); *slot = scr_als_ctx_retain(f->als); + if (f->als != NULL && slot == &scr_als_main_slot) scr_als_main_entered(); } } @@ -758,26 +785,6 @@ ScrDyn *scr_als_peek(double id) { return NULL; } -/* enterWith on the main stack lasts until that code returns to the loop, - * so the store does not reach callbacks scheduled without it: the loop - * clears the main slot when the main module's body returns, and an - * enterWith inside a callback the loop runs puts a tick that clears it at - * the front of the tick queue, so it runs as soon as that callback - * returns. */ -static SCR_TL bool scr_loop_started = false; - -static void scr_als_main_clear(void) { - scr_als_ctx_release(scr_als_main_slot); - scr_als_main_slot = NULL; -} - -static void scr_next_tick_raw_first(void (*fn)(void)); - -void scr_als_entered_with(void) { - if (scr_loop_started && SCR_ALS_SLOT() == &scr_als_main_slot) - scr_next_tick_raw_first(scr_als_main_clear); -} - static SCR_TL ScrCtx scr_loop_ctx; /* the main stack (scheduler home) */ static SCR_TL ScrFiber *scr_current = NULL; /* A finished fiber whose last switch went to the loop (scr_resume_fiber). */ diff --git a/tests/corpus/7106-async-prefix-enter-with.ts b/tests/corpus/7106-async-prefix-enter-with.ts index 27dff250b..d70822171 100644 --- a/tests/corpus/7106-async-prefix-enter-with.ts +++ b/tests/corpus/7106-async-prefix-enter-with.ts @@ -3,7 +3,9 @@ // after the call (Node's semantics), and the callee keeps it after its own // await; after the first await it stays inside the callee. Covers callees // that never suspend, stackless and fiber-backed callees, nested callees, -// run() scopes inside the prefix, and calls without an await. +// run() scopes inside the prefix, and calls without an await. A store that +// an event-loop callback enters this way, or through a generator step, ends +// with that callback and does not reach the next one. import { AsyncLocalStorage } from "node:async_hooks"; const store = new AsyncLocalStorage(); @@ -45,6 +47,33 @@ async function fibered(tag: string): Promise { return n; } +function* steps(): Generator { + store.enterWith("generator-step"); + yield 1; +} +function callbacks(): Promise { + return new Promise((resolve) => { + setTimeout(() => { + void prefixThenAwait("9"); + log.push(`timer after the call: ${current()}`); + }, 0); + setTimeout(() => { + log.push(`second timer: ${current()}`); + steps().next(); + log.push(`second timer after a generator step: ${current()}`); + }, 0); + setTimeout(() => { + log.push(`third timer: ${current()}`); + void neverSuspends("10"); + log.push(`third timer after the call: ${current()}`); + }, 0); + setTimeout(() => { + log.push(`last timer: ${current()}`); + resolve(); + }, 0); + }); +} + async function main(): Promise { await store.run("A", async () => { await neverSuspends("1"); @@ -83,6 +112,8 @@ async function main(): Promise { await fibered("8"); log.push(`H after fibered: ${current()}`); }); + await callbacks(); + log.push(`main after the callbacks: ${current()}`); for (const line of log) console.log(line); } void main(); From fb544eb98e40024a1ed8122dc8ab41501c0484b9 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 06:07:58 -0500 Subject: [PATCH 069/102] Validate DiffieHellman peer keys like Node: oversized keys and RFC 5114 subgroups Keys, primes and generators drop their leading zero bytes before import, as BN_bin2bn does, and a value still past mbedTLS's 80000-byte limit throws Node's error or a coded SC2020 error instead of aborting the process: computeSecret rejects a key longer than the prime as too large, a long generator is a bad generator, and setPublicKey/setPrivateKey refuse with SC2020. Under the RFC 5114 groups, computeSecret rejects a peer key with key^q mod p != 1 with ERR_CRYPTO_INVALID_KEYTYPE, as OpenSSL's public key check does, closing small-subgroup confinement of the private key. The safe-prime groups keep the range check only, as in Node. Exponents past 8192 bits are split into digits bit by bit, so generateKeys with a long private key takes linear time. --- .../limitations/builtin-apis/crypto.mdx | 1 + .../tests/corpus/6712-dh-peer-keys.js.json | 6 + packages/runtime/src/scr_dh.c | 117 +++++++++++++++--- tests/corpus/6712-dh-peer-keys.js | 117 ++++++++++++++++++ .../corpus-costs/6712-dh-peer-keys.js.json | 1 + 5 files changed, 223 insertions(+), 19 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6712-dh-peer-keys.js.json create mode 100644 tests/corpus/6712-dh-peer-keys.js create mode 100644 tests/harness/corpus-costs/6712-dh-peer-keys.js.json diff --git a/docs/content/limitations/builtin-apis/crypto.mdx b/docs/content/limitations/builtin-apis/crypto.mdx index 6eb42c8b1..f1c06eb72 100644 --- a/docs/content/limitations/builtin-apis/crypto.mdx +++ b/docs/content/limitations/builtin-apis/crypto.mdx @@ -20,6 +20,7 @@ ECDH property reads and writes throw a coded SC2020 error. `createDiffieHellman`, `getDiffieHellman`, and `createDiffieHellmanGroup` support the modp1, modp2, modp5, and modp14 through modp18 groups, explicit primes and generators, and generated safe primes, on native targets, through `generateKeys()`, `computeSecret()`, `getPrime()`, `getGenerator()`, `getPublicKey()`, `getPrivateKey()`, `setPublicKey()`, `setPrivateKey()`, and `verifyError`, with Node's private key lengths, DH_check results, and errors; wasm32-wasi builds are refused. Primes longer than 8192 bits throw a coded SC2020 error; Node accepts primes up to 10000 bits for key generation and secrets. + `setPublicKey()` and `setPrivateKey()` keys longer than 80000 bytes, not counting leading zero bytes, throw a coded SC2020 error, as does a generator that long with a prime below 512 bits; Node accepts them. 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. diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6712-dh-peer-keys.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6712-dh-peer-keys.js.json new file mode 100644 index 000000000..101260f54 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6712-dh-peer-keys.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6712-dh-peer-keys.js" + ], + "diags": [] +} diff --git a/packages/runtime/src/scr_dh.c b/packages/runtime/src/scr_dh.c index 351d97a0f..cf44338f5 100644 --- a/packages/runtime/src/scr_dh.c +++ b/packages/runtime/src/scr_dh.c @@ -17,7 +17,8 @@ * p ≡ 23 (mod 24) for the generator 2, p ≡ 59 (mod 60) for 5 and * p ≡ 11 (mod 12) otherwise, as OpenSSL's dh_builtin_genparams does. * Primes longer than mbedTLS's 8192-bit limit throw a coded SC2020 - * error. All arguments are borrowed. */ + * error, as do keys and generators past mbedTLS's 80000-byte limit (leading + * zero bytes aside). All arguments are borrowed. */ #include "scr_runtime.h" #include @@ -39,6 +40,9 @@ #define SD_MIN_MODULUS_BITS 512 #define SD_MAX_MODULUS_BITS 10000 +/* The longest value an mbedtls_mpi holds, in bytes. */ +#define SD_MAX_VALUE_BYTES (MBEDTLS_MPI_MAX_LIMBS * sizeof(mbedtls_mpi_uint)) + /* DH_check result bits, as verifyError reports them. */ enum { SD_P_NOT_PRIME = 0x01, @@ -171,6 +175,14 @@ static void sd_too_long(void) { scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020"); } +/* A key or generator past SD_MAX_VALUE_BYTES, which BN_bin2bn reads. */ +static void sd_value_too_long(void) { + char message[96]; + int n = snprintf(message, sizeof message, "DiffieHellman values longer than %zu bytes have no native implementation", + (size_t)SD_MAX_VALUE_BYTES); + scr_throw_error_msg_code(SCR_ERR_ERROR, message, n < 0 ? 0 : (size_t)n, "SC2020"); +} + /* validateInt32(value, name). */ static bool sd_validate_int32(const char *name, double value) { bool integer = isfinite(value) && trunc(value) == value; @@ -215,10 +227,10 @@ static bool sd_exp(mbedtls_mpi *out, const mbedtls_mpi *base, const mbedtls_mpi MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&step, 1)); MBEDTLS_MPI_CHK(mbedtls_mpi_shift_l(&step, SD_DIGIT_BITS)); for (size_t offset = 0; offset < ebits; offset += SD_DIGIT_BITS) { - MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&digit, e)); - MBEDTLS_MPI_CHK(mbedtls_mpi_shift_r(&digit, offset)); - for (size_t bit = SD_DIGIT_BITS; bit < mbedtls_mpi_bitlen(&digit); bit++) - MBEDTLS_MPI_CHK(mbedtls_mpi_set_bit(&digit, bit, 0)); + /* Bit by bit, so each digit costs its own width, not the exponent's. */ + MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&digit, 0)); + for (size_t bit = 0; bit < SD_DIGIT_BITS && offset + bit < ebits; bit++) + if (mbedtls_mpi_get_bit(e, offset + bit)) MBEDTLS_MPI_CHK(mbedtls_mpi_set_bit(&digit, bit, 1)); MBEDTLS_MPI_CHK(mbedtls_mpi_exp_mod(&term, &power, &digit, p, NULL)); MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&acc, &acc, &term)); MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(&acc, &acc, p)); @@ -234,6 +246,36 @@ cleanup: return ret == 0; } +/* Drops a big-endian value's leading zero bytes, which BN_bin2bn ignores + * but mbedtls_mpi_read_binary counts against SD_MAX_VALUE_BYTES. */ +static void sd_strip(const unsigned char **data, size_t *len) { + while (*len > 0 && **data == 0) { + (*data)++; + (*len)--; + } +} + +/* BN_bin2bn: false when the value, without its leading zeros, is longer + * than SD_MAX_VALUE_BYTES. */ +static bool sd_read(mbedtls_mpi *x, const ScrBytes *bytes) { + const unsigned char *data = bytes->data; + size_t len = bytes->len; + sd_strip(&data, &len); + if (len > SD_MAX_VALUE_BYTES) return false; + if (mbedtls_mpi_read_binary(x, data, len) != 0) scr_trap("scriptc: out of memory\n"); + return true; +} + +/* BN_cmp over two big-endian values, for ones sd_read cannot hold. */ +static int sd_cmp_bytes(const ScrBytes *a, const ScrBytes *b) { + const unsigned char *a_data = a->data, *b_data = b->data; + size_t a_len = a->len, b_len = b->len; + sd_strip(&a_data, &a_len); + sd_strip(&b_data, &b_len); + if (a_len != b_len) return a_len < b_len ? -1 : 1; + return a_len ? memcmp(a_data, b_data, a_len) : 0; +} + /* A uniformly random number of exactly `bits` bits (the top bit set), and * odd when `odd`, as BN_priv_rand writes it. */ static bool sd_random_bits(mbedtls_mpi *x, size_t bits, bool odd) { @@ -872,12 +914,21 @@ static ScrDyn *sd_generate(double bits, const ScrBytes *generator_bytes, double /* new DiffieHellman(prime, generator) over explicit parameters. */ static ScrDyn *sd_from_prime(const ScrBytes *prime, const ScrBytes *generator_bytes, double generator) { ScDh *d = sd_alloc(); - if (mbedtls_mpi_read_binary(&d->p, prime->data, prime->len) != 0) scr_trap("scriptc: out of memory\n"); - if (generator_bytes) { - if (mbedtls_mpi_read_binary(&d->g, generator_bytes->data, generator_bytes->len) != 0) - scr_trap("scriptc: out of memory\n"); - } else if (mbedtls_mpi_lset(&d->g, (mbedtls_mpi_sint)generator) != 0) { - scr_trap("scriptc: out of memory\n"); + bool p_held = sd_read(&d->p, prime); + bool g_held = true; + if (generator_bytes) g_held = sd_read(&d->g, generator_bytes); + else if (mbedtls_mpi_lset(&d->g, (mbedtls_mpi_sint)generator) != 0) scr_trap("scriptc: out of memory\n"); + if (!p_held || !g_held) { + /* A prime this long is past MBEDTLS_MPI_MAX_BITS, and a generator + * this long is at least a prime of SD_MIN_MODULUS_BITS. */ + bool bad = g_held ? mbedtls_mpi_cmp_int(&d->g, 2) < 0 + : !p_held ? sd_cmp_bytes(generator_bytes, prime) >= 0 + : mbedtls_mpi_bitlen(&d->p) >= SD_MIN_MODULUS_BITS; + sd_release(d); + if (bad) sd_bad_generator(); + else if (!p_held) sd_too_long(); + else sd_value_too_long(); + return NULL; } if (mbedtls_mpi_cmp_int(&d->g, 2) < 0 || (mbedtls_mpi_bitlen(&d->p) >= SD_MIN_MODULUS_BITS && mbedtls_mpi_cmp_mpi(&d->g, &d->p) >= 0)) { @@ -1057,10 +1108,27 @@ static bool sd_derives(const ScDh *d) { return mbedtls_mpi_cmp_int(&d->priv, 0) != 0 && bits >= SD_MIN_MODULUS_BITS && bits <= SD_MAX_MODULUS_BITS; } +/* DH_check_pub_key's subgroup test: under a named group with its own q + * (the RFC 5114 groups), a peer key must have key^q mod p = 1. The safe + * prime groups' q is (p - 1) / 2, which OpenSSL does not test. */ +static bool sd_in_subgroup(const ScDh *d, const mbedtls_mpi *peer) { + if (!d->named || !d->named->q) return true; + mbedtls_mpi q, r; + mbedtls_mpi_init(&q); + mbedtls_mpi_init(&r); + if (mbedtls_mpi_read_binary(&q, d->named->q, d->named->q_len) != 0 || !sd_exp(&r, peer, &q, &d->p)) + scr_trap("scriptc: out of memory\n"); + bool in = mbedtls_mpi_cmp_int(&r, 1) == 0; + mbedtls_mpi_free(&q); + mbedtls_mpi_free(&r); + return in; +} + /* computeSecret(key, inputEncoding, outputEncoding): key^priv mod p, - * padded to the prime's length. A secret of 0, 1 or p - 1 is predictable - * (a peer key of small order, or a composite modulus), so it fails like - * OpenSSL's derivation does. */ + * padded to the prime's length. A key outside [2, p - 2], or outside a + * named group's order-q subgroup, is rejected as DH_check_pub_key does. + * A secret of 0, 1 or p - 1 is predictable (a peer key of small order, + * or a composite modulus), so it fails like OpenSSL's derivation does. */ static ScrDyn *sd_compute_secret(ScDh *d, const ScrDyn *key, const ScrDyn *in_enc, const ScrDyn *out_enc) { ScrBytes *bytes = ca_key_bytes(SD_SUBJECT, key, in_enc); if (!bytes) return NULL; @@ -1069,12 +1137,19 @@ static ScrDyn *sd_compute_secret(ScDh *d, const ScrDyn *key, const ScrDyn *in_en mbedtls_mpi_init(&peer); mbedtls_mpi_init(&bound); mbedtls_mpi_init(&secret); - if (mbedtls_mpi_read_binary(&peer, bytes->data, bytes->len) != 0 || mbedtls_mpi_sub_int(&bound, &d->p, 1) != 0) + /* A key longer than p, past its leading zeros, is above p - 1. */ + const unsigned char *data = bytes->data; + size_t len = bytes->len; + sd_strip(&data, &len); + bool longer = len > mbedtls_mpi_size(&d->p); + if ((!longer && mbedtls_mpi_read_binary(&peer, data, len) != 0) || mbedtls_mpi_sub_int(&bound, &d->p, 1) != 0) scr_trap("scriptc: out of memory\n"); - if (mbedtls_mpi_cmp_int(&peer, 1) <= 0) { + if (!longer && mbedtls_mpi_cmp_int(&peer, 1) <= 0) { sd_throw(SCR_ERR_RANGE, "ERR_CRYPTO_INVALID_KEYLEN", "Supplied key is too small"); - } else if (mbedtls_mpi_cmp_mpi(&peer, &bound) >= 0) { + } else if (longer || mbedtls_mpi_cmp_mpi(&peer, &bound) >= 0) { sd_throw(SCR_ERR_RANGE, "ERR_CRYPTO_INVALID_KEYLEN", "Supplied key is too large"); + } else if (!sd_in_subgroup(d, &peer)) { + sd_throw(SCR_ERR_RANGE, "ERR_CRYPTO_INVALID_KEYTYPE", "Supplied key is invalid"); } else if (!d->has_priv || (!d->group && !sd_derives(d)) || !sd_exp(&secret, &peer, &d->priv, &d->p) || mbedtls_mpi_cmp_int(&secret, 1) <= 0 || mbedtls_mpi_cmp_mpi(&secret, &bound) == 0) { sd_operation_failed("Failed to compute shared secret"); @@ -1103,9 +1178,13 @@ static ScrDyn *sd_get_value(const mbedtls_mpi *value, bool present, const char * static ScrDyn *sd_set_value(mbedtls_mpi *value, bool *present, ScrDyn *self, const ScrDyn *key, const ScrDyn *encoding) { ScrBytes *bytes = ca_key_bytes(SD_SUBJECT, key, encoding); if (!bytes) return NULL; - if (mbedtls_mpi_read_binary(value, bytes->data, bytes->len) != 0) scr_trap("scriptc: out of memory\n"); - *present = true; + bool held = sd_read(value, bytes); scr_bytes_release(bytes); + if (!held) { + sd_value_too_long(); + return NULL; + } + *present = true; return scr_dyn_retain(self); } diff --git a/tests/corpus/6712-dh-peer-keys.js b/tests/corpus/6712-dh-peer-keys.js new file mode 100644 index 000000000..819fcf960 --- /dev/null +++ b/tests/corpus/6712-dh-peer-keys.js @@ -0,0 +1,117 @@ +// DiffieHellman computeSecret's peer key checks, and keys, primes and +// generators with leading zero bytes: under the RFC 5114 groups a peer key +// outside the order-q subgroup is invalid, while other parameters only +// check the range; a key longer than the prime is too large, and leading +// zeros of any length are ignored. +import crypto from "node:crypto"; + +function attempt(label, run) { + try { + console.log(label, "ok", JSON.stringify(run())); + } catch (e) { + console.log(label, e.name, e.code, e.message); + } +} + +const zeros = Buffer.alloc(100000); +const padded = (bytes) => Buffer.concat([zeros, bytes]); + +// Each group's parameters, and a peer key of small order: h^((p - 1) / r) +// for a small prime r dividing (p - 1) / q. +const groups = [ + { + label: "RFC 5114 1024-bit", + order: 7, + p: "B10B8F96A080E01DDE92DE5EAE5D54EC52C99FBCFB06A3C69A6A9DCA52D23B616073E28675A23D189838EF1E2EE652C013ECB4AEA906112324975C3CD49B83BFACCBDD7D90C4BD7098488E9C219A73724EFFD6FAE5644738FAA31A4FF55BCCC0A151AF5F0DC8B4BD45BF37DF365C1A65E68CFDA76D4DA708DF1FB2BC2E4A4371", + g: "A4D1CBD5C3FD34126765A442EFB99905F8104DD258AC507FD6406CFF14266D31266FEA1E5C41564B777E690F5504F213160217B4B01B886A5E91547F9E2749F4D7FBD7D3B9A92EE1909D0D2263F80A76A6A24C087A091F531DBF0A0169B6A28AD662A4D18E73AFA32D779D5918D08BC8858F4DCEF97C2A24855E6EEB22B3B2E5", + small: "24986e0c35fbae0d16a21b2aab7eac0dc32e9ca8c24c1eb9387366ee8a6df2bee49b6f46ea2525d208c1bc3d87e3749586616e0161a305f670830ba1fa9e4c5a1bd5ae9f4dc2032f1fd99bbcf3f4444a09d4da3ccbde680580ee8d78feced92d1efb235fc9f25c8525a4e5a453ccf7375119cee48b05421c093d10c8b6e90ab8", + }, + { + label: "RFC 5114 2048-bit, 224-bit q", + order: 3, + p: "AD107E1E9123A9D0D660FAA79559C51FA20D64E5683B9FD1B54B1597B61D0A75E6FA141DF95A56DBAF9A3C407BA1DF15EB3D688A309C180E1DE6B85A1274A0A66D3F8152AD6AC2129037C9EDEFDA4DF8D91E8FEF55B7394B7AD5B7D0B6C12207C9F98D11ED34DBF6C6BA0B2C8BBC27BE6A00E0A0B9C49708B3BF8A317091883681286130BC8985DB1602E714415D9330278273C7DE31EFDC7310F7121FD5A07415987D9ADC0A486DCDF93ACC44328387315D75E198C641A480CD86A1B9E587E8BE60E69CC928B2B9C52172E413042E9B23F10B0E16E79763C9B53DCF4BA80A29E3FB73C16B8E75B97EF363E2FFA31F71CF9DE5384E71B81C0AC4DFFE0C10E64F", + g: "AC4032EF4F2D9AE39DF30B5C8FFDAC506CDEBE7B89998CAF74866A08CFE4FFE3A6824A4E10B9A6F0DD921F01A70C4AFAAB739D7700C29F52C57DB17C620A8652BE5E9001A8D66AD7C17669101999024AF4D027275AC1348BB8A762D0521BC98AE247150422EA1ED409939D54DA7460CDB5F6C6B250717CBEF180EB34118E98D119529A45D6F834566E3025E316A330EFBB77A86F0C1AB15B051AE3D428C8F8ACB70A8137150B8EEB10E183EDD19963DDD9E263E4770589EF6AA21E7F5F2FF381B539CCE3409D13CD566AFBB48D6C019181E1BCFE94B30269EDFE72FE9B6AA4BD7B5A0F1C71CFFF4C19C418E1F6EC017981BC087F2A7065B384B890D3191F2BFA", + small: "73ef184cd50bd427992f4bbeaf1d7712f8cb8264929f533ded004618b29064e3583963fc634df866ef9aa5f158077765219401ad4bf0a2c42204241c8a728af1012cfd399a76f13a0e2cb153c0888a9eb0e05312610923777d185f46bf865bbfe86a0e79a6761d7e153cb46e2221dc3415a7e78c22d33c3d1e2363c041bb57badd344969ee2a1c4917d26ab51a20bc343b4db9964871b0918b2b8e97ff7d297e8b8ca2329426755fdf302a6401030c0f0206a0da004cac53d4408d2ff47cff332435d1f01cbeee301b8dda896be231fd38264f1a5c2b51365a8e74e608a2510c26c92c8d091e18577e854c43d5dc3b2779552f6723878deb5ec58bce2da61abe", + }, + { + label: "RFC 5114 2048-bit, 256-bit q", + order: 7, + p: "87A8E61DB4B6663CFFBBD19C651959998CEEF608660DD0F25D2CEED4435E3B00E00DF8F1D61957D4FAF7DF4561B2AA3016C3D91134096FAA3BF4296D830E9A7C209E0C6497517ABD5A8A9D306BCF67ED91F9E6725B4758C022E0B1EF4275BF7B6C5BFC11D45F9088B941F54EB1E59BB8BC39A0BF12307F5C4FDB70C581B23F76B63ACAE1CAA6B7902D52526735488A0EF13C6D9A51BFA4AB3AD8347796524D8EF6A167B5A41825D967E144E5140564251CCACB83E6B486F6B3CA3F7971506026C0B857F689962856DED4010ABD0BE621C3A3960A54E710C375F26375D7014103A4B54330C198AF126116D2276E11715F693877FAD7EF09CADB094AE91E1A1597", + g: "3FB32C9B73134D0B2E77506660EDBD484CA7B18F21EF205407F4793A1A0BA12510DBC15077BE463FFF4FED4AAC0BB555BE3A6C1B0C6B47B1BC3773BF7E8C6F62901228F8C28CBB18A55AE31341000A650196F931C77A57F2DDF463E5E9EC144B777DE62AAAB8A8628AC376D282D6ED3864E67982428EBC831D14348F6F2F9193B5045AF2767164E1DFC967C1FB3F2E55A4BD1BFFE83B9C80D052B985D182EA0ADB2A3B7313D3FE14C8484B1E052588B9B7D2BBD2DF016199ECD06E1557CD0915B3353BBB64E0EC377FD028370DF92B52C7891428CDC67EB6184B523D1DB246C32F63078490F00EF8D647D148D47954515E2327CFEF98C582664B4C0F6CC41659", + small: "7e22fad9cc23b5949616a26b060dcec3557a81d98dc45f51943f4e29b06dd73e6fbf201c01c4c2620b81698048fcb21655d1276bfb402a41c3af50528f2df02b3440a3b7a1855dfe31a549ddce9563ed18fe1530a3a649f87fa4d427d6d2e1b73cf3848177651080f2ca96628fed411c331d9e28d28da5f0c65f2516f9bb4c72e4c9050f5d654bcc0139e66fbc582ae32d345ad84a249d9cea131c6a9af59ecaefbc190ca265394eb8190ff91a6af58327060ca4900829eaa3a1c26f86737d7510bfd55c430bcc1f2db6a62c3bfe1717e5236945c475bb7b36dc2fa5ab06b089325dfd864a6b044622e62a5638ce23f319cf564826ce1e5c1bc1166896c5f205", + }, +]; + +for (const group of groups) { + const p = Buffer.from(group.p, "hex"); + const g = Buffer.from(group.g, "hex"); + const alice = crypto.createDiffieHellman(p, g); + const bob = crypto.createDiffieHellman(p, g); + alice.generateKeys(); + bob.generateKeys(); + const name = group.label; + attempt(`${name}: verifyError`, () => alice.verifyError); + attempt(`${name}: agreed`, () => alice.computeSecret(bob.getPublicKey()).equals(bob.computeSecret(alice.getPublicKey()))); + attempt(`${name}: order ${group.order}`, () => alice.computeSecret(Buffer.from(group.small, "hex")).length); + attempt(`${name}: 2`, () => alice.computeSecret(Buffer.from([2])).length); + attempt(`${name}: p - 2`, () => { + const key = Buffer.from(p); + key[key.length - 1] -= 2; + return alice.computeSecret(key).length; + }); + attempt(`${name}: p - 1`, () => { + const key = Buffer.from(p); + key[key.length - 1] -= 1; + return alice.computeSecret(key).length; + }); + attempt(`${name}: without keys`, () => crypto.createDiffieHellman(p, g).computeSecret(Buffer.from([2])).length); + // The same prime with another generator is not the named group. The + // private key is a multiple of neither 3 nor 7, so the small-order key + // gives a secret other than 1. + const other = crypto.createDiffieHellman(p, 2); + other.setPrivateKey(Buffer.from("0123456789abcdee", "hex")); + attempt(`${name}, generator 2: order ${group.order}`, () => other.computeSecret(Buffer.from(group.small, "hex")).length); + attempt(`${name}, generator 2: 2`, () => other.computeSecret(Buffer.from([2])).length); +} + +// The safe prime groups check only the range: 11 is a quadratic +// non-residue modulo the 2048-bit MODP prime. +const modp14 = crypto.getDiffieHellman("modp14"); +modp14.generateKeys(); +attempt("modp14: non-residue", () => modp14.computeSecret(Buffer.from([11])).length); +const explicit = crypto.createDiffieHellman(modp14.getPrime(), modp14.getGenerator()); +explicit.generateKeys(); +attempt("modp14 explicit: non-residue", () => explicit.computeSecret(Buffer.from([11])).length); + +// Keys longer than the prime, and leading zeros. +const peer = crypto.createDiffieHellman(modp14.getPrime(), 2); +peer.generateKeys(); +const secret = modp14.computeSecret(peer.getPublicKey()); +attempt("100000 bytes of 0xff", () => modp14.computeSecret(Buffer.alloc(100000, 0xff)).length); +attempt("prime and one byte", () => modp14.computeSecret(Buffer.concat([Buffer.from([1]), modp14.getPrime()])).length); +attempt("hex of 100000 bytes", () => modp14.computeSecret(Buffer.alloc(100000, 0x7f).toString("hex"), "hex").length); +attempt("zero-padded key", () => modp14.computeSecret(padded(peer.getPublicKey())).equals(secret)); +attempt("zero-padded hex key", () => modp14.computeSecret(padded(peer.getPublicKey()).toString("hex"), "hex").equals(secret)); +attempt("zeros", () => modp14.computeSecret(zeros).length); +attempt("zero-padded 1", () => modp14.computeSecret(padded(Buffer.from([1]))).length); +attempt("zero-padded p - 1", () => { + const key = Buffer.from(modp14.getPrime()); + key[key.length - 1] -= 1; + return modp14.computeSecret(padded(key)).length; +}); +attempt("zero-padded public key", () => { + const dh = crypto.createDiffieHellman(modp14.getPrime(), 2); + dh.setPublicKey(padded(peer.getPublicKey())); + return dh.getPublicKey().equals(peer.getPublicKey()); +}); +attempt("zero-padded private key", () => { + const dh = crypto.createDiffieHellman(modp14.getPrime(), 2); + dh.setPrivateKey(padded(peer.getPrivateKey())); + return [dh.getPrivateKey().equals(peer.getPrivateKey()), dh.generateKeys().equals(peer.getPublicKey())]; +}); +attempt("zero-padded prime and generator", () => { + const dh = crypto.createDiffieHellman(padded(modp14.getPrime()), padded(Buffer.from([2]))); + return [dh.verifyError, dh.getPrime().equals(modp14.getPrime()), dh.getGenerator("hex")]; +}); +attempt("generator of 100000 bytes", () => crypto.createDiffieHellman(modp14.getPrime(), Buffer.alloc(100000, 0xff)).verifyError); +attempt("zero-padded generator 1", () => crypto.createDiffieHellman(modp14.getPrime(), padded(Buffer.from([1]))).verifyError); diff --git a/tests/harness/corpus-costs/6712-dh-peer-keys.js.json b/tests/harness/corpus-costs/6712-dh-peer-keys.js.json new file mode 100644 index 000000000..429593dc5 --- /dev/null +++ b/tests/harness/corpus-costs/6712-dh-peer-keys.js.json @@ -0,0 +1 @@ +{ "plain": 9427, "san": 12410 } From d01117fa517daca56dbb8d87d3c6267d028a81b5 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 06:13:45 -0500 Subject: [PATCH 070/102] Batch the contextual types and signatures that lowering asks per node ClassProtocols' identity-flow fixpoint asks the contextual type of each site whose source carries identity, one round trip at a time, and lowering asks the resolved signature of each call and the contextual type of each array literal and conditional it lowers the same way. The checker facade can now batch them: prefetchContextualTypes for the fixpoint's sites before it runs, and, for each prefetched wave of reachable roots, the resolved signatures of its calls and the contextual types of its array literals and conditionals. A batched query that fails is left out of the memo, so a direct query still throws where it is made. The batches use the checker's getContextualTypes and getResolvedSignatures requests. NODE_BATCH_QUERIES keeps them off until scriptc depends on a tsc-ts release that answers them; while it is off the prefetches do nothing. --- .../src/frontend/lowering/class-protocols.ts | 30 +++++++- packages/compiler/src/frontend/ts7/checker.ts | 72 ++++++++++++++++++- .../src/frontend/ts7/semantic-checker.ts | 18 +++++ 3 files changed, 115 insertions(+), 5 deletions(-) diff --git a/packages/compiler/src/frontend/lowering/class-protocols.ts b/packages/compiler/src/frontend/lowering/class-protocols.ts index 81aa90a1f..76091b13e 100644 --- a/packages/compiler/src/frontend/lowering/class-protocols.ts +++ b/packages/compiler/src/frontend/lowering/class-protocols.ts @@ -101,6 +101,8 @@ export class ClassProtocols { const sites: { source: ts.Expression; target: () => ts.Type | undefined; + /** The node whose contextual type `target` answers. */ + contextual?: ts.Expression; assertion?: true; }[] = []; /** Expressions whose values are observed as whole objects. */ @@ -122,7 +124,8 @@ export class ClassProtocols { const callbackParams: { fn: ts.SignatureDeclaration; index: number; name: ts.Node }[] = []; const contextual = (expr: ts.Expression) => () => this.checker.getContextualType(expr); const flow = (expr: ts.Expression | undefined): void => { - if (expr !== undefined) sites.push({ source: expr, target: contextual(expr) }); + if (expr !== undefined) + sites.push({ source: expr, target: contextual(expr), contextual: expr }); }; const write = (target: ts.Expression): void => { while (ts.isParenthesizedExpression(target) || ts.isNonNullExpression(target)) @@ -329,7 +332,11 @@ export class ClassProtocols { facts.loose.push({ node: looseArguments[i]!, call: looseCalls[i]!, symbols }); } this.facts = facts; - const pending: { sourceType: ts.Type; target: () => ts.Type | undefined }[] = []; + const pending: { + sourceType: ts.Type; + target: () => ts.Type | undefined; + contextual?: ts.Expression; + }[] = []; /** Views a value of unknown origin is asserted to and that expose a * method of a class the view accepts (see methodViewSources). */ const methodViews = new Set(); @@ -352,7 +359,11 @@ export class ClassProtocols { } continue; } - pending.push({ sourceType, target: site.target }); + pending.push( + site.contextual === undefined + ? { sourceType, target: site.target } + : { sourceType, target: site.target, contextual: site.contextual }, + ); } for (const { fn, index, name } of callbackParams) { attempt(() => { @@ -377,6 +388,19 @@ export class ClassProtocols { // flows and origins are complete. const before = new Set(marked); const targets = new Map(); + // The fixpoint asks the target of each site whose source carries + // identity: one batch asks those of the sites that carry it now, and a + // site that starts to as marks grow asks its own. + attempt(() => + this.checker.prefetchContextualTypes( + pending.flatMap((entry) => + entry.contextual !== undefined && + attempt(() => this.carriesIdentity(entry.sourceType, marked)) === true + ? [entry.contextual] + : [], + ), + ), + ); let changed = true; while (changed) { changed = false; diff --git a/packages/compiler/src/frontend/ts7/checker.ts b/packages/compiler/src/frontend/ts7/checker.ts index 4f2d60294..cd43636af 100644 --- a/packages/compiler/src/frontend/ts7/checker.ts +++ b/packages/compiler/src/frontend/ts7/checker.ts @@ -45,7 +45,7 @@ import type { TypePredicate, TypeReference, } from "./semantic-types.js"; -import type { SemanticChecker as Checker } from "./semantic-checker.js"; +import { NODE_BATCH_QUERIES, type SemanticChecker as Checker } from "./semantic-checker.js"; import { symbolNameOf, type SemanticProject as Project } from "./semantic-model.js"; import { isTypeNode, walkPreorder } from "./ast.js"; import { SignatureKind, SyntaxKind, TypeFlags, type SymbolFlags } from "./enums.js"; @@ -79,6 +79,30 @@ function withPanicFence( } } +/** Answers for `items` in chunks, each answer given to `store`. A chunk + * that throws is split until the throwing items are alone; those get no + * answer, so their direct query throws again where it is made. */ +function batchAnswers( + items: readonly I[], + fetch: (chunk: readonly I[]) => readonly (O | undefined)[], + store: (item: I, answer: O | undefined) => void, +): void { + const answer = (chunk: readonly I[]): void => { + let answers: readonly (O | undefined)[]; + try { + answers = fetch(chunk); + } catch { + if (chunk.length === 1) return; + const mid = chunk.length >> 1; + answer(chunk.slice(0, mid)); + answer(chunk.slice(mid)); + return; + } + chunk.forEach((item, index) => store(item, answers[index])); + }; + for (let i = 0; i < items.length; i += BATCH_CHUNK) answer(items.slice(i, i + BATCH_CHUNK)); +} + function chunked(items: readonly T[], fetch: (chunk: readonly T[]) => readonly R[]): R[] { const out: R[] = []; for (let i = 0; i < items.length; i += BATCH_CHUNK) { @@ -322,7 +346,51 @@ export class CheckerFacade { prefetchRoots(roots: readonly Node[]): void { this.ensureActive(); this.markManaged(roots); - this.prefetchNodes(collectNodes(roots, "reachable")); + const nodes = collectNodes(roots, "reachable"); + this.prefetchNodes(nodes); + if (!NODE_BATCH_QUERIES) return; + // Lowering a call resolves its signature (reconcileOverloadReturn). + this.prefetchResolvedSignatures( + nodes.filter( + (node) => + node.kind === SyntaxKind.CallExpression || + node.kind === SyntaxKind.TaggedTemplateExpression, + ), + ); + // Lowering an array literal or a conditional asks its contextual type. + this.prefetchContextualTypes( + nodes.filter( + (node) => + node.kind === SyntaxKind.ArrayLiteralExpression || + node.kind === SyntaxKind.ConditionalExpression, + ), + ); + } + + /** Batches the contextual type of each node, for an analysis that asks it + * of many nodes (class-protocols.ts). A query that fails stays out of the + * memo, so a later getContextualType asks again as it would have. */ + prefetchContextualTypes(nodes: readonly Node[]): void { + if (!NODE_BATCH_QUERIES) return; + this.ensureActive(); + const missing = [...new Set(nodes)].filter((node) => !this.cache.contextualType.has(node)); + batchAnswers( + missing, + (chunk) => this.raw.getContextualTypes(chunk), + (node, type) => this.cache.contextualType.set(node, type), + ); + } + + /** Batches the resolved signature of each call (getResolvedSignature). */ + prefetchResolvedSignatures(nodes: readonly Node[]): void { + if (!NODE_BATCH_QUERIES) return; + this.ensureActive(); + const missing = [...new Set(nodes)].filter((node) => !this.cache.resolvedSignature.has(node)); + batchAnswers( + missing, + (chunk) => this.raw.getResolvedSignatures(chunk), + (node, signature) => this.cache.resolvedSignature.set(node, signature), + ); } /** Batches symbol queries for every identifier under roots without the diff --git a/packages/compiler/src/frontend/ts7/semantic-checker.ts b/packages/compiler/src/frontend/ts7/semantic-checker.ts index 5e7f8339a..1e5f46b4d 100644 --- a/packages/compiler/src/frontend/ts7/semantic-checker.ts +++ b/packages/compiler/src/frontend/ts7/semantic-checker.ts @@ -96,6 +96,13 @@ export interface SemanticCompletion { symbol: SemanticSymbol | undefined; } +/** Whether lowering asks the checker for contextual types and resolved + * signatures in batches (`getContextualTypes`, `getResolvedSignatures`). + * Off until scriptc depends on a tsc-ts release that answers them: the + * batch prefetches (checker.ts) then do nothing and lowering asks node by + * node. */ +export const NODE_BATCH_QUERIES = false; + /** The pinned checker's request surface over native objects. Every query * converges on the same snapshot/project registries, including batch and * lazy-object queries. No SDK object is constructed or consulted here. */ @@ -201,6 +208,10 @@ export class SemanticChecker { getContextualType(node: AstNode): SemanticType | undefined { return this.type("getContextualType", { location: node.id }); } + /** getContextualType for each node. */ + getContextualTypes(nodes: readonly AstNode[]): (SemanticType | undefined)[] { + return this.optionalTypes("getContextualTypes", { locations: nodes.map((node) => node.id) }); + } getTypeFromTypeNode(node: AstNode): SemanticType | undefined { return this.type("getTypeFromTypeNode", { location: node.id }); } @@ -213,6 +224,13 @@ export class SemanticChecker { getResolvedSignature(node: AstNode): SemanticSignature | undefined { return this.signature("getResolvedSignature", { location: node.id }); } + /** getResolvedSignature for each node. */ + getResolvedSignatures(nodes: readonly AstNode[]): (SemanticSignature | undefined)[] { + const data = this.project.request<(SignatureResponse | null)[]>("getResolvedSignatures", { + locations: nodes.map((node) => node.id), + }); + return data.map((item) => (item === null ? undefined : this.project.signature(item))); + } getSignatureFromDeclaration(node: AstNode): SemanticSignature | undefined { return this.signature("getSignatureFromDeclaration", { location: node.id }); } From 0f6ea63f21f8a0f044177ebb6f36fc3cf96fac16 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 06:17:05 -0500 Subject: [PATCH 071/102] Give each evaluation of a forward-read generic binding its own function A generic binding inside a function that a nested function read before the declaration lowered stores its instance into a TDZ box when the declaration runs. That value was the instance's closure, which the backend interns for module functions, so every evaluation of the declaration stored the same function object. JavaScript makes a new one each time. The stored value is now a closure over a lifted forwarder that calls the instance, so each evaluation allocates a new closure; the forwarder is created once per instance. Async and rest-parameter bindings read this way report SC1090. Corpus 7180 checks the identities. --- .../frontend/lowering/generic-functions.ts | 71 ++++++++++++++++++- .../7180-generic-local-binding-early-uses.ts | 16 +++++ 2 files changed, 84 insertions(+), 3 deletions(-) diff --git a/packages/compiler/src/frontend/lowering/generic-functions.ts b/packages/compiler/src/frontend/lowering/generic-functions.ts index d0e07582c..e8d3241c0 100644 --- a/packages/compiler/src/frontend/lowering/generic-functions.ts +++ b/packages/compiler/src/frontend/lowering/generic-functions.ts @@ -16,7 +16,7 @@ import { isUnitType, typeEquals, } from "../../ir/ir.js"; -import { nodeThrowExpr } from "../../ir/build.js"; +import { helperLoc, nodeThrowExpr } from "../../ir/build.js"; import { isJsSourceFile, locOf } from "../program.js"; import { typeKey } from "../type-mapper.js"; import { functionCanReturnUndefined } from "../function-completion.js"; @@ -102,6 +102,8 @@ export interface GenericFnInfo { * runs: the BOOL global its declaration sets, and whether it is a * `let`/`const` (a temporal dead zone) or a `var` (undefined). */ presence?: { flagId: string; lexical: boolean }; + /** genericValueForwarder's lifted functions, by instance name. */ + valueForwarders?: Map; /** runsAfterDeclaration's answers for the function declarations whose * calls it placed. */ ordering?: Map; @@ -1266,7 +1268,10 @@ export function lowerGenericFnValue( * nested function read it before the declaration lowered (`const read = * () => id; const id: (x: number) => number = (x: T): T => x`): such * a read resolves to an ordinary TDZ local, so the declaration assigns it - * the instance its concrete declared signature pins. */ + * the instance its concrete declared signature pins. Each evaluation of + * the declaration makes a new function object, as in JavaScript: the + * value is a closure over a forwarder to the instance, not the instance's + * interned closure. */ export function genericBindingStoredValue( lowerer: Lowerer, decl: ts.VariableDeclaration, @@ -1281,7 +1286,67 @@ export function genericBindingStoredValue( ); const sigs = lowerer.checker.getCallSignatures(lowerer.typeOf(name)); if (sigs.length !== 1) fenceUnpinned(); - return pinnedGenericClosure(lowerer, name, info, sigs[0]!, fenceUnpinned); + const pinned = pinnedGenericClosure(lowerer, name, info, sigs[0]!, fenceUnpinned); + const async = ts.getModifiers(info.decl)?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword); + if (pinned.kind !== "closure" || pinned.type.kind !== "func" || pinned.type.rest || async) + return lowerer.unsupported( + "SC1090", + name, + `async or rest-parameter generic function bindings read before their declaration (each evaluation of '${info.baseName}' makes a new function object)`, + ); + return { + ...pinned, + fnName: genericValueForwarder(lowerer, info, pinned.fnName, pinned.type, pinned.loc), + }; +} + +/** A lifted function that calls the instance `instance` (of type `type`) + * with its own arguments. Lifted functions get a new closure object per + * evaluation; module functions, which instances are, get one interned + * closure. */ +function genericValueForwarder( + lowerer: Lowerer, + info: GenericFnInfo, + instance: string, + type: IrType & { kind: "func" }, + at: SrcLoc, +): string { + info.valueForwarders ??= new Map(); + const existing = info.valueForwarders.get(instance); + if (existing !== undefined) return existing; + const name = `${instance}%value`; + const loc = helperLoc(at); + const params: IrParam[] = type.params.map((paramType, i) => ({ + localId: `%arg${i}.0`, + name: `%arg${i}`, + type: paramType, + })); + const call: IrExpr = { + kind: "call", + callee: instance, + args: params.map((p): IrExpr => ({ kind: "varRef", localId: p.localId, type: p.type, loc })), + type: type.ret, + loc, + }; + lowerer.liftedFns.push({ + name, + params, + returnType: type.ret, + locals: params.map((p) => ({ id: p.localId, name: p.name, type: p.type, mutable: false })), + captures: [], + ...(ts.isFunctionExpression(info.decl) ? { ownsPrototype: true } : {}), + body: + type.ret.kind === "void" + ? [ + { kind: "exprStmt", expr: call, loc }, + { kind: "return", value: null, loc }, + ] + : [{ kind: "return", value: call, loc }], + loc, + }); + lowerer.noteEdge(name); + info.valueForwarders.set(instance, name); + return name; } /** The closure of the instance of `info` that `target` pins, for a value diff --git a/tests/corpus/7180-generic-local-binding-early-uses.ts b/tests/corpus/7180-generic-local-binding-early-uses.ts index 85458d973..f3f7816b5 100644 --- a/tests/corpus/7180-generic-local-binding-early-uses.ts +++ b/tests/corpus/7180-generic-local-binding-early-uses.ts @@ -51,3 +51,19 @@ function counter(): () => number { return step; } console.log(counter()()); + +// Each evaluation of the declaration makes a new function object. +const first = make(); +console.log(first === make(), first === first, first(8)); +function looped(): string { + const seen: ((x: string) => string)[] = []; + for (let i = 0; i < 2; i++) { + const read = (): ((x: string) => string) => tag; + const tag: (x: string) => string = function (x: T): T { + return x; + }; + seen.push(read()); + } + return `${seen[0] === seen[1]} ${seen[1]!("p")}`; +} +console.log(looped()); From 3fecf687f542143adbb381bf6f182383b7baa7e8 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 06:31:30 -0500 Subject: [PATCH 072/102] Throw Node's TypeError for member reads of holes in wide unions A binding that may hold a value its declared type omits (a function parameter fed array elements, which can be holes) and that the checker narrowed to one record or class arm of a union with more than two arms was read through a checked extraction of that arm. When the binding held a hole, a member read or method call threw "undefined is not representable in the target union ..." for a record arm and "Value is not an instance of 'Shape'" for a class arm, where Node throws "Cannot read properties of undefined (reading 'a')". The read now tests for undefined first and throws Node's TypeError, as the two-arm path already does. --- .../lowering/expressions/narrowing.ts | 49 +++++++++++++++--- .../7280-named-reads-hole-receivers.ts.json | 6 +++ .../corpus/7280-named-reads-hole-receivers.ts | 50 +++++++++++++++++++ .../7280-named-reads-hole-receivers.ts.json | 1 + 4 files changed, 100 insertions(+), 6 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7280-named-reads-hole-receivers.ts.json create mode 100644 tests/corpus/7280-named-reads-hole-receivers.ts create mode 100644 tests/harness/corpus-costs/7280-named-reads-hole-receivers.ts.json diff --git a/packages/compiler/src/frontend/lowering/expressions/narrowing.ts b/packages/compiler/src/frontend/lowering/expressions/narrowing.ts index 2e3dd6140..786f3a337 100644 --- a/packages/compiler/src/frontend/lowering/expressions/narrowing.ts +++ b/packages/compiler/src/frontend/lowering/expressions/narrowing.ts @@ -985,11 +985,41 @@ export function runtimeOptionalReceiverRead( loc, }; } + // An array hole in a slot with more than two arms fails the member + // access with Node's TypeError before the checked extraction runs. + const holeGuarded = (extracted: IrExpr): IrExpr => { + if (local.type.kind !== "union") return extracted; + const holeTag = lowerer.armTag(local.type.unionId, UNDEFINED_T); + if (holeTag < 0) return extracted; + return { + kind: "ternary", + cond: { + kind: "unionIsTag", + unionId: local.type.unionId, + tag: holeTag, + negated: false, + value: varRef(local.id, local.type, loc), + type: BOOL, + loc, + }, + then: nodeThrowExpr( + 1, + "", + runtimeOptionalReceiverMessage(expr, property), + extracted.type, + loc, + ), + else_: extracted, + type: extracted.type, + loc, + }; + }; if (narrowed.kind === "object") { const view = checkedClassAssertion(lowerer, varRef(local.id, local.type, loc), narrowed, loc); // Preserve the member-specific missing-value error on the two-arm // path below; mixed storage also needs to validate its concrete class. - if (view && (lowerer.unions.get(local.type.unionId)?.arms.length ?? 0) > 2) return view; + if (view && (lowerer.unions.get(local.type.unionId)?.arms.length ?? 0) > 2) + return holeGuarded(view); } if (narrowed.kind === "record" && lowerer.armTag(local.type.unionId, narrowed) < 0) { const hosted = hostedStorageView(lowerer, varRef(local.id, local.type, loc), narrowed, loc); @@ -1014,7 +1044,9 @@ export function runtimeOptionalReceiverRead( "a direct read from a runtime-optional capture with multiple value arms", ); } - return lowerer.checkedNarrowCall(helper, varRef(local.id, local.type, loc), narrowed, loc); + return holeGuarded( + lowerer.checkedNarrowCall(helper, varRef(local.id, local.type, loc), narrowed, loc), + ); } // A predicate can strengthen a record's fields or narrow a base class // to a subclass without changing the slot's stored value arm. Extract @@ -1029,10 +1061,7 @@ export function runtimeOptionalReceiverRead( "a runtime-optional receiver without a representable value arm", ); } - const message = - property === null - ? `${expr.text} is not a function` - : `Cannot read properties of undefined (reading '${property}')`; + const message = runtimeOptionalReceiverMessage(expr, property); return lowerer.maybeNarrow( { kind: "ternary", @@ -1061,6 +1090,14 @@ export function runtimeOptionalReceiverRead( ); } +/** Node's TypeError message for a member read (`property`) or a call + * (`property` null) through an undefined runtime-optional receiver. */ +function runtimeOptionalReceiverMessage(expr: ts.Identifier, property: string | null): string { + return property === null + ? `${expr.text} is not a function` + : `Cannot read properties of undefined (reading '${property}')`; +} + export function runtimeOptionalTrueIds(lowerer: Lowerer, node: ts.Expression): IrLocal[] { return runtimeOptionalGuardIds(lowerer, node, true); } diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7280-named-reads-hole-receivers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7280-named-reads-hole-receivers.ts.json new file mode 100644 index 000000000..febb008f7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7280-named-reads-hole-receivers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7280-named-reads-hole-receivers.ts" + ], + "diags": [] +} diff --git a/tests/corpus/7280-named-reads-hole-receivers.ts b/tests/corpus/7280-named-reads-hole-receivers.ts new file mode 100644 index 000000000..59f0c4820 --- /dev/null +++ b/tests/corpus/7280-named-reads-hole-receivers.ts @@ -0,0 +1,50 @@ +// Named reads and method calls through a parameter narrowed to one arm of a +// wide union, when an array hole reaches the narrowed branch. +type Bag = number | string | number[] | { a?: number; f?: () => string }; +function isBag(value: Bag): value is { a?: number; f?: () => string } { + return !Array.isArray(value) && typeof value !== "string" && typeof value !== "number"; +} +function peek(value: Bag): string { + if (isBag(value)) return typeof value.a; + return "-"; +} +function call(value: Bag): string { + if (isBag(value)) return value.f?.() ?? "none"; + return "-"; +} +class Shape { + side: number; + constructor(side: number) { + this.side = side; + } + area(): number { + return this.side * this.side; + } +} +type Item = Shape | string | number; +function area(item: Item): number { + if (item instanceof Shape || (typeof item !== "string" && typeof item !== "number")) return item.area(); + return 0; +} +const bags: Bag[] = [{ a: 1, f: () => "f" }, "s", [1]]; +bags.length = 4; +const items: Item[] = [new Shape(2), "x"]; +items.length = 3; +const out: string[] = []; +for (let i = 0; i < bags.length; i++) { + for (const which of [0, 1]) { + try { + out.push(which === 0 ? peek(bags[i]) : call(bags[i])); + } catch (e) { + out.push(e instanceof TypeError ? e.message : "other"); + } + } +} +for (let i = 0; i < items.length; i++) { + try { + out.push(String(area(items[i]))); + } catch (e) { + out.push(e instanceof TypeError ? e.message : "other"); + } +} +console.log(out.join("\n")); diff --git a/tests/harness/corpus-costs/7280-named-reads-hole-receivers.ts.json b/tests/harness/corpus-costs/7280-named-reads-hole-receivers.ts.json new file mode 100644 index 000000000..db9f23551 --- /dev/null +++ b/tests/harness/corpus-costs/7280-named-reads-hole-receivers.ts.json @@ -0,0 +1 @@ +{ "plain": 4700, "san": 2400 } From 9b317ba97da174cc7949a8c849dd6c0fb5e56879 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 06:48:13 -0500 Subject: [PATCH 073/102] Allow the JSX lowering tests' TypeScript 5 import jsx-source.test.ts compares the JSX rewrite with TypeScript 5's transpileModule output, so it imports typescript5 as the other test oracles on the TypeScript 5 island allowlist do. scripts/test-ts7.mjs did not list it, and the TypeScript 7 parity job failed since #1786. --- scripts/test-ts7.mjs | 1 + 1 file changed, 1 insertion(+) diff --git a/scripts/test-ts7.mjs b/scripts/test-ts7.mjs index e022c1ff5..b776bea3e 100644 --- a/scripts/test-ts7.mjs +++ b/scripts/test-ts7.mjs @@ -25,6 +25,7 @@ if (process.argv.includes("--baselines-only")) { const ALLOWED_TYPESCRIPT5_IMPORTS = new Set([ "packages/compiler/src/frontend/comptime-node.ts", + "packages/compiler/src/frontend/jsx-source.test.ts", "packages/compiler/src/frontend/ts7/world-check.ts", "packages/compiler/src/frontend/ts7/source-parser.test.ts", "packages/compiler/src/library/semantic-source.ts", From 1f357b3091288cf7aafa51d988580fa0b66c6420 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 07:01:51 -0500 Subject: [PATCH 074/102] Fence non-Buffer chunk parameters on byte-mode stream callbacks again --- .../src/frontend/lowering/lower-stream.ts | 48 +++++++++++++++---- 1 file changed, 40 insertions(+), 8 deletions(-) diff --git a/packages/compiler/src/frontend/lowering/lower-stream.ts b/packages/compiler/src/frontend/lowering/lower-stream.ts index 14062051f..cb81348eb 100644 --- a/packages/compiler/src/frontend/lowering/lower-stream.ts +++ b/packages/compiler/src/frontend/lowering/lower-stream.ts @@ -289,6 +289,7 @@ function lowerStreamCallback( node: ts.MethodDeclaration | ts.FunctionExpression | ts.ArrowFunction, thisType: IrType, fullTuple: IrType[], + chunkValues = true, ): IrExpr { const loc = locOf(node); const { shapes, funcType } = lowerer.lambdaSignature(node); @@ -309,11 +310,13 @@ function lowerStreamCallback( // callable dyn whose glue dispatches to the runtime's *_done). if (funcType.params[i]!.kind === "dyn") continue; // A write or transform chunk of another type converts from the - // chunk's value when the callback runs (an object-mode side's value, - // or the Buffer), or throws a TypeError there; an encoding of another - // type (`string | null | undefined`) from the encoding argument's. + // chunk's value when the callback runs (an object-mode side's value), + // or throws a TypeError there — on a side known to be byte mode the + // chunk is a Buffer, so the declared type is the fence's; an encoding + // of another type (`string | null | undefined`) converts from the + // encoding argument's value. if ( - (i === 0 || i === 1) && + ((i === 0 && chunkValues) || i === 1) && (which === "write" || which === "transform") && funcType.params[i]!.kind !== "func" && canConvertToDyn( @@ -465,6 +468,20 @@ function streamObjectModes( return out; } +/** Whether an options literal sets the writable side's object mode with a + * `true` literal (objectMode, or writableObjectMode on a duplex stream). + * Reports nothing: streamObjectModes fences the other value forms. */ +function literalWritesValues(opts: ts.ObjectLiteralExpression, duplexish: boolean): boolean { + for (const prop of opts.properties?.nodes ?? []) { + if (!ts.isPropertyAssignment(prop)) continue; + const name = + ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name) ? prop.name.text : null; + if (name !== "objectMode" && !(duplexish && name === "writableObjectMode")) continue; + if (prop.initializer.kind !== ts.SyntaxKind.FalseKeyword) return true; + } + return false; +} + /** The full Node parameter tuples of the option callbacks, given the * concrete stream's `this` type. The trailing completion callbacks keep * whatever func type the checker contextually gave the user's parameter @@ -802,7 +819,10 @@ function parseStreamOptions( } return declared ?? funcOf([], VOID); }); - present.set(name, lowerStreamCallback(lowerer, name, fnNode, thisType, tuple)); + present.set( + name, + lowerStreamCallback(lowerer, name, fnNode, thisType, tuple, out.writableObject), + ); } finally { if (pinned) lowerer.stageSourceTypes.delete(pinned); } @@ -1151,6 +1171,7 @@ function streamMethodWrapper( thisType: IrType, loc: SrcLoc, blame: ts.Node, + chunkValues = true, ): IrExpr | null { const found = lowerer.findMethodOn(info, methodName); if (!found) { @@ -1235,10 +1256,11 @@ function streamMethodWrapper( continue; } // A write or transform chunk of another type converts from the - // chunk's value when the method runs (an object-mode side's value, - // or the Buffer), or throws a TypeError there. + // chunk's value when the method runs (an object-mode side's value), + // or throws a TypeError there; a byte-mode side's chunk is a Buffer. if ( i === 0 && + chunkValues && (which === "write" || which === "transform") && got.type.kind !== "func" && canConvertToDyn( @@ -1343,10 +1365,20 @@ export function lowerStreamSuperCall( ); } const shape = streamCtorShape(cls); + // Whether the writable side holds values: options read at run time may + // set objectMode, and a literal says so with objectMode (or a Duplex's + // writableObjectMode) true; otherwise _write and _transform receive + // Buffers. + const optsNode = argNodes[0] !== undefined ? followOptionsArg(lowerer, argNodes[0]) : null; + const chunkValues = + argNodes[0] !== undefined && + (optsNode === null || + !ts.isObjectLiteralExpression(optsNode) || + literalWritesValues(optsNode, cls !== "%Readable" && cls !== "%Writable")); const fallback = (name: string): IrExpr | null => { const methodName = UNDERSCORE_METHODS.get(name); return methodName - ? streamMethodWrapper(lowerer, info, name, methodName, thisType, loc, blame) + ? streamMethodWrapper(lowerer, info, name, methodName, thisType, loc, blame, chunkValues) : null; }; const thisRef = (): IrExpr => ({ kind: "varRef", localId: thisLocal.id, type: thisType, loc }); From 01dd4f6796c2deed78f330822c861e4cb73321e3 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 07:05:30 -0500 Subject: [PATCH 075/102] Keep the handle tags in name order and update two tests for current main --- packages/runtime/src/scr_dyn.h | 10 +++++----- tests/harness/library-profile.test.ts | 9 ++++++--- tests/harness/stream-entry-kinds.test.ts | 6 ++---- 3 files changed, 13 insertions(+), 12 deletions(-) diff --git a/packages/runtime/src/scr_dyn.h b/packages/runtime/src/scr_dyn.h index c9d090370..9607274e3 100644 --- a/packages/runtime/src/scr_dyn.h +++ b/packages/runtime/src/scr_dyn.h @@ -143,6 +143,7 @@ typedef enum { X(ABORT_CONTROLLER, 15) /* native static-fetch AbortController */ \ X(ABORT_SIGNAL, 8) /* native static-fetch AbortSignal */ \ X(ARRAY_BUFFER, 18) /* fixed-length ArrayBuffer storage */ \ + X(ASYMMETRIC_CRYPTO_KEY, 69) /* WebCrypto ECDSA and RSA CryptoKey (scr_webcrypto_pki.c) */ \ X(BLOB, 41) /* ScrBlob — new Blob() and Blob#slice() */ \ X(BROADCAST_CHANNEL, 51) /* worker_threads BroadcastChannel (scr_worker_events.c) */ \ X(BUILTIN_MODULE, 21) /* native builtin export object */ \ @@ -160,11 +161,6 @@ typedef enum { X(DIR, 44) /* fs.Dir (scr_lib.c) */ \ X(DISPOSABLE_STACK, 49) /* DisposableStack (scr_symbol.c) */ \ X(ECDH, 64) /* node:crypto ECDH (scr_ecdh.c) */ \ - X(PRIVATE_KEY, 65) /* node:crypto PrivateKeyObject (scr_pki.c) */ \ - X(PUBLIC_KEY, 66) /* node:crypto PublicKeyObject (scr_pki.c) */ \ - X(SIGN, 67) /* node:crypto Sign (scr_pki.c) */ \ - X(VERIFY, 68) /* node:crypto Verify (scr_pki.c) */ \ - X(ASYMMETRIC_CRYPTO_KEY, 69) /* WebCrypto ECDSA and RSA CryptoKey (scr_webcrypto_pki.c) */ \ X(EVENT, 14) /* ScrEvent — new Event() and AbortSignal's abort events */ \ X(EVENT_TARGET, 39) /* ScrEventTarget — new EventTarget() */ \ X(FETCH_HEADERS, 13) /* native static-fetch response Headers */ \ @@ -192,14 +188,18 @@ typedef enum { X(NET_SERVER, 3) /* ScrNetServer — net.Server (http.Server rides the same handle) */ \ X(NET_SOCKET, 2) /* ScrNetSocket — net.Socket */ \ X(NET_SOCKET_ADDRESS, 47) /* net.SocketAddress (scr_net.c) */ \ + X(PRIVATE_KEY, 65) /* node:crypto PrivateKeyObject (scr_pki.c) */ \ + X(PUBLIC_KEY, 66) /* node:crypto PublicKeyObject (scr_pki.c) */ \ X(REGEXP, 26) /* native RegExp, shared compiled pattern */ \ X(SEARCH_PARAMS, 33) /* live WHATWG URLSearchParams */ \ X(SEGMENTER, 19) /* default Unicode grapheme segmentation */ \ X(SEGMENTS, 20) /* iterable immutable segmentation result */ \ X(SET, 25) /* native Set, shared backing map */ \ X(SHARED_ARRAY_BUFFER, 37) \ + X(SIGN, 67) /* node:crypto Sign (scr_pki.c) */ \ X(STDIO, 27) /* stable process stdin/stdout/stderr values */ \ X(URL, 28) /* native WHATWG URL */ \ + X(VERIFY, 68) /* node:crypto Verify (scr_pki.c) */ \ X(WASM_GLOBAL, 61) /* WebAssembly.Global */ \ X(WASM_INSTANCE, 58) /* WebAssembly.Instance */ \ X(WASM_MEMORY, 59) /* WebAssembly.Memory */ \ diff --git a/tests/harness/library-profile.test.ts b/tests/harness/library-profile.test.ts index 2b28a6cd0..f327f8372 100644 --- a/tests/harness/library-profile.test.ts +++ b/tests/harness/library-profile.test.ts @@ -482,7 +482,10 @@ describe("library profile fences", () => { remediations: { SC2012: "the explicit map key wins" }, fences: [ { id: "diagnostic.sc2012", remediation: "request it as an effect" }, - { id: "node-builtin.crypto.createSign", remediation: "signatures come from the host" }, + { + id: "node-builtin.crypto.createDiffieHellman", + remediation: "key agreement comes from the host", + }, ], }, }), @@ -492,9 +495,9 @@ describe("library profile fences", () => { // Explicit remediations keys win over fence-supplied text. expect(profileRemediation(r.profile, "SC2012")).toBe("the explicit map key wins"); // A fence's remediation answers for its covered entries' codes - // (crypto.createSign is SC2020) — spec §3's "in a fence entry or a + // (crypto.createDiffieHellman is SC2020) — spec §3's "in a fence entry or a // remediations map", one lookup either way. - expect(profileRemediation(r.profile, "SC2020")).toBe("signatures come from the host"); + expect(profileRemediation(r.profile, "SC2020")).toBe("key agreement comes from the host"); expect(profileRemediation(r.profile, "SC4014")).toBeUndefined(); }); diff --git a/tests/harness/stream-entry-kinds.test.ts b/tests/harness/stream-entry-kinds.test.ts index f7333b298..ec89c5914 100644 --- a/tests/harness/stream-entry-kinds.test.ts +++ b/tests/harness/stream-entry-kinds.test.ts @@ -138,7 +138,7 @@ r.once('readable', () => { expect(r.stdout).toBe(`caught ${READ_FENCE_MESSAGE}\n`); }); - test("a dynamic source that mixes Buffers and strings without a decoder is destroyed", async () => { + test("a dynamic source that mixes Buffers and strings yields each as it is, as Node does", async () => { const r = await compileAndRun( "mixed-dynamic-source", `import { Readable } from "node:stream"; @@ -151,8 +151,6 @@ r.on("close", () => console.log("close")); `, ); expect(r.exitCode).toBe(0); - expect(r.stdout).toBe( - "data true b1\nerror a Readable.from source that mixes strings and Buffers is not supported yet\nclose\n", - ); + expect(r.stdout).toBe("data true b1\ndata false s1\nclose\n"); }); }); From f87a04fa06b0e2e9b547b435542220a59d2761ae Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 07:08:26 -0500 Subject: [PATCH 076/102] Build typed 'message' listener parameters from the message A 'message' listener with a typed parameter received each message as a checked-dynamic value: the port decoded the message into dyn objects, the listener's thunk matched the value against each union arm, read every field again to build the record, and the dyn objects were then released. For bench/channel-messages that was about a third of the delivery time. - A closure registered with on, once, addListener, prependListener or prependOnceListener for 'message' gets a typed message entry when its parameter is a number, boolean, string, a record of those without union fields, or a boxed union of those arms with null or undefined. The entry builds the parameter from the message's nodes and calls the closure. - The entry handles a message only when it has the parameter's exact layout: the union arm the checked conversion picks, and a record's declared keys in declaration order with no others. Any other message runs through the thunk on the decoded value, as before, so undeclared keys, other orders and mismatches behave as they did. - Ports, workers and parentPort deliver a message through the entries when no value in it is reached twice and it holds no ports or native handles. Listeners without an entry share one decoded value, made when the first of them runs. - The message readers are runtime entry points, so the runtime ABI is now 27. Corpus 7130 and 7131 check typed listeners on MessageChannel ports, a worker and parentPort against Node: exact layouts, extra keys, shared values, nested records, untyped listeners beside typed ones, once listeners and a transferred port. --- packages/cli/test/native-link-info.test.ts | 4 +- packages/compiler/src/backend/llvm/dyn.ts | 300 ++++++++++++++++++ .../compiler/src/backend/llvm/expr-dynamic.ts | 35 ++ packages/compiler/src/backend/runtime-abi.ts | 4 +- .../src/backend/runtime-pack-targets.test.ts | 2 +- .../compiler/src/backend/runtime-pack.test.ts | 2 +- .../test/native-codegen-integration.test.ts | 4 +- .../7130-typed-message-listeners.ts.json | 6 + .../corpus/7131-typed-worker-messages.ts.json | 6 + .../runtime-darwin-arm64/scripts/build.mjs | 2 +- .../runtime-pack-common/scripts/build.mjs | 2 +- packages/runtime/src/scr_console.c | 2 +- packages/runtime/src/scr_core.h | 2 +- packages/runtime/src/scr_dyn.h | 57 +++- packages/runtime/src/scr_events_emitter.c | 54 +++- packages/runtime/src/scr_events_emitter.h | 6 + packages/runtime/src/scr_json.c | 7 + packages/runtime/src/scr_message.c | 69 ++-- packages/runtime/src/scr_message.test.c | 47 +++ packages/runtime/src/scr_worker_events.c | 24 ++ tests/corpus/7130-typed-message-listeners.ts | 80 +++++ tests/corpus/7131-typed-worker-messages.ts | 54 ++++ .../7130-typed-message-listeners.ts.json | 1 + .../7131-typed-worker-messages.ts.json | 1 + .../self-hosting-native-toolchain.test.ts | 2 +- 25 files changed, 718 insertions(+), 55 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7130-typed-message-listeners.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7131-typed-worker-messages.ts.json create mode 100644 tests/corpus/7130-typed-message-listeners.ts create mode 100644 tests/corpus/7131-typed-worker-messages.ts create mode 100644 tests/harness/corpus-costs/7130-typed-message-listeners.ts.json create mode 100644 tests/harness/corpus-costs/7131-typed-worker-messages.ts.json diff --git a/packages/cli/test/native-link-info.test.ts b/packages/cli/test/native-link-info.test.ts index 630ef7173..a7a5e718a 100644 --- a/packages/cli/test/native-link-info.test.ts +++ b/packages/cli/test/native-link-info.test.ts @@ -72,7 +72,7 @@ describe.runIf(supported)("macOS arm64 native link info", () => { minimum_os: "14.0", }, program: { object, entry_symbol: "main" }, - runtime_abi: { version: 26, marker: "scr_runtime_abi_v26" }, + runtime_abi: { version: 27, marker: "scr_runtime_abi_v27" }, runtime_pack: { kind: "precompiled", package: "@scriptc/runtime-darwin-arm64", @@ -165,6 +165,6 @@ describe.runIf(supported)("macOS arm64 native link info", () => { () => null, (failure: { stderr?: string }) => failure, ); - expect(error?.stderr).toContain("scr_runtime_abi_v26"); + expect(error?.stderr).toContain("scr_runtime_abi_v27"); }); }); diff --git a/packages/compiler/src/backend/llvm/dyn.ts b/packages/compiler/src/backend/llvm/dyn.ts index 6911ef98b..ac01a9209 100644 --- a/packages/compiler/src/backend/llvm/dyn.ts +++ b/packages/compiler/src/backend/llvm/dyn.ts @@ -108,6 +108,15 @@ const DYN_HANDLE_UNBOX_FN: Record = { dgramSocket: "scr_dgram_from_dyn", }; +/** ScrMessageKind (scr_message.h): the node kinds message readers test. */ +const MESSAGE_KIND = { + UNDEFINED: 0, + NULL: 1, + BOOL: 2, + NUMBER: 3, + STRING: 4, +} as const; + export const DYN_KIND = { NULL: 0, BOOL: 1, @@ -173,6 +182,8 @@ export class LlDyn { private readonly dynFuncThunks = new Map(); private readonly dynFuncBoxes = new Map(); private readonly dynFuncAdapters = new Map(); + private readonly messageListeners = new Map(); + private readonly messageReaders = new Map(); private readonly promiseDynAdapters = new Map(); private readonly mapDynOps = new Map(); private dynToStrFn: string | null = null; @@ -4610,6 +4621,295 @@ export class LlDyn { return name; } + /** `sc_dml_(ptr c, ptr message) -> i1`, the typed message entry of a + * closure registered as a 'message' listener (ScrDynMessageListener): + * builds the closure's parameter from the message's nodes and calls the + * closure. It answers false, without calling it, when the message does + * not have the parameter's exact layout, and the listener then runs + * through its thunk on the decoded message, as before. Null when the + * signature's parameter has no message reader (messageReadable). */ + messageListenerHelper(t: IrType & { kind: "func" }): string | null { + const key = typeKey(t); + const existing = this.messageListeners.get(key); + if (existing !== undefined) return existing; + const param = t.params[0]; + const supported = + t.params.length === 1 && + t.rest !== true && + param !== undefined && + (t.ret.kind === "void" || t.ret.kind === "f64" || t.ret.kind === "bool") && + this.messageReadable(param, new Set()); + if (!supported) { + this.messageListeners.set(key, null); + return null; + } + const name = `sc_dml_${this.messageListeners.size}`; + this.messageListeners.set(key, name); + const B = new BlockBuilder(); + B.entryAllocas.push(`%fail = alloca i1`); + B.line(`store i1 false, ptr %fail`); + const value = B.tmp(); + B.line( + `${value} = call ${this.valTy(param)} @${this.messageReaderHelper(param)}(ptr %m, ${this.host.sizeType} 0, ptr %fail)`, + ); + const failed = B.tmp(); + B.line(`${failed} = load i1, ptr %fail`); + const lMiss = B.newLabel("dml.miss"); + const lCall = B.newLabel("dml.call"); + B.condBr(failed, lMiss, lCall); + B.startBlock(lMiss); + B.terminate(`ret i1 false`); + B.startBlock(lCall); + // The closure consumes its parameter; a pending exception stays for + // the emitter, as after the thunk. + const fnp = B.tmp(); + const fn = B.tmp(); + B.line(`${fnp} = getelementptr inbounds %ScrClosure, ptr %c, i64 0, i32 1`); + B.line(`${fn} = load ptr, ptr ${fnp}`); + const args = `ptr %c, ${this.valTy(param)} ${value}`; + if (t.ret.kind === "void") B.line(`call void ${fn}(${args})`); + else B.line(`${B.tmp()} = call ${this.valTy(t.ret)} ${fn}(${args})`); + B.terminate(`ret i1 true`); + this.defs.push( + `define internal zeroext i1 @${name}(ptr %c, ptr %m) ${FN_ATTRS} { ; message entry for ${llvmCommentText(key)}`, + B.render(), + `}`, + ``, + ); + return name; + } + + /** Whether a message reader can build T: numbers, booleans and strings; + * records of them with only declared fields, none of union type; and + * boxed unions of those arms and null or undefined, with at most one + * number, boolean and string arm. */ + private messageReadable(t: IrType, seen: Set): boolean { + switch (t.kind) { + case "f64": + case "bool": + case "string": + return true; + case "record": { + const shape = this.host.recordsById.get(t.shapeId); + if (!shape || shape.tuple || shape.indexValue || shape.fields.length === 0) return false; + if (seen.has(t.shapeId) || this.isRecursiveShape(t)) return false; + seen.add(t.shapeId); + const readable = shape.fields.every( + (f) => + !f.name.startsWith("%") && + f.type.kind !== "union" && + llFieldType(f.type, this.host.inlineUnions.record(f.type)) !== INLINE_UNION_FIELD && + this.messageReadable(f.type, seen), + ); + seen.delete(t.shapeId); + return readable; + } + case "union": { + const def = this.host.unionsById.get(t.unionId); + if (!def || this.host.nullableUnions.has(t.unionId)) return false; + const scalars = new Set(); + for (const arm of def.arms) { + if (arm.kind === "nullT" || arm.kind === "undefinedT") continue; + if (arm.kind === "f64" || arm.kind === "bool" || arm.kind === "string") { + if (scalars.has(arm.kind)) return false; + scalars.add(arm.kind); + continue; + } + if (arm.kind !== "record" || !this.messageReadable(arm, seen)) return false; + } + return true; + } + default: + return false; + } + } + + /** `sc_dmr_(ptr message, size node, ptr fail) -> T`: T (+1) built + * from a message node, for a type messageReadable accepts. Sets *fail + * and returns a dummy when the node does not have T's layout: the arm + * the checked conversion would choose, a record's declared keys in + * declaration order and no others. */ + private messageReaderHelper(t: IrType): string { + const key = typeKey(t); + const existing = this.messageReaders.get(key); + if (existing) return existing; + const name = `sc_dmr_${this.messageReaders.size}`; + this.messageReaders.set(key, name); + const host = this.host; + const S = host.sizeType; + if (t.kind !== "record") host.declare(`declare i32 @scr_message_kind(ptr, ${S})`); + const retTy = this.valTy(t); + const dummy = retTy === "double" ? f64Lit(0) : retTy === "i1" ? "false" : "null"; + const B = new BlockBuilder(); + const lFail = B.newLabel("dmr.fail"); + // scr_message_fields tests a record's kind itself. + const kind = B.tmp(); + if (t.kind !== "record") B.line(`${kind} = call i32 @scr_message_kind(ptr %m, ${S} %n)`); + const requireKind = (want: number): void => { + const ok = B.tmp(); + B.line(`${ok} = icmp eq i32 ${kind}, ${want}`); + const lOk = B.newLabel("dmr.kind"); + B.condBr(ok, lOk, lFail); + B.startBlock(lOk); + }; + switch (t.kind) { + case "f64": + case "bool": { + host.declare(`declare double @scr_message_number(ptr, ${S})`); + requireKind(t.kind === "f64" ? MESSAGE_KIND.NUMBER : MESSAGE_KIND.BOOL); + const n = B.tmp(); + B.line(`${n} = call double @scr_message_number(ptr %m, ${S} %n)`); + if (t.kind === "f64") B.terminate(`ret double ${n}`); + else { + const b = B.tmp(); + B.line(`${b} = fcmp une double ${n}, ${f64Lit(0)}`); + B.terminate(`ret i1 ${b}`); + } + break; + } + case "string": { + host.declare(`declare ptr @scr_message_string(ptr, ${S})`); + requireKind(MESSAGE_KIND.STRING); + const str = B.tmp(); + B.line(`${str} = call ptr @scr_message_string(ptr %m, ${S} %n)`); + B.terminate(`ret ptr ${str}`); + break; + } + case "record": { + const shape = host.recordsById.get(t.shapeId)!; + const order = recordSourceFieldOrder(shape); + const fields = new Map(shape.fields.map((f, i) => [f.name, { field: f, index: i }])); + const base = host.nullableUnions.fieldBase(t.shapeId); + const struct = mangleRecordStruct(t.shapeId); + const names = this.recordNameTable(t.shapeId, shape); + host.declare(`declare zeroext i1 @scr_message_fields(ptr, ${S}, ptr, ptr, ${S}, ptr)`); + B.entryAllocas.push(`%kids = alloca [${order.length} x ${S}]`); + const matched = B.tmp(); + B.line( + `${matched} = call zeroext i1 @scr_message_fields(ptr %m, ${S} %n, ptr ${names.names}, ptr ${names.lens}, ${S} ${order.length}, ptr %kids)`, + ); + const lBuild = B.newLabel("dmr.build"); + B.condBr(matched, lBuild, lFail); + B.startBlock(lBuild); + B.line(`%r0 = call ptr @${mangleRecordNew(t.shapeId)}()`); + order.forEach((fieldName, i) => { + const { field, index } = fields.get(fieldName)!; + const kidp = B.tmp(); + const kid = B.tmp(); + B.line( + `${kidp} = getelementptr inbounds [${order.length} x ${S}], ptr %kids, i64 0, i64 ${i}`, + ); + B.line(`${kid} = load ${S}, ptr ${kidp}`); + const v = B.tmp(); + B.line( + `${v} = call ${this.valTy(field.type)} @${this.messageReaderHelper(field.type)}(ptr %m, ${S} ${kid}, ptr %fail)`, + ); + const failed = B.tmp(); + B.line(`${failed} = load i1, ptr %fail`); + const lDrop = B.newLabel("dmr.drop"); + const lStore = B.newLabel("dmr.store"); + B.condBr(failed, lDrop, lStore); + B.startBlock(lDrop); + B.line(`call void ${releaseSym(host, t)}(ptr %r0)`); + B.terminate(`ret ptr null`); + B.startBlock(lStore); + const p = B.tmp(); + B.line( + `${p} = getelementptr inbounds %${struct}, ptr %r0, i64 0, i32 ${index + base} ; .${llvmCommentText(fieldName)}`, + ); + const fieldTy = llFieldType(field.type, host.inlineUnions.record(field.type)); + if (fieldTy === "i8") { + const z = B.tmp(); + B.line(`${z} = zext i1 ${v} to i8`); + B.line(`store i8 ${z}, ptr ${p}`); + } else { + B.line(`store ${fieldTy} ${v}, ptr ${p}`); + } + }); + B.terminate(`ret ptr %r0`); + break; + } + case "union": { + const def = host.unionsById.get(t.unionId)!; + def.arms.forEach((arm, i) => { + const lNext = B.newLabel("dmr.next"); + if (arm.kind === "nullT" || arm.kind === "undefinedT") { + const hit = B.tmp(); + B.line( + `${hit} = icmp eq i32 ${kind}, ${arm.kind === "nullT" ? MESSAGE_KIND.NULL : MESSAGE_KIND.UNDEFINED}`, + ); + const lHit = B.newLabel("dmr.unit"); + B.condBr(hit, lHit, lNext); + B.startBlock(lHit); + B.terminate(`ret ptr ${host.unitInstanceRef(t.unionId, i)}`); + B.startBlock(lNext); + return; + } + if (arm.kind !== "record") { + const want = + arm.kind === "f64" + ? MESSAGE_KIND.NUMBER + : arm.kind === "bool" + ? MESSAGE_KIND.BOOL + : MESSAGE_KIND.STRING; + const hit = B.tmp(); + B.line(`${hit} = icmp eq i32 ${kind}, ${want}`); + const lHit = B.newLabel("dmr.arm"); + B.condBr(hit, lHit, lNext); + B.startBlock(lHit); + } + // A record arm that does not match leaves *fail clear for the + // next arm, like the checked conversion's next-arm match. + const v = B.tmp(); + B.line( + `${v} = call ${this.valTy(arm)} @${this.messageReaderHelper(arm)}(ptr %m, ${S} %n, ptr %fail)`, + ); + if (arm.kind === "record") { + const failed = B.tmp(); + B.line(`${failed} = load i1, ptr %fail`); + const lHit = B.newLabel("dmr.arm"); + const lMiss = B.newLabel("dmr.miss"); + B.condBr(failed, lMiss, lHit); + B.startBlock(lMiss); + B.line(`store i1 false, ptr %fail`); + B.br(lNext); + B.startBlock(lHit); + } + const u = B.tmp(); + if (arm.kind === "f64") { + host.declare(`declare ptr @scr_union_new_f64(i32, double)`); + B.line(`${u} = call ptr @scr_union_new_f64(i32 ${i}, double ${v})`); + } else if (arm.kind === "bool") { + host.declare(`declare ptr @scr_union_new_bool(i32, i1 zeroext)`); + B.line(`${u} = call ptr @scr_union_new_bool(i32 ${i}, i1 ${v})`); + } else { + const rc = vAdapters(host, arm); + host.declare(`declare ptr @scr_union_new_ref(i32, ptr, ptr, ptr, ptr)`); + B.line( + `${u} = call ptr @scr_union_new_ref(i32 ${i}, ptr ${v}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${traceArg(host, arm)})`, + ); + } + B.terminate(`ret ptr ${u}`); + B.startBlock(lNext); + }); + B.br(lFail); + break; + } + default: + throw new InternalCompilerError(`llvm emitter bug: message reader of ${key}`); + } + B.startBlock(lFail); + B.line(`store i1 true, ptr %fail`); + B.terminate(`ret ${retTy} ${dummy}`); + this.defs.push( + `define internal ${retTy === "i1" ? "zeroext i1" : retTy} @${name}(ptr %m, ${S} %n, ptr %fail) ${FN_ATTRS} { ; message reader for ${llvmCommentText(key)}`, + B.render(), + `}`, + ``, + ); + return name; + } + /** The adapter closure body for one TARGET signature: caps[0] is an * untraced obj-box owning the dyn function value. */ dynFuncAdapterHelper(t: IrType & { kind: "func" }): string { diff --git a/packages/compiler/src/backend/llvm/expr-dynamic.ts b/packages/compiler/src/backend/llvm/expr-dynamic.ts index 563a900f8..58bb90569 100644 --- a/packages/compiler/src/backend/llvm/expr-dynamic.ts +++ b/packages/compiler/src/backend/llvm/expr-dynamic.ts @@ -16,6 +16,7 @@ import { streamTypedRefEligible } from "../../ir/analysis.js"; import { DYN, type IrExpr, + type IrType, isDynTypedRefType, isRefCounted, isUnitType, @@ -221,6 +222,19 @@ export function emitDynamicExpr( host.own({ name: prepared, type: { kind: "dyn" } }); host.emitPendingCheck(); const args = e.args.map((a) => emitBorrowedInput(host, a)); + // A closure registered as a 'message' listener gets a typed message + // entry: ports deliver messages of its parameter's layout without + // decoding them to checked-dynamic values first. + const listener = messageListenerArg(e); + if (listener !== null) { + const entry = host.dyn.messageListenerHelper(listener); + if (entry !== null) { + host.declare(`declare void @scr_dyn_func_set_message(ptr, ptr, ptr)`); + B.line( + `call void @scr_dyn_func_set_message(ptr ${args[1]!.name}, ptr @${host.dyn.dynFuncThunkHelper(listener)}, ptr @${entry})`, + ); + } + } let argsPtr = "null"; if (args.length > 0) { const arr = B.slot(); @@ -1323,3 +1337,24 @@ export const INHERITED_OBJECT_MEMBERS: ReadonlySet = new Set([ "hasOwnProperty", "propertyIsEnumerable", ]); + +/** EventEmitter methods that register their second argument as a listener. */ +const LISTENER_METHODS: ReadonlySet = new Set([ + "on", + "once", + "addListener", + "prependListener", + "prependOnceListener", +]); + +/** The closure type of `recv.on("message", listener)` and the other + * listener registrations with a typed closure for the 'message' event, or + * null. */ +function messageListenerArg(e: ExprOf<"dynInvoke">): (IrType & { kind: "func" }) | null { + if (!LISTENER_METHODS.has(e.method) || e.args.length !== 2) return null; + const [event, listener] = e.args; + if (event?.kind !== "dynFrom" || event.value.kind !== "strLit" || event.value.value !== "message") + return null; + if (listener?.kind !== "dynFrom" || listener.value.type.kind !== "func") return null; + return listener.value.type; +} diff --git a/packages/compiler/src/backend/runtime-abi.ts b/packages/compiler/src/backend/runtime-abi.ts index 703e8fe48..3a41d9176 100644 --- a/packages/compiler/src/backend/runtime-abi.ts +++ b/packages/compiler/src/backend/runtime-abi.ts @@ -2,8 +2,8 @@ * of the link contract: a program object keeps this symbol undefined and the * matching runtime defines it, so incompatible manual links fail before the * program can start. */ -export const RUNTIME_ABI_VERSION = 26 as const; -export const RUNTIME_ABI_MARKER = "scr_runtime_abi_v26" as const; +export const RUNTIME_ABI_VERSION = 27 as const; +export const RUNTIME_ABI_MARKER = "scr_runtime_abi_v27" as const; /** Object consumption is useful today, but the complete scr_* surface may * still change before 1.0. The versioned marker prevents accidental mixing; diff --git a/packages/compiler/src/backend/runtime-pack-targets.test.ts b/packages/compiler/src/backend/runtime-pack-targets.test.ts index c884f1132..af61e5229 100644 --- a/packages/compiler/src/backend/runtime-pack-targets.test.ts +++ b/packages/compiler/src/backend/runtime-pack-targets.test.ts @@ -52,7 +52,7 @@ async function fixture(target: NativeTargetSpec, workers = false) { object_format: target.objectFormat, minimum_os: target.minimumOs, }, - runtime_abi: { version: 26, marker: "scr_runtime_abi_v26" }, + runtime_abi: { version: 27, marker: "scr_runtime_abi_v27" }, compiler: { command: "fixture", identity: "fixture", target: target.llvmTriple }, macros: { executable: [], excluded: ["SCR_LIB"], sanitizer: "external-toolchain-required" }, flavors: { diff --git a/packages/compiler/src/backend/runtime-pack.test.ts b/packages/compiler/src/backend/runtime-pack.test.ts index 3a0b7870a..d09509911 100644 --- a/packages/compiler/src/backend/runtime-pack.test.ts +++ b/packages/compiler/src/backend/runtime-pack.test.ts @@ -127,7 +127,7 @@ async function fixture(target: NativeTargetSpec = MACOS_ARM64_TARGET) { object_format: target.objectFormat, minimum_os: target.minimumOs, }, - runtime_abi: { version: 26, marker: "scr_runtime_abi_v26" }, + runtime_abi: { version: 27, marker: "scr_runtime_abi_v27" }, compiler: { command: "clang", identity: "fixture clang", diff --git a/packages/compiler/test/native-codegen-integration.test.ts b/packages/compiler/test/native-codegen-integration.test.ts index af8d9b724..35a747d60 100644 --- a/packages/compiler/test/native-codegen-integration.test.ts +++ b/packages/compiler/test/native-codegen-integration.test.ts @@ -378,7 +378,7 @@ done: expect(await symbols(helperObject, ["-u"])).toEqual(await symbols(clangObject, ["-u"])); expect(await symbols(helperObject, ["-gU"])).toEqual(await symbols(clangObject, ["-gU"])); expect(await symbols(helperObject, ["-gU"])).toEqual(["0000000000000000 T _main"]); - expect(await symbols(helperObject, ["-u"])).toContain("_scr_runtime_abi_v26"); + expect(await symbols(helperObject, ["-u"])).toContain("_scr_runtime_abi_v27"); const clangExe = join(dir, "clang-program"); const linkDriver = join(dir, "clang-driver.c"); @@ -712,7 +712,7 @@ done: .split("\n"); expect(undefinedSymbols).toContain("_sf_scale"); expect(undefinedSymbols).toContain("_sf_callback_mix"); - expect(undefinedSymbols).toContain("_scr_runtime_abi_v26"); + expect(undefinedSymbols).toContain("_scr_runtime_abi_v27"); }); test("helper and clang object paths retain the same outbound FFI C ABI", async () => { diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7130-typed-message-listeners.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7130-typed-message-listeners.ts.json new file mode 100644 index 000000000..f02244324 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7130-typed-message-listeners.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7130-typed-message-listeners.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7131-typed-worker-messages.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7131-typed-worker-messages.ts.json new file mode 100644 index 000000000..89a6c125a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7131-typed-worker-messages.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7131-typed-worker-messages.ts" + ], + "diags": [] +} diff --git a/packages/runtime-darwin-arm64/scripts/build.mjs b/packages/runtime-darwin-arm64/scripts/build.mjs index 012b86013..631750cdf 100644 --- a/packages/runtime-darwin-arm64/scripts/build.mjs +++ b/packages/runtime-darwin-arm64/scripts/build.mjs @@ -340,7 +340,7 @@ async function build() { package: packageManifest.name, version: packageManifest.version, target: RUNTIME_PACK_MATRIX.target, - runtime_abi: { version: 26, marker: "scr_runtime_abi_v26" }, + runtime_abi: { version: 27, marker: "scr_runtime_abi_v27" }, compiler: { command: compiler, identity: compilerVersion, diff --git a/packages/runtime-pack-common/scripts/build.mjs b/packages/runtime-pack-common/scripts/build.mjs index 5b8f3563f..0e81033ad 100644 --- a/packages/runtime-pack-common/scripts/build.mjs +++ b/packages/runtime-pack-common/scripts/build.mjs @@ -437,7 +437,7 @@ async function build() { package: packageManifest.name, version: packageManifest.version, target: matrix.target, - runtime_abi: { version: 26, marker: "scr_runtime_abi_v26" }, + runtime_abi: { version: 27, marker: "scr_runtime_abi_v27" }, compiler: { command: compiler, identity: compilerVersion, diff --git a/packages/runtime/src/scr_console.c b/packages/runtime/src/scr_console.c index 24cd8093b..a3ac43cc0 100644 --- a/packages/runtime/src/scr_console.c +++ b/packages/runtime/src/scr_console.c @@ -148,7 +148,7 @@ static void scr_enable_utf8_console_output(void) { } #endif -void scr_runtime_abi_v26(void) {} +void scr_runtime_abi_v27(void) {} void scr_init(void) { #ifdef SCR_WORKERS diff --git a/packages/runtime/src/scr_core.h b/packages/runtime/src/scr_core.h index 791c600c7..fea020d16 100644 --- a/packages/runtime/src/scr_core.h +++ b/packages/runtime/src/scr_core.h @@ -81,7 +81,7 @@ void scr_init(void); /* Program objects emitted by the bundled LLVM helper reference this symbol. * Its versioned spelling makes a mismatched manual runtime link fail before * the program can start. */ -void scr_runtime_abi_v26(void); +void scr_runtime_abi_v27(void); void scr_runtime_workers_v8(void); /* ── the trap funnel (scr_console.c; scr_library.c under -DSCR_LIB) ────── diff --git a/packages/runtime/src/scr_dyn.h b/packages/runtime/src/scr_dyn.h index c9d090370..2602e0341 100644 --- a/packages/runtime/src/scr_dyn.h +++ b/packages/runtime/src/scr_dyn.h @@ -1,6 +1,7 @@ /* scriptc runtime — dynamic values: the checked-dynamic tree, native handles, * dyn promises, the ambient receiver and listener adapters (scr_json.c, - * scr_dyn_handle.c, scr_async_dyn.c). Included by scr_runtime.h, which says + * scr_dyn_handle.c, scr_async_dyn.c), and the message readers of typed + * 'message' listeners (scr_message.c). Included by scr_runtime.h, which says * where new declarations go. */ #ifndef SCR_DYN_H #define SCR_DYN_H @@ -254,6 +255,55 @@ typedef struct ScrDynTypedCast { * result as an owned (+1) dyn value. `args` entries are BORROWED. */ typedef ScrDyn *(*ScrDynThunk)(ScrClosure *clo, ScrDyn *const *args, size_t argc); +/* A compiled 'message' listener's typed entry: builds the closure's + * parameter from the message's nodes (the readers below) and calls + * the closure. Answers false, without calling it, when the message does + * not have the parameter's layout; the caller then decodes the message + * and calls the thunk. */ +struct ScrMessage; +typedef bool (*ScrDynMessageListener)(ScrClosure *clo, const struct ScrMessage *message); + +/* The kinds of a message's nodes (scr_message.c). */ +typedef enum { + SCR_MESSAGE_UNDEFINED, + SCR_MESSAGE_NULL, + SCR_MESSAGE_BOOL, + SCR_MESSAGE_NUMBER, + SCR_MESSAGE_STRING, + SCR_MESSAGE_BIGINT, + SCR_MESSAGE_ARRAY, + SCR_MESSAGE_OBJECT, + SCR_MESSAGE_STORAGE, + SCR_MESSAGE_BYTES, + SCR_MESSAGE_ARRAY_BUFFER, + SCR_MESSAGE_ERROR, + /* A deeply frozen plain-data graph shared by pointer (see publication). */ + SCR_MESSAGE_PUBLISHED, + /* A typed value published with @scriptc/threads (immortal), delivered as + * a fresh typed-ref capsule over the same pointer. */ + SCR_MESSAGE_TYPED_REF, + /* A transferred MessagePort: its channel end (+1) and side. */ + SCR_MESSAGE_PORT, + /* A native handle cloned through its unit's ScrDynHandleTransfer. */ + SCR_MESSAGE_HANDLE, +} ScrMessageKind; + +/* Readers for compiled 'message' listeners (ScrDynMessageListener), which + * build their typed parameter from the nodes. Node 0 is the root, and a + * node's values have higher numbers. scr_message_readable answers whether + * the message can reach these listeners: no node is reached twice, and it + * holds no ports or native handles, which the receiver adopts when it + * decodes the message. kind answers a ScrMessageKind; number reads a + * NUMBER or BOOL node, string a STRING node (+1). fields answers whether an + * OBJECT node has exactly the given keys, in order, and writes their value + * nodes. */ +bool scr_message_readable(const struct ScrMessage *message); +int32_t scr_message_kind(const struct ScrMessage *message, size_t node); +double scr_message_number(const struct ScrMessage *message, size_t node); +ScrStr *scr_message_string(const struct ScrMessage *message, size_t node); +bool scr_message_fields(const struct ScrMessage *message, size_t node, const char *const *names, + const size_t *lengths, size_t count, size_t *values); + /* Object member. Keys own shared immutable UTF-8 bytes (NUL-terminated for * convenience; key_len excludes the NUL) — duplicate keys were already * collapsed at parse time (later wins, like JS JSON.parse). */ @@ -391,7 +441,7 @@ struct ScrDyn { * and `name` are static compiler-emitted literals (never freed); name * may be NULL (anonymous — inspect prints [Function (anonymous)]). * The dyn→closure ownership edge is traced by the cycle collector. */ - struct { ScrClosure *clo; ScrDynThunk thunk; const char *sig; const char *name; uint32_t arity; ScrClassObj *class_obj; } fn; + struct { ScrClosure *clo; ScrDynThunk thunk; const char *sig; const char *name; uint32_t arity; ScrClassObj *class_obj; ScrDynMessageListener message; } fn; /* Native handles normally keep conservative ownership edges. Sets * backed by cycle-capable maps expose their edge to the collector. * Cache that allocation property: during collection the map may be @@ -1246,6 +1296,9 @@ ScrDyn *scr_dyn_define_prototype_props(ScrDyn *target, ScrDyn *descs, ScrDyn *pr * (callers retain first when they keep their own reference); `sig`/`name` * must be static literals (the box never frees them; name may be NULL). */ ScrDyn *scr_dyn_new_func(ScrClosure *clo, ScrDynThunk thunk, uint32_t arity, const char *sig, const char *name); +/* Gives a function box made with thunk its typed message entry (an + * EventEmitter listener registered from it keeps the entry). */ +void scr_dyn_func_set_message(ScrDyn *fn, ScrDynThunk thunk, ScrDynMessageListener listener); ScrDyn *scr_dyn_new_class(ScrClassObj *cls, const char *type_key); /* EventEmitter and the stream constructors as untyped constructor values, * and instanceof over untyped constructor functions diff --git a/packages/runtime/src/scr_events_emitter.c b/packages/runtime/src/scr_events_emitter.c index 901e2d114..5e03c0d6c 100644 --- a/packages/runtime/src/scr_events_emitter.c +++ b/packages/runtime/src/scr_events_emitter.c @@ -82,6 +82,8 @@ typedef struct ScrEeEntry { * the meta events. */ ScrClosure *flex_cb; ScrDynThunk flex_invoke; + /* The function box's typed message entry (scr_emitter_emit_message). */ + ScrDynMessageListener flex_message; const char *flex_sig; const char *flex_name; uint32_t flex_arity; @@ -512,6 +514,7 @@ static ScrEmitter *scr_ee_add(ScrEmitter *em, ScrStr *name, ScrClosure *cb /*mov if (dyn) { e->flex_cb = scr_closure_retain(dyn->v.fn.clo); e->flex_invoke = dyn->v.fn.thunk; + e->flex_message = dyn->v.fn.message; e->flex_sig = dyn->v.fn.sig; e->flex_name = dyn->v.fn.name; e->flex_arity = dyn->v.fn.arity; @@ -1013,15 +1016,16 @@ static ScrDyn *const scr_ee_no_args[1] = { NULL }; * a nested emit's snapshot still holds it (the shared fired flag — Node's * wrapper.fired). A listener throw stops the pass (the exception stays * pending for the caller). Returns whether the bucket had listeners. */ +typedef struct ScrEeMessage ScrEeMessage; static bool scr_ee_emit_core(ScrEmitter *em, ScrStr *name, va_list *ap_template, - ScrDyn *const *flex_args, size_t flex_argc); + ScrDyn *const *flex_args, size_t flex_argc, ScrEeMessage *message); /* emit('error', ...) first emits the same arguments to errorMonitor. */ static void scr_ee_emit_error_monitor(ScrEmitter *em, va_list *ap_template, ScrDyn *const *flex_args, size_t flex_argc) { ScrEeBucket *b = scr_ee_bucket_of(em->reg, SCR_EE_ERROR_MONITOR); if (!b || b->n == 0) return; - scr_ee_emit_core(em, SCR_EE_ERROR_MONITOR, ap_template, flex_args, flex_argc); + scr_ee_emit_core(em, SCR_EE_ERROR_MONITOR, ap_template, flex_args, flex_argc, NULL); } /* A listener this emit has no argument form for: an untyped emit whose @@ -1044,8 +1048,17 @@ SCR_COLD static void scr_ee_listener_mismatch(const ScrStr *name, bool typed_emi scr_throw_error(typed_emit ? SCR_ERR_ERROR : SCR_ERR_TYPE, message); } +/* A message emit (scr_emitter_emit_message): listeners with a typed message + * entry read the message; the others share one decoded argument, made when + * the first of them runs. */ +struct ScrEeMessage { + const struct ScrMessage *message; + ScrDyn *(*decode)(const struct ScrMessage *); + ScrDyn *decoded; +}; + static bool scr_ee_emit_core(ScrEmitter *em, ScrStr *name, va_list *ap_template, - ScrDyn *const *flex_args, size_t flex_argc) { + ScrDyn *const *flex_args, size_t flex_argc, ScrEeMessage *message) { if (name->len == 5 && memcmp(name->data, "error", 5) == 0) { scr_ee_emit_error_monitor(em, ap_template, flex_args, flex_argc); if (scr_exc_pending()) return true; @@ -1088,6 +1101,19 @@ static bool scr_ee_emit_core(ScrEmitter *em, ScrStr *name, va_list *ap_template, continue; } } + if (message && e->flex_message && e->flex_message(e->flex_cb, message->message)) { + scr_ee_entry_unref(e); + continue; + } + if (message && !message->decoded) { + message->decoded = message->decode(message->message); + if (!message->decoded) { + scr_ee_entry_unref(e); + continue; + } + flex_args = &message->decoded; + flex_argc = 1; + } if (flex_args && e->flex_invoke) { ScrDyn *answer = e->flex_invoke(e->flex_cb, flex_args, flex_argc); scr_dyn_release(answer); /* EventEmitter ignores callback results. */ @@ -1108,7 +1134,7 @@ static bool scr_ee_emit_core(ScrEmitter *em, ScrStr *name, va_list *ap_template, static bool scr_ee_emit_va(ScrEmitter *em, ScrStr *name, ...) { va_list ap; va_start(ap, name); - bool had = scr_ee_emit_core(em, name, &ap, NULL, 0); + bool had = scr_ee_emit_core(em, name, &ap, NULL, 0, NULL); va_end(ap); return had; } @@ -1119,7 +1145,7 @@ static bool scr_ee_emit_mixed_va(ScrEmitter *em, ScrStr *name, ScrDyn *const *ar int typed, ...) { va_list ap; va_start(ap, typed); - bool had = scr_ee_emit_core(em, name, typed ? &ap : NULL, args ? args : scr_ee_no_args, argc); + bool had = scr_ee_emit_core(em, name, typed ? &ap : NULL, args ? args : scr_ee_no_args, argc, NULL); va_end(ap); return had; } @@ -1131,7 +1157,7 @@ static bool scr_ee_emit_mixed_va(ScrEmitter *em, ScrStr *name, ScrDyn *const *ar bool scr_emitter_emit(ScrEmitter *em, ScrStr *name, ...) { va_list ap; va_start(ap, name); - bool had = scr_ee_emit_core(em, name, &ap, NULL, 0); + bool had = scr_ee_emit_core(em, name, &ap, NULL, 0, NULL); va_end(ap); return had; } @@ -1143,7 +1169,7 @@ bool scr_emitter_emit(ScrEmitter *em, ScrStr *name, ...) { bool scr_emitter_emit_mixed(ScrEmitter *em, ScrStr *name, ScrDyn *const *args, size_t argc, ...) { va_list ap; va_start(ap, argc); - bool had = scr_ee_emit_core(em, name, &ap, args ? args : scr_ee_no_args, argc); + bool had = scr_ee_emit_core(em, name, &ap, args ? args : scr_ee_no_args, argc, NULL); va_end(ap); return had; } @@ -1241,7 +1267,15 @@ static bool scr_ee_emit_error_dyn(ScrEmitter *em, ScrStr *name, ScrDyn *const *a /* An untyped emit of a name typed code never fixes a tuple for (computed * names, runtime-internal registries): the arguments as given. */ bool scr_emitter_emit_flex(ScrEmitter *em, ScrStr *name, ScrDyn *const *args, size_t argc) { - return scr_ee_emit_core(em, name, NULL, args ? args : scr_ee_no_args, argc); + return scr_ee_emit_core(em, name, NULL, args ? args : scr_ee_no_args, argc, NULL); +} + +bool scr_emitter_emit_message(ScrEmitter *em, ScrStr *name, const struct ScrMessage *message, + ScrDyn *(*decode)(const struct ScrMessage *)) { + ScrEeMessage state = {message, decode, NULL}; + bool had = scr_ee_emit_core(em, name, NULL, NULL, 0, &state); + scr_dyn_release(state.decoded); + return had; } /* emit(name, ...args) through an untyped value: the arguments as given. @@ -1255,7 +1289,7 @@ bool scr_emitter_emit_any(ScrEmitter *em, ScrStr *name, ScrDyn *const *args, siz return scr_ee_emit_mixed_va(em, name, args, argc, s != NULL, s); } } - return scr_ee_emit_core(em, name, NULL, args ? args : scr_ee_no_args, argc); + return scr_ee_emit_core(em, name, NULL, args ? args : scr_ee_no_args, argc, NULL); } /* Handle event registries use checked callbacks for every tuple, including @@ -1268,7 +1302,7 @@ bool scr_emitter_emit_error_flex(ScrEmitter *em, ScrDyn *error) { return false; } ScrStr *name = scr_str_new("error", 5); - bool had = scr_ee_emit_core(em, name, NULL, &error, 1); + bool had = scr_ee_emit_core(em, name, NULL, &error, 1, NULL); scr_str_release(name); return had; } diff --git a/packages/runtime/src/scr_events_emitter.h b/packages/runtime/src/scr_events_emitter.h index b66de9e5a..6e1ef536a 100644 --- a/packages/runtime/src/scr_events_emitter.h +++ b/packages/runtime/src/scr_events_emitter.h @@ -154,6 +154,12 @@ ScrEmitter *scr_emitter_remove_all(ScrEmitter *em, ScrStr *name, bool all); * emit('error', err): no listener ⇒ THROWS err (borrowed; +1 taken). */ bool scr_emitter_emit(ScrEmitter *em, ScrStr *name, ...); bool scr_emitter_emit_flex(ScrEmitter *em, ScrStr *name, ScrDyn *const *args, size_t argc); +/* An untyped emit of one message: a listener registered from a function + * box with a typed message entry (scr_dyn_func_set_message) reads the + * message itself; the other listeners get decode(message), made once. */ +struct ScrMessage; +bool scr_emitter_emit_message(ScrEmitter *em, ScrStr *name, const struct ScrMessage *message, + ScrDyn *(*decode)(const struct ScrMessage *)); /* An untyped emit of an event with a fixed tuple: the arguments as given * for dynamic listeners, plus the tuple converted by the caller as * scr_emitter_emit's variadics for typed listeners. has_typed answers diff --git a/packages/runtime/src/scr_json.c b/packages/runtime/src/scr_json.c index f610ffdbb..355a34aee 100644 --- a/packages/runtime/src/scr_json.c +++ b/packages/runtime/src/scr_json.c @@ -4122,9 +4122,16 @@ ScrDyn *scr_dyn_new_func(ScrClosure *clo, ScrDynThunk thunk, uint32_t arity, con /* A signature adapter reports the length of the function it adapts. */ d->v.fn.arity = clo->identity != NULL ? clo->identity_length : arity; d->v.fn.class_obj = NULL; + d->v.fn.message = NULL; return d; } +void scr_dyn_func_set_message(ScrDyn *fn, ScrDynThunk thunk, ScrDynMessageListener listener) { + /* scr_dyn_new_func answers an adapted function's original box, whose + * closure has other parameter types. */ + if (fn && fn->kind == SCR_DYN_FUNC && fn->v.fn.thunk == thunk) fn->v.fn.message = listener; +} + /* A class is function-shaped for typeof and identity, but calling it without * new always throws. The closure owns the class object and its lexical boxes. */ static ScrDyn *scr_dyn_class_call(ScrClosure *closure, ScrDyn *const *args, size_t argc) { diff --git a/packages/runtime/src/scr_message.c b/packages/runtime/src/scr_message.c index 5e1bce37f..508266103 100644 --- a/packages/runtime/src/scr_message.c +++ b/packages/runtime/src/scr_message.c @@ -3,30 +3,6 @@ #include #include -typedef enum { - SCR_MESSAGE_UNDEFINED, - SCR_MESSAGE_NULL, - SCR_MESSAGE_BOOL, - SCR_MESSAGE_NUMBER, - SCR_MESSAGE_STRING, - SCR_MESSAGE_BIGINT, - SCR_MESSAGE_ARRAY, - SCR_MESSAGE_OBJECT, - SCR_MESSAGE_STORAGE, - SCR_MESSAGE_BYTES, - SCR_MESSAGE_ARRAY_BUFFER, - SCR_MESSAGE_ERROR, - /* A deeply frozen plain-data graph shared by pointer (see publication). */ - SCR_MESSAGE_PUBLISHED, - /* A typed value published with @scriptc/threads (immortal), delivered as - * a fresh typed-ref capsule over the same pointer. */ - SCR_MESSAGE_TYPED_REF, - /* A transferred MessagePort: its channel end (+1) and side. */ - SCR_MESSAGE_PORT, - /* A native handle cloned through its unit's ScrDynHandleTransfer. */ - SCR_MESSAGE_HANDLE, -} ScrMessageKind; - const ScrMessagePortOps *scr_message_port_ops = NULL; typedef struct { @@ -95,6 +71,7 @@ struct ScrMessage { size_t count; bool storage; /* has STORAGE nodes */ bool releases; /* has STORAGE, PORT or HANDLE nodes, which own resources */ + bool readable; /* see scr_message_readable */ }; typedef struct { @@ -143,6 +120,8 @@ typedef struct { bool uncaught; /* the next value is an uncaught exception or its cause */ bool storage; bool releases; + bool shared; /* a node was reached twice */ + bool adopts; /* has PORT or HANDLE nodes */ ScrMessageNode inline_nodes[SCR_MESSAGE_INLINE]; ScrMessageVisit inline_visits[SCR_MESSAGE_INLINE]; ScrMessagePending inline_properties[SCR_MESSAGE_INLINE]; @@ -168,7 +147,7 @@ static void scr_message_encoder_init(ScrMessageEncoder *encoder, const ScrDyn *t encoder->stack_capacity = SCR_MESSAGE_INLINE; encoder->transfer = transfer; encoder->uncaught = uncaught; - encoder->storage = encoder->releases = false; + encoder->storage = encoder->releases = encoder->shared = encoder->adopts = false; } static bool scr_message_listed(const ScrMessageEncoder *encoder, const ScrDyn *value) { @@ -290,7 +269,10 @@ static void scr_message_push(ScrMessageEncoder *encoder, size_t node) { static size_t scr_message_storage(ScrMessageEncoder *encoder, const ScrBytes *bytes) { const ScrBytes *owner = bytes->backing ? bytes->backing : bytes; size_t found = scr_message_find(encoder, owner, SCR_MESSAGE_STORAGE + 1); - if (found != SIZE_MAX) return found; + if (found != SIZE_MAX) { + encoder->shared = true; + return found; + } size_t node = scr_message_node(encoder); scr_message_identify(encoder, owner, SCR_MESSAGE_STORAGE + 1, node); ScrMessageNode *storage = &encoder->nodes[node]; @@ -360,7 +342,10 @@ static size_t scr_message_value(ScrMessageEncoder *encoder, const ScrDyn *input) return SIZE_MAX; } size_t found = scr_message_find(encoder, identity, domain); - if (found != SIZE_MAX) return found; + if (found != SIZE_MAX) { + encoder->shared = true; + return found; + } size_t id = scr_message_node(encoder); scr_message_identify(encoder, identity, domain, id); encoder->visits[id].input = scr_dyn_retain((ScrDyn *)input); @@ -482,7 +467,7 @@ static size_t scr_message_value(ScrMessageEncoder *encoder, const ScrDyn *input) node->kind = SCR_MESSAGE_PORT; node->v.port.channel = channel; node->v.port.side = side; - encoder->releases = true; + encoder->releases = encoder->adopts = true; break; } bool buffer = scr_buffer_storage_is(value); @@ -498,7 +483,7 @@ static size_t scr_message_value(ScrMessageEncoder *encoder, const ScrDyn *input) node->kind = SCR_MESSAGE_HANDLE; node->v.handle.transfer = transfer; node->v.handle.payload = payload; - encoder->releases = true; + encoder->releases = encoder->adopts = true; break; } const ScrBytes *bytes = buffer ? value->v.handle.ptr : value->v.bytes; @@ -678,6 +663,7 @@ static ScrMessage *scr_message_try_publish(const ScrDyn *value) { message = scr_message_alloc(1, sizeof(*message) + sizeof(*message->nodes)); message->nodes = (ScrMessageNode *)(message + 1); message->count = 1; + message->readable = true; message->nodes[0].kind = SCR_MESSAGE_PUBLISHED; message->nodes[0].v.published = (ScrDyn *)value; if (getenv("SCRIPTC_PUBLISH_TRACE")) @@ -770,7 +756,8 @@ static ScrMessage *scr_message_pack(ScrMessageEncoder *encoder) { ScrMessageProperty *slots = (ScrMessageProperty *)(nodes + count); ScrMessageTyped *records = (ScrMessageTyped *)(slots + properties); char *text = (char *)(records + typed); - *message = (ScrMessage){nodes, count, encoder->storage, encoder->releases}; + *message = (ScrMessage){nodes, count, encoder->storage, encoder->releases, + !encoder->shared && !encoder->adopts}; memcpy(nodes, encoder->nodes, count * sizeof(*nodes)); if (typed) memcpy(records, encoder->typed, typed * sizeof(*records)); size_t first = 0; @@ -1014,6 +1001,28 @@ done:; return result; } +bool scr_message_readable(const ScrMessage *message) { return message->readable; } + +int32_t scr_message_kind(const ScrMessage *message, size_t node) { return message->nodes[node].kind; } + +double scr_message_number(const ScrMessage *message, size_t node) { return message->nodes[node].v.number; } + +ScrStr *scr_message_string(const ScrMessage *message, size_t node) { + return scr_str_new(message->nodes[node].v.text.data, message->nodes[node].v.text.length); +} + +bool scr_message_fields(const ScrMessage *message, size_t node, const char *const *names, + const size_t *lengths, size_t count, size_t *values) { + const ScrMessageNode *object = &message->nodes[node]; + if (object->kind != SCR_MESSAGE_OBJECT || object->count != count) return false; + for (size_t i = 0; i < count; i++) { + const ScrMessageProperty *property = &object->properties[i]; + if (property->length != lengths[i] || memcmp(property->key, names[i], lengths[i])) return false; + values[i] = property->value; + } + return true; +} + void scr_message_free(ScrMessage *message) { if (!message) return; if (message->releases) diff --git a/packages/runtime/src/scr_message.test.c b/packages/runtime/src/scr_message.test.c index bdabc4d12..b6adf34c5 100644 --- a/packages/runtime/src/scr_message.test.c +++ b/packages/runtime/src/scr_message.test.c @@ -250,6 +250,52 @@ static void check_large(void) { scr_message_free(message); } +/* The readers compiled 'message' listeners use: node kinds and values, a + * record's keys in order, and which messages they may read. */ +static void check_readers(void) { + ScrDyn *root = scr_dyn_new_obj(); + put_number(root, "id", 7); + ScrStr *text = scr_str_new("seven", 5); + scr_dyn_obj_set(root, "name", 4, scr_dyn_new_str(text)); + scr_str_release(text); + scr_dyn_obj_set(root, "done", 4, scr_dyn_new_bool(true)); + ScrMessage *message = scr_message_encode(root); + assert(message && scr_message_readable(message)); + assert(scr_message_kind(message, 0) == SCR_MESSAGE_OBJECT); + static const char *const names[] = {"id", "name", "done"}; + static const size_t lengths[] = {2, 4, 4}; + size_t values[3]; + assert(scr_message_fields(message, 0, names, lengths, 3, values)); + assert(scr_message_kind(message, values[0]) == SCR_MESSAGE_NUMBER); + assert(scr_message_number(message, values[0]) == 7); + assert(scr_message_kind(message, values[1]) == SCR_MESSAGE_STRING); + ScrStr *name = scr_message_string(message, values[1]); + assert(name->len == 5 && !memcmp(name->data, "seven", 5)); + scr_str_release(name); + assert(scr_message_kind(message, values[2]) == SCR_MESSAGE_BOOL); + assert(scr_message_number(message, values[2]) == 1); + /* Another order, a missing key or an extra key does not match. */ + static const char *const reordered[] = {"name", "id", "done"}; + static const size_t reordered_lengths[] = {4, 2, 4}; + assert(!scr_message_fields(message, 0, reordered, reordered_lengths, 3, values)); + assert(!scr_message_fields(message, 0, names, lengths, 2, values)); + assert(!scr_message_fields(message, values[0], names, lengths, 3, values)); + scr_message_free(message); + put_number(root, "extra", 1); + message = scr_message_encode(root); + assert(!scr_message_fields(message, 0, names, lengths, 3, values)); + scr_message_free(message); + /* A value reached twice makes the message unreadable. */ + ScrDyn *shared = scr_dyn_new_obj(); + scr_dyn_obj_set(root, "first", 5, scr_dyn_retain(shared)); + scr_dyn_obj_set(root, "second", 6, shared); + message = scr_message_encode(root); + assert(message && !scr_message_readable(message)); + scr_message_free(message); + scr_dyn_release(root); + scr_collect_cycles(); +} + /* A link-gated unit's handle crosses threads through the transfer hooks in * its ops: share on the sender, adopt on the receiver, drop with the * message. The test borrows the last capacity slot, which no unit uses, so @@ -376,6 +422,7 @@ int main(void) { check_rejection(); check_documents(); check_large(); + check_readers(); check_handle_transfer(); scr_context_cleanup(); puts("message graphs preserve identity, sparse values, byte aliases and getter order"); diff --git a/packages/runtime/src/scr_worker_events.c b/packages/runtime/src/scr_worker_events.c index 252230372..3d10183f4 100644 --- a/packages/runtime/src/scr_worker_events.c +++ b/packages/runtime/src/scr_worker_events.c @@ -665,6 +665,17 @@ static bool scr_channel_dispatch(void) { continue; } scr_worker_view_retain(view); + if (event->message && !view->broadcast && scr_message_readable(event->message)) { + /* Compiled listeners with a typed message entry read the message. */ + ScrStr *name = scr_str_new("message", 7); + scr_dyn_this_push(view, SCR_DYNH_MESSAGE_PORT); + scr_emitter_emit_message(view->events, name, event->message, scr_message_decode); + scr_dyn_this_pop(); + scr_str_release(name); + scr_mail_event_free(event); + scr_worker_view_release(view); + return true; + } ScrDyn *argument = event->message ? scr_message_decode(event->message) : NULL; if (argument && view->broadcast) { ScrDyn *self = scr_dyn_new_handle(view, SCR_DYNH_BROADCAST_CHANNEL); @@ -815,6 +826,19 @@ static void scr_worker_dispatch(void) { } } scr_worker_view_retain(view); + if (event->kind == SCR_WORKER_MESSAGE && event->message && scr_message_readable(event->message)) { + /* Compiled listeners with a typed message entry read the message. */ + if (!scr_exc_pending()) { + ScrStr *name = scr_str_new("message", 7); + scr_dyn_this_push(view, view->port ? SCR_DYNH_MESSAGE_PORT : SCR_DYNH_WORKER); + scr_emitter_emit_message(view->events, name, event->message, scr_message_decode); + scr_dyn_this_pop(); + scr_str_release(name); + } + scr_worker_view_release(view); + scr_mail_event_free(event); + return; + } const char *event_name = event->kind == SCR_WORKER_ONLINE ? "online" : event->kind == SCR_WORKER_EXIT ? "exit" : event->kind == SCR_WORKER_ERROR ? "error" : "message"; ScrDyn *argument = event->message ? scr_message_decode(event->message) : diff --git a/tests/corpus/7130-typed-message-listeners.ts b/tests/corpus/7130-typed-message-listeners.ts new file mode 100644 index 000000000..b98983824 --- /dev/null +++ b/tests/corpus/7130-typed-message-listeners.ts @@ -0,0 +1,80 @@ +import { MessageChannel } from "node:worker_threads"; + +// 'message' listeners with typed parameters on MessageChannel ports. A +// message with the parameter's exact layout, and one with other keys, +// shared values or other kinds, reach the listener with the same values as +// in Node. +type Item = { id: number; name: string; done: boolean }; +type Nested = { label: string; item: Item }; + +const { port1, port2 } = new MessageChannel(); +// Each port's lines print in delivery order once every message arrived. +const lines: string[] = []; +const nestedLines: string[] = []; +const otherLines: string[] = []; +let pending = 0; +function finish(): void { + if (--pending === 0) { + for (const line of [...lines, ...nestedLines, ...otherLines]) console.log(line); + port1.close(); + channel.port1.close(); + other.port1.close(); + } +} + +port1.on("message", (value: number | string | Item | null | undefined) => { + if (value === null || value === undefined) lines.push(`unit ${String(value)}`); + else if (typeof value === "number") lines.push(`number ${value.toFixed(2)}`); + else if (typeof value === "string") lines.push(`string ${value.length} ${value}`); + else lines.push(`item ${value.id} ${value.name} ${value.done} ${JSON.stringify(value)}`); + finish(); +}); + +const sent: unknown[] = [ + 1.5, + -0, + "", + "héllo wörld", + null, + undefined, + { id: 1, name: "first", done: false }, + { id: 2, name: "", done: true }, + // An extra key stays beside the record. + { id: 4, name: "extra", done: false, note: "kept" }, +]; +pending += sent.length; +for (const value of sent) port2.postMessage(value); + +// Nested records, a value shared by two fields, and a second listener +// that reads the message untyped. +const channel = new MessageChannel(); +channel.port1.on("message", (value: Nested) => { + nestedLines.push(`nested ${value.label} ${value.item.id} ${value.item.name} ${JSON.stringify(value)}`); + finish(); +}); +channel.port1.on("message", (value: unknown) => { + nestedLines.push(`untyped ${JSON.stringify(value)}`); + finish(); +}); +const shared = { id: 5, name: "shared", done: true }; +const nested: unknown[] = [ + { label: "plain", item: { id: 6, name: "six", done: false } }, + { label: "shared", item: shared, again: shared }, +]; +pending += 2 * nested.length; +for (const value of nested) channel.port2.postMessage(value); + +// once listeners, and a listener added while the port delivers. +const other = new MessageChannel(); +other.port1.once("message", (value: Item) => { + otherLines.push(`once ${value.id} ${value.name}`); + other.port1.on("message", (later: number) => { + otherLines.push(`later ${later}`); + finish(); + }); + finish(); +}); +pending += 3; +other.port2.postMessage({ id: 7, name: "seven", done: true }); +other.port2.postMessage(8); +other.port2.postMessage(9); diff --git a/tests/corpus/7131-typed-worker-messages.ts b/tests/corpus/7131-typed-worker-messages.ts new file mode 100644 index 000000000..86197b4de --- /dev/null +++ b/tests/corpus/7131-typed-worker-messages.ts @@ -0,0 +1,54 @@ +import { MessageChannel, MessagePort, Worker, isMainThread, parentPort } from "node:worker_threads"; + +// 'message' listeners with typed parameters on a worker and its +// parentPort: records and numbers in both directions, and a message that +// carries a transferred MessagePort. +type Job = { id: number; text: string; urgent: boolean }; +type Reply = { id: number; length: number; upper: string }; + +if (isMainThread) { + const worker = new Worker(new URL(import.meta.url)); + // The worker's replies, then the port's, each in delivery order. + const replies: string[] = []; + const portLines: string[] = []; + let expected = 5; + const done = (): void => { + if (--expected > 0) return; + for (const line of [...replies, ...portLines]) console.log(line); + void worker.terminate(); + }; + worker.on("message", (reply: Reply | number) => { + if (typeof reply === "number") replies.push(`count ${reply}`); + else replies.push(`reply ${reply.id} ${reply.length} ${reply.upper}`); + done(); + }); + const jobs: Job[] = [ + { id: 1, text: "alpha", urgent: false }, + { id: 2, text: "βeta", urgent: true }, + { id: 3, text: "", urgent: false }, + ]; + for (const job of jobs) worker.postMessage(job); + worker.postMessage(jobs.length); + // A port in the message: the worker answers through it. + const { port1, port2 } = new MessageChannel(); + port1.on("message", (text: string) => { + portLines.push(`port ${text}`); + port1.close(); + done(); + }); + worker.postMessage({ port: port2 }, [port2]); +} else { + let count = 0; + parentPort!.on("message", (message: Job | number | { port: MessagePort }) => { + if (typeof message === "number") { + parentPort!.postMessage(count + message); + } else if ("port" in message) { + message.port.postMessage("through the port"); + message.port.close(); + } else { + count++; + const text = message.urgent ? message.text.toUpperCase() : message.text; + parentPort!.postMessage({ id: message.id, length: message.text.length, upper: text }); + } + }); +} diff --git a/tests/harness/corpus-costs/7130-typed-message-listeners.ts.json b/tests/harness/corpus-costs/7130-typed-message-listeners.ts.json new file mode 100644 index 000000000..bf7b0d199 --- /dev/null +++ b/tests/harness/corpus-costs/7130-typed-message-listeners.ts.json @@ -0,0 +1 @@ +{ "plain": 2200, "san": 2200 } diff --git a/tests/harness/corpus-costs/7131-typed-worker-messages.ts.json b/tests/harness/corpus-costs/7131-typed-worker-messages.ts.json new file mode 100644 index 000000000..953e2af8f --- /dev/null +++ b/tests/harness/corpus-costs/7131-typed-worker-messages.ts.json @@ -0,0 +1 @@ +{ "plain": 1700, "san": 1600 } diff --git a/tests/harness/self-hosting-native-toolchain.test.ts b/tests/harness/self-hosting-native-toolchain.test.ts index 176caa516..c0176eb93 100644 --- a/tests/harness/self-hosting-native-toolchain.test.ts +++ b/tests/harness/self-hosting-native-toolchain.test.ts @@ -108,7 +108,7 @@ for (const backend of ["llvm"] as const) { object_format: target.objectFormat, minimum_os: target.minimumOs, }, - runtime_abi: { version: 26, marker: "scr_runtime_abi_v26" }, + runtime_abi: { version: 27, marker: "scr_runtime_abi_v27" }, compiler: { command: "fixture", identity: "fixture", target: target.llvmTriple }, macros: { executable: [], excluded: [], sanitizer: "external-toolchain-required" }, flavors: { From 87162a491d4b0f4819bc6577f0045f02a3774912 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 07:20:14 -0500 Subject: [PATCH 077/102] Index dispatch receivers by name instead of testing each one ClassDynamicDispatch.process tested every property receiver for every property dispatch and for every method name a dynamic call names, in every pass: on the flat tsc-ts bundle, 9.2 million receiver tests per build. It now indexes each receiver list once by the method, generic method, accessor and field names along each receiver's base chain, and tests only the receivers listed under a name, plus the ones whose emitter, stream or EventTarget root answers names of its own, in list order. Names that the test decides on every receiver (compiler names, constructor, stack) and emit-override specializations still test every receiver. SCRIPTC_CHECK_DISPATCH_CANDIDATES=1 checks each selection against a test of every receiver. --- .../lowering/class-dynamic-dispatch.ts | 149 ++++++++++++++++-- 1 file changed, 132 insertions(+), 17 deletions(-) diff --git a/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts b/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts index fefe85d0c..79edae433 100644 --- a/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts +++ b/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts @@ -1,4 +1,5 @@ import { primitiveConstructorOr } from "./lower-exprs.js"; +import { InternalCompilerError } from "../../errors.js"; import { dynUndefinedExpr, helperLoc, nodeThrowExpr, varRef } from "../../ir/build.js"; import { constructedValue } from "./constructor-returns.js"; import { eventTargetApiMembers, eventTargetInheritedMember } from "./lower-event-target.js"; @@ -467,6 +468,77 @@ function sortAdded(lowerer: Lowerer, set: Set, from: number): void { for (const name of added) set.add(name); } +/** The receivers of one property-receiver list (propertyReceivers) by the + * names that can make them answer a member, as positions in the list. A + * receiver whose root answers names of its own (an emitter, a stream, an + * EventTarget or a Date) is in `rooted` instead. */ +interface ReceiverIndex { + plans: readonly PropertyReceiver[]; + /** By a method or generic method its base chain declares. */ + methods: Map; + /** By a method, generic method or accessor its base chain declares (an + * accessor under its property name), or a field it has. */ + members: Map; + rooted: number[]; +} + +function receiverIndex(lowerer: Lowerer, plans: readonly PropertyReceiver[]): ReceiverIndex { + const methods = new Map(); + const members = new Map(); + const rooted: number[] = []; + const add = (table: Map, name: string, position: number): void => { + const positions = table.get(name); + if (positions === undefined) table.set(name, [position]); + else if (positions[positions.length - 1] !== position) positions.push(position); + }; + plans.forEach(({ info }, position) => { + if ( + emitterRooted(lowerer, info) || + info.builtinStream !== undefined || + eventTargetApiMembers(info) !== null || + dateRootOf(info) !== null + ) { + rooted.push(position); + return; + } + for (let c: ClassInfo | null = info; c; c = c.base) { + for (const name of c.methods.keys()) { + add(methods, name, position); + add( + members, + name.startsWith("get:") || name.startsWith("set:") ? name.slice(4) : name, + position, + ); + } + for (const name of c.genericMethods?.keys() ?? []) { + add(methods, name, position); + add(members, name, position); + } + } + for (const name of info.fields.keys()) add(members, name, position); + }); + for (const table of [methods, members]) + for (const positions of table.values()) positions.sort((a, b) => a - b); + return { plans, methods, members, rooted }; +} + +/** The ascending union of two ascending position lists. */ +function mergePositions(left: readonly number[], right: readonly number[]): number[] { + const out: number[] = []; + let i = 0; + let j = 0; + while (i < left.length || j < right.length) { + const next = + j >= right.length || (i < left.length && left[i]! <= right[j]!) ? left[i++]! : right[j++]!; + if (out[out.length - 1] !== next) out.push(next); + } + return out; +} + +/** SCRIPTC_CHECK_DISPATCH_CANDIDATES=1 checks every indexed receiver selection + * against a test of every receiver. */ +const CHECK_CANDIDATES = process.env["SCRIPTC_CHECK_DISPATCH_CANDIDATES"] === "1"; + export function classPropertiesHelper(lowerer: Lowerer, loc: SrcLoc, readOnly = false): IrFunction { const name = readOnly ? READ_PROPERTIES : "%dyn.class.properties"; lowerer.shareHelper(name); @@ -1342,10 +1414,31 @@ export class ClassDynamicDispatch { } refreshDescriptorGuards(lowerer); const byMethod = new Map(); + // A query asks every receiver about one name, and the program's dispatch + // sites ask about thousands: index the receivers by name once per list. + let index: ReceiverIndex | null = null; + const indexOf = (plans: readonly PropertyReceiver[]): ReceiverIndex => + index?.plans === plans ? index : (index = receiverIndex(lowerer, plans)); + /** The receivers of `plans` that can answer `name`, in list order: those + * `table` lists under it and the rooted ones. Emit-override + * specializations (`emit:`) join a class's methods while bodies + * lower, so they keep every receiver. */ + const receiversFor = ( + plans: readonly PropertyReceiver[], + name: string, + table: "methods" | "members", + ): readonly PropertyReceiver[] => { + if (name.startsWith("emit:")) return plans; + const found = indexOf(plans); + return mergePositions(found[table].get(name) ?? [], found.rooted).map( + (position) => plans[position]!, + ); + }; const candidates = (method: string): ClassInfo[] => { const found = byMethod.get(method); if (found) return found; - const matching = this.propertyReceivers(lowerer, true).flatMap(({ info }) => { + const plans = this.propertyReceivers(lowerer, true); + const test = ({ info }: PropertyReceiver): ClassInfo[] => { if (!info || info.fields.has(method) || info.builtinError) return []; if (emitterRooted(lowerer, info) && EMITTER_METHODS.has(method)) return [info]; if ( @@ -1364,7 +1457,13 @@ export class ClassDynamicDispatch { return findMethodOn(lowerer, info, method) || findGenericMethodOn(lowerer, info, method) ? [info] : []; - }); + }; + const matching = receiversFor(plans, method, "methods").flatMap(test); + if (CHECK_CANDIDATES) { + const every = plans.flatMap(test); + if (every.length !== matching.length || every.some((info, i) => info !== matching[i])) + throw new InternalCompilerError(`indexed candidates for ${method} differ`); + } byMethod.set(method, matching); return matching; }; @@ -2898,24 +2997,40 @@ export class ClassDynamicDispatch { }); changed = true; } - for (const plan of this.propertyReceivers(lowerer, true)) { + // Only the receivers that declare or hold the name, and the rooted + // ones, can pass the test, except for names it decides on every + // receiver. Fields added while bodies lower (the property bag and the + // attribute words) have compiler names, which take every receiver. + const plans = this.propertyReceivers(lowerer, true); + const anyReceiver = + !isClassOwnEnumerableFieldName(dispatch.name) || + dispatch.name === "constructor" || + dispatch.name === "stack"; + const skips = (plan: PropertyReceiver): boolean => + !isClassOwnEnumerableFieldName(dispatch.name) || + (!(plan.info.builtinStream !== undefined && streamProperty(dispatch.name)) && + !eventTargetInheritedMember(plan.info, dispatch.name) && + !dateInheritedMember(lowerer, plan.info, dispatch.name) && + !findMethodOn(lowerer, plan.info, dispatch.name) && + !findGenericMethodOn(lowerer, plan.info, dispatch.name) && + dispatch.name !== "constructor" && + !plan.info.fields.has(dispatch.name) && + !(dispatch.name === "stack" && lowerer.isSubclassOf(plan.info.def.name, "%Error")) && + !findMethodOn(lowerer, plan.info, `get:${dispatch.name}`) && + !findMethodOn(lowerer, plan.info, `set:${dispatch.name}`)); + const selected = anyReceiver ? plans : receiversFor(plans, dispatch.name, "members"); + if ( + CHECK_CANDIDATES && + plans.some( + (plan) => !dispatch.classes.has(plan.key) && !skips(plan) && !selected.includes(plan), + ) + ) + throw new InternalCompilerError(`indexed receivers for ${dispatch.name} differ`); + for (const plan of selected) { const { info } = plan; // Classes answered in an earlier pass skip the member lookups. if (dispatch.classes.has(plan.key)) continue; - if ( - !isClassOwnEnumerableFieldName(dispatch.name) || - (!(info.builtinStream !== undefined && streamProperty(dispatch.name)) && - !eventTargetInheritedMember(info, dispatch.name) && - !dateInheritedMember(lowerer, info, dispatch.name) && - !findMethodOn(lowerer, info, dispatch.name) && - !findGenericMethodOn(lowerer, info, dispatch.name) && - dispatch.name !== "constructor" && - !info.fields.has(dispatch.name) && - !(dispatch.name === "stack" && lowerer.isSubclassOf(info.def.name, "%Error")) && - !findMethodOn(lowerer, info, `get:${dispatch.name}`) && - !findMethodOn(lowerer, info, `set:${dispatch.name}`)) - ) - continue; + if (skips(plan)) continue; dispatch.classes.add(plan.key); const loc = dispatch.fn.loc; const { receiver, condition } = this.propertyReceiver(plan, loc); From 930ee4e63a5f79d3d9414f596cae814e8e6b6c06 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 07:20:38 -0500 Subject: [PATCH 078/102] Answer binary requests in the literal-values test transport Object replies are read through binary() since the checker objects are resolved from their ids, so the test transport answers both forms. --- .../src/frontend/literal-values.test.ts | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/packages/compiler/src/frontend/literal-values.test.ts b/packages/compiler/src/frontend/literal-values.test.ts index 2a85f82bf..1d792b1d4 100644 --- a/packages/compiler/src/frontend/literal-values.test.ts +++ b/packages/compiler/src/frontend/literal-values.test.ts @@ -8,16 +8,15 @@ import { function harness() { const members = new Map(); - const snapshot = new SemanticSnapshot(1, { - text(method, payload) { - const query = JSON.parse(payload) as { objectId: number }; - if (method !== "getTypesOfType" || !members.has(query.objectId)) - throw new Error(`unexpected request: ${method}`); - return JSON.stringify(members.get(query.objectId)); - }, - binary(method) { + const reply = (method: string, payload: string) => { + const query = JSON.parse(payload) as { objectId: number }; + if (method !== "getTypesOfType" || !members.has(query.objectId)) throw new Error(`unexpected request: ${method}`); - }, + return JSON.stringify(members.get(query.objectId)); + }; + const snapshot = new SemanticSnapshot(1, { + text: reply, + binary: (method, payload) => new TextEncoder().encode(reply(method, payload)), }); const project = snapshot.addProject("literal-values", () => undefined); let id = 0; From 3800a7d31158b3ff72559b53d779b281da1917ac Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 07:37:58 -0500 Subject: [PATCH 079/102] Version dense array loops bounded by an invariant limit A counted loop whose limit is an invariant value other than the array's length, such as `j < n` after `const n = a.length`, gets the same fast copy as a loop to `a.length`: one test before the loop bounds the limit by 2^31 - 1 and by each indexed array's hole-free prefix, for every array the loop provably never resizes, and the fast copy reads those slots directly. The length proof accepts number and boolean writes to class fields, which run no user code, and borrowed element reads in a fast copy load the slot without the prefix test or the runtime call. The fast copy's loop body may hold up to 160 IR nodes. --- .../backend/llvm/dense-array-loops.test.ts | 85 +++++++++++---- .../src/backend/llvm/dense-array-loops.ts | 85 +++++++++++---- .../src/backend/llvm/local-array-reads.ts | 18 ++++ .../src/ir/array-length-stability.test.ts | 26 +++++ .../compiler/src/ir/array-length-stability.ts | 9 ++ ...-array-dense-loop-invariant-limits.ts.json | 6 ++ .../7320-array-dense-loop-invariant-limits.ts | 101 ++++++++++++++++++ ...-array-dense-loop-invariant-limits.ts.json | 1 + 8 files changed, 291 insertions(+), 40 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7320-array-dense-loop-invariant-limits.ts.json create mode 100644 tests/corpus/7320-array-dense-loop-invariant-limits.ts create mode 100644 tests/harness/corpus-costs/7320-array-dense-loop-invariant-limits.ts.json diff --git a/packages/compiler/src/backend/llvm/dense-array-loops.test.ts b/packages/compiler/src/backend/llvm/dense-array-loops.test.ts index 405ad67e7..32c9cccab 100644 --- a/packages/compiler/src/backend/llvm/dense-array-loops.test.ts +++ b/packages/compiler/src/backend/llvm/dense-array-loops.test.ts @@ -1,5 +1,6 @@ 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 { countedDenseShape, matchDenseArrayLoop, @@ -111,16 +112,23 @@ test("loops that may resize, rebind or move storage keep the ordinary copy only" expect([...rebound!.arrays.keys()]).toEqual(["a"]); }); +const counted = ( + fields: Pick, +): IntegerCountedForLoop => ({ + localId: "i", + guarded: false, + limitGuarded: false, + startGuarded: false, + guardLimit: 0, + ...fields, +}); + test("counted shapes need a non-negative counter strictly below the length", () => { const ascending = (limit: IrExpr, inclusive: boolean, min = 0) => - countedDenseShape(loop([]), { - localId: "i", - start: num(min), - limit, - step: 1, - inclusive, - range: { min, max: 100 }, - }); + countedDenseShape( + loop([]), + counted({ start: num(min), limit, step: 1, inclusive, range: { min, max: 100 } }), + ); const minus = (offset: number): IrExpr => ({ kind: "bin", op: "-", @@ -129,19 +137,58 @@ test("counted shapes need a non-negative counter strictly below the length", () type: F64, loc, }); - expect(ascending(method("a", "length"), false)?.length.localId).toBe("a"); - expect(ascending(minus(1), true)?.length.localId).toBe("a"); + expect(ascending(method("a", "length"), false)?.length?.localId).toBe("a"); + expect(ascending(minus(1), true)?.length?.localId).toBe("a"); expect(ascending(method("a", "length"), true)).toBeNull(); expect(ascending(minus(1), false, -1)).toBeNull(); + // Another invariant limit bounds the counter itself; the entry test + // compares it with every indexed array's hole-free prefix. + const limited = ascending(ref("n"), false); + expect(limited?.length).toBeNull(); + expect(limited?.limit?.limit).toEqual(ref("n")); + expect(ascending(ref("n"), false, -1)).toBeNull(); const descending = (offset: number) => - countedDenseShape(loop([]), { - localId: "i", - start: minus(offset), - limit: num(0), - step: -1, - inclusive: true, - range: { min: 0, max: 100 }, - }); - expect(descending(1)?.length.localId).toBe("a"); + countedDenseShape( + loop([]), + counted({ + start: minus(offset), + limit: num(0), + step: -1, + inclusive: true, + range: { min: 0, max: 100 }, + }), + ); + expect(descending(1)?.length?.localId).toBe("a"); expect(descending(0)).toBeNull(); }); + +test("a loop to another invariant limit covers each array whose length it keeps", () => { + const limited: DenseLoopShape = { + counter: "i", + length: null, + limit: counted({ + start: num(0), + limit: ref("n"), + step: 1, + inclusive: false, + range: { min: 0, max: 100 }, + }), + range: { min: 0, max: 100 }, + }; + const matchLimited = (body: IrStmt[], unaliased = new Set()) => + matchDenseArrayLoop(loop(body), limited, locals, unaliased, new Set(["a", "b"])); + const copy = write("b", read("a")); + const dense = matchLimited([copy]); + expect([...dense!.arrays.keys()].sort()).toEqual(["a", "b"]); + expect(dense!.length).toBeNull(); + expect(dense!.limit?.limit).toEqual(ref("n")); + // An array the loop may resize is not covered; neither is one it may + // share storage with. + const resizing = [ + { kind: "exprStmt" as const, expr: read("a"), loc }, + { kind: "exprStmt" as const, expr: method("b", "getNumber", [ref("i")]), loc }, + { kind: "exprStmt" as const, expr: method("b", "push", [num(1)]), loc }, + ]; + expect([...matchLimited(resizing, new Set(["b"]))!.arrays.keys()]).toEqual(["a"]); + expect(matchLimited(resizing)).toBeNull(); +}); diff --git a/packages/compiler/src/backend/llvm/dense-array-loops.ts b/packages/compiler/src/backend/llvm/dense-array-loops.ts index 708825344..184ff1353 100644 --- a/packages/compiler/src/backend/llvm/dense-array-loops.ts +++ b/packages/compiler/src/backend/llvm/dense-array-loops.ts @@ -15,22 +15,33 @@ * test bounds `a.length` by 2^31 - 1, so the fast copy's counter is an int32. * Arrays longer than that are sparse in practice (a dense one would need * 16 GB of slots) and take the ordinary copy, as does every array with a - * hole, present undefined or sparse storage below `a.length`. */ + * hole, present undefined or sparse storage below `a.length`. + * + * 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. */ 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 { LlvmEmitterContext } from "./expr-context.js"; import { loadArrCount, SCR_ARR_FIELD } from "./common.js"; +import { emitCountedLoopLimit } from "./counted-loops.js"; export const INT32_MAX = 2147483647; export interface DenseArrayLoop { /** The loop's counter binding. */ counter: string; - /** The array whose length bounds the counter. */ - length: IrExpr & { kind: "varRef" }; + /** The array whose length bounds the counter, or null for a counted loop + * bounded by `limit`. */ + length: (IrExpr & { kind: "varRef" }) | null; + /** The ascending counted loop whose invariant limit bounds the counter, + * when `length` is null. */ + limit: IntegerCountedForLoop | null; /** Arrays whose accesses at the counter are proven to be inside the * hole-free prefix in the fast copy, with a read of each binding. */ arrays: ReadonlyMap; @@ -39,12 +50,15 @@ export interface DenseArrayLoop { } /** The fast copy duplicates the loop; keep the duplicated code small. */ -const MAX_LOOP_NODES = 120; +const MAX_LOOP_NODES = 160; /** How a matched integer loop bounds its counter below `length.length`. */ export interface DenseLoopShape { counter: string; - length: IrExpr & { kind: "varRef" }; + /** The array whose length bounds the counter, or null for `limit`. */ + length: (IrExpr & { kind: "varRef" }) | null; + /** An ascending counted loop bounded by another invariant limit. */ + limit?: IntegerCountedForLoop; /** 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; @@ -73,22 +87,18 @@ function lengthOffset(e: IrExpr): { receiver: IrExpr & { kind: "varRef" }; offse /** The array bounding a counted loop's counter below its length: an * ascending loop compared below `a.length - c`, or a descending one starting - * at `a.length - c` (c >= 1). */ + * at `a.length - c` (c >= 1). Another ascending loop is bounded by its own + * invariant limit. */ export function countedDenseShape( loop: IrStmt & { kind: "for" }, - counted: { - localId: string; - start: IrExpr; - limit: IrExpr; - step: number; - inclusive: boolean; - range: IntegerRange; - }, + counted: IntegerCountedForLoop, ): DenseLoopShape | null { if (counted.range.min < 0) return null; if (counted.step > 0) { const bound = lengthOffset(counted.limit); - if (!bound || bound.offset < (counted.inclusive ? 1 : 0)) return null; + if (!bound) + return { counter: counted.localId, length: null, limit: counted, range: counted.range }; + if (bound.offset < (counted.inclusive ? 1 : 0)) return null; return { counter: counted.localId, length: bound.receiver, range: counted.range }; } // The start is evaluated once, before the loop; the counter only falls. @@ -143,9 +153,11 @@ export function matchDenseArrayLoop( return everyStmtChild(s, expr, stmt); }; if (!loop.body.every(stmt) || !expr(loop.cond) || nested) return null; + const nodesOfLoop = [loop.cond, ...loop.body]; if ( + length !== null && !preservesArrayLength( - [loop.cond, ...loop.body], + nodesOfLoop, { receiver: length.localId, inRange: counter }, locals, unaliased, @@ -161,7 +173,14 @@ export function matchDenseArrayLoop( local.boxed || local.tdz || disturbed.has(id) || - (id !== length.localId && !initialized.has(id)) + (id !== length?.localId && !initialized.has(id)) + ) + continue; + // Without a bounding array, the entry test reads each array's `filled` + // once: the loop must not change any of their lengths. + if ( + length === null && + !preservesArrayLength(nodesOfLoop, { receiver: id, inRange: counter }, locals, unaliased) ) continue; arrays.set(id, ref); @@ -170,13 +189,15 @@ export function matchDenseArrayLoop( 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) }, }; } -/** The fast copy's entry test: the bounding length is at most 2^31 - 1 and - * at most every indexed array's hole-free prefix bound. */ +/** The fast copy's entry test: the bounding length (or the counted loop's + * exclusive limit) is at most 2^31 - 1 and at most every indexed array's + * hole-free prefix bound. */ export function emitDenseLoopGuard(host: LlvmEmitterContext, loop: DenseArrayLoop): string { const B = host.B; const size = host.sizeType; @@ -186,7 +207,29 @@ export function emitDenseLoopGuard(host: LlvmEmitterContext, loop: DenseArrayLoo host.markMemoryPointer(ptr, "array:header"); return ptr; }; - const receiver = host.emitStableReceiver(loop.length, []); + if (loop.length === null) { + // A limit at or below the start runs no pass, and passes the test. + const limit = emitCountedLoopLimit(host, loop.limit!); + const small = B.tmp(); + B.line(`${small} = icmp sle i64 ${limit}, ${INT32_MAX}`); + let valid = small; + 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 sle i64 ${limit}, ${wide}`); + B.line(`${both} = and i1 ${valid}, ${covered}`); + valid = both; + } + return valid; + } + const length = loop.length; + const receiver = host.emitStableReceiver(length, []); const lenPtr = header(receiver.name, SCR_ARR_FIELD.len), len = B.tmp(), small = B.tmp(); @@ -194,7 +237,7 @@ export function emitDenseLoopGuard(host: LlvmEmitterContext, loop: DenseArrayLoo B.line(`${small} = icmp ule ${size} ${len}, ${INT32_MAX}`); let valid = small; for (const [id, ref] of loop.arrays) { - const array = id === loop.length.localId ? receiver : host.emitStableReceiver(ref, []); + const array = id === length.localId ? receiver : host.emitStableReceiver(ref, []); const filledPtr = header(array.name, SCR_ARR_FIELD.filled), filled = B.tmp(), covered = B.tmp(), diff --git a/packages/compiler/src/backend/llvm/local-array-reads.ts b/packages/compiler/src/backend/llvm/local-array-reads.ts index 45d046e1f..cdd00c4e7 100644 --- a/packages/compiler/src/backend/llvm/local-array-reads.ts +++ b/packages/compiler/src/backend/llvm/local-array-reads.ts @@ -586,6 +586,24 @@ export function emitBorrowedArrayRead( const B = host.B; const array = host.emitStableReceiver(read.arr, [read.index]); const loopIndex = host.emitIntegerLoopIndex(read.index); + if (loopIndex !== null && host.provenDenseIndex(read.arr, 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. + const dataPtr = B.tmp(), + data = B.tmp(), + valuePtr = B.tmp(), + value = B.tmp(); + 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 i64, ptr ${data}, ${host.sizeType} ${loopIndex}`); + host.markMemoryPointer(valuePtr, "array:elements"); + B.line(`${value} = load ptr, ptr ${valuePtr}${host.fieldAliasAttachment(valuePtr)}`); + B.line(`store ptr ${value}, ptr ${slot}`); + return; + } const index = host.emitExpr(read.index); // A proven integer index (an int32 local, say) needs no double // round-trip; a negative one compares above the capacity as unsigned. diff --git a/packages/compiler/src/ir/array-length-stability.test.ts b/packages/compiler/src/ir/array-length-stability.test.ts index a0d0e49a7..f9b3cc9c2 100644 --- a/packages/compiler/src/ir/array-length-stability.test.ts +++ b/packages/compiler/src/ir/array-length-stability.test.ts @@ -167,3 +167,29 @@ test("fresh local arrays read only as receivers have no alias", () => { const rebound = [...body, { kind: "assign", localId: "out", value: arr("a"), loc } as IrStmt]; expect(findUnaliasedLocalArrays(fn(rebound)).has("out")).toBe(false); }); + +test("number and boolean writes to class fields run no user code", () => { + const obj: IrExpr = { + kind: "varRef", + localId: "o", + type: { kind: "object", className: "P" }, + loc, + }; + const scope = new Map(locals).set("o", { + id: "o", + name: "o", + type: { kind: "object", className: "P" }, + mutable: false, + }); + const fieldSet = (value: IrExpr): IrStmt => ({ + kind: "fieldSet", + obj, + className: "P", + field: "x", + value, + loc, + }); + expect(preserves([fieldSet(read("a", ref("i")))], "i", new Set(), scope)).toBe(true); + // A reference stored into a field releases the old one. + expect(preserves([fieldSet(arr("b"))], "i", new Set(), scope)).toBe(false); +}); diff --git a/packages/compiler/src/ir/array-length-stability.ts b/packages/compiler/src/ir/array-length-stability.ts index 3f9c3b9ca..ed57972b6 100644 --- a/packages/compiler/src/ir/array-length-stability.ts +++ b/packages/compiler/src/ir/array-length-stability.ts @@ -264,6 +264,15 @@ export function preservesArrayLength( ); case "return": return s.value === null || expr(s.value); + case "fieldSet": + // A number or boolean stored into a class field: accessors are + // calls, not field writes, and the old value holds no reference to + // release, so the write runs no user code. + return ( + (s.value.type.kind === "f64" || s.value.type.kind === "bool") && + expr(s.obj) && + expr(s.value) + ); default: if (!PLAIN_STATEMENTS.has(s.kind)) return false; } diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7320-array-dense-loop-invariant-limits.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7320-array-dense-loop-invariant-limits.ts.json new file mode 100644 index 000000000..785bf9d82 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7320-array-dense-loop-invariant-limits.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7320-array-dense-loop-invariant-limits.ts" + ], + "diags": [] +} diff --git a/tests/corpus/7320-array-dense-loop-invariant-limits.ts b/tests/corpus/7320-array-dense-loop-invariant-limits.ts new file mode 100644 index 000000000..878245e60 --- /dev/null +++ b/tests/corpus/7320-array-dense-loop-invariant-limits.ts @@ -0,0 +1,101 @@ +// Index loops bounded by an invariant limit other than the array's own length +// (a local copy of a length, a literal, an inclusive bound), over arrays the +// loop never resizes: class instances whose number and boolean fields the loop +// writes, and number arrays that are dense, short, holey or partially filled. + +class Body { + x: number; + v = 0; + hit = false; + next: Body | null = null; + + constructor(x: number) { + this.x = x; + } +} + +function pairs(bodies: Body[]): string { + const n = bodies.length; + for (let i = 0; i < n; i++) { + const bi = bodies[i]!; + let vi = bi.v; + for (let j = i + 1; j < n; j++) { + const bj = bodies[j]!; + const d = bi.x - bj.x; + const f = 1 / (d * d + 1); + vi -= d * f; + bj.v += d * f; + bj.hit = f > 0.1; + } + bi.v = vi; + } + return bodies.map((b) => `${b.v.toFixed(6)}${b.hit ? "*" : ""}`).join(" "); +} + +function firstThree(bodies: Body[]): number { + let s = 0; + for (let j = 0; j < 3; j++) s += bodies[j]!.x; + return s; +} + +function inclusive(bodies: Body[]): number { + const last = bodies.length - 1; + let s = 0; + for (let j = 1; j <= last; j++) s += bodies[j]!.x * j; + return s; +} + +function linked(bodies: Body[]): string { + const n = bodies.length; + // A reference field write: the loop keeps the ordinary copy. + for (let j = 0; j < n - 1; j++) bodies[j]!.next = bodies[j + 1]!; + let count = 0; + for (let b: Body | null = bodies[0]!; b !== null; b = b.next) count++; + return `${count}`; +} + +function sumTo(a: number[], limit: number): string { + const n = limit; + let s = 0; + let missing = 0; + for (let i = 0; i < n; i++) { + const v = a[i]; + if (v === undefined) missing++; + else s += v; + } + return `${s} ${missing}`; +} + +function scaleTo(a: number[], out: number[]): string { + const n = a.length; + for (let i = 0; i < n; i++) out[i] = a[i] * 2; + return `${out.length}:${out.join(",")}`; +} + +function window(a: number[]): number { + let s = 0; + for (let i = 2; i < 6; i++) s += a[i] * i; + return s; +} + +const bodies = [new Body(0), new Body(1.5), new Body(-2), new Body(4), new Body(0.25)]; +console.log(pairs(bodies)); +console.log(pairs(bodies)); +console.log(firstThree(bodies), inclusive(bodies), inclusive([new Body(7)])); +console.log(linked([new Body(1), new Body(2), new Body(3)])); + +const dense = [1, 2, 3, 4, 5, 6, 7, 8]; +console.log(sumTo(dense, 8), sumTo(dense, 5), sumTo(dense, 0), sumTo(dense, -3)); +// Limits past the length or the filled prefix take the checked loop. +console.log(sumTo(dense, 10), sumTo([], 2)); +const holey = [1]; +holey[3] = 4; +console.log(sumTo(holey, 4), sumTo(holey, 1)); +const shortened = [1, 2, 3, 4, 5, 6]; +shortened.length = 3; +shortened.length = 6; +console.log(sumTo(shortened, 6), sumTo(shortened, 3)); +console.log(scaleTo(dense, new Array(8).fill(0))); +console.log(scaleTo(dense, [9, 9])); +console.log(scaleTo([1, 2, 3], [])); +console.log(window(dense), window([1, 2, 3, 4, 5, 6])); diff --git a/tests/harness/corpus-costs/7320-array-dense-loop-invariant-limits.ts.json b/tests/harness/corpus-costs/7320-array-dense-loop-invariant-limits.ts.json new file mode 100644 index 000000000..2ea93101c --- /dev/null +++ b/tests/harness/corpus-costs/7320-array-dense-loop-invariant-limits.ts.json @@ -0,0 +1 @@ +{ "plain": 2600, "san": 31600 } From c297971f130d183cb0f39fa1a8991d0728e96340 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 07:41:13 -0500 Subject: [PATCH 080/102] Report JSX-lowered files to the checker server as changed The program the lowering compiles serves each file that has JSX at its own path, with the JSX rewritten to calls (host.addVirtualFile). The host reported such a path to the checker server as created whenever it was not virtual yet. The files exist on disk and the server had already read them for the program that checks them as written, so tsgo kept their original text, and lowering met the JSX syntax: SC1090 "syntax 'JsxFragment' is not supported yet" in 6822, 6824 and 6825 under SCRIPTC_CHECKER=tsgo, while tsc-ts reread the files. A virtual file that replaces a file on disk is now reported as changed, and both checkers give the same LLVM IR and diagnostics for the JSX corpus programs. --- packages/compiler/src/frontend/ts7/program-host.ts | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/packages/compiler/src/frontend/ts7/program-host.ts b/packages/compiler/src/frontend/ts7/program-host.ts index c87da0bfe..639086e94 100644 --- a/packages/compiler/src/frontend/ts7/program-host.ts +++ b/packages/compiler/src/frontend/ts7/program-host.ts @@ -192,7 +192,10 @@ export class Ts7Host { const key = tsgoPath(path); if (this.virtualFiles.get(key) === content) return; if (!this.virtualChanges.has(key)) - this.virtualChanges.set(key, this.virtualFiles.has(key) ? "changed" : "created"); + this.virtualChanges.set( + key, + this.virtualFiles.has(key) || trackedFileExists(path) ? "changed" : "created", + ); this.virtualFiles.set(key, content); } From 906f9911a148b4e1f54c0b4e195bafa92b629824 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 07:45:48 -0500 Subject: [PATCH 081/102] Keep a callback's captured scalars in registers in loops that call it A call through a binding that the constant-callback census resolves keeps a fallback through the closure's code pointer. In a loop that fallback is an unknown call that takes the closure, so the closure's code pointer, its captures and a captured `let` were reloaded, and the `let` stored back, on every iteration of `let s = 0; a.forEach((v) => { s = (s + v) | 0; })`. A for, while or do-while loop that calls such a binding now tests once, before the loop, that the binding's closure has the known code pointer. The copy where the test holds calls the function directly with no fallback, and the other copy is the ordinary loop. A closure's code pointer is set only when the closure is built and the census resolves only bindings the function never rebinds, so one test covers the loop. Only bindings declared before the loop qualify, and loops are versioned up to a size bound. Number and boolean box payloads get an alias category of their own, so a store to a captured `let` no longer aliases element loads and other memory in the loop. With the closure built in the caller, the test folds after inlining and the captured `let` stays in a register. --- .../src/backend/llvm/emit-function.ts | 2 + .../src/backend/llvm/emit-statements.ts | 117 ++++++++++++++ packages/compiler/src/backend/llvm/emitter.ts | 45 +++++- .../compiler/src/backend/llvm/expr-calls.ts | 27 ++-- .../test/callback-loop-versions.test.ts | 83 ++++++++++ .../7300-callback-captured-scalars.ts.json | 6 + .../corpus/7300-callback-captured-scalars.ts | 147 ++++++++++++++++++ .../7300-callback-captured-scalars.ts.json | 1 + 8 files changed, 406 insertions(+), 22 deletions(-) create mode 100644 packages/compiler/test/callback-loop-versions.test.ts create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7300-callback-captured-scalars.ts.json create mode 100644 tests/corpus/7300-callback-captured-scalars.ts create mode 100644 tests/harness/corpus-costs/7300-callback-captured-scalars.ts.json diff --git a/packages/compiler/src/backend/llvm/emit-function.ts b/packages/compiler/src/backend/llvm/emit-function.ts index 09e6551c3..9e8f7d701 100644 --- a/packages/compiler/src/backend/llvm/emit-function.ts +++ b/packages/compiler/src/backend/llvm/emit-function.ts @@ -83,6 +83,8 @@ export function emitFunction(emitter: LlEmitter, fn: IrFunction): string { } emitter.currentConstantCallbacks = emitter.debug === null ? (emitter.constantCallbacks.get(fn.name) ?? new Map()) : new Map(); + emitter.knownCallbacks.clear(); + emitter.callbackVersionsEnabled = emitter.debug === null && !fn.async && !fn.generator; // Preserve concrete source bindings for debugger inspection. Suspended // functions keep the established array lifetime across continuations. emitter.streamingSplitsEnabled = emitter.debug === null && !fn.async && !fn.generator; diff --git a/packages/compiler/src/backend/llvm/emit-statements.ts b/packages/compiler/src/backend/llvm/emit-statements.ts index 7239db7d8..618464e88 100644 --- a/packages/compiler/src/backend/llvm/emit-statements.ts +++ b/packages/compiler/src/backend/llvm/emit-statements.ts @@ -55,6 +55,7 @@ import { emitBytesLoopVersionGuard } from "./bytes-loop-versions.js"; import { mangleLocal } from "../mangle.js"; import { LlvmUnsupportedError } from "./unsupported.js"; import type { LlValue } from "./expr-context.js"; +import { everyExprChild, everyStmtChild } from "../../ir/traverse.js"; import { widenInteger } from "./integer-values.js"; import { SCALAR_UNION_RESULT } from "./int32-abi.js"; import { emitLiteralSwitch } from "./switch-dispatch.js"; @@ -76,6 +77,9 @@ import { } from "./string-construction.js"; import { emitStringInputs } from "./string-lifetimes.js"; +/** A callback loop version copies the loop; keep the copies small. */ +const MAX_CALLBACK_VERSION_COST = 400; + export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { const B = emitter.B; emitter.frames.push([]); @@ -795,6 +799,11 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { break; } case "while": { + const callbacks = callbackVersionBindings(emitter, s); + if (callbacks) { + emitCallbackVersionedLoop(emitter, s, callbacks); + break; + } const workerBudget = emitter.workerLoopBudget(s); const le = B.newLabel("loop.e"); emitter.emitLoopCopies(s, true, le, (exit) => { @@ -827,6 +836,11 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { break; } case "doWhile": { + const callbacks = callbackVersionBindings(emitter, s); + if (callbacks) { + emitCallbackVersionedLoop(emitter, s, callbacks); + break; + } const workerBudget = emitter.workerLoopBudget(s); // Body first (runs at least once); continue jumps to the CONDITION. const le = B.newLabel("loop.e"); @@ -855,6 +869,11 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { break; } case "for": { + const callbacks = callbackVersionBindings(emitter, s); + if (callbacks) { + emitCallbackVersionedLoop(emitter, s, callbacks); + break; + } // The init's scope wraps the whole loop (break/continue must NOT // release it — scopeDepth captured after the push, C parity). const integerArrayLoop = @@ -1885,6 +1904,104 @@ export function emitSwitch(emitter: LlEmitter, s: IrStmt & { kind: "switch" }): B.startBlock(end); } +/** The loop copies a callback loop version needs: the bindings the loop + * calls that the constant-callback census resolves to one function, each + * with that function's direct entry. Only small loops of optimized + * synchronous functions, and only bindings declared before the loop that + * an enclosing version has not already proved, qualify: the guard reads + * each binding before the loop runs. */ +function callbackVersionBindings( + emitter: LlEmitter, + s: IrStmt & { kind: "for" | "while" | "doWhile" }, +): { ref: IrExpr & { kind: "varRef" }; direct: string }[] | null { + if ( + !emitter.callbackVersionsEnabled || + emitter.currentConstantCallbacks.size === 0 || + emitter.callbackVersioning.has(s) + ) + return null; + const found = new Map(); + // Bindings the loop declares or writes (a callback declared in its body). + const bound = new Set(); + let cost = 0; + const expr = (e: IrExpr): boolean => { + if (++cost > MAX_CALLBACK_VERSION_COST) return false; + if (e.kind === "assignExpr") bound.add(e.localId); + if ( + e.kind === "callValue" && + e.callee.kind === "varRef" && + !emitter.knownCallbacks.has(e.callee.localId) && + !found.has(e.callee.localId) + ) { + const local = emitter.currentLocals.get(e.callee.localId); + const target = + local && local.tdz !== true ? emitter.knownCallbackTarget(e.callee) : undefined; + if (target) found.set(e.callee.localId, { ref: e.callee, direct: target.direct }); + } + return everyExprChild(e, expr, stmt); + }; + const stmt = (x: IrStmt): boolean => { + if (++cost > MAX_CALLBACK_VERSION_COST) return false; + if (x.kind === "varDecl" || x.kind === "assign" || x.kind === "forOf") bound.add(x.localId); + else if (x.kind === "tryCatch" && x.catchLocalId !== null) bound.add(x.catchLocalId); + return everyStmtChild(x, expr, stmt); + }; + if (!stmt(s)) return null; + const bindings = [...found.values()].filter(({ ref }) => !bound.has(ref.localId)); + return bindings.length > 0 ? bindings : null; +} + +/** A callback loop version. The guard tests, once before the loop, that + * each binding's closure holds its known function: a closure's code + * pointer is written only when the closure is built, and the census + * resolves only bindings the function never rebinds. The copy where the + * guard holds calls those functions directly, with no indirect fallback + * that could rewrite the closure or what it captures, so LLVM can keep a + * captured scalar the callback updates in a register. The other copy is the + * ordinary loop. */ +function emitCallbackVersionedLoop( + emitter: LlEmitter, + s: IrStmt & { kind: "for" | "while" | "doWhile" }, + bindings: { ref: IrExpr & { kind: "varRef" }; direct: string }[], +): void { + const B = emitter.B; + let ok = "true"; + for (const { ref, direct } of bindings) { + // A borrowed read: the guard only compares the code pointer. + const closure = emitter.emitReadReceiver(ref).name; + const fnp = B.tmp(), + fn = B.tmp(), + same = B.tmp(); + B.line(`${fnp} = getelementptr inbounds %ScrClosure, ptr ${closure}, i64 0, i32 1`); + B.line(`${fn} = load ptr, ptr ${fnp}`); + B.line(`${same} = icmp eq ptr ${fn}, ${direct}`); + if (ok === "true") ok = same; + else { + const both = B.tmp(); + B.line(`${both} = and i1 ${ok}, ${same}`); + ok = both; + } + } + const fast = B.newLabel("callback.version.fast"), + slow = B.newLabel("callback.version.slow"), + done = B.newLabel("callback.version.done"); + B.condBr(ok, fast, slow); + emitter.callbackVersioning.add(s); + try { + B.startBlock(slow); + emitter.emitStmt(s); + B.br(done); + B.startBlock(fast); + for (const { ref } of bindings) emitter.knownCallbacks.add(ref.localId); + emitter.emitStmt(s); + B.br(done); + } finally { + for (const { ref } of bindings) emitter.knownCallbacks.delete(ref.localId); + emitter.callbackVersioning.delete(s); + } + B.startBlock(done); +} + /** Emit a loop's condition, body and update through `emitCopy`, twice * when speculative-integers.ts plans a fast integer copy. Both copies * share the loop's setup and exit; the ordinary copy comes first so the diff --git a/packages/compiler/src/backend/llvm/emitter.ts b/packages/compiler/src/backend/llvm/emitter.ts index ed1785912..9170db7d2 100644 --- a/packages/compiler/src/backend/llvm/emitter.ts +++ b/packages/compiler/src/backend/llvm/emitter.ts @@ -831,6 +831,12 @@ export class LlEmitter { readonly callLifetimes: CallLifetimes; readonly constantCallbacks: Map>; currentConstantCallbacks: ReadonlyMap = new Map(); + /** Callback bindings whose closures an enclosing callback loop version + * proved to hold their known function: calls take the direct entry with + * no fallback (emitCallbackVersionedLoop). */ + knownCallbacks = new Set(); + readonly callbackVersioning = new Set(); + callbackVersionsEnabled = false; readonly stackCallbacks: StackCallbacks; readonly receiverReaders: AmbientReceiverReaders; readonly stackCaptures: StackCaptures; @@ -3901,6 +3907,25 @@ export class LlEmitter { return b; } + /** The function a call through `callee` is known to reach (a literal + * closure, or a binding the constant-callback census resolves) and the + * entry it calls directly. Async and generator functions stay indirect. */ + knownCallbackTarget(callee: IrExpr): { known: IrFunction; direct: string } | undefined { + const knownName = + callee.kind === "closure" + ? callee.fnName + : callee.kind === "varRef" + ? this.currentConstantCallbacks.get(callee.localId) + : undefined; + const known = knownName ? this.fnByName.get(knownName) : undefined; + if (!known || known.async || known.generator) return undefined; + if (known.captures === undefined) { + this.fnValues.add(known.name); + return { known, direct: `@${mangleWrapper(known.name)}` }; + } + return { known, direct: `@${this.callTarget(known.name)}` }; + } + /** The payload slot of a capture box (ScrBox.slot, field 5). */ boxSlot(box: string): string { const slot = this.B.tmp(); @@ -3914,12 +3939,18 @@ export class LlEmitter { const r = B.tmp(); // Scalar payloads are read in place (scr_box_get_f64/bool are a // memcpy and a nonzero test of the same slot), so LLVM can keep a - // captured number in a register across a loop of calls. + // captured number in a register across a loop of calls. They have an + // alias category of their own: every other access to a box's payload + // is untagged or a runtime call. if (acc === "f64") { - B.line(`${r} = load double, ptr ${this.boxSlot(box)}`); + B.line( + `${r} = load double, ptr ${this.boxSlot(box)}${this.memoryAliasAttachment("box:scalar")}`, + ); } else if (acc === "bool") { const raw = B.tmp(); - B.line(`${raw} = load i64, ptr ${this.boxSlot(box)}`); + B.line( + `${raw} = load i64, ptr ${this.boxSlot(box)}${this.memoryAliasAttachment("box:scalar")}`, + ); B.line(`${r} = icmp ne i64 ${raw}, 0`); } else { this.declare(`declare ptr @scr_box_get_ref(ptr)`); @@ -3933,11 +3964,15 @@ export class LlEmitter { const B = this.B; const acc = boxAccess(t); if (acc === "f64") { - B.line(`store double ${value}, ptr ${this.boxSlot(box)}`); + B.line( + `store double ${value}, ptr ${this.boxSlot(box)}${this.memoryAliasAttachment("box:scalar")}`, + ); } else if (acc === "bool") { const raw = B.tmp(); B.line(`${raw} = zext i1 ${value} to i64`); - B.line(`store i64 ${raw}, ptr ${this.boxSlot(box)}`); + B.line( + `store i64 ${raw}, ptr ${this.boxSlot(box)}${this.memoryAliasAttachment("box:scalar")}`, + ); } else { this.declare(`declare void @scr_box_set_ref(ptr, ptr)`); B.line(`call void @scr_box_set_ref(ptr ${box}, ptr ${value})`); diff --git a/packages/compiler/src/backend/llvm/expr-calls.ts b/packages/compiler/src/backend/llvm/expr-calls.ts index f0aa3b276..4bcf2a3d5 100644 --- a/packages/compiler/src/backend/llvm/expr-calls.ts +++ b/packages/compiler/src/backend/llvm/expr-calls.ts @@ -29,7 +29,6 @@ import { mangleClassStruct, mangleFnClosure, mangleFunction, - mangleWrapper, mangleVtStruct, mangleAsyncDirectSpawn, } from "../mangle.js"; @@ -839,21 +838,9 @@ export function emitCallExpr( host.declare("declare void @scr_dyn_this_push_dyn(ptr)"); B.line(`call void @scr_dyn_this_push_dyn(ptr ${receiver?.name ?? "null"})`); }; - const knownName = - e.callee.kind === "closure" - ? e.callee.fnName - : e.callee.kind === "varRef" - ? host.currentConstantCallbacks.get(e.callee.localId) - : undefined; - const candidate = knownName ? host.fnByName.get(knownName) : undefined; - const known = candidate && !candidate.async && !candidate.generator ? candidate : undefined; - let direct: string | undefined; - if (known) { - if (known.captures === undefined) { - host.fnValues.add(known.name); - direct = `@${mangleWrapper(known.name)}`; - } else direct = `@${host.callTarget(known.name)}`; - } + const target = host.knownCallbackTarget(e.callee); + const known = target?.known; + const direct = target?.direct; // A known closure body that borrows reference parameters is entered // directly with lent arguments, as a direct call to a borrowing body // is: an argument is read without a reference when neither a later @@ -939,7 +926,13 @@ export function emitCallExpr( let pending = host.indirectMayThrow; let pendingGuard: string | undefined; let t: string; - if (direct && e.callee.kind === "closure") { + // A literal closure, or a binding an enclosing callback loop version + // proved to hold its known function, enters it directly. + if ( + direct && + (e.callee.kind === "closure" || + (e.callee.kind === "varRef" && host.knownCallbacks.has(e.callee.localId))) + ) { t = invoke(lending ?? direct, !host.receiverReaders.ignores(known!)); if (quiet) pending = false; } else { diff --git a/packages/compiler/test/callback-loop-versions.test.ts b/packages/compiler/test/callback-loop-versions.test.ts new file mode 100644 index 000000000..c26abe1c4 --- /dev/null +++ b/packages/compiler/test/callback-loop-versions.test.ts @@ -0,0 +1,83 @@ +import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { expect, test } from "vitest"; +import { compile } from "../src/index.js"; + +async function emitLlvm(source: string): Promise { + const dir = await mkdtemp(join(tmpdir(), "scriptc-callback-versions-")); + try { + const entry = join(dir, "main.ts"); + const outPath = join(dir, "main.ll"); + await writeFile(entry, source); + const result = await compile(entry, { outDir: dir, outPath, outputKind: "llvm" }); + if (!result.ok) throw new Error(result.diagnostics.map((d) => d.message).join("\n")); + return await readFile(outPath, "utf8"); + } finally { + await rm(dir, { recursive: true, force: true }); + } +} + +const body = (llvm: string, marker: string): string => { + const match = new RegExp(`^define internal [^\\n]*${marker}[^]*?^}`, "m").exec(llvm); + if (!match) throw new Error(`no function ${marker}`); + return match[0]; +}; + +test("loops that call a known callback test its closure once and call it directly", async () => { + const llvm = await emitLlvm(` + function each(values: number[], visit: (v: number) => void): void { + for (let i = 0; i < values.length; i++) visit(values[i]!); + } + let sum = 0; + each([1, 2, 3], (v) => { sum += v; }); + console.log(sum); + `); + const fn = body(llvm, "@sc_bf_each"); + const fast = /^callback\.version\.fast\d+:$[^]*?^callback\.version\.done\d+:$/m.exec(fn)![0]; + // The guard compares the closure's code pointer once, before the loop. + expect(fn.slice(0, fn.indexOf(fast))).toMatch(/icmp eq ptr %\S+, @/); + expect(fast).not.toContain("callback.indirect"); + expect(fast).not.toContain("scr_dyn_this_push_dyn"); + // The ordinary copy keeps the fallback through the closure's pointer. + expect(fn).toContain("callback.indirect"); +}); + +test("captured number payloads carry their own alias tag", async () => { + const llvm = await emitLlvm(` + function total(values: number[]): number { + let sum = 0; + values.forEach((v) => { sum += v; }); + return sum; + } + console.log(total([1, 2, 3])); + `); + // Every read and write through a box's payload slot (field 5) is tagged. + const slots = [ + ...llvm.matchAll(/(%\S+) = getelementptr inbounds %ScrBox, ptr %\S+, i32 0, i32 5/g), + ]; + expect(slots.length).toBeGreaterThan(0); + for (const [, slot] of slots) { + for (const access of llvm.matchAll( + new RegExp(`(load double, ptr|store double %\\S+, ptr) \\${slot}\\b[^\\n]*`, "g"), + )) + expect(access[0]).toMatch(/!tbaa !\d+$/); + } + expect(llvm).toMatch(/load double, ptr %\S+, !tbaa !\d+/); +}); + +test("a callback declared in the loop body is not read before the loop", async () => { + const llvm = await emitLlvm(` + function strides(): number { + let calls = 0; + for (let i = 0; i < 10; i++) { + const bump = (): void => { i += 2; }; + bump(); + calls++; + } + return calls; + } + console.log(strides()); + `); + expect(llvm).not.toContain("callback.version"); +}); diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7300-callback-captured-scalars.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7300-callback-captured-scalars.ts.json new file mode 100644 index 000000000..dc1158934 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7300-callback-captured-scalars.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7300-callback-captured-scalars.ts" + ], + "diags": [] +} diff --git a/tests/corpus/7300-callback-captured-scalars.ts b/tests/corpus/7300-callback-captured-scalars.ts new file mode 100644 index 000000000..c8e8b28bd --- /dev/null +++ b/tests/corpus/7300-callback-captured-scalars.ts @@ -0,0 +1,147 @@ +// Callbacks that update captured `let` numbers and booleans from loops: typed +// array and array methods, an authored higher-order function called with one +// function at several calls and with two functions at one, closures of one +// function over different bindings, a callback that throws part way, nested +// callbacks, callbacks declared in the loop body, and reads after the loop. + +function each(values: number[], visit: (v: number, i: number) => void): void { + for (let i = 0; i < values.length; i++) visit(values[i]!, i); +} + +function until(limit: number, step: (i: number) => boolean): number { + let i = 0; + while (i < limit) { + if (!step(i)) break; + i++; + } + return i; +} + +function twice(values: Int16Array, f: (v: number) => void): void { + let i = 0; + do { + for (let j = 0; j < values.length; j++) f(values[j]!); + i++; + } while (i < 2); +} + +const ints = new Int32Array([5, -3, 8, 0, 12, -7, 4]); +let total = 0; +let negatives = 0; +let sawZero = false; +ints.forEach((v) => { + total = (total + v) | 0; + if (v < 0) negatives++; + if (v === 0) sawZero = true; +}); +console.log("forEach", total, negatives, sawZero); + +let max = -Infinity; +let maxAt = -1; +const floats = new Float64Array([0.5, 9.25, -2, 9.25, 3]); +floats.forEach((v, i) => { + if (v > max) { + max = v; + maxAt = i; + } +}); +console.log("max", max, maxAt); + +let calls = 0; +const doubled = ints.map((v) => { + calls++; + return v * 2 + calls; +}); +console.log("map", doubled.join(","), calls); + +let seen = 0; +const big = [3, 14, 15, 92, 65].filter((v) => { + seen += v; + return v > 10; +}); +console.log("filter", big.join(","), seen); + +let sum = 0; +let count = 0; +const summing = (v: number): void => { + sum += v; + count++; +}; +each([1, 2, 3], summing); +each([10, 20], summing); +console.log("each shared", sum, count); + +let a = 0; +let b = 0; +each([1, 2], (v) => { + a += v; +}); +each([1, 2], (v, i) => { + b += v * (i + 1); +}); +console.log("each two", a, b); + +const counters: (() => number)[] = []; +for (let k = 0; k < 3; k++) { + let local = k * 100; + each([1, 1, 1], () => { + local++; + }); + counters.push(() => local); +} +console.log("closures", counters.map((c) => c()).join(",")); + +let steps = 0; +console.log("until", until(10, (i) => (steps += i, steps < 12)), steps); + +let shorts = 0; +twice(new Int16Array([7, -8, 9]), (v) => { + shorts = shorts * 2 + v; +}); +console.log("twice", shorts); + +let partial = 0; +try { + floats.forEach((v) => { + if (v < 0) throw new RangeError(`at ${partial}`); + partial += v; + }); +} catch (error) { + console.log("throw", (error as Error).message, partial); +} + +let outer = 0; +let inner = 0; +[1, 2, 3].forEach((x) => { + outer += x; + ints.forEach((y) => { + if (y > x) inner++; + }); +}); +console.log("nested", outer, inner); + +let flag = false; +let flips = 0; +new Uint8Array([1, 0, 1, 1]).forEach((v) => { + if (v === 1) flag = !flag; + if (flag) flips++; +}); +console.log("bool", flag, flips); + +// Callbacks declared in the loop body: each iteration binds its own. +let strides = 0; +for (let i = 0; i < 10; i++) { + const bump = (): void => { + i += 2; + strides++; + }; + bump(); +} +let countdown = 0; +let k = 3; +while (k > 0) { + const tick = (n: number): number => (n > 0 ? tick(n - 1) + 1 : 0); + countdown += tick(k); + k--; +} +console.log("declared in loop", strides, countdown); diff --git a/tests/harness/corpus-costs/7300-callback-captured-scalars.ts.json b/tests/harness/corpus-costs/7300-callback-captured-scalars.ts.json new file mode 100644 index 000000000..18495cd4e --- /dev/null +++ b/tests/harness/corpus-costs/7300-callback-captured-scalars.ts.json @@ -0,0 +1 @@ +{ "plain": 6000, "san": 7900 } From f0c48e1b399cb7aa44ddfad988b678f9c6c3154d Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 08:03:32 -0500 Subject: [PATCH 082/102] Bound compiled regex reads by the characters left in the subject The 16-character searches (the first-character search, the start filter and greedy class loops) and literal runs checked `i + n <= len` in 32-bit arithmetic. Subjects may be up to 2^31 - 2 characters, so near that length the sum wrapped negative, passed the check and read past the subject. Each check now compares the characters left (`len - i`, which cannot wrap) with the characters it reads, and advances the position only after it passes. --- .../src/backend/llvm/regex-matchers.ts | 28 +++--- .../test/regex-matcher-bounds.test.ts | 91 +++++++++++++++++++ 2 files changed, 106 insertions(+), 13 deletions(-) create mode 100644 packages/compiler/test/regex-matcher-bounds.test.ts diff --git a/packages/compiler/src/backend/llvm/regex-matchers.ts b/packages/compiler/src/backend/llvm/regex-matchers.ts index 77f8a06eb..d83d6bae5 100644 --- a/packages/compiler/src/backend/llvm/regex-matchers.ts +++ b/packages/compiler/src/backend/llvm/regex-matchers.ts @@ -882,16 +882,13 @@ class RxGen { this.block(head); const i = this.tmp(), i16 = this.tmp(), + rest = this.tmp(), fits = this.tmp(); this.line(`${i} = phi i32 [ ${a}, %seek ], [ ${i16}, %${next} ]`); - this.line(`${i16} = add i32 ${i}, 16`); - if (reach === 0) { - this.line(`${fits} = icmp sle i32 ${i16}, %len`); - } else { - const last = this.tmp(); - this.line(`${last} = add i32 ${i16}, ${reach}`); - this.line(`${fits} = icmp sle i32 ${last}, %len`); - } + // The characters left (0 <= i <= len, so this cannot wrap; i + 16 + // can for subjects near 2^31 characters). + this.line(`${rest} = sub i32 %len, ${i}`); + this.line(`${fits} = icmp sge i32 ${rest}, ${16 + reach}`); this.line(`br i1 ${fits}, label %${load}, label %${tail}`); this.block(load); const mask = filter !== null ? this.testPrefix(filter, i) : this.testVector(plan!, i), @@ -899,6 +896,7 @@ class RxGen { this.line(`${any} = icmp ne i16 ${mask}, 0`); this.line(`br i1 ${any}, label %${hit}, label %${next}`); this.block(next); + this.line(`${i16} = add i32 ${i}, 16`); this.line(`br label %${head}`); this.block(hit); const k = this.lowestBit(mask), @@ -1149,10 +1147,10 @@ class RxGen { check = this.label("chk"); this.block(entry); const p = this.loadPos(), - end = this.tmp(), + rest = this.tmp(), inb = this.tmp(); - this.line(`${end} = add i32 ${p}, ${sets.length}`); - this.line(`${inb} = icmp sle i32 ${end}, %len`); + this.line(`${rest} = sub i32 %len, ${p}`); + this.line(`${inb} = icmp sge i32 ${rest}, ${sets.length}`); this.line(`br i1 ${inb}, label %${check}, label %fail`); this.block(check); let acc = ""; @@ -1171,6 +1169,8 @@ class RxGen { acc = both; } } + const end = this.tmp(); + this.line(`${end} = add i32 ${p}, ${sets.length}`); // Storing before the branch is safe: every resume sets the position. this.storePos(end); this.line(`br i1 ${acc}, label %${succ}, label %fail`); @@ -1377,10 +1377,11 @@ class RxGen { this.block(vhead); const kv = this.tmp(), kv16 = this.tmp(), + left = this.tmp(), fits = this.tmp(); this.line(`${kv} = phi i32 [ 0, %${entry} ], [ ${kv16}, %${vnext} ]`); - this.line(`${kv16} = add i32 ${kv}, 16`); - this.line(`${fits} = icmp sle i32 ${kv16}, ${lim}`); + this.line(`${left} = sub i32 ${lim}, ${kv}`); + this.line(`${fits} = icmp sge i32 ${left}, 16`); this.line(`br i1 ${fits}, label %${vload}, label %${tail}`); this.block(vload); const vat = this.tmp(); @@ -1390,6 +1391,7 @@ class RxGen { this.line(`${all} = icmp eq i16 ${mask}, -1`); this.line(`br i1 ${all}, label %${vnext}, label %${vexit}`); this.block(vnext); + this.line(`${kv16} = add i32 ${kv}, 16`); this.line(`br label %${vhead}`); this.block(vexit); const missing = this.tmp(); diff --git a/packages/compiler/test/regex-matcher-bounds.test.ts b/packages/compiler/test/regex-matcher-bounds.test.ts new file mode 100644 index 000000000..3e0ec7f1b --- /dev/null +++ b/packages/compiler/test/regex-matcher-bounds.test.ts @@ -0,0 +1,91 @@ +/* Compiled regex matchers bound every read by the characters left in the + * subject, so subjects near the runtime's 2^31 - 2 character limit are + * read only inside the subject. Each matcher runs on a subject of exactly + * that length whose last byte sits just before an inaccessible page: a + * bounds check that wraps past INT32_MAX reads that page and faults. The + * subject is a lazily mapped zero region (no memory is committed for it) + * with the characters each case needs written near its end. */ +import { execFileSync } from "node:child_process"; +import { mkdtempSync, rmSync, writeFileSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { expect, test } from "vitest"; +import { compileRegexMatcher, REGEX_MATCHER_DECLS } from "../src/backend/llvm/regex-matchers.js"; + +const LIMIT = 2 ** 31 - 2; + +/** [symbol, pattern, flags, start offset from the end, tail text]. */ +const CASES: [string, string, string, number, string][] = [ + // The first-character vector search, 10 characters before the end. + ["seek", "[b-d]", "", 10, "c"], + // The start filter (two 8-character alternatives), 20 before the end. + ["filter", "agggtaaa|tttaccct", "i", 20, "TTTACCCT"], + // A run of 8 literal characters beginning 2 before the end. + ["run", "xy234567", "", 30, "xy"], + // A greedy class over the whole subject, 16 characters per step. + ["greedy", "[^x]+", "", LIMIT, ""], +]; + +const DRIVER = ` +#include +#include +#include +#include +#include +void scr_regex_stack_grow(void *a, void *b, void *c, int32_t d) { (void)a; (void)b; (void)c; (void)d; _exit(3); } +void scr_regex_stack_free(void *p) { (void)p; } +${CASES.map(([sym]) => `int32_t ${sym}(const char *, int32_t, int32_t, const char **);`).join("\n")} +static void check(const char *name, int32_t (*m)(const char *, int32_t, int32_t, const char **), + int32_t start, const char *tail) { + const int32_t len = ${LIMIT}; + size_t page = (size_t)sysconf(_SC_PAGESIZE); + size_t body = ((size_t)len + page - 1) / page * page; + char *base = mmap(NULL, body + page, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0); + if (base == MAP_FAILED || mprotect(base + body, page, PROT_NONE) != 0) _exit(4); + char *s = base + (body - (size_t)len); + memcpy(s + len - strlen(tail), tail, strlen(tail)); + const char *out[16] = {0}; + int32_t found = m(s, len, start, out); + if (found) printf("%s %ld %ld\\n", name, (long)(out[0] - s), (long)(out[1] - s)); + else printf("%s none\\n", name); + fflush(stdout); + munmap(base, body + page); +} +int main(void) { +${CASES.map(([sym, , , back, tail]) => ` check("${sym}", ${sym}, ${LIMIT - back}, ${JSON.stringify(tail)});`).join("\n")} + return 0; +} +`; + +test.skipIf(process.platform === "win32")( + "compiled regex matchers stay inside subjects near 2^31 characters", + { timeout: 120_000 }, + () => { + const lines: string[] = []; + const decls = new Set(REGEX_MATCHER_DECLS); + for (const [sym, pattern, flags] of CASES) { + const code = compileRegexMatcher(sym, pattern, flags, "i64", true); + if (code === null) throw new Error(`/${pattern}/${flags} did not compile`); + lines.push(...code.lines.map((line) => line.replace(/^define internal /, "define "))); + for (const decl of code.decls) decls.add(decl); + } + const dir = mkdtempSync(join(tmpdir(), "scriptc-regex-bounds-")); + try { + const ir = join(dir, "matchers.ll"); + const driver = join(dir, "driver.c"); + const binary = join(dir, "bounds"); + writeFileSync(ir, [...decls, ...lines, "attributes #0 = { nounwind }", ""].join("\n")); + writeFileSync(driver, DRIVER); + execFileSync("clang", ["-O2", "-Wno-override-module", ir, driver, "-o", binary]); + const output = execFileSync(binary, { encoding: "utf8" }); + expect(output.trim().split("\n")).toEqual([ + `seek ${LIMIT - 1} ${LIMIT}`, + `filter ${LIMIT - 8} ${LIMIT}`, + "run none", + `greedy 0 ${LIMIT}`, + ]); + } finally { + rmSync(dir, { recursive: true, force: true }); + } + }, +); From 866c0bfea5a22bff19537bf33f8c375fc7d8823c Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 08:05:45 -0500 Subject: [PATCH 083/102] Version typed-array loops whose index adds an unranged invariant term A row-major dot product, `const base = r * cols; for (let j = 0; j < cols; j++) s += w[base + j] * v[j]`, kept one index test per `w` read: the typed-array loop version guard covered an index `k * counter + terms + c` only when every loop-invariant term had a proven integer range, and `base` has none when `cols` is a parameter. The guard now also accepts a pure loop-invariant term without a proven range. It evaluates the term once and requires an exact integer (not -0) between -2^32 and 2^32, then checks the first and last index as for any affine index. In the fast copy the term has that range, so the index is integer arithmetic and the reads take no index test. Any other value runs the checked copy. Adds a Float32Array matrix-vector product with four accumulators per row to the typed-array-kernels workload. --- benchmarks/runtime/README.md | 2 +- .../runtime/workloads/typed-array-kernels.ts | 31 ++++++- .../backend/llvm/bytes-loop-versions.test.ts | 33 +++++++ .../src/backend/llvm/bytes-loop-versions.ts | 89 ++++++++++++++++--- ...-typed-array-invariant-index-terms.ts.json | 6 ++ .../6997-typed-array-invariant-index-terms.ts | 78 ++++++++++++++++ ...-typed-array-invariant-index-terms.ts.json | 1 + 7 files changed, 227 insertions(+), 13 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6997-typed-array-invariant-index-terms.ts.json create mode 100644 tests/corpus/6997-typed-array-invariant-index-terms.ts create mode 100644 tests/harness/corpus-costs/6997-typed-array-invariant-index-terms.ts.json diff --git a/benchmarks/runtime/README.md b/benchmarks/runtime/README.md index cbf47675a..1e01aa3a7 100644 --- a/benchmarks/runtime/README.md +++ b/benchmarks/runtime/README.md @@ -26,7 +26,7 @@ Application-shaped workloads for measuring the speed of compiled executables. Ea | `region-builds` | cpu | a watch-mode build loop over `LifetimeRegion`: each build binds a program in a new region and releases the previous one, which a cache keeps referenced for two builds | | `template-render` | cpu | template literals, escaping, `map`/`join` | | `thread-slots`, `thread-slots-cache` | cpu | worker threads reading one published type graph from an `InternTable` and keeping per-thread state for each type they visit: a `ThreadSlots` family, or a direct-mapped cache by id in front of a `Map` by id (the `-cache` entry); under Node.js both are per thread | -| `typed-array-kernels` | cpu | element-wise loops that run to one typed array's length and index others at the same position: `Float64Array` axpy, `Float32Array` blend, `Uint8Array` mask, wrapping `Int32Array` add, `Uint8ClampedArray` brighten, RGBA to gray | +| `typed-array-kernels` | cpu | element-wise loops that run to one typed array's length and index others at the same position: `Float64Array` axpy, `Float32Array` blend, `Uint8Array` mask, wrapping `Int32Array` add, `Uint8ClampedArray` brighten, RGBA to gray, and a row-major `Float32Array` matrix-vector product | | `typed-array-scan`, `typed-array-scan-workers` | cpu | element-by-element scan loops over `Uint8Array`, `Uint16Array`, `Int32Array` and `Float64Array`; the second entry is a worker-enabled executable (it can start a worker), so each access also checks for shared storage | | `unicode-lexer` | cpu | a hand-written lexer over a 2.7M-unit bundled module whose comments and strings are in several languages: `charCodeAt` scans, line starts | | `validate-errors` | cpu | throw/catch on a fraction of inputs, small call chains | diff --git a/benchmarks/runtime/workloads/typed-array-kernels.ts b/benchmarks/runtime/workloads/typed-array-kernels.ts index ba68f7241..4fd2e7cd7 100644 --- a/benchmarks/runtime/workloads/typed-array-kernels.ts +++ b/benchmarks/runtime/workloads/typed-array-kernels.ts @@ -1,5 +1,6 @@ // Element-wise loops over several typed arrays: each loop runs to one -// array's length and reads or writes the others at the same index. +// array's length and reads or writes the others at the same index. Also a +// row-major matrix-vector product with four accumulators per row. function axpy(a: number, x: Float64Array, y: Float64Array, out: Float64Array): void { for (let i = 0; i < out.length; i++) out[i] = a * x[i]! + y[i]!; @@ -21,6 +22,23 @@ function brighten(src: Uint8ClampedArray, gain: number, out: Uint8ClampedArray): for (let i = 0; i < out.length; i++) out[i] = src[i]! * gain + 8; } +function matvec(w: Float32Array, x: Float32Array, out: Float32Array, cols: number): void { + for (let r = 0; r < out.length; r++) { + const base = r * cols; + let s0 = 0; + let s1 = 0; + let s2 = 0; + let s3 = 0; + for (let j = 0; j < cols; j += 4) { + s0 += w[base + j]! * x[j]!; + s1 += w[base + j + 1]! * x[j + 1]!; + s2 += w[base + j + 2]! * x[j + 2]!; + s3 += w[base + j + 3]! * x[j + 3]!; + } + out[r] = s0 + s1 + s2 + s3; + } +} + function gray(rgba: Uint8Array, out: Uint8Array): void { for (let i = 0; i < out.length; i++) { const j = i * 4; @@ -45,6 +63,10 @@ const io = new Int32Array(n); const pixels = new Uint8ClampedArray(n); const bright = new Uint8ClampedArray(n); const rgba = new Uint8Array(n * 4); +const side = 256; +const weights = new Float32Array(side * side); +const vector = new Float32Array(side); +const product = new Float32Array(side); const luma = new Uint8Array(n); let state = 2463534242; const next = (): number => { @@ -65,6 +87,8 @@ for (let i = 0; i < n; i++) { pixels[i] = next() & 255; } for (let i = 0; i < rgba.length; i++) rgba[i] = next() & 255; +for (let i = 0; i < weights.length; i++) weights[i] = (next() % 2001) / 1000 - 1; +for (let i = 0; i < side; i++) vector[i] = (next() % 1001) / 1000; const rounds = Math.round(1200 * scale); let f64Sum = 0; @@ -73,6 +97,7 @@ let byteSum = 0; let intSum = 0; let brightSum = 0; let lumaSum = 0; +let productSum = 0; for (let r = 0; r < rounds; r++) { // Change one input element per round so no round repeats the last. const at = (r * 7919) & (n - 1); @@ -82,12 +107,14 @@ for (let r = 0; r < rounds; r++) { ia[at] = r * 65537; pixels[at] = r & 255; rgba[at * 4] = r & 255; + vector[r & (side - 1)] = (r % 1001) / 1000; axpy(1.5, x, y, d); blend((r & 15) / 16, fa, fb, fo); mask(data, key, masked); addWrap(ia, ib, io); brighten(pixels, 0.75 + (r & 7) / 8, bright); gray(rgba, luma); + matvec(weights, vector, product, side); const probe = (r * 104729) & (n - 1); f64Sum += d[probe]!; f32Sum += fo[probe]!; @@ -95,6 +122,7 @@ for (let r = 0; r < rounds; r++) { intSum = (intSum + io[probe]!) | 0; brightSum += bright[probe]!; lumaSum += luma[probe]!; + productSum += product[probe & (side - 1)]!; } console.log(`float64 ${f64Sum.toFixed(3)}`); console.log(`float32 ${f32Sum.toFixed(3)}`); @@ -102,3 +130,4 @@ console.log(`uint8 ${byteSum}`); console.log(`int32 ${intSum}`); console.log(`clamped ${brightSum}`); console.log(`gray ${lumaSum}`); +console.log(`matvec ${productSum.toFixed(3)}`); diff --git a/packages/compiler/src/backend/llvm/bytes-loop-versions.test.ts b/packages/compiler/src/backend/llvm/bytes-loop-versions.test.ts index 28194c7b3..ace8f294c 100644 --- a/packages/compiler/src/backend/llvm/bytes-loop-versions.test.ts +++ b/packages/compiler/src/backend/llvm/bytes-loop-versions.test.ts @@ -134,6 +134,39 @@ test("a counted loop's affine accesses get one guard and exact operand ranges", expect(version.ranges.get(shifted)).toEqual({ min: 1, max: Number.MAX_SAFE_INTEGER }); }); +test("invariant terms without a range are tested by the guard", () => { + // for (let i = 0; i < n; i++) out[i] = src[k + i], with `k` a parameter + const shifted = bin("+", ref("k"), ref("i")); + const loop = counted([set(ref("out", f64s), ref("i"), get(ref("src", f64s), shifted))]); + const kernel = fn([loop]); + const version = match(kernel, loop)!; + expect([...version.guarded]).toEqual(["v1:k"]); + expect(version.affine.map((c) => c.terms.map((t) => t.key))).toEqual([[], ["v1:k"]]); + // In the fast copy the term has the range the guard tests. + expect(version.ranges.get(shifted.kind === "bin" ? shifted.left : shifted)).toEqual({ + min: -(2 ** 32), + max: 2 ** 32, + }); + 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)); + // -2^32 <= k <= 2^32, and k is the double of its frozen integer. + expect(guard).toMatch(/fcmp oge double %\S+, 0xC1F0000000000000/); + expect(guard).toMatch(/fcmp ole double %\S+, 0x41F0000000000000/); + expect(guard).toMatch(/freeze i64/); + const fast = /^bytes\.version\.fast\d+:$[^]*?^bytes\.version\.done\d+:$/m.exec(body)![0]; + expect(fast).not.toContain("bytes.index"); + expect(body.slice(0, body.indexOf(fast))).toContain("bytes.index.invalid"); +}); + test("statically ranged indices compare one constant with the length", () => { const masked = bin("&", bin("^", ref("i"), ref("k")), num(255)); const loop = counted([set(ref("out", f64s), num(0), get(ref("table", i32s), masked))]); diff --git a/packages/compiler/src/backend/llvm/bytes-loop-versions.ts b/packages/compiler/src/backend/llvm/bytes-loop-versions.ts index 8c7f668a0..c3cee3feb 100644 --- a/packages/compiler/src/backend/llvm/bytes-loop-versions.ts +++ b/packages/compiler/src/backend/llvm/bytes-loop-versions.ts @@ -7,6 +7,7 @@ import { everyExprChild, everyStmtChild } from "../../ir/traverse.js"; import { exactInteger, widenInteger } from "./integer-values.js"; import { emitCountedLoopLimit, emitCountedLoopSafety } from "./counted-loops.js"; import { emitBytesHeaderLength, emitBytesSharedStorage } from "./expr-bytes.js"; +import { f64Lit } from "./common.js"; type Node = IrExpr | IrStmt; type VarRef = IrExpr & { kind: "varRef" }; @@ -50,6 +51,9 @@ export interface BytesLoopVersion { ownedReceivers: number[]; fixed: FixedCheck[]; affine: AffineCheck[]; + /** Keys of affine terms the guard tests at run time: exact integers + * within GUARDED_TERM. */ + guarded: ReadonlySet; /** The counted loop whose iteration space the affine checks cover. */ counted: IntegerCountedForLoop | null; /** The guard also requires every counter value within [-bound, bound]. */ @@ -83,6 +87,9 @@ const MAX_FIXED_END = 2 ** 32; const MAX_CHECKS = 8; const MAX_OFFSET = 2 ** 31; const SAFE = Number.MAX_SAFE_INTEGER; +/** The range the guard requires of an invariant index term without a + * proven one: every index of a typed array of at most 2^32 elements. */ +const GUARDED_TERM: IntegerRange = { min: -(2 ** 32), max: 2 ** 32 }; const INVARIANT_OPS = new Set(["+", "-", "*", "&", "|", "^", "<<", ">>", ">>>"]); /** Loop versioning for typed-array bounds. A typed array's length and data @@ -95,7 +102,9 @@ const INVARIANT_OPS = new Set(["+", "-", "*", "&", "|", "^", "<<", ">>", ">>>"]) * `hi < length`, such as `table[x & 0xff]` or a constant-trip counter; * - an index `k * counter + invariant + c` of a counted loop needs its first * and last values in bounds, such as `out[base + i]` for `i < n` or - * `view.getUint32(i * 4)`. + * `view.getUint32(i * 4)`. An invariant without a proven integer range, + * such as `base` for `const base = r * cols`, must also be an exact + * integer between -2^32 and 2^32, which the guard tests. * * In worker programs, every access of a view that may be shared tests its * shared storage. A view's storage is also fixed at construction, so the @@ -198,9 +207,8 @@ export function matchBytesLoopVersion( } return invariant(e.localId) ? e : null; }; - // A pure integer operand evaluated again before the loop. - const invariantKey = (e: IrExpr): string | null => { - if (!facts.ranges.get(e)) return null; + // A pure loop-invariant number, evaluated again before the loop. + const pureKey = (e: IrExpr): string | null => { if (e.kind === "numLit") return Number.isSafeInteger(e.value) ? `n${e.value}` : null; if (e.kind === "varRef") return invariant(e.localId) ? `v${e.localId.length}:${e.localId}` : null; @@ -210,12 +218,27 @@ export function matchBytesLoopVersion( e.left.type.kind === "f64" && e.right.type.kind === "f64" ) { - const left = invariantKey(e.left), - right = invariantKey(e.right); + const left = pureKey(e.left), + right = pureKey(e.right); return left !== null && right !== null ? `(${e.op} ${left} ${right})` : null; } return null; }; + // Invariant terms without a proven range, such as `base` in + // `w[base + j]` with `const base = r * cols` for a parameter `cols`. The + // guard tests each one: an exact integer (not -0) within GUARDED_TERM. + const guardedRanges = new Map(); + const guardedNodes = new Map(); + // The key of a loop-invariant index term, with a proven range or guarded. + const invariantKey = (e: IrExpr): string | null => { + const key = pureKey(e); + if (key === null || facts.ranges.get(e)) return key; + if (e.kind === "numLit") return null; + guardedRanges.set(e, GUARDED_TERM); + guardedNodes.set(e, key); + return key; + }; + const termRange = (e: IrExpr): IntegerRange => facts.ranges.get(e) ?? guardedRanges.get(e)!; interface Affine { /** The counter's coefficient; 0 when the value is loop-invariant. */ counter: number; @@ -223,9 +246,10 @@ export function matchBytesLoopVersion( offset: number; } // Every operand of an affine index is `counter * k + Σ terms + offset`. - // Invariant terms need proven ranges. Operands that involve the counter - // need none: the guard bounds the counter so that each of them is a safe - // integer, which makes the index's double arithmetic exact. + // Invariant terms need proven ranges or the guard's test (guarded terms). + // Operands that involve the counter need none: the guard bounds the + // counter so that each of them is a safe integer, which makes the index's + // double arithmetic exact. const shapes = new Map(); const affine = (e: IrExpr): Affine | null => { if (shapes.has(e)) return shapes.get(e)!; @@ -309,7 +333,7 @@ export function matchBytesLoopVersion( }; const termMagnitude = (terms: Term[]): number => terms.reduce((sum, t) => { - const r = facts.ranges.get(t.expr)!; + const r = termRange(t.expr); return sum + Math.max(Math.abs(r.min), Math.abs(r.max)); }, 0); @@ -433,7 +457,7 @@ export function matchBytesLoopVersion( let min = Math.min(a, b) + shape.offset, max = Math.max(a, b) + shape.offset; for (const term of shape.terms) { - const r = facts.ranges.get(term.expr)!; + const r = termRange(term.expr); min += term.sign > 0 ? r.min : -r.max; max += term.sign > 0 ? r.max : -r.min; } @@ -447,6 +471,12 @@ export function matchBytesLoopVersion( ranges.set(operand, { min: Math.max(min, known.min), max: Math.min(max, known.max) }); } } + // Guarded terms of the kept checks, and the range the guard proves for + // every node of each in the fast copy. + const guarded = new Set(); + for (const group of affineKept) + for (const term of group.check.terms) if (guardedRanges.has(term.expr)) guarded.add(term.key); + for (const [node, key] of guardedNodes) if (guarded.has(key)) ranges.set(node, GUARDED_TERM); // Renumber the receivers the kept checks use. const order = [...used].sort((a, b) => a - b); const renumber = new Map(order.map((old, index) => [old, index])); @@ -470,6 +500,7 @@ export function matchBytesLoopVersion( minOffset: g.check.minOffset, maxEnd: g.check.maxEnd, })), + guarded, counted: affineKept.length > 0 ? counted : null, counterBound: needsBound ? bound : null, ranges, @@ -567,6 +598,14 @@ export function emitBytesLoopVersionGuard( let base = "0"; for (const term of check.terms) { const value = host.emitExpr(term.expr); + if (version.guarded.has(term.key)) { + const tested = emitGuardedTerm(host, value.name); + conditions.push(tested.ok); + const sum = B.tmp(); + B.line(`${sum} = ${term.sign > 0 ? "add" : "sub"} i64 ${base}, ${tested.integer}`); + base = sum; + continue; + } const integer = exactInteger(host, value, term.expr); if (!integer) { // Unreachable: every term has a proven range. Stay checked. @@ -614,6 +653,34 @@ export function emitBytesLoopVersionGuard( else B.condBr(valid, fast, slow); } +/** Tests that a guarded term is an exact integer within GUARDED_TERM (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 emitGuardedTerm(host: LlvmEmitterContext, value: string): { 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(GUARDED_TERM.min)}`); + B.line(`${high} = fcmp ole double ${value}, ${f64Lit(GUARDED_TERM.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(); diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6997-typed-array-invariant-index-terms.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6997-typed-array-invariant-index-terms.ts.json new file mode 100644 index 000000000..6d60d2635 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6997-typed-array-invariant-index-terms.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6997-typed-array-invariant-index-terms.ts" + ], + "diags": [] +} diff --git a/tests/corpus/6997-typed-array-invariant-index-terms.ts b/tests/corpus/6997-typed-array-invariant-index-terms.ts new file mode 100644 index 000000000..53d9f10c0 --- /dev/null +++ b/tests/corpus/6997-typed-array-invariant-index-terms.ts @@ -0,0 +1,78 @@ +// Typed-array loops whose index adds a loop-invariant number with no known +// integer range, such as the row base of a matrix-vector product. Rows +// with integer, fractional, negative, -0 and NaN bases, windows at 2^32 and +// beyond, and matrices too short for their last rows, read and write as +// Node does. + +function matvec(w: Float32Array, v: Float32Array, out: Float32Array, cols: number): void { + for (let r = 0; r < out.length; r++) { + const base = r * cols; + let s0 = 0, s1 = 0, s2 = 0, s3 = 0; + for (let j = 0; j < cols; j += 4) { + s0 += w[base + j]! * v[j]!; + s1 += w[base + j + 1]! * v[j + 1]!; + s2 += w[base + j + 2]! * v[j + 2]!; + s3 += w[base + j + 3]! * v[j + 3]!; + } + out[r] = s0 + s1 + s2 + s3; + } +} + +function rowSums(m: Float64Array, rows: number, cols: number, first: number): number[] { + const sums: number[] = []; + for (let r = first; r < first + rows; r++) { + let s = 0; + for (let c = 0; c < cols; c++) s += m[r * cols + c]!; + sums.push(s); + } + return sums; +} + +function shiftedCopy(src: Int16Array, out: Int16Array, offset: number): void { + for (let i = 0; i < out.length; i++) out[i] = src[i - offset]! + 1; +} + +function window(src: Uint8Array, start: number, k: number): number { + let s = 0; + for (let i = 0; i < k; i++) s += src[start + i]! * (i + 1); + return s; +} + +const rows = 6, cols = 8; +const w = new Float32Array(rows * cols); +for (let i = 0; i < w.length; i++) w[i] = ((i * 37) % 23) / 4 - 2; +const v = new Float32Array(cols); +for (let i = 0; i < cols; i++) v[i] = (i % 5) - 1.5; +const out = new Float32Array(rows); +matvec(w, v, out, cols); +console.log("matvec", out.join(",")); +const tall = new Float32Array(rows + 2); +matvec(w, v, tall, cols); +console.log("matvec past rows", tall.join(",")); +const odd = new Float32Array(3); +matvec(w, v, odd, 6.5); +console.log("matvec fractional cols", odd.join(",")); +matvec(w, v, odd, NaN); +console.log("matvec NaN cols", odd.join(",")); + +const m = new Float64Array(30); +for (let i = 0; i < m.length; i++) m[i] = i * 1.5 - 7; +console.log("rows", rowSums(m, 5, 6, 0).join(",")); +console.log("rows from -1", rowSums(m, 3, 6, -1).join(",")); +console.log("rows fractional", rowSums(m, 2, 2.5, 1).join(",")); +console.log("rows past end", rowSums(m, 3, 6, 4).join(",")); +console.log("rows -0 base", rowSums(m, 1, 6, -0).join(",")); + +const src16 = new Int16Array([10, 20, 30, 40, 50, 60]); +const shifted = new Int16Array(6); +shiftedCopy(src16, shifted, 2); +console.log("shifted", shifted.join(",")); +shiftedCopy(src16, shifted, -3); +console.log("shifted back", shifted.join(",")); +shiftedCopy(src16, shifted, 0.5); +console.log("shifted half", shifted.join(",")); + +const bytes = new Uint8Array(40); +for (let i = 0; i < bytes.length; i++) bytes[i] = (i * 29) & 255; +console.log("window", window(bytes, 3, 8), window(bytes, 36, 8), window(bytes, -2, 4)); +console.log("window far", window(bytes, 2 ** 32, 3), window(bytes, 2 ** 32 + 1, 3), window(bytes, 2 ** 40, 2), window(bytes, -(2 ** 32), 2)); diff --git a/tests/harness/corpus-costs/6997-typed-array-invariant-index-terms.ts.json b/tests/harness/corpus-costs/6997-typed-array-invariant-index-terms.ts.json new file mode 100644 index 000000000..ed05a3c5d --- /dev/null +++ b/tests/harness/corpus-costs/6997-typed-array-invariant-index-terms.ts.json @@ -0,0 +1 @@ +{ "plain": 3400, "san": 4800 } From e4a9940e5b4d45170992c3094cd7888dbf064fdb Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 08:07:12 -0500 Subject: [PATCH 084/102] Finish bailed speculative iterations outside the ordinary loop copy A speculative integer loop's failed check used to continue at the failed statement inside the ordinary copy. That gave the ordinary copy a second entry, so LLVM saw an irreducible cycle and did not hoist its invariant loads or keep its values in registers. A loop whose check fails on every entry, such as an inner loop over fractional fields, then ran every iteration in that unoptimized copy. A failed check now continues in a third copy that is entered only from the fast copy: it re-executes the failed statement, the rest of the body and the update, then jumps to the ordinary copy's header. The ordinary copy has a single entry and stays a natural loop. Each loop site also counts its entries in a row whose fast copy bailed. A fast copy that completes a speculated write and leaves the loop clears the count, and after 8 bailing entries in a row the site runs the ordinary copy only. The count is a hint, read and written with unordered atomics: both copies give the same results. --- .../src/backend/llvm/emit-statements.ts | 100 ++++++++++++++-- packages/compiler/src/backend/llvm/emitter.ts | 11 ++ .../test/speculative-loop-emission.test.ts | 85 ++++++++++++++ .../7321-speculative-loop-bail-sites.ts.json | 6 + .../7321-speculative-loop-bail-sites.ts | 111 ++++++++++++++++++ .../7321-speculative-loop-bail-sites.ts.json | 1 + 6 files changed, 304 insertions(+), 10 deletions(-) create mode 100644 packages/compiler/test/speculative-loop-emission.test.ts create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7321-speculative-loop-bail-sites.ts.json create mode 100644 tests/corpus/7321-speculative-loop-bail-sites.ts create mode 100644 tests/harness/corpus-costs/7321-speculative-loop-bail-sites.ts.json diff --git a/packages/compiler/src/backend/llvm/emit-statements.ts b/packages/compiler/src/backend/llvm/emit-statements.ts index 7239db7d8..a22de3445 100644 --- a/packages/compiler/src/backend/llvm/emit-statements.ts +++ b/packages/compiler/src/backend/llvm/emit-statements.ts @@ -803,6 +803,7 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { const lp = workerBudget !== null ? B.newLabel("loop.p") : lc; B.br(lc); B.startBlock(lc); + enterLoopHeader(emitter, lc); B.condBr(emitter.emitCondition(s.cond), lb, exit); B.startBlock(lb); emitter.jumpTargets.push({ @@ -835,6 +836,7 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { const lc = B.newLabel("loop.c"); B.br(lb); B.startBlock(lb); + enterLoopHeader(emitter, lb); emitter.jumpTargets.push({ kind: "loop", brkLabel: exit, @@ -1135,6 +1137,7 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { s.update || capturedLets.length > 0 || workerBudget !== null ? B.newLabel("loop.u") : lc; B.br(lc); B.startBlock(lc); + enterLoopHeader(emitter, lc); if (integerLoop && integerSlot) { const receiver = emitter.emitStableReceiver(integerLoop.limitReceiver, []); const lenPtr = B.tmp(); @@ -1885,6 +1888,10 @@ export function emitSwitch(emitter: LlEmitter, s: IrStmt & { kind: "switch" }): B.startBlock(end); } +/** Entries in a row whose fast copy bailed before a speculative loop site + * stops trying it. */ +const SPECULATION_BAILS = 8; + /** Emit a loop's condition, body and update through `emitCopy`, twice * when speculative-integers.ts plans a fast integer copy. Both copies * share the loop's setup and exit; the ordinary copy comes first so the @@ -1939,23 +1946,66 @@ export function emitLoopCopies( ok = both; } } + // Each entry whose fast copy bails counts at the loop site, and a fast + // copy that completes a speculated write and leaves the loop clears the + // count. After SPECULATION_BAILS bailing entries in a row, the site runs + // the ordinary copy only. The count is a hint: both copies give the same + // results, and a race between workers loses at most an update. + const bails = `@scr.spec.bails.${emitter.speculativeLoopSites++}`; + emitter.declare(`${bails} = internal global i8 0`); + const count = B.tmp(), + trying = B.tmp(); + B.line(`${count} = load atomic i8, ptr ${bails} unordered, align 1`); + B.line(`${trying} = icmp ult i8 ${count}, ${SPECULATION_BAILS}`); + if (ok === "true") ok = trying; + else { + const both = B.tmp(); + B.line(`${both} = and i1 ${ok}, ${trying}`); + ok = both; + } const fast = B.newLabel("spec.fast"), slow = B.newLabel("spec.slow"); B.condBr(ok, fast, slow); const resume = new Map(); for (const s of plan.writes) resume.set(s, { label: B.newLabel("spec.resume"), placed: false }); + // A failed check finishes its iteration in a third copy, entered only + // there: it re-executes the statement and the rest of the body and the + // update, then enters the ordinary copy through its header. Jumping + // into the middle of the ordinary copy instead would give that loop a + // second entry, and LLVM does not optimize an irreducible loop. + const points = [...resume.values()]; + let header: string | null = null; B.startBlock(slow); + emitter.speculationHeader = (label) => { + header = label; + }; + try { + emitCopy(exit); + } finally { + emitter.speculationHeader = null; + } + if (header === null) + throw new InternalCompilerError("llvm emitter bug: speculative loop copy without a header"); + B.startBlock(B.newLabel("spec.tail")); emitter.speculationResume = resume; + emitter.speculationHeader = () => { + B.br(header!); + B.startBlock(B.newLabel("spec.unused")); + }; try { emitCopy(exit); } finally { emitter.speculationResume = null; + emitter.speculationHeader = null; } B.startBlock(fast); - if (![...resume.values()].every((r) => r.placed)) { + if (!points.every((r) => r.placed)) { B.br(slow); return; } + const ran = B.slot(); + B.entryAllocas.push(`${ran} = alloca i1 ; speculated write completed`); + B.line(`store i1 false, ptr ${ran}`); for (const id of plan.locals.keys()) { const shadow = B.slot(); B.entryAllocas.push( @@ -1992,22 +2042,43 @@ export function emitLoopCopies( writes: plan.writes, resume: new Map([...resume].map(([s, r]) => [s, r.label])), deferred, + bails, + ran, }; try { - if (deferred.size === 0) emitCopy(exit); - else { - const leave = B.newLabel("spec.leave"); - emitCopy(leave); - B.startBlock(leave); - emitter.writeBackDeferred(deferred); - B.br(exit); - } + const leave = B.newLabel("spec.leave"); + emitCopy(leave); + B.startBlock(leave); + emitter.writeBackDeferred(deferred); + // An entry that never ran a speculated write (a loop of no iterations) + // says nothing about the site. + const wrote = B.tmp(), + left = B.tmp(), + counted = B.tmp(), + both = B.tmp(), + clear = B.newLabel("spec.clear"); + B.line(`${wrote} = load i1, ptr ${ran}`); + B.line(`${left} = load atomic i8, ptr ${bails} unordered, align 1`); + B.line(`${counted} = icmp ne i8 ${left}, 0`); + B.line(`${both} = and i1 ${wrote}, ${counted}`); + B.condBr(both, clear, exit); + B.startBlock(clear); + B.line(`store atomic i8 0, ptr ${bails} unordered, align 1`); + B.br(exit); } finally { emitter.speculation = null; for (const id of plan.locals.keys()) emitter.integerLoopBindings.delete(id); } } +/** At the top of a loop copy's header: lets a speculative loop find its + * ordinary copy's header, and keeps its third copy out of the loop. */ +function enterLoopHeader(emitter: LlEmitter, header: string): void { + const dispatch = emitter.speculationHeader; + emitter.speculationHeader = null; + dispatch?.(header); +} + /** A proven integer loop (speculative-integers.ts) for this loop, or null. * A shadowed local's double is stale until the loop is left, which only * the loop's exit, a return and an exception do: the loop is planned only @@ -2134,7 +2205,8 @@ export function emitSpeculativeWrite( if (emitter.frames.pop()!.length > 0) throw new InternalCompilerError("llvm emitter bug: speculative write owns a temporary"); B.line(`store i64 ${result}, ptr ${binding.slot}`); - const deferred = emitter.speculation!.deferred; + const { deferred, bails: site, ran } = emitter.speculation!; + if (ran !== undefined) B.line(`store i1 true, ptr ${ran}`); if (!deferred.has(target.localId)) { const number = B.tmp(); B.line(`${number} = sitofp i64 ${result} to double`); @@ -2145,6 +2217,14 @@ export function emitSpeculativeWrite( B.br(done); B.startBlock(failed); emitter.writeBackDeferred(deferred); + if (site !== undefined) { + const count = B.tmp(), + next = B.tmp(); + emitter.declare("declare i8 @llvm.uadd.sat.i8(i8, i8)"); + B.line(`${count} = load atomic i8, ptr ${site} unordered, align 1`); + B.line(`${next} = call i8 @llvm.uadd.sat.i8(i8 ${count}, i8 1)`); + B.line(`store atomic i8 ${next}, ptr ${site} unordered, align 1`); + } B.br(resume!); B.startBlock(done); } diff --git a/packages/compiler/src/backend/llvm/emitter.ts b/packages/compiler/src/backend/llvm/emitter.ts index ed1785912..c1cf66af4 100644 --- a/packages/compiler/src/backend/llvm/emitter.ts +++ b/packages/compiler/src/backend/llvm/emitter.ts @@ -1102,9 +1102,20 @@ export class LlEmitter { resume: Map; /** Globals whose double is written back only when the copy is left. */ deferred: Set; + /** The loop site's count of bailing entries in a row (a global), and + * whether this entry completed a speculated write (a slot). A proven + * integer loop has neither. */ + bails?: string; + ran?: string; } | null = null; + /** Speculative loop sites numbered so far in the module. */ + speculativeLoopSites = 0; /** The ordinary copy being emitted: resume labels still to place. */ speculationResume: Map | null = null; + /** Run once at the top of the next loop copy's header + * (`enterLoopHeader`): records the ordinary copy's header, or sends the + * third copy's header there. */ + speculationHeader: ((header: string) => void) | null = null; /** The function being emitted, for speculative globals. */ speculativeFunction = ""; /** Every function that writes each number global (computed on demand). */ diff --git a/packages/compiler/test/speculative-loop-emission.test.ts b/packages/compiler/test/speculative-loop-emission.test.ts new file mode 100644 index 000000000..78a7de295 --- /dev/null +++ b/packages/compiler/test/speculative-loop-emission.test.ts @@ -0,0 +1,85 @@ +import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { expect, test } from "vitest"; +import { compile } from "../src/index.js"; + +async function emitLlvm(source: string): Promise { + const dir = await mkdtemp(join(tmpdir(), "scriptc-speculative-loop-")); + try { + const entry = join(dir, "main.ts"); + const outPath = join(dir, "main.ll"); + await writeFile(entry, source); + const result = await compile(entry, { outDir: dir, outPath, outputKind: "llvm" }); + expect(result.ok, JSON.stringify(result.diagnostics)).toBe(true); + return await readFile(outPath, "utf8"); + } finally { + await rm(dir, { recursive: true, force: true }); + } +} + +const source = ` +class Point { + x: number; + w = 0; + constructor(x: number) { + this.x = x; + } +} +function scaled(points: Point[], scale: number): number { + let s = 0; + for (let i = 0; i < points.length; i++) { + const p = points[i]!; + p.w += 1; + const k = p.x * scale; + s += k * k; + } + return s; +} +console.log(scaled([new Point(1), new Point(2)], 2), scaled([new Point(1)], 0.5)); +`; + +function labels(fn: string): string[] { + return [...fn.matchAll(/^([\w.]+):/gm)].map((m) => m[1]!); +} + +test("a failed check finishes its iteration outside the ordinary copy", async () => { + const llvm = await emitLlvm(source); + const fn = /^define internal double @sc_bf_scaled\([^]*?^}/m.exec(llvm)?.[0] ?? ""; + const order = labels(fn); + const slow = order.findIndex((l) => l.startsWith("spec.slow")); + const tail = order.findIndex((l) => l.startsWith("spec.tail")); + const fast = order.findIndex((l) => l.startsWith("spec.fast")); + expect(slow).toBeGreaterThanOrEqual(0); + expect(tail).toBeGreaterThan(slow); + expect(fast).toBeGreaterThan(tail); + // Every resume point is in the third copy, between its start and the + // fast copy, so the ordinary copy has one entry. + const resumes = order.flatMap((l, i) => (l.startsWith("spec.resume") ? [i] : [])); + expect(resumes.length).toBeGreaterThan(0); + for (const i of resumes) { + expect(i).toBeGreaterThan(tail); + expect(i).toBeLessThan(fast); + } + // The third copy's header leaves for the ordinary copy's header. + const header = order[slow + 1]!; + const third = fn.slice(fn.indexOf(`\n${order[tail]}:`), fn.indexOf(`\n${order[fast]}:`)); + expect(third).toContain(`br label %${header}`); +}); + +test("a loop site stops entering its fast copy after repeated bails", async () => { + const llvm = await emitLlvm(source); + const site = /^(@scr\.spec\.bails\.\d+) = internal global i8 0$/m.exec(llvm)?.[1]; + expect(site).toBeDefined(); + const fn = /^define internal double @sc_bf_scaled\([^]*?^}/m.exec(llvm)?.[0] ?? ""; + const escaped = site!.replace(/\./g, "\\."); + // The entry test reads the count, a bail adds one, and a completed fast + // copy clears it. + expect(fn).toMatch( + new RegExp( + `(%\\S+) = load atomic i8, ptr ${escaped} unordered, align 1\\n\\s*%\\S+ = icmp ult i8 \\1, 8`, + ), + ); + expect(fn).toMatch(new RegExp(`call i8 @llvm\\.uadd\\.sat\\.i8\\(i8 %\\S+, i8 1\\)`)); + expect(fn).toContain(`store atomic i8 0, ptr ${site} unordered, align 1`); +}); diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7321-speculative-loop-bail-sites.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7321-speculative-loop-bail-sites.ts.json new file mode 100644 index 000000000..113eeedb7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7321-speculative-loop-bail-sites.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7321-speculative-loop-bail-sites.ts" + ], + "diags": [] +} diff --git a/tests/corpus/7321-speculative-loop-bail-sites.ts b/tests/corpus/7321-speculative-loop-bail-sites.ts new file mode 100644 index 000000000..460595feb --- /dev/null +++ b/tests/corpus/7321-speculative-loop-bail-sites.ts @@ -0,0 +1,111 @@ +// Speculative integer loops whose checks fail: on the first statement of +// every entry (fractional field data), after an effect earlier in the same +// iteration, before a `continue`, `break` or `return`, and on entries +// that alternate between integer and fractional data. A site that keeps +// failing stops trying its integer copy; every result is Node's. + +class Point { + x: number; + y: number; + w = 0; + + constructor(x: number, y: number) { + this.x = x; + this.y = y; + } +} + +function show(label: string, value: number): void { + console.log(label, Object.is(value, -0) ? "-0" : String(value)); +} + +// Each inner entry fails at its first statement when the fields hold +// fractions, and runs no iteration at all for the last point. +function pairs(points: Point[]): number { + let total = 0; + for (let i = 0; i < points.length; i++) { + const p = points[i]!; + let acc = p.w; + for (let j = i + 1; j < points.length; j++) { + const q = points[j]!; + const dx = p.x - q.x; + const dy = p.y - q.y; + const d2 = dx * dx + dy * dy; + acc += d2; + q.w += d2 * 0.5; + } + p.w = acc; + total += acc; + } + return total; +} + +const fractional = [ + new Point(0.5, 1), + new Point(1.25, -2), + new Point(3, 4.75), + new Point(-1.5, 0), +]; +const integral = [new Point(0, 1), new Point(2, -2), new Point(3, 4), new Point(-1, 0)]; +for (let round = 0; round < 12; round++) { + show(`pairs fractional ${round}`, pairs(fractional)); +} +// The same site, now with integer data after it stopped speculating. +show("pairs integral", pairs(integral)); +show("pairs integral again", pairs(integral)); + +// A field write comes before the failing statement: the iteration resumes +// after it and must not repeat it. +function afterEffect(points: Point[], scale: number): number { + let s = 0; + for (let i = 0; i < points.length; i++) { + const p = points[i]!; + p.w += 1; + const k = p.x * scale; + s += k * k; + } + return s; +} +const marks = [new Point(1, 0), new Point(2, 0), new Point(3, 0)]; +show("after effect 2", afterEffect(marks, 2)); +show("after effect 0.5", afterEffect(marks, 0.5)); +show("after effect 3", afterEffect(marks, 3)); +console.log(marks.map((p) => p.w).join(" ")); + +// The failing statement is followed by `continue`, `break` and `return`. +function control(n: number, step: number): number { + let acc = 0; + let i = 0; + while (i < n) { + const v = i * step; + i++; + if (v * v > 400) break; + if ((i & 1) === 0) continue; + acc += v * 3; + if (acc > 1000) return -acc; + } + return acc; +} +for (const step of [1, 0.5, 2, 0.75, 7, 1.5, 3, 0.25, 5, 1.75, 4]) { + show(`control ${step}`, control(40, step)); +} + +// do-while: the check fails part-way through, on some entries only. +function steps(start: number, factor: number): number { + let v = start; + let k = 0; + do { + v = v * factor - k; + k++; + } while (k < 6); + return v; +} +for (let r = 0; r < 20; r++) show(`steps ${r}`, steps(r % 3 === 0 ? r + 0.5 : r, 3)); + +// Overflow past 2^53 on later entries only. +function powers(base: number, n: number): number { + let p = 1; + for (let i = 0; i < n; i++) p = p * base; + return p; +} +for (const n of [3, 10, 40, 80, 5, 60, 2, 70, 1, 90, 0, 4]) show(`powers ${n}`, powers(3, n)); diff --git a/tests/harness/corpus-costs/7321-speculative-loop-bail-sites.ts.json b/tests/harness/corpus-costs/7321-speculative-loop-bail-sites.ts.json new file mode 100644 index 000000000..1e5609a66 --- /dev/null +++ b/tests/harness/corpus-costs/7321-speculative-loop-bail-sites.ts.json @@ -0,0 +1 @@ +{ "plain": 2000, "san": 2600 } From fbb4fbc5b0c59c91bbb6f2e3fc15f97c7fa203dc Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 08:07:37 -0500 Subject: [PATCH 085/102] Encode posted records from their fields, and queue a message in one block postMessage of a typed record boxes it as a live record capsule, and the message encoder materialized the capsule's checked-dynamic view to read it: it built the view object, listed its own keys, tested each one for enumerability and read it back, then released the view and the key list. On an object-only run of bench/channel-messages that was about half of the encode time. - A live record capsule whose view was never created (no undeclared properties, no writes through an untyped view) now encodes from the record's field hooks (ScrDynTypedRecordOps), which answer exactly the view's keys, order and boxed values. Nested records encode the same way to a depth of 32, then through their views as before. Capsules with a view, published values, and every other value encode as before. - The mail event that carries a message lives in the message's block, so a queued message is one allocation instead of two. Corpus 7139 and 7360 post typed records on a MessageChannel and between a worker and the main thread: optional fields, nested records, a record reached twice, a chain deeper than the recursion limit, a parsed record with undeclared keys, and a function-valued field. --- .../corpus/7139-message-typed-records.ts.json | 6 ++ .../corpus/7360-worker-typed-records.ts.json | 6 ++ packages/runtime/src/scr_dyn.h | 3 + packages/runtime/src/scr_json.c | 4 ++ packages/runtime/src/scr_mailbox.c | 8 ++- packages/runtime/src/scr_mailbox.h | 5 ++ packages/runtime/src/scr_message.c | 53 +++++++++++++++++- packages/runtime/src/scr_worker.c | 5 +- tests/corpus/7139-message-typed-records.ts | 55 +++++++++++++++++++ tests/corpus/7360-worker-typed-records.ts | 37 +++++++++++++ .../7139-message-typed-records.ts.json | 1 + .../7360-worker-typed-records.ts.json | 1 + 12 files changed, 177 insertions(+), 7 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7139-message-typed-records.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7360-worker-typed-records.ts.json create mode 100644 tests/corpus/7139-message-typed-records.ts create mode 100644 tests/corpus/7360-worker-typed-records.ts create mode 100644 tests/harness/corpus-costs/7139-message-typed-records.ts.json create mode 100644 tests/harness/corpus-costs/7360-worker-typed-records.ts.json diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7139-message-typed-records.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7139-message-typed-records.ts.json new file mode 100644 index 000000000..5e50dcd13 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7139-message-typed-records.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7139-message-typed-records.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7360-worker-typed-records.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7360-worker-typed-records.ts.json new file mode 100644 index 000000000..4925143ad --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7360-worker-typed-records.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7360-worker-typed-records.ts" + ], + "diags": [] +} diff --git a/packages/runtime/src/scr_dyn.h b/packages/runtime/src/scr_dyn.h index 2602e0341..62987708a 100644 --- a/packages/runtime/src/scr_dyn.h +++ b/packages/runtime/src/scr_dyn.h @@ -364,6 +364,9 @@ typedef struct ScrDynTypedRecordOps { * for-in over a record with every field present (atomic slot). */ ScrArr *keys; } ScrDynTypedRecordOps; +/* A record capsule's ops while it answers from the native record (no view + * created yet), or NULL. */ +const ScrDynTypedRecordOps *scr_dyn_typed_ref_live_record(const ScrDyn *d); /* Prototype members of a compiled class seen as `unknown`, emitted per * class by the compiler: the string names of methods, getters and setters diff --git a/packages/runtime/src/scr_json.c b/packages/runtime/src/scr_json.c index 355a34aee..1c85a928a 100644 --- a/packages/runtime/src/scr_json.c +++ b/packages/runtime/src/scr_json.c @@ -3591,6 +3591,10 @@ static const ScrDynTypedRecordOps *scr_typed_ref_record_ops(const ScrDyn *d) { return (const ScrDynTypedRecordOps *)(const void *)d->v.typed_ref.array; } +const ScrDynTypedRecordOps *scr_dyn_typed_ref_live_record(const ScrDyn *d) { + return d->kind == SCR_DYN_TYPED_REF ? scr_typed_ref_record_ops(d) : NULL; +} + static bool scr_typed_ref_record_field(const ScrDynTypedRecordOps *ops, const ScrStr *key, size_t *out) { /* Compiled reads pass the interned literal the field names also use. */ diff --git a/packages/runtime/src/scr_mailbox.c b/packages/runtime/src/scr_mailbox.c index a8dc7e5cc..b2af22774 100644 --- a/packages/runtime/src/scr_mailbox.c +++ b/packages/runtime/src/scr_mailbox.c @@ -140,9 +140,11 @@ ScrMailbox *scr_mailbox_retain(ScrMailbox *mailbox) { void scr_mail_event_free(ScrMailEvent *event) { if (!event) return; - scr_message_free(event->message); free(event->data); - free(event); + ScrMessage *message = event->message; + /* An event in its message's block goes with the message. */ + if (!event->in_message) free(event); + scr_message_free(message); } void scr_mailbox_release(ScrMailbox *mailbox) { @@ -460,7 +462,7 @@ void scr_channel_set_owner(ScrChannel *channel, int side, ScrMailbox *owner, uns * messages as ready, so it does not wait while the queue is non-empty. */ bool scr_channel_post(ScrChannel *channel, int side, ScrMessage *message, unsigned message_kind, unsigned wake_kind) { - ScrMailEvent *event = calloc(1, sizeof(*event)); + ScrMailEvent *event = message ? scr_message_mail_event(message) : calloc(1, sizeof(*event)); if (!event) scr_trap("scriptc: out of memory\n"); event->kind = message_kind; event->message = message; diff --git a/packages/runtime/src/scr_mailbox.h b/packages/runtime/src/scr_mailbox.h index 4e5f253b5..a4acfccd0 100644 --- a/packages/runtime/src/scr_mailbox.h +++ b/packages/runtime/src/scr_mailbox.h @@ -12,8 +12,13 @@ typedef struct ScrMailEvent { unsigned char *data; /* raw bytes (a worker's captured stdout or stderr), owned */ size_t length; struct ScrMailEvent *next; + bool in_message; /* the event is the one message's block holds (scr_message_mail_event) */ } ScrMailEvent; +/* The event that carries `message`, in the message's own block: a queued + * message is then one allocation. Freeing the event frees the message. */ +ScrMailEvent *scr_message_mail_event(ScrMessage *message); + ScrMailbox *scr_mailbox_new(void); ScrMailbox *scr_mailbox_retain(ScrMailbox *mailbox); void scr_mailbox_release(ScrMailbox *mailbox); diff --git a/packages/runtime/src/scr_message.c b/packages/runtime/src/scr_message.c index 508266103..29cbb1be0 100644 --- a/packages/runtime/src/scr_message.c +++ b/packages/runtime/src/scr_message.c @@ -1,4 +1,5 @@ #include "scr_message.h" +#include "scr_mailbox.h" #include #include @@ -72,6 +73,7 @@ struct ScrMessage { bool storage; /* has STORAGE nodes */ bool releases; /* has STORAGE, PORT or HANDLE nodes, which own resources */ bool readable; /* see scr_message_readable */ + ScrMailEvent event; /* the event that carries the message (scr_message_mail_event) */ }; typedef struct { @@ -98,6 +100,10 @@ typedef struct { * and properties allocates only its block. */ #define SCR_MESSAGE_INLINE 8 +/* How deep live records nest before the rest of a graph encodes through + * the visit stack (scr_message_value recurses for them). */ +#define SCR_MESSAGE_RECORD_DEPTH 32 + typedef struct { ScrMessageNode *nodes; ScrMessageVisit *visits; @@ -121,6 +127,7 @@ typedef struct { bool storage; bool releases; bool shared; /* a node was reached twice */ + size_t record_depth; /* live records being encoded from their fields */ bool adopts; /* has PORT or HANDLE nodes */ ScrMessageNode inline_nodes[SCR_MESSAGE_INLINE]; ScrMessageVisit inline_visits[SCR_MESSAGE_INLINE]; @@ -148,6 +155,7 @@ static void scr_message_encoder_init(ScrMessageEncoder *encoder, const ScrDyn *t encoder->transfer = transfer; encoder->uncaught = uncaught; encoder->storage = encoder->releases = encoder->shared = encoder->adopts = false; + encoder->record_depth = 0; } static bool scr_message_listed(const ScrMessageEncoder *encoder, const ScrDyn *value) { @@ -321,6 +329,9 @@ static ScrDyn *scr_message_uncaught_keys(const ScrDyn *view) { return keys; } +static void scr_message_property(ScrMessageEncoder *encoder, size_t id, + const ScrStr *key, size_t value, bool hidden); + static size_t scr_message_value(ScrMessageEncoder *encoder, const ScrDyn *input) { bool uncaught = encoder->uncaught; encoder->uncaught = false; @@ -382,6 +393,39 @@ static size_t scr_message_value(ScrMessageEncoder *encoder, const ScrDyn *input) node->v.published = (ScrDyn *)input; return id; } + /* A live record capsule (scr_dyn_typed_ref_bind_record) whose view was + * never created encodes its fields from the record: the view would hold + * exactly those keys, in that order, with the values its ops box. Nested + * records encode the same way up to a depth, then through their views + * and the visit stack. */ + const ScrDynTypedRecordOps *record = + input->kind == SCR_DYN_TYPED_REF && encoder->record_depth < SCR_MESSAGE_RECORD_DEPTH + ? scr_dyn_typed_ref_live_record(input) : NULL; + if (record) { + encoder->visits[id].view = (ScrDyn *)input; + encoder->nodes[id].kind = SCR_MESSAGE_OBJECT; + void *rec = input->v.typed_ref.ptr; + encoder->record_depth++; + size_t result = id; + for (size_t i = 0; i < record->count; i++) { + if (!record->fixed && !record->has(rec, i)) continue; + ScrDyn *child = record->get(rec, i); + if (!child || scr_exc_pending()) { + scr_dyn_release(child); + result = SIZE_MAX; + break; + } + size_t next = scr_message_value(encoder, child); + scr_dyn_release(child); + if (next == SIZE_MAX) { + result = SIZE_MAX; + break; + } + scr_message_property(encoder, id, record->names[i], next, false); + } + encoder->record_depth--; + return result; + } ScrDyn *value = input->kind == SCR_DYN_TYPED_REF ? scr_dyn_typed_ref_materialize(input) : (ScrDyn *)input; encoder->visits[id].view = value; @@ -756,8 +800,8 @@ static ScrMessage *scr_message_pack(ScrMessageEncoder *encoder) { ScrMessageProperty *slots = (ScrMessageProperty *)(nodes + count); ScrMessageTyped *records = (ScrMessageTyped *)(slots + properties); char *text = (char *)(records + typed); - *message = (ScrMessage){nodes, count, encoder->storage, encoder->releases, - !encoder->shared && !encoder->adopts}; + *message = (ScrMessage){.nodes = nodes, .count = count, .storage = encoder->storage, + .releases = encoder->releases, .readable = !encoder->shared && !encoder->adopts}; memcpy(nodes, encoder->nodes, count * sizeof(*nodes)); if (typed) memcpy(records, encoder->typed, typed * sizeof(*records)); size_t first = 0; @@ -1003,6 +1047,11 @@ done:; bool scr_message_readable(const ScrMessage *message) { return message->readable; } +ScrMailEvent *scr_message_mail_event(ScrMessage *message) { + message->event = (ScrMailEvent){.message = message, .in_message = true}; + return &message->event; +} + int32_t scr_message_kind(const ScrMessage *message, size_t node) { return message->nodes[node].kind; } double scr_message_number(const ScrMessage *message, size_t node) { return message->nodes[node].v.number; } diff --git a/packages/runtime/src/scr_worker.c b/packages/runtime/src/scr_worker.c index 67f4ec084..59e245ea0 100644 --- a/packages/runtime/src/scr_worker.c +++ b/packages/runtime/src/scr_worker.c @@ -99,9 +99,10 @@ static bool scr_worker_stats(void) { static ScrMailEvent *scr_worker_event(unsigned kind, uint64_t source, int code, ScrMessage *message) { - ScrMailEvent *event = calloc(1, sizeof(*event)); + ScrMailEvent *event = message ? scr_message_mail_event(message) : calloc(1, sizeof(*event)); if (!event) scr_trap("scriptc: out of memory\n"); - *event = (ScrMailEvent){.kind = kind, .source = source, .code = code, .message = message}; + *event = (ScrMailEvent){ + .kind = kind, .source = source, .code = code, .message = message, .in_message = message != NULL}; return event; } diff --git a/tests/corpus/7139-message-typed-records.ts b/tests/corpus/7139-message-typed-records.ts new file mode 100644 index 000000000..678b9cc48 --- /dev/null +++ b/tests/corpus/7139-message-typed-records.ts @@ -0,0 +1,55 @@ +import { MessageChannel } from "node:worker_threads"; + +// Typed records posted on a MessageChannel arrive as plain objects with +// the same keys, order and values as in Node: optional fields present and +// absent, nested records, a record reached twice, a record nested deeper +// than the encoder recurses, a record parsed with undeclared keys, and a +// function-valued field, which postMessage rejects. +type Point = { x: number; y: number }; +type Item = { id: number; name: string; done: boolean; pos: Point; note?: string }; +type Pair = { left: Point; right: Point }; +type Link = { value: number; next?: Link }; + +const { port1, port2 } = new MessageChannel(); +const lines: string[] = []; +const expected = 7; +port1.on("message", (value: unknown) => { + let checks = ""; + if (!Array.isArray(value)) { + const object = value as Record; + if ("left" in object) checks += ` same ${object["left"] === object["right"]}`; + const pos = object["pos"] as Record | undefined; + if (pos !== undefined) checks += ` negative zero ${Object.is(pos["x"], -0)}`; + } + lines.push(JSON.stringify(value) + checks); + if (lines.length === expected) { + for (const line of lines) console.log(line); + port1.close(); + } +}); + +const item: Item = { id: 1, name: "first", done: false, pos: { x: 1, y: 2 } }; +port2.postMessage(item); +const noted: Item = { id: 2, name: "", done: true, pos: { x: -0, y: 0.5 }, note: "n" }; +port2.postMessage(noted); + +const shared: Point = { x: 3, y: 4 }; +const pair: Pair = { left: shared, right: shared }; +port2.postMessage(pair); + +let chain: Link = { value: 0 }; +for (let i = 1; i < 40; i++) chain = { value: i, next: chain }; +port2.postMessage(chain); + +const parsed = JSON.parse('{"y":6,"extra":true,"x":5}') as Point; +port2.postMessage(parsed); +port2.postMessage({ x: 7, y: 8 } as Point); +port2.postMessage([item.pos, noted.pos]); + +type WithFunction = { id: number; run: () => number }; +const bad: WithFunction = { id: 9, run: () => 1 }; +try { + port2.postMessage(bad); +} catch (error) { + console.log("rejected", (error as Error).name); +} diff --git a/tests/corpus/7360-worker-typed-records.ts b/tests/corpus/7360-worker-typed-records.ts new file mode 100644 index 000000000..6749398f3 --- /dev/null +++ b/tests/corpus/7360-worker-typed-records.ts @@ -0,0 +1,37 @@ +import { Worker, isMainThread, parentPort, workerData } from "node:worker_threads"; + +// Typed records posted to a worker and back keep their keys, order and +// values, as in Node: records with optional fields, nested records and a +// record in workerData. +type Point = { x: number; y: number }; +type Job = { id: number; label: string; urgent: boolean; at: Point; note?: string }; +type Reply = { id: number; sum: number; label: string }; + +if (isMainThread) { + const start: Point = { x: 10, y: 20 }; + const worker = new Worker(new URL(import.meta.url), { workerData: start }); + const replies: string[] = []; + worker.on("message", (reply: Reply) => { + replies.push(`${JSON.stringify(reply)} ${Object.keys(reply).join(",")}`); + if (replies.length === 3) { + for (const line of replies) console.log(line); + void worker.terminate(); + } + }); + const jobs: Job[] = [ + { id: 1, label: "a", urgent: false, at: { x: 1, y: 2 } }, + { id: 2, label: "b", urgent: true, at: { x: 3, y: 4 }, note: "n" }, + { id: 3, label: "", urgent: false, at: { x: -1, y: 0.25 } }, + ]; + for (const job of jobs) worker.postMessage(job); +} else { + const origin = workerData as Point; + parentPort!.on("message", (job: Job) => { + const reply: Reply = { + id: job.id, + sum: job.at.x + job.at.y + origin.x + origin.y, + label: `${job.label}${job.urgent ? "!" : ""}${job.note ?? ""}`, + }; + parentPort!.postMessage(reply); + }); +} diff --git a/tests/harness/corpus-costs/7139-message-typed-records.ts.json b/tests/harness/corpus-costs/7139-message-typed-records.ts.json new file mode 100644 index 000000000..f0ed6cbc2 --- /dev/null +++ b/tests/harness/corpus-costs/7139-message-typed-records.ts.json @@ -0,0 +1 @@ +{ "plain": 4300, "san": 4400 } diff --git a/tests/harness/corpus-costs/7360-worker-typed-records.ts.json b/tests/harness/corpus-costs/7360-worker-typed-records.ts.json new file mode 100644 index 000000000..cf0403d1d --- /dev/null +++ b/tests/harness/corpus-costs/7360-worker-typed-records.ts.json @@ -0,0 +1 @@ +{ "plain": 2700, "san": 2900 } From d406f633bdb2d609e8c9a85a107ff275fe46bf28 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 08:18:18 -0500 Subject: [PATCH 086/102] Keep the receiver index within what the native frontend lowers The receiver index read its methods or members table by a computed key and iterated generic method names through `?.keys() ?? []`. The native frontend refuses dynamic keyed reads of records and cannot convert the iterator-or-array union, so the complete frontend no longer lowered. The table is now selected with a conditional and the generic method names are iterated under a check. --- .../frontend/lowering/class-dynamic-dispatch.ts | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts b/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts index 79edae433..79deb2aeb 100644 --- a/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts +++ b/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts @@ -510,10 +510,11 @@ function receiverIndex(lowerer: Lowerer, plans: readonly PropertyReceiver[]): Re position, ); } - for (const name of c.genericMethods?.keys() ?? []) { - add(methods, name, position); - add(members, name, position); - } + if (c.genericMethods) + for (const name of c.genericMethods.keys()) { + add(methods, name, position); + add(members, name, position); + } } for (const name of info.fields.keys()) add(members, name, position); }); @@ -1430,9 +1431,8 @@ export class ClassDynamicDispatch { ): readonly PropertyReceiver[] => { if (name.startsWith("emit:")) return plans; const found = indexOf(plans); - return mergePositions(found[table].get(name) ?? [], found.rooted).map( - (position) => plans[position]!, - ); + const positions = (table === "methods" ? found.methods : found.members).get(name); + return mergePositions(positions ?? [], found.rooted).map((position) => plans[position]!); }; const candidates = (method: string): ClassInfo[] => { const found = byMethod.get(method); From 2f3e25b431fc13f0f8a08fdb0505b0c277dc734a Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 08:35:56 -0500 Subject: [PATCH 087/102] Accept Buffer-compatible chunk annotations and keep super(undefined) in byte mode --- .../src/frontend/lowering/lower-stream.ts | 18 ++++++---- tests/corpus/7240-objectmode-streams.ts | 33 ++++++++++++++++- .../stream-byte-mode-chunk-fences.ts | 36 +++++++++++++++++++ .../stream-byte-mode-chunk-fences.ts.txt | 8 +++++ 4 files changed, 87 insertions(+), 8 deletions(-) create mode 100644 tests/diagnostics/stream-byte-mode-chunk-fences.ts create mode 100644 tests/harness/__snapshots__/stream-byte-mode-chunk-fences.ts.txt diff --git a/packages/compiler/src/frontend/lowering/lower-stream.ts b/packages/compiler/src/frontend/lowering/lower-stream.ts index cb81348eb..6540b3a99 100644 --- a/packages/compiler/src/frontend/lowering/lower-stream.ts +++ b/packages/compiler/src/frontend/lowering/lower-stream.ts @@ -312,11 +312,13 @@ function lowerStreamCallback( // A write or transform chunk of another type converts from the // chunk's value when the callback runs (an object-mode side's value), // or throws a TypeError there — on a side known to be byte mode the - // chunk is a Buffer, so the declared type is the fence's; an encoding - // of another type (`string | null | undefined`) converts from the - // encoding argument's value. + // chunk is a Buffer, so the declared type must be Node's or a + // supertype of it (`Buffer | string`); an encoding of another type + // (`string | null | undefined`) converts from the encoding argument's + // value. if ( - ((i === 0 && chunkValues) || i === 1) && + ((i === 0 && (chunkValues || widensInto(lowerer, fullTuple[0]!, funcType.params[0]!, loc))) || + i === 1) && (which === "write" || which === "transform") && funcType.params[i]!.kind !== "func" && canConvertToDyn( @@ -1369,11 +1371,13 @@ export function lowerStreamSuperCall( // set objectMode, and a literal says so with objectMode (or a Duplex's // writableObjectMode) true; otherwise _write and _transform receive // Buffers. + // super(undefined) and super(null) pass no options (followOptionsArg + // answers null), so their sides are byte mode too. const optsNode = argNodes[0] !== undefined ? followOptionsArg(lowerer, argNodes[0]) : null; const chunkValues = - argNodes[0] !== undefined && - (optsNode === null || - !ts.isObjectLiteralExpression(optsNode) || + optsNode !== null && + optsNode !== undefined && + (!ts.isObjectLiteralExpression(optsNode) || literalWritesValues(optsNode, cls !== "%Readable" && cls !== "%Writable")); const fallback = (name: string): IrExpr | null => { const methodName = UNDERSCORE_METHODS.get(name); diff --git a/tests/corpus/7240-objectmode-streams.ts b/tests/corpus/7240-objectmode-streams.ts index 9316ff480..47f799eee 100644 --- a/tests/corpus/7240-objectmode-streams.ts +++ b/tests/corpus/7240-objectmode-streams.ts @@ -2,7 +2,8 @@ // and Writable in pipeline(), typed 'data' listeners, a Transform with // readableObjectMode parsing bytes into records, an object-mode Duplex, // a PassThrough's object-counted high-water mark, and Readable.from over -// a Map, a Set of records and an array mixing strings and Buffers. +// a Map, a Set of records and an array mixing strings and Buffers, and +// byte-mode chunk parameters typed Buffer | string. import { Duplex, PassThrough, Readable, Transform, Writable } from "node:stream"; import { pipeline } from "node:stream/promises"; @@ -119,6 +120,34 @@ async function collections(): Promise { for await (const t of Readable.from(tags)) console.log("set", JSON.stringify(t)); } +// Byte-mode sides pass Buffers: a chunk parameter typed as a supertype +// of Buffer takes them, inline and as an underscore method, and +// super(undefined) leaves the stream in byte mode. +class Collector extends Writable { + constructor() { + super(undefined); + } + _write(chunk: Buffer | string, _encoding: BufferEncoding, cb: (err?: Error | null) => void): void { + console.log("collector", Buffer.isBuffer(chunk), typeof chunk === "string" ? chunk : chunk.toString()); + cb(); + } +} + +async function byteChunks(): Promise { + const inline = new Writable({ + write(chunk: Buffer | string, _encoding: BufferEncoding, cb: (err?: Error | null) => void): void { + console.log("inline", Buffer.isBuffer(chunk), typeof chunk === "string" ? chunk : chunk.toString()); + cb(); + }, + }); + inline.write("one"); + inline.end(Buffer.from("two")); + await new Promise((resolve) => inline.on("finish", () => resolve())); + const collector = new Collector(); + collector.end("three"); + await new Promise((resolve) => collector.on("finish", () => resolve())); +} + async function main(): Promise { await records(); await collections(); @@ -126,5 +155,7 @@ async function main(): Promise { sided(); duplex(); passthrough(); + await new Promise((resolve) => setTimeout(resolve, 5)); + await byteChunks(); } main(); diff --git a/tests/diagnostics/stream-byte-mode-chunk-fences.ts b/tests/diagnostics/stream-byte-mode-chunk-fences.ts new file mode 100644 index 000000000..6afd1d794 --- /dev/null +++ b/tests/diagnostics/stream-byte-mode-chunk-fences.ts @@ -0,0 +1,36 @@ +// A byte-mode stream's write chunks are Buffers: an underscore method +// whose chunk parameter has another type is fenced, and super(undefined) +// passes no options, so the stream is in byte mode. A parameter that +// admits the Buffer (Buffer | string) is not fenced, inline or as a +// method. +import { Writable } from "node:stream"; + +class Numbers extends Writable { + constructor() { + super(undefined); + } + _write(chunk: number, _encoding: BufferEncoding, cb: (err?: Error | null) => void): void { + console.log(chunk); + cb(); + } +} +new Numbers().end("x"); + +const accepted = new Writable({ + write(chunk: Buffer | string, _encoding: BufferEncoding, cb: (err?: Error | null) => void): void { + console.log(typeof chunk === "string" ? chunk : chunk.toString()); + cb(); + }, +}); +accepted.end("z"); + +class Wide extends Writable { + constructor() { + super(undefined); + } + _write(chunk: Buffer | string, _encoding: BufferEncoding, cb: (err?: Error | null) => void): void { + console.log(typeof chunk === "string" ? chunk : chunk.toString()); + cb(); + } +} +new Wide().end("w"); diff --git a/tests/harness/__snapshots__/stream-byte-mode-chunk-fences.ts.txt b/tests/harness/__snapshots__/stream-byte-mode-chunk-fences.ts.txt new file mode 100644 index 000000000..39a06dfd7 --- /dev/null +++ b/tests/harness/__snapshots__/stream-byte-mode-chunk-fences.ts.txt @@ -0,0 +1,8 @@ +stream-byte-mode-chunk-fences.ts:10:5 - error SC2020: 'a '_write' method whose parameter 0 is 'number' where Node passes 'Uint8Array'' is part of the standard library types but has no scriptc lowering yet + + 9 | constructor() { + 10 | super(undefined); + | ^~~~~~~~~~~~~~~~ + 11 | } + + hint: annotate the parameter with the Node signature's type or a supertype of it (chunks are Buffers here) \ No newline at end of file From 6e75e59f753e9dd25ba5b915220f036d2421bc10 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 08:52:18 -0500 Subject: [PATCH 088/102] Check each speculative site of a loop in the third-copy emission test Since dense-array loops bounded by an invariant limit are versioned, the test's loop has a speculative site in each dense copy. The test paired every resume point with the first site's labels; it now checks each site's resume points against that site's third and fast copies. --- .../test/speculative-loop-emission.test.ts | 43 +++++++++++-------- 1 file changed, 26 insertions(+), 17 deletions(-) diff --git a/packages/compiler/test/speculative-loop-emission.test.ts b/packages/compiler/test/speculative-loop-emission.test.ts index 78a7de295..a691d856d 100644 --- a/packages/compiler/test/speculative-loop-emission.test.ts +++ b/packages/compiler/test/speculative-loop-emission.test.ts @@ -47,24 +47,33 @@ test("a failed check finishes its iteration outside the ordinary copy", async () const llvm = await emitLlvm(source); const fn = /^define internal double @sc_bf_scaled\([^]*?^}/m.exec(llvm)?.[0] ?? ""; const order = labels(fn); - const slow = order.findIndex((l) => l.startsWith("spec.slow")); - const tail = order.findIndex((l) => l.startsWith("spec.tail")); - const fast = order.findIndex((l) => l.startsWith("spec.fast")); - expect(slow).toBeGreaterThanOrEqual(0); - expect(tail).toBeGreaterThan(slow); - expect(fast).toBeGreaterThan(tail); - // Every resume point is in the third copy, between its start and the - // fast copy, so the ordinary copy has one entry. - const resumes = order.flatMap((l, i) => (l.startsWith("spec.resume") ? [i] : [])); - expect(resumes.length).toBeGreaterThan(0); - for (const i of resumes) { - expect(i).toBeGreaterThan(tail); - expect(i).toBeLessThan(fast); + // The loop may have several speculative sites (one in each copy of a + // dense-array loop). Each site emits its ordinary copy, its third copy + // and its fast copy in that order. + const slows = order.flatMap((l, i) => (l.startsWith("spec.slow") ? [i] : [])); + expect(slows.length).toBeGreaterThan(0); + let resumes = 0; + for (const slow of slows) { + const next = (prefix: string): number => + order.findIndex((l, i) => i > slow && l.startsWith(prefix)); + const tail = next("spec.tail"); + const fast = next("spec.fast"); + expect(tail).toBeGreaterThan(slow); + expect(fast).toBeGreaterThan(tail); + // Every resume point of the site is in its third copy, between that + // copy's start and the fast copy, so the ordinary copy has one entry. + for (let i = slow + 1; i < fast; i++) { + if (!order[i]!.startsWith("spec.resume")) continue; + expect(i).toBeGreaterThan(tail); + resumes++; + } + // The third copy's header leaves for the ordinary copy's header. + const header = order[slow + 1]!; + const third = fn.slice(fn.indexOf(`\n${order[tail]}:`), fn.indexOf(`\n${order[fast]}:`)); + expect(third).toContain(`br label %${header}`); } - // The third copy's header leaves for the ordinary copy's header. - const header = order[slow + 1]!; - const third = fn.slice(fn.indexOf(`\n${order[tail]}:`), fn.indexOf(`\n${order[fast]}:`)); - expect(third).toContain(`br label %${header}`); + expect(resumes).toBe(order.filter((l) => l.startsWith("spec.resume")).length); + expect(resumes).toBeGreaterThan(0); }); test("a loop site stops entering its fast copy after repeated bails", async () => { From 142e10a0c428065a37eac0228b3a2b83fef5694f Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 08:55:08 -0500 Subject: [PATCH 089/102] Run counters that step beside a counted loop's counter as integers `for (let i = 0, p = 0; i < count; i++, p += 4)` kept both counters as doubles: the counted-loop match takes a single declaration and a single update. A counted loop now also accepts further counters declared in its head and stepped by a constant in its update, when the condition does not read them and the body does not write them. On body entry k such a counter holds `start + step * k`, so its range follows from the driver's: k is at most the driver's span over its step. When that range can pass 2^53, the versioned loop tests `|start| + |step| * span / |driver step| <= 2^52` at run time, and an unproven start is tested for an exact safe integer, as the driver's is. Nested update blocks (`i++, j += 2, k--`) are flattened. Byte windows and dense loops still take only single-counter loops. --- .../src/backend/llvm/counted-loops.ts | 45 ++++- .../backend/llvm/dense-array-loops.test.ts | 1 + .../src/backend/llvm/emit-statements.ts | 36 +++- .../compiler/src/ir/integer-loops.test.ts | 100 ++++++++++ packages/compiler/src/ir/integer-loops.ts | 188 +++++++++++++----- .../7141-comoving-loop-counters.ts.json | 6 + tests/corpus/7141-comoving-loop-counters.ts | 144 ++++++++++++++ .../7141-comoving-loop-counters.ts.json | 1 + 8 files changed, 467 insertions(+), 54 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7141-comoving-loop-counters.ts.json create mode 100644 tests/corpus/7141-comoving-loop-counters.ts create mode 100644 tests/harness/corpus-costs/7141-comoving-loop-counters.ts.json diff --git a/packages/compiler/src/backend/llvm/counted-loops.ts b/packages/compiler/src/backend/llvm/counted-loops.ts index 02943b852..ca2dd6b92 100644 --- a/packages/compiler/src/backend/llvm/counted-loops.ts +++ b/packages/compiler/src/backend/llvm/counted-loops.ts @@ -1,4 +1,9 @@ -import type { IntegerCountedForLoop, IntegerPairedForLoop } from "../../ir/integer-loops.js"; +import type { + IntegerCountedForLoop, + IntegerLoopFollower, + IntegerPairedForLoop, +} from "../../ir/integer-loops.js"; +import { FOLLOWER_GUARD_LIMIT } from "../../ir/integer-loops.js"; import type { IrExpr } from "../../ir/ir.js"; import type { LlvmEmitterContext } from "./expr-context.js"; import { f64Lit } from "./common.js"; @@ -61,9 +66,47 @@ export function emitCountedLoopSafety( ); } if (loop.startGuarded) safe = andSafe(host, safe, emitExactStart(host, loop.start)); + for (const follower of loop.followers) { + if (follower.startGuarded) safe = andSafe(host, safe, emitExactStart(host, follower.start)); + if (follower.tripGuarded) safe = andSafe(host, safe, emitFollowerReach(host, loop, follower)); + } return safe; } +/** `|start| + |step| * span / |driver step| <= 2^52` for a follower, where + * `span` is the distance from the driver's start to the limit. The body runs + * at most `span / |driver step| + 1` times, so every value the follower holds + * on a body entry is within the bound. NaN and infinities fail the ordered + * test. */ +function emitFollowerReach( + host: LlvmEmitterContext, + loop: IntegerCountedForLoop, + follower: IntegerLoopFollower, +): string { + const B = host.B; + const start = host.emitExpr(loop.start), + limit = host.emitExpr(loop.limit), + from = host.emitExpr(follower.start); + const span = B.tmp(), + reach = B.tmp(), + magnitude = B.tmp(), + total = B.tmp(), + ok = B.tmp(); + B.line( + loop.step > 0 + ? `${span} = fsub double ${limit.name}, ${start.name}` + : `${span} = fsub double ${start.name}, ${limit.name}`, + ); + B.line( + `${reach} = fmul double ${span}, ${f64Lit(Math.abs(follower.step) / Math.abs(loop.step))}`, + ); + host.declare(`declare double @llvm.fabs.f64(double)`); + B.line(`${magnitude} = call double @llvm.fabs.f64(double ${from.name})`); + B.line(`${total} = fadd double ${magnitude}, ${reach}`); + B.line(`${ok} = fcmp ole double ${total}, ${f64Lit(FOLLOWER_GUARD_LIMIT)}`); + return ok; +} + /** The run-time test of a guarded paired loop: each unproven start is an * exact safe integer. */ export function emitPairedLoopSafety(host: LlvmEmitterContext, loop: IntegerPairedForLoop): string { diff --git a/packages/compiler/src/backend/llvm/dense-array-loops.test.ts b/packages/compiler/src/backend/llvm/dense-array-loops.test.ts index 32c9cccab..f7a4bc892 100644 --- a/packages/compiler/src/backend/llvm/dense-array-loops.test.ts +++ b/packages/compiler/src/backend/llvm/dense-array-loops.test.ts @@ -120,6 +120,7 @@ const counted = ( limitGuarded: false, startGuarded: false, guardLimit: 0, + followers: [], ...fields, }); diff --git a/packages/compiler/src/backend/llvm/emit-statements.ts b/packages/compiler/src/backend/llvm/emit-statements.ts index 7239db7d8..c493f6c9c 100644 --- a/packages/compiler/src/backend/llvm/emit-statements.ts +++ b/packages/compiler/src/backend/llvm/emit-statements.ts @@ -879,8 +879,9 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { !integerLoop && !countedLoop && emitter.countedLoopsEnabled ? matchIntegerPairedForLoop(s, emitter.numericLocals, emitter.integerRanges) : null; + // Byte windows and dense loops reason about one counter. const window = - countedLoop && emitter.byteWindowsEnabled + countedLoop && countedLoop.followers.length === 0 && emitter.byteWindowsEnabled ? matchByteWindow( s, countedLoop, @@ -898,7 +899,7 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { length: integerArrayLoop.limitReceiver as IrExpr & { kind: "varRef" }, range: { min: 0, max: 4294967294 }, } - : countedLoop && !countedLoop.guarded + : countedLoop && !countedLoop.guarded && countedLoop.followers.length === 0 ? countedDenseShape(s, countedLoop) : null; const dense = @@ -1030,6 +1031,7 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { let integerSlot: string | null = null; let countedLimit: string | null = null; const pairedSlots: string[] = []; + const followerSlots: string[] = []; if (integerLoop) { integerSlot = B.slot(); B.entryAllocas.push( @@ -1073,6 +1075,23 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { ? emitter.denseLoop.range : countedLoop.range, }); + for (const follower of countedLoop.followers) { + const slot = B.slot(); + B.entryAllocas.push( + `${slot} = alloca i64 ; integer induction ${emitter.currentLocals.get(follower.localId)!.name}`, + ); + const value = emitter.emitExpr(follower.start); + const followerStart = B.tmp(); + B.line(`${followerStart} = fptosi double ${value.name} to i64`); + B.line(`store i64 ${followerStart}, ptr ${slot}`); + followerSlots.push(slot); + emitter.integerLoopBindings.set(follower.localId, { + slot, + type: "i64", + signed: true, + range: follower.range, + }); + } countedLimit = emitCountedLoopLimit(emitter, countedLoop); } else if (pairedLoop) { for (const counter of [pairedLoop.low, pairedLoop.high]) { @@ -1212,6 +1231,13 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { B.line(`${old} = load i64, ptr ${integerSlot}`); B.line(`${next} = add nsw i64 ${old}, ${countedLoop.step}`); B.line(`store i64 ${next}, ptr ${integerSlot}`); + countedLoop.followers.forEach((follower, i) => { + const was = B.tmp(); + const now = B.tmp(); + B.line(`${was} = load i64, ptr ${followerSlots[i]}`); + B.line(`${now} = add nsw i64 ${was}, ${follower.step}`); + B.line(`store i64 ${now}, ptr ${followerSlots[i]}`); + }); } else if (pairedLoop) { [pairedLoop.low, pairedLoop.high].forEach((counter, i) => { const old = B.tmp(); @@ -1227,7 +1253,11 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { B.startBlock(le); emitter.releaseScope(emitter.scopes.pop()!); if (integerLoop) emitter.integerLoopBindings.delete(integerLoop.localId); - if (countedLoop) emitter.integerLoopBindings.delete(countedLoop.localId); + if (countedLoop) { + emitter.integerLoopBindings.delete(countedLoop.localId); + for (const follower of countedLoop.followers) + emitter.integerLoopBindings.delete(follower.localId); + } if (pairedLoop) { emitter.integerLoopBindings.delete(pairedLoop.low.localId); emitter.integerLoopBindings.delete(pairedLoop.high.localId); diff --git a/packages/compiler/src/ir/integer-loops.test.ts b/packages/compiler/src/ir/integer-loops.test.ts index 24bbf5be0..e1453abad 100644 --- a/packages/compiler/src/ir/integer-loops.test.ts +++ b/packages/compiler/src/ir/integer-loops.test.ts @@ -426,3 +426,103 @@ test("paired counters closing in on each other run as integers", () => { unused.body = []; expect(matchIntegerPairedForLoop(unused, vars)).toBeNull(); }); + +test("counters stepped beside the tested one run as integers", () => { + const vars = new Map(locals); + for (const id of ["j", "k", "limit", "from"]) + vars.set(id, { id, name: id, type: F64, mutable: true }); + vars.set("s", { id: "s", name: "s", type: STRING, mutable: false }); + const step = (id: string, op: "+" | "-", value = 1): IrStmt => ({ + kind: "assign", + localId: id, + value: { kind: "bin", op, left: ref(id), right: number(value), type: F64, loc }, + loc, + }); + const read = (index: IrExpr): IrStmt => ({ + kind: "exprStmt", + expr: { + kind: "strIntrinsic", + method: "charCodeAt", + receiver: { kind: "varRef", localId: "s", type: STRING, loc }, + args: [index], + type: F64, + loc, + }, + loc, + }); + const comoving = ( + limit: IrExpr, + followerStart: IrExpr = number(0), + update: IrStmt = { kind: "block", body: [step("i", "+"), step("j", "+", 4)], loc }, + ) => + ({ + kind: "for", + loc, + init: { + kind: "block", + body: [ + { kind: "varDecl", localId: "i", init: number(0), loc }, + { kind: "varDecl", localId: "j", init: followerStart, loc }, + ], + loc, + }, + cond: { kind: "bin", op: "<", left: ref("i"), right: limit, type: BOOL, loc }, + update, + body: [read(ref("j"))], + }) as IrStmt & { kind: "for" }; + // A literal limit bounds the follower: at most 9 updates of 4 before the + // last body entry. + expect(matchIntegerCountedForLoop(comoving(number(10)), vars)).toMatchObject({ + localId: "i", + guarded: false, + range: { min: 0, max: 9 }, + followers: [ + { + localId: "j", + step: 4, + startGuarded: false, + tripGuarded: false, + range: { min: 0, max: 36 }, + }, + ], + }); + // An unknown limit or start is tested at run time. + expect(matchIntegerCountedForLoop(comoving(ref("limit")), vars)).toMatchObject({ + guarded: true, + followers: [{ tripGuarded: true, range: { min: 0, max: 2 ** 52 + 2 } }], + }); + expect(matchIntegerCountedForLoop(comoving(number(10), ref("from")), vars)).toMatchObject({ + guarded: true, + followers: [{ startGuarded: true, tripGuarded: true }], + }); + // A literal limit with known starts that can pass 2^53 is refused. + expect(matchIntegerCountedForLoop(comoving(number(10), number(2 ** 53 - 9)), vars)).toBeNull(); + // Nested update blocks (`i++, j += 4, k--`) step three counters. + const three = comoving(number(10), number(0), { + kind: "block", + body: [{ kind: "block", body: [step("i", "+"), step("j", "+", 4)], loc }, step("k", "-")], + loc, + }); + if (three.init?.kind === "block") + three.init.body.push({ kind: "varDecl", localId: "k", init: number(5), loc }); + expect(matchIntegerCountedForLoop(three, vars)?.followers).toMatchObject([ + { localId: "j", range: { min: 0, max: 36 } }, + { localId: "k", step: -1, range: { min: -4, max: 5 } }, + ]); + // A follower without a step, one the body writes, one the limit reads, a + // captured one, and a start that reads another counter are refused. + expect( + matchIntegerCountedForLoop( + comoving(number(10), number(0), { kind: "block", body: [step("i", "+")], loc }), + vars, + ), + ).toBeNull(); + const writing = comoving(number(10)); + writing.body.push(step("j", "+")); + expect(matchIntegerCountedForLoop(writing, vars)).toBeNull(); + expect(matchIntegerCountedForLoop(comoving(ref("j")), vars)).toBeNull(); + const boxed = new Map(vars); + boxed.set("j", { ...vars.get("j")!, boxed: true }); + expect(matchIntegerCountedForLoop(comoving(number(10)), boxed)).toBeNull(); + expect(matchIntegerCountedForLoop(comoving(number(10), ref("i")), vars)).toBeNull(); +}); diff --git a/packages/compiler/src/ir/integer-loops.ts b/packages/compiler/src/ir/integer-loops.ts index e80680d6e..c4cdc327c 100644 --- a/packages/compiler/src/ir/integer-loops.ts +++ b/packages/compiler/src/ir/integer-loops.ts @@ -28,8 +28,36 @@ export interface IntegerCountedForLoop { startGuarded: boolean; guardLimit: number; range: IntegerRange; + /** Counters declared and stepped beside this one that the condition does + * not test, such as `j` in `for (let i = 0, j = 0; i < n; i++, j += 4)`. */ + followers: IntegerLoopFollower[]; } +/** A counter that steps by a constant on every update of a counted loop. + * After `k` updates it holds `start + step * k`. */ +export interface IntegerLoopFollower { + localId: string; + start: IrExpr; + step: number; + /** As the driver's `startGuarded` (part of the loop's `guarded`). */ + startGuarded: boolean; + /** The follower's range depends on the run-time trip count: the versioned + * loop also tests `|start| + |step| * span / |driver step|` against + * `FOLLOWER_GUARD_LIMIT`, where `span` is the distance from the driver's + * start to the limit (part of the loop's `guarded`). */ + tripGuarded: boolean; + /** The follower's values on every body entry. */ + range: IntegerRange; +} + +/** The bound of the run-time follower test. */ +export const FOLLOWER_GUARD_LIMIT = 2 ** 52; +/** The magnitude a follower that passed the test can reach. The test's four + * f64 operations (the step ratio, the span, its product and the sum) each + * round down by at most a factor of 1 - 2^-53, so the exact sum is below + * `2^52 / (1 - 2^-53)^4`, which is less than 2^52 + 3. */ +const FOLLOWER_GUARD_RANGE = FOLLOWER_GUARD_LIMIT + 2; + function constantStep(update: IrStmt | null, id: string): number | null { if (update?.kind === "exprStmt" && update.expr.kind === "incDec" && update.expr.localId === id) return update.expr.op === "+" ? 1 : -1; @@ -115,33 +143,61 @@ export function matchIntegerCountedForLoop( ranges: IntegerRanges = new Map(), unaliased: ReadonlySet | null = null, ): IntegerCountedForLoop | null { - const init = stmt.init; - if (init?.kind !== "varDecl" || !init.init) return null; - const local = locals.get(init.localId); - if (local?.type.kind !== "f64" || !local.mutable || local.boxed || local.tdz) return null; - const start = init.init; - let startRange = - start.kind === "numLit" && Number.isSafeInteger(start.value) && !Object.is(start.value, -0) - ? { min: start.value, max: start.value } - : ranges.get(start); - // An unproven start is tested at run time, on a versioned loop. - const startGuarded = !startRange && start.kind !== "numLit" && start.type.kind === "f64"; - if (startGuarded) startRange = { min: -Number.MAX_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER }; - if ( - !startRange || - startRange.min < -Number.MAX_SAFE_INTEGER || - startRange.max > Number.MAX_SAFE_INTEGER || - !stableLoopValue(start, locals, stmt.body, false, local.id) - ) - return null; - const step = constantStep(stmt.update, local.id); - if (step === null || writesLocal(stmt.body, local.id)) return null; const cond = stmt.cond; if (cond?.kind !== "bin") return null; + const decls = stmt.init?.kind === "block" ? stmt.init.body : stmt.init ? [stmt.init] : []; + // `i++, j += 2, k--` lowers to nested blocks of steps. + const flat = (u: IrStmt | null): (IrStmt | null)[] => + u?.kind === "block" ? u.body.flatMap(flat) : [u]; + const updates = flat(stmt.update); + if (decls.length === 0 || updates.length !== decls.length) return null; + const declared = (e: IrExpr): string | null => + e.kind === "varRef" && decls.some((d) => d.kind === "varDecl" && d.localId === e.localId) + ? e.localId + : null; + // The condition tests the driving counter; every other declaration + // follows it. + const driver = declared(cond.left) ?? declared(cond.right); + const counterIds = decls.map((d) => (d.kind === "varDecl" ? d.localId : "")); + const stepOf = (id: string): number | null => { + const steps = updates.map((u) => constantStep(u, id)).filter((v) => v !== null); + return steps.length === 1 ? steps[0]! : null; + }; + // A counter's start is a stable integer that refers to no counter. An + // unproven start is tested at run time, on a versioned loop. + const counterStart = ( + id: string, + ): { start: IrExpr; range: IntegerRange; guarded: boolean; step: number } | null => { + const decl = decls.find((d) => d.kind === "varDecl" && d.localId === id); + if (decl?.kind !== "varDecl" || !decl.init) return null; + const local = locals.get(id); + if (local?.type.kind !== "f64" || !local.mutable || local.boxed || local.tdz) return null; + const start = decl.init; + const known = + start.kind === "numLit" && Number.isSafeInteger(start.value) && !Object.is(start.value, -0) + ? { min: start.value, max: start.value } + : ranges.get(start); + const guarded = !known && start.kind !== "numLit" && start.type.kind === "f64"; + const range = guarded ? { min: -Number.MAX_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER } : known; + const step = stepOf(id); + if ( + !range || + range.min < -Number.MAX_SAFE_INTEGER || + range.max > Number.MAX_SAFE_INTEGER || + !counterIds.every((counter) => stableLoopValue(start, locals, stmt.body, false, counter)) || + step === null || + writesLocal(stmt.body, id) + ) + return null; + return { start, range, guarded, step }; + }; + const head = driver === null ? null : counterStart(driver); + if (!head) return null; + const local = locals.get(driver!)!; + const { start, step, guarded: startGuarded, range: startRange } = head; let limit = cond.right, op: string = cond.op; if (cond.left.kind !== "varRef" || cond.left.localId !== local.id) { - if (cond.right.kind !== "varRef" || cond.right.localId !== local.id) return null; limit = cond.left; op = ({ "<": ">", "<=": ">=", ">": "<", ">=": "<=" } as Record)[op] ?? ""; } @@ -185,11 +241,68 @@ export function matchIntegerCountedForLoop( const limitGuarded = !boundRange || (step > 0 ? !(boundRange.max <= guardLimit) : !(boundRange.min >= guardLimit)); if (limitGuarded && limit.kind === "numLit") return null; - const guarded = limitGuarded || startGuarded; + const range = + step > 0 + ? { + min: startRange.min, + max: Math.max( + startRange.min, + Math.min( + Number.MAX_SAFE_INTEGER, + boundRange + ? Math.ceil(boundRange.max) - (inclusive ? 0 : 1) + : Number.MAX_SAFE_INTEGER, + ), + ), + } + : { + min: Math.min( + startRange.max, + Math.max( + -Number.MAX_SAFE_INTEGER, + boundRange + ? Math.floor(boundRange.min) + (inclusive ? 0 : 1) + : -Number.MAX_SAFE_INTEGER, + ), + ), + max: startRange.max, + }; + // On body entry k the driver holds `start + step * k`, so k is at most the + // driver's span over |step|, and a follower holds its start plus its own + // step times k. + const trips = Math.floor( + (step > 0 ? range.max - startRange.min : startRange.max - range.min) / Math.abs(step), + ); + const followers: IntegerLoopFollower[] = []; + for (const id of counterIds) { + if (id === local.id) continue; + const follower = counterStart(id); + // The limit is evaluated once; a follower changes on every update. + if (!follower || !stableLoopValue(limit, locals, stmt.body, false, id)) return null; + const reach = follower.step * trips; + const min = follower.range.min + Math.min(0, reach), + max = follower.range.max + Math.max(0, reach); + const tripGuarded = min < -Number.MAX_SAFE_INTEGER || max > Number.MAX_SAFE_INTEGER; + // Known starts and a literal limit are not tested at run time. + if (tripGuarded && !follower.guarded && !startGuarded && limit.kind === "numLit") return null; + followers.push({ + localId: id, + start: follower.start, + step: follower.step, + startGuarded: follower.guarded, + tripGuarded, + range: tripGuarded + ? { min: Math.max(-FOLLOWER_GUARD_RANGE, min), max: Math.min(FOLLOWER_GUARD_RANGE, max) } + : { min, max }, + }); + } + const guarded = + limitGuarded || startGuarded || followers.some((f) => f.startGuarded || f.tripGuarded); let useful = false; let cost = 0; const counter = (e: IrExpr): boolean => - (e.kind === "varRef" && e.localId === local.id) || + (e.kind === "varRef" && + (e.localId === local.id || followers.some((f) => f.localId === e.localId))) || (e.kind === "bin" && (e.op === "+" || e.op === "-" || e.op === "*") && (counter(e.left) || counter(e.right))); @@ -241,32 +354,6 @@ export function matchIntegerCountedForLoop( return (!guarded || ++cost <= 80) && everyStmtChild(s, expr, bodyStmt); }; if (!stmt.body.every(bodyStmt) || !useful) return null; - const range = - step > 0 - ? { - min: startRange.min, - max: Math.max( - startRange.min, - Math.min( - Number.MAX_SAFE_INTEGER, - boundRange - ? Math.ceil(boundRange.max) - (inclusive ? 0 : 1) - : Number.MAX_SAFE_INTEGER, - ), - ), - } - : { - min: Math.min( - startRange.max, - Math.max( - -Number.MAX_SAFE_INTEGER, - boundRange - ? Math.floor(boundRange.min) + (inclusive ? 0 : 1) - : -Number.MAX_SAFE_INTEGER, - ), - ), - max: startRange.max, - }; return { localId: local.id, start, @@ -278,6 +365,7 @@ export function matchIntegerCountedForLoop( startGuarded, guardLimit, range, + followers, }; } diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7141-comoving-loop-counters.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7141-comoving-loop-counters.ts.json new file mode 100644 index 000000000..392c9f10d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7141-comoving-loop-counters.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7141-comoving-loop-counters.ts" + ], + "diags": [] +} diff --git a/tests/corpus/7141-comoving-loop-counters.ts b/tests/corpus/7141-comoving-loop-counters.ts new file mode 100644 index 000000000..a756b7a46 --- /dev/null +++ b/tests/corpus/7141-comoving-loop-counters.ts @@ -0,0 +1,144 @@ +// For loops with a second counter that steps beside the tested one +// (`i++, j += 4`): pixel strides over typed arrays, interleaving into number +// arrays, descending and inclusive loops, three counters, early exits, +// starts and limits that are fractions, negative zero, NaN, infinite or +// near 2^53, counters that live across a yield or an await, and counters a +// closure captures, the body writes or the condition reads. +function luminance(px: Uint8Array, count: number): number[] { + const out: number[] = []; + for (let i = 0, p = 0; i < count; i++, p += 4) { + out.push((px[p]! * 77 + px[p + 1]! * 150 + px[p + 2]! * 29) >> 8); + } + return out; +} +const px = new Uint8Array(32); +for (let k = 0; k < px.length; k++) px[k] = (k * 37 + 11) & 255; +console.log(luminance(px, 8).join(",")); +// Past the end, reads are undefined and the sums NaN, which `>> 8` makes 0. +console.log(luminance(px, 10).join(",")); +console.log(luminance(px, 0).length, luminance(px, -3).length, luminance(px, 2.5).join(",")); +console.log(luminance(px, NaN).length); + +function interleave(a: number[], b: number[]): number[] { + const out: number[] = new Array(a.length * 2).fill(-1); + const n = a.length; + for (let i = 0, j = 0; i < n; i++, j += 2) { + out[j] = a[i]!; + out[j + 1] = b[i]!; + } + return out; +} +console.log(interleave([1, 2, 3, 4], [10, 20, 30, 40]).join(",")); +console.log(interleave([], []).length); + +// The second counter's start is not proven: charCodeAt truncates its index, +// and the counter's own values keep JS semantics. +function codes(s: string, count: number, from: number, step: number): string { + const out: (number | string)[] = []; + if (step === 3) { + for (let i = 0, j = from; i < count; i++, j += 3) out.push(s.charCodeAt(j), j); + } else { + for (let i = 0, j = from; i < count; i++, j -= 2) out.push(s.charCodeAt(j), j); + } + return out.join(","); +} +const word = "abcdefghijklmnop"; +console.log(codes(word, 4, 0, 3), "|", codes(word, 4, 15, -2)); +console.log(codes(word, 4, 0.5, 3), "|", codes(word, 3, 9.75, -2)); +const negativeZero = -0; +console.log(codes(word, 2, negativeZero, 3), Object.is(negativeZero, -0)); +console.log(codes(word, 2, NaN, 3), "|", codes(word, 2, Infinity, -2), "|", codes(word, 2, -Infinity, 3)); +// Near 2^52 the run-time test passes or fails on the trip count; near 2^53 +// the double counter rounds (odd values above 2^53 are not representable). +console.log(codes(word, 4, 2 ** 52 - 16, 3)); +console.log(codes(word, 6, 2 ** 52 - 4, 3)); +console.log(codes(word, 6, 2 ** 53 - 10, 3)); +console.log(codes(word, 4, -(2 ** 53) + 3, -2)); +// A limit that is not finite or not an integer. +function capped(s: string, limit: number): string { + const out: number[] = []; + for (let i = 0, j = 1; i < limit; i++, j += 2) { + if (j >= s.length) break; + out.push(s.charCodeAt(j)); + } + return out.join(","); +} +console.log(capped(word, Infinity), "|", capped(word, 3.5), "|", capped(word, NaN), "|", capped(word, -Infinity)); + +// A descending driver with an ascending follower, inclusive bounds and +// larger steps. +function mirror(s: string): string { + const out: string[] = []; + for (let i = s.length - 1, j = 0; i >= 0; i--, j += 2) out.push(`${s.charCodeAt(i)}@${j}`); + return out.join(" "); +} +console.log(mirror("scriptc")); +function stepped(bytes: Uint8Array, last: number): string { + const out: number[] = []; + for (let i = 0, j = bytes.length - 1; i <= last; i += 3, j -= 5) + out.push(bytes[i]! | 0, bytes[j]! | 0, j); + return out.join(","); +} +console.log(stepped(px, 9), "|", stepped(px, 30)); + +// Three counters, continue and break. +function triple(a: Uint8Array, n: number): string { + const out: number[] = []; + for (let i = 0, j = 10, k = 100; i < n; i++, j -= 1, k += 7) { + if (i % 3 === 1) continue; + if (k > 150) break; + out.push(a[i]!, a[j]!, k); + } + return out.join(","); +} +console.log(triple(px, 12), "|", triple(px, 4)); + +// A counted limit with a known range and a follower used by a remainder. +let rotated = 0; +for (let i = 0, j = 5; i < 1000; i++, j += 3) rotated = (rotated * 31 + px[j % 32]!) % 1000003; +console.log(rotated); + +// The follower starting from a driver's start of unproven exactness. +function window(bytes: Uint8Array, from: number, to: number): string { + const out: number[] = []; + for (let i = from, j = 0; i < to; i++, j += 2) out.push(bytes[i]! | 0, bytes[j]! | 0, i, j); + return out.join(","); +} +console.log(window(px, 2, 5), "|", window(px, 1.5, 4), "|", window(px, -0, 2)); + +// Counters a closure captures keep one binding per iteration; a follower the +// body writes, one the condition reads, and a start that reads another +// counter keep their JS values. +const reads: (() => number)[] = []; +for (let i = 0, j = 0; i < 3; i++, j += 4) { + reads.push(() => j); + void px[j]; +} +console.log(reads.map((read) => read()).join(",")); +const written: number[] = []; +for (let i = 0, j = 0; i < 5; i++, j += 2) { + if (i === 2) j += 7; + written.push(px[j]!, j); +} +console.log(written.join(",")); +const chased: number[] = []; +for (let i = 0, j = 5; i < j; i += 2, j++) chased.push(px[i]!, i, j); +console.log(chased.join(",")); +const offset: number[] = []; +for (let i = 1, j = i + 1; i < 4; i++, j += 2) offset.push(px[j]!, j); +console.log(offset.join(",")); + +// Counters that live across a yield or an await. +function* strided(bytes: Uint8Array, n: number): Generator { + for (let i = 0, j = 1; i < n; i++, j += 3) yield bytes[j]! + i; +} +console.log([...strided(px, 6)].join(",")); +async function weighted(bytes: Uint8Array, n: number): Promise { + let sum = 0; + for (let i = 0, j = 2; i < n; i++, j += 5) { + await null; + sum += bytes[j]! * (i + 1); + } + return sum; +} +void (async () => console.log(await weighted(px, 6), await weighted(px, 3)))(); diff --git a/tests/harness/corpus-costs/7141-comoving-loop-counters.ts.json b/tests/harness/corpus-costs/7141-comoving-loop-counters.ts.json new file mode 100644 index 000000000..7c0606885 --- /dev/null +++ b/tests/harness/corpus-costs/7141-comoving-loop-counters.ts.json @@ -0,0 +1 @@ +{ "plain": 4260, "san": 6600 } From 0318671352edbc3d699dc9beeaca53316af149d6 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 09:17:49 -0500 Subject: [PATCH 090/102] Reuse the class dispatch passes' per-function scans while bodies are unchanged --- .../lowering/caught-value-dispatch.ts | 24 +- .../frontend/lowering/class-construction.ts | 20 +- .../lowering/class-dynamic-dispatch.ts | 118 ++------ .../deferred-module-initializers.test.ts | 9 + .../lowering/deferred-module-initializers.ts | 14 +- .../frontend/lowering/dispatch-sites.test.ts | 60 ++++ .../src/frontend/lowering/dispatch-sites.ts | 272 ++++++++++++++++++ .../lowering/generator-dynamic-dispatch.ts | 50 ++-- .../compiler/src/frontend/lowering/lowerer.ts | 18 +- 9 files changed, 417 insertions(+), 168 deletions(-) create mode 100644 packages/compiler/src/frontend/lowering/dispatch-sites.test.ts create mode 100644 packages/compiler/src/frontend/lowering/dispatch-sites.ts diff --git a/packages/compiler/src/frontend/lowering/caught-value-dispatch.ts b/packages/compiler/src/frontend/lowering/caught-value-dispatch.ts index 606d10d56..07d68baec 100644 --- a/packages/compiler/src/frontend/lowering/caught-value-dispatch.ts +++ b/packages/compiler/src/frontend/lowering/caught-value-dispatch.ts @@ -11,6 +11,7 @@ import { } from "../../ir/ir.js"; import { everyStmtList, transformStmtList } from "../../ir/traverse.js"; import { classInstanceOf } from "./class-dynamic-dispatch.js"; +import type { DispatchSites } from "./dispatch-sites.js"; import type { ClassInfo } from "./lower-classes.js"; import type { Lowerer } from "./lowerer.js"; @@ -26,25 +27,16 @@ export class CaughtValueDispatch { private readonly payloadHelpers = new Map(); private readonly payloadHelperFns = new Set(); - process(lowerer: Lowerer, functions: readonly IrFunction[]): boolean { + process(lowerer: Lowerer, functions: readonly IrFunction[], sites: DispatchSites): boolean { const consumers: IrFunction[] = []; for (const fn of functions) { if (fn === this.helper) continue; - let consumes = false; - everyStmtList(fn.body, { - stmt: (stmt) => { - if (stmt.kind === "throw" && stmt.value.type.kind === "object") { - const info = lowerer.classes.get(stmt.value.type.className); - if (info) this.thrownClasses.add(info.def.name); - } - return true; - }, - expr: (expr) => { - if (expr.kind === "caughtToDyn") consumes = true; - return true; - }, - }); - if (consumes) consumers.push(fn); + const found = sites.of(fn); + for (const className of found.thrown) { + const info = lowerer.classes.get(className); + if (info) this.thrownClasses.add(info.def.name); + } + if (found.caughtValues) consumers.push(fn); } if (!this.helper && consumers.length === 0) return false; let changed = false; diff --git a/packages/compiler/src/frontend/lowering/class-construction.ts b/packages/compiler/src/frontend/lowering/class-construction.ts index 30f504b4a..66ec547bc 100644 --- a/packages/compiler/src/frontend/lowering/class-construction.ts +++ b/packages/compiler/src/frontend/lowering/class-construction.ts @@ -13,7 +13,8 @@ import { type IrType, type SrcLoc, } from "../../ir/ir.js"; -import { everyStmtList, transformExpr, transformStmtList } from "../../ir/traverse.js"; +import { transformExpr, transformStmtList } from "../../ir/traverse.js"; +import type { DispatchSites } from "./dispatch-sites.js"; import type { Lowerer } from "./lowerer.js"; import type { ParamShape } from "./call-signatures.js"; import { classPrototypeData } from "./class-prototypes.js"; @@ -254,22 +255,17 @@ export class ClassConstructionDispatch { private prototypeHelper: IrFunction | null = null; private readonly prototypes = new Set(); - process(lowerer: Lowerer, functions: readonly IrFunction[]): boolean { + process(lowerer: Lowerer, functions: readonly IrFunction[], sites: DispatchSites): boolean { const discover = (type: IrType): void => { if (type.kind === "classval") this.constructors.add(type.className); else if (type.kind === "union") lowerer.unions.get(type.unionId)?.arms.forEach(discover); }; const prototypeReads = new Set(); - for (const fn of functions) - everyStmtList(fn.body, { - stmt: () => true, - expr: (expr) => { - if (expr.kind === "dynFrom") discover(expr.value.type); - if (expr.kind === "libCall" && expr.fn === "dyn.classBasePrototype") - prototypeReads.add(fn); - return true; - }, - }); + for (const fn of functions) { + const found = sites.of(fn); + found.values.forEach(discover); + if (found.basePrototypes) prototypeReads.add(fn); + } let changed = false; for (const fn of functions) { if (fn === this.prototypeHelper || !prototypeReads.has(fn)) continue; diff --git a/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts b/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts index fefe85d0c..f2ccb0ec6 100644 --- a/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts +++ b/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts @@ -77,6 +77,7 @@ import { isClassCallback } from "./class-callbacks.js"; import { CaughtValueDispatch } from "./caught-value-dispatch.js"; import { refreshDescriptorGuards } from "./class-descriptors.js"; import { ClassConstructionDispatch } from "./class-construction.js"; +import { DispatchSites } from "./dispatch-sites.js"; import { emitterRooted, lowerDynamicEmitterEmit, @@ -226,7 +227,7 @@ const KEY_CALLS = new Map([ ["dyn.keySetComputed", "value"], ]); -function toPrimitiveHint(expr: IrExpr): ToPrimitiveHint | null { +export function toPrimitiveHint(expr: IrExpr): ToPrimitiveHint | null { if (expr.kind === "toString") return expr.operand.type.kind === "dyn" ? "string" : null; if (expr.kind === "dynKeyGet") return expr.key.type.kind === "dyn" ? "string" : null; if (expr.kind !== "libCall") return null; @@ -780,6 +781,8 @@ export class ClassDynamicDispatch { private readonly generatorDispatch = new GeneratorDynamicDispatch(); private readonly caughtDispatch = new CaughtValueDispatch(); private readonly constructionDispatch = new ClassConstructionDispatch(); + /** What each function's body holds for this pass and its sub-passes. */ + readonly sites = new DispatchSites(); /** Property names a delete can remove (null: any name), for the field * creation tracking decision. */ private deletedNames: Set | null | undefined; @@ -862,12 +865,13 @@ export class ClassDynamicDispatch { ) fn.body.shift(); } - let changed = this.caughtDispatch.process(lowerer, functions); + let changed = this.caughtDispatch.process(lowerer, functions, this.sites); changed = refreshErrorMethodDispatch(lowerer, functions) || changed; changed = refreshClassMethodValueSelections(lowerer) || changed; changed = refreshErrorPropertyDispatch(lowerer, functions) || changed; - changed = this.generatorDispatch.process(lowerer, functions, this.generated) || changed; - changed = this.constructionDispatch.process(lowerer, functions) || changed; + changed = + this.generatorDispatch.process(lowerer, functions, this.generated, this.sites) || changed; + changed = this.constructionDispatch.process(lowerer, functions, this.sites) || changed; const seenTypes = new Set(); const rewrite = new Set(); const toPrimitiveSites = new Set(); @@ -891,100 +895,18 @@ export class ClassDynamicDispatch { }; const boxedBefore = this.boxed.size; const boxedConstructorsBefore = this.boxedConstructors.size; - for (const fn of functions) - everyStmtList(fn.body, { - stmt: (statement) => { - // Field-creation instrumentation can box a base-constructor receiver - // even when only its derived instances otherwise cross the boundary. - if ( - statement.kind === "fieldSet" && - lowerer.classes.get(statement.className)?.def.tracksOwnFields && - isClassOwnEnumerableFieldName(statement.field) - ) - discover(statement.obj.type); - return true; - }, - expr: (expr) => { - if ( - expr.kind === "jsonStringify" || - (expr.kind === "libCall" && - (expr.fn === "json.stringifyValue" || expr.fn === "json.stringifyReplacer")) - ) { - this.serializesClasses = true; - } - if ( - toPrimitiveHint(expr) !== null || - (expr.kind === "libCall" && (expr.fn === "dyn.valueOf" || expr.fn === "dyn.toString")) - ) - toPrimitiveSites.add(fn); - switch (expr.kind) { - case "dynFrom": - discover(expr.value.type); - break; - case "fieldIncDec": - if ( - lowerer.classes.get(expr.className)?.def.tracksOwnFields && - isClassOwnEnumerableFieldName(expr.field) - ) - discover(expr.obj.type); - break; - case "call": - if ( - (expr.callee === "%dyn.class.properties" || - expr.callee === "%dyn.class.readProperties") && - expr.args[0]?.kind === "dynFrom" && - isDynTypedRefType(expr.args[0].value.type) - ) - rewrite.add(fn); - break; - case "dynHasKey": - hasKeySites.add(fn); - break; - case "caughtTest": - if (expr.test === "instanceof") caughtSites.add(fn); - break; - case "caughtNarrow": - case "caughtCheck": - if (expr.type.kind === "object") caughtSites.add(fn); - break; - case "dynKeyGet": - case "dynInvoke": - rewrite.add(fn); - break; - case "dynCheck": - if (isDynTypedRefType(expr.type)) rewrite.add(fn); - // A dynamic function checked into a native function type - // receives its arguments as dynamic values: class instances - // passed to it cross the boundary when it is called (a JS - // `list.map((rec) => rec.match(x))` callback with an untyped - // parameter). - if (expr.type.kind === "func") expr.type.params.forEach(discover); - break; - case "libCall": - if ( - expr.fn === "bytes.construct" || - expr.fn === "dyn.keySet" || - expr.fn === "dyn.keySetComputed" || - expr.fn === "dyn.iterator" || - expr.fn === "dyn.arrayFromIterator" || - expr.fn === "dyn.toString" || - expr.fn === "dyn.stringConstructor" || - expr.fn === "dyn.forInKeys" || - expr.fn === "dyn.forInKeyStrings" || - expr.fn === "dyn.hasKeyComputed" || - expr.fn === "dyn.hasOwnComputed" || - expr.fn === "dyn.propertyIsEnumerableComputed" || - expr.fn === "dyn.defineProperty" || - expr.fn === "dyn.getPrototype" || - expr.fn === "dyn.reflectGet" || - expr.fn === "dyn.reflectSet" - ) - rewrite.add(fn); - break; - } - return true; - }, - }); + for (const fn of functions) { + const found = this.sites.of(fn); + // A class starts tracking its own fields during this pass. + for (const { type, fieldClass } of found.boxing) + if (fieldClass === undefined || lowerer.classes.get(fieldClass)?.def.tracksOwnFields) + discover(type); + if (found.serializes) this.serializesClasses = true; + if (found.conversions) toPrimitiveSites.add(fn); + if (found.dispatches) rewrite.add(fn); + if (found.keyTests) hasKeySites.add(fn); + if (found.caughtClassTests) caughtSites.add(fn); + } // The classes this pass found join the tables in a fixed order, not in // the order the scan met them. sortAdded(lowerer, this.boxed, boxedBefore); diff --git a/packages/compiler/src/frontend/lowering/deferred-module-initializers.test.ts b/packages/compiler/src/frontend/lowering/deferred-module-initializers.test.ts index 28f05bfce..4696659bc 100644 --- a/packages/compiler/src/frontend/lowering/deferred-module-initializers.test.ts +++ b/packages/compiler/src/frontend/lowering/deferred-module-initializers.test.ts @@ -159,6 +159,15 @@ test("fills every empty copy with the exact file and span while preserving popul for (const untouched of [otherFile, otherStart, otherEnd]) expect(untouched.body).toEqual([]); }); +test("reports the functions whose placeholders it fills", () => { + const { initializers, pending, lowerer } = fixture(); + const functions = [fn("init", [block(loc)]), fn("use", [read("registry")])]; + pending.set("registry", [{ loc, lower: () => [value(4)] }]); + const filled: IrFunction[] = []; + expect(initializers.process(lowerer, functions, (f) => filled.push(f))).toBe(true); + expect(filled).toEqual([functions[0]]); +}); + test("an update of the binding demands its initializer", () => { const { initializers, pending, lowerer } = fixture(); const updated = block(loc), diff --git a/packages/compiler/src/frontend/lowering/deferred-module-initializers.ts b/packages/compiler/src/frontend/lowering/deferred-module-initializers.ts index eb22b4085..a44df8f75 100644 --- a/packages/compiler/src/frontend/lowering/deferred-module-initializers.ts +++ b/packages/compiler/src/frontend/lowering/deferred-module-initializers.ts @@ -129,7 +129,14 @@ export class DeferredModuleInitializers { return block; } - process(lowerer: Lowerer, functions: readonly IrFunction[]): boolean { + /** Materializes the initializers that reached bodies observe. `filled` + * receives each function whose body changes inside an unchanged statement + * list. */ + process( + lowerer: Lowerer, + functions: readonly IrFunction[], + filled?: (fn: IrFunction) => void, + ): boolean { if (this.pending.size === 0) return false; // Scans keep only the reads of deferred bindings. for (const key of this.pending.keys()) { @@ -192,7 +199,10 @@ export class DeferredModuleInitializers { } if (holders.length === 0) continue; // These bodies changed inside unchanged statement lists. - for (const fn of holders) this.scans.delete(fn); + for (const fn of holders) { + this.scans.delete(fn); + filled?.(fn); + } // An inserted body can introduce a placeholder needed by another // action in this pass. Unattached bodies are not part of the live IR. for (const nested of scanStatements(body).placeholders) add(nested, holders); diff --git a/packages/compiler/src/frontend/lowering/dispatch-sites.test.ts b/packages/compiler/src/frontend/lowering/dispatch-sites.test.ts new file mode 100644 index 000000000..1d027ac34 --- /dev/null +++ b/packages/compiler/src/frontend/lowering/dispatch-sites.test.ts @@ -0,0 +1,60 @@ +import { expect, test, vi } from "vitest"; +import { DYN, F64, VOID, type IrFunction, type IrStmt, type SrcLoc } from "../../ir/ir.js"; +import * as traversal from "../../ir/traverse.js"; +import { DispatchSites } from "./dispatch-sites.js"; + +const loc: SrcLoc = { file: "sites.ts", start: 0, end: 1 }; +const keyRead = (key: string): IrStmt => ({ + kind: "exprStmt", + expr: { + kind: "dynKeyGet", + value: { kind: "varRef", localId: "value", type: DYN, loc }, + key: { kind: "strLit", value: key, type: DYN, loc }, + type: DYN, + loc, + }, + loc, +}); +const value = (n: number): IrStmt => ({ + kind: "exprStmt", + expr: { kind: "numLit", value: n, type: F64, loc }, + loc, +}); +const fn = (body: IrStmt[]): IrFunction => ({ + name: "f", + body, + params: [], + locals: [], + returnType: VOID, + loc, +}); + +test("reuses a function's sites while its statement list is unchanged", () => { + const sites = new DispatchSites(); + const f = fn([value(1)]); + const walk = vi.spyOn(traversal, "everyStmtList"); + try { + expect(sites.of(f).dispatches).toBe(false); + expect(sites.of(f).dispatches).toBe(false); + expect(walk).toHaveBeenCalledTimes(1); + // A statement added to the same list is found. + f.body.push(keyRead("next")); + expect(sites.of(f)).toMatchObject({ dispatches: true, generatorSteps: true }); + // So is a replaced list. + f.body = [value(2)]; + expect(sites.of(f)).toMatchObject({ dispatches: false, generatorSteps: false }); + expect(walk).toHaveBeenCalledTimes(3); + } finally { + walk.mockRestore(); + } +}); + +test("scans a body again once a change inside an unchanged list is reported", () => { + const sites = new DispatchSites(); + const placeholder: Extract = { kind: "block", body: [], loc }; + const f = fn([placeholder]); + expect(sites.of(f).dispatches).toBe(false); + placeholder.body.push(keyRead("map")); + sites.forget(f); + expect(sites.of(f)).toMatchObject({ dispatches: true, runtimeSteps: true }); +}); diff --git a/packages/compiler/src/frontend/lowering/dispatch-sites.ts b/packages/compiler/src/frontend/lowering/dispatch-sites.ts new file mode 100644 index 000000000..2618dacf9 --- /dev/null +++ b/packages/compiler/src/frontend/lowering/dispatch-sites.ts @@ -0,0 +1,272 @@ +import { InternalCompilerError } from "../../errors.js"; +import { + isClassOwnEnumerableFieldName, + isDynTypedRefType, + typeKey, + type IrFunction, + type IrStmt, + type IrType, +} from "../../ir/ir.js"; +import { everyStmtList } from "../../ir/traverse.js"; +import { toPrimitiveHint } from "./class-dynamic-dispatch.js"; +import { GENERATOR_STEP_METHODS, HELPER_METHODS } from "./generator-dynamic-dispatch.js"; + +/** What one function's body holds for the class dispatch pass and its + * caught-value, generator and class construction sub-passes, collected in + * one walk. Lists keep the order the walk meets their entries. */ +export interface FunctionSites { + statements: IrStmt[]; + length: number; + first: IrStmt | undefined; + last: IrStmt | undefined; + /** The value types of `dynFrom` expressions, once per type key. */ + values: IrType[]; + /** The types the class dispatch scan boxes, once per type key and class: + * `dynFrom` values, the parameter types of dynamic functions checked into + * native function types, and the receivers of own enumerable field writes + * and updates. A receiver counts only while its class (`fieldClass`) + * tracks its own fields. */ + boxing: { type: IrType; fieldClass?: string }[]; + /** JSON serialization of dynamic values. */ + serializes: boolean; + /** ToPrimitive conversions, and `dyn.valueOf` and `dyn.toString` calls. */ + conversions: boolean; + /** Sites the class dispatch rewrite can change. */ + dispatches: boolean; + /** `dynHasKey` tests. */ + keyTests: boolean; + /** `instanceof` tests of caught values, and caught values narrowed or + * checked to class types. */ + caughtClassTests: boolean; + /** Calls and reads of generator steps, and reads of iterator helper + * methods. */ + generatorSteps: boolean; + /** Values the runtime steps: iterator helper calls and reads, `dynIterN`, + * and rest destructuring. */ + runtimeSteps: boolean; + /** `dyn.classBasePrototype` calls. */ + basePrototypes: boolean; + /** The classes of thrown class instances, once each. */ + thrown: string[]; + /** `caughtToDyn` conversions. */ + caughtValues: boolean; +} + +/** The `libCall`s the class dispatch rewrite can change. */ +const DISPATCH_LIB_CALLS = new Set([ + "bytes.construct", + "dyn.keySet", + "dyn.keySetComputed", + "dyn.iterator", + "dyn.arrayFromIterator", + "dyn.toString", + "dyn.stringConstructor", + "dyn.forInKeys", + "dyn.forInKeyStrings", + "dyn.hasKeyComputed", + "dyn.hasOwnComputed", + "dyn.propertyIsEnumerableComputed", + "dyn.defineProperty", + "dyn.getPrototype", + "dyn.reflectGet", + "dyn.reflectSet", +]); + +/** Prototype data helpers (classPrototypeData) gain method slots inside + * their initialization block, so their summaries are not reused. */ +const PROTOTYPE_DATA_PREFIX = "%prototype.data."; + +/** SCRIPTC_CHECK_DISPATCH_SCANS=1 checks each reused summary against a fresh walk. */ +const CHECK_SCANS = process.env["SCRIPTC_CHECK_DISPATCH_SCANS"] === "1"; + +/** The function summaries (FunctionSites) of one class dispatch pass, kept + * across its runs. */ +export class DispatchSites { + private readonly sites = new Map(); + + /** The sites of `fn`. A summary is reused while the function's statement + * list is the same array with the same length and the same first and last + * statements: the dispatch passes replace the lists they rewrite and add + * statements to the helpers they extend. Other changes inside an + * unchanged list are reported with `forget`, except in prototype data + * helpers, which are scanned on every use. */ + of(fn: IrFunction): FunctionSites { + const cached = this.sites.get(fn); + if ( + cached !== undefined && + !fn.name.startsWith(PROTOTYPE_DATA_PREFIX) && + cached.statements === fn.body && + cached.length === fn.body.length && + cached.first === fn.body[0] && + cached.last === fn.body[fn.body.length - 1] + ) { + if (CHECK_SCANS && !sameSites(cached, scanSites(fn.body))) + throw new InternalCompilerError( + `reused dispatch sites of ${fn.name} disagree with a fresh scan`, + ); + return cached; + } + const sites = scanSites(fn.body); + this.sites.set(fn, sites); + return sites; + } + + /** Drops the summary of a function whose body changed inside an unchanged + * statement list. */ + forget(fn: IrFunction): void { + this.sites.delete(fn); + } +} + +function scanSites(statements: IrStmt[]): FunctionSites { + const sites: FunctionSites = { + statements, + length: statements.length, + first: statements[0], + last: statements[statements.length - 1], + values: [], + boxing: [], + serializes: false, + conversions: false, + dispatches: false, + keyTests: false, + caughtClassTests: false, + generatorSteps: false, + runtimeSteps: false, + basePrototypes: false, + thrown: [], + caughtValues: false, + }; + const valueKeys = new Set(); + const boxingKeys = new Set(); + const thrown = new Set(); + const box = (type: IrType, fieldClass?: string): void => { + const key = `${fieldClass ?? ""}\0${typeKey(type)}`; + if (boxingKeys.has(key)) return; + boxingKeys.add(key); + sites.boxing.push(fieldClass === undefined ? { type } : { type, fieldClass }); + }; + everyStmtList(statements, { + stmt: (statement) => { + if (statement.kind === "throw" && statement.value.type.kind === "object") { + const className = statement.value.type.className; + if (!thrown.has(className)) { + thrown.add(className); + sites.thrown.push(className); + } + } + // Field-creation instrumentation can box a base-constructor receiver + // even when only its derived instances otherwise cross the boundary. + if (statement.kind === "fieldSet" && isClassOwnEnumerableFieldName(statement.field)) + box(statement.obj.type, statement.className); + return true; + }, + expr: (expr) => { + if ( + expr.kind === "jsonStringify" || + (expr.kind === "libCall" && + (expr.fn === "json.stringifyValue" || expr.fn === "json.stringifyReplacer")) + ) + sites.serializes = true; + if ( + toPrimitiveHint(expr) !== null || + (expr.kind === "libCall" && (expr.fn === "dyn.valueOf" || expr.fn === "dyn.toString")) + ) + sites.conversions = true; + if ( + (expr.kind === "dynInvoke" && GENERATOR_STEP_METHODS.has(expr.method)) || + (expr.kind === "dynKeyGet" && + expr.key.kind === "strLit" && + (GENERATOR_STEP_METHODS.has(expr.key.value) || HELPER_METHODS.has(expr.key.value))) + ) + sites.generatorSteps = true; + if ( + (expr.kind === "dynInvoke" && HELPER_METHODS.has(expr.method)) || + (expr.kind === "dynKeyGet" && + expr.key.kind === "strLit" && + HELPER_METHODS.has(expr.key.value)) || + expr.kind === "dynIterN" || + (expr.kind === "libCall" && expr.fn === "dyn.destructureRest") + ) + sites.runtimeSteps = true; + switch (expr.kind) { + case "dynFrom": { + const key = typeKey(expr.value.type); + if (!valueKeys.has(key)) { + valueKeys.add(key); + sites.values.push(expr.value.type); + } + box(expr.value.type); + break; + } + case "fieldIncDec": + if (isClassOwnEnumerableFieldName(expr.field)) box(expr.obj.type, expr.className); + break; + case "call": + if ( + (expr.callee === "%dyn.class.properties" || + expr.callee === "%dyn.class.readProperties") && + expr.args[0]?.kind === "dynFrom" && + isDynTypedRefType(expr.args[0].value.type) + ) + sites.dispatches = true; + break; + case "dynHasKey": + sites.keyTests = true; + break; + case "caughtTest": + if (expr.test === "instanceof") sites.caughtClassTests = true; + break; + case "caughtNarrow": + case "caughtCheck": + if (expr.type.kind === "object") sites.caughtClassTests = true; + break; + case "caughtToDyn": + sites.caughtValues = true; + break; + case "dynKeyGet": + case "dynInvoke": + sites.dispatches = true; + break; + case "dynCheck": + if (isDynTypedRefType(expr.type)) sites.dispatches = true; + // A dynamic function checked into a native function type + // receives its arguments as dynamic values: class instances + // passed to it cross the boundary when it is called (a JS + // `list.map((rec) => rec.match(x))` callback with an untyped + // parameter). + if (expr.type.kind === "func") expr.type.params.forEach((type) => box(type)); + break; + case "libCall": + if (expr.fn === "dyn.classBasePrototype") sites.basePrototypes = true; + if (DISPATCH_LIB_CALLS.has(expr.fn)) sites.dispatches = true; + break; + } + return true; + }, + }); + return sites; +} + +function sameSites(left: FunctionSites, right: FunctionSites): boolean { + const sameList = (a: readonly T[], b: readonly T[], same: (x: T, y: T) => boolean): boolean => + a.length === b.length && a.every((item, index) => same(item, b[index]!)); + return ( + sameList(left.values, right.values, (a, b) => a === b) && + sameList( + left.boxing, + right.boxing, + (a, b) => a.type === b.type && a.fieldClass === b.fieldClass, + ) && + sameList(left.thrown, right.thrown, (a, b) => a === b) && + left.serializes === right.serializes && + left.conversions === right.conversions && + left.dispatches === right.dispatches && + left.keyTests === right.keyTests && + left.caughtClassTests === right.caughtClassTests && + left.generatorSteps === right.generatorSteps && + left.runtimeSteps === right.runtimeSteps && + left.basePrototypes === right.basePrototypes && + left.caughtValues === right.caughtValues + ); +} diff --git a/packages/compiler/src/frontend/lowering/generator-dynamic-dispatch.ts b/packages/compiler/src/frontend/lowering/generator-dynamic-dispatch.ts index 3f43e5e05..db542412f 100644 --- a/packages/compiler/src/frontend/lowering/generator-dynamic-dispatch.ts +++ b/packages/compiler/src/frontend/lowering/generator-dynamic-dispatch.ts @@ -13,16 +13,20 @@ import { type IrStmt, type IrType, } from "../../ir/ir.js"; -import { everyStmtList, transformStmtList } from "../../ir/traverse.js"; +import { transformStmtList } from "../../ir/traverse.js"; import { genResultRecord } from "../type-mapper.js"; +import type { DispatchSites } from "./dispatch-sites.js"; import type { Lowerer } from "./lowerer.js"; type GeneratorType = Extract; type Invoke = Extract; type KeyGet = Extract; +/** The generator methods a dynamic call or read steps. */ +export const GENERATOR_STEP_METHODS = new Set(["next", "return", "throw"]); + /** The iterator helper methods the runtime answers on checked iterators. */ -const HELPER_METHODS = new Set([ +export const HELPER_METHODS = new Set([ "map", "filter", "take", @@ -101,6 +105,7 @@ export class GeneratorDynamicDispatch { lowerer: Lowerer, functions: readonly IrFunction[], classHelpers: ReadonlySet, + sites: DispatchSites, ): boolean { const seen = new Set(); const rewrite = new Set(); @@ -117,34 +122,14 @@ export class GeneratorDynamicDispatch { lowerer.shapes.get(type.shapeId)?.fields.forEach((field) => discover(field.type)); else if (type.kind === "union") lowerer.unions.get(type.unionId)?.arms.forEach(discover); }; - for (const fn of functions) - everyStmtList(fn.body, { - stmt: () => true, - expr: (expr) => { - if (expr.kind === "dynFrom") discover(expr.value.type); - if (expr.kind === "dynInvoke" && ["next", "return", "throw"].includes(expr.method)) - rewrite.add(fn); - // The runtime steps the values iterator helpers and destructuring - // receive. - if ( - (expr.kind === "dynInvoke" && HELPER_METHODS.has(expr.method)) || - (expr.kind === "dynKeyGet" && - expr.key.kind === "strLit" && - HELPER_METHODS.has(expr.key.value)) || - expr.kind === "dynIterN" || - (expr.kind === "libCall" && expr.fn === "dyn.destructureRest") - ) - runtimeSteps = true; - if ( - expr.kind === "dynKeyGet" && - expr.key.kind === "strLit" && - (["next", "return", "throw"].includes(expr.key.value) || - HELPER_METHODS.has(expr.key.value)) - ) - rewrite.add(fn); - return true; - }, - }); + for (const fn of functions) { + const found = sites.of(fn); + found.values.forEach(discover); + // The runtime steps the values iterator helpers and destructuring + // receive. + if (found.runtimeSteps) runtimeSteps = true; + if (found.generatorSteps) rewrite.add(fn); + } let changed = false; for (const fn of functions) { // The generator helper's fallback may itself dispatch native classes. @@ -159,7 +144,7 @@ export class GeneratorDynamicDispatch { if ( expr.kind === "dynKeyGet" && expr.key.kind === "strLit" && - (["next", "return", "throw"].includes(expr.key.value) || + (GENERATOR_STEP_METHODS.has(expr.key.value) || (HELPER_METHODS.has(expr.key.value) && this.generators.size > 0)) ) { const method = expr.key.value; @@ -173,8 +158,7 @@ export class GeneratorDynamicDispatch { loc: expr.loc, }; } - if (expr.kind !== "dynInvoke" || !["next", "return", "throw"].includes(expr.method)) - return expr; + if (expr.kind !== "dynInvoke" || !GENERATOR_STEP_METHODS.has(expr.method)) return expr; const key = JSON.stringify([expr.method, expr.args.length, expr.calleeName]); let dispatch = this.dispatches.get(key); if (!dispatch) { diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts index b02a0a843..7a2bfd9e7 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -8231,13 +8231,17 @@ export class Lowerer { for (;;) { drainInstances(); const declared = unitsInOrder(); - const initializerChanged = this.deferredModuleInitializers.process(this, [ - ...declared, - ...initFunctions, - ...instanceFunctions, - ...byName(this.liftedFns), - ...byName(this.implicitFns), - ]); + const initializerChanged = this.deferredModuleInitializers.process( + this, + [ + ...declared, + ...initFunctions, + ...instanceFunctions, + ...byName(this.liftedFns), + ...byName(this.implicitFns), + ], + (fn) => classDispatch.sites.forget(fn), + ); const dispatchChanged = classDispatch.process(this, [ ...declared, ...initFunctions, From ed66338cb6a2e47c7dfd409487b4fd22853973d5 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 09:25:44 -0500 Subject: [PATCH 091/102] Record the order-parity baseline for the byte-mode chunk fence fixture --- .../tests/diagnostics/stream-byte-mode-chunk-fences.ts.json | 6 ++++++ 1 file changed, 6 insertions(+) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/stream-byte-mode-chunk-fences.ts.json diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/stream-byte-mode-chunk-fences.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/stream-byte-mode-chunk-fences.ts.json new file mode 100644 index 000000000..8a02db2be --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/stream-byte-mode-chunk-fences.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/stream-byte-mode-chunk-fences.ts" + ], + "diags": [] +} From 279cdcffae822a41934914bd1f2f71ff4966659f Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 09:39:07 -0500 Subject: [PATCH 092/102] Name source files relative to the entry's directory in structural positions Structural positions started with a file's absolute path, so lowered names (closures, recursive records and unions, and every name keyed by a type that holds one) changed with the directory the program was compiled in. Union arms are ordered by their types' keys, so a program compiled in a new temporary directory could also get its union arms in another order. union-retype.test.ts compiles each program in a fresh temporary directory, and in about one run in ten the arms of the visitor's unions came out in an order where no retag keeps its tags, which failed "lowered identity retags share the box". Positions now name a file by its path relative to the entry's directory (default library files keep their base name), so the same program gets the same names wherever it sits. --- packages/compiler/src/frontend/lowering/lowerer.ts | 10 ++++++---- packages/compiler/test/stable-names.test.ts | 7 +++++++ 2 files changed, 13 insertions(+), 4 deletions(-) diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts index 7a2bfd9e7..747e396af 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -181,7 +181,7 @@ export { newFnCtx, type FnCtx } from "./function-context.js"; * - Lexical scoping is resolved here: locals get function-unique ids * ("x.0", "x.1" for shadowing); the IR is scope-flat. */ -import { dirname, resolve } from "node:path"; +import { dirname, relative, resolve } from "node:path"; import { bindingSource } from "../binding-source.js"; import { tsgoPath } from "../dts-paths.js"; import * as ts from "../ts7/adapter.js"; @@ -3192,12 +3192,14 @@ export class Lowerer { errorPropertyDispatchRevision: string | null = null; /** Structural source positions (structural-positions.ts) for names that * stay the same when unrelated code moves. */ - /** Default library files are named by their base name: two checkers - * install them in different directories. */ + /** Files are named by their path relative to the entry's directory, so + * names do not depend on where the program sits, and default library + * files by their base name: two checkers install them in different + * directories. */ readonly positions = new StructuralPositions((sf) => this.program.isSourceFileDefaultLibrary(sf) ? `lib:${sf.fileName.slice(sf.fileName.lastIndexOf("/") + 1)}` - : sf.fileName, + : relative(dirname(this.entry.fileName), sf.fileName), ); /** The outermost node whose token span is exactly `loc`, or null. */ diff --git a/packages/compiler/test/stable-names.test.ts b/packages/compiler/test/stable-names.test.ts index 720472556..c82db039d 100644 --- a/packages/compiler/test/stable-names.test.ts +++ b/packages/compiler/test/stable-names.test.ts @@ -110,3 +110,10 @@ console.log(box.value); expect(locals).toHaveLength(2); expect(locals[0]!.name).not.toBe(locals[1]!.name); }); + +test("names do not depend on the directory the program sits in", async () => { + // Each call lowers in its own temporary directory. + const [first] = await lower(recursive); + const [second] = await lower(recursive); + expect(names(second!)).toEqual(names(first!)); +}); From 8487742019e824472ad29a96135c2e3553147ca6 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 09:48:41 -0500 Subject: [PATCH 093/102] Read the shared decoded value after an untyped listener, and skip discriminated unions - Once a 'message' listener without a typed entry has decoded the message, the listeners after it read that decoded value, so a typed listener sees what an earlier untyped listener changed, as in Node. - A union with a literal discriminator gets no typed message entry: its checked conversion also tests the discriminator, which the message readers do not. Corpus 7361 checks a typed listener after an untyped one that changes the message, and a listener on a discriminated union. --- packages/compiler/src/backend/llvm/dyn.ts | 8 ++-- ...7361-message-listeners-share-value.ts.json | 6 +++ packages/runtime/src/scr_events_emitter.c | 9 ++-- packages/runtime/src/scr_events_emitter.h | 4 +- .../7361-message-listeners-share-value.ts | 45 +++++++++++++++++++ ...7361-message-listeners-share-value.ts.json | 1 + 6 files changed, 66 insertions(+), 7 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7361-message-listeners-share-value.ts.json create mode 100644 tests/corpus/7361-message-listeners-share-value.ts create mode 100644 tests/harness/corpus-costs/7361-message-listeners-share-value.ts.json diff --git a/packages/compiler/src/backend/llvm/dyn.ts b/packages/compiler/src/backend/llvm/dyn.ts index ac01a9209..5c9d8e60f 100644 --- a/packages/compiler/src/backend/llvm/dyn.ts +++ b/packages/compiler/src/backend/llvm/dyn.ts @@ -4681,8 +4681,8 @@ export class LlDyn { /** Whether a message reader can build T: numbers, booleans and strings; * records of them with only declared fields, none of union type; and - * boxed unions of those arms and null or undefined, with at most one - * number, boolean and string arm. */ + * boxed unions of those arms and null or undefined without a literal + * discriminator, with at most one number, boolean and string arm. */ private messageReadable(t: IrType, seen: Set): boolean { switch (t.kind) { case "f64": @@ -4706,7 +4706,9 @@ export class LlDyn { } case "union": { const def = this.host.unionsById.get(t.unionId); - if (!def || this.host.nullableUnions.has(t.unionId)) return false; + // A discriminated union's checked conversion also tests the arm's + // literal discriminator, which the readers do not. + if (!def || def.discriminant || this.host.nullableUnions.has(t.unionId)) return false; const scalars = new Set(); for (const arm of def.arms) { if (arm.kind === "nullT" || arm.kind === "undefinedT") continue; diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7361-message-listeners-share-value.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7361-message-listeners-share-value.ts.json new file mode 100644 index 000000000..f6a78ee9a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7361-message-listeners-share-value.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7361-message-listeners-share-value.ts" + ], + "diags": [] +} diff --git a/packages/runtime/src/scr_events_emitter.c b/packages/runtime/src/scr_events_emitter.c index 5e03c0d6c..93a724ecb 100644 --- a/packages/runtime/src/scr_events_emitter.c +++ b/packages/runtime/src/scr_events_emitter.c @@ -1049,8 +1049,8 @@ SCR_COLD static void scr_ee_listener_mismatch(const ScrStr *name, bool typed_emi } /* A message emit (scr_emitter_emit_message): listeners with a typed message - * entry read the message; the others share one decoded argument, made when - * the first of them runs. */ + * entry read the message until a listener without one runs; that listener + * and every later one share one decoded argument. */ struct ScrEeMessage { const struct ScrMessage *message; ScrDyn *(*decode)(const struct ScrMessage *); @@ -1101,7 +1101,10 @@ static bool scr_ee_emit_core(ScrEmitter *em, ScrStr *name, va_list *ap_template, continue; } } - if (message && e->flex_message && e->flex_message(e->flex_cb, message->message)) { + /* Once a listener has the decoded value, later listeners read that + * value: an earlier listener may have changed it, as in Node. */ + if (message && !message->decoded && e->flex_message && + e->flex_message(e->flex_cb, message->message)) { scr_ee_entry_unref(e); continue; } diff --git a/packages/runtime/src/scr_events_emitter.h b/packages/runtime/src/scr_events_emitter.h index 6e1ef536a..29d4c397f 100644 --- a/packages/runtime/src/scr_events_emitter.h +++ b/packages/runtime/src/scr_events_emitter.h @@ -156,7 +156,9 @@ bool scr_emitter_emit(ScrEmitter *em, ScrStr *name, ...); bool scr_emitter_emit_flex(ScrEmitter *em, ScrStr *name, ScrDyn *const *args, size_t argc); /* An untyped emit of one message: a listener registered from a function * box with a typed message entry (scr_dyn_func_set_message) reads the - * message itself; the other listeners get decode(message), made once. */ + * message itself while no listener has needed the decoded value; from the + * first listener without an entry on, every listener gets decode(message), + * made once. */ struct ScrMessage; bool scr_emitter_emit_message(ScrEmitter *em, ScrStr *name, const struct ScrMessage *message, ScrDyn *(*decode)(const struct ScrMessage *)); diff --git a/tests/corpus/7361-message-listeners-share-value.ts b/tests/corpus/7361-message-listeners-share-value.ts new file mode 100644 index 000000000..2a4e287df --- /dev/null +++ b/tests/corpus/7361-message-listeners-share-value.ts @@ -0,0 +1,45 @@ +import { MessageChannel, type MessagePort } from "node:worker_threads"; + +// Listeners of one message share its value, as in Node: a typed listener +// that runs after an untyped one sees the changes the untyped one made, +// and a listener on a discriminated union reads the arm its discriminator +// names. +type Item = { id: number; name: string }; +type Shape = { kind: "circle"; size: number } | { kind: "square"; size: number; corner: string }; + +const lines: string[] = []; +let pending = 0; +const ports: MessagePort[] = []; +function finish(): void { + if (--pending > 0) return; + for (const line of lines) console.log(line); + for (const port of ports) port.close(); +} + +const shared = new MessageChannel(); +ports.push(shared.port1); +shared.port1.on("message", (value: Item) => { + lines.push(`typed first ${value.id} ${value.name}`); +}); +shared.port1.on("message", (value: any) => { + value.id = value.id * 10; + value.name = `${value.name}!`; +}); +shared.port1.on("message", (value: Item) => { + lines.push(`typed after ${value.id} ${value.name}`); + finish(); +}); +pending += 2; +shared.port2.postMessage({ id: 1, name: "a" }); +shared.port2.postMessage({ id: 2, name: "b" }); + +const shapes = new MessageChannel(); +ports.push(shapes.port1); +shapes.port1.on("message", (shape: Shape) => { + if (shape.kind === "circle") lines.push(`circle ${shape.size}`); + else lines.push(`square ${shape.size} ${shape.corner}`); + finish(); +}); +pending += 2; +shapes.port2.postMessage({ kind: "circle", size: 3 }); +shapes.port2.postMessage({ kind: "square", size: 4, corner: "round" }); diff --git a/tests/harness/corpus-costs/7361-message-listeners-share-value.ts.json b/tests/harness/corpus-costs/7361-message-listeners-share-value.ts.json new file mode 100644 index 000000000..c428eb8f1 --- /dev/null +++ b/tests/harness/corpus-costs/7361-message-listeners-share-value.ts.json @@ -0,0 +1 @@ +{ "plain": 3000, "san": 4600 } From ddf7eb8a2bc226e215a9795f51cf3ac747c57572 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 09:50:32 -0500 Subject: [PATCH 094/102] Check with tsc-ts 0.0.7 and batch contextual types and signatures tsc-ts 0.0.7 answers getContextualTypes and getResolvedSignatures, so NODE_BATCH_QUERIES is on: lowering asks the checker for the contextual types of identity-flow sites, array literals and conditionals, and the resolved signatures of calls, in batches instead of node by node. The release-age exclusions move to tsc-ts 0.0.7 and its platform packages, and add @scriptc/threads 0.4.1, which tsc-ts 0.0.7 depends on. --- packages/compiler/package.json | 2 +- .../src/frontend/ts7/semantic-checker.ts | 9 +- pnpm-lock.yaml | 138 +++++++++--------- pnpm-workspace.yaml | 17 ++- 4 files changed, 83 insertions(+), 83 deletions(-) diff --git a/packages/compiler/package.json b/packages/compiler/package.json index 98d984d4f..a283f821a 100644 --- a/packages/compiler/package.json +++ b/packages/compiler/package.json @@ -40,7 +40,7 @@ }, "dependencies": { "@scriptc/runtime": "workspace:*", - "tsc-ts": "0.0.5", + "tsc-ts": "0.0.7", "typescript": "7.0.2", "typescript5": "npm:typescript@5.9.3" }, diff --git a/packages/compiler/src/frontend/ts7/semantic-checker.ts b/packages/compiler/src/frontend/ts7/semantic-checker.ts index d1d42c6e1..e7e6b408d 100644 --- a/packages/compiler/src/frontend/ts7/semantic-checker.ts +++ b/packages/compiler/src/frontend/ts7/semantic-checker.ts @@ -97,11 +97,10 @@ export interface SemanticCompletion { } /** Whether lowering asks the checker for contextual types and resolved - * signatures in batches (`getContextualTypes`, `getResolvedSignatures`). - * Off until scriptc depends on a tsc-ts release that answers them: the - * batch prefetches (checker.ts) then do nothing and lowering asks node by - * node. */ -export const NODE_BATCH_QUERIES = false; + * signatures in batches (`getContextualTypes`, `getResolvedSignatures`, + * answered from tsc-ts 0.0.7 on). Off, the batch prefetches (checker.ts) do + * nothing and lowering asks node by node. */ +export const NODE_BATCH_QUERIES = true; /** The pinned checker's request surface over native objects. Every query * converges on the same snapshot/project registries, including batch and diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 2404c3885..589de2a51 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -55,7 +55,7 @@ importers: version: 5.9.3 vercel: specifier: 58.1.0 - version: 58.1.0(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3)(rollup@4.62.2) + version: 58.1.0(@emnapi/core@1.11.3)(@emnapi/runtime@1.11.3)(rollup@4.62.2) vitest: specifier: ^3.0.0 version: 3.2.7(patch_hash=03a418fae669c2cd9846dc3c49e6c1b8ee7047bbdcda9d4f5d5ee09eb525a1be)(@edge-runtime/vm@3.2.0)(@types/node@24.13.3)(tsx@4.23.0) @@ -110,8 +110,8 @@ importers: specifier: workspace:* version: link:../runtime tsc-ts: - specifier: 0.0.5 - version: 0.0.5 + specifier: 0.0.7 + version: 0.0.7 typescript: specifier: 7.0.2 version: 7.0.2 @@ -271,14 +271,14 @@ packages: effect: ^4.0.0 redis: '>=5.0.0 <7.0.0' - '@emnapi/core@2.0.0-alpha.3': - resolution: {integrity: sha512-AZypUeJ/yByuxyS7BlSNRDOMLMlROYtjYdIAuBmJssVz1UJDSeYxLrdizhXCFYhedC5bqd/ASy8EuNXbVVXp9g==} + '@emnapi/core@1.11.3': + resolution: {integrity: sha512-zLpS5asjEb7lq8jYLq37N6XKaE41DIexlY1rF/z4/tIl3wo13Sqm28fRyfIsKZD+NZ8mM5RoKkpW/rBcuoSZSg==} - '@emnapi/runtime@2.0.0-alpha.3': - resolution: {integrity: sha512-hFPAhMUjJD9BSyCANEISPOogeXC9Zo9ZQl7L6vKnaVsMkCtzznaW/naYypeyl0Gv5rYfWYsZbpixTMpjDJzQeA==} + '@emnapi/runtime@1.11.3': + resolution: {integrity: sha512-Xz4Tpyki7XyrpbUK1jR1AhdAdaXyhhY4lZ3neLodmhpuWfy2PAQN5B46sAiU4liOXGLkHypn/qU+jvfWSCYYLA==} - '@emnapi/wasi-threads@2.0.1': - resolution: {integrity: sha512-9DsSk+o5NBX0CCJT8s0EROGSGxjR/tKu6aBTaVyq+SjAEQH4XcdcRxPBRzsBLizTTJ49MJjF+jgu3qnO9GLQcQ==} + '@emnapi/wasi-threads@1.2.3': + resolution: {integrity: sha512-ELEBe8PsLvvJ6QMr0zLt8ffvOHW/dc1m3CEzNMg7aJUv3bMaoDtw2TXyDAwkYBuroxxuHEwhRTLJSe5sya547g==} '@esbuild/aix-ppc64@0.27.0': resolution: {integrity: sha512-KuZrd2hRjz01y5JK9mEBSD3Vj3mbCvemhT466rSuJYeE/hjuBrHfjjcjMdTm/sz7au+++sdbJZJmuBwQLuw68A==} @@ -1360,8 +1360,8 @@ packages: cpu: [x64] os: [win32] - '@scriptc/threads@0.3.6': - resolution: {integrity: sha512-XZb4JhXM/ivhx4MMLxqLLF2mCI28nUK+VVKlCnELO83tacUuGlq7YCe/8LwvzO7fZwy/rCH4+genAYYEc6BF6Q==} + '@scriptc/threads@0.4.1': + resolution: {integrity: sha512-wKgEBiVc07ZIGNFGwJpV5JbTXJN1N42qG6/g7ipnwt3klsU0nuWH2ToKV9vYH+RQstF7+twq6zMCf2qhUloTHQ==} engines: {node: '>=24.0.0'} '@sinclair/typebox@0.25.24': @@ -1377,42 +1377,42 @@ packages: '@ts-morph/common@0.11.1': resolution: {integrity: sha512-7hWZS0NRpEsNV8vWJzg7FEz6V8MaLNeJOmwmghqUXTpzk16V1LLZhdo+4QvE/+zv4cVci0OviuJFnqhEfoV3+g==} - '@tsc-ts/darwin-arm64@0.0.5': - resolution: {integrity: sha512-yP64b2VpAKWG92KepBqxs1P89wpwiheYwNMk4EmmhSl6aw/ImIBrdHYNjvao3sg6FHZCXTc+PB6Vukh6hyQiJQ==} + '@tsc-ts/darwin-arm64@0.0.7': + resolution: {integrity: sha512-nIaTJKBpG6n60xxRYfBlh02G6aSO2punIvj4qPy8/CXZu0Kw4ra/J3PYJtrtYMIh/eIGo4+f1Q01v5dFPPwZbw==} cpu: [arm64] os: [darwin] - '@tsc-ts/darwin-x64@0.0.5': - resolution: {integrity: sha512-CEeHOFfpx5H9V3WSq+V7XGU8tfc06nRN818auiRVwuwPHvpti9gHq0HYkvf/43PH1pIGcgf68sQYdIxJhrQDKQ==} + '@tsc-ts/darwin-x64@0.0.7': + resolution: {integrity: sha512-8ITDyF3FG4SYeS1cV4+oRpbbk0jVsfd23Ww138wbQymbOLYjWPafzj4bymxnIE5kEWjZPVqTFDbaYqgWwNStag==} cpu: [x64] os: [darwin] - '@tsc-ts/linux-arm64-gnu@0.0.5': - resolution: {integrity: sha512-qwybOqGDEa35eV9x/3WO81ExAUbUMY8288ATC83kUfYGmOAVStaO+JM2IdrsiI8hLWVC7/f0RFgZ+7dyWh9/nA==} + '@tsc-ts/linux-arm64-gnu@0.0.7': + resolution: {integrity: sha512-nXGjtbM3YrARWOb+nkDaFdhKGSzPf3ofl/gV4x8JnVQ8SgK4IWJ5J0u93sk3mTYgdLj/Gcobp/D3lZ6WIzjKvA==} cpu: [arm64] os: [linux] libc: [glibc] - '@tsc-ts/linux-arm64-musl@0.0.5': - resolution: {integrity: sha512-6oSw3NbQIrnxxCRuEe190MbMFoOrM+P+u1usascQMgSjsMcVRnJ/ztvTnRrCDtfPEHJ5EC8drgWIpcdrhGsB0w==} + '@tsc-ts/linux-arm64-musl@0.0.7': + resolution: {integrity: sha512-hSjpQsOhrLaDsbvEO5EH9nC3Vy0WAt3aB+GejytEh9fl4F3kT0BasbBP4wJqu6S5SG9upLW7ZClXiNVnGYDGlQ==} cpu: [arm64] os: [linux] libc: [musl] - '@tsc-ts/linux-x64-gnu@0.0.5': - resolution: {integrity: sha512-KrlBLUcG7M6p7lN+ke+kHVLqy7IiY/H0FxFZzq5slXanhrps/BfjdkUahsyREg7KVprr08xFuXqJTBtLEI4eow==} + '@tsc-ts/linux-x64-gnu@0.0.7': + resolution: {integrity: sha512-MCU2MFefQGG/++nepg09BtYnsN2mVzeYfIS6GW30ChxUt2nJUMkEvzbDim9czDevW4LRqHgfnwEt+hs2ud1SDQ==} cpu: [x64] os: [linux] libc: [glibc] - '@tsc-ts/linux-x64-musl@0.0.5': - resolution: {integrity: sha512-fr8yGzkocCcTYoE+NwC+/WGPNteQ2GmOPJTy/z9NcsLchnpSIZ1fzFll15UYPKQlwQdNRJXxKK3npVBtLRdHTg==} + '@tsc-ts/linux-x64-musl@0.0.7': + resolution: {integrity: sha512-abTZZkn74772MPABStuXWJ1GHI07nbEf4a3Nwl7NYI5mLFYxeLSbq6+cGh0BUJeBeMhFNsjtQ5/j5sGmsrJ2tg==} cpu: [x64] os: [linux] libc: [musl] - '@tsc-ts/win32-x64-msvc@0.0.5': - resolution: {integrity: sha512-SQwufJafzsiOBYncHOxYkyELWjLlBijcKB+xOs6hr6Lxxp5MMLoPtvDFNG88c7G5xv2TDb1XbvyxnjQltr6SHw==} + '@tsc-ts/win32-x64-msvc@0.0.7': + resolution: {integrity: sha512-EOhLTkuWYytJYklR5BI1jRtTpEIPh1FQJKD8R37qqlcnPrELlRO6Nc2ncDpdCoYbpN+KrewIVPB3xD4o3VGUaw==} cpu: [x64] os: [win32] @@ -2577,8 +2577,8 @@ packages: ts-toolbelt@6.15.5: resolution: {integrity: sha512-FZIXf1ksVyLcfr7M317jbB67XFJhOO1YqdTcuGaq9q5jLUoTikukZ+98TPjKiP2jC5CgmYdWWYs0s2nLSU0/1A==} - tsc-ts@0.0.5: - resolution: {integrity: sha512-Eea+zNv7y696pqNZtXBd0AX7/6PXIhR7aaEb0EhgpHadbk7VEiURD94/NngeLpYWts2tPjetkpwFLJY0+6yOnQ==} + tsc-ts@0.0.7: + resolution: {integrity: sha512-KRWTXRUvwMXi4At6xOWPDa/0BreY3MR2tPHooEMNWLZUA2eLphNe7PJiHclPLLn9RCnHY4ffDTTeF5hqgyBvtA==} engines: {node: '>=20'} hasBin: true @@ -2840,18 +2840,18 @@ snapshots: - bufferutil - utf-8-validate - '@emnapi/core@2.0.0-alpha.3': + '@emnapi/core@1.11.3': dependencies: - '@emnapi/wasi-threads': 2.0.1 + '@emnapi/wasi-threads': 1.2.3 tslib: 2.8.1 optional: true - '@emnapi/runtime@2.0.0-alpha.3': + '@emnapi/runtime@1.11.3': dependencies: tslib: 2.8.1 optional: true - '@emnapi/wasi-threads@2.0.1': + '@emnapi/wasi-threads@1.2.3': dependencies: tslib: 2.8.1 optional: true @@ -3090,10 +3090,10 @@ snapshots: '@napi-rs/keyring-win32-ia32-msvc': 1.2.0 '@napi-rs/keyring-win32-x64-msvc': 1.2.0 - '@napi-rs/wasm-runtime@1.1.6(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3)': + '@napi-rs/wasm-runtime@1.1.6(@emnapi/core@1.11.3)(@emnapi/runtime@1.11.3)': dependencies: - '@emnapi/core': 2.0.0-alpha.3 - '@emnapi/runtime': 2.0.0-alpha.3 + '@emnapi/core': 1.11.3 + '@emnapi/runtime': 1.11.3 '@tybys/wasm-util': 0.10.3 optional: true @@ -3159,9 +3159,9 @@ snapshots: '@oxc-transform/binding-openharmony-arm64@0.111.0': optional: true - '@oxc-transform/binding-wasm32-wasi@0.111.0(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3)': + '@oxc-transform/binding-wasm32-wasi@0.111.0(@emnapi/core@1.11.3)(@emnapi/runtime@1.11.3)': dependencies: - '@napi-rs/wasm-runtime': 1.1.6(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3) + '@napi-rs/wasm-runtime': 1.1.6(@emnapi/core@1.11.3)(@emnapi/runtime@1.11.3) transitivePeerDependencies: - '@emnapi/core' - '@emnapi/runtime' @@ -3340,9 +3340,9 @@ snapshots: '@rolldown/binding-openharmony-arm64@1.0.0-rc.1': optional: true - '@rolldown/binding-wasm32-wasi@1.0.0-rc.1(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3)': + '@rolldown/binding-wasm32-wasi@1.0.0-rc.1(@emnapi/core@1.11.3)(@emnapi/runtime@1.11.3)': dependencies: - '@napi-rs/wasm-runtime': 1.1.6(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3) + '@napi-rs/wasm-runtime': 1.1.6(@emnapi/core@1.11.3)(@emnapi/runtime@1.11.3) transitivePeerDependencies: - '@emnapi/core' - '@emnapi/runtime' @@ -3439,7 +3439,7 @@ snapshots: '@rollup/rollup-win32-x64-msvc@4.62.2': optional: true - '@scriptc/threads@0.3.6': {} + '@scriptc/threads@0.4.1': {} '@sinclair/typebox@0.25.24': {} @@ -3454,25 +3454,25 @@ snapshots: mkdirp: 1.0.4 path-browserify: 1.0.1 - '@tsc-ts/darwin-arm64@0.0.5': + '@tsc-ts/darwin-arm64@0.0.7': optional: true - '@tsc-ts/darwin-x64@0.0.5': + '@tsc-ts/darwin-x64@0.0.7': optional: true - '@tsc-ts/linux-arm64-gnu@0.0.5': + '@tsc-ts/linux-arm64-gnu@0.0.7': optional: true - '@tsc-ts/linux-arm64-musl@0.0.5': + '@tsc-ts/linux-arm64-musl@0.0.7': optional: true - '@tsc-ts/linux-x64-gnu@0.0.5': + '@tsc-ts/linux-x64-gnu@0.0.7': optional: true - '@tsc-ts/linux-x64-musl@0.0.5': + '@tsc-ts/linux-x64-musl@0.0.7': optional: true - '@tsc-ts/win32-x64-msvc@0.0.5': + '@tsc-ts/win32-x64-msvc@0.0.7': optional: true '@tybys/wasm-util@0.10.3': @@ -3563,7 +3563,7 @@ snapshots: '@typescript/typescript-win32-x64@7.0.2': optional: true - '@vercel/backends@0.8.27(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3)(rollup@4.62.2)': + '@vercel/backends@0.8.27(@emnapi/core@1.11.3)(@emnapi/runtime@1.11.3)(rollup@4.62.2)': dependencies: '@vercel/build-utils': 13.36.0 '@vercel/nft': 1.10.0(rollup@4.62.2) @@ -3571,10 +3571,10 @@ snapshots: execa: 3.2.0 fs-extra: 11.1.0 get-port: 5.1.1 - oxc-transform: 0.111.0(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3) + oxc-transform: 0.111.0(@emnapi/core@1.11.3)(@emnapi/runtime@1.11.3) path-to-regexp: 8.3.0 resolve.exports: 2.0.3 - rolldown: 1.0.0-rc.1(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3) + rolldown: 1.0.0-rc.1(@emnapi/core@1.11.3)(@emnapi/runtime@1.11.3) srvx: 0.11.16 ts-morph: 12.0.0 tsx: 4.21.0 @@ -3600,9 +3600,9 @@ snapshots: cjs-module-lexer: 1.2.3 es-module-lexer: 1.5.0 - '@vercel/cervel@0.1.35(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3)(rollup@4.62.2)': + '@vercel/cervel@0.1.35(@emnapi/core@1.11.3)(@emnapi/runtime@1.11.3)(rollup@4.62.2)': dependencies: - '@vercel/backends': 0.8.27(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3)(rollup@4.62.2) + '@vercel/backends': 0.8.27(@emnapi/core@1.11.3)(@emnapi/runtime@1.11.3)(rollup@4.62.2) transitivePeerDependencies: - '@emnapi/core' - '@emnapi/runtime' @@ -3638,9 +3638,9 @@ snapshots: '@vercel/error-utils@2.2.0': {} - '@vercel/express@0.1.118(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3)(rollup@4.62.2)': + '@vercel/express@0.1.118(@emnapi/core@1.11.3)(@emnapi/runtime@1.11.3)(rollup@4.62.2)': dependencies: - '@vercel/cervel': 0.1.35(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3)(rollup@4.62.2) + '@vercel/cervel': 0.1.35(@emnapi/core@1.11.3)(@emnapi/runtime@1.11.3)(rollup@4.62.2) '@vercel/nft': 1.10.0(rollup@4.62.2) '@vercel/node': 5.9.0(rollup@4.62.2) '@vercel/static-config': 3.4.0 @@ -4442,7 +4442,7 @@ snapshots: os-paths@4.4.0: {} - oxc-transform@0.111.0(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3): + oxc-transform@0.111.0(@emnapi/core@1.11.3)(@emnapi/runtime@1.11.3): optionalDependencies: '@oxc-transform/binding-android-arm-eabi': 0.111.0 '@oxc-transform/binding-android-arm64': 0.111.0 @@ -4460,7 +4460,7 @@ snapshots: '@oxc-transform/binding-linux-x64-gnu': 0.111.0 '@oxc-transform/binding-linux-x64-musl': 0.111.0 '@oxc-transform/binding-openharmony-arm64': 0.111.0 - '@oxc-transform/binding-wasm32-wasi': 0.111.0(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3) + '@oxc-transform/binding-wasm32-wasi': 0.111.0(@emnapi/core@1.11.3)(@emnapi/runtime@1.11.3) '@oxc-transform/binding-win32-arm64-msvc': 0.111.0 '@oxc-transform/binding-win32-ia32-msvc': 0.111.0 '@oxc-transform/binding-win32-x64-msvc': 0.111.0 @@ -4604,7 +4604,7 @@ snapshots: reusify@1.1.0: {} - rolldown@1.0.0-rc.1(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3): + rolldown@1.0.0-rc.1(@emnapi/core@1.11.3)(@emnapi/runtime@1.11.3): dependencies: '@oxc-project/types': 0.110.0 '@rolldown/pluginutils': 1.0.0-rc.1 @@ -4619,7 +4619,7 @@ snapshots: '@rolldown/binding-linux-x64-gnu': 1.0.0-rc.1 '@rolldown/binding-linux-x64-musl': 1.0.0-rc.1 '@rolldown/binding-openharmony-arm64': 1.0.0-rc.1 - '@rolldown/binding-wasm32-wasi': 1.0.0-rc.1(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3) + '@rolldown/binding-wasm32-wasi': 1.0.0-rc.1(@emnapi/core@1.11.3)(@emnapi/runtime@1.11.3) '@rolldown/binding-win32-arm64-msvc': 1.0.0-rc.1 '@rolldown/binding-win32-x64-msvc': 1.0.0-rc.1 transitivePeerDependencies: @@ -4813,17 +4813,17 @@ snapshots: ts-toolbelt@6.15.5: {} - tsc-ts@0.0.5: + tsc-ts@0.0.7: dependencies: - '@scriptc/threads': 0.3.6 + '@scriptc/threads': 0.4.1 optionalDependencies: - '@tsc-ts/darwin-arm64': 0.0.5 - '@tsc-ts/darwin-x64': 0.0.5 - '@tsc-ts/linux-arm64-gnu': 0.0.5 - '@tsc-ts/linux-arm64-musl': 0.0.5 - '@tsc-ts/linux-x64-gnu': 0.0.5 - '@tsc-ts/linux-x64-musl': 0.0.5 - '@tsc-ts/win32-x64-msvc': 0.0.5 + '@tsc-ts/darwin-arm64': 0.0.7 + '@tsc-ts/darwin-x64': 0.0.7 + '@tsc-ts/linux-arm64-gnu': 0.0.7 + '@tsc-ts/linux-arm64-musl': 0.0.7 + '@tsc-ts/linux-x64-gnu': 0.0.7 + '@tsc-ts/linux-x64-musl': 0.0.7 + '@tsc-ts/win32-x64-msvc': 0.0.7 tslib@2.8.1: optional: true @@ -4894,9 +4894,9 @@ snapshots: dependencies: punycode: 2.3.1 - vercel@58.1.0(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3)(rollup@4.62.2): + vercel@58.1.0(@emnapi/core@1.11.3)(@emnapi/runtime@1.11.3)(rollup@4.62.2): dependencies: - '@vercel/backends': 0.8.27(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3)(rollup@4.62.2) + '@vercel/backends': 0.8.27(@emnapi/core@1.11.3)(@emnapi/runtime@1.11.3)(rollup@4.62.2) '@vercel/blob': 2.4.0 '@vercel/build-utils': 13.36.0 '@vercel/cli-auth': 0.3.1 @@ -4904,7 +4904,7 @@ snapshots: '@vercel/container': 0.1.0 '@vercel/detect-agent': 1.2.3 '@vercel/elysia': 0.1.104(rollup@4.62.2) - '@vercel/express': 0.1.118(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3)(rollup@4.62.2) + '@vercel/express': 0.1.118(@emnapi/core@1.11.3)(@emnapi/runtime@1.11.3)(rollup@4.62.2) '@vercel/fastify': 0.1.107(rollup@4.62.2) '@vercel/fun': 1.3.0 '@vercel/go': 3.10.2 diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml index a3e992b0a..ceb1506e9 100644 --- a/pnpm-workspace.yaml +++ b/pnpm-workspace.yaml @@ -7,14 +7,15 @@ minimumReleaseAgeExclude: - "effect@4.0.0" - "@effect/platform-node@4.0.0" - "@effect/platform-node-shared@4.0.0" - - "@tsc-ts/darwin-arm64@0.0.5" - - "@tsc-ts/darwin-x64@0.0.5" - - "@tsc-ts/linux-arm64-gnu@0.0.5" - - "@tsc-ts/linux-arm64-musl@0.0.5" - - "@tsc-ts/linux-x64-gnu@0.0.5" - - "@tsc-ts/linux-x64-musl@0.0.5" - - "@tsc-ts/win32-x64-msvc@0.0.5" - - "tsc-ts@0.0.5" + - "@tsc-ts/darwin-arm64@0.0.7" + - "@tsc-ts/darwin-x64@0.0.7" + - "@tsc-ts/linux-arm64-gnu@0.0.7" + - "@tsc-ts/linux-arm64-musl@0.0.7" + - "@tsc-ts/linux-x64-gnu@0.0.7" + - "@tsc-ts/linux-x64-musl@0.0.7" + - "@tsc-ts/win32-x64-msvc@0.0.7" + - "tsc-ts@0.0.7" + - "@scriptc/threads@0.4.1" allowBuilds: esbuild: true overrides: From cd2b1e2574ca8fde0f8516d7b8800a861246c312 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 09:55:01 -0500 Subject: [PATCH 095/102] Keep callback loop versions from nesting A callback loop version emits its loop twice. A loop inside either copy could be versioned again, so a nest of loops that each call a callback built just before them (`const g = adder(i)`) doubled at every level: a three-deep nest was emitted seven times per function. A loop inside a callback version, or the versioned loop itself emitted again for each copy, is no longer versioned, so a loop nest is emitted at most twice. The outer loop keeps its version; inner loops keep their calls as they are. --- .../src/backend/llvm/emit-statements.ts | 17 +++++----- .../test/callback-loop-versions.test.ts | 31 +++++++++++++++++++ 2 files changed, 38 insertions(+), 10 deletions(-) diff --git a/packages/compiler/src/backend/llvm/emit-statements.ts b/packages/compiler/src/backend/llvm/emit-statements.ts index ffd47c467..4fe1a27bd 100644 --- a/packages/compiler/src/backend/llvm/emit-statements.ts +++ b/packages/compiler/src/backend/llvm/emit-statements.ts @@ -1910,9 +1910,11 @@ export function emitSwitch(emitter: LlEmitter, s: IrStmt & { kind: "switch" }): /** The loop copies a callback loop version needs: the bindings the loop * calls that the constant-callback census resolves to one function, each * with that function's direct entry. Only small loops of optimized - * synchronous functions, and only bindings declared before the loop that - * an enclosing version has not already proved, qualify: the guard reads - * each binding before the loop runs. */ + * synchronous functions, and only bindings declared before the loop, + * qualify: the guard reads each binding before the loop runs. Versions do + * not nest: a loop inside either copy of a version (including the + * versioned loop itself, emitted again for each copy) keeps its calls as + * they are, so a loop nest is emitted at most twice. */ function callbackVersionBindings( emitter: LlEmitter, s: IrStmt & { kind: "for" | "while" | "doWhile" }, @@ -1920,7 +1922,7 @@ function callbackVersionBindings( if ( !emitter.callbackVersionsEnabled || emitter.currentConstantCallbacks.size === 0 || - emitter.callbackVersioning.has(s) + emitter.callbackVersioning.size > 0 ) return null; const found = new Map(); @@ -1930,12 +1932,7 @@ function callbackVersionBindings( const expr = (e: IrExpr): boolean => { if (++cost > MAX_CALLBACK_VERSION_COST) return false; if (e.kind === "assignExpr") bound.add(e.localId); - if ( - e.kind === "callValue" && - e.callee.kind === "varRef" && - !emitter.knownCallbacks.has(e.callee.localId) && - !found.has(e.callee.localId) - ) { + if (e.kind === "callValue" && e.callee.kind === "varRef" && !found.has(e.callee.localId)) { const local = emitter.currentLocals.get(e.callee.localId); const target = local && local.tdz !== true ? emitter.knownCallbackTarget(e.callee) : undefined; diff --git a/packages/compiler/test/callback-loop-versions.test.ts b/packages/compiler/test/callback-loop-versions.test.ts index c26abe1c4..63a669fd4 100644 --- a/packages/compiler/test/callback-loop-versions.test.ts +++ b/packages/compiler/test/callback-loop-versions.test.ts @@ -81,3 +81,34 @@ test("a callback declared in the loop body is not read before the loop", async ( `); expect(llvm).not.toContain("callback.version"); }); + +test("loops inside a callback version are not versioned again", async () => { + // Each inner loop calls a callback a factory builds just before it; without + // the limit, every copy of a version would version the next loop again. + const llvm = await emitLlvm(` + function adder(k: number): (v: number) => number { + return (v: number) => v + k; + } + function nest(n: number, f: (v: number) => number): number { + let s = 0; + for (let i = 0; i < n; i++) { + s += f(i); + const g = adder(i); + for (let j = 0; j < n; j++) { + s += g(j); + const h = adder(j); + for (let k = 0; k < n; k++) s += h(k); + } + } + return s; + } + console.log(nest(3, (v) => v - 1), nest(2, (v) => v * 3)); + `); + // One version for the outer loop of each compiled `nest`; its two copies + // keep the inner loops whole. + const versions = [...llvm.matchAll(/^define [^\n]*@sc_bf_nest[^]*?^}/gm)].map( + ([body]) => body.match(/^callback\.version\.fast\d+:$/gm)?.length ?? 0, + ); + expect(versions.every((count) => count <= 1)).toBe(true); + expect(versions.some((count) => count === 1)).toBe(true); +}); From b82c70d5de2853a368f13edb96ced5f14061fe2e Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 09:56:19 -0500 Subject: [PATCH 096/102] Bound a follower's trip count only by a safe-integer span The trip count that bounds a follower's range was the driver's span over its step, computed in doubles. A span above 2^53 - 1 can round down: from -(2^53 - 1) to below 2^52 - 1 the span 3 * 2^52 - 3 becomes 3 * 2^52 - 4, so a follower that reaches 2^53 got the range limit 2^53 - 1 and ran as an unchecked integer. Such a span now bounds no trip count, and the follower is tested at run time (or the loop is refused when every value is known). Below it the quotient rounds to at least its floor, and the follower's products and sums are exact within the safe range. --- packages/compiler/src/ir/integer-loops.test.ts | 16 ++++++++++++++++ packages/compiler/src/ir/integer-loops.ts | 10 ++++++---- 2 files changed, 22 insertions(+), 4 deletions(-) diff --git a/packages/compiler/src/ir/integer-loops.test.ts b/packages/compiler/src/ir/integer-loops.test.ts index e1453abad..b6ac27e3a 100644 --- a/packages/compiler/src/ir/integer-loops.test.ts +++ b/packages/compiler/src/ir/integer-loops.test.ts @@ -525,4 +525,20 @@ test("counters stepped beside the tested one run as integers", () => { boxed.set("j", { ...vars.get("j")!, boxed: true }); expect(matchIntegerCountedForLoop(comoving(number(10)), boxed)).toBeNull(); expect(matchIntegerCountedForLoop(comoving(number(10), ref("i")), vars)).toBeNull(); + // A driver span above 2^53 - 1 bounds no trip count. From -(2^53 - 1) to + // below 2^52 - 1 the span 3 * 2^52 - 3 rounds down to 3 * 2^52 - 4, which + // would put this follower's last value at 2^53 - 1 instead of 2^53. + const wide = comoving(number(2 ** 52 - 1), number(-(2 ** 52) + 3), { + kind: "block", + body: [step("i", "+"), step("j", "+")], + loc, + }); + if (wide.init?.kind === "block" && wide.init.body[0]?.kind === "varDecl") + wide.init.body[0].init = number(-Number.MAX_SAFE_INTEGER); + expect(matchIntegerCountedForLoop(wide, vars)).toBeNull(); + if (wide.init?.kind === "block" && wide.init.body[1]?.kind === "varDecl") + wide.init.body[1].init = ref("from"); + expect(matchIntegerCountedForLoop(wide, vars)?.followers).toMatchObject([ + { startGuarded: true, tripGuarded: true }, + ]); }); diff --git a/packages/compiler/src/ir/integer-loops.ts b/packages/compiler/src/ir/integer-loops.ts index c4cdc327c..c451c0852 100644 --- a/packages/compiler/src/ir/integer-loops.ts +++ b/packages/compiler/src/ir/integer-loops.ts @@ -269,10 +269,12 @@ export function matchIntegerCountedForLoop( }; // On body entry k the driver holds `start + step * k`, so k is at most the // driver's span over |step|, and a follower holds its start plus its own - // step times k. - const trips = Math.floor( - (step > 0 ? range.max - startRange.min : startRange.max - range.min) / Math.abs(step), - ); + // step times k. A span above 2^53 - 1 can round down, so it bounds no + // trip count. Below it the quotient rounds to at least its floor, and the + // follower's products and sums below are exact while they stay within + // ±(2^53 - 1) and round outside it otherwise. + const span = step > 0 ? range.max - startRange.min : startRange.max - range.min; + const trips = span <= Number.MAX_SAFE_INTEGER ? Math.floor(span / Math.abs(step)) : Infinity; const followers: IntegerLoopFollower[] = []; for (const id of counterIds) { if (id === local.id) continue; From ca579641a45bebcd629b2081b101233613375596 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 10:04:30 -0500 Subject: [PATCH 097/102] Index quoted get: and set: method names under their own keys --- .../lowering/class-dynamic-dispatch.ts | 13 +++++----- .../class-quoted-accessor-keys.mjs.json | 6 +++++ tests/corpus/class-quoted-accessor-keys.mjs | 26 +++++++++++++++++++ .../class-quoted-accessor-keys.mjs.json | 1 + 4 files changed, 40 insertions(+), 6 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-quoted-accessor-keys.mjs.json create mode 100644 tests/corpus/class-quoted-accessor-keys.mjs create mode 100644 tests/harness/corpus-costs/class-quoted-accessor-keys.mjs.json diff --git a/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts b/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts index 79deb2aeb..e792de957 100644 --- a/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts +++ b/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts @@ -477,7 +477,7 @@ interface ReceiverIndex { /** By a method or generic method its base chain declares. */ methods: Map; /** By a method, generic method or accessor its base chain declares (an - * accessor under its property name), or a field it has. */ + * accessor under its key and under its property name), or a field it has. */ members: Map; rooted: number[]; } @@ -504,11 +504,12 @@ function receiverIndex(lowerer: Lowerer, plans: readonly PropertyReceiver[]): Re for (let c: ClassInfo | null = info; c; c = c.base) { for (const name of c.methods.keys()) { add(methods, name, position); - add( - members, - name.startsWith("get:") || name.startsWith("set:") ? name.slice(4) : name, - position, - ); + // A `get:`/`set:` key is an accessor of the property after the + // prefix, or a method whose quoted name has that prefix; the test + // looks up both. + add(members, name, position); + if (name.startsWith("get:") || name.startsWith("set:")) + add(members, name.slice(4), position); } if (c.genericMethods) for (const name of c.genericMethods.keys()) { diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-quoted-accessor-keys.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-quoted-accessor-keys.mjs.json new file mode 100644 index 000000000..234634ebd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-quoted-accessor-keys.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-quoted-accessor-keys.mjs" + ], + "diags": [] +} diff --git a/tests/corpus/class-quoted-accessor-keys.mjs b/tests/corpus/class-quoted-accessor-keys.mjs new file mode 100644 index 000000000..637300b43 --- /dev/null +++ b/tests/corpus/class-quoted-accessor-keys.mjs @@ -0,0 +1,26 @@ +// Methods whose quoted names begin with "get:" or "set:", next to an +// accessor of the property after the prefix, read and called through +// untyped values. +class Quoted { + "get:size"() { + return "method get:size"; + } + "set:size"(value) { + return `method set:size ${value}`; + } + get size() { + return 3; + } +} +class Sized { + constructor() { + this.size = 5; + } +} +const values = [new Quoted(), new Sized(), { "get:size": () => "record get:size", size: 1 }]; +for (const value of values) { + const getter = value["get:size"]; + console.log(typeof getter, getter?.call(value)); + console.log(typeof value["set:size"], value.size); + if (value instanceof Quoted) console.log(value["get:size"](), value["set:size"](7)); +} diff --git a/tests/harness/corpus-costs/class-quoted-accessor-keys.mjs.json b/tests/harness/corpus-costs/class-quoted-accessor-keys.mjs.json new file mode 100644 index 000000000..81da85b90 --- /dev/null +++ b/tests/harness/corpus-costs/class-quoted-accessor-keys.mjs.json @@ -0,0 +1 @@ +{ "plain": 3900, "san": 4000 } From 08081ca1a2185a824a4fe8068447ec39e8e924f7 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 10:22:22 -0500 Subject: [PATCH 098/102] Encode each field of a posted record completely before the next A typed record encoded from its field hooks queued a plain-object field on the visit stack and went on to the next field, so getters on later fields ran before the properties of earlier ones were read. Node's serializer finishes each field, nested properties included, before the next. The record path now drains the visit stack down to where it started after each field, so properties are read in Node's order. Corpus 7139 posts a record whose fields hold getter-bearing objects and prints the read order. --- packages/runtime/src/scr_message.c | 28 +++++++++++++++----- tests/corpus/7139-message-typed-records.ts | 30 ++++++++++++++++++++++ 2 files changed, 51 insertions(+), 7 deletions(-) diff --git a/packages/runtime/src/scr_message.c b/packages/runtime/src/scr_message.c index 29cbb1be0..d4eb263cf 100644 --- a/packages/runtime/src/scr_message.c +++ b/packages/runtime/src/scr_message.c @@ -331,6 +331,7 @@ static ScrDyn *scr_message_uncaught_keys(const ScrDyn *view) { static void scr_message_property(ScrMessageEncoder *encoder, size_t id, const ScrStr *key, size_t value, bool hidden); +static bool scr_message_drain(ScrMessageEncoder *encoder, size_t base); static size_t scr_message_value(ScrMessageEncoder *encoder, const ScrDyn *input) { bool uncaught = encoder->uncaught; @@ -407,6 +408,9 @@ static size_t scr_message_value(ScrMessageEncoder *encoder, const ScrDyn *input) void *rec = input->v.typed_ref.ptr; encoder->record_depth++; size_t result = id; + /* A field's value encodes completely, its containers' properties + * included, before the next field's: getters run in Node's order. */ + size_t base = encoder->depth; for (size_t i = 0; i < record->count; i++) { if (!record->fixed && !record->has(rec, i)) continue; ScrDyn *child = record->get(rec, i); @@ -422,6 +426,10 @@ static size_t scr_message_value(ScrMessageEncoder *encoder, const ScrDyn *input) break; } scr_message_property(encoder, id, record->names[i], next, false); + if (encoder->depth > base && !scr_message_drain(encoder, base)) { + result = SIZE_MAX; + break; + } } encoder->record_depth--; return result; @@ -832,10 +840,11 @@ static ScrMessage *scr_message_pack(ScrMessageEncoder *encoder) { return message; } -static ScrMessage *scr_message_encode_run(ScrMessageEncoder *encoder, const ScrDyn *value) { - ScrMessage *message = NULL; - if (scr_message_value(encoder, value) == SIZE_MAX) goto done; - while (encoder->depth && !scr_exc_pending()) { +/* Encodes the properties of the containers on the visit stack above + * `base`, depth first, as Node's serializer visits them (getters run in + * that order). False when a property could not be read or encoded. */ +static bool scr_message_drain(ScrMessageEncoder *encoder, size_t base) { + while (encoder->depth > base && !scr_exc_pending()) { size_t id = encoder->stack[encoder->depth - 1]; ScrMessageVisit *visit = &encoder->visits[id]; if (visit->cursor == visit->keys->v.arr.len) { encoder->depth--; continue; } @@ -843,7 +852,7 @@ static ScrMessage *scr_message_encode_run(ScrMessageEncoder *encoder, const ScrD bool error = encoder->nodes[id].kind == SCR_MESSAGE_ERROR; if (key->kind != SCR_DYN_STR || (!error && !scr_dyn_property_is_enumerable(visit->view, key->v.str))) continue; ScrDyn *child = scr_dyn_bag_get(visit->view, key->v.str, visit->view); - if (!child || scr_exc_pending()) { scr_dyn_release(child); break; } + if (!child || scr_exc_pending()) { scr_dyn_release(child); return false; } bool hidden = error; if (visit->uncaught) { /* Node keeps an uncaught Error's data properties except functions @@ -854,10 +863,15 @@ static ScrMessage *scr_message_encode_run(ScrMessageEncoder *encoder, const ScrD } size_t next = scr_message_value(encoder, child); scr_dyn_release(child); - if (next == SIZE_MAX) break; + if (next == SIZE_MAX) return false; scr_message_property(encoder, id, key->v.str, next, hidden); } -done: + return !scr_exc_pending(); +} + +static ScrMessage *scr_message_encode_run(ScrMessageEncoder *encoder, const ScrDyn *value) { + ScrMessage *message = NULL; + if (scr_message_value(encoder, value) != SIZE_MAX) scr_message_drain(encoder, 0); if (!scr_exc_pending()) message = scr_message_pack(encoder); else for (size_t i = 0; i < encoder->count; i++) scr_message_drop(&encoder->nodes[i]); diff --git a/tests/corpus/7139-message-typed-records.ts b/tests/corpus/7139-message-typed-records.ts index 678b9cc48..35d0d1588 100644 --- a/tests/corpus/7139-message-typed-records.ts +++ b/tests/corpus/7139-message-typed-records.ts @@ -53,3 +53,33 @@ try { } catch (error) { console.log("rejected", (error as Error).name); } + +// Fields that hold objects with getters: each field's value is read +// completely, its getters included, before the next field's, as in Node. +type Holder = { id: number; first: unknown; second: unknown }; +const reads: string[] = []; +const getters: Holder = { + id: 1, + first: { + get a() { + reads.push("first.a"); + return 1; + }, + nested: { + get b() { + reads.push("first.nested.b"); + return 2; + }, + }, + }, + second: { + get c() { + reads.push("second.c"); + return 3; + }, + }, +}; +const { port1: getterPort, port2: getterSender } = new MessageChannel(); +getterSender.postMessage(getters); +console.log("getter order", reads.join(",")); +getterPort.close(); From eef347115963cbe0723b0a53017b696b6f5f242e Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 10:46:38 -0500 Subject: [PATCH 099/102] Stop asking batch methods the checker server answers as unknown tsgo has no getContextualTypes or getResolvedSignatures. Each prefetch asked for them anyway, and a failed chunk was split and retried down to single nodes, so a tsgo build paid about two failed requests per prefetched node. The checker facade now remembers a batch method the server answers with "unknown API method" and asks those queries node by node from then on. --- packages/compiler/src/frontend/ts7/checker.ts | 40 +++++++++++++++++-- .../src/frontend/ts7/semantic-checker.ts | 3 +- packages/compiler/test/ts7/facade.test.ts | 31 ++++++++++++++ 3 files changed, 69 insertions(+), 5 deletions(-) diff --git a/packages/compiler/src/frontend/ts7/checker.ts b/packages/compiler/src/frontend/ts7/checker.ts index cd43636af..9550d1dc2 100644 --- a/packages/compiler/src/frontend/ts7/checker.ts +++ b/packages/compiler/src/frontend/ts7/checker.ts @@ -86,12 +86,19 @@ function batchAnswers( items: readonly I[], fetch: (chunk: readonly I[]) => readonly (O | undefined)[], store: (item: I, answer: O | undefined) => void, -): void { + unknown: (error: unknown) => boolean = () => false, +): boolean { + let known = true; const answer = (chunk: readonly I[]): void => { + if (!known) return; let answers: readonly (O | undefined)[]; try { answers = fetch(chunk); - } catch { + } catch (error) { + if (unknown(error)) { + known = false; + return; + } if (chunk.length === 1) return; const mid = chunk.length >> 1; answer(chunk.slice(0, mid)); @@ -101,6 +108,13 @@ function batchAnswers( chunk.forEach((item, index) => store(item, answers[index])); }; for (let i = 0; i < items.length; i += BATCH_CHUNK) answer(items.slice(i, i + BATCH_CHUNK)); + return known; +} + +/** Whether a request failed because the server has no such method: tsgo, + * and tsc-ts before 0.0.7, answer the batch methods this way. */ +function unknownMethod(error: unknown, method: string): boolean { + return error instanceof Error && error.message.includes(`unknown API method "${method}"`); } function chunked(items: readonly T[], fetch: (chunk: readonly T[]) => readonly R[]): R[] { @@ -239,6 +253,9 @@ function collectNodes(roots: readonly Node[], walk: PrefetchWalk = "all"): Node[ export class CheckerFacade { private readonly cache = new CheckerCache(); + /** Batch methods the server answered as unknown. Lowering asks those + * node by node from then on, without a failed request per prefetch. */ + private readonly unknownBatchMethods = new Set(); constructor( /** The underlying 7.0.2 sync checker — exposed for methods the facade @@ -374,7 +391,8 @@ export class CheckerFacade { if (!NODE_BATCH_QUERIES) return; this.ensureActive(); const missing = [...new Set(nodes)].filter((node) => !this.cache.contextualType.has(node)); - batchAnswers( + this.batchNodes( + "getContextualTypes", missing, (chunk) => this.raw.getContextualTypes(chunk), (node, type) => this.cache.contextualType.set(node, type), @@ -386,13 +404,27 @@ export class CheckerFacade { if (!NODE_BATCH_QUERIES) return; this.ensureActive(); const missing = [...new Set(nodes)].filter((node) => !this.cache.resolvedSignature.has(node)); - batchAnswers( + this.batchNodes( + "getResolvedSignatures", missing, (chunk) => this.raw.getResolvedSignatures(chunk), (node, signature) => this.cache.resolvedSignature.set(node, signature), ); } + /** Answers a node batch method's chunks (batchAnswers), unless the server + * has answered the method as unknown. */ + private batchNodes( + method: string, + nodes: readonly Node[], + fetch: (chunk: readonly Node[]) => readonly (O | undefined)[], + store: (node: Node, answer: O | undefined) => void, + ): void { + if (nodes.length === 0 || this.unknownBatchMethods.has(method)) return; + if (!batchAnswers(nodes, fetch, store, (error) => unknownMethod(error, method))) + this.unknownBatchMethods.add(method); + } + /** Batches symbol queries for every identifier under roots without the * usual companion getTypeOfSymbol batch. Preflight uses this for AST * analyses that themselves inspect deferred bodies for binding identity: diff --git a/packages/compiler/src/frontend/ts7/semantic-checker.ts b/packages/compiler/src/frontend/ts7/semantic-checker.ts index e7e6b408d..c19f93598 100644 --- a/packages/compiler/src/frontend/ts7/semantic-checker.ts +++ b/packages/compiler/src/frontend/ts7/semantic-checker.ts @@ -99,7 +99,8 @@ export interface SemanticCompletion { /** Whether lowering asks the checker for contextual types and resolved * signatures in batches (`getContextualTypes`, `getResolvedSignatures`, * answered from tsc-ts 0.0.7 on). Off, the batch prefetches (checker.ts) do - * nothing and lowering asks node by node. */ + * nothing and lowering asks node by node. A server without a batch method + * (tsgo) answers it as unknown once, and the facade stops asking. */ export const NODE_BATCH_QUERIES = true; /** The pinned checker's request surface over native objects. Every query diff --git a/packages/compiler/test/ts7/facade.test.ts b/packages/compiler/test/ts7/facade.test.ts index 94bab8b31..8e03400a2 100644 --- a/packages/compiler/test/ts7/facade.test.ts +++ b/packages/compiler/test/ts7/facade.test.ts @@ -835,6 +835,37 @@ export function f(input: number): number { expect(panics).toBe(warmPanics); }); +test("a batch method the server answers as unknown is asked once, then node by node", () => { + const w = buildTwoWorlds(RICH_TS, host); + worlds.push(w); + const sf = w.p7.getSourceFile(w.files[0]!)!; + const raw = w.p7.project.checker; + const requests: Record = {}; + // A server without the batch methods, as tsgo is. + const older = new Proxy(raw, { + get(target, prop, receiver) { + const value = Reflect.get(target, prop, receiver); + if (prop === "getContextualTypes" || prop === "getResolvedSignatures") { + return () => { + requests[prop] = (requests[prop] ?? 0) + 1; + throw new Error(`unknown API method "${prop}"`); + }; + } + return typeof value === "function" ? value.bind(target) : value; + }, + }) as Checker; + const facade = new CheckerFacade(older); + + facade.prefetchRoots([sf]); + expect(requests).toEqual({ getContextualTypes: 1, getResolvedSignatures: 1 }); + facade.prefetchRoots(sf.statements.nodes); + facade.prefetchContextualTypes(collectNodes(w)); + expect(requests).toEqual({ getContextualTypes: 1, getResolvedSignatures: 1 }); + // The node-by-node queries still answer. + const call = collectNodes(w).find(ad.isCallExpression)!; + expect(facade.getResolvedSignature(call)).toBe(raw.getResolvedSignature(call)); +}); + test("autoPrefetch: false degrades to per-call queries (the escape hatch works)", () => { const w = buildTwoWorlds(RICH_TS, host); worlds.push(w); From 9aaebbab254ac0ee6359e10eca248fefab0c3559 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 11:14:27 -0500 Subject: [PATCH 100/102] Prepare v0.4.2 release --- CHANGELOG.md | 156 +++++++++++++++++- packages/cli-darwin-arm64/package.json | 2 +- packages/cli-darwin-x64/package.json | 2 +- packages/cli-linux-arm64-gnu/package.json | 2 +- packages/cli-linux-arm64-musl/package.json | 2 +- packages/cli-linux-x64-gnu/package.json | 2 +- packages/cli-linux-x64-musl/package.json | 2 +- packages/cli-win32-x64-msvc/package.json | 2 +- packages/cli/package.json | 2 +- packages/compiler/package.json | 2 +- packages/compiler/surface-manifest.json | 2 +- packages/experimental/package.json | 2 +- packages/llvm-darwin-arm64/package.json | 2 +- packages/llvm-darwin-x64/package.json | 2 +- packages/llvm-linux-arm64-gnu/package.json | 2 +- packages/llvm-linux-arm64-musl/package.json | 2 +- packages/llvm-linux-x64-gnu/package.json | 2 +- packages/llvm-linux-x64-musl/package.json | 2 +- packages/llvm-win32-x64-msvc/package.json | 2 +- packages/runtime-android-arm64/package.json | 2 +- packages/runtime-darwin-arm64/package.json | 2 +- packages/runtime-darwin-x64/package.json | 2 +- packages/runtime-ios-arm64/package.json | 2 +- .../runtime-ios-simulator-arm64/package.json | 2 +- packages/runtime-linux-arm64-gnu/package.json | 2 +- .../runtime-linux-arm64-musl/package.json | 2 +- packages/runtime-linux-x64-gnu/package.json | 2 +- packages/runtime-linux-x64-musl/package.json | 2 +- packages/runtime-wasm32-wasi/package.json | 2 +- packages/runtime-win32-x64-msvc/package.json | 2 +- packages/runtime/package.json | 2 +- packages/threads/package.json | 2 +- packages/types/package.json | 2 +- 33 files changed, 186 insertions(+), 34 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 31d34e8db..2bdd47363 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,160 @@ All notable changes to scriptc will be documented in this file. +## 0.4.2 + +### Highlights + +- **Faster builds of large programs:** + - scriptc checks with tsc-ts 0.0.7, which answers contextual types and resolved signatures in batches, so lowering asks for them in one request per chunk instead of one per node. A native build of tsc-ts is 7% faster (110.5 → 103.5 s on 8 vCPUs, lowering 12% faster), with an identical executable. + - The native compiler is built with profile-guided optimization, so tsc-ts builds 6.9% faster cold and 10.7% faster after an edit. + - The class dispatch passes index their receivers by name instead of testing each one, and they reuse their per-function scans while a function's body is unchanged. + - Checker replies resolve objects the compiler already holds from their ids without decoding them. +- **Leaner builds:** + - The frontend of an optimized executable's first build runs in a child process, so the native code generator starts after its memory is released. The cold build of tsc-ts peaks at 2.21 GB instead of 3.30 GB. + - The compiler collects its heap as lowering and LLVM emission grow it. +- **WebCrypto:** + - The `crypto` global, `node:crypto`'s `webcrypto` and `crypto.subtle` are one object. + - `generateKey`, `importKey`, `exportKey`, `encrypt`, `decrypt`, `deriveBits`, `deriveKey`, `wrapKey` and `unwrapKey` cover HMAC, AES-GCM, AES-CBC, AES-CTR, AES-KW, PBKDF2, HKDF and JSON Web Keys. + - `crypto.subtle` signs and verifies with ECDSA, RSASSA-PKCS1-v1_5, RSA-PSS and Ed25519. + - All of it follows Node 24's argument conversion, algorithm normalization and `DOMException`s. jose's symmetric JWE paths run as in Node. +- **JSX:** `.tsx`, `.jsx` and JavaScript files with JSX compile under the project's `jsx` options. + - `react`, `react-jsx` and `react-jsxdev` lower to the factory calls TypeScript emits, with the same keys, fallbacks and source positions. + - `preserve` and `react-native` are refused with a named diagnostic. +- **Faster worker messages:** + - A message is encoded into one block sized to its contents. + - A typed record is posted from its fields. + - A `'message'` listener with a typed parameter builds it from the message, without a checked-dynamic copy. + - Messages between `MessageChannel` ports take 90 ms where they took 250 ms in 0.4.1 (Node: 337 ms), with a peak RSS of 45 MB instead of 115 MB. +- **Loops over typed arrays vectorize:** a loop to a typed array's length keeps one bounds test for every typed array it indexes. + - Index temporaries such as `const j = i * 4` are computed as integers. + - Uint8ClampedArray stores convert inline. + - Row-major index terms such as `r * cols + j` are tested once before the loop. + - Typed-array callback methods call a literal callback directly on an integer counter. + - An 896 × 896 matrix-vector product with four accumulators takes 55 ms instead of 396 ms (Node: 275 ms). `Uint8Array.map` is 4.5 times as fast and `Int32Array.some` 7.8 times as fast as in 0.4.1. + +### Features + +- **Asymmetric keys and signatures in `node:crypto`:** + - `generateKeyPair`, `generateKeyPairSync`, `createPrivateKey` and `createPublicKey` handle RSA, EC and Ed25519 keys in PEM, DER and JWK. + - `sign`, `verify`, `createSign` and `createVerify` sign and verify with those keys, with Node's output and errors. + - Ed25519 verification matches Node on 2,083 test vectors, including small-order and mixed-order keys. +- **`crypto.createDiffieHellman`, `crypto.getDiffieHellman` and `crypto.createDiffieHellmanGroup`:** + - The modp1, modp2 and modp5 to modp18 groups, explicit primes and generators, and generated safe primes are supported, with Node 24's key widths, `verifyError` bits, key range checks and errors. + - Secrets of 0, 1 and p − 1 are rejected, and so are peer keys outside the RFC 5114 subgroups. + - Primes longer than 8192 bits are refused. +- **TLS:** + - `tls.connect` and `tls.createServer` negotiate `ALPNProtocols`, and both sockets report `alpnProtocol`. `minVersion` and `maxVersion` bound the handshake, and `getProtocol()` reports the version it picked. + - `tls.createServer` takes an `SNICallback` that answers a `SecureContext` synchronously or later. + - `new tls.TLSSocket(socket, { isServer: true, ... })` and `tls.connect({ socket })` run the handshake on an open socket, such as an HTTP `CONNECT` tunnel. + - A client whose peer closes before the handshake completes fails with Node's `ECONNRESET`. +- **Streams:** + - Readable, Writable, Duplex, Transform and PassThrough streams take `objectMode`, `readableObjectMode` and `writableObjectMode`, and an object-mode side carries any value through `push`, `write`, `pipe`, `pipeline`, `for await` and `'data'` listeners. + - `_write` and `_transform` receive the encoding argument as Node passes it. + - `Cipheriv` and `Decipheriv` are Transforms: they can be piped, used as `pipeline()` stages, read and iterated. + - `pipeline()` accepts function stages anywhere among its streams, and an array, a string or a synchronous generator as its source. +- **Packages compiled from their JavaScript:** + - js-yaml and smol-toml compile statically and match Node: ES5 error constructors (`Object.create(Error.prototype)`, `Error.call(this)`, `Error.captureStackTrace`) and classes extending `Date` behave as in Node. + - TypeScript's UMD module wrapper compiles as the module body, and tsc's `__importDefault` and `__importStar` helpers around builtin modules compile as plain `require()` calls. + - Interfaces, type aliases and enums that only a package's `.d.ts` declares keep their types. +- **JavaScript sources:** + - Error constructors can be read as values, so `err.constructor === TypeError` works. + - `workerData` can be destructured. + - Unary `+` converts unions of strings, numbers, booleans, `null` and `undefined` as `Number()` does, so `+process.argv[2]` compiles. + - These compile and behave as in Node: + - chained readline listener registration; + - `Number.parseInt` without a radix; + - `match` and `search` with a possibly undefined regular expression; + - `Buffer.from` over an untyped `ArrayBuffer`, with its byte offset; + - Atomics on untyped arrays. + - Buffer methods run on Buffers held as untyped values. +- **`fs`:** + - The synchronous functions (`readFileSync`, `writeFileSync`, `statSync`, `readdirSync`, `mkdirSync`, `rmSync`, `openSync` and the others) accept `file:` URLs wherever they accept a path, with Node's conversion errors. + - `fs.promises.rm` takes `recursive`, `force`, `maxRetries` and `retryDelay`, and removing a directory without `recursive` throws Node's `ERR_FS_EISDIR`. +- **`TypedArray.of`** creates a typed array of its arguments, and a dynamic iterable spread into `Array.of`, `push` or `TypedArray.of` is drained through the iterator protocol. +- **Global `isFinite` converts its argument with ToNumber,** as `isNaN` does. The Math functions and `String.fromCharCode` evaluate every argument before converting any. +- **`Object.freeze`, `Object.seal` and `Object.preventExtensions` of a function** act on its own properties, and `Object.isFrozen`, `Object.isSealed` and `Object.isExtensible` answer for functions. @noble/hashes' frozen hashers work. +- **EventEmitters used through both typed and untyped references** share one listener list. An untyped `emit` reaches typed listeners, an untyped `emit('error')` follows Node's contract, and `listenerCount`, `eventNames`, `listeners`, `rawListeners`, `removeAllListeners`, `setMaxListeners` and `getMaxListeners` work on untyped values. +- **Template literals, `join`, `Array.prototype.toString` and the default `sort()`** call an object's own or inherited `toString`, as `String()` does, instead of printing `[object Object]`. +- **Classes and generics:** + - A generic factory declared to return a constructor type can return one of its local classes, including an anonymous class expression, and `class X extends factory(...)` extends it. + - Static methods of a function-local class compile. + - Constructor types declared in the program (`new () => unknown`, types that also name static members, construct overloads) hold class values. + - Members typed by a conditional type over a literal class type argument (`Field`) resolve. + - Object literals under an erased generic member may hold callbacks with optional or defaulted parameters. +- **Assignment and update targets wrapped in parentheses or non-null assertions** (`(x) = 1`, `h.sums[k]! += 10`) compile. +- **Untyped values keep what JavaScript code adds:** + - Properties that untyped code adds to a typed object literal stay on it. + - Named properties written to an array through an `unknown` view stay on the array, and `for...in` visits them after the indices. + - An `unknown` value asserted to a structural type with methods keeps its class's methods. + - The type inferred from an empty object literal holds any non-nullish value, as TypeScript's `{}` does. +- **A WebAssembly module the build finds but does not translate** rejects with a `CompileError` that names the reason, for example a proposal outside the translated feature set. +- **SC6101 names the functions that likely run often and use untyped values:** + - It shows up to five, most likely hot first, with why their values are untyped: an `any`, an untyped `JSON.parse` result or an untyped JavaScript file. + - `scriptc coverage --fail-on=dynamic` fails on it, and `--no-dynamic-tier-warning` leaves it out. + +### Performance + +- **Regular expressions skip start positions that their leading character sets rule out,** testing 16 positions at once. Searching 50 MB of text for nine case-insensitive alternations takes 0.83 s instead of 3.88 s (Node: 4.38 s). +- **Loop counters stay integers in more loops:** + - Counters that step beside a counted loop's counter (`for (let i = 0, p = 0; i < n; i++, p += 4)`) stay integers: a pixel-stride loop takes 114 ms instead of 340 ms (Node: 190 ms). + - So do two counters that close in on each other (`lo++, hi--`), 17% faster on a permutation-reversal loop. + - So do counters of loops bounded by a string's length or by an invariant limit other than an array's length, and while-loop counters that nested scans advance. A non-ASCII lexer is 9.5% faster. +- **Loops that call a known callback** test its closure once before the loop and call the function directly, so captured `let` bindings stay in registers. `forEach` sums with a captured accumulator are 25 to 55% faster. +- **A speculative integer loop whose check fails** finishes the iteration outside the ordinary loop, which stays optimizable, and a loop site that keeps failing stops trying. With the hole-free-prefix test that element reads now take first, a pairwise loop over an array of class instances with number fields is about 1.25 times as fast as in 0.4.1. +- **Typed arrays over a SharedArrayBuffer** read and write elements inline as relaxed atomic accesses. A numeric kernel over shared `Float64Array`s takes 0.78 s instead of 1.56 s (Node: 0.84 s). +- **`Math.pow(2, n)` for integer exponents** builds the result from its bits. A counter that masks with `Math.pow(2, length)` takes 11.0 s instead of 20.4 s. +- **Async calls that never suspend run in place,** and so does `await Promise.all` of such calls, with Node's microtask turns and rejection handling. An async pipeline takes 5.5 ms instead of 9.7 ms. +- **Strings:** + - `Number()` of a short integer string returns the integer directly. + - `split` builds its result in one inline block, and `indexOf` and `slice` on ASCII strings skip the UTF-16 index map. A log summary is 20% faster. + - `charAt` and `s[i]` on ASCII strings read the character from a table. + - Chains of one-character `replace` calls (the HTML-escape idiom) replace a block of 16 bytes at a time, 12.8% faster on a template renderer. +- **`JSON.parse` and `JSON.stringify`** scan whole words and append parsed typed arrays in bulk, 22% faster to parse and 10% faster to stringify records. +- **Smaller arrays, maps and program-lifetime instances:** + - The array header is 32 bytes instead of 48. + - Arrays of up to 16 known elements keep their slots in their own block. + - Arrays of a known final length get exactly that capacity. + - Small map entry arrays grow in finer steps. + - On Linux, `ProgramLifetime` instances take a 32-bit header and are referenced in 4 bytes. + - They lower the peak memory of a large TypeScript type checker: the 4-byte references alone take a large project's check from 4.13 GB to 3.75 GB, and the 32-bit header saves a further 5%. +- **Worker messages queued together are delivered in one batch** before immediates run. 20,000 messages interleaved with a worker's output drain in 0.5 s instead of 5.6 s (Node: 0.57 s). +- **The cycle collector** never buffers instances of classes whose fields hold nothing cycle-capable, and its per-object paths are shorter. A workload of cyclic graphs is about 5% faster. +- **Array helpers specialized for a callback that cannot throw** skip the pending-exception test, 4.5% faster on a functional pipeline. +- **Compile time:** + - A file's function declarations are walked once for their references, so lowering a 10 MB single-module bundle takes 69 s instead of 219 s. + - LLVM emission computes its module facts once, 6.9% faster on tsc-ts. + - AST walks visit subtrees by their node ranges and read node words through a `Uint32Array`. + - Program builds no longer import runtime bitcode, so builds through Node and through the native compiler produce identical executables. + +### Fixes + +- **Member reads and method calls on an array hole** held in a binding narrowed to one arm of a wide union throw Node's `Cannot read properties of undefined` TypeError. +- **`AsyncLocalStorage`:** + - A store entered before an async function's first await, or in a body that never suspends, is the caller's store after the call. + - Each synchronous generator step runs in its resumer's context, as in Node. +- **Generic arrow and function-expression bindings used before their declarations** behave as in Node, including the `ReferenceError` of a `let` or `const`. +- **Assignment expressions into a module `let` declared without an initializer** (`new Promise((r) => (resolve = r))`) store the value instead of throwing a `ReferenceError`. +- **The `extends` expression of a class defined inside a function** is evaluated each time the definition runs. +- **A `super()` call that leads an `if` condition's comma chain** compiles. +- **A catch binding tests `instanceof`** correctly for values thrown as `unknown`, rejected promises and runtime errors. +- **zlib callbacks receive `undefined` as their result when the operation fails,** as in Node, and a callback may assign a fallback to it. +- **`Readable.push` and `Writable.write` with `string | null` or `Buffer | null` chunks** no longer crash. +- **Object literals keep their key order** through compiler rewrites and on shapes a typed `JSON.parse` also builds, so `JSON.stringify`, `Object.keys` and `console.log` match Node. +- **`console.log` prints class instances with their class name** in programs that test `instanceof` on unknown values. +- **`String`, `Number` and `Boolean` passed to array methods** convert as their direct calls do, and nested array literals in a recursive JSON-style union build. +- **A dynamic method call that the program also reads through a prototype** finds the method when the instance's property bag does not hold it. +- **Storing an element on `Array.prototype`** fails with SC2020, because holes in native arrays do not read inherited elements. +- **A recursive type alias in a generic signature** no longer crashes the compiler. +- **A `Buffer` view of an untyped typed array** compiles. +- **JSX programs checked with tsgo** compile as they do with tsc-ts. +- **Two programs whose entries share a name and build into one directory** no longer share a cached translation unit, so a later cache hit always relinks the right program. +- **A warm build whose cached LLVM exceeds the engine's string limit** reads it in parts instead of failing with `Invalid string length`. +- **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. + + + ## 0.4.1 ### Highlights @@ -77,8 +231,6 @@ All notable changes to scriptc will be documented in this file. - **TypeScript enum exports in compiled packages stay `undefined` until they are assigned,** as in Node. - **Element writes accept a possibly undefined index** (typed-array writes, compound and update writes, element assignments used as values and destructuring targets) and convert it with ToNumber, as element reads already did. - - ## 0.4.0 ### Breaking changes diff --git a/packages/cli-darwin-arm64/package.json b/packages/cli-darwin-arm64/package.json index 482e5f1e5..23584b60a 100644 --- a/packages/cli-darwin-arm64/package.json +++ b/packages/cli-darwin-arm64/package.json @@ -1,6 +1,6 @@ { "name": "@scriptc/cli-darwin-arm64", - "version": "0.4.1", + "version": "0.4.2", "description": "Native scriptc compiler for darwin-arm64", "license": "Apache-2.0", "homepage": "https://scriptc.dev", diff --git a/packages/cli-darwin-x64/package.json b/packages/cli-darwin-x64/package.json index b1ced2c03..d9e6dafc6 100644 --- a/packages/cli-darwin-x64/package.json +++ b/packages/cli-darwin-x64/package.json @@ -1,6 +1,6 @@ { "name": "@scriptc/cli-darwin-x64", - "version": "0.4.1", + "version": "0.4.2", "description": "Native scriptc compiler for darwin-x64", "license": "Apache-2.0", "homepage": "https://scriptc.dev", diff --git a/packages/cli-linux-arm64-gnu/package.json b/packages/cli-linux-arm64-gnu/package.json index 0aa213279..5b8cb4db2 100644 --- a/packages/cli-linux-arm64-gnu/package.json +++ b/packages/cli-linux-arm64-gnu/package.json @@ -1,6 +1,6 @@ { "name": "@scriptc/cli-linux-arm64-gnu", - "version": "0.4.1", + "version": "0.4.2", "description": "Native scriptc compiler for linux-arm64-gnu", "license": "Apache-2.0", "homepage": "https://scriptc.dev", diff --git a/packages/cli-linux-arm64-musl/package.json b/packages/cli-linux-arm64-musl/package.json index 4ac5434ae..0901602ec 100644 --- a/packages/cli-linux-arm64-musl/package.json +++ b/packages/cli-linux-arm64-musl/package.json @@ -1,6 +1,6 @@ { "name": "@scriptc/cli-linux-arm64-musl", - "version": "0.4.1", + "version": "0.4.2", "description": "Native scriptc compiler for linux-arm64-musl", "license": "Apache-2.0", "homepage": "https://scriptc.dev", diff --git a/packages/cli-linux-x64-gnu/package.json b/packages/cli-linux-x64-gnu/package.json index 7473c36bc..f01478aad 100644 --- a/packages/cli-linux-x64-gnu/package.json +++ b/packages/cli-linux-x64-gnu/package.json @@ -1,6 +1,6 @@ { "name": "@scriptc/cli-linux-x64-gnu", - "version": "0.4.1", + "version": "0.4.2", "description": "Native scriptc compiler for linux-x64-gnu", "license": "Apache-2.0", "homepage": "https://scriptc.dev", diff --git a/packages/cli-linux-x64-musl/package.json b/packages/cli-linux-x64-musl/package.json index 08e048cd1..a6986a66a 100644 --- a/packages/cli-linux-x64-musl/package.json +++ b/packages/cli-linux-x64-musl/package.json @@ -1,6 +1,6 @@ { "name": "@scriptc/cli-linux-x64-musl", - "version": "0.4.1", + "version": "0.4.2", "description": "Native scriptc compiler for linux-x64-musl", "license": "Apache-2.0", "homepage": "https://scriptc.dev", diff --git a/packages/cli-win32-x64-msvc/package.json b/packages/cli-win32-x64-msvc/package.json index 54e323839..6b03811b8 100644 --- a/packages/cli-win32-x64-msvc/package.json +++ b/packages/cli-win32-x64-msvc/package.json @@ -1,6 +1,6 @@ { "name": "@scriptc/cli-win32-x64-msvc", - "version": "0.4.1", + "version": "0.4.2", "description": "Native scriptc compiler for win32-x64-msvc", "license": "Apache-2.0", "homepage": "https://scriptc.dev", diff --git a/packages/cli/package.json b/packages/cli/package.json index d66ba3247..034747c29 100644 --- a/packages/cli/package.json +++ b/packages/cli/package.json @@ -1,6 +1,6 @@ { "name": "scriptc", - "version": "0.4.1", + "version": "0.4.2", "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", diff --git a/packages/compiler/package.json b/packages/compiler/package.json index a283f821a..a1d66963d 100644 --- a/packages/compiler/package.json +++ b/packages/compiler/package.json @@ -1,6 +1,6 @@ { "name": "@scriptc/compiler", - "version": "0.4.1", + "version": "0.4.2", "description": "The scriptc compiler — TypeScript/JavaScript frontend, typed IR, LLVM backend", "license": "Apache-2.0", "homepage": "https://scriptc.dev", diff --git a/packages/compiler/surface-manifest.json b/packages/compiler/surface-manifest.json index 45b3edbaa..637a5f831 100644 --- a/packages/compiler/surface-manifest.json +++ b/packages/compiler/surface-manifest.json @@ -1,6 +1,6 @@ { "schemaVersion": 2, - "compilerVersion": "0.4.1", + "compilerVersion": "0.4.2", "coverage": [ "Entries are projected mechanically from the compiler's own decision tables: the diagnostics registry, the unsupported-syntax dispatch tables, the stdlib and node-builtin lowering tables, and the supported-builtin-module list. Nothing is hand-maintained; the manifest regenerates byte-identically from the source tree at this version.", "Absence from this manifest means 'not projected', never 'unsupported'. Surfaces lowered through dedicated code paths rather than tables are not yet projected: console, JSON, Promise/async and the timer surface, the net/http/tls/https/dgram/dns/assert/test/stream/readline module member surfaces, template literals, the regex slice, global functions (parseInt, parseFloat, isNaN, isFinite), and the process surface outside its ambient slice.", diff --git a/packages/experimental/package.json b/packages/experimental/package.json index 5b6906de6..cfb4151a4 100644 --- a/packages/experimental/package.json +++ b/packages/experimental/package.json @@ -1,6 +1,6 @@ { "name": "@scriptc/experimental", - "version": "0.4.1", + "version": "0.4.2", "description": "Experimental scriptc APIs, with Node.js implementations: lifetime regions for ProgramLifetime objects, intern tables shared between threads, and per-thread slots on shared objects", "license": "Apache-2.0", "homepage": "https://scriptc.dev", diff --git a/packages/llvm-darwin-arm64/package.json b/packages/llvm-darwin-arm64/package.json index 472056c39..615fe9d81 100644 --- a/packages/llvm-darwin-arm64/package.json +++ b/packages/llvm-darwin-arm64/package.json @@ -1,6 +1,6 @@ { "name": "@scriptc/llvm-darwin-arm64", - "version": "0.4.1", + "version": "0.4.2", "description": "Pinned LLVM code-generation helper for scriptc on macOS arm64", "license": "Apache-2.0 WITH LLVM-exception", "homepage": "https://scriptc.dev", diff --git a/packages/llvm-darwin-x64/package.json b/packages/llvm-darwin-x64/package.json index 7f55cb6b5..fd6caf976 100644 --- a/packages/llvm-darwin-x64/package.json +++ b/packages/llvm-darwin-x64/package.json @@ -1,6 +1,6 @@ { "name": "@scriptc/llvm-darwin-x64", - "version": "0.4.1", + "version": "0.4.2", "description": "Pinned LLVM code-generation helper for scriptc on macOS x64", "license": "Apache-2.0 WITH LLVM-exception", "homepage": "https://scriptc.dev", diff --git a/packages/llvm-linux-arm64-gnu/package.json b/packages/llvm-linux-arm64-gnu/package.json index 0e1a55b22..7d66257f4 100644 --- a/packages/llvm-linux-arm64-gnu/package.json +++ b/packages/llvm-linux-arm64-gnu/package.json @@ -1,6 +1,6 @@ { "name": "@scriptc/llvm-linux-arm64-gnu", - "version": "0.4.1", + "version": "0.4.2", "description": "Pinned LLVM code-generation helper for scriptc on Linux arm64", "license": "Apache-2.0 WITH LLVM-exception", "homepage": "https://scriptc.dev", diff --git a/packages/llvm-linux-arm64-musl/package.json b/packages/llvm-linux-arm64-musl/package.json index efdd97444..b3a01089d 100644 --- a/packages/llvm-linux-arm64-musl/package.json +++ b/packages/llvm-linux-arm64-musl/package.json @@ -1,6 +1,6 @@ { "name": "@scriptc/llvm-linux-arm64-musl", - "version": "0.4.1", + "version": "0.4.2", "description": "Statically linked LLVM code-generation helper for scriptc on Linux arm64 musl", "license": "Apache-2.0 WITH LLVM-exception", "homepage": "https://scriptc.dev", diff --git a/packages/llvm-linux-x64-gnu/package.json b/packages/llvm-linux-x64-gnu/package.json index 39667d535..0b3264ec7 100644 --- a/packages/llvm-linux-x64-gnu/package.json +++ b/packages/llvm-linux-x64-gnu/package.json @@ -1,6 +1,6 @@ { "name": "@scriptc/llvm-linux-x64-gnu", - "version": "0.4.1", + "version": "0.4.2", "description": "Pinned LLVM code-generation helper for scriptc on Linux x64", "license": "Apache-2.0 WITH LLVM-exception", "homepage": "https://scriptc.dev", diff --git a/packages/llvm-linux-x64-musl/package.json b/packages/llvm-linux-x64-musl/package.json index 9efd41845..6c83d1cb9 100644 --- a/packages/llvm-linux-x64-musl/package.json +++ b/packages/llvm-linux-x64-musl/package.json @@ -1,6 +1,6 @@ { "name": "@scriptc/llvm-linux-x64-musl", - "version": "0.4.1", + "version": "0.4.2", "description": "Statically linked LLVM code-generation helper for scriptc on Linux x64 musl", "license": "Apache-2.0 WITH LLVM-exception", "homepage": "https://scriptc.dev", diff --git a/packages/llvm-win32-x64-msvc/package.json b/packages/llvm-win32-x64-msvc/package.json index 329fa308c..9fb682f0f 100644 --- a/packages/llvm-win32-x64-msvc/package.json +++ b/packages/llvm-win32-x64-msvc/package.json @@ -1,6 +1,6 @@ { "name": "@scriptc/llvm-win32-x64-msvc", - "version": "0.4.1", + "version": "0.4.2", "description": "Pinned LLVM code-generation helper for scriptc on Windows x64", "license": "Apache-2.0 WITH LLVM-exception", "homepage": "https://scriptc.dev", diff --git a/packages/runtime-android-arm64/package.json b/packages/runtime-android-arm64/package.json index 75c54e9c3..362fbc572 100644 --- a/packages/runtime-android-arm64/package.json +++ b/packages/runtime-android-arm64/package.json @@ -1,6 +1,6 @@ { "name": "@scriptc/runtime-android-arm64", - "version": "0.4.1", + "version": "0.4.2", "description": "Precompiled scriptc library runtime pack for Android arm64", "license": "Apache-2.0", "homepage": "https://scriptc.dev", diff --git a/packages/runtime-darwin-arm64/package.json b/packages/runtime-darwin-arm64/package.json index 7473b05f3..a4176ed60 100644 --- a/packages/runtime-darwin-arm64/package.json +++ b/packages/runtime-darwin-arm64/package.json @@ -1,6 +1,6 @@ { "name": "@scriptc/runtime-darwin-arm64", - "version": "0.4.1", + "version": "0.4.2", "description": "Precompiled scriptc runtime pack for macOS arm64", "license": "Apache-2.0", "homepage": "https://scriptc.dev", diff --git a/packages/runtime-darwin-x64/package.json b/packages/runtime-darwin-x64/package.json index ab8666c88..91bc4182b 100644 --- a/packages/runtime-darwin-x64/package.json +++ b/packages/runtime-darwin-x64/package.json @@ -1,6 +1,6 @@ { "name": "@scriptc/runtime-darwin-x64", - "version": "0.4.1", + "version": "0.4.2", "description": "Precompiled scriptc runtime pack for macOS x64", "license": "Apache-2.0", "homepage": "https://scriptc.dev", diff --git a/packages/runtime-ios-arm64/package.json b/packages/runtime-ios-arm64/package.json index a3a254685..2fdd68897 100644 --- a/packages/runtime-ios-arm64/package.json +++ b/packages/runtime-ios-arm64/package.json @@ -1,6 +1,6 @@ { "name": "@scriptc/runtime-ios-arm64", - "version": "0.4.1", + "version": "0.4.2", "description": "Precompiled scriptc library runtime pack for iOS arm64", "license": "Apache-2.0", "homepage": "https://scriptc.dev", diff --git a/packages/runtime-ios-simulator-arm64/package.json b/packages/runtime-ios-simulator-arm64/package.json index 7981422b8..cbdf96d1d 100644 --- a/packages/runtime-ios-simulator-arm64/package.json +++ b/packages/runtime-ios-simulator-arm64/package.json @@ -1,6 +1,6 @@ { "name": "@scriptc/runtime-ios-simulator-arm64", - "version": "0.4.1", + "version": "0.4.2", "description": "Precompiled scriptc library runtime pack for iOS simulator arm64", "license": "Apache-2.0", "homepage": "https://scriptc.dev", diff --git a/packages/runtime-linux-arm64-gnu/package.json b/packages/runtime-linux-arm64-gnu/package.json index d633ac303..e0d228925 100644 --- a/packages/runtime-linux-arm64-gnu/package.json +++ b/packages/runtime-linux-arm64-gnu/package.json @@ -1,6 +1,6 @@ { "name": "@scriptc/runtime-linux-arm64-gnu", - "version": "0.4.1", + "version": "0.4.2", "description": "Precompiled scriptc runtime pack for Linux arm64 glibc", "license": "Apache-2.0", "homepage": "https://scriptc.dev", diff --git a/packages/runtime-linux-arm64-musl/package.json b/packages/runtime-linux-arm64-musl/package.json index 460ca25fa..70eee223f 100644 --- a/packages/runtime-linux-arm64-musl/package.json +++ b/packages/runtime-linux-arm64-musl/package.json @@ -1,6 +1,6 @@ { "name": "@scriptc/runtime-linux-arm64-musl", - "version": "0.4.1", + "version": "0.4.2", "description": "Precompiled scriptc runtime pack for Linux arm64 musl", "license": "Apache-2.0", "homepage": "https://scriptc.dev", diff --git a/packages/runtime-linux-x64-gnu/package.json b/packages/runtime-linux-x64-gnu/package.json index 9c6336a04..5822fd21d 100644 --- a/packages/runtime-linux-x64-gnu/package.json +++ b/packages/runtime-linux-x64-gnu/package.json @@ -1,6 +1,6 @@ { "name": "@scriptc/runtime-linux-x64-gnu", - "version": "0.4.1", + "version": "0.4.2", "description": "Precompiled scriptc runtime pack for Linux x64 glibc", "license": "Apache-2.0", "homepage": "https://scriptc.dev", diff --git a/packages/runtime-linux-x64-musl/package.json b/packages/runtime-linux-x64-musl/package.json index e9f885a5c..1db34d4a7 100644 --- a/packages/runtime-linux-x64-musl/package.json +++ b/packages/runtime-linux-x64-musl/package.json @@ -1,6 +1,6 @@ { "name": "@scriptc/runtime-linux-x64-musl", - "version": "0.4.1", + "version": "0.4.2", "description": "Precompiled scriptc runtime pack for Linux x64 musl", "license": "Apache-2.0", "homepage": "https://scriptc.dev", diff --git a/packages/runtime-wasm32-wasi/package.json b/packages/runtime-wasm32-wasi/package.json index c9a40c2c0..5bbd23755 100644 --- a/packages/runtime-wasm32-wasi/package.json +++ b/packages/runtime-wasm32-wasi/package.json @@ -1,6 +1,6 @@ { "name": "@scriptc/runtime-wasm32-wasi", - "version": "0.4.1", + "version": "0.4.2", "description": "Precompiled scriptc runtime pack for WASI Preview 1", "license": "Apache-2.0", "homepage": "https://scriptc.dev", diff --git a/packages/runtime-win32-x64-msvc/package.json b/packages/runtime-win32-x64-msvc/package.json index f7e4c9860..df4a9a109 100644 --- a/packages/runtime-win32-x64-msvc/package.json +++ b/packages/runtime-win32-x64-msvc/package.json @@ -1,6 +1,6 @@ { "name": "@scriptc/runtime-win32-x64-msvc", - "version": "0.4.1", + "version": "0.4.2", "description": "Precompiled scriptc runtime pack for Windows x64 MSVC", "license": "Apache-2.0", "homepage": "https://scriptc.dev", diff --git a/packages/runtime/package.json b/packages/runtime/package.json index 1af249b9d..9232266af 100644 --- a/packages/runtime/package.json +++ b/packages/runtime/package.json @@ -1,6 +1,6 @@ { "name": "@scriptc/runtime", - "version": "0.4.1", + "version": "0.4.2", "description": "scriptc native runtime sources and vendored dependencies", "license": "Apache-2.0", "homepage": "https://scriptc.dev", diff --git a/packages/threads/package.json b/packages/threads/package.json index 2aeeb7cbb..11b8ef624 100644 --- a/packages/threads/package.json +++ b/packages/threads/package.json @@ -1,6 +1,6 @@ { "name": "@scriptc/threads", - "version": "0.4.1", + "version": "0.4.2", "description": "Zero-copy publication of immutable object graphs to worker threads (scriptc), with a deep-freezing Node.js implementation", "license": "Apache-2.0", "homepage": "https://scriptc.dev", diff --git a/packages/types/package.json b/packages/types/package.json index ffbbdf4a4..689c7b72f 100644 --- a/packages/types/package.json +++ b/packages/types/package.json @@ -1,6 +1,6 @@ { "name": "@scriptc/types", - "version": "0.4.1", + "version": "0.4.2", "description": "Contract types for scriptc: type-only annotations (Int32, NoThrow, Immutable) that scriptc checks and optimizes, with no runtime semantics", "license": "Apache-2.0", "homepage": "https://scriptc.dev", From e39ddf3d00e0b1305f4ceff4534547adace32f5c Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 13:18:04 -0500 Subject: [PATCH 101/102] Refresh the native compiler's optimization profile --- packages/compiler/native/cli.profdata.gz | Bin 1452782 -> 1634955 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/packages/compiler/native/cli.profdata.gz b/packages/compiler/native/cli.profdata.gz index 55523e76548ae821bbce8762876d84a3b3ccd182..e2f344a4d7f73f6e5b70e119a45c1e9db5fdf6d3 100644 GIT binary patch literal 1634955 zcmV);K!(2`iwFP!000021MD4loD)TNcXOTIj*fIt+V%oS@6tS~AcifocY$1TBst&& zDHe)~pjc2qu`8gWf`Vc}u>gvQilC@`B8s9YidX>oejz(|mq{k&3LKF4&&zCfr@ndf z-kUdX&N%ZtZqqTh3UL-l0)dU2-VI8>ziDSsdY6?>vC`Eoe1|iDJEYV)iyvwE(TL*s z*W)Y^d79ps(FE5uTS{q?EA^q^Bz@fXK|alXKEEM_rTJmvpBWu zYiFC()OtRrL7;~Boq8_Sk45Ww(}&L{i8~uSc=kiP_595?>1Xl1N$n{=UTZy{_-w{m zJTr6GSv(F_RHz*2ukVMS#Vu`C{a+3A?9I6~&*J|A*%H6as(KcW&kxkMVco!Ux?#1m z_`Ugo^zcyuJhofl`IfXm`tPp-cz@5p^Uthm>|PS6kk~8myteiHM8C7mAi7)6t?Chz zexa;^r-&}o+xh;N)XMtjur;J!-L9E-`*c>Y=kk(hcekbNKWeyROks zkL&om?XHH@KH}U$8gYK0q~&Iu<9cQg3Am7+^sqc2*J;ft5LlQ)EGuIjUN_k$uMfF9T-X z%oAAgcRfdjErKGFiJDWl9{u(|Y!RFyFbd0X94*s~$jWFDcUKBvfN4cCv2a9#rGNj@ z5(-B|$Wov0a=2Y~m+JAjr`dT^Vf;;z04qH4&e-WQ4sR^vL=bL~&drKT5-G%8zy18d z)EdnQB1mX0R(sXsv4g3=Q(!k`lVwkBr`*&?kZGb6aXB4isvxHm^_ubAi z;-Y9i^@_>Q#c9k&q!Irf`st>A^XuU#OAtj-Vp)#mC7D-3XgALi8?V9)P8!kPcU*sd z;bm6(H!_?I$=Ig>EeoiIsyV@Mr|N3Atv|zL-CMQu1;#B>qC8JYFjNeg-1tfLZJQcF zYtEWLQPvctv9wwf}op+%Tu>-=w9& z5sz9p)xuq2x^8%!UE;ddB8Cngec0I+)^$PHx^e;wc!6Vq%*lrijXlw+{#(gaO4v_H zaX!b_y*5!}YC9l)+B#IRDUvAd4sU

    #6I&>venj0Nts2RG-7`%FelOZSP`g&X}ef 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Ȑt9k6i}dF2La)|6;2iU-|VDt;+U@FU^I@MnkNW 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

    0n8;PO+|GJL< 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%0DsH7X?j`A@W!=`W+JG4VWYUC`O4pK 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%0A3fH>pQsO`t<97)sV;h2r8 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

    S7zDpT)IviIZ-pYd?7tTuPrKUWEbWyYr>u!Tt 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�k=enncIpVse{ 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�*Er089Uq%U)VgzeO;q@MU4O56u0EQv@f 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 z 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�QO7wMev~+5%^H*C8Aiz%MXUy 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�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