HN 日本語サマリー

← 一覧へ戻る
プログラミング

Fixing a WebKit bug to see if promises are made of train tracks

Fixing a WebKit bug to see if promises are made of train tracks (alistair.sh)

24 pointsby dverlaeckt801 コメント

要約

この記事では、JavaScriptのPromiseの内部動作に関するWebKitのバグ修正について解説しています。特に、`Promise.resolve()`や`await`がカスタムコンストラクタを持つPromiseにどのように反応するか、そしてその挙動がJavaScriptコアエンジンの実装によってどのように異なるかを探求しています。

全文翻訳

WebKitのバグを修正して、Promiseがトレイン・トラックでできているか確認する

これは、7月までBunやSafariで完了しなかったプログラムです。

never.mjs

const p = Promise.resolve(1);
p.constructor = {
	get [Symbol.species]() {
		throw new Error("boom");
	},
};

console.log("before");
await p;
console.log("done");

これが混乱して見えるとしても心配しないでください。JavaScript仕様によれば、ゲッターがエラーをスローするため、await pも同様にスローし、プログラムはクラッシュするはずです。Node.jsはクラッシュしますが、Safari 26とBun 1.3.14は 'before' とログ出力し、エラーを報告した後、ハングします。

Safari 26はBunと同じように失敗します。

BunとSafariはどちらもJavaScriptCoreを組み込んでいるため、動作は同じです。Promiseは決して解決(settle)されません。満たされたり拒否されたりすることなく、永遠に保留(pending)状態のままです。これはWebKitバグ 318399でした。私はこれをWebKit/WebKit#68749で修正しました。修正はわずか16行でした!

何がうまくいかなかったのでしょうか?

resolveは何をするのか

Promiseについて簡単に復習しましょう。

JavaScriptで新しいPromiseを構築するとき、エンジンは resolve と reject の2つの関数を作成し、Promiseコンストラクタに渡すコールバックに渡します。

new Promise((resolve, reject) => {
	console.log("I got my resolve function!", resolve);
	console.log("I got my reject function!", reject);
	resolve(42);
});

// V8では以下のようにログ出力されます:
//	I got my resolve function! ƒ () { [native code] }
//	I got my reject function! ƒ () { [native code] }

組み込みヘルパー関数 Promise.resolve(value) は、Promiseを構築し、渡された値で resolve を即座に呼び出すことで同様のことを行います(ただし、value がPromiseであり、.constructor プロパティが Promise と等しい場合は、そのまま返されます)。単純なユーザーランド実装は以下のようになります。

function PromiseDotResolve(value) {
	if (value instanceof Promise && value.constructor === Promise) {
		return value;
	}

	return new Promise(resolve => resolve(value));
}

await 42 と書く場合も同様です。エンジンはPromiseを作成し、Promise.resolve() と同様に resolve(42) を即座に呼び出します。同じ例外が適用されます。

多くの人は、Promiseを2つの方法で終了できる値(値で満たされるか、理由で拒否されるか)と考えています。これは、Promiseの使用感がJavaScriptを日常的に書く際の感覚とほぼ一致するため、合理的な近似です。したがって、Promiseの単純な実装は以下のようになります。

type PromiseState<T> =
	| {type: 'pending'}
	| {type: 'resolved', value: T}
	| {type: 'rejected', value: unknown};

class MediocrePromise<T> {
	private state: PromiseState<T> = {type: 'pending'};
	private callbacks: Array<() => void> = []; // .then() によって登録される

	private resolve(value: T) {
		this.settle({type: 'resolved', value});
	}

	private reject(reason: unknown) {
		this.settle({type: 'rejected', value: reason});
	}

	private settle(state: PromiseState<T>) {
		this.state = state;
		for (const callback of this.callbacks) callback();
	}

	// 例示のため、constructor, then などは省略されています
}

これを MediocrePromise と名付けました。保留状態、値で解決する機能、理由で拒否する機能があります。実際のPromiseのように、実行するコールバックのリストさえあります!これは良い実装でしょうか?

残念ながら、いいえ。これは良い実装ではありません。MediocrePromise は、解決と拒否の動作方法の重要な違いを見落としています。

拒否から始めましょう。Promiseを拒否するのは簡単です!reject(reason) を呼び出すと、Promiseは reason を拒否値としてマークします。素晴らしい!MediocrePromise は拒否を正しく実装しています!

