Skip to content

js_parser: keep "use strict" and the directive prologue in the output - #40838

Closed
robobun wants to merge 15 commits into
mainfrom
farm/c39b41fd/fix-use-strict-directives
Closed

robobun wants to merge 15 commits into
mainfrom
farm/c39b41fd/fix-use-strict-directives

Conversation

@robobun

@robobun robobun commented Aug 28, 2026 •

Copy link
Copy Markdown
Collaborator

Problem

  • The parser dropped every "use strict" (src/js_parser/parse/mod.rs, the skip = true prologue branch) and the bundler restored only a module-level one. So bun f.cjs ran a function with "use strict" sloppy, --minify dropped "use client", and function f(a = 1) { "use strict" } was accepted.
  • A wrapped CommonJS file in the entry chunk lost its directive (the linker tested the chunk, not the file). The transpiler cache key lacked remove_cjs_module_wrapper.

Fix

Background

  • A directive prologue is the run of string statements at the start of a script, module, or function body. Only "use strict" has semantics. "use client" marks a file for tools.
  • The runtime wraps a CommonJS file in (function(exports, require, module, ...) { ... }) (to_ast). -e, -p and stdin get the same output without the wrapper.
  • The bundler wraps a CommonJS file in __commonJS(function(exports, module) { ... }) and a required ES module in __esm(() => { ... }), with init_x() calls at sync_dependencies_end in that body.
Notes

Repros, all checked against bun 1.4.1 and esbuild 0.25.1:

  1. function f() { "use strict"; ... } in a .cjs: bun f.cjs printed sloppy false, node strict true. Now strict true. bun build --no-bundle keeps both directives.
  2. "use strict"; function f() { return typeof this } with bun build --no-bundle: the directive is printed first.
  3. a.cjs with "use strict" required from entry.js, --format=cjs: the __commonJS wrapper body starts with "use strict" and the bundle prints undefined.
  4. "use client"; export const x = 1 with --minify: output is "use client";var e=1;export{e as x};.
  5. function f(a = 1) { "use strict" } is a parse error. function h(){ "use strict"; return 010 } is a parse error with a note at the directive.
  6. { 'use strict'; var eval = 1 } and if (1) { 'use strict'; eval = 1 } parse and run.
  7. bun -e '"use strict"; console.log((function(){ return this === undefined })())' printed false, node true. Now true. Same for -p and stdin.
  8. A 50 KiB .tsx file run once, then the same bytes piped to bun -: the second run printed nothing (it got the cached wrapper function of the file and never called it). Now it prints the same output.
  9. namespace N { "use strict"; ... } in a .cts: the body ran sloppy. tsc keeps the directive in the lowered IIFE, and so does bun now.
  10. /*! @license MIT */ "use no memo"; export function Hello() {...} with --react-compiler: the opt-out was ignored because the legal comment ended the prologue scan. Same inside a function body.

Siblings covered by the tests: arrow, method, and static method bodies; "use asm" removed in both positions; duplicate directives removed; a comment before or between directives; a template literal and a late string are not directives; a class static block is not a prologue; directives stay ahead of the JSX runtime import that the transpiler injects; --target=bun --format=cjs puts the directive inside the // @bun @bun-cjs wrapper; "use strict" before init_b() in an __esm wrapper; two entry points where one requires the other (the wrapped copy keeps the directive inside its wrapper, its own chunk has it at the top); "use client"; "use strict" stays strict with the inspector attached and under bun test --coverage (both turn syntax minification off); the REPL prints "use strict" as a completion value.

Directive token rules, from ECMA-262 11.2.1: a directive is an expression statement that is a single string literal token, so ("use strict") is not one and ends the prologue, and a Use Strict Directive has no escape sequence, so "use\x20strict" is a plain directive string. The parser checks that the statement starts at the string token and compares the raw source bytes for "use strict". The escaped spelling is dropped like "use asm" (the printer cannot keep the escape), except in the REPL, where it stays the completion value. node follows both rules. esbuild 0.25.1 does not: it rejects function f(a = 1) { ("first"); "use strict" } and makes function g() { "use\x20strict"; return this } strict.

Dev server output (--format=internal_bake_dev) is a registry of module closures. Each closure opens with its own module's prologue (InsideWrapperPrefix::append_directive). The chunk top gets no copy, since the registry wrapper is not a module and a chunk-level "use strict" would apply to every module in it. The real dev server assembles its output in finish_from_bake_dev_server, so this only affects the bun build form of the format.

test/bundler/bundler_bytecode_portable.test.ts pins the bundler's output hashes. The corpus and the bundled libraries (react-dom, undici, svelte, happy-dom) contain function-level "use strict", so their output and bytecode changed. The snapshot was regenerated with --update-snapshots; only the nine bundler builds that contain such directives moved, the vm.Script entries did not. The comment that said the bundler drops function-level directives is gone. The token rules and the namespace prologue did not move any hash.

RuntimeTranspilerCache is at version 28 because the printed output of cached CommonJS modules changes, and because the features hash gains remove_cjs_module_wrapper. Follow-up, not done here: hash_for_runtime_transpiler lists the hashed fields by hand, and #38683 and #38590 each add one more. An exhaustive destructure of Features would turn a missing field into a compile error.

Sibling PRs, with their tests run against this branch:

snapshotSourceMap.mappings in expectBundled.ts used to compare positions with a matcher-less expect(a === b). main fixed that in #34552, so the rebase drops this PR's copy of the fix. The ReactSSR <html> entry is the consumer's real answer (100:19060:void).

Not part of this change: path_package_name (src/js_parser/p.rs) returns @scope for a bare require("@scope/pkg"), so a configured bare scoped package is never unwrapped. Pre-existing, tracked separately.

Kept as is, on purpose: "use strict" is omitted from an __commonJS wrapper in ESM output (esbuild prints it there, an ES module is strict already). Bun still drops an unused string expression statement outside a prologue (function f() { var x; "later" }) with or without minification, where esbuild keeps it. Not in this change.


no test proof · iteration 10 · platform-specific test(s) that do not run on this machine, deferring to CI, which covers all platforms: test/js/bun/repl/repl.test.ts, test/cli/run/run-eval.test.ts, test/bundler/transpiler/preserve-use-strict-cjs.test.ts, test/bundler/bundler_bytecode_portable.test.ts

@coderabbitai

coderabbitai Bot commented Aug 28, 2026 •

Copy link
Copy Markdown
Contributor

Review Change Stack

Note

Reviews paused

It looks like this branch is under active development. To avoid overwhelming you with review comments due to an influx of new commits, CodeRabbit has automatically paused this review. You can configure this behavior by changing the reviews.auto_review.auto_pause_after_reviewed_commits setting.

Use the following commands to manage reviews:

  • @coderabbitai resume to resume automatic reviews.
  • @coderabbitai review to trigger a single review.

Use the checkboxes below for quick actions:

  • ▶️ Resume reviews
  • 🔍 Trigger review

No actionable comments were generated in the recent review. 🎉

ℹ️ Recent review info
⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: ASSERTIVE

Plan: Pro

Run ID: 5e4845d5-6872-4567-89aa-d22653d958e3

📥 Commits

Reviewing files that changed from the base of the PR and between 0b83933 and 6e122ab.

📒 Files selected for processing (5)
  • src/js_parser/parse/parse_typescript.rs
  • src/react_compiler/program.rs
  • test/bundler/transpiler/react-compiler.test.ts
  • test/bundler/transpiler/transpiler.test.js
  • test/cli/run/run-cjs.test.ts

Included review availability: Your plan provides up to 10 included reviews per hour; 1 remains after this review.


Walkthrough

The parser preserves directive prologues as AST data, tracks strict-mode locations and legacy octal literals, and emits directives through bundler wrappers and entry points. Tests cover ordering, deduplication, strict-mode validation, runtime behavior, and output snapshots.

Changes

Directive prologue handling