解決はより複雑です。resolve(value) を呼び出しても、value はすぐに格納されません。まず、value が .then() メソッドを持っているか確認します。持っていない場合(例: 数値、文字列、メソッドのないオブジェクトなど)、Promiseは value で満たされ、処理は完了です。持っている場合、value は別のPromiseとして扱われます。元のPromiseはまだ解決されておらず、代わりに resolve は自身と reject 関数を value.then(resolve, reject) に渡します。これらの関数のどちらかが最終的に呼び出されたものが、Promiseを解決します。すみません、長くなりました。後で図で説明します。もう少しお付き合いください。

resolve 関数は仕様で resolve手続きとして定義されています。value が .then を持っているかを見つけるために、value.then を読み取ります。プロパティの読み取りはゲッターを実行する可能性があり、ゲッターはスローする可能性があります(冒頭のプログラムのように)。したがって、.then() メソッドを持つプロパティを検索すると、3つの可能な結果が得られます。

resolve(value)
  read value.then
    missing, or not a function -> fulfil with value
    getter throws            -> reject with the error
    a function               -> follow value
                                 value.then(resolve, reject)

私の MediocrePromise は、この追加のチェックと追加の動作を欠いています!

この非対称性が存在する理由は、失敗は保留中の操作ではないからです。何かが失敗した場合、コードにはすでに理由(おそらくエラー)があります!そのため、すぐに reject(reason) を呼び出すことができます。これは、解決のハッピーパスとは異なります。有用な値が後で到着する可能性があります。

reject(new Error("bad request")); // 理由はここにあります
resolve(response.json());         // ボディはまだ到着していません

これが、追加の動作が resolve でのみ実装されている理由です。

value.then が関数であるパスでは、仕様は value をthenableと見なします。Promiseは .then() メソッドを持っているため、thenableです。.then() メソッドを持つ他のオブジェクトもthenableです。ThenableはPromiseが機能する場所ならどこでも機能します。

簡単に言うと、thenableは .then() メソッドを持つ任意の値です。したがって、任意のPromiseもthenableです。

例:

// `thenable` はPromiseではありません!
const thenable = {
	// resolve(thenable) は、外部Promiseのresolveとrejectを渡してこれを呼び出します
	then(resolve, _reject) {
		resolve(42);
	},
};

// thenableでresolve()が呼び出された
await new Promise(resolve => resolve(thenable)); // 42

// `.then` コールバックがthenableを返す
await Promise.resolve().then(() => thenable); // 42

// thenableを直接awaitする
await thenable; // 42

仕様では、上記のresolve/reject関数をthenableの.then()に渡すプロセスをassimilation(同化)と呼んでいます。しかし、おそらくより親しみやすい言葉はflattening(平坦化)でしょう。外部のthenableを値として保持するのではなく、外部Promiseはそれを待ちます。これにより、2つのレイヤーが1つになります。

最後に、「resolved」は実際のPromiseの状態ではないことに注意してください。MediocrePromise もこれを間違っていました!resolve が呼び出されると、Promiseは結果にロックインされますが、保留状態のままであることは絶対に可能です。

const inner = new Promise(() => {}); // 決して解決しない
const outer = new Promise(resolve => resolve(inner));

ここで、outer は解決されましたが、inner が決して解決しないため、永遠に保留状態のままです。MediocrePromise の resolved 状態は、実際には仕様で定義されている「fulfilled」の状態でした。

レールウェイ

少し脱線しましょう。

Scott Wlaschin の記事 Railway Oriented Programming は、失敗する可能性のあるコードを、1つの入力と2つの出力(成功トラックと失敗トラック)を持つ線路の断片として描いています。

validate()
request
  -> success
  -> failure

リクエストが失敗トラックにヒットすると、そこにとどまり、後続のすべてのステップをスキップして、最終的に結果を処理するまで続きます。Wlaschin は、2つの線路の断片を結合することを「binding」と呼んでいます(JavaScriptの fn.bind() とは混同しないでください)。Rustのユーザーは、bindingを and_then、あるいは ? 演算子として知っているかもしれません。これらはすべて同じ意味です。前の部分が成功した場合にのみ次のコードを実行し、それ以外の場合は失敗をそのまま通過させます。

update() が失敗したため、最後のステップがスキップされる様子を見てみましょう。

validate()
update()
send()
request
  -> success
  -> failure

線路の各断片は、Result を返す関数と考えることができます。静的型付けされたプログラミング言語では、Result 型の実装は通常、2つの型パラメータ(成功型と失敗型)を受け入れ、各トラックに1つずつ対応します。例えばRustでは、validate 関数のシグネチャを以下のように想像できます。

fn validate(request: Request) -> Result<Request, ValidationError>

validate() を他のステップと and_then を使って連鎖させるには、すべての部分が同じ型で失敗する必要があります。そこで、ValidationError の代わりに、各関数が AppError を返すようにしましょう。これは、リクエストが失敗する可能性のあるすべての方法を表すenumです。

enum AppError {
	Validation(ValidationError),
	Database(DatabaseError),
	Network(NetworkError),
}

fn validate(request: Request) -> Result<Request, AppError> { /* ... */ }
fn update(request: Request) -> Result<Record, AppError> { /* ... */ }
fn send(record: Record) -> Result<Receipt, AppError> { /* ... */ }

validate(request).and_then(update).and_then(send) // Result<Receipt, AppError>

JavaScriptのPromiseは、これにかなり似ています!満たされたトラックと拒否されたトラックがあり、.then(onFulfilled, onRejected) はそれらの間のスイッチです。

.then(validate)
.then(update)
.then(send)

Promise
  -> fulfilled
  -> rejected

ジョブ

念のため、もう一度resolve手続きの図を見てみましょう。

resolve(value)
  read value.then
    missing, or not a function -> fulfil with value
    getter throws            -> reject with the error
    a function               -> follow value
                                 value.then(resolve, reject)

右側のパス、つまり value.then が関数の場合、エンジンは .then() を即座に呼び出しません。代わりに、エンジンはマイクロタスクと呼ばれるジョブをキューに入れます。仕様では、この特定のジョブを NewPromiseResolveThenableJob と呼び、次のように定義されています。

a. Let resolvingFunctions be CreateResolvingFunctions(promiseToResolve).

b. Let thenCallResult be Completion(HostCallJobCallback(then, thenable, « resolvingFunctions.[[Resolve]], resolvingFunctions.[[Reject]] »)).

c. If thenCallResult is an abrupt completion, return ? Call(resolvingFunctions.[[Reject]], undefined, « thenCallResult.[[Value]] »).

これもまた長文です。翻訳します。

  1. 新しいresolve/reject関数のペアを作成する
  2. thenableの .then(resolve, reject) 関数を(新しく作成したresolve/reject関数とともに)呼び出す
  3. .then() の呼び出しがスローした場合、スローされたものでPromiseを拒否する

.then はthenableに定義されているものにすぎないことを思い出してください。thenableが実際のPromiseの場合、呼び出されるメソッドはプロトタイプの Promise.prototype.then です。

ここで、プログラムの重要な行をもう一度見てみましょう。

p.constructor = {
	get [Symbol.species]() {
		throw new Error("boom");
	},
};

ここで p を変更しただけなので、グローバルな Promise は変更されていません。

以前の例外を思い出してください。実際のPromise(デフォルトではすべてのPromiseで真)の constructor が Promise であるPromiseを await すると、エンジンはショートカットをしてそのPromiseを直接待機します。ここで p.constructor を置き換えたということは、ショートカットを使用できないことを意味します。代わりに、エンジンは await p の p を他の値と同様に扱います。つまり、新しいPromiseを作成し、それに resolve(p) を呼び出します。

p には .then() があるため、thenableであり、resolve(p) は p.then(resolve, reject) を呼び出します。プログラムがクラッシュしたことを見ると、Promise.prototype.then は何らかの方法で p.constructor[Symbol.species] にアクセスしているはずですよね?しかし、なぜ .then() が Symbol.species ゲッターを気にするのでしょうか?

気にする理由は、.then() が新しいPromiseを返すからです。これが .then().then() の連鎖を可能にします。もし Promise をサブクラス化した場合、.then() はプレーンな Promise ではなく、サブクラスのインスタンスを返すことが期待されます。

class MyPromise extends Promise {}
MyPromise.resolve(1).then(x => x) instanceof MyPromise; // true

そのため、実際のPromiseの then メソッドは、引数を処理する前に、どのコンストラクタを使って新しいPromiseを構築するかを決定します。これは、まず this.constructor を読み取り、次に constructor[Symbol.species] を読み取ることで行われます(仕様ではこのステップをSpeciesConstructorと呼んでいます)。どちらも通常のプロパティ読み取りであり、発見したように、プロパティ読み取りはゲッターを実行する可能性があり、ゲッターはスローする可能性があります!

これはまさに、冒頭のプログラムが行っていることです!p.constructor にスローする Symbol.species ゲッターを設定したため、p.then(resolve, reject) は、resolve と reject をコールバックとして格納する前に、speciesルックアップ中にスローします。NewPromiseResolveThenableJob のステップCを思い出してください。これは、.then() の呼び出しがスローした場合に、エンジンがPromiseを拒否するようにします。これはV8/Node.jsで見られた仕様に準拠した動作です。

では、なぜSafariとBunはPromiseを拒否する代わりにハングするのでしょうか?