Layer / File(s) Summary
Parser directive and strict-mode tracking
src/ast/*, src/js_parser/*
Directive prologues are parsed, deduplicated, and passed to Ast. Strict-mode locations, eval and arguments assignments, and legacy octal literals receive explicit tracking and diagnostics.
AST and bundled directive storage
src/ast/ast_result.rs, src/bundler/AstBuilder.rs, src/bundler/bundled_ast.rs, src/js_parser/*
Ast and BundledAst store directive slices in source order. Column registration, initialization, conversion, and flags use the new representation.
Bundler directive emission
src/bundler/LinkerContext.rs, src/bundler/linker_context/*, src/js_printer/lib.rs
HMR bodies, wrapper prefixes, and entry points emit preserved directives with strict-format filtering, quoting, and minification-aware separators.
Validation, runtime coverage, and cache format
src/jsc/RuntimeTranspilerCache.rs, test/bundler/*, test/cli/run/*, test/js/bun/repl/repl.test.ts
Tests cover directive placement, preservation, deduplication, strict-mode errors, runtime behavior, source maps, bytecode snapshots, and the cache format update.

Suggested reviewers: jarred-sumner

Merge Risk: 🔵 Low · up to 6e122

The PR changes directive parsing and emission across runtime, bundling, and transpilation paths. It is mergeable with owner awareness for a possible InternalBakeDev entry-point path that may omit directives and for test assertions that could provide less precise diagnostics if they fail.

🚥 Pre-merge checks | ✅ 4
✅ Passed checks (4 passed)
Check name Status Explanation
Linked Issues check ✅ Passed Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check ✅ Passed Check skipped because no linked issues were found for this pull request.
Title check ✅ Passed The title clearly identifies the primary change: preserving "use strict" and directive prologues in parser output.
Description check ✅ Passed The description gives detailed problem, fix, background, verification results, test coverage, and known limitations. It does not use the template headings, but it provides the required information and…
Full details: Description check

Explanation

The description gives detailed problem, fix, background, verification results, test coverage, and known limitations. It does not use the template headings, but it provides the required information and is substantially complete.


Comment @coderabbitai help to get the list of available commands.

@robobun

robobun commented Aug 28, 2026 •

Copy link
Copy Markdown
Collaborator Author
Updated 5:30 AM PT - Aug 29th, 2026

❌ @robobun, your commit 6e122ab has 1 failures in Build #108334 (All Failures):


🧪   To try this PR locally:

bunx bun-pr 40838

That installs a local version of the PR into your bun-40838 executable, so you can run:

bun-40838 --bun

@claude claude Bot left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Nothing blocking. The comments below are optional suggestions. There is no need to push a fix for them before merging.

Additional findings (outside the current diff — GitHub can't attach inline comments there):

  • 🟣 src/js_parser/parse/mod.rs — pre-existing: this PR wires legacy-octal recording into pfx_t_numeric_literal and parse_property, but skips the third TNumericLiteral sibling in parse_property_binding (the placeholder // check for legacy octal literal is left as-is), so "use strict"; const { 010: x } = obj still parses without the new "Legacy octal literals cannot be used in strict mode" error that esbuild reports. Fix: push p.lexer.range() onto p.legacy_octal_literals here when p.lexer.is_legacy_octal_literal, matching the other two TNumericLiteral arms so every numeric-literal parse site feeds the visit-time check. [also at: src/js_parser/parse/parse_property.rs:266 - pre-existing: the legacy-octal check is wired up here and in pfx_t_numeric_literal, but the third sibling with the…]

    Extended reasoning...

    parse_property_binding (src/js_parser/parse/mod.rs:1168) creates the E::Number key for object destructuring patterns and advances the lexer without recording is_legacy_octal_literal. During the visit pass, visit_binding on BObject calls visit_expr(&mut property.key) (src/js_parser/visit/mod.rs:675), which reaches e_number (src/js_parser/visit/visit_expr.rs:100-110). e_number binary-searches p.legacy_octal_literals by e.loc.start; the loc is absent, so no diagnostic is emitted even though p.is_strict_mode() is true. On base no legacy-octal check exists at all, so the same input is silently accepted there too — this is a partial fix, the sibling site the class-wide check missed. esbuild's parseBinding calls p.checkForLegacyOctalLiteral(key.Data) at this exact spot, so Bun diverges from the reference for "use strict"; const { 010: x } = {} and function f({ 010: x }) { "use strict" }.

    Verification: pre-existing — the third TNumericLiteral sibling is left unwired while the other two are updated in this PR. At src/js_parser/parse/mod.rs:1168-1172 (parse_property_binding): T::TNumericLiteral => { key = p.new_expr(E::Number::new(p.lexer.number), p.lexer.loc()); // check for legacy octal literal p.lexer.next()?; } The placeholder comment remains; nothing is pushed to…

@robobun

robobun commented Aug 28, 2026

Copy link
Copy Markdown
Collaborator Author

Wired the third numeric-literal site in 477e5f7: parse_property_binding now records a legacy octal key, so "use strict"; var { 010: x } = o reports the error like the other two sites. The three sites share record_legacy_octal_literal, which keeps the list sorted for the visit-pass binary search. Tests in transpiler.test.js.

The same push updates bundler_npm.test.ts (ReactSSR): the react development builds carry a function-level "use strict" that is now printed, which moves the pinned columns and the output size.

Comment thread src/ast/ast_result.rs Resolved
Comment thread src/ast/scope.rs Resolved
Comment thread src/bundler/LinkerContext.rs Resolved
Comment thread src/js_parser/p.rs Resolved
Comment thread src/js_parser/p.rs Resolved
Comment thread src/js_parser/p.rs Resolved
Comment thread src/js_parser/p.rs Resolved
Comment thread src/js_parser/parse/mod.rs Resolved
Comment thread src/js_parser/parse/mod.rs Resolved
Comment thread src/js_parser/parse/parse_entry.rs Resolved
Comment thread src/js_parser/parser.rs Resolved
Comment thread src/js_parser/repl_transforms.rs Resolved
Comment thread src/jsc/RuntimeTranspilerCache.rs Resolved
Comment thread src/js_parser/repl_transforms.rs Resolved

@claude claude Bot left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Nothing blocking. The comments below are optional suggestions. There is no need to push a fix for them before merging.

@robobun

robobun commented Aug 28, 2026

Copy link
Copy Markdown
Collaborator Author

Status: the diff is complete and the PR's own tests pass on every lane. In build 107936 the only red jobs were two tests that also fail on main and that this change does not touch: test/js/node/http2/h2-conformance.test.ts (darwin aarch64) and test/js/web/url/url.test.ts (darwin x64, ICU table). Both are reported for main-break triage. Everything else passed, or passed on retry. bafe579 only renames a flag for clarity.

@claude claude Bot left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Nothing blocking. The comments below are optional suggestions. There is no need to push a fix for them before merging.

Comment thread src/js_printer/lib.rs Resolved
Comment thread src/ast/ast_result.rs Resolved

@claude claude Bot left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This pull request has now been reviewed several times and this review found new issues. Before patching these one by one, step back: would one root-cause fix close several of them? Is the pull request's scope growing with each push? Prefer root-cause fixes, keep scope fixed, and note out-of-scope improvements as follow-ups.

Comment thread src/js_parser/p.rs Resolved

@claude claude Bot left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Still open from earlier reviews (1):

  • 🔴 src/js_parser/p.rs:5200 — is_valid_assignment_target now permits eval/arguments when the source scope is sloppy but never checks is_strict_mode_o…

Comment thread test/bundler/bundler_directive.test.ts Resolved
@robobun

robobun commented Aug 28, 2026

Copy link
Copy Markdown
Collaborator Author

Status at 7cdd77d: the diff is complete and every review thread is resolved. Build 107993 has two red jobs, neither touched by this change: test/js/web/url/url.test.ts on darwin x64 (fails on main too, ICU table) and test/cli/run/require-cache.test.ts on debian x64-asan, where the "don't leak file paths via import()" case (100k dynamic imports of a 21-byte file) hit its 30s timeout; the same lane passed it on retry in build 107903. Both are reported for main-break triage. The PR's own tests pass on every lane.

@claude claude Bot left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Code review found no issues

No high-confidence issues detected in this change.

A directive prologue is now recognized only at the start of a module body
or a function body (`ParseStatementOptions.allow_directive_prologue`). A
string statement at the start of a block, a class static block, or a
TypeScript namespace stays an expression statement and does not make the
enclosing scope strict.

Every prologue string, including "use strict", becomes an `S::Directive`
statement. A function-level "use strict" is printed again, the early
error for a non-simple parameter list fires, and strict mode propagates
from the function body scope to the parameter scope. `Scope.use_strict_loc`
records the directive so strict-mode error notes point at it.

The module-level prologue is stripped into `Ast.directives` (a list that
replaces the single "use strict" flag) and printed ahead of every other
statement: by `print_ast` for transpile-only output, inside the runtime
CommonJS wrapper, at the top of an entry chunk, and inside the wrapper of
a wrapped module that is not the chunk's own entry point. The wrapper
directives go before the `init_*()` dependency calls. `--minify` no longer
drops `S::Directive` statements.

Also: assigning to `eval` or `arguments` is an error only in strict mode,
and a legacy octal literal (`010`) in strict code is reported.
… in the React Compiler prologue scan

A namespace body is lowered to a function body, and tsc keeps its
directive prologue in the IIFE. Parse it with allow_directive_prologue so
`namespace N { "use strict"; ... }` runs strict in a CommonJS file.

The React Compiler reads the module-level and function-level prologue to
find "use no memo". A preserved legal comment (`/*! ... */`) ahead of the
directive used to end that scan, so the opt-out was ignored. Case from
#35473.
@robobun

robobun commented Aug 29, 2026

Copy link
Copy Markdown
Collaborator Author

Dedupe of the open directive PRs. This branch is rebased onto main (one conflict, in expectBundled.ts, where main already had the same fix) and the tests of each sibling PR were run against it. Result:

Also fixes #6854.

Not done here, noted for a follow-up: hash_for_runtime_transpiler lists the hashed Features fields by hand. #38683 and #38590 each add one more field to it. Building the hash from an exhaustive destructure would turn a missing field into a compile error.

@claude claude Bot left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Code review found no issues

No high-confidence issues detected in this change.

robobun added a commit that referenced this pull request Sep 24, 2026
…rameter

`function makeArguments(..._) { "use strict"; ... }` is a SyntaxError in
JavaScript. It compiles today only because the parser drops function-level
directives (#40838 changes that). The file is a module, so the function is
strict without the directive. A new assertion pins that the `arguments`
object is the strict kind, which is the case that upstream a0e2a50e76 fixed.
dylan-conway added a commit that referenced this pull request Sep 26, 2026
Fixes #25559

Upgrades the WebKit fork to upstream WebKit `7b485a76e9` (2026-09-23):
970 upstream commits since the previous merge base `ccdcb8a026`, about
200 of them in JavaScriptCore, WTF, bmalloc or cmake. Fork PR:
oven-sh/WebKit#725. This PR replaces #42666 (upstream `6b58d86abe`, the
first 216 commits of the range) and contains its source edits.

### Pin

- `WEBKIT_VERSION` is `f20ce77445`, the fork's main. It holds
oven-sh/WebKit#725 (the upgrade) and oven-sh/WebKit#734 (positions).
- oven-sh/WebKit#725 landed as a squash. The tree of `74650443cb` is
identical to the tree of `3a8b1bc93b`, the head that CI tested here
before. The squash has no upstream parent, so `git merge-base` with
upstream is still `ccdcb8a026`. The next upgrade must name `7b485a76e9`
as its base by hand, unless someone first records the merge on the
fork's main (`git merge -s ours` of the branch
`bun/upgrade-to-7b485a76e9`).

### Problem

- The fork is 970 commits behind upstream. #42666 stopped at
`6b58d86abe` and did not land.
- #25559: a `++array.length` loop is quadratic past 100000 elements.
Upstream `ab1caf1170` fixes `JSArray::setLength`. The loop of the issue
takes 5152 ms on the current release build and 726 ms on the debug +
ASAN build of this PR.

### Fix

- `WEBKIT_VERSION` points at the fork's main, with oven-sh/WebKit#725
and oven-sh/WebKit#734.
- `error.stack` costs what it did before the upgrade, within a few
percent (see Downsides). With offsets only, upstream reads a whole
source the first time a position in it is asked for, and decodes the
expression info again for every position. In oven-sh/WebKit#734 the
lexer notes where the lines start while it parses a whole source, the
code and its bytecode carry that table, and each position that was
looked up is kept. Nothing of that is in Bun.
- Upstream no longer stores lines and columns (`c76c52f5b1`).
`SourceCode(provider, firstLine, startColumn)` is gone, and 3 of Bun's 5
call sites would still compile with the integers read as source offsets.
All 5 now pass offsets only, and the provider's start position carries
the node:vm `lineOffset` and `columnOffset`.
- The other source edits follow upstream API changes:
`Error.stackTraceLimit` storage, `CheckedPtr` plumbing for inspector
agents, typed C strings, `ASCIICString` heap names, `char8_t` option
strings. "Notes for Bun" lists each one.
- The builtins share one text, and a `SourceCode` no longer has a first
line, so `at map (native:1:11)` had become `at map (native:3323:11)`.
The source of Bun's builtins, like that of JavaScriptCore's, is now a
`BuiltinsSourceProvider`, which is told where each builtin starts and
counts from there. `processTicksAndRejections (native:7:39)` and the
rest are what they were.
- Verified: `test/js/bun/jsc/webkit-upgrade-7b485a76e9.test.ts` (22
cases, 10 fail on main), 5 cases in `bun-build-compile.test.ts` for the
sources of an executable (fail without oven-sh/WebKit#734), 4
`Error.appendStackTrace` cases in `capture-stack-trace.test.js` (3 fail
on main) and a `SourceTextModule` position case in `vm.test.ts` (fails
on main). `test/bundler/bundler_bytecode_portable.test.ts` has a new
snapshot, because the bytecode cache format changed. 80 outputs with
positions in them are the same as on main: 20 sources, each run from a
file and compiled three ways. The Notes list the other suites.

### Background

- JavaScriptCore used to store a line and a column next to every source
offset in the parser, in `ExpressionInfo` and in the bytecode cache. It
now stores offsets only. `SourceProvider` builds a table of line starts
the first time someone asks for a line or a column, for example when
`Error.stack` is read.
- The bytecode cache (`bun build --bytecode`, `--compile`) has no line
and column fields any more. Payloads in the portability test are 3% to
6% smaller. The cache version is a hash of `WEBKIT_VERSION`, so a new
build rejects old payloads and compiles from source.
- `Error.stackTraceLimit`: JSC kept the limit in a C++ field that only a
`put` on the constructor updated. It now reads the own property of the
`Error` constructor when it captures a stack, as V8 does. Bun's default
of 10 moves to `Options::defaultErrorStackTraceLimit()`.

### Downsides

- Behaviour changes that code could depend on:
`vm.runInNewContext("Error.stackTraceLimit")` is 10 (was 100, Node gives
10). `TypeError.stackTraceLimit = n` and a setter installed on
`Error.stackTraceLimit` no longer change the limit. `BigInt("-")`,
`BigInt("+")` and `BigInt("0x ")` throw `SyntaxError` (were `0n`).
`Intl.DurationFormat("en", { hours: "numeric" }).format({ hours: 1 })`
is `"1:00:00"` (was `"1"`). `Intl.DateTimeFormat`
`resolvedOptions().dayPeriod` is `undefined` for an AM/PM pattern (was
`"short"`). `resize(-1)` and `resize(2 ** 53)` on a detached
`ArrayBuffer` throw `RangeError` (were `TypeError`, and Node throws
`TypeError`): the specification runs `ToIndex` before the detached check
(`223bd0faee`). Of 26 behaviours compared with Node 26.3, 12 changed to
Node's result and this one changed away from it.
- A position now takes a lookup in the source's table of line starts,
which the code did not need when it had its lines and columns. A stack
trace whose call sites are all new executes 3% (1 function deep) to 6%
(10 deep) more instructions than on main. The first `error.stack` in a
file takes 4 to 5 µs longer (20 µs against 15 µs at 100 KB, 27 µs
against 23 µs at 10 MB), where upstream alone takes 2.5 ms at 10 MB.
Repeated reads are 0.95 to 1.05 of main over 22 cases. In a 100 MB
module compiled with `--bytecode` the first read takes 0.03 ms and 0.6
MB of RSS, where upstream alone takes 34.5 ms and 137 MB. Loading a
module of 500 to 12,000 characters executes 2.7% to 3.6% fewer
instructions than on main. The tables are in oven-sh/WebKit#734.
- Positions that change, found by running 37 constructs through
`node:vm` and about 120 scripts of every feature that reports a position
(call sites, uncaught errors, `bun test` output, junit, inline
snapshots, coverage, `--cpu-prof`, the inspector) on main and on this
branch. Everything else was the same.
- The `new X` frame under a field initializer that throws is where the
constructor's parameters start: `4:14` (was `4:15` to `4:17`). Node
gives `4:14`.
- A position in a class field initializer on the same line as the
enclosing function has its true column: `1:45`, and `1:67` with 22
characters before it (was `1:35` for both). That is the shape of
minified code.
- `vm.SourceTextModule` applies `lineOffset` and `columnOffset` as Node
does (both were one short).
- A runtime error in a `vm.Script` with a negative `lineOffset` prints
the source line and a caret, as Node does.
- The frame that disposes a `using` is where its scope ends, `6:2` (was
the first line of the function with a column that meant nothing,
`2:12`). Node gives the last statement, `5:4`.
- The frame of an implicit base-class constructor is `unknown:1:11` (was
`unknown:1:17`). Both are positions in a text that the engine makes up.
- Bytecode holds the line starts of its source, about one byte per line.
It is still smaller than before the upgrade, because it shrank by more
(what TypeScript's `tsc` embeds with `--bytecode`: 16.49 MB to 16.17
MB). An executable without bytecode embeds what it did.
- Upstream's `WeakBlock` redesign (`7f5ab15882`, one week old upstream)
makes `WeakImpl::clear()` edit the free list and the counts of a block
without a lock. A `JSC::Weak` that is destroyed by a thread without the
API lock, or by the lock owner while it has released heap access, now
corrupts the weak blocks. I found no such call: 174,668 probed calls,
and about 4,700 tests with an assertion in `WeakBlock::deallocate`,
child processes included. Not covered: macOS, Windows, native addons
that delete a reference on their own thread, and code that no test runs.

<details><summary>Notes for Bun: every source edit, and what was
verified</summary>

New in this PR (upstream `6b58d86abe..7b485a76e9`):

- `SourceCode` (`c76c52f5b1`). `src/codegen/bundle-functions.ts`,
`JSCommonJSModule.cpp`, `NodeVM.cpp` (two sites) and
`NodeVMSourceTextModule.cpp` drop the line and column arguments. The
three-argument sites in `NodeVM.cpp` and `NodeVMSourceTextModule.cpp`
are the ones that would have compiled with the integers read as
`startOffset` and `endOffset`.
- node:vm start positions. JSC now adds the provider's start position to
every derived line and column, as unsigned numbers. The old `SourceCode`
constructor clamped `firstLine` and `startColumn` to 1. With
`lineOffset: -5`, the unclamped provider gave `e.line === 4294967293`
and broke the arrow header of compile-time errors (2 cases of
`vm.test.ts`). The new `providerStartPosition()` in `NodeVM.cpp` clamps
at zero for `vm.Script`, `vm.compileFunction` and `vm.SourceTextModule`.
`decorateParseErrorStack()` keeps its logic that applies the sign again.
Result: the same output as before this PR for negative offsets. Not
changed by this PR: `vm.compileFunction` reports the first body line one
too high for `lineOffset` 0 and 1 (`vm.js:2`, where Node prints
`vm.js:1` and `vm.js:2`). The 1.4.3 release prints the same lines as
this branch for offsets 0, 1, 5 and -3, and #38240 is the open PR for
it.
- `vm.SourceTextModule` passed zero-based numbers to the one-based
`SourceCode` arguments. With the provider as the only source of the
start position, a module with `lineOffset: n` now reports the same lines
as `vm.Script` with `lineOffset: n`, which is also what Node reports.
`vm.test.ts` has a case for it. #38235 covers the rest of the module
offsets (negative values, the identifier as the file name).
- `Error.appendStackTrace` (fork commit `eacf0ea760`). The fork's
`ErrorInstance::captureStackTrace()` called `value()` on
`JSGlobalObject::stackTraceLimit()`. The limit is empty for a value that
is not a number and for a deleted property, and since `a5bfdb3aaf` also
for `NaN` and for an accessor. `Error.stackTraceLimit = NaN;
Error.appendStackTrace(new Error("a"), new Error("b"))` aborted the
process. The string and the deleted form abort on main too. It now
captures zero frames, like `Error.captureStackTrace`.
- `ErrorStackFrame.cpp`: `ExpressionInfo::Entry` has no `lineColumn`.
`getAdjustedPositionForBytecode()` asks
`SourceProvider::documentLineColumnForOffset()` for the divot.
- `NodeVM.cpp` `decorateParseErrorStack()`: `JSTextPosition::column()`
is gone. The caret column is the distance from the token offset back to
the previous `\n` of the source, which is also how
`nthSourceLineForArrowHeader()` splits lines.
- `Error.stackTraceLimit` (`a5bfdb3aaf`):
`JSGlobalObject::setStackTraceLimit()` is gone. `JSCInitialize` sets
`Options::defaultErrorStackTraceLimit()` to 10. Every realm's `Error`
constructor starts from that option, so node:vm contexts now start at 10
(they started at 100, Node gives 10). `ShadowRealm` already had 10.
- Inspector agents (`9a8a5f7d36`): `InspectorAgentBase` derives from
`AbstractCanMakeCheckedPtr`. `InspectorLifecycleAgent`,
`InspectorTestReporterAgent`, `InspectorHTTPServerAgent` and
`InspectorBunFrontendDevServerAgent` add `CanMakeThreadSafeCheckedPtr`,
`WTF_OVERRIDE_DELETE_FOR_CHECKED_PTR` and
`OVERRIDE_ABSTRACT_CAN_MAKE_CHECKEDPTR`. The thread-safe base is what
upstream uses for agents whose controller can be destroyed on another
thread.
- `BunGCOutputConstraint.cpp`, `BunClientData.cpp` (`9b5592466b`):
marking constraint names are `ASCIICString`, so the literals take `_s`.
- `BunJSCModule.h` (`58e02c19b9`): `Options::samplingProfilerPath()` is
a `const char8_t*`, so the store takes `pathCString.data()`. The edit
adapts the type and nothing else: the statement segfaults on every call,
on main too, because the options are read-only after `Config::finalize`
(#32212), and #41137 replaces it.
- `JSSecrets.cpp` (`29a96fa550`): `CString::mutableSpan()` is protected.
`SecretsJobOptions` holds `UTF8CString`, which keeps `mutableSpan()`
public, so the destructor still zeroes the buffers. The platform
functions keep their `const CString&` parameters.
- `bindings.cpp` (`c17d3df6ec`): includes
`wtf/PlainGregorianDateTime.h`.
- `bundler_bytecode_portable.test.ts`: every hash moves, as the file's
header says for a format change. The bundled JS hashes do not move.

From #42666 (upstream `ccdcb8a026..6b58d86abe`):

- `String::utf8()` returns `UTF8CString` (`00130dc2f3`), whose `data()`
is a `const char8_t*`. 48 calls in 17 files give a NUL-terminated string
to a C function or to a format string, and they call
`legacyCStringPointer()`. The class generator emits the same pattern. 13
calls pass bytes and a length, and they use `span()`.
- `toCString()` is `toUTF8CString()` (`7189f73167`). `WeakGCMap` holds
raw pointers (`8ae0649a80`, `SecureContextCache::set()`).
`String(std::span<const char>)` is private (`74b519d7f9`,
`BunProcess.cpp`). `dataLog()` has no `const char8_t*` overload
(`BunAnalyzeTranspiledModule.cpp`).
- `scripts/verify-baseline-static/allowlist-x64-windows.txt`: this PR no
longer changes it. Its entry `__std_max_8i` was for `5e03b0c541`, which
uses `std::max` over an initializer list of `int64_t` (the MSVC STL
vectorizes that behind an `__isa_available` test). Main now lists the
code of the MSVC STL as `<lib:libcpmt.lib>` (#43704), and the merge of
main (`efdc463da7`) took that entry.
- Tests of #42666. The 5 cases of its
`webkit-upgrade-6b58d86abe.test.ts` are in
`webkit-upgrade-7b485a76e9.test.ts`, some in a longer form (the BigInt
case has its 8 operand shapes plus 6). Its
`webkit-upgrade-ccdcb8a026.test.ts` is carried over as a file: 5 cases
for the previous upstream range, which pass before and after this
upgrade.

Review of this diff (what I checked by hand, and how):

- Stack position of a class field initializer: **a regression, repaired
in the fork.** For a base class with an explicit constructor, `endpoint
= config.url` with `config === null` gave `at new Client (file.ts:7:15)`
on main (the `constructor(` line) and `at new Client (file.ts:9:21)`
with the pin `eacf0ea7` (the last statement of the constructor). Bun's
code frame then puts the caret on a line that did not throw. Cause:
upstream `c76c52f5b1`. The old `StatementNode::setLoc()` gave a scope
node the first line of the function next to the offset of its end, and a
frame used the line. Fork commit `3a8b1bc93b` gives the call the offset
where the constructor starts: `at new Client (file.ts:7:14)`, which is
what Node 26.3 prints. Upstream `main` still has the old call. The
expression info stores that offset, so the bytecode snapshot changes for
the 16 payloads that have a class with instance fields, and the 11
without one keep their hash.
- `using` and `await using`: the frame of the function that owns the
declaration moved from its first line to the statement that leaves the
scope (`work (2:14)` to `work (6:10)`). Node prints `work (6:12)`, so
this stays.
- `SourceCode` call sites: a scan of `src/` for every `SourceCode(...)`
finds 29 calls with one argument and 2 with three,
`bundle-functions.ts:468` and `JSCommonJSModule.cpp:176`. Both pass
`startOffset` and `endOffset`. No call passes a line and a column.
- `ErrorStackFrame.cpp`: `CodeBlock::expressionInfoForBytecodeIndex()`
adds `sourceOffset()` to the divot, so the divot that
`getAdjustedPositionForBytecode()` gives to
`documentLineColumnForOffset()` is an offset in the provider. Upstream's
`CodeBlock::lineColumnForBytecodeIndex()` does the same.
- `allowlist-x64.txt`: in a release build with LTO and the baseline
features, the region that the scanner counts as
`ipint_op_memory_atomic_wait64` is 43,831 bytes and has 8 AVX
instructions. They are the same sequences as in the handlers of
`v128.load8_splat`, `load16_splat`, `load32_splat` and `load64_splat` (3
+ 3 + 1 + 1). The gate is `Options.cpp:943`: `if (isX86_64() &&
!isX86_64_AVX()) Options::useWasmSIMD() = false`.
- `JSSecrets.cpp`: `mutableSpan()` copies a buffer that is shared, so
the destructor would then zero a copy. A breakpoint on
`~SecretsJobOptions()` shows a reference count of 1 for `password`,
`name` and `service` in `set`, `get` and `delete`, so the zeroing is in
place. The container has no keyring, so each call ended with
`ERR_SECRETS_PLATFORM_ERROR`.
- `FuzzilliREPRL.cpp`: no CI lane builds with `FUZZILLI_ENABLED`.
Compiled by hand with that flag, the file of this PR compiles, links and
runs. The file of main does not compile against the new WebKit (`format
specifies type 'char *' but the argument has type 'const char8_t *'`).
- Three worker test files fail on my machine and pass in CI.
`worker.test.ts` and `worker-late-completion.test.ts` hit the 5 second
limit on a host with a load average of 110 (CI, `x64-asan`: 42 of 42 in
3.5 s and 33 of 33 in 7.7 s). The `dns.lookup()` case of
`worker-terminate-lifetime.test.ts` is a LeakSanitizer report at
`node_fs_binding.rs:183` (#39684), in a container without DNS.

Measurements (Linux x64, release builds with LTO of main `8d36bff512`
and of this PR at `701805bae0`, runs interleaved A/B, host load average
about 110, so the quartiles are beside each median):

| | main q1 / median / q3 | this PR q1 / median / q3 |
|---|---|---|
| First `.stack` read, 10 MB source with 90,177 functions (15 runs) |
0.034 / 0.036 / 0.038 ms | 7.31 / 7.63 / 7.79 ms |
| Next 1,000 `.stack` reads, same source | 2.40 / 2.49 / 2.70 ms | 2.72
/ 2.82 / 2.91 ms |
| User CPU of that process | 662 / 684 / 699 ms | 647 / 649 / 665 ms |
| Peak RSS of that process | 105.9 / 106.9 / 107.1 MB | 102.5 / 103.5 /
104.6 MB |
| `new Error().stack`, 2 frames (9 runs) | 2.82 / 3.00 / 3.07 µs | 2.34
/ 3.41 / 3.57 µs |
| `new Error().stack`, 10 frames | 9.04 / 10.04 / 10.53 µs | 9.36 /
11.70 / 12.04 µs |
| `new Error().stack`, 50 frames | 38.2 / 43.3 / 43.7 µs | 39.2 / 46.9 /
49.3 µs |
| `new Error()`, 10 frames, no read of `.stack` | 0.45 / 0.63 / 0.68 µs
| 0.43 / 0.69 / 0.70 µs |
| Startup, `console.log` only, user CPU (25 runs) | 1.95 / 3.02 / 4.05
ms | 1.92 / 2.95 / 3.73 ms |
| Text section of the binary (`size`) | 80,675,832 bytes | 80,452,686
bytes |

The quartiles of the `new Error().stack` rows overlap. The medians are
higher on this PR at every depth (1.14, 1.09, 1.17 and 1.08 times), so
the slowdown is probably real and about 10%. `perf`, `valgrind` and
`strace` are not installed on the machine, so there are no instruction
counts.

`WeakImpl::clear()` and threads. A `Weak` may be destroyed by the thread
that holds the API lock while it has heap access, or by a GC thread
while the world is stopped. `WeakSet::allocate()` asserts the lock, and
nothing asserts it on deallocation. Bun releases heap access in one
place: `us_loop_run_bun_tick` (`epoll_kqueue.c`), between
`Bun__JSC_onBeforeWait` and `Bun__JSC_acquireHeapAccessAfterWait`, when
an idle collection is pending (#43681). In that window the thread runs
the poll and the mimalloc idle hooks. The libuv loop never releases
access.

Measured on Linux x64 with the debug build, with
`BUN_IDLE_GC_SECONDS=1,1,1`:

- A gdb breakpoint on `WeakImpl::clear()` that reads the owner of the
`JSLock`, the `hasAccessBit` of `Heap::m_worldState` and
`Heap::m_worldIsStopped`. 15 runs (12 worker, `MessagePort` and
`BroadcastChannel` test files, `napi.test.ts`, the upgrade test and a
workload with 3 workers, transfers, `fs` and `fetch`): 174,668 calls and
99 parks without heap access. 172,647 calls came from the lock owner
with heap access. 2,021 came from the collector thread with the world
stopped and the JS thread parked, all from `Heap::sweepArrayBuffers()`.
None came from the lock owner without access or from another thread.
- An assertion in `WeakBlock::deallocate` (not in this PR). Two controls
show that it fires: a call from a `Bun Pool` thread gives `ASSERTION
FAILED: m_heap.vm().currentThreadIsHoldingAPILock()`, and a call from a
JS thread that is parked without access gives `ASSERTION FAILED:
m_heap.hasHeapAccess()`. With that build, `test/js/web/workers`,
`test/js/node/worker_threads`, `test/js/web/broadcastchannel`,
`test/napi` and `test/js/web/abort` ran in full, and
`test/js/web/fetch`, `test/js/bun/http` and `test/js/web/streams` ran
for 12 minutes each: about 4,700 passing tests, child processes
included, no assertion failure.
- `napi_delete_reference` in a finalizer stays safe: `WeakSet::sweep`
keeps the block it walks linked (`WeakBlock::IterationScope`) and reads
the next block after the finalizers ran. This PR removes the stale
sentence from the comment there.
- The debug + ASAN `jsc` shell of this WebKit fails
`JSON-parse-reviver.js`: `JSONObject.cpp` and `CloneBase.h` both define
`JSC::WalkerState`, with 4 bytes and 1 byte, and `jsc.cpp` now uses
both. Bun does not have the problem: no file of Bun or of the
JavaScriptCore library includes the clone headers, and the test passes
in Bun (debug + ASAN and release). The fix for the shell is
oven-sh/WebKit#733.

`apply` and `arguments.length` (`a0e2a50e76`): upstream fixed
`sizeOfVarargs()` for a strict `arguments` object only. A sloppy one
with `length = 2 ** 32 + 1` still wraps to 1, before and after this PR
(Node throws `RangeError`). In a CommonJS file Bun drops a
function-level `"use strict"` (#40838), so the function of upstream's
example has a sloppy `arguments` object there.

Checked and unchanged: `runtime/JSType.h`, the fork's
`.github/workflows`, the release tarball names. The WebCore bindings
generator changes do not touch code that Bun's bindings use. JSC
options: `weakBlockPoolDivisor` (16) and `useB3SpecializeSelect` (true)
are new, none is removed.

Verified on Linux x64 with `bun run build:local` (Bun debug + ASAN
against the fork branch at `3a8b1bc93b`): `bun-debug -p 42` prints 42.
These files pass: `webkit-upgrade-7b485a76e9.test.ts` (18),
`webkit-upgrade-ccdcb8a026.test.ts` (5) and the five older
`webkit-upgrade-*.test.ts` files, `node/vm/vm.test.ts`, `vm-sourceUrl`,
`script-leak`, `sourcetextmodule-leak`, `sourcetextmodule-link-gc`,
`vm-script-fetcher-leak`, `happy-dom-vm-16277`,
`node/v8/capture-stack-trace.test.js` (68),
`bun/util/inspect-error.test.js` (39), `inspect.test.js`, `reportError`,
`error-gc-test`, `bun/test/stack.test.ts`, the inline snapshot tests,
`expect-stack-overflow-crash`, `cli/test/coverage.test.ts` (14),
`cli/inspect/` (`inspect`, `bun-inspector-protocol`, `HTTPServerAgent`,
`test-reporter`, `BunFrontendDevServer`, `compile-bytecode-tooling`),
`bun/jsc/bun-jsc.test.ts` (41),
`bun/sourcemap/internal-sourcemap.test.ts`, `bun/cookie/cookie.test.ts`,
`web/workers/worker.test.ts` (42),
`node-inspect-tests/parallel/util-inspect.test.js`, and
`bundler_bytecode_portable.test.ts` (22, with the new snapshot).
`web/fetch/fetch.test.ts` has 6 failures and `bun/http/serve.test.ts`
has 2. The same 8 fail with the release build of main in my container:
it runs as root and has no IPv6.

Not compiled locally: the Windows and macOS code paths. I read every
platform-specific use of `CString`, `utf8()`, `SourceCode` and the other
changed APIs in `src/`. CI builds them for real.

</details>

<details><summary>Upstream changes, 6b58d86abe..7b485a76e9 (754 commits,
154 touch JavaScriptCore, WTF, bmalloc or cmake)</summary>

Each commit appears once, under the most specific heading that applies.

### Needs an embedder-side change, or a check

- `c76c52f5b1` The parser and the bytecode keep source offsets only.
`SourceProvider` derives lines and columns from a lazy `LineStartTable`.
`SourceCode` loses `SourceCode(Ref<SourceProvider>&&, int firstLine, int
startColumn)` and the last two arguments of the five-argument form. An
old three-argument call still compiles, with its integers read as
`startOffset` and `endOffset`. Write `SourceCode(WTF::move(provider))`.
The start position of the provider now carries the line and column
offset. `JSTextPosition` keeps only `offset` and loses `line`,
`lineStartOffset` and `column()`. `ExpressionInfo::Entry::lineColumn`,
`UnlinkedCodeBlock::lineColumnForBytecodeIndex()` and
`CodeBlock::firstLineColumnOffset()` no longer exist. Call
`CodeBlock::lineColumnForBytecodeIndex()`,
`SourceProvider::positionInfoForOffset()` or
`SourceProvider::documentLineColumnForOffset()`.
`SourceCode::firstLine()` and `startColumn()` now build the line table.
`SourceCode::subExpression()`, `ScriptExecutable::recordParse()`,
`parseRootNode()` and `parseFunctionForFunctionConstructor()` lose their
line and column parameters. `Lexer<T>::isWhiteSpace()`,
`isLineTerminator()`, `convertHex()` and `convertUnicode()` become free
functions in `parser/SourceCharacters.h`. The bytecode cache layout is
not compatible: `CachedTypes.cpp` and the `ExpressionInfo` encoding drop
all line and column fields. A raw U+2028 or U+2029 inside a string
literal now starts a new line for reported line numbers.
https://bugs.webkit.org/show_bug.cgi?id=324564
- `a5bfdb3aaf` `JSGlobalObject::setStackTraceLimit()` and
`m_stackTraceLimit` no longer exist. `JSGlobalObject::stackTraceLimit()`
reads the own data property `stackTraceLimit` of the realm `Error`
constructor with `getDirect()`. It returns `std::nullopt` for a value
that is not a number. The initial `Error.stackTraceLimit` comes from
`Options::defaultErrorStackTraceLimit()` (default 100).
`Object.defineProperty(Error, "stackTraceLimit", { value: 3 })` and
inline-cached `Error.stackTraceLimit = n` writes now change the limit.
`TypeError.stackTraceLimit = 2` and a setter installed on
`Error.stackTraceLimit` no longer change it, which matches V8. The
commit message states a cost of about 3 ns per `new Error()`.
https://bugs.webkit.org/show_bug.cgi?id=324314
- `9a8a5f7d36` `Inspector::InspectorAgentBase` now derives from
`WTF::AbstractCanMakeCheckedPtr`. Each concrete agent must add a
`CanMakeCheckedPtr<T>` or `CanMakeThreadSafeCheckedPtr<T>` base,
`WTF_OVERRIDE_DELETE_FOR_CHECKED_PTR(T)` and a public
`OVERRIDE_ABSTRACT_CAN_MAKE_CHECKEDPTR(...)`. Upstream uses the
thread-safe base where teardown can run on another thread.
`JSGlobalObjectInspectorController` now holds agents as `CheckedPtr`
members and declares `m_agents` before them. `m_consoleClient` is now
`const`, so a constructor must call `lazyInitialize(m_consoleClient,
...)`. https://bugs.webkit.org/show_bug.cgi?id=324216
- `9b5592466b` JSC heap names change type from `CString` to
`ASCIICString`. This applies to the constructors of `Subspace`,
`IsoSubspace`, `CompleteSubspace`, `PreciseSubspace`,
`MarkingConstraint`, `SimpleMarkingConstraint`, `SlotVisitor` and
`AbstractSlotVisitor`, and to `MarkingConstraintSet::add()`.
`ASCIICString` has an implicit constructor from `ASCIILiteral`, but its
`const char*` constructor is `explicit`. A caller that passes a plain
literal must add `_s`. `Subspace::name()`, `MarkingConstraint::name()`,
`abbreviatedName()` and `AbstractSlotVisitor::codeName()` now return
`const ASCIICString&`. `ProfilerSupport::markStart()`, `markEnd()`,
`mark()` and `markInterval()` now take `UTF8CString&&`.
`StringPrintStream::toASCIICString()` and `WTF::toASCIICString()` are
new. https://bugs.webkit.org/show_bug.cgi?id=324651
- `58e02c19b9` `OptionsStorage::OptionString` in `runtime/OptionsList.h`
changes from `const char*` to `const char8_t*`. All string option
accessors, for example `Options::samplingProfilerPath()`, now have that
type. The option stores the raw pointer and does not copy the string.
`SourceProvider::sourceCodeDumpFilePath()` takes and returns
`UTF8CString`. WTF adds `String(const char8_t*)` and
`printInternal(PrintStream&, const char8_t*)`. Four sites that decoded
option paths as Latin-1 now decode them as UTF-8.
https://bugs.webkit.org/show_bug.cgi?id=324652
- `c17d3df6ec` `WTF::GregorianDateTime` and `wtf/GregorianDateTime.h` no
longer exist. `PlainGregorianDateTime` moves from
`JavaScriptCore/PlainGregorianDateTime.h` (namespace `JSC`) to
`wtf/PlainGregorianDateTime.h` (namespace `WTF`, with a global `using`).
`PlainGregorianDateTime::fromMilliseconds(double)` and
`currentLocalTime()` replace the old constructor and
`setToCurrentLocalTime()`. The class is a 64-bit payload without
setters, `yearDay()`, `operator tm()` or the `offsetOf...()` functions.
`DateCache::msToGregorianDateTime()`,
`DateInstance::gregorianDateTime()` and `formatDateTime()` already used
`PlainGregorianDateTime`. https://bugs.webkit.org/show_bug.cgi?id=324677
- `29a96fa550` `CString(ASCIILiteral)`, `CString(CStringBuffer*)`,
`CString::mutableSpan()`, `mutableSpanIncludingNullTerminator()` and
`grow()` are now `protected`. `CString(const std::string&)` no longer
exists. `UTF8CString`, `Latin1CString` and `ASCIICString` keep
`mutableSpan()`, `grow()` and the `ASCIILiteral` constructor public.
`safePrintfType(const Latin1CString&)` is deleted.
`JIT::compileTimeStats()` returns `UncheckedKeyHashMap<ASCIICString,
Seconds>`. https://bugs.webkit.org/show_bug.cgi?id=324791
- `99452a3d81` `CString::newUninitialized()` becomes `protected`. Call
`ASCIICString::newUninitialized()`, `UTF8CString::newUninitialized()` or
`Latin1CString::newUninitialized()`. `WTF::setCrashLogMessage()` (Cocoa)
now takes `UTF8CString&&`. `wtf/Forward.h` now exports `ASCIICString`,
`UTF8CString`, `Latin1CString` and `CStringWithEncoding` to the global
namespace. https://bugs.webkit.org/show_bug.cgi?id=324692
- `fd27a24dd1` `StringTypeAdapter<CString>` has a deleted constructor.
`makeString()` and `StringBuilder::append()` reject an untyped `CString`
at compile time. Keep the typed value (`auto s = string.utf8()`), or
pass a span. `TextStream` declares `operator<<(const CString&)` as `=
delete`. `WTF::safeStrerror()` returns `UTF8CString`, and its `length()`
is now the message length.
https://bugs.webkit.org/show_bug.cgi?id=324230
- `eefa5dc4c3` `CString` loses `CString(std::span<const
Latin1Character>)` and `CString(std::span<const char8_t>)`. For bytes
with no known encoding, write `CString(byteCast<char>(bytes))`. For
text, use a typed constructor such as `UTF8CString {
byteCast<char8_t>(bytes) }`. `URLHelpers::userVisibleURL()` now takes
`std::span<const char8_t>`. `TextStream` gains `operator<<` overloads
for the typed strings. https://bugs.webkit.org/show_bug.cgi?id=324082
- `7e37c8055a` `WTF::toHexCString()`, `SHA1::hexDigest()` and
`SHA1::computeHexDigest()` return `ASCIICString`.
`CStringWithEncoding::legacyCStringPointer()` now exists only for
`UTF8CString`. On an `ASCIICString`, call `data()`.
`Wasm::NameSection::setHash()` takes `const
std::optional<ASCIICString>&`.
https://bugs.webkit.org/show_bug.cgi?id=324076
- `8217890851` `SHA1::addBytes(const CString&)` and
`Persistence::Coder<CString>` no longer exist.
`base64EncodeToStringReturnNullIfOverflow(const CString&, ...)` now
takes `const Latin1CString&`.
https://bugs.webkit.org/show_bug.cgi?id=324322
- `f5430ef75d` Intl code carries locale identifiers as `ASCIICString`.
`canonicalizeUnicodeLocaleID()`,
`localeIDBufferForLanguageTagWithNullTerminator()`,
`IntlCache::getBestDateTimePattern()` and
`IntlCache::getFieldDisplayName()` take `const ASCIICString&`. WTF adds
`StringView::ascii()` and `StringImpl::asciiForCharacters()`.
`IntlCache::canonicalizeUnicodeLocaleID()` returns a null `String` for a
non-ASCII tag without an ICU call.
https://bugs.webkit.org/show_bug.cgi?id=324324
- `7f5ab15882` `WeakBlock` now counts its allocated, live and dead
`WeakImpl` slots, so `Heap` no longer scans logically-empty blocks.
`Heap` pools empty blocks for all `WeakSet`s, and block stealing no
longer skips a `MarkedBlock` that had `WeakBlock`s. The new option
`weakBlockPoolDivisor` (default 16) keeps one pooled block per 16
`MarkedBlock`s. `WeakImpl::clear()` moves to `WeakBlock.h`. It now
updates the free list and the counters of the block without a lock, and
it can release the block. The old `clear()` only wrote a tag.
`Heap::addLogicallyEmptyWeakBlock()`, `WeakBlock::SweepResult`,
`takeSweepResult()`, `isLogicallyEmptyButNotFree()` and
`disconnectContainer()` no longer exist. New: `Heap::weakBlockCount()`,
`$vm.weakBlockCount()`, and `alignedMalloc()` plus `tryAlignedMalloc()`
on `FastMalloc` and `FastCompactMalloc`.
https://bugs.webkit.org/show_bug.cgi?id=324140
- `7692eececb` `WeakGCSet<T>` stores raw `T*` values, like `WeakGCMap`
since `8ae0649a80`. `reconcileWeakReferencesAtGCEnd()` removes unmarked
entries in eden and full collections. Iteration yields `T*`, and each
entry is live. `WeakGCSetHash` and `WeakGCSetHashTraits` no longer
exist. `JSGlobalObject::WeakCustomGetterOrSetterHash<T>::hash()` and
`equal()` take `T*`. `WeakGCSet.h` and `WeakGCSetInlines.h` no longer
include `WeakInlines.h`. https://bugs.webkit.org/show_bug.cgi?id=324122
- `aa19dc61a0` The last parameter of the `IsoSubspace` constructor
changes from `std::unique_ptr<AlignedMemoryAllocator>&&` to
`AlignedMemoryAllocator*`, with default `nullptr`. `ISO_SUBSPACE_INIT`
needs no edit. All `IsoSubspace` objects now share
`Heap::fastMallocAllocator`, and structure subspaces share the new
`Heap::structureAllocator`. A `LocalAllocator` can thus steal an empty
`MarkedBlock` from any subspace on the same allocator. The option
`stealEmptyBlocksFromOtherAllocators` (default `true`) still controls
this. `AlignedMemoryAllocator::registerDirectory()`,
`registerSubspace()`, `firstDirectory()` and
`Subspace::findEmptyBlockToSteal()` no longer exist. This is the second
landing of `fe81aba198`, which upstream reverted in the previous range.
https://bugs.webkit.org/show_bug.cgi?id=324020
- `d2cffa902f` JSC's `CloneSerializerBase` and `CloneDeserializerBase`
now handle `ArrayBuffer`, `SharedArrayBuffer`, typed arrays, `DataView`,
`WebAssembly.Module` and shared `WebAssembly.Memory`. The
`CloneDeserializerBase` constructor has a new fourth parameter of type
`CloneDeserializationSideChannels`. `CloneSerializerBase` gets a second
template parameter `SideChannelsType`.
`ArrayBufferContents::shareWith()` and its `operator bool()` become
`const`. Bun's `SerializedScriptValue.cpp` has its own serializer and
does not use these classes.
https://bugs.webkit.org/show_bug.cgi?id=324104

### Runtime, parser and builtins

- `7b485a76e9` The bytecode compiler emits a guarded
`op_construct_varargs` for `Reflect.construct(target, args[,
newTarget])` call sites. The guard makes the ordinary call when the
callee is not the original `Reflect.construct` or the arguments fail its
validation. Microbenchmarks are 1.42x to 3.43x faster. On the fast path,
`Error.stack` has no native `construct` frame between the constructor
and the caller. The new `LinkTimeConstant::reflectConstructFunction`
shifts the values of later `LinkTimeConstant` entries, which cached
bytecode stores. https://bugs.webkit.org/show_bug.cgi?id=324411
- `a89c41295f` `StringToBigInt` now needs at least one digit after a
sign or a radix prefix. `BigInt("-")`, `BigInt(" + ")` and `BigInt("0x
")` throw a `SyntaxError`. They returned `0n` before. `0n == "-"` is now
`false`. https://bugs.webkit.org/show_bug.cgi?id=324127
- `a848db6782` A parenthesized assignment target no longer gives its
name to an anonymous function or class. `(fn) = function () {}` leaves
`fn.name` as `""`. The rule also covers `??=`, `||=`, `&&=` and
destructuring defaults. https://bugs.webkit.org/show_bug.cgi?id=324430
- `ab1caf1170` `JSArray::setLength` skips `countElements()` when the new
length fits in the current vector. A `++array.length` loop past 100000
elements was quadratic. The microbenchmark goes from 2123.65 ms to 5.31
ms. The commit message links
https://github.com/oven-sh/bun/issues/25559.
https://bugs.webkit.org/show_bug.cgi?id=324306
- `433f888ace` `Error.stackTraceLimit = NaN` now clears the internal
limit, and new errors get no `stack`. The old code clamped `NaN` to `0`.
https://bugs.webkit.org/show_bug.cgi?id=323427
- `a0e2a50e76` `sizeOfVarargs()` clamps the `length` of a strict
`arguments` object before it compares it with the argument limit.
`arguments.length = 2 ** 32 + 1; g.apply(null, arguments)` now throws
`RangeError`. https://bugs.webkit.org/show_bug.cgi?id=324226
- `da75c48c45` `ArrayBuffer.prototype.slice` uses the species watchpoint
only when the receiver belongs to the current realm.
`ArrayBuffer.prototype.slice.call(otherRealm.buffer, 0, 8).constructor`
is now `otherRealm.ArrayBuffer`.
https://bugs.webkit.org/show_bug.cgi?id=324619
- `c5c46669ba` `Intl.DateTimeFormat` sets `dayPeriod` only from pattern
characters `b` and `B`, not from the AM/PM marker `a`.
`resolvedOptions().dayPeriod` for `{ hour: "numeric", minute: "2-digit"
}` is now `undefined`. `formatToParts()` still reports the AM/PM marker
as a `dayPeriod` part. https://bugs.webkit.org/show_bug.cgi?id=324559
- `9aea44e083` `Intl.DurationFormat` uses `"always"` as the display
default for minutes and seconds that follow a `"numeric"` or `"2-digit"`
unit. `new Intl.DurationFormat("en", { hours: "numeric" }).format({
hours: 1 })` returns `"1:00:00"`, not `"1"`.
https://bugs.webkit.org/show_bug.cgi?id=324561
- `6319f7420d` `BytecodeGenerator::emitUsingBodyScope()` emits the jump
to `skipSlot` before it ends the try range of each dispose call. DFG
failed in `DFGOSRAvailabilityAnalysisPhase` for some `using` and `await
using` code before. https://bugs.webkit.org/show_bug.cgi?id=324005
- `df94b6ccbb`, `9a38124281` Upstream `JSBigInt` gets Toom-3
multiplication (smaller operand of at least 508 digits) and
Schönhage-Strassen FFT multiplication. Both are ports of V8. The fork
already has both, with the `InterruptCheck` plumbing, so the merge keeps
the fork's versions. https://bugs.webkit.org/show_bug.cgi?id=323587
https://bugs.webkit.org/show_bug.cgi?id=324209
- `d2d61f8871` `JSBigInt` multiplication (`multiplySchoolbook`,
`multiplySpecialLow`, `multiplySpecialHigh`, `multiplyComba` and the
fixed-size variants) uses `std::span` in place of raw pointers. Results
do not change. https://bugs.webkit.org/show_bug.cgi?id=324494
- `ea153e64fb`, `d7240f488f`, `34ccaa804c` `CloneSerializerBase` and
`CloneDeserializerBase` follow JSC throw-scope style and stop at the
first exception. The `jsc` shell adds `structuredClone(value, { transfer
})`. Bun has its own serializer.
https://bugs.webkit.org/show_bug.cgi?id=324423
https://bugs.webkit.org/show_bug.cgi?id=324429
https://bugs.webkit.org/show_bug.cgi?id=324474
- `2a24a9aa7c` `JSClassCreate()` retains
`JSClassDefinition.parentClass`, and the `OpaqueJSClass` destructor
releases it. https://bugs.webkit.org/show_bug.cgi?id=319684
- `8ca47457ed` The new private header `JavaScriptCore/JSStringRefCPP.h`
adds `utf8CString(JSStringRef)` and `createJSString()`.
https://bugs.webkit.org/show_bug.cgi?id=324435
- `18073b9f6c` `JSTypedArrayConstructors.h` declares the explicit
`s_info` specializations for each typed array constructor and for
`JSDataViewConstructor`. Include it before a call to `info()` on these
classes. https://bugs.webkit.org/show_bug.cgi?id=324514
- `125543708a` `TypeProfiler::typeInformationForExpressionAtOffset()` no
longer dereferences a null `TypeLocation`.
https://bugs.webkit.org/show_bug.cgi?id=323314
- `c5fe81278b` `JSObject::crashDueToEmptyValueAtValidOffset` reports new
diagnostic data. The crash reason constant changes to
`0x100900d0ff5e7bad`. https://bugs.webkit.org/show_bug.cgi?id=324194

### RegExp (Yarr)

- `7aeed1e3bd` Non-global `String.prototype.replace(regexp, "")` returns
a substring cell of the subject when the match touches either end.
`string-replace-regexp-strip-prefix` is 2.30x faster.
https://bugs.webkit.org/show_bug.cgi?id=323409
- `ae0a88e6c1` A `\k<name>` back reference in a lookbehind no longer
matches empty when its group is the last group opened.
`/(?<n>.)..(?<=\k<n>.)/.exec("abc")` now returns `null`.
https://bugs.webkit.org/show_bug.cgi?id=324402
- `d8a2cff958` The DFG and FTL anchored first-character filter for
`RegExp.prototype.test` runs only when `lastIndex` is an Int32. Other
`lastIndex` values take the slow path, so the `ToLength(lastIndex)` side
effects stay observable after tier-up.
https://bugs.webkit.org/show_bug.cgi?id=324307
- `d22fa241f1` `SpeculativeJIT::emitRegExpMinimumLengthFilterGuards()`
no longer asserts when base and argument share a register, as in
`re.test(re)`. Debug builds only.
https://bugs.webkit.org/show_bug.cgi?id=324211

### JIT (LLInt, Baseline, DFG, FTL, B3, Air)

- `e57b0d1670` DFG stores OSR exits as a delta-encoded byte stream,
`DFG::OSRExitStream`, and decodes a `DFG::OSRExit` on demand.
`DFG::JITCode::m_osrExit` becomes `m_osrExits`. Exit data in one
JetStream3 run drops from 47.7 MB to 6.3 MB.
https://bugs.webkit.org/show_bug.cgi?id=323407
- `219167e2b4`, `7a5cfe078b` A linked DFG or FTL OSR exit entrance is
now one near call, and the return address identifies the exit. A DFG
entrance shrinks from 8 to 4 bytes on ARM64 and from 11 to 5 bytes on
x86_64. An FTL entrance shrinks from 20 to 4 bytes on ARM64 and from 10
to 5 bytes on x86_64. `DFGOSRExitBase.h` adds `static_assert(isARM64()
|| isX86_64())`. https://bugs.webkit.org/show_bug.cgi?id=324137
https://bugs.webkit.org/show_bug.cgi?id=324407
- `4dbb362ca1` `CodeBlock::updatePredictionsConcurrently()` updates
value profile and array profile predictions without a lock. The Baseline
JIT compiler thread and concurrent GC marking call it, so array profile
updates also move off the main thread.
https://bugs.webkit.org/show_bug.cgi?id=324016
- `418114c05c` `abstractAccess()` calls `entry.prepareToWatch()` when it
resolves a put to a `ClosureVar`. DFG could fold a module variable to a
stale value after an import cycle. This is the upstream form of the
fork's #624, and the merge takes upstream's test files.
https://bugs.webkit.org/show_bug.cgi?id=324124
- `5d1761dffb` DFG SSA lowering emits a separate `CheckInBounds` node
for `StringAt` and `StringCodePointAt`. FTL could remove the bounds
check together with an unused node before. Then `s.codePointAt(i) ===
undefined` stayed `false` for an out-of-bounds `i`.
https://bugs.webkit.org/show_bug.cgi?id=323640
- `54277a51f5` The DFG bytecode parser checks for `BadStringType` exit
sites before it compiles a by-val access as `CheckIdent` plus by-id. A
non-atom key such as `name.toLowerCase()` caused the same OSR exit after
each recompilation. The microbenchmark is 8.03x faster.
https://bugs.webkit.org/show_bug.cgi?id=323839
- `51a07f95fd` The DFG abstract interpreter and the DFG and FTL
`compileSpread()` take the original `Set` structure from the realm of
`node->child1()`. With a cross-realm `Set`, the compiler could treat
`[...set]` as free of side effects.
https://bugs.webkit.org/show_bug.cgi?id=321705
- `4dcc426f83` `B3LowerToAir` checks `crossesInterference()` before it
fuses or moves an `AtomicWeakCAS` or `AtomicStrongCAS` into a later
`Branch` or compare. A wasm `i32.atomic.rmw.cmpxchg` could move past a
`memory.grow` and use a stale memory base.
https://bugs.webkit.org/show_bug.cgi?id=319842
- `9c6d017806` `doneLocation` moves from `PropertyInlineCache` to
`RepatchingPropertyInlineCache`. `HandlerPropertyInlineCache` shrinks
from 88 to 80 bytes. `CodeBlock::findPropertyCache()` no longer exists.
https://bugs.webkit.org/show_bug.cgi?id=324424
- `e87ea0e64e` The specialize-select transform leaves
`B3::ReduceStrength` and becomes the new phase `B3::specializeSelect()`.
The new option `useB3SpecializeSelect` (default `true`) controls it.
https://bugs.webkit.org/show_bug.cgi?id=324673
- `95cec227df`, `7ae08af38b`, `7825a32d2b`, `fda68a8bb0`, `d6cc5eaa35`,
`d7fa43a33f`, `0aad9d201d`, `ba0e7b4024` Compile-time work in Air and
B3: `LiveRange` uses `Vector<Interval, 4>`, `IntervalSet` gets a bulk
constructor, `WTF::Liveness` gets a streaming adapter mode,
`fixObviousSpills` tracks aliased registers in register sets, the dense
liveness budget rises from 4 MB to 8 MB,
`IntervalSet::verifyCoverageConsistency` is a no-op in release builds,
and `B3::Procedure::deleteAllVariables()` is new. Generated code does
not change. https://bugs.webkit.org/show_bug.cgi?id=324009
https://bugs.webkit.org/show_bug.cgi?id=324750
https://bugs.webkit.org/show_bug.cgi?id=324795
https://bugs.webkit.org/show_bug.cgi?id=324695
https://bugs.webkit.org/show_bug.cgi?id=324716
https://bugs.webkit.org/show_bug.cgi?id=324688
https://bugs.webkit.org/show_bug.cgi?id=324759
https://bugs.webkit.org/show_bug.cgi?id=325058

### WebAssembly

- `5ad2bece76` IPInt handler slots shrink from 256 to 128 bytes on
ARM64, and large handlers jump to out-of-line code. offlineasm gains
`bc`, `loadbinc`, `loadbpreinc` and `orlshifti`.
`LowLevelInterpreter.cpp` adds `OFFLINE_ASM_ALIGN_TRAP_128` for Windows
ARM64. The commit message reports about 5% faster IPInt execution.
https://bugs.webkit.org/show_bug.cgi?id=324059
- `b9d477930e` `Heap::finalizeWasmCalleeCleanup()` calls
`WTF::crossModifyingCodeFence()` before it releases Wasm callees.
https://bugs.webkit.org/show_bug.cgi?id=320401
- `778a559d30` Both WasmToJS stubs also store the IPInt `MC` register in
the new `Wasm::WasmToJSIPIntMCSlot`. `Wasm::WasmToJSScratchSpaceSize`
grows from 16 to 32 bytes.
https://bugs.webkit.org/show_bug.cgi?id=324832
- `08f5b5c35e` `JSWebAssemblyInstance::setDebugId()`, `debugId()` and
`m_debugId` exist only under `ENABLE(WEBASSEMBLY_DEBUGGER)`, which
JSCOnly does not set. https://bugs.webkit.org/show_bug.cgi?id=324189
- `f2bd414de3`, `6452e03b9f`, `d8d3577549`, `74efecb8e0`, `a57cde3b59`,
`0aac8dcd47`, `9f9aae3434`, `073031147c` Wasm debugger fixes and the new
`qWasmStackValue` packet. All of this code is under
`ENABLE(WEBASSEMBLY_DEBUGGER)`, which only `PLATFORM(MAC)` sets.

### GC and memory

- `6c0de596d5` `BlockDirectory::findBlockForAllocation()` prefetches the
`MarkedBlock` header before the sweep that builds the free list.
`BlockDirectory::m_blocks` stores `std::pair<MarkedBlock::Handle*,
MarkedBlock*>`. `MarkedBlock::Handle` moves the rarely used `m_weakSet`
behind `m_block`. https://bugs.webkit.org/show_bug.cgi?id=324632

### WTF and bmalloc

- `6c6e928fdc` `WTF::loadLoadFence()` and `WTF::loadStoreFence()` emit
`dmb ishld` on ARM64. They emitted the full `dmb ish` barrier before.
https://bugs.webkit.org/show_bug.cgi?id=324352
- `ce646f1f85`, `3ff034369d`, `2d8b6e5a48`, `95a960a3ae`
`SAFE_WTFLOGALWAYS`, `LOG`, `RELEASE_LOG`, `ASSERT_WITH_MESSAGE` and the
signpost macros convert each argument with `WTF::logPrintfType()`. A
call site can pass a typed C string for `%s`. The helpers move from
`wtf/StdLibExtras.h` to `wtf/Assertions.h`. Existing callers need no
edit. https://bugs.webkit.org/show_bug.cgi?id=324090
https://bugs.webkit.org/show_bug.cgi?id=324142
https://bugs.webkit.org/show_bug.cgi?id=324287
https://bugs.webkit.org/show_bug.cgi?id=324236
- `f83706791b` `CStringWithEncoding::isolatedCopy()` is new.
`CStringBuffer` does not have a thread-safe reference count.
https://bugs.webkit.org/show_bug.cgi?id=319652
- `2d30c8e50c` `StringImpl::simplifyWhiteSpace()` returns `*this`
without allocation when the string is already simplified.
https://bugs.webkit.org/show_bug.cgi?id=324694
- `fbc14a1c5a` `wtf/text/StringCommon.h` adds a SIMD
`countMatchedCharacters()` overload for a compile-time character set.
https://bugs.webkit.org/show_bug.cgi?id=324640
- `77e8645084` `WTF::switchOn()`, `switchOnTupleAtIndex()` and
`WTF::apply()` mark their functor parameters `NOESCAPE`.
https://bugs.webkit.org/show_bug.cgi?id=324320
- `9e74021a2f` `Borrow::~Borrow()` asserts (debug only) that the object
is still borrowed when the borrow ends.
https://bugs.webkit.org/show_bug.cgi?id=324545
- `01f33be1d1` `determineTZoneMallocFallback()` selects
`ForceFastMalloc` when libpas uses MTE (Apple internal SDK on arm64e
only). https://bugs.webkit.org/show_bug.cgi?id=323981

### Build system and platform

- `a2a6f364bf` `WebKitCompilerFlags.cmake` adds `-fwrapv` for GCC, Clang
and `clang-cl` builds when the compiler accepts it. Signed integer
overflow in JSC, WTF and bmalloc code now wraps. Bun compiles its own
C++, which includes JSC inline code, without `-fwrapv`.
https://bugs.webkit.org/show_bug.cgi?id=324351
- `a306abc2c0` `Source/bmalloc/mimalloc/CMakeLists.txt` calls
`add_subdirectory(mimalloc EXCLUDE_FROM_ALL)`. `USE_MIMALLOC=ON` stops
the configure step when CMake is older than 3.25.
https://bugs.webkit.org/show_bug.cgi?id=324458
- `8009ddd215` `wtf/cocoa/MemoryFootprintCocoa.cpp` implements
`memoryFootprint()` with a call to a new overload,
`memoryFootprint(mach_port_t)`. `wtf/MemoryFootprint.h` declares that
overload only under `PLATFORM(COCOA)`, but the JSCOnly port compiles the
file on all Apple targets. The fork widens the guard to `OS(DARWIN)`.
https://bugs.webkit.org/show_bug.cgi?id=323690
- `fd4a9d09bf` `WebKitCommon.cmake` sets
`CMAKE_POSITION_INDEPENDENT_CODE` only when `NOT APPLE`. The fork keeps
its `NOT USE_BUN_JSC_ADDITIONS` condition as well.
https://bugs.webkit.org/show_bug.cgi?id=325064
- `5a819a7b96`, `d00124d9d7`, `6f39f11c5e` `WebKitCommon.cmake` records
the build settings with `set-webkit-configuration` when the build
directory is under the WebKit product directory. The step is not fatal,
and Bun's build directory does not match.
https://bugs.webkit.org/show_bug.cgi?id=324135
https://bugs.webkit.org/show_bug.cgi?id=324558
https://bugs.webkit.org/show_bug.cgi?id=324648
- `5bb1c6d49c` `WebKitCommon.cmake` derives `WTF_CPU_*` from
`CMAKE_OSX_ARCHITECTURES` on Apple hosts when that variable names one
architecture. This corrects an x86_64 build on an arm64 Mac, including
the offlineasm backend choice.
https://bugs.webkit.org/show_bug.cgi?id=319646
- `94ff070fff` `_WEBKIT_ADD_CODE_SIGN` reads entitlements from the
`CODE_SIGN_ENTITLEMENTS` target property. The fork keeps its early
`return()` for `CMAKE_CROSSCOMPILING`.
https://bugs.webkit.org/show_bug.cgi?id=324292
- `5cc3f23625` `WebKitCompilerFlags.cmake` no longer sets
`CMAKE_COMPILE_WARNING_AS_ERROR` for `DEVELOPER_MODE` builds on Windows.
https://bugs.webkit.org/show_bug.cgi?id=324157
- `61b575f0d0`, `2834de45ef`, `78c1083fa2`, `27504b2544` Build fixes and
one removed CMake option (`ENABLE_SWIFT_DEMO_URI_SCHEME`). No effect on
a JSCOnly build.

### Reverted within the range

- `b34e745e23` Upstream reverts the Linux main-thread detection from
317619@main (`getpid() == gettid()`), which aborted hosts that start WTF
on another thread. The fork had disabled that path under
`USE(BUN_JSC_ADDITIONS)`. The merge drops the fork's guards.
https://bugs.webkit.org/show_bug.cgi?id=322394
- `6ba0c9f709` and `d6e6a0fc1f` (`wtf/EscapableByteSpan.h`),
`14d632bf1e`, `0d533fd7f0` and `4dbba08d80` (Xcode PGO settings),
`d6f958d63e`, `e13c60e3d5` and `5a1e7b740f` (a web preference),
`3f7093e05c` (a web preference). No net effect on JSC.

### WebCore-only or no effect on a JSC embedder

`0d729748ef`, `162c4db3f1`, `a91d249a05`, `bf4e2de4fd`, `4ebc2a99c1`,
`3e95a187a1`, `648bbc69d1`, `3e1e77d2ba`, `a0df39e48d`, `fa1ff79d59`,
`27621d5adf`, `56909e17f9`, `d49b603f37`, `55f5311df8`, `13d5142b78`,
`484abf80fd`, `e887d63b22`, `d07436ebd4`, `49649b12d8`, `6307d48da4`,
`1aa6a33856`, `d0755e594a`, `7c5bf4eb1f`, `6b34ce7a2b`, `9c43b4a109`,
`56677f10e9`, `e25f645b0f`, `5fa37cf1fa`, `12a60d1a39`, `88ebf35179`,
`fc260f4e1c`, `263f9383d1`, `a749c7f864`, `d9eaeec654`, `06c8bf6974`,
`1666648452`, `a7c26d671b`, `6c721682be`, `3a633e3e57`, `02ad1221be`,
`36a3ac72aa`, `3113b23fc2`, `9467789fc1`, `41a9dfe94e`, `0ac65b1a46`.

</details>

<details><summary>Upstream changes, ccdcb8a026..6b58d86abe (216 commits,
47 touch JavaScriptCore, WTF, bmalloc, cmake or JSTests)</summary>

#42666 has the full list for this part of the range (runtime, GC,
RegExp, JIT, WebAssembly, WTF and build changes). These are its entries
that need an embedder-side change or a check.

Each entry says what a caller must change. Some entries need a check
only, and say so.

- `74b519d7f9` `WTF::String(std::span<const char>)` is now private, next
to `String(const char*)`, because `char` carries no encoding. Callers
name the encoding: `String::fromLatin1(std::span<const char>)` (new
overload), `String(std::span<const Latin1Character>)`,
`String::fromUTF8(...)` or `String(ASCIILiteral)`. In the same commit
`WTF::enumName()` and `WTF::enumTypeName()` (`wtf/EnumTraits.h`) return
`ASCIILiteral`. They returned `std::span<const char>` before, so callers
now test `isEmpty()` and not `empty()`.
https://bugs.webkit.org/show_bug.cgi?id=323650
- `7bd7b6dfad` `CString` gains `legacyCStringPointer()`, which returns
the same `const char*` as `data()`. Every upstream `utf8().data()` call
site moves to it. `CStringWithEncoding::characters()` (the `const char*`
accessor of `UTF8CString` and `ASCIICString` from `5f14e32e57`) is
renamed to `legacyCStringPointer()`. No type changes in this commit. It
is the mechanical half of the retype of `String::utf8()`. The retype
itself is `00130dc2f3`, the next entry.
https://bugs.webkit.org/show_bug.cgi?id=323722
- `00130dc2f3` `String::utf8()`, `StringImpl::utf8()`,
`StringView::utf8()` and `Identifier::utf8()` now return `UTF8CString`.
They returned `CString` before. `UTF8CString` is the alias
`CStringWithEncoding<char8_t>` (alias in `wtf/Forward.h`, class in
`wtf/text/CString.h`). The siblings are `Latin1CString`
(`Latin1Character`) and `ASCIICString` (`char`). `CStringWithEncoding`
is a final class that derives publicly from `CString` and adds no data
member. It hides the `CString` accessors so that the character type
carries the encoding. `data()` still exists, but for a `UTF8CString` it
returns `const char8_t*`. `span()` and `spanIncludingNullTerminator()`
return `std::span<const char8_t>`, and `mutableSpan()` returns
`std::span<char8_t>`. `legacyCStringPointer()` returns the same address
as `const char*`. It is the accessor for `%s` arguments and C functions,
and `Latin1CString` does not have it. `length()`, `isNull()`,
`isEmpty()`, `hash()` and `toStdString()` come from `CString` and do not
change. A call such as `s.utf8().data()` that feeds a `const char*`
parameter must become `s.utf8().legacyCStringPointer()`. The same
applies to `s.utf8().span().data()`. For a `std::span<const char>`,
write `byteCast<char>(utf8.span())`. A `const void*` parameter
(`fwrite`, `write`) still accepts `data()`. The `SAFE_PRINTF` and
`SAFE_FPRINTF` macros accept the `UTF8CString` itself. `PrintStream` has
no overload for `const char8_t*`, so `dataLog()` must get the
`UTF8CString` itself or the `String`. A `UTF8CString` converts
implicitly to `CString` (derived to base). So `CString c = s.utf8()`
still compiles and `c.data()` is `const char*`, but the encoding is
lost. `String` gains an implicit constructor from `const
CStringWithEncoding<CharacterType>&` that decodes by character type.
`CStringWithEncoding` gains explicit constructors from `const
std::string&` and from a null-terminated `const CharacterType*`.
`wtf/text/StringCommon.h` gains `unsafeSpan(const char8_t*)`.
https://bugs.webkit.org/show_bug.cgi?id=323846
- `9b09294076` Upstream removes about 850 `legacyCStringPointer()` call
sites where the destination already accepts a `String`. `LOG` with `%s`
becomes `LOG_WITH_STREAM`, `EXPECT_STREQ` becomes `EXPECT_EQ` in tests,
and `dataLog()` gets the `String`. Almost all edits are in WebCore,
WebKit and TestWebKitAPI. In JSC and WTF the commit edits two lines.
`Options::dumpAllOptions()` and the truncation path of
`printInternal(PrintStream&, const CString&)` now print a `String`
directly. No WTF or JSC function changes a parameter type or a return
type. No caller edit is needed.
https://bugs.webkit.org/show_bug.cgi?id=323859
- `7189f73167` `StringPrintStream::toCString()` is renamed to
`toUTF8CString()` and returns `UTF8CString`. The function template
`WTF::toCString(...)` is renamed to `WTF::toUTF8CString(...)` in the
same way. The old names have no alias. `printInternal(PrintStream&,
const CString&)` is now `= delete`, and the non-const `CString&`
overload is removed. So `out.print(cstring)`, `dataLog(cstring)` and
`dataLogLn(cstring)` do not compile for an untyped `CString`. New
overloads print `const UTF8CString&`, `const ASCIICString&` and `const
Latin1CString&`. UTF-8 and ASCII bytes go through unchanged, and Latin-1
is transcoded to UTF-8. To replace `out.print(someCString)`, keep the
typed value (`auto s = string.utf8()`, `toUTF8CString(...)`,
`string.ascii()`) and print that. Or print the `String` or `StringView`
itself, or pass `cstring.data()` as `const char*`. These bytecode
helpers now return `UTF8CString`: `CodeBlock::inferredName()`,
`CodeBlock::sourceCodeForTools()`, `CodeBlock::sourceCodeOnOneLine()`,
`InlineCallFrame::inferredName()`, `UnlinkedSourceCode::toUTF8()`,
`reduceWhitespace()`, `ArrayProfile::briefDescription()`,
`ValueProfile::briefDescription()`, `BytecodeDumper::registerName()` and
`constantName()`. These JIT and runtime helpers do the same:
`MacroAssemblerCodeRef::disassembly()`, `Compilation::disassembly()`,
`ExceptionScope::unexpectedExceptionMessage()`, `Air::Special::name()`,
`JITPlan::signpostMessage()`, `Wasm::Plan::signpostMessage()`,
`DFG::nodeListDump()`, `nodeMapDump()` and `nodeValuePairListDump()`. In
WTF, `sortedListDump()`, `sortedMapDump()`, `BackwardsGraph::dump()`,
`SingleRootGraph::dump()` and `StringHashDumpContext::brief()` return
`UTF8CString`. `Identifier::ascii()` and
`StringHashDumpContext::getID()` return `ASCIICString`, and
`Structure::dumpBrief()` takes `const ASCIICString&`. `PerfLog::log()`,
`GdbJIT::log()`, `Profiler::Database::logEvent()` and
`Profiler::Compilation::addDescription()` take `const UTF8CString&`, and
`DFG::validate()` takes a `UTF8CString`. As a side effect
`CodeBlock::inferredNameWithHash()`,
`SamplingProfiler::reportTopBytecodes()` and
`DebuggerCallFrame::functionName()` no longer decode UTF-8 function
names as Latin-1. https://bugs.webkit.org/show_bug.cgi?id=323960
- `25f7ce345a` `FileSystem::fileSystemRepresentation(const String&)`
returns `UTF8CString`. It returned `CString` before. A caller that
passed `.data()` to `open()`, `stat()` or a similar C function must call
`.legacyCStringPointer()`. On Windows the function now converts with
`CP_UTF8`. It converted with `CP_ACP` (the active ANSI code page)
before. The GLib functions `currentExecutablePath()`,
`currentExecutableName()` and `webkitTopLevelDirectory()` also return
`UTF8CString`, and Cocoa gains `currentExecutableName()`.
`createTemporaryFileInDirectory()` (Cocoa only) returns
`std::pair<FileHandle, String>`. `wtf/StdLibExtras.h` gains
`safeNSStringPrintfType()` and the `SAFE_WTFLOGALWAYS` macro.
`CStringWithEncoding` gains `createNSString()` for Objective-C++ code.
The JSC callers (`dumpJITMemory()`, `API/JSScript.mm`) move to
`legacyCStringPointer()`. https://bugs.webkit.org/show_bug.cgi?id=324034
- `8ae0649a80` `WeakGCMap<Key, Value>` now stores a raw `Value*` per
entry. It stored a `Weak<Value>` before, which is a pointer to a
separate `WeakImpl` that the heap reaps in each collection. `ValueType`
is `ValueArg*`. So `set(key, value)` takes a raw pointer, and the
`ensureValue()` functor returns a raw pointer. `find()->value` is a raw
pointer with no `.get()`. `isEmpty()` is removed. `pruneStaleEntries()`
is replaced by `reconcileWeakReferencesAtGCEnd(VM&, CollectionScope)`.
`WeakGCMap.h` no longer includes `Weak.h`, and `WeakGCMapInlines.h` no
longer includes `WeakInlines.h`. A caller that wrote `map.set(key,
Weak<T>(cell))` must write `map.set(key, cell)`. A file that got
`JSC::Weak` through `WeakGCMap.h` must include `<JavaScriptCore/Weak.h>`
itself. Old design: `WeakBlock::reap` cleared each `Weak<>` in every
collection, and `pruneStaleEntries()` removed the cleared entries in
full collections only. New design: `Heap::runEndPhase()` calls
`Heap::reconcileWeakGCHashTables()`, and each table tests its values
with `Heap::isMarked()`. A full collection visits every registered table
and removes each entry whose value is null or not marked. An eden
collection visits only the tables on the new list
`Heap::m_dirtyWeakGCHashTables`. `set()` and `ensureValue()` put the map
on that list through `WeakGCHashTable::markDirty(VM&)`. In an eden
collection the map only sets a dead value to null and does not rehash.
`get()`, `find()`, `contains()` and `ensureValue()` treat the null entry
as absent, and the next full collection removes it. A table that gained
no entry since the last collection is skipped. All its values are old,
and an eden collection cannot free them. `WeakGCHashTable`
(`runtime/WeakGCHashTable.h`) now derives from
`BasicRawSentinelNode<WeakGCHashTable>`. A subclass must override
`reconcileWeakReferencesAtGCEnd(VM&, CollectionScope)` in place of
`pruneStaleEntries()`. It must call `markDirty(vm)` when it adds an
entry, if eden collections must visit it.
`Heap::unregisterWeakGCHashTable()` also takes the table off the dirty
list. `WeakGCSet` keeps `Weak<>` entries and removes them in full
collections only, as before.
https://bugs.webkit.org/show_bug.cgi?id=323958
- `b8d7e24add` The MarkedBlock warm-up (prefault) supply moves from JSC
into libpas. The old code was `WarmUpBlockProvider` in
`heap/FastMallocAlignedMemoryAllocator.cpp`. It ran a `JSCWarmUp`
`AutomaticThread` that allocated blocks with
`tryFastCompactAlignedMalloc()` and wrote one byte per page. It worked
with every `fastMalloc` backend. The new code is
`bmalloc_prefault_supply.c` and `bmalloc_prefault_supply.h` in libpas,
and JSC calls it only under `#if USE(LIBPAS)`. So upstream, a build
whose `fastMalloc` is mimalloc or the system allocator gets no
prefaulted blocks. In that build `tryAllocateAlignedMemory()` calls
`tryFastCompactAlignedMalloc()` directly. With libpas,
`tryAllocateAlignedMemory()` returns
`bmalloc_prefault_supply_try_allocate()` for block-sized requests. The
supply is a fixed array of at most 64 slots
(`BMALLOC_PREFAULT_SUPPLY_MAX_BLOCKS`). Takers and the filler exchange
slots with atomic operations and no lock. A mutex and a condition
variable only wake or start the filler. The filler is a detached
pthread. It allocates with
`bmalloc_try_allocate_with_alignment_inline()` and touches pages with
the new `pas_page_malloc_populate()`. After one idle interval with no
demand it frees all blocks and exits, and a later take starts a new
thread. The options `useWarmUpMarkedBlocks` (true),
`warmUpMarkedBlockCount` (32) and `warmUpMarkedBlockIdleTimeout` (10
seconds) keep their names and defaults. JSC copies them once into
`bmalloc_prefault_supply_target` and
`bmalloc_prefault_supply_idle_timeout_in_milliseconds`.
`$vm.warmUpMarkedBlockState()` is removed.
`$vm.warmUpMarkedBlocksAreEnabled()` and `$vm.warmUpMarkedBlockCount()`
replace it, and `$vm.setWarmUpMarkedBlockAllocationShouldFail()` stays.
In C++, `warmUpMarkedBlockStateForTesting()`, `WarmUpMarkedBlockPhase`
and `WarmUpMarkedBlockState` are removed.
`warmUpMarkedBlocksAreEnabledForTesting()` and
`warmUpMarkedBlockCountForTesting()` are added, and without libpas they
return `false` and 0. `pas_thread.h` (the Windows pthread shim) gains
include guards, `PTHREAD_MUTEX_INITIALIZER`, `PTHREAD_COND_INITIALIZER`,
`extern "C"` and `PAS_API` exports. The new source file is listed in
`Source/bmalloc/CMakeLists.txt` and
`Source/bmalloc/libpas/CMakeLists.txt`.
https://bugs.webkit.org/show_bug.cgi?id=323480
- `2aedf51ba6` `WTF::UUID::emptyValue` and `UUID::deletedValue` become
private. The constructor `UUID(HashTableEmptyValueType)` becomes private
too. Only `HashTraits<UUID>` and `MarkableTraits<UUID>` (now friends)
can build the empty value. `UUID(HashTableDeletedValueType)` stays
public. `UUID(UInt128)` now release-asserts that the value is not 0
(empty) and not 1 (deleted), so `UUID { 0 }` crashes. `UUID(uint64_t
high, uint64_t low)` now rejects the empty value as well as the deleted
value. Code that needs "no UUID" must use `Markable<WTF::UUID>` or
`std::optional<WTF::UUID>`. `createVersion4()`, `createVersion4Weak()`,
`createVersion5()`, `parse()`, `parseVersion4()` and `toString()` do not
change. https://bugs.webkit.org/show_bug.cgi?id=323944
- `a371ed3141` A caller can no longer construct a `WTF::UUID` from raw
bits. `UUID(std::span<const uint8_t, 16>)` and `UUID(UInt128)` become
private. `UUID(std::span<const uint8_t>)` and `UUID(uint64_t, uint64_t)`
are removed. New factories replace them. `static std::optional<UUID>
tryCreate(std::span<const uint8_t>)` returns `std::nullopt` if the size
is not 16 or the value is reserved (0 or 1). `static std::optional<UUID>
tryCreate(uint64_t high, uint64_t low)` does the same for two halves.
`static consteval UUID createConstant(uint64_t high, uint64_t low)` is
for hardcoded constants, and a reserved value is a compile error. The
static `UUID::isValid(uint64_t, uint64_t)` is removed, and the member
`isValid()` stays. The only raw constructor call in JSC
(`jscJITNamespace` in `jit/ExecutableAllocator.cpp`, under
`HAVE(KDEBUG_H)`) moves to `createConstant()`. The random, parse and
string functions do not change. A caller that only uses
`createVersion4()`, `createVersion4UUIDString()`, `parse()` or
`toString()` needs no edit.
https://bugs.webkit.org/show_bug.cgi?id=324032
- `2d4a4717af` `wtf/UUID.h` gains the struct `UUIDCanonicalForm` (two
`uint64_t` fields, `high` and `low`) and
`StringTypeAdapter<UUIDCanonicalForm>`. The adapter holds the 8-4-4-4-12
lowercase hex layout. `StringTypeAdapter<UUID>` now derives from it and
passes `uuid.high()` and `uuid.low()`. The output of `makeString(uuid)`
does not change. The only new user is the FIDO AAGUID logging in WebKit.
No caller edit is needed. https://bugs.webkit.org/show_bug.cgi?id=324075
- `6103d1b95a` `makeStringByJoining(std::span<const String>, …
@robobun

robobun commented Oct 23, 2026

Copy link
Copy Markdown
Collaborator Author

The wrapper gate of this PR is now #46578, a change of its own: the per-file test in generateCodeForFileInChunkJS.rs and InsideWrapperPrefix::append_directive. The earlier comments here and in #40831 say that this fix lives in this PR. That is no longer the plan.

After #46578 lands, a rebase of this PR drops its gate hunk and its own append_directive, and keeps the loop over ast.directives. Keep the !ast.wrapper_ref.is_empty() check from #46578. This branch has no such check, so a "use strict" ES module with no wrapper symbol gets a closure that has no name.

@robobun

robobun commented Oct 24, 2026

Copy link
Copy Markdown
Collaborator Author

A note from #46735, which writes to the same place.

At 6e122ab this PR adds a loop in the InternalBakeDev branch of generateCodeForFileInChunkJS.rs that prints each of the file's own directives first in the dev-server closure. #46735 adds "use strict" at that place for client files with ES module semantics, and it leaves CommonJS closures without it on purpose.

The reason is in the HMR runtime. It runs a CommonJS module again on the exports object of its last run (hmr-module.ts, loadOrEsmModule(mod, cjs, cjs.exports)). The tsc output for export { helper } from "./helper" starts with "use strict", does exports.helper = void 0, then defines helper as a getter. With the file's own directive in the closure, the second run throws TypeError: Cannot set property helper of #<Object> which has only a getter, and the page reloads. On main that save updates in place. The test a save of tsc CommonJS output with a named re-export updates in place in #46735 fails in that case.

So the dev-server closure of a CommonJS file needs to skip "use strict" until the loader gives each run a new exports object (#31944 is about that). If both PRs land, the two pushes also need one block: an ES module with its own "use strict" would get the directive two times.

@robobun

robobun commented Nov 16, 2026

Copy link
Copy Markdown
Collaborator Author

Closing: #48884 landed this work on main (85351f6). It took the change from #46730, which carried the same design forward.

I ran the tests of this PR against a debug build of main (ed13248), and the six original reports against canary 1.4.5-canary.1+ed132482b.

On main now

  • A "use strict" in a function body is kept: at runtime, in bun build, with --no-bundle, in Bun.Transpiler, and with --minify.
  • The directives of a file print first: ahead of injected imports, at the top of the entry chunk, and inside the wrapper of a wrapped file ahead of its init_*() calls.
  • Only a module, function, or TypeScript namespace body has a prologue. ("use strict") and "use\x20strict" are not directives.
  • function f(a = 1) { "use strict" } is an error, and a directive applies to the parameters.
  • From this PR's tests: run-eval, repl, react-compiler and preserve-use-strict-cjs all pass. 23 of the 31 bundler_directive cases and 7 of the 9 run-cjs cases pass.

Different on main, by decision in #46730

  • A repeated directive prints as often as it is written. This PR removed the repeats (1 bundler_directive case and 1 transpiler.test.js case).

Not on main. Each has an open PR.

The remaining failures of this PR's tests on main are these three items, plus one source map string that was pinned in August (main has the same case with the current string) and one error message that differs (Invalid assignment target for a sloppy arguments = 2 in ESM output).

@robobun robobun closed this Nov 16, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

Projects

None yet

Development

Successfully merging this pull request may close these issues.

bun build doesn't hoist "use strict", "use client", "use server", etc. directives

2 participants