JavaScriptCoreには、thenableが実際の通常のPromiseである最も一般的なケースのための高速パスがありました。その高速パスは、まずspeciesルックアップを実行し、その後でresolve/reject関数を作成しました。ルックアップがスローした場合(プログラムのように)、resolve関数はまだ存在しなかったため、拒否するものがありませんでした。例外はジョブ全体からエスケープしました(インスペクタの赤い Error: boom がそれです)。そして、私たちのPromiseは永遠に保留状態のままでした。

これを鉄道で表すと次のようになります。

spec
  create resolve/reject
  call x.then
    -> fulfilled
    -> throws -> rejected

JSC, before
  look up species
  create resolve/reject
    -> fulfilled
    -> throws, uncaught -> rejected
    -> neither. pending forever.

私たちの列車は効果的に脱線しました!どちらのトラックでも旅を終える機会さえ得られなかったため、列車が駅に到着する前にハングアップしたのです。

幸いなことに、修正は簡単で、おそらくすでに明らかでしょう!.then() を呼び出す前にresolve/reject関数を作成する必要があります。これにより、.then() の呼び出しがスローした場合に実際にPromiseを拒否する能力が得られます。resolve関数を作成することは単なる割り当てであり、割り当てはスローできません。関数が存在すれば、既存のエラーハンドリングは他のどの失敗と同様にPromiseを拒否します。

2つのステップを正しい順序にすることで、Bun 1.4とSafari 27は、Nodeと同様に仕様どおりに動作するようになりました。

バグ修正完了!しかし、それは私に一つの疑問を残しました。以前、Promiseを鉄道として描きましたが、満たされたトラックと拒否されたトラックがありました。しかし、エンジンが拒否トラックにエラーを置いたのを見たのに、私たちのコードのどの行も reject() を呼び出したわけではありません。それは、そのトラックに何があるのか、決して知ることができないということでしょうか?

それでは、Promiseは鉄道なのでしょうか?

TypeScriptでは、Promise<T> インターフェースは単一の型パラメータしか持たず、開発者がPromiseがどのように拒否されるかを表現する方法を提供しません。

declare const p: Promise<number>;

TypeScriptユーザーは2015年から Promise<T, E> の存在を求めています。このIssueを参照してください: microsoft/TypeScript#6283!かつてTypeScriptでMicrosoftに勤務していたRon Bucktonは、このIssueをクローズし、次のように述べています。

we cannot guarantee the correct type of the exception at design time.

これは、今学んだように真実です!以前、ランタイムが boom でPromiseを拒否するのを見ました。p.then() は Symbol.species ゲッターを読み取り、それがエラーをスローしました。そして、ジョブのステップCは、ユーザーランドの reject() 呼び出しから非常に離れた場所で、そのエラーでPromiseを拒否しました。仕様自体が拒否トラックに値を置くことができる場合、たとえ reject() を1つの型でしか呼び出さないコードであっても、E を与えることはできません。失敗トラックは any でなければなりません(はい、技術的には unknown も可能ですが、TypeScriptのようなプロジェクトの範囲と規模にとって、採用と後方互換性も重要なことです)。

これを鉄道として表現すると、次のようになります。

read value.then
call value.then
resolve(value)
  -> T
  -> any

見てください、この失敗トラックを制御する術がありません!これは、Promiseを鉄道として描くことはできますが、Rustのような実際のResult型ほど有用ではないことを意味します。

何を学んだか?

まとめましょう!

  • resolve(value) はPromiseを即座に満たすわけではありません。まず value.then を読み取り、それが関数であればPromiseは value に従います。
  • 「Resolved」は状態ではありません。なぜなら、解決されたPromiseはまだ保留状態である可能性があるからです。
  • value.then の読み取り、および Promise.prototype.then 内の constructor[Symbol.species] の読み取りは、通常のプロパティ読み取りです。ゲッターはスローする可能性があり、仕様はスローされたものを拒否トラックに置きます。
  • JavaScriptCoreは、resolve関数を作成する前にspecies読み取りを実行したため、スローしたときに拒否するものがありませんでした。修正(WebKit/WebKit#68749)は、まず関数を作成し、ゲッターがスローしたときにそれらを呼び出すことでした。
  • Promiseは鉄道の形状をしていますが、その失敗トラックはエンジンがあなたと共有するため、ラベル付けできません。だからこそ、TypeScriptの Promise<T> には E がないのです。

最後まで読んだなら、Promiseに私が興奮しているのと同じくらい興奮していることを嬉しく思います。読んでくれて本当にありがとう!

この投稿のドラフトをレビューしてくれたLandon Boles、Jacob Thornton、Amadeus Demarzi、Conrad Crawfordに感謝します